hh-shipments 0.3.24 → 0.3.26

package/package.json

@@ -1,5 +1,6 @@
 {
   "dependencies": {
+    "@zxing/library": "^0.23.0",
     "bcryptjs": "^2.4.3",
     "cookie-parser": "^1.4.6",
     "express": "^4.21.2",
@@ -15,10 +16,10 @@
   "name": "hh-shipments",
   "scripts": {
     "start": "node server.js",
-    "test": "node test/run-tests.js && node test/run-carriers-tests.js"
+    "test": "node test/run-extract-tests.js && node test/run-tests.js && node test/run-carriers-tests.js"
   },
   "type": "commonjs",
-  "version": "0.3.24",
+  "version": "0.3.26",
   "bin": {
     "hh-shipments": "server.js"
   },

package/public/app.js

@@ -175,53 +175,120 @@ function loadTesseract() {
   return tesseractLoading;
 }
 
-// Tesseract reads dark-text-on-light far better than the reverse. Chat
-// screenshots (dark mode) come out as white-on-black, so detect dark images
-// and invert them before OCR. Light images (labels) pass through untouched.
-async function maybeInvertForOcr(file) {
+// "Better eyes": smart OCR pipeline that adapts to image type.
+// - Chat screenshots (dark): invert, PSM 6 (uniform block)
+// - Labels (light): crop to tracking zone, upscale, PSM 6
+// - Falls back to full-image PSM 3 if targeted fails
+async function ocrFile(file, statusEl) {
+  await loadTesseract();
+  statusEl.textContent = 'Reading screenshot…';
+  const isDark = await isDarkImage(file);
+  file = isDark ? await invertImage(file) : file;
+
+  const log = (m) => { if (m.status === 'recognizing text' && statusEl) statusEl.textContent = `Reading… ${Math.round(m.progress * 100)}%`; };
+
+  // Pass 1: targeted — for labels, crop to the tracking-number zone (bottom 45%)
+  // and upscale for Tesseract. For chats, use the full image.
+  let bestText = '';
+  if (!isDark) {
+    try {
+      const zoned = await cropAndUpscale(file, 0, 0.55, 1, 0.45, 2);
+      const r1 = await Tesseract.recognize(zoned, 'eng', {
+        logger: log,
+        tessedit_pageseg_mode: '6', // uniform block of text
+      });
+      bestText = r1.data.text || '';
+      // If the zone has a plausible tracking number, we're done
+      if (/(1Z|12|IZ|17)\s*[0-9A-Z)\]}(\[{|!]/i.test(bestText)) {
+        if (statusEl) statusEl.textContent = '';
+        return bestText;
+      }
+    } catch (e) {}
+  }
+
+  // Pass 2: full image with PSM 6
+  try {
+    const r2 = await Tesseract.recognize(file, 'eng', {
+      logger: log,
+      tessedit_pageseg_mode: '6',
+    });
+    const t2 = r2.data.text || '';
+    if (t2.length > bestText.length) bestText = t2;
+  } catch (e) {}
+
+  // Pass 3: fallback to default PSM 3 if we got nothing useful
+  if (!bestText || bestText.trim().length < 10) {
+    try {
+      const r3 = await Tesseract.recognize(file, 'eng', { logger: log });
+      const t3 = r3.data.text || '';
+      if (t3.length > bestText.length) bestText = t3;
+    } catch (e) {}
+  }
+
+  if (statusEl) statusEl.textContent = '';
+  return bestText;
+}
+
+async function isDarkImage(file) {
   try {
     const bmp = await createImageBitmap(file);
-    const w = bmp.width, h = bmp.height;
-    const canvas = document.createElement('canvas');
-    // sample at reduced size for speed
-    const sw = Math.min(200, w), sh = Math.min(200, h);
-    canvas.width = sw; canvas.height = sh;
-    const ctx = canvas.getContext('2d', { willReadFrequently: true });
+    const sw = Math.min(100, bmp.width), sh = Math.min(100, bmp.height);
+    const c = document.createElement('canvas');
+    c.width = sw; c.height = sh;
+    const ctx = c.getContext('2d', { willReadFrequently: true });
     ctx.drawImage(bmp, 0, 0, sw, sh);
     const px = ctx.getImageData(0, 0, sw, sh).data;
     let sum = 0, n = 0;
     for (let i = 0; i < px.length; i += 16) {
-      sum += 0.299 * px[i] + 0.587 * px[i + 1] + 0.114 * px[i + 2];
+      sum += 0.299 * px[i] + 0.587 * px[i+1] + 0.114 * px[i+2];
       n++;
     }
-    const avg = sum / n;
     bmp.close();
-    if (avg > 110) return file; // already light — leave it alone
-    // dark image: invert to dark-on-light
-    const c2 = document.createElement('canvas');
-    c2.width = w; c2.height = h;
-    const x2 = c2.getContext('2d');
-    const full = await createImageBitmap(file);
-    x2.drawImage(full, 0, 0);
-    full.close();
-    const img = x2.getImageData(0, 0, w, h);
+    return (sum / n) < 110;
+  } catch (e) { return false; }
+}
+
+async function invertImage(file) {
+  try {
+    const bmp = await createImageBitmap(file);
+    const c = document.createElement('canvas');
+    c.width = bmp.width; c.height = bmp.height;
+    const ctx = c.getContext('2d');
+    ctx.drawImage(bmp, 0, 0);
+    bmp.close();
+    const img = ctx.getImageData(0, 0, c.width, c.height);
     const d = img.data;
     for (let i = 0; i < d.length; i += 4) {
-      d[i] = 255 - d[i]; d[i + 1] = 255 - d[i + 1]; d[i + 2] = 255 - d[i + 2];
+      d[i] = 255 - d[i]; d[i+1] = 255 - d[i+1]; d[i+2] = 255 - d[i+2];
     }
-    x2.putImageData(img, 0, 0);
-    const blob = await new Promise((res) => c2.toBlob(res, 'image/jpeg', 0.92));
+    ctx.putImageData(img, 0, 0);
+    const blob = await new Promise((res) => c.toBlob(res, 'image/jpeg', 0.92));
     return blob ? new File([blob], 'inv.jpg', { type: 'image/jpeg' }) : file;
   } catch (e) { return file; }
 }
 
-async function ocrFile(file, statusEl) {
-  await loadTesseract();
-  statusEl.textContent = 'Reading screenshot…';
-  file = await maybeInvertForOcr(file);
-  const { data } = await Tesseract.recognize(file, 'eng', { logger: (m) => { if (m.status === 'recognizing text') statusEl.textContent = `Reading… ${Math.round(m.progress * 100)}%`; } });
-  statusEl.textContent = '';
-  return data.text || '';
+async function cropAndUpscale(file, fx, fy, fw, fh, scale) {
+  const bmp = await createImageBitmap(file);
+  const sw = Math.round(bmp.width * fw), sh = Math.round(bmp.height * fh);
+  const c = document.createElement('canvas');
+  c.width = Math.round(sw * scale);
+  c.height = Math.round(sh * scale);
+  const ctx = c.getContext('2d');
+  ctx.drawImage(bmp, bmp.width * fx, bmp.height * fy, sw, sh, 0, 0, c.width, c.height);
+  bmp.close();
+  // Boost contrast for text
+  try {
+    const img = ctx.getImageData(0, 0, c.width, c.height);
+    const d = img.data;
+    for (let i = 0; i < d.length; i += 4) {
+      const v = 0.299*d[i] + 0.587*d[i+1] + 0.114*d[i+2];
+      const nv = v < 140 ? Math.max(0, v - 40) : Math.min(255, v + 40);
+      d[i] = d[i+1] = d[i+2] = nv;
+    }
+    ctx.putImageData(img, 0, 0);
+  } catch (e) {}
+  const blob = await new Promise((res) => c.toBlob(res, 'image/jpeg', 0.95));
+  return new File([blob], 'crop.jpg', { type: 'image/jpeg' });
 }
 
 async function handlePhotoFile(f) {
@@ -314,15 +381,17 @@ async function fetchTimeout(url, opts = {}, ms = 60000) {
 }
 
 // ---- Barcode-first decoding (ZXing) ----
-// A decoded barcode is checksum-verified (Code128 mod-103), so it is
-// essentially never wrong — far more reliable than OCR text for labels.
+// Bundled locally at /vendor/zxing.min.js so a CDN outage can never
+// silently kill it. A decoded barcode is checksum-verified (Code128
+// mod-103), so it is essentially never wrong — far more reliable than
+// OCR text for labels.
 let zxingPromise = null;
 function loadZxing() {
   if (window.ZXing) return Promise.resolve();
   if (!zxingPromise) {
     zxingPromise = new Promise((res, rej) => {
       const s = document.createElement('script');
-      s.src = 'https://cdn.jsdelivr.net/npm/@zxing/library@0.21.3/umd/index.min.js';
+      s.src = '/vendor/zxing.min.js';
       s.onload = res;
       s.onerror = () => rej(new Error('barcode reader failed to load'));
       document.head.appendChild(s);
@@ -357,8 +426,13 @@ async function ocrTopStrip(origFile, statusEl) {
 function strictTracking(s) {
   s = String(s || '').toUpperCase().replace(/[\s-]/g, '');
   if (/^1Z[0-9A-Z]{16}$/.test(s)) return s;          // UPS
-  if (/^9\d{19,21}$/.test(s)) return s;               // USPS
-  if (/^(\d{12}|\d{15}|\d{20})$/.test(s)) return s;    // FedEx
+  // IMpb barcode: strip the routing prefix, return the tracking number.
+  // The routing portion alone is never a shipment.
+  var impb = (window.HHExtract && HHExtract.parseImpb) ? HHExtract.parseImpb(s) : null;
+  if (impb) return impb;
+  if (/^9[1-5]\d{18,20}$/.test(s)) return s;         // USPS
+  if (/^420\d{9}$/.test(s)) return null;             // IMpb routing — never a shipment
+  if (/^(\d{12}|\d{15}|\d{20})$/.test(s)) return s;   // FedEx
   if (/^\d{10,11}$/.test(s)) return s;                // DHL
   return null;
 }
@@ -533,13 +607,12 @@ async function loadPending() {
 async function reviewPendingImage(id) {
   $('photo-result').innerHTML = `<img src="/api/intake/image/${id}" style="max-width:100%;border-radius:10px"><p class="muted">Extracting…</p>`;
   try {
-    await loadTesseract();
     const resp = await fetch(`/api/intake/image/${id}`);
     const blob = await resp.blob();
-    const file = await maybeInvertForOcr(new File([blob], 'pending.jpg', { type: blob.type || 'image/jpeg' }));
-    const { data } = await Tesseract.recognize(file, 'eng');
+    const file = new File([blob], 'pending.jpg', { type: blob.type || 'image/jpeg' });
+    const text = await ocrFile(file, null);
     await api.patch('/api/intake/' + id, { state: 'reviewed' });
-    await runQuick(data.text || '', $('photo-result'));
+    await runQuick(text, $('photo-result'));
     loadPending();
   } catch (e) { $('photo-result').innerHTML = `<p class="error">${esc(e.message)}</p>`; }
 }

package/public/extract.js

@@ -9,8 +9,8 @@
   var PATTERNS = [
     // UPS: 1Z + 16 alphanumerics
     { carrier: 'ups', confidence: 'high', re: /\b(1Z[0-9A-Z]{16})\b/gi },
-    // USPS: 20-22 digits starting 92-95 (9400..., 9205..., etc.)
-    { carrier: 'usps', confidence: 'high', re: /\b(9[2-5]\d{18,20})\b/g },
+    // USPS: 20-22 digits starting 91-95 (9400..., 9305..., 9205..., 9101..., etc.)
+    { carrier: 'usps', confidence: 'high', re: /\b(9[1-5]\d{18,20})\b/g },
     // USPS S10 international: 2 letters + 9 digits + 2 letters (ends US = USPS)
     { carrier: 'usps', confidence: 'medium', re: /\b([A-Z]{2}\d{9}US)\b/g },
     // FedEx SmartPost / Ground 22-digit starting 96
@@ -95,9 +95,14 @@
     anchorZones(text).forEach(function (z) {
       runPatterns(z.text, found, seen, z.carrier);
       spacedUpsIn(z.text, found, seen, 'high');
+      spacedDigitGroupsIn(z.text, found, seen, 'high');
     });
     // 1) Whole-text strict patterns
     runPatterns(text, found, seen, false);
+    // 1b) Spaced digit groups: labels print "9305 5110 4390 0011 2062 42"
+    // with spaces, which strict PATTERNS cannot match. Without this pass a
+    // perfectly-read number is silently dropped.
+    spacedDigitGroupsIn(text, found, seen, 'medium');
     // 2) OCR-tolerant recovery pass
     extractOcrTolerant(text, found, seen);
     var rank = { high: 0, medium: 1, low: 2 };
@@ -142,6 +147,9 @@
         var num = normalize(m[1]);
         if (seen[num]) continue;
         seen[num] = true;
+        // Never accept an IMpb routing prefix (420 + 9 digits) as a FedEx
+        // number — it is postal routing, not a shipment.
+        if (p.carrier === 'fedex' && /^420\d{9}$/.test(num)) continue;
         // Context boost: carrier word near the number, or a hot-zone anchor
         // naming this carrier (a label's "UPS GROUND" line means the number
         // under it really is UPS).
@@ -162,12 +170,61 @@
   function isValidFormat(number, carrier) {
     var n = normalize(number);
     if (carrier === 'ups') return /^1Z[0-9A-Z]{16}$/.test(n);
-    if (carrier === 'usps') return /^9[2-5]\d{18,20}$/.test(n) || /^[A-Z]{2}\d{9}US$/.test(n);
-    if (carrier === 'fedex') return /^(96\d{20}|\d{12}|\d{15}|\d{20})$/.test(n);
+    if (carrier === 'usps') return /^9[1-5]\d{18,20}$/.test(n) || /^[A-Z]{2}\d{9}US$/.test(n);
+    // FedEx: never accept an IMpb routing prefix (420 + 9 digits) — it is
+    // postal routing, not a shipment number.
+    if (carrier === 'fedex') return /^(96\d{20}|\d{12}|\d{15}|\d{20})$/.test(n) && !/^420\d{9}$/.test(n);
     if (carrier === 'dhl') return /^\d{10,11}$/.test(n) || /^[A-Z]{2,4}\d{10,20}$/.test(n);
     return false;
   }
 
+  // Intelligent Mail package barcode: 420 + routing digits + USPS tracking,
+  // e.g. 420078742956 + 9305511043900011206242 (34 digits). The full barcode
+  // is NOT the tracking number — return the trailing tracking number. The
+  // routing portion must never pass as a shipment number.
+  function parseImpb(s) {
+    var num = normalize(s);
+    if (!/^420\d{23,31}$/.test(num)) return null; // 26–34 digits total
+    var m = /(9[1-5]\d{18,20})$/.exec(num);
+    return m ? m[1] : null;
+  }
+
+  // A spaced/dashed digit run is only plausible as a tracking number when
+  // every group has 2+ digits — this rejects ZIP+4 glued to a nearby lone
+  // digit ("07874-2956 1 lb"), phone fragments ("1-800-555-1234"), etc.
+  function validSpacedGroups(raw) {
+    var groups = String(raw).split(/[\s-]+/);
+    if (groups.length < 2) return true; // contiguous — decided elsewhere
+    for (var i = 0; i < groups.length; i++) if (groups[i].length < 2) return false;
+    return true;
+  }
+
+  // Digit groups split by spaces/dashes: "9305 5110 4390 0011 2062 42".
+  // Strict PATTERNS only match contiguous runs, so this pass exists for the
+  // standard label printing format. Only fires when the raw match actually
+  // contains a separator (contiguous runs are already covered by PATTERNS).
+  // Joined candidates must validate against a carrier format; IMpb barcodes
+  // yield their tracking number, never the routing.
+  function spacedDigitGroupsIn(text, found, seen, conf) {
+    var re = /\b\d(?:[\s-]?\d){9,33}\b/g, m;
+    while ((m = re.exec(text)) !== null) {
+      if (!/[\s-]/.test(m[0])) continue;
+      if (!validSpacedGroups(m[0])) continue;
+      var num = normalize(m[0]);
+      if (!num || seen[num]) continue;
+      var impb = parseImpb(num);
+      if (impb) {
+        seen[num] = true;
+        if (!seen[impb]) { seen[impb] = true; found.push({ number: impb, carrier: 'usps', confidence: conf }); }
+        continue;
+      }
+      var carrier = guessCarrier(num);
+      if (carrier === 'unknown') { seen[num] = true; continue; }
+      seen[num] = true;
+      found.push({ number: num, carrier: carrier, confidence: conf });
+    }
+  }
+
   function guessCarrier(num) {
     var carriers = ['ups', 'usps', 'fedex', 'dhl'];
     for (var i = 0; i < carriers.length; i++) if (isValidFormat(num, carriers[i])) return carriers[i];
@@ -194,13 +251,20 @@
     // a) UPS number split by spaces/dashes (whole-text fallback; the anchor
     // pass already tried the hot zones at high confidence)
     spacedUpsIn(text, found, seen, 'medium');
-    // b) long digit-like runs with OCR confusions -> fix -> re-match digit formats
-    var runRe = /[0-9OILSBoilszb]{10,24}/g, run;
+    // b) long digit-like runs with OCR confusions -> fix -> re-match digit formats.
+    // Space-aware: OCR often reads "9305 51O0 ..." with both mangled chars
+    // AND spaces, so runs may contain separators. Runs up to 34 chars so a
+    // full 34-digit IMpb barcode is tested whole (parseImpb) instead of
+    // being split into chunks that false-positive as DHL/FedEx.
+    var runRe = /[0-9OILSBoilszb](?:[\s-]?[0-9OILSBoilszb]){9,33}/g, run;
     while ((run = runRe.exec(text)) !== null) {
+      if (/[\s-]/.test(run[0]) && !validSpacedGroups(run[0])) continue;
       var fixed = normalize(ocrDigitFix(run[0]));
-      if (/^9[2-5]\d{18,20}$/.test(fixed)) push(fixed, 'usps', 'medium');
+      var impbFixed = parseImpb(fixed);
+      if (impbFixed) { push(impbFixed, 'usps', 'medium'); continue; }
+      if (/^9[1-5]\d{18,20}$/.test(fixed)) push(fixed, 'usps', 'medium');
       else if (/^96\d{20}$/.test(fixed)) push(fixed, 'fedex', 'medium');
-      else if (/^(\d{12}|\d{15}|\d{20})$/.test(fixed)) push(fixed, 'fedex', 'medium');
+      else if (/^(\d{12}|\d{15}|\d{20})$/.test(fixed) && !/^420\d{9}$/.test(fixed)) push(fixed, 'fedex', 'medium');
       else if (/^\d{11}$/.test(fixed)) push(fixed, 'dhl', 'medium');
       else if (/^\d{10}$/.test(fixed)) push(fixed, 'dhl', 'low');
     }
@@ -214,6 +278,7 @@
     });
     tokens.sort(function (a, b) { return b.length - a.length; });
     tokens.slice(0, 3).forEach(function (t) {
+      if (/^420\d{9}$/.test(t)) return; // IMpb routing — never a shipment
       // UPS "1Z" misread as "12"/"IZ" in a joined (space-free) token
       var fixed = repairUpsZ(t);
       if (fixed) { push(fixed, 'ups', 'medium'); return; }
@@ -225,7 +290,7 @@
     });
   }
 
-  var api = { extractTrackingNumbers: extractTrackingNumbers, extractContext: extractContext, normalize: normalize, isValidFormat: isValidFormat };
+  var api = { extractTrackingNumbers: extractTrackingNumbers, extractContext: extractContext, normalize: normalize, isValidFormat: isValidFormat, parseImpb: parseImpb };
   if (typeof module !== 'undefined' && module.exports) module.exports = api;
   globalThis.HHExtract = api;
 })();

package/public/index.html

@@ -4,7 +4,7 @@
 <meta charset="utf-8">
 <meta name="viewport" content="width=device-width, initial-scale=1, viewport-fit=cover">
 <meta name="theme-color" content="#0a84ff">
-<meta name="app-version" content="0.3.24">
+<meta name="app-version" content="0.3.25">
 <title>HH Shipments</title>
 <link rel="manifest" href="/manifest.webmanifest">
 <link rel="apple-touch-icon" href="/icon-192.png">

package/public/sw.js

@@ -2,7 +2,7 @@
    CACHE name includes the app version (injected by the server), so every
    deploy installs a fresh shell and deletes the old one. */
 const CACHE = 'hh-ship-__APP_VERSION__';
-const SHELL = ['/', '/index.html', '/styles.css', '/app.js', '/extract.js', '/manifest.webmanifest'];
+const SHELL = ['/', '/index.html', '/styles.css', '/app.js', '/extract.js', '/vendor/zxing.min.js', '/manifest.webmanifest'];
 
 self.addEventListener('install', (e) => {
   e.waitUntil(caches.open(CACHE).then((c) => c.addAll(SHELL)).then(() => self.skipWaiting()));