tapirscan 1.0.0 → 1.2.0

package/dist/multiformat/geometry.js

@@ -35,7 +35,7 @@ export function transformFor(quad, width, height) {
     }
     return a.map((row) => row[8]);
 }
-export function rectify(gray, width, height, quad) {
+export function rectificationPlan(quad) {
     const distance = (a, b) => Math.hypot(a[0] - b[0], a[1] - b[1]);
     const w = Math.max(8, Math.ceil(Math.max(distance(quad[0], quad[1]), distance(quad[3], quad[2]))));
     const h = Math.max(8, Math.ceil(Math.max(distance(quad[0], quad[3]), distance(quad[1], quad[2]))));
@@ -54,10 +54,19 @@ export function rectify(gray, width, height, quad) {
         base[7] / divisor,
     ];
     const paddedWidth = w + 2 * pad, paddedHeight = h + 2 * pad;
+    return { width: paddedWidth, height: paddedHeight, transform: t };
+}
+export function rectify(gray, width, height, quad) {
+    const { width: paddedWidth, height: paddedHeight, transform: t } = rectificationPlan(quad);
     const data = new Uint8Array(paddedWidth * paddedHeight);
-    for (let y = 0; y < paddedHeight; y++)
+    for (let y = 0; y < paddedHeight; y++) {
+        const cy = y + 0.5;
+        const yX = t[1] * cy, yY = t[4] * cy, yZ = t[7] * cy;
         for (let x = 0; x < paddedWidth; x++) {
-            const [xx, yy] = project(t, x + 0.5, y + 0.5);
+            const cx = x + 0.5;
+            const z = t[6] * cx + yZ + 1;
+            const xx = (t[0] * cx + yX + t[2]) / z;
+            const yy = (t[3] * cx + yY + t[5]) / z;
             if (xx < 0 || yy < 0 || xx > width - 1 || yy > height - 1) {
                 data[y * paddedWidth + x] = 255;
                 continue;
@@ -67,6 +76,7 @@ export function rectify(gray, width, height, quad) {
             data[y * paddedWidth + x] = Math.round((gray[y0 * width + x0] * (1 - fx) + gray[y0 * width + x1] * fx) * (1 - fy) +
                 (gray[y1 * width + x0] * (1 - fx) + gray[y1 * width + x1] * fx) * fy);
         }
+    }
     return { data, width: paddedWidth, height: paddedHeight, transform: t };
 }
 /** Convex intersection, including opposite winding and projective quadrilaterals. */

package/dist/multiformat/linear-duplicates.d.ts

@@ -0,0 +1,16 @@
+import type { Image, Quad } from "../host.js";
+type Read = {
+    text: string;
+    format: string;
+    polygon: Quad;
+    support: number;
+    eanAddOn?: string;
+    gs1?: boolean;
+    readerInitialization?: boolean;
+};
+/** Only merge equal-value, aligned bands when source pixels connect their bars.
+ * This does not change search coverage or retry budgets. Exhausting the small
+ * evidence budget leaves detections separate, never drops an unchecked read.
+ */
+export declare function mergeLinearDuplicates<T extends Read>(reads: readonly T[], image: Image): T[];
+export {};

package/dist/multiformat/linear-duplicates.js

@@ -0,0 +1,163 @@
+import { polygonOverlap } from "./geometry.js";
+const formats = new Set(["EAN13", "UPCA", "EAN8", "UPCE", "Code128", "Code39", "ITF"]);
+function bitCount(value) {
+    let bits = value - ((value >>> 1) & 0x55555555);
+    bits = (bits & 0x33333333) + ((bits >>> 2) & 0x33333333);
+    return (((bits + (bits >>> 4)) & 0x0f0f0f0f) * 0x01010101) >>> 24;
+}
+const midpoint = (a, b) => [
+    (a[0] + b[0]) / 2,
+    (a[1] + b[1]) / 2,
+];
+const line = (q) => [midpoint(q[0], q[3]), midpoint(q[1], q[2])];
+/** Only merge equal-value, aligned bands when source pixels connect their bars.
+ * This does not change search coverage or retry budgets. Exhausting the small
+ * evidence budget leaves detections separate, never drops an unchecked read.
+ */
+export function mergeLinearDuplicates(reads, image) {
+    if (reads.length < 2)
+        return [...reads];
+    const seen = new Set();
+    let repeated = false;
+    for (const read of reads) {
+        if (!read.text || !formats.has(read.format))
+            continue;
+        const key = `${read.format}:${read.text}`;
+        if (seen.has(key)) {
+            repeated = true;
+            break;
+        }
+        seen.add(key);
+    }
+    if (!repeated)
+        return [...reads];
+    let remaining = 32768;
+    const result = [];
+    let values;
+    const profile = (left, right) => {
+        if (remaining < 64)
+            return undefined;
+        remaining -= 64;
+        values ??= new Float64Array(64);
+        let lo = 255, hi = 0;
+        for (let i = 0; i < 64; i++) {
+            const f = (i + 0.5) / 64;
+            const x = Math.round(left[0] + (right[0] - left[0]) * f);
+            const y = Math.round(left[1] + (right[1] - left[1]) * f);
+            if (x < 0 || y < 0 || x >= image.width || y >= image.height)
+                return undefined;
+            const p = y * image.stride + x * image.channels;
+            const value = image.channels === 1
+                ? image.data[p]
+                : (77 * image.data[p] + 150 * image.data[p + 1] + 29 * image.data[p + 2]) / 256;
+            values[i] = value;
+            lo = Math.min(lo, value);
+            hi = Math.max(hi, value);
+        }
+        if (hi - lo < 24)
+            return undefined;
+        const threshold = (lo + hi) / 2;
+        let first = 0, second = 0;
+        for (let i = 0; i < 32; i++) {
+            if (values[i] < threshold)
+                first |= 1 << i;
+            if (values[i + 32] < threshold)
+                second |= 1 << i;
+        }
+        return [first, second];
+    };
+    const connected = (a, inputB) => {
+        if (!a.every((p) => p.every(Number.isFinite)) || !inputB.every((p) => p.every(Number.isFinite)))
+            return undefined;
+        const al = line(a), bl = line(inputB);
+        const ax = al[1][0] - al[0][0], ay = al[1][1] - al[0][1];
+        let bx = bl[1][0] - bl[0][0], by = bl[1][1] - bl[0][1];
+        const aw = Math.hypot(ax, ay), bw = Math.hypot(bx, by);
+        if (aw < 24 || bw / aw < 0.9 || bw / aw > 1.1)
+            return undefined;
+        let b = inputB;
+        if (ax * bx + ay * by < 0) {
+            b = [inputB[2], inputB[3], inputB[0], inputB[1]];
+            bx = -bx;
+            by = -by;
+        }
+        if ((ax * bx + ay * by) / (aw * bw) < 0.996)
+            return undefined;
+        const ac = midpoint(al[0], al[1]), bline = line(b), bc = midpoint(bline[0], bline[1]);
+        const dx = bc[0] - ac[0], dy = bc[1] - ac[1];
+        if (Math.abs(dx * ax + dy * ay) / aw > aw * 0.06)
+            return undefined;
+        // Bound endpoint movement too: rotation/perspective can move an edge farther
+        // than the centers. Every interpolated sample then moves at most one pixel.
+        const distance = Math.max(Math.hypot(bline[0][0] - al[0][0], bline[0][1] - al[0][1]), Math.hypot(bline[1][0] - al[1][0], bline[1][1] - al[1][1]));
+        const steps = Math.ceil(distance);
+        if (steps < 1 || steps > 384 || (steps + 2) * 64 > remaining)
+            return undefined;
+        const reference = profile(al[0], al[1]);
+        if (!reference)
+            return undefined;
+        let dark0 = reference[0], dark1 = reference[1];
+        let light0 = ~dark0, light1 = ~dark1;
+        const minimumDark = Math.max(4, Math.ceil((bitCount(dark0) + bitCount(dark1)) / 4));
+        const minimumLight = Math.max(4, Math.ceil((bitCount(light0) + bitCount(light1)) / 4));
+        for (let step = 1; step <= steps; step++) {
+            const f = step / steps;
+            const l = [
+                al[0][0] + (bline[0][0] - al[0][0]) * f,
+                al[0][1] + (bline[0][1] - al[0][1]) * f,
+            ];
+            const r = [
+                al[1][0] + (bline[1][0] - al[1][0]) * f,
+                al[1][1] + (bline[1][1] - al[1][1]) * f,
+            ];
+            const sample = profile(l, r);
+            if (!sample)
+                return undefined;
+            const disagreement = bitCount(reference[0] ^ sample[0]) + bitCount(reference[1] ^ sample[1]);
+            if (disagreement > 12)
+                return undefined;
+            dark0 &= sample[0];
+            dark1 &= sample[1];
+            light0 &= ~sample[0];
+            light1 &= ~sample[1];
+            // A skewed separator may cross columns at different heights. Require
+            // individual bars AND spaces to survive the entire bridge, not just rows.
+            if (bitCount(dark0) + bitCount(dark1) < minimumDark ||
+                bitCount(light0) + bitCount(light1) < minimumLight)
+                return undefined;
+        }
+        const along = (p) => (-ay * p[0] + ax * p[1]) / aw;
+        const top = along(midpoint(a[0], a[1])) < along(midpoint(b[0], b[1])) ? a : b;
+        const bottom = along(midpoint(a[2], a[3])) > along(midpoint(b[2], b[3])) ? a : b;
+        return [top[0], top[1], bottom[2], bottom[3]];
+    };
+    for (const read of [...reads].sort((a, b) => b.support - a.support)) {
+        if (!formats.has(read.format) || !read.text || remaining < 192) {
+            result.push(read);
+            continue;
+        }
+        let merged = false;
+        for (let i = 0; i < result.length; i++) {
+            const other = result[i];
+            if (read.format !== other.format ||
+                read.text !== other.text ||
+                read.eanAddOn !== other.eanAddOn ||
+                Boolean(read.gs1) !== Boolean(other.gs1) ||
+                Boolean(read.readerInitialization) !== Boolean(other.readerInitialization))
+                continue;
+            if (polygonOverlap(other.polygon, read.polygon).smaller >= 0.65) {
+                merged = true;
+                break;
+            }
+            const polygon = connected(other.polygon, read.polygon);
+            if (!polygon)
+                continue;
+            result[i] = { ...other, polygon }; // Keep strongest support; observations may overlap.
+            merged = true;
+            break;
+        }
+        if (!merged)
+            result.push(read);
+    }
+    return result;
+}

package/dist/multiformat/scanner.d.ts

@@ -1,7 +1,9 @@
-import { type Image, type Quad } from "../multiformat-host.js";
+import { ReleaseDetailScanner } from "../detail.js";
+import { IndependentScanner, type Image, type Quad } from "../completion-host.mjs";
 import type { Mode } from "../index.js";
 import { type Format } from "./formats.js";
 export interface Barcode {
+    bytes?: number[];
     format: Format | "Unknown";
     text: string;
     polygon: Quad;
@@ -21,6 +23,7 @@ export interface Barcode {
 }
 export type EanAddOnSymbol = "Ignore" | "Read" | "Require";
 export interface Frame {
+    primary?: ReturnType<ReleaseDetailScanner["scanLocalized"]> | ReturnType<IndependentScanner["scanLocalized"]>;
     eanAddOnSymbol: EanAddOnSymbol;
     barcodes: Barcode[];
     regions: Barcode[];
@@ -39,13 +42,19 @@ export declare class MediumMultiformatScanner {
     private mode;
     private extra?;
     private handle;
+    private rgba;
+    private crop;
+    private effort;
+    private qrEffort;
     private disposed;
     private constructor();
-    static create(mediumBytes: ArrayBuffer, extraBytes?: ArrayBuffer, mode?: Mode, recoveryBytes?: ArrayBuffer): Promise<MediumMultiformatScanner>;
+    static create(mediumBytes: ArrayBuffer | undefined, extraBytes?: ArrayBuffer, mode?: Mode, recoveryBytes?: ArrayBuffer): Promise<MediumMultiformatScanner>;
     scan(image: Image, inputFormats?: readonly string[], options?: {
         linearStrategy?: "scanlines" | "medium-localized";
         eanAddOnSymbol?: EanAddOnSymbol;
+        finishCandidates?: boolean;
     }): Frame;
     private scanExtra;
+    private scanPrepared;
     dispose(): void;
 }

package/dist/multiformat/scanner.js

@@ -1,25 +1,38 @@
+import { mergeLinearDuplicates } from "./linear-duplicates.js";
 import { ReleaseDetailScanner, fitLimits } from "../detail.js";
-import { IndependentScanner } from "../multiformat-host.js";
+import { IndependentScanner } from "../completion-host.mjs";
 import { policy } from "../policy.js";
-import { rectify, project, distinctReads, polygonOverlap } from "./geometry.js";
+import { rectify, rectificationPlan, project, distinctReads, polygonOverlap } from "./geometry.js";
 import { toGray } from "./pixels.js";
 import { maskFor, resolveFormats, linearFormats as supportedLinearFormats, } from "./formats.js";
+function scanGray(image) {
+    return image.channels === 1 && image.stride === image.width
+        ? image.data.subarray(0, image.width * image.height)
+        : toGray(image);
+}
 /** Frozen EAN13 Medium plus project-owned opt-in readers. No reference decoder. */
 export class MediumMultiformatScanner {
     medium;
     mode = "medium";
     extra;
     handle = 0;
+    rgba = false;
+    crop = false;
+    effort = 1;
+    qrEffort = 1;
     disposed = false;
     constructor() { }
     static async create(mediumBytes, extraBytes, mode = "medium", recoveryBytes) {
         const scanner = new MediumMultiformatScanner();
         try {
             scanner.mode = mode;
-            scanner.medium =
-                mode !== "low" && recoveryBytes
-                    ? await ReleaseDetailScanner.create(mediumBytes, recoveryBytes, mode)
-                    : await IndependentScanner.create(mediumBytes);
+            scanner.effort = { low: 0, medium: 1, high: 2, "very-high": 2 }[mode];
+            scanner.qrEffort = { low: 0, medium: 1, high: 2, "very-high": 3 }[mode];
+            if (mediumBytes)
+                scanner.medium =
+                    mode !== "low" && recoveryBytes
+                        ? await ReleaseDetailScanner.create(mediumBytes, recoveryBytes, mode)
+                        : await IndependentScanner.create(mediumBytes);
             if (extraBytes) {
                 const instance = await WebAssembly.instantiate(extraBytes, {});
                 const e = instance.instance.exports;
@@ -37,6 +50,14 @@ export class MediumMultiformatScanner {
                 }
                 if (!(e.memory instanceof WebAssembly.Memory))
                     throw Error("Invalid multiformat WASM memory.");
+                scanner.rgba =
+                    typeof e.multi_capabilities === "function" &&
+                        (e.multi_capabilities() & 4) !== 0 &&
+                        [e.multi_prepare_rgba, e.multi_input_rgba, e.multi_scan_rgba].every((f) => typeof f === "function");
+                scanner.crop =
+                    typeof e.multi_capabilities === "function" &&
+                        (e.multi_capabilities() & 16) !== 0 &&
+                        [e.multi_capture_source, e.multi_crop_transform, e.multi_crop].every((f) => typeof f === "function");
                 scanner.extra = e;
                 scanner.handle = e.multi_new();
                 if (!scanner.handle)
@@ -53,8 +74,7 @@ export class MediumMultiformatScanner {
         if (this.disposed)
             throw Error("Scanner is disposed.");
         const medium = this.medium;
-        if (!medium)
-            throw Error("Medium reader has not been initialized.");
+        const scanPolicy = { ...policy, finishCandidates: options.finishCandidates ?? false };
         const formats = resolveFormats(inputFormats);
         const eanAddOnSymbol = options.eanAddOnSymbol ?? "Ignore";
         if (!["Ignore", "Read", "Require"].includes(eanAddOnSymbol))
@@ -82,10 +102,43 @@ export class MediumMultiformatScanner {
             data.length < (height - 1) * stride + width * channels)
             throw Error("Invalid image dimensions or buffer.");
         const barcodes = [], regions = [];
+        let primary;
         let unfinished = false, mediumMs = 0, additionalMs = 0, preparationMs = 0, localizationMs = 0;
+        const extraFormats = formats.filter((f) => eanAddOnSymbol !== "Ignore" || (f !== "EAN13" && f !== "UPCA"));
+        const conservative = medium instanceof ReleaseDetailScanner &&
+            !localized &&
+            eanAddOnSymbol === "Ignore" &&
+            formats.some((f) => f === "EAN13" || f === "UPCA") &&
+            extraFormats.some((f) => supportedLinearFormats.includes(f));
+        let preparedGray;
+        let preLinear;
+        const coverage = [];
+        if (conservative) {
+            const prepareStart = performance.now();
+            preparedGray = scanGray(image);
+            preparationMs += performance.now() - prepareStart;
+            const extraStart = performance.now();
+            preLinear = this.scanExtra(preparedGray, width, height, extraFormats.filter((f) => supportedLinearFormats.includes(f)), this.effort, eanAddOnSymbol);
+            additionalMs += performance.now() - extraStart;
+            for (const read of preLinear.barcodes) {
+                const error = read.error ?? Infinity;
+                const checked = ["EAN8", "UPCE", "Code128"].includes(read.format) && read.support >= 3 && error <= 0.08;
+                const unchecked = ["Code39", "ITF"].includes(read.format) &&
+                    read.support >= 8 &&
+                    error <= 0.035 &&
+                    read.text.length >= 8;
+                if (checked || unchecked)
+                    coverage.push(read.polygon);
+            }
+        }
         if (formats.includes("EAN13") || formats.includes("UPCA")) {
+            if (!medium)
+                throw Error("EAN13 engine has not been initialized.");
             const begin = performance.now();
-            const found = medium.scanLocalized(image, policy, fitLimits[this.mode], true);
+            const found = medium instanceof ReleaseDetailScanner
+                ? medium.scanLocalized(image, scanPolicy, fitLimits[this.mode], true, coverage)
+                : medium.scanLocalized(image, scanPolicy, fitLimits[this.mode], true);
+            primary = found;
             const localization = found.localization;
             proposals = localization.proposals;
             localizationMs = found.localizationMs;
@@ -122,8 +175,10 @@ export class MediumMultiformatScanner {
             mediumMs = performance.now() - begin;
         }
         if (localized && !formats.includes("EAN13") && !formats.includes("UPCA")) {
+            if (!medium)
+                throw Error("EAN13 localization engine has not been initialized.");
             const begin = performance.now();
-            const found = medium.scanLocalized(image, policy, fitLimits[this.mode], true)
+            const found = medium.scanLocalized(image, scanPolicy, fitLimits[this.mode], true)
                 .localization;
             proposals = found.proposals;
             unfinished ||= Boolean(found.workLimited) || (found.omitted ?? 0) > 0;
@@ -131,38 +186,70 @@ export class MediumMultiformatScanner {
         }
         // UPC-A has the same optical structure as zero-prefixed EAN13, so the
         // frozen Medium reader handles it without a second optical search.
-        const extraFormats = formats.filter((f) => eanAddOnSymbol !== "Ignore" || (f !== "EAN13" && f !== "UPCA"));
         if (extraFormats.length) {
             if (!this.extra || !this.handle)
                 throw Error("Additional readers have not been loaded.");
             const begin = performance.now();
-            const gray = toGray(image);
-            preparationMs = performance.now() - begin;
+            const rgba = this.rgba &&
+                !localized &&
+                formats.length === 1 &&
+                formats[0] === "QRCode" &&
+                channels === 4 &&
+                stride === width * 4;
+            const gray = preparedGray ?? (rgba ? data.subarray(0, width * height * 4) : scanGray(image));
+            preparationMs += performance.now() - begin;
             const matrixFormats = extraFormats.filter((f) => !supportedLinearFormats.includes(f));
             const linearFormats = extraFormats.filter((f) => supportedLinearFormats.includes(f));
             const run = (pixels, w, h, enabled, effort) => {
                 const start = performance.now();
-                const result = this.scanExtra(pixels, w, h, enabled, effort, eanAddOnSymbol);
+                const result = this.scanExtra(pixels, w, h, enabled, effort, eanAddOnSymbol, rgba);
                 additionalMs += performance.now() - start;
                 unfinished ||= result.unfinished;
                 return result;
             };
             if (!localized || !proposals.length) {
-                const result = run(gray, width, height, extraFormats, 1);
-                barcodes.push(...result.barcodes);
-                regions.push(...(result.regions ?? []));
+                for (const [enabled, effort] of [
+                    [linearFormats, this.effort],
+                    [matrixFormats, matrixFormats.includes("QRCode") ? this.qrEffort : 1],
+                ]) {
+                    if (!enabled.length)
+                        continue;
+                    const result = enabled === linearFormats && preLinear
+                        ? preLinear
+                        : run(gray, width, height, enabled, effort);
+                    unfinished ||= result.unfinished;
+                    barcodes.push(...result.barcodes);
+                    regions.push(...(result.regions ?? []));
+                }
             }
             else {
                 if (matrixFormats.length) {
-                    const result = run(gray, width, height, matrixFormats, 1);
+                    const result = run(gray, width, height, matrixFormats, matrixFormats.includes("QRCode") ? this.qrEffort : 1);
                     barcodes.push(...result.barcodes);
                     regions.push(...(result.regions ?? []));
                 }
+                if (this.crop) {
+                    this.extra.multi_prepare(this.handle, width, height);
+                    new Uint8Array(this.extra.memory.buffer, this.extra.multi_input(this.handle), width * height).set(gray);
+                    if (this.extra.multi_capture_source(this.handle) !== 0)
+                        throw Error("Could not retain source image.");
+                }
                 for (const proposal of proposals) {
                     const start = performance.now();
                     let crop;
+                    let pixels;
                     try {
-                        crop = rectify(gray, width, height, proposal.polygon);
+                        if (this.crop) {
+                            crop = rectificationPlan(proposal.polygon);
+                            new Float64Array(this.extra.memory.buffer, this.extra.multi_crop_transform(this.handle), 8).set(crop.transform);
+                            if (this.extra.multi_crop(this.handle, crop.width, crop.height) !== 0)
+                                throw Error("Could not sample barcode crop.");
+                        }
+                        else {
+                            const sampled = rectify(gray, width, height, proposal.polygon);
+                            crop = sampled;
+                            pixels = sampled.data;
+                        }
                     }
                     catch {
                         unfinished = true;
@@ -170,7 +257,14 @@ export class MediumMultiformatScanner {
                         continue;
                     }
                     preparationMs += performance.now() - start;
-                    const result = run(crop.data, crop.width, crop.height, linearFormats, 0);
+                    const decodeStart = performance.now();
+                    const result = pixels
+                        ? run(pixels, crop.width, crop.height, linearFormats, 0)
+                        : this.scanPrepared(linearFormats, 0, eanAddOnSymbol);
+                    if (!pixels) {
+                        additionalMs += performance.now() - decodeStart;
+                        unfinished ||= result.unfinished;
+                    }
                     const reads = result.barcodes;
                     if (!reads.length)
                         regions.push({ format: "Unknown", text: "", polygon: proposal.polygon, support: 0 });
@@ -210,11 +304,14 @@ export class MediumMultiformatScanner {
             const remaining = regions.filter((region) => !barcodes.some((b) => polygonOverlap(region.polygon, b.polygon).a >= 0.65));
             regions.splice(0, regions.length, ...distinctReads(remaining));
         }
+        const mergedLinear = mergeLinearDuplicates(barcodes, image);
+        barcodes.splice(0, barcodes.length, ...mergedLinear);
         barcodes.sort((a, b) => b.support - a.support);
         barcodes.forEach((b, i) => {
             b.rank = i + 1;
         });
         return {
+            primary,
             barcodes,
             eanAddOnSymbol,
             regions: [...barcodes, ...regions],
@@ -228,16 +325,22 @@ export class MediumMultiformatScanner {
             linearStrategy,
         };
     }
-    scanExtra(gray, width, height, formats, effort, eanAddOnSymbol) {
+    scanExtra(gray, width, height, formats, effort, eanAddOnSymbol, rgba = false) {
         const e = this.extra;
         if (!e || !this.handle)
             throw Error("Additional readers have not been loaded.");
-        if (e.multi_prepare(this.handle, width, height) !== 0)
+        if ((rgba ? e.multi_prepare_rgba : e.multi_prepare)(this.handle, width, height) !== 0)
             throw Error("Additional reader rejected image size.");
-        new Uint8Array(e.memory.buffer, e.multi_input(this.handle), width * height).set(gray);
+        new Uint8Array(e.memory.buffer, (rgba ? e.multi_input_rgba : e.multi_input)(this.handle), width * height * (rgba ? 4 : 1)).set(gray);
+        return this.scanPrepared(formats, effort, eanAddOnSymbol, rgba);
+    }
+    scanPrepared(formats, effort, eanAddOnSymbol, rgba = false) {
+        const e = this.extra;
+        if (!e || !this.handle)
+            throw Error("Additional readers have not been loaded.");
         const mask = maskFor(formats) |
             (eanAddOnSymbol === "Read" ? 32768 : eanAddOnSymbol === "Require" ? 65536 : 0);
-        if (e.multi_scan(this.handle, mask, effort) !== 0)
+        if ((rgba ? e.multi_scan_rgba : e.multi_scan)(this.handle, mask, effort) !== 0)
             throw Error("Additional scanner failed.");
         const bytes = new Uint8Array(e.memory.buffer, e.multi_output(this.handle), e.multi_output_len(this.handle));
         const found = JSON.parse(new TextDecoder().decode(bytes));

package/examples/camera.html

@@ -0,0 +1,63 @@
+<!doctype html>
+<html lang="en">
+  <meta charset="utf-8" />
+  <title>Tapirscan worker example</title>
+  <button id="start">Start camera</button>
+  <button id="stop" disabled>Stop</button>
+  <video autoplay muted playsinline style="max-width: 100%"></video>
+  <pre role="status"></pre>
+  <script type="module">
+    import { createScannerWorker } from "./worker-client.mjs";
+    const video = document.querySelector("video");
+    const status = document.querySelector("pre");
+    const start = document.querySelector("#start");
+    const stop = document.querySelector("#stop");
+    const canvas = document.createElement("canvas");
+    const context = canvas.getContext("2d", { willReadFrequently: true });
+    let running = false;
+    let scanner;
+    let stream;
+    function shutdown() {
+      running = false;
+      scanner?.dispose();
+      scanner = undefined;
+      stream?.getTracks().forEach((track) => track.stop());
+      stream = undefined;
+      video.srcObject = null;
+    }
+    start.onclick = async () => {
+      start.disabled = true;
+      running = true;
+      try {
+        scanner = await createScannerWorker({ formats: ["EAN13", "QRCode"] });
+        if (!running) return;
+        stream = await navigator.mediaDevices.getUserMedia({
+          video: { facingMode: "environment" },
+        });
+        if (!running) return;
+        video.srcObject = stream;
+        await video.play();
+        stop.disabled = false;
+        while (running) {
+          canvas.width = video.videoWidth;
+          canvas.height = video.videoHeight;
+          context.drawImage(video, 0, 0);
+          const result = await scanner.scan(
+            context.getImageData(0, 0, canvas.width, canvas.height),
+          );
+          status.textContent = JSON.stringify(result.values);
+          // Backpressure: capture only after the previous scan has completed.
+          await new Promise(requestAnimationFrame);
+        }
+      } catch (error) {
+        if (running) status.textContent = error.message;
+      } finally {
+        shutdown();
+        start.disabled = false;
+        stop.disabled = true;
+      }
+    };
+    stop.onclick = shutdown;
+    window.addEventListener("pagehide", shutdown);
+  </script>
+</html>

package/examples/scan-worker.mjs

@@ -0,0 +1,20 @@
+// Serve this directory alongside ../dist and ../wasm, or adapt the import for your bundler.
+import { Scanner } from "../dist/index.js";
+
+let scanner;
+self.onmessage = async ({ data: { id, type, options, image } }) => {
+  try {
+    if (type === "init") {
+      if (scanner) throw Error("Scanner already initialized");
+      scanner = await Scanner.create(options);
+      self.postMessage({ id });
+    } else if (type === "scan") {
+      if (!scanner) throw Error("Scanner not initialized");
+      self.postMessage({ id, result: scanner.scan(image, options) });
+    } else {
+      throw Error(`Unknown worker request: ${type}`);
+    }
+  } catch (error) {
+    self.postMessage({ id, error: { message: error.message, code: error.code } });
+  }
+};

package/examples/worker-client.mjs

@@ -0,0 +1,63 @@
+/** Initialize once. scan() transfers ownership of the supplied pixel buffer.
+ * Await each scan before capturing the next frame; dispose() stops the worker.
+ * Structured cloning yields independent mutable results on the receiving side.
+ */
+export async function createScannerWorker(options = {}) {
+  const worker = new Worker(new URL("./scan-worker.mjs", import.meta.url), { type: "module" });
+  let pending;
+  let nextId = 0;
+  let closed = false;
+  function dispose(reason = Error("Scanner worker disposed")) {
+    if (closed) return;
+    closed = true;
+    worker.terminate();
+    pending?.reject(reason);
+    pending = undefined;
+  }
+  worker.onerror = (event) => dispose(Error(event.message || "Scanner worker failed"));
+  worker.onmessageerror = () => dispose(Error("Could not deserialize scanner result"));
+  worker.onmessage = ({ data }) => {
+    if (!pending || pending.id !== data.id) return;
+    const { resolve, reject } = pending;
+    pending = undefined;
+    if (data.error) reject(Object.assign(Error(data.error.message), { code: data.error.code }));
+    else resolve(data.result);
+  };
+  function request(type, message, transfer = []) {
+    if (closed) return Promise.reject(Error("Scanner worker disposed"));
+    if (pending)
+      return Promise.reject(Error("Await the previous scan before sending another frame"));
+    return new Promise((resolve, reject) => {
+      const id = nextId++;
+      pending = { id, resolve, reject };
+      try {
+        worker.postMessage({ id, type, ...message }, transfer);
+      } catch (error) {
+        pending = undefined;
+        reject(error);
+      }
+    });
+  }
+  try {
+    await request("init", { options });
+  } catch (error) {
+    dispose(error);
+    throw error;
+  }
+  return {
+    scan(image, options = {}) {
+      // Send explicit storage settings; ImageData's prototype is not required in the worker.
+      const pixels = {
+        data: image.data,
+        width: image.width,
+        height: image.height,
+        channels: image.channels ?? 4,
+        stride: image.stride,
+      };
+      return request("scan", { image: pixels, options }, [image.data.buffer]);
+    },
+    dispose() {
+      dispose();
+    },
+  };
+}