@@ -437,7 +437,13 @@ fn cmd_decode(args: &[String]) -> Result<(), String> {
     }
 
     // 1D front-end: scan lines, then try the checksummed linear decoders.
-    let candidates = anyd::scan1d::scan_lines(&frame, &anyd::scan1d::ScanOptions::default());
+    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()),
 
@@ -0,0 +1,250 @@
+//! EAN/UPC decoding from per-scanline sub-pixel edge widths (the industry-standard
+//! way real scanners read the retail family off a camera frame).
+//!
+//! Where [`decode`](super::decode) consumes a clean, hard-quantized [`LinearPattern`]
+//! bool grid, this path consumes the raw run *widths* (in pixels) of one image scanline
+//! — as produced by [`crate::scan1d::scan_edges`] — and classifies each digit from its
+//! four element widths normalized to that digit's own local 7-module width. Measuring
+//! the module scale per digit tolerates the slowly-varying pitch a curved surface
+//! imposes, and reading widths (not a global integer grid) recovers the single-module
+//! guards and elements that hard quantization merges under optical blur.
+//!
+//! The recovered digits, variant and check digit are assembled into exactly the
+//! [`Symbol`] the structural decoder would produce for the same code, so both paths are
+//! interchangeable and the lossless re-encode invariant holds.
+
+use super::tables::{EAN13_FIRST_PARITY, check_digit, l_widths, upce_expand, upce_from_parity};
+use super::{EanMeta, EanVariant};
+use crate::image::GrayFrame;
+use crate::scan1d::{ScanOptions, scan_edges};
+use crate::segment::Segment;
+use crate::symbol::{Symbol, SymbolMeta};
+use crate::symbology::Symbology;
+
+/// Maximum acceptable per-digit width-match score (sum of squared module-count
+/// deviations over the four elements). Clean digits score ~0; this rejects noise.
+const MAX_DIGIT_SCORE: f32 = 1.4;
+/// Maximum relative deviation of a guard element from the guard's mean element width.
+const GUARD_TOL: f32 = 0.55;
+
+/// Decode every EAN/UPC main variant from one scanline's run widths, trying both scan
+/// directions. Returns the assembled [`Symbol`] for the first variant that validates
+/// (guards, parity and check digit), or `None`.
+pub fn decode_edges(edges: &[f32]) -> Option<Symbol> {
+    if edges.len() < 3 {
+        return None;
+    }
+    let forward: Vec<f32> = edges.windows(2).map(|w| w[1] - w[0]).collect();
+    let mut reversed = forward.clone();
+    reversed.reverse();
+    for widths in [&forward, &reversed] {
+        if let Some(sym) = decode_widths(widths) {
+            return Some(sym);
+        }
+    }
+    None
+}
+
+/// Try each main variant against a run-width sequence that starts with a bar.
+fn decode_widths(w: &[f32]) -> Option<Symbol> {
+    let (variant, digits) = [try_ean13(w), try_ean8(w), try_upce(w)]
+        .into_iter()
+        .flatten()
+        .next()?;
+    Some(Symbol::new(
+        symbology_of(variant),
+        vec![Segment::numeric(digits)],
+        SymbolMeta::Ean(EanMeta {
+            variant,
+            addon: None,
+        }),
+    ))
+}
+
+fn symbology_of(variant: EanVariant) -> Symbology {
+    match variant {
+        EanVariant::Ean13 => Symbology::Ean13,
+        EanVariant::Ean8 => Symbology::Ean8,
+        EanVariant::UpcA => Symbology::UpcA,
+        EanVariant::UpcE => Symbology::UpcE,
+        EanVariant::Ean2 => Symbology::Ean2,
+        EanVariant::Ean5 => Symbology::Ean5,
+    }
+}
+
+fn to_ascii(vals: &[u8]) -> Vec<u8> {
+    vals.iter().map(|&v| b'0' + v).collect()
+}
+
+/// Whether `n` guard elements are all within tolerance of their common mean width.
+fn guard_ok(elems: &[f32]) -> bool {
+    let mean = elems.iter().sum::<f32>() / elems.len() as f32;
+    if mean <= 0.0 {
+        return false;
+    }
+    elems.iter().all(|&e| (e - mean).abs() <= GUARD_TOL * mean)
+}
+
+/// Classify a 4-element digit from its widths. `left` selects the left half (L/G, parity
+/// recovered) versus the right half (R). Returns `(digit, is_even, score)`; even is
+/// always `false` for right digits.
+fn classify(w: &[f32], left: bool) -> Option<(u8, bool, f32)> {
+    let total: f32 = w.iter().sum();
+    if total <= 0.0 {
+        return None;
+    }
+    let unit = total / 7.0;
+    let norm = [w[0] / unit, w[1] / unit, w[2] / unit, w[3] / unit];
+    let score_against = |pat: [u8; 4]| -> f32 {
+        (0..4)
+            .map(|i| {
+                let d = norm[i] - pat[i] as f32;
+                d * d
+            })
+            .sum()
+    };
+    let mut best: Option<(u8, bool, f32)> = None;
+    for d in 0..10u8 {
+        let l = l_widths(d);
+        // R widths equal L widths; G widths are L reversed. Left digits try L and G;
+        // right digits try only R.
+        let cands: &[(bool, [u8; 4])] = if left {
+            &[(false, l), (true, [l[3], l[2], l[1], l[0]])]
+        } else {
+            &[(false, l)]
+        };
+        for &(even, pat) in cands {
+            let s = score_against(pat);
+            if best.is_none_or(|(_, _, bs)| s < bs) {
+                best = Some((d, even, s));
+            }
+        }
+    }
+    best.filter(|&(_, _, s)| s <= MAX_DIGIT_SCORE)
+}
+
+/// EAN-13 / UPC-A: 59 runs (start `101`, six left digits, centre `01010`, six right
+/// digits, end `101`). Searches a small start offset for the guard.
+fn try_ean13(w: &[f32]) -> Option<(EanVariant, Vec<u8>)> {
+    at_offsets(w, 59, |r| {
+        if !guard_ok(&r[0..3]) || !guard_ok(&r[27..32]) || !guard_ok(&r[56..59]) {
+            return None;
+        }
+        let mut left = [0u8; 6];
+        let mut parity = [false; 6];
+        for i in 0..6 {
+            let (d, even, _) = classify(&r[3 + i * 4..7 + i * 4], true)?;
+            left[i] = d;
+            parity[i] = even;
+        }
+        let first = (0..10u8).find(|&f| EAN13_FIRST_PARITY[f as usize] == parity)?;
+        let mut right = [0u8; 6];
+        for i in 0..6 {
+            let (d, _, _) = classify(&r[32 + i * 4..36 + i * 4], false)?;
+            right[i] = d;
+        }
+        let mut vals = Vec::with_capacity(13);
+        vals.push(first);
+        vals.extend_from_slice(&left);
+        vals.extend_from_slice(&right);
+        if check_digit(&vals[..12]) != vals[12] {
+            return None;
+        }
+        if first == 0 {
+            Some((EanVariant::UpcA, to_ascii(&vals[1..])))
+        } else {
+            Some((EanVariant::Ean13, to_ascii(&vals)))
+        }
+    })
+}
+
+/// EAN-8: 43 runs (start `101`, four left L digits, centre `01010`, four right digits,
+/// end `101`).
+fn try_ean8(w: &[f32]) -> Option<(EanVariant, Vec<u8>)> {
+    at_offsets(w, 43, |r| {
+        if !guard_ok(&r[0..3]) || !guard_ok(&r[19..24]) || !guard_ok(&r[40..43]) {
+            return None;
+        }
+        let mut vals = [0u8; 8];
+        for i in 0..4 {
+            let (d, even, _) = classify(&r[3 + i * 4..7 + i * 4], true)?;
+            if even {
+                return None; // EAN-8 left digits are all odd (L).
+            }
+            vals[i] = d;
+        }
+        for i in 0..4 {
+            let (d, _, _) = classify(&r[24 + i * 4..28 + i * 4], false)?;
+            vals[4 + i] = d;
+        }
+        if check_digit(&vals[..7]) != vals[7] {
+            return None;
+        }
+        Some((EanVariant::Ean8, to_ascii(&vals)))
+    })
+}
+
+/// UPC-E: 33 runs (start `101`, six L/G digits carrying number-system+check parity, end
+/// guard `010101`).
+fn try_upce(w: &[f32]) -> Option<(EanVariant, Vec<u8>)> {
+    at_offsets(w, 33, |r| {
+        if !guard_ok(&r[0..3]) || !guard_ok(&r[27..33]) {
+            return None;
+        }
+        let mut payload = [0u8; 6];
+        let mut parity = [false; 6];
+        for i in 0..6 {
+            let (d, even, _) = classify(&r[3 + i * 4..7 + i * 4], true)?;
+            payload[i] = d;
+            parity[i] = even;
+        }
+        let (ns, check) = upce_from_parity(&parity)?;
+        if check_digit(&upce_expand(ns, &payload)) != check {
+            return None;
+        }
+        let mut vals = Vec::with_capacity(8);
+        vals.push(ns);
+        vals.extend_from_slice(&payload);
+        vals.push(check);
+        Some((EanVariant::UpcE, to_ascii(&vals)))
+    })
+}
+
+/// Try `f` on `w[o..o+len]` for a few even start offsets (skipping spurious leading
+/// runs) and return its first success.
+fn at_offsets<F>(w: &[f32], len: usize, f: F) -> Option<(EanVariant, Vec<u8>)>
+where
+    F: Fn(&[f32]) -> Option<(EanVariant, Vec<u8>)>,
+{
+    if w.len() < len {
+        return None;
+    }
+    let max_off = (w.len() - len).min(6);
+    (0..=max_off).step_by(2).find_map(|o| f(&w[o..o + len]))
+}
+
+/// Robustly read an EAN/UPC symbol from a frame by decoding every fine scanline
+/// ([`scan_edges`]) and taking the value that the most scanlines agree on. Consensus
+/// across scanlines is what makes a curved, blurred capture — where each individual line
+/// corrupts different thin features — decode reliably, and it also suppresses the rare
+/// false positive a single noisy line might slip past the checksum.
+pub fn scan(frame: &GrayFrame<'_>, opts: &ScanOptions) -> Option<Symbol> {
+    let mut tally: Vec<(String, usize, Symbol)> = Vec::new();
+    for cand in scan_edges(frame, opts) {
+        let Some(sym) = decode_edges(&cand.edges) else {
+            continue;
+        };
+        let key = format!("{:?}|{}", sym.symbology, sym.text().unwrap_or_default());
+        if let Some(entry) = tally.iter_mut().find(|(k, _, _)| *k == key) {
+            entry.1 += 1;
+        } else {
+            let mut sym = sym;
+            sym.location.get_or_insert(cand.location);
+            tally.push((key, 1, sym));
+        }
+    }
+    tally
+        .into_iter()
+        .max_by_key(|(_, n, _)| *n)
+        .map(|(_, _, s)| s)
+}
@@ -6,7 +6,10 @@
 //! - `tables`  — L/G/R element patterns, parity tables, guards, check digits and
 //!   the UPC-E ⟷ UPC-A expansion.
 //! - `encode`  — [`Symbol`] → [`LinearPattern`].
