1 files changed, 83 insertions, 0 deletions

diff --git a/rsnix/src/gop.rs b/rsnix/src/gop.rs
index 012a9d0..ecf8fa9 100644
--- a/rsnix/src/gop.rs
+++ b/rsnix/src/gop.rs
@@ -516,6 +516,89 @@ pub fn dump_lines(lines: &[&str]) {
             }
         }
     }
+    // Scannable QR of the same text below the band (heap-free encoder;
+    // real hardware has no serial console — photograph the screen).
+    dump_qr(lines);
+}
+
+/// Render the crash/fault lines as a QR code below the dump band.
+///
+/// The joined text is built in a `.bss` buffer (the fault path must not
+/// allocate) and encoded byte-mode EC-L by `crate::qr` (also heap-free,
+/// static matrix).  Over-long text is truncated with a "…" marker.  If
+/// the text does not fit a QR or there is no framebuffer, this is a no-op
+/// and the band text remains the only channel.
+static mut QR_TEXT: [u8; crate::qr::MAX_BYTES + 4] = [0; crate::qr::MAX_BYTES + 4];
+
+pub fn dump_qr(lines: &[&str]) {
+    let Some(fb) = fb().as_ref() else {
+        return;
+    };
+    unsafe {
+        let text = &mut *core::ptr::addr_of_mut!(QR_TEXT);
+        let mut n = 0usize;
+        for line in lines {
+            let b = line.as_bytes();
+            let take = b.len().min(text.len() - n);
+            text[n..n + take].copy_from_slice(&b[..take]);
+            n += take;
+            if n < text.len() {
+                text[n] = b'\n';
+                n += 1;
+            }
+        }
+        while n > 0 && text[n - 1] == b'\n' {
+            n -= 1;
+        }
+        if n == 0 {
+            return;
+        }
+        let cap = crate::qr::MAX_BYTES.saturating_sub(3);
+        if n > cap {
+            n = cap;
+            text[n..n + 3].copy_from_slice(b"...");
+            n += 3;
+        }
+        if crate::qr::encode(&text[..n]) == 0 {
+            return;
+        }
+    }
+    render_qr(fb, lines.len() * 16);
+}
+
+/// Draw the current QR matrix (black on white, quiet zone) centred below
+/// the band, scaled to the largest square that fits.
+fn render_qr(fb: &Framebuffer, band_px: usize) {
+    let size = crate::qr::size();
+    if size == 0 {
+        return;
+    }
+    let total = size + 8; // 4-module quiet zone each side
+    let avail_w = fb.width.saturating_sub(24);
+    let avail_h = fb.height.saturating_sub(band_px + 16);
+    let scale = (avail_w / total).min(avail_h / total);
+    if scale < 1 {
+        return;
+    }
+    let px = total * scale;
+    let x0 = (fb.width - px) / 2;
+    let y0 = band_px + 8 + (avail_h.saturating_sub(px) / 2);
+    let white = rgb(0xFF, 0xFF, 0xFF);
+    let black = rgb(0, 0, 0);
+    fill_rect(x0, y0, px, px, white);
+    for y in 0..size {
+        for x in 0..size {
+            if crate::qr::module(x, y) {
+                fill_rect(
+                    x0 + (x + 4) * scale,
+                    y0 + (y + 4) * scale,
+                    scale,
+                    scale,
+                    black,
+                );
+            }
+        }
+    }
 }
 
 /// Read one pixel back from the shadow (RAM; cheap).  Test/demo use only.