fix(demo): unify decode path + cache-bust wasm so the demo actually decodes

Two compounding bugs made every prior fix invisible in the live demo:

1. Duplicated decode logic. The WASM decode export and the CLI each carried a
   hand-copied list of decoders that drifted: the CLI gained the new width-ratio
   EAN edge reader while the WASM export still ran only the old quantized 1D path,
   so the demo could never decode the curved/blurred 1D captures the CLI now reads.
   Consolidated both into one library entry point, anyd::pipeline::scan_all(frame)
   (2D samplers + EAN/UPC edge reader + quantized linear decoders, deduped). CLI
   and WASM now call it, so a front-end can never again ship a stale decoder list.

2. No cache-busting on the wasm fetch. GitHub Pages + the browser cache .wasm
   aggressively (and a blob worker's fetch ignores hard refresh), so visitors kept
   running a stale build no matter what was deployed. The page now loads
   anyd.wasm?v=<load-time>, shared by the main thread and the decode worker.

Verified via scan_all on the exact crops the demo produces from real captures:
the curved bottle EAN-13 (4901085663356) and a hand-held omron QR both decode.
Adds testdata/real_scene_qr.png + real_scene_qr_via_scan_all pinning the shared
path. Full suite / clippy / fmt / doc clean.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

Author: MagicalTux

src/bin/anyd.rs

@@ -20,7 +20,7 @@ use anyd::output::Encoding;
 use anyd::render::render;
 use anyd::segment::Segment;
 use anyd::symbology::Symbology;
-use anyd::traits::{Decode, Encode};
+use anyd::traits::Encode;
 
 fn main() -> ExitCode {
     let args: Vec<String> = std::env::args().skip(1).collect();
@@ -416,54 +416,15 @@ fn cmd_decode(args: &[String]) -> Result<(), String> {
         .collect();
     let frame = GrayFrame::new(&luma, w, h).map_err(|e| e.to_string())?;
 
-    let mut found: Vec<(String, Symbol)> = Vec::new();
-    let mut seen = std::collections::HashSet::new();
-    let mut record = |sym: Symbol| {
-        let key = (sym.symbology, sym.text().unwrap_or_default());
-        if seen.insert(key) {
-            found.push((sym.symbology.to_string(), sym));
-        }
-    };
-
-    // 2D samplers.
-    if let Ok(s) = anyd::codes::qr::scan(&frame) {
-        record(s);
-    }
-    if let Ok(s) = anyd::codes::datamatrix::scan(&frame) {
-        record(s);
-    }
-    if let Some(s) = anyd::codes::pdf417::scan(&frame) {
-        record(s);
-    }
-
-    // 1D front-end: scan lines, then try the checksummed linear decoders.
-    let scan_opts = anyd::scan1d::ScanOptions::default();
-    // EAN/UPC: the width-ratio edge path reads curved, blurred camera captures that the
-    // quantized grid cannot, and votes across scanlines for a robust result.
-    if let Some(s) = anyd::codes::ean::scan(&frame, &scan_opts) {
-        record(s);
-    }
-    let candidates = anyd::scan1d::scan_lines(&frame, &scan_opts);
-    let linear: Vec<Box<dyn Decode>> = vec![
-        Box::new(anyd::codes::code128::Code128Decoder::new()),
-        Box::new(anyd::codes::ean::EanDecoder::new()),
-        Box::new(anyd::codes::code93::Code93Decoder::new()),
-        Box::new(anyd::codes::code39::Code39Decoder::new()),
-        Box::new(anyd::codes::itf::ItfDecoder::new()),
-        Box::new(anyd::codes::codabar::CodabarDecoder::new()),
-    ];
-    for cand in &candidates {
-        for dec in &linear {
-            if let Some(s) = anyd::scan1d::try_decode(cand, dec.as_ref()) {
-                record(s);
-            }
-        }
-    }
+    // One shared decode entry point (see `anyd::pipeline::scan_all`) drives every
+    // front-end, so the CLI and the WebAssembly demo can never disagree on what decodes.
+    let found = anyd::pipeline::scan_all(&frame);
 
     if found.is_empty() {
         return Err("no barcode found in image".into());
     }
-    for (name, sym) in &found {
+    for sym in &found {
+        let name = sym.symbology.to_string();
         match sym.text() {
             Some(t) => println!("{name}: {t}"),
             None => println!("{name}: <binary> {}", hex(&sym.payload_bytes())),

src/pipeline.rs

@@ -76,3 +76,67 @@ impl Hints {
         self.previous.iter().find(|k| k.fingerprint == Some(fp))
     }
 }
+
+/// Decode **every** symbology this library can read from a full (already-binarizable)
+/// luminance frame, returning one [`Symbol`] per distinct code found.
+///
+/// This is the single analysis entry point shared by every front-end — the `anyd` CLI,
+/// the WebAssembly `decode` export, and callers embedding the library — so they can never
+/// drift out of sync over which decoders run or in what order. It runs the 2D image
+/// samplers (QR, Data Matrix, PDF417) and the 1D pipeline (the width-ratio EAN/UPC edge
+/// reader that handles curved, blurred camera captures, plus the quantized `scan1d`
+/// front-end feeding the remaining checksummed linear decoders), de-duplicated by
+/// `(symbology, text)`. It never returns an error: a frame with no code yields an empty
+/// vec. Intended for a located crop or a whole still image; on a live stream, gate it
+/// behind [`crate::detect::locate`] and decode only the regions it returns.
+pub fn scan_all(frame: &crate::image::GrayFrame<'_>) -> Vec<Symbol> {
+    use crate::traits::Decode;
+
+    let mut found: Vec<Symbol> = Vec::new();
+    let mut push = |sym: Symbol| {
+        let key = (sym.symbology, sym.text().unwrap_or_default());
+        if !found
+            .iter()
+            .any(|s| (s.symbology, s.text().unwrap_or_default()) == key)
+        {
+            found.push(sym);
+        }
+    };
+
+    // 2D image samplers.
+    if let Ok(s) = crate::codes::qr::scan(frame) {
+        push(s);
+    }
+    if let Ok(s) = crate::codes::datamatrix::scan(frame) {
+        push(s);
+    }
+    if let Some(s) = crate::codes::pdf417::scan(frame) {
+        push(s);
+    }
+
+    // 1D front-end. The EAN/UPC edge reader (width ratios, voted across scanlines) reads
+    // curved/blurred captures the quantized grid cannot; the quantized `scan1d` path then
+    // feeds the remaining checksummed linear decoders.
+    let scan_opts = crate::scan1d::ScanOptions::default();
+    if let Some(s) = crate::codes::ean::scan(frame, &scan_opts) {
+        push(s);
+    }
+    let candidates = crate::scan1d::scan_lines(frame, &scan_opts);
+    let linear: [Box<dyn Decode>; 6] = [
+        Box::new(crate::codes::code128::Code128Decoder::new()),
+        Box::new(crate::codes::ean::EanDecoder::new()),
+        Box::new(crate::codes::code93::Code93Decoder::new()),
+        Box::new(crate::codes::code39::Code39Decoder::new()),
+        Box::new(crate::codes::itf::ItfDecoder::new()),
+        Box::new(crate::codes::codabar::CodabarDecoder::new()),
+    ];
+    for cand in &candidates {
+        for dec in &linear {
+            if let Some(s) = crate::scan1d::try_decode(cand, dec.as_ref()) {
+                push(s);
+            }
+        }
+    }
+
+    found
+}

src/wasm.rs

@@ -18,7 +18,7 @@
 use crate::GrayFrame;
 use crate::output::Encoding;
 use crate::segment::Segment;
-use crate::traits::{Decode, Encode};
+use crate::traits::Encode;
 
 /// Allocate `len` bytes in wasm memory and return the pointer (caller fills it).
 #[unsafe(no_mangle)]
@@ -100,50 +100,19 @@ pub unsafe extern "C" fn decode(w: usize, h: usize, luma_ptr: *const u8) -> u64
         Err(_) => return export(b"[]".to_vec()),
     };
 
-    let mut out: Vec<(String, String)> = Vec::new();
-    let mut push = |sym: crate::Symbol| {
-        let name = sym.symbology.to_string();
-        let text = sym.text().unwrap_or_default();
-        if !out.iter().any(|(n, t)| *n == name && *t == text) {
-            out.push((name, text));
-        }
-    };
-
-    if let Ok(s) = crate::codes::qr::scan(&frame) {
-        push(s);
-    }
-    if let Ok(s) = crate::codes::datamatrix::scan(&frame) {
-        push(s);
-    }
-    if let Some(s) = crate::codes::pdf417::scan(&frame) {
-        push(s);
-    }
-    let candidates = crate::scan1d::scan_lines(&frame, &crate::scan1d::ScanOptions::default());
-    let linear: [Box<dyn Decode>; 6] = [
-        Box::new(crate::codes::code128::Code128Decoder::new()),
-        Box::new(crate::codes::ean::EanDecoder::new()),
-        Box::new(crate::codes::code93::Code93Decoder::new()),
-        Box::new(crate::codes::code39::Code39Decoder::new()),
-        Box::new(crate::codes::itf::ItfDecoder::new()),
-        Box::new(crate::codes::codabar::CodabarDecoder::new()),
-    ];
-    for cand in &candidates {
-        for dec in &linear {
-            if let Some(s) = crate::scan1d::try_decode(cand, dec.as_ref()) {
-                push(s);
-            }
-        }
-    }
+    // Same shared decode entry point as the CLI (`crate::pipeline::scan_all`), so the
+    // demo and the command line always agree on what a frame decodes to.
+    let out = crate::pipeline::scan_all(&frame);
 
     let mut json = String::from("[");
-    for (i, (name, text)) in out.iter().enumerate() {
+    for (i, sym) in out.iter().enumerate() {
         if i > 0 {
             json.push(',');
         }
         json.push_str("{\"symbology\":");
-        json_str(&mut json, name);
+        json_str(&mut json, &sym.symbology.to_string());
         json.push_str(",\"text\":");
-        json_str(&mut json, text);
+        json_str(&mut json, &sym.text().unwrap_or_default());
         json.push('}');
     }
     json.push(']');

testdata/real_scene_qr.png

@@ -450,3 +450,37 @@ fn real_scene_text_is_not_a_barcode() {
         "consensus floor must reject stray checksum-passing misreads on plain text"
     );
 }
+
+/// The shared [`anyd::pipeline::scan_all`] entry point — the one both the CLI and the
+/// WebAssembly demo call — must read a real QR capture. `testdata/real_scene_qr.png` is
+/// the located crop of an omron package QR from a hand-held frame. This guards the
+/// consolidated decode path so a front-end can never again ship a decoder list that has
+/// drifted from what actually works (the demo previously ran a hand-copied list missing
+/// the current 1D reader).
+#[cfg(feature = "cli")]
+#[test]
+fn real_scene_qr_via_scan_all() {
+    use anyd::GrayFrame;
+
+    let bytes = std::fs::read("testdata/real_scene_qr.png").expect("read fixture");
+    let rgba = oxideav_png::decode_png_to_rgba(&bytes).expect("decode PNG");
+    let (w, h) = (rgba.width as usize, rgba.height as usize);
+    let luma: Vec<u8> = rgba
+        .data
+        .chunks_exact(4)
+        .map(|p| ((p[0] as u32 * 299 + p[1] as u32 * 587 + p[2] as u32 * 114) / 1000) as u8)
+        .collect();
+    let frame = GrayFrame::new(&luma, w, h).expect("valid frame");
+
+    let found = anyd::pipeline::scan_all(&frame);
+    let qr = found
+        .iter()
+        .find(|s| s.symbology == anyd::Symbology::QrCode)
+        .expect("scan_all must read the QR capture");
+    assert_eq!(
+        qr.text().as_deref(),
+        Some(
+            "https://www.omronconnect.com/devices/?utm_source=qrcode&utm_medium=package&utm_campaign=mc-6800b"
+        ),
+    );
+}

tests/real_world.rs

@@ -124,8 +124,14 @@ <h2>Decode an image</h2>
 let wasm;
 const mem = () => new Uint8Array(wasm.memory.buffer);
 
+// Load the wasm with a per-load cache-buster. GitHub Pages and the browser cache
+// `.wasm` aggressively (and a blob worker's fetch ignores a hard refresh), so without
+// this a freshly deployed build would keep running the visitor's stale copy. The main
+// thread and the decode worker share this exact URL so they instantiate the same build.
+const WASM_URL = new URL('anyd.wasm?v=' + Date.now(), location.href).href;
+
 async function init() {
-  const res = await fetch('anyd.wasm');
+  const res = await fetch(WASM_URL);
   const { instance } = await WebAssembly.instantiateStreaming(res, {});
   wasm = instance.exports;
 }
@@ -366,8 +372,8 @@ <h2>Decode an image</h2>
 
 // Decoding runs in a background worker (its own wasm instance) so the heavy sampler
 // can never block the UI thread — the live overlay stays smooth even when a scan is
-// slow. The main thread only sends a frame when the worker is free.
-const WASM_URL = new URL('anyd.wasm', location.href).href;
+// slow. The main thread only sends a frame when the worker is free. It reuses the
+// cache-busted WASM_URL defined above so the worker loads the same fresh build.
 const workerSrc = `
 let w; const mem = () => new Uint8Array(w.memory.buffer);
 const ready = fetch(${JSON.stringify(WASM_URL)}).then(r => WebAssembly.instantiateStreaming(r, {})).then(x => { w = x.instance.exports; });