-//! - `decode`  — [`LinearPattern`] → [`Symbol`].
+//! - `decode`  — [`LinearPattern`] → [`Symbol`] (structural, from a clean module grid).
+//! - `edge`    — [`Symbol`] from per-scanline sub-pixel run *widths* ([`scan`],
+//!   [`decode_edges`]), the robust path for curved, blurred camera captures where hard
+//!   quantization merges the single-module guards and elements.
 //!
 //! ## Lossless representation
 //!
@@ -39,10 +42,12 @@
 //! [`Symbology::Ean5`]: crate::Symbology::Ean5
 
 mod decode;
+mod edge;
 mod encode;
 mod tables;
 
 pub use decode::EanDecoder;
+pub use edge::{decode_edges, scan};
 pub use encode::EanEncoder;
 
 /// Which member of the EAN/UPC family a [`crate::Symbol`] represents.
 
@@ -76,6 +76,31 @@ pub fn match_right(m: &[bool]) -> Option<u8> {
     (0..10u8).find(|&d| m == r_code(d))
 }
 
+/// Run-length the four elements of a 7-module EAN/UPC digit code (always exactly four
+/// runs), as module counts. Used by the edge/width-ratio decoder.
+fn widths7(code: [bool; 7]) -> [u8; 4] {
+    let mut out = [0u8; 4];
+    let mut idx = 0;
+    let mut cur = code[0];
+    for &b in &code {
+        if b == cur {
+            out[idx] += 1;
+        } else {
+            idx += 1;
+            out[idx] = 1;
+            cur = b;
+        }
+    }
+    out
+}
+
+/// Element widths (module counts, summing to 7) of the L-code for digit `d`, ordered
+/// space,bar,space,bar. The G-code widths are these reversed and the R-code widths are
+/// identical (complementing a bit string preserves its run lengths).
+pub fn l_widths(d: u8) -> [u8; 4] {
+    widths7(l_code(d))
+}
+
 // ---- Guard and delineator patterns (`true` = bar) --------------------------
 
 /// Normal start/end guard: `101`.