tapirscan 1.2.1 → 1.2.2

package/README.md

@@ -91,11 +91,12 @@ The one-shot helper accepts the same option:
 URLs resolve against the page/worker URL in browsers and the package module in
 Node; use an absolute URL for an unambiguous location. For authenticated requests
 or custom storage, use `loadWasm: async (url) => arrayBuffer`. The callback receives
-URLs resolved against `wasmBaseUrl` when both options are supplied. Only engines needed by the selected formats are loaded.
+URLs resolved against `wasmBaseUrl` when both options are supplied. Creation loads
+one complete Rust scanner for the selected effort mode.
 
 Use the deployed base path if your app is hosted below a subpath. Copy all current
-WASMs: EAN13/UPCA scanning in Medium/High/Very high also loads the Low recovery decoder. The demo and its
-comparison engines are not needed in your app.
+WASMs so every effort mode remains available. The demo and its comparison engines
+are not needed in your app.
 
 ## Camera and worker use
 
@@ -200,6 +201,9 @@ including separate copies of the same value. Coordinates start at the
 top left, x rightward and y downward. Geometry is returned, not a cropped bitmap.
 Map coordinates back yourself if you resize/rotate before scanning. Support is a
 ranking heuristic, not a probability.
+Polygon coordinates are Rust `f32` values exposed as JavaScript numbers. Their
+decimal string form may show the exact binary value instead of the shorter
+decimal spelling used by older package builds.
 
 The package exports `EanAddOnPolicy`, `ScannerOptions`, `ScanOptions`, `ScanResult`, `Barcode`,
 `PixelImage`, `Image`, `Quad`, `Mode`, `Format`, `FormatSelection`, `Diagnostics`,

package/dist/index.d.ts

@@ -1,17 +1,13 @@
-import type { Recovery, DetailRegion } from "./detail-20260914/scanner.mjs";
-import { type Barcode as FormatBarcode } from "./multiformat/scanner.js";
 import { type Format, type FormatSelection } from "./multiformat/formats.js";
 export { commonFormats, commonLinearFormats, formatBits, linearFormats, matrixFormats, retailFormats, } from "./multiformat/formats.js";
 export type { Format, FormatSelection } from "./multiformat/formats.js";
-import { type ScanFrame, type Quad as HostQuad } from "./completion-host.mjs";
-/** Source-image corners, in pixels. */
+export { ScannerError } from "./rust-session.js";
 export type Quad = readonly [
     readonly [number, number],
     readonly [number, number],
     readonly [number, number],
     readonly [number, number]
 ];
-/** Decoded pixels; stride defaults to width * channels. Alpha is ignored. */
 export interface Image {
     readonly data: Uint8Array;
     readonly width: number;
@@ -19,58 +15,56 @@ export interface Image {
     readonly channels: 1 | 3 | 4;
     readonly stride?: number;
 }
-export { ScannerError } from "./completion-host.mjs";
-type RawDiagnosticBarcode = FormatBarcode | (ScanFrame["barcodes"][number] & {
-    format: "EAN13";
-});
 export type Mode = "low" | "medium" | "high" | "very-high";
 export interface ScanOptions {
     /** Allow reader-specific extra work. Supported for every format; exact budgets may evolve. */
     extendedBudget?: boolean;
     /** Per-call subset of the formats configured at creation. */
     formats?: FormatSelection;
+    /** Include raw engine diagnostics. Public barcodes and unread geometry are always included. */
     debug?: boolean;
 }
 interface RawDiagnostics {
-    schemaVersion: 2;
-    mode: Mode;
-    multiple: boolean;
-    elapsedMs: number;
-    localizationLimited: boolean;
     scan: {
         barcodes: RawDiagnosticBarcode[];
         unfinished: boolean;
-        regions?: FormatBarcode[];
-    } & Partial<Omit<ScanFrame, "barcodes" | "unfinished">>;
+        candidates?: unknown[];
+    };
     localization?: {
         proposals: {
-            polygon: HostQuad;
-            score: number;
-            text: string;
+            polygon: Quad;
+            score?: number;
+            text?: string;
         }[];
-        omitted: number;
-        workLimited: boolean;
-        trace?: Record<string, number>;
     };
-    recovery?: Recovery;
-    detailRegions?: DetailRegion[];
     searchWindows?: {
         kind: string;
         polygon: number[][];
         candidateIndex: number;
     }[];
+    [key: string]: unknown;
 }
-/** Deeply immutable scan evidence, independent of the scanner lifetime. */
 type ReadonlyDeep<T> = T extends object ? {
     readonly [K in keyof T]: ReadonlyDeep<T[K]>;
 } : T;
+interface RawDiagnosticBarcode {
+    text: string;
+    format: Format | "Unknown";
+    polygon: Quad;
+    support: number;
+    bytes?: number[];
+    candidate_indices?: number[];
+    gs1?: boolean;
+    readerInitialization?: boolean;
+    structuredAppend?: StructuredAppend;
+    eanAddOn?: string;
+    [key: string]: unknown;
+}
 export type DiagnosticBarcode = ReadonlyDeep<RawDiagnosticBarcode>;
-/** Source geometry with no accepted decode; format is a reader hint. */
 export interface UndecodedRegion {
     readonly format: Format | "Unknown";
     readonly polygon: Quad;
 }
-/** Stable region evidence. null means this reader did not expose that evidence. */
 export interface RegionEvidence {
     readonly proposals: ReadonlyDeep<NonNullable<RawDiagnostics["localization"]>["proposals"]> | null;
     readonly searchWindows: ReadonlyDeep<NonNullable<RawDiagnostics["searchWindows"]>> | null;
@@ -80,7 +74,6 @@ export type Diagnostics = ReadonlyDeep<RawDiagnostics> & {
     readonly regions: RegionEvidence;
 };
 export interface StructuredAppend {
-    /** One-based symbol index; symbols are not automatically assembled. */
     readonly index: number;
     readonly count: number;
     readonly id?: string;
@@ -115,6 +108,7 @@ export interface ScanResult {
         readonly height: number;
     };
     readonly mode: Mode;
+    /** Whole synchronous WASM call time measured by the JavaScript host. */
     readonly elapsedMs: number;
     readonly unfinished: boolean;
     readonly undecoded: readonly UndecodedRegion[];
@@ -132,7 +126,7 @@ export interface ScannerOptions {
     loadWasm?: (url: URL) => Promise<ArrayBuffer>;
 }
 export type PixelImage = Image | Pick<ImageData, "data" | "width" | "height">;
-/** Mode selects a compiled implementation. Create another instance to switch. */
+/** A reusable scanner. Results own their data and remain valid after later scans or disposal. */
 export declare class Scanner {
     private readonly host;
     readonly mode: Mode;
@@ -144,6 +138,7 @@ export declare class Scanner {
     get eanAddOnPolicy(): EanAddOnPolicy;
     static create(options?: ScannerOptions): Promise<Scanner>;
     scan(inputImage: PixelImage, options?: ScanOptions): ScanResult;
+    /** Release the WASM session. Repeated disposal is safe; scanning afterward fails. */
     dispose(): void;
 }
 /** Scan one image with automatic cleanup. Reuse Scanner for a stream of images. */

package/dist/index.js

@@ -1,11 +1,14 @@
-import { mergeLinearDuplicates } from "./multiformat/linear-duplicates.js";
-import { ReleaseDetailScanner, fitLimits } from "./detail.js";
-import { policy } from "./policy.js";
-import { MediumMultiformatScanner } from "./multiformat/scanner.js";
-import { resolveFormats } from "./multiformat/formats.js";
+import { maskFor, resolveFormats, } from "./multiformat/formats.js";
+import { RustScannerSession, ScannerError } from "./rust-session.js";
 export { commonFormats, commonLinearFormats, formatBits, linearFormats, matrixFormats, retailFormats, } from "./multiformat/formats.js";
-import { IndependentScanner, } from "./completion-host.mjs";
-export { ScannerError } from "./completion-host.mjs";
+export { ScannerError } from "./rust-session.js";
+const modes = {
+    low: { id: 0, file: "low-release-1.2.2-public-low-r2.wasm" },
+    medium: { id: 1, file: "medium-release-1.2.2-public-low-r2.wasm" },
+    high: { id: 2, file: "high-release-1.2.2-public-low-r2.wasm" },
+    "very-high": { id: 3, file: "very-high-release-1.2.2-public-low-r2.wasm" },
+};
+const addOnPolicies = { Ignore: 0, Read: 1, Require: 2 };
 function pixels(image) {
     const input = image;
     if (input === null || typeof input !== "object")
@@ -36,7 +39,6 @@ function pixels(image) {
         stride,
     };
 }
-/** Freeze only plain result data, never caller-owned input buffers. */
 function freeze(value) {
     for (const child of Object.values(value))
         if (child !== null && typeof child === "object")
@@ -54,89 +56,58 @@ async function loadDefault(url) {
         throw new Error(`WASM load failed: ${String(response.status)}`);
     return response.arrayBuffer();
 }
-function regionEvidence(raw) {
-    const undecoded = [];
-    if (raw.scan.regions) {
-        for (const region of raw.scan.regions) {
-            if (!raw.scan.barcodes.includes(region))
-                undecoded.push({ format: region.format, polygon: region.polygon });
-        }
-    }
-    else {
-        const decoded = new Set(raw.scan.barcodes.flatMap((b) => ("candidate_indices" in b ? b.candidate_indices : [])));
-        raw.localization?.proposals.forEach((p, i) => {
-            if (!decoded.has(i))
-                undecoded.push({ format: "Unknown", polygon: p.polygon });
-        });
-        for (const attempt of raw.recovery?.attempts ?? []) {
-            const decoded = new Set(attempt.reads.flatMap((b) => b.candidate_indices));
-            attempt.proposals.forEach((p, i) => {
-                if (!decoded.has(i))
-                    undecoded.push({ format: "Unknown", polygon: p.polygon });
-            });
-        }
-    }
-    return {
-        proposals: raw.localization?.proposals ?? null,
-        searchWindows: raw.searchWindows ?? null,
+function wireResult(value) {
+    if (value === null ||
+        typeof value !== "object" ||
+        !("barcodes" in value) ||
+        !Array.isArray(value.barcodes) ||
+        !("bestIndex" in value) ||
+        (value.bestIndex !== null &&
+            (!Number.isInteger(value.bestIndex) ||
+                value.bestIndex < 0 ||
+                value.bestIndex >= value.barcodes.length)) ||
+        !("undecoded" in value) ||
+        !Array.isArray(value.undecoded) ||
+        !("image" in value) ||
+        value.image === null ||
+        typeof value.image !== "object" ||
+        !("mode" in value) ||
+        !Object.hasOwn(modes, String(value.mode)) ||
+        !("unfinished" in value) ||
+        typeof value.unfinished !== "boolean")
+        throw new ScannerError("invalid_output", "Scanner returned an invalid result");
+    return value;
+}
+function publicResult(raw, elapsedMs, debug) {
+    const barcodes = raw.barcodes;
+    const undecoded = raw.undecoded.map(({ format, polygon }) => ({
+        format: format ?? "Unknown",
+        polygon,
+    }));
+    const regions = {
+        proposals: raw.debug?.localization?.proposals ?? null,
+        searchWindows: raw.debug?.searchWindows ?? null,
         undecoded,
     };
-}
-function publicResult(raw, image, debug) {
-    const barcodes = raw.scan.barcodes.map((read) => {
-        const { text, format, polygon, support } = read;
-        const left = Math.floor(Math.min(...polygon.map((p) => p[0])));
-        const top = Math.floor(Math.min(...polygon.map((p) => p[1])));
-        return {
-            text,
-            format,
-            polygon,
-            support,
-            ...("bytes" in read ? { payloadBytes: read.bytes } : {}),
-            ...("gs1" in read ? { gs1: read.gs1 } : {}),
-            ...("readerInitialization" in read
-                ? { readerInitialization: read.readerInitialization }
-                : {}),
-            ...("structuredAppend" in read ? { structuredAppend: read.structuredAppend } : {}),
-            ...("eanAddOn" in read ? { eanAddOn: read.eanAddOn } : {}),
-            rect: {
-                left,
-                top,
-                width: Math.ceil(Math.max(...polygon.map((p) => p[0]))) - left,
-                height: Math.ceil(Math.max(...polygon.map((p) => p[1]))) - top,
-            },
-        };
-    });
-    let bestIndex = -1;
-    for (let i = 0; i < barcodes.length; i++)
-        if (bestIndex < 0 || raw.scan.barcodes[i].support > raw.scan.barcodes[bestIndex].support)
-            bestIndex = i;
-    const regions = regionEvidence(raw);
     return freeze({
         barcodes,
         values: barcodes.map((b) => b.text),
-        best: barcodes[bestIndex],
-        undecoded: regions.undecoded,
-        image: { width: image.width, height: image.height },
+        best: raw.bestIndex === null ? undefined : barcodes[raw.bestIndex],
+        image: raw.image,
         mode: raw.mode,
-        elapsedMs: raw.elapsedMs,
-        unfinished: raw.scan.unfinished || raw.localizationLimited || (raw.localization?.omitted ?? 0) > 0,
-        ...(debug ? { debug: { ...raw, regions } } : {}),
+        elapsedMs,
+        unfinished: raw.unfinished,
+        undecoded,
+        ...(debug && raw.debug ? { debug: { ...raw.debug, regions } } : {}),
     });
 }
-const modes = {
-    low: "low-shared-retail-portable-20260919.wasm",
-    medium: "medium-shared-retail-portable-20260919.wasm",
-    high: "high-shared-retail-portable-20260919.wasm",
-    "very-high": "very-high-shared-retail-portable-20260919.wasm",
-};
-/** Mode selects a compiled implementation. Create another instance to switch. */
+/** A reusable scanner. Results own their data and remain valid after later scans or disposal. */
 export class Scanner {
     host;
     mode;
     configuredFormats;
     addOnPolicy;
-    constructor(host, mode, configuredFormats = resolveFormats(), addOnPolicy = "Ignore") {
+    constructor(host, mode, configuredFormats, addOnPolicy) {
         this.host = host;
         this.mode = mode;
         this.configuredFormats = configuredFormats;
@@ -161,8 +132,8 @@ export class Scanner {
         if (!Object.hasOwn(modes, mode))
             throw new TypeError("Unknown scanner mode");
         const formats = resolveFormats(options.formats);
-        const addonPolicy = options.eanAddOnPolicy === undefined ? "Ignore" : options.eanAddOnPolicy;
-        if (!["Ignore", "Read", "Require"].includes(addonPolicy))
+        const addOnPolicy = options.eanAddOnPolicy === undefined ? "Ignore" : options.eanAddOnPolicy;
+        if (!Object.hasOwn(addOnPolicies, addOnPolicy))
             throw new TypeError("eanAddOnPolicy must be Ignore, Read or Require");
         if (options.loadWasm !== undefined && typeof options.loadWasm !== "function")
             throw new TypeError("loadWasm must be a function");
@@ -175,24 +146,10 @@ export class Scanner {
             : new URL(options.wasmBaseUrl, typeof location === "undefined" ? import.meta.url : location.href);
         if (!base.pathname.endsWith("/"))
             base.pathname += "/";
-        const load = options.loadWasm ?? loadDefault;
-        const sharedRetail = mode === "medium" && addonPolicy === "Ignore";
-        const needsPrimary = formats.some((f) => f === "EAN13" || f === "UPCA" || (sharedRetail && (f === "EAN8" || f === "UPCE")));
-        const bytes = needsPrimary ? await load(new URL(modes[mode], base)) : undefined;
-        const recovery = !needsPrimary || mode === "low" ? undefined : await load(new URL(modes.low, base));
-        const multiformat = addonPolicy !== "Ignore" || formats.length !== 1 || formats[0] !== "EAN13";
-        const extra = addonPolicy !== "Ignore" ||
-            formats.some((f) => f !== "EAN13" && f !== "UPCA" && (!sharedRetail || (f !== "EAN8" && f !== "UPCE")))
-            ? await load(new URL("multiformat.wasm", base))
-            : undefined;
-        if (multiformat)
-            return new Scanner(await MediumMultiformatScanner.create(bytes, extra, mode, recovery), mode, formats, addonPolicy);
-        if (!bytes)
-            throw new Error("EAN13 engine was not loaded");
-        const host = recovery
-            ? await ReleaseDetailScanner.create(bytes, recovery, mode)
-            : await IndependentScanner.create(bytes);
-        return new Scanner(host, mode, formats);
+        const selected = modes[mode];
+        const bytes = await (options.loadWasm ?? loadDefault)(new URL(selected.file, base));
+        const host = await RustScannerSession.create(bytes, selected.id, maskFor(formats), addOnPolicies[addOnPolicy]);
+        return new Scanner(host, mode, formats, addOnPolicy);
     }
     scan(inputImage, options = {}) {
         const image = pixels(inputImage);
@@ -200,73 +157,24 @@ export class Scanner {
         if (input === null || typeof input !== "object" || Array.isArray(input))
             throw new TypeError("Invalid scan options");
         for (const key of Object.keys(options))
-            if (key !== "debug" && key !== "formats" && key !== "extendedBudget")
+            if (!["debug", "formats", "extendedBudget"].includes(key))
                 throw new TypeError(`Unknown scan option: ${key}`);
         if (options.debug !== undefined && typeof options.debug !== "boolean")
             throw new TypeError("debug must be a boolean");
         if (options.extendedBudget !== undefined && typeof options.extendedBudget !== "boolean")
             throw new TypeError("extendedBudget must be a boolean");
-        const finishCandidates = options.extendedBudget ?? false;
-        const debug = options.debug ?? false;
-        const scanPolicy = { ...policy, finishCandidates };
         const formats = options.formats === undefined ? this.formats : resolveFormats(options.formats);
         if (formats.some((format) => !this.formats.includes(format)))
             throw new TypeError(`Scan formats must be a subset of configured formats. Requested: ${formats.join(", ")}; configured: ${this.formats.join(", ")}`);
-        if (this.host instanceof MediumMultiformatScanner) {
-            const frame = this.host.scan(image, formats, {
-                eanAddOnSymbol: this.eanAddOnPolicy,
-                finishCandidates,
-            });
-            const barcodes = frame.barcodes;
-            const primary = frame.primary;
-            const localization = primary?.localization;
-            return publicResult({
-                schemaVersion: 2,
-                mode: this.mode,
-                multiple: true,
-                elapsedMs: frame.scanMs,
-                // Preserve the aggregate limit flag when additional readers cannot separate causes.
-                localizationLimited: frame.unfinished,
-                scan: {
-                    ...primary?.scan,
-                    barcodes,
-                    unfinished: frame.unfinished,
-                    regions: frame.regions,
-                },
-                ...(primary
-                    ? {
-                        localization,
-                        searchWindows: primary.searchWindows,
-                        ...("recovery" in primary ? { recovery: primary.recovery } : {}),
-                        ...("detailRegions" in primary ? { detailRegions: primary.detailRegions } : {}),
-                    }
-                    : {}),
-            }, image, debug);
-        }
-        const full = this.host.scanLocalized(image, scanPolicy, fitLimits[this.mode], true);
-        // Isolate the imported host's JSON result at the public ABI type boundary.
-        const localization = full.localization;
-        const barcodes = mergeLinearDuplicates(full.scan.barcodes.map((b) => ({
-            ...b,
-            format: "EAN13",
-        })), image);
-        return publicResult({
-            schemaVersion: 2,
-            mode: this.mode,
-            multiple: true,
-            elapsedMs: full.scanMs,
-            localizationLimited: localization.workLimited || localization.omitted > 0,
-            scan: { ...full.scan, barcodes },
-            localization,
-            searchWindows: full.searchWindows,
-            ...("recovery" in full && "detailRegions" in full
-                ? {
-                    recovery: full.recovery,
-                    detailRegions: full.detailRegions,
-                }
-                : {}),
-        }, image, debug);
+        const debug = options.debug ?? false;
+        const flags = (options.extendedBudget ? 1 : 0) | (debug ? 2 : 0);
+        const start = performance.now();
+        const raw = wireResult(this.host.scan(image, flags, options.formats === undefined ? 0 : maskFor(formats)));
+        if (debug && !raw.debug)
+            throw new ScannerError("invalid_output", "Scanner omitted requested diagnostics");
+        return publicResult(raw, performance.now() - start, debug);
     }
+    /** Release the WASM session. Repeated disposal is safe; scanning afterward fails. */
     dispose() {
         this.host.dispose();
     }

package/dist/multiformat/format-registry.d.ts

@@ -0,0 +1,26 @@
+export declare const formatBits: {
+    readonly EAN13: 1;
+    readonly UPCA: 2;
+    readonly EAN8: 4;
+    readonly UPCE: 8;
+    readonly Code128: 16;
+    readonly Code39: 32;
+    readonly ITF: 64;
+    readonly Codabar: 128;
+    readonly Code93: 256;
+    readonly QRCode: 512;
+    readonly DataMatrix: 1024;
+    readonly PDF417: 2048;
+    readonly Aztec: 4096;
+    readonly DataBar: 8192;
+    readonly DataBarExpanded: 16384;
+    readonly MaxiCode: 131072;
+};
+export type Format = keyof typeof formatBits;
+export declare const retailFormats: readonly Format[];
+export declare const commonLinearFormats: readonly Format[];
+export declare const commonFormats: readonly Format[];
+export declare const linearFormats: readonly Format[];
+export declare const matrixFormats: readonly Format[];
+export declare const eanAddOnReadFlag = 32768;
+export declare const eanAddOnRequireFlag = 65536;

package/dist/multiformat/format-registry.js

@@ -0,0 +1,62 @@
+// Generated by scripts/generate_formats.py from config/formats.json. Do not edit.
+export const formatBits = {
+    EAN13: 1,
+    UPCA: 2,
+    EAN8: 4,
+    UPCE: 8,
+    Code128: 16,
+    Code39: 32,
+    ITF: 64,
+    Codabar: 128,
+    Code93: 256,
+    QRCode: 512,
+    DataMatrix: 1024,
+    PDF417: 2048,
+    Aztec: 4096,
+    DataBar: 8192,
+    DataBarExpanded: 16384,
+    MaxiCode: 131072,
+};
+export const retailFormats = ["EAN13", "UPCA", "EAN8", "UPCE"];
+export const commonLinearFormats = [
+    "EAN13",
+    "UPCA",
+    "EAN8",
+    "UPCE",
+    "Code128",
+    "Code39",
+    "ITF",
+];
+export const commonFormats = [
+    "EAN13",
+    "UPCA",
+    "EAN8",
+    "UPCE",
+    "Code128",
+    "Code39",
+    "ITF",
+    "QRCode",
+    "DataMatrix",
+];
+export const linearFormats = [
+    "EAN13",
+    "UPCA",
+    "EAN8",
+    "UPCE",
+    "Code128",
+    "Code39",
+    "ITF",
+    "Codabar",
+    "Code93",
+    "DataBar",
+    "DataBarExpanded",
+];
+export const matrixFormats = [
+    "QRCode",
+    "DataMatrix",
+    "PDF417",
+    "Aztec",
+    "MaxiCode",
+];
+export const eanAddOnReadFlag = 32768;
+export const eanAddOnRequireFlag = 65536;

package/dist/multiformat/formats.d.ts

@@ -1,28 +1,6 @@
 /** Explicit opt-in formats for the independent Medium extension. */
-export declare const formatBits: {
-    readonly EAN13: 1;
-    readonly UPCA: 2;
-    readonly EAN8: 4;
-    readonly UPCE: 8;
-    readonly Code128: 16;
-    readonly Code39: 32;
-    readonly ITF: 64;
-    readonly Codabar: 128;
-    readonly Code93: 256;
-    readonly QRCode: 512;
-    readonly DataMatrix: 1024;
-    readonly PDF417: 2048;
-    readonly Aztec: 4096;
-    readonly DataBar: 8192;
-    readonly DataBarExpanded: 16384;
-    readonly MaxiCode: 131072;
-};
-export type Format = keyof typeof formatBits;
-export declare const retailFormats: readonly Format[];
-export declare const commonLinearFormats: readonly Format[];
-export declare const commonFormats: readonly Format[];
-export declare const linearFormats: readonly Format[];
-export declare const matrixFormats: readonly Format[];
+import { commonFormats, commonLinearFormats, formatBits, linearFormats, matrixFormats, retailFormats, type Format } from "./format-registry.js";
+export { commonFormats, commonLinearFormats, formatBits, linearFormats, matrixFormats, retailFormats, type Format, };
 export type FormatSelection = Format | readonly Format[] | "retail" | "common1D" | "common" | "1D" | "2D" | "all";
 export declare function resolveFormats(input?: readonly string[] | string): Format[];
 export declare function maskFor(formats: readonly Format[]): number;

package/dist/multiformat/formats.js

@@ -1,44 +1,6 @@
 /** Explicit opt-in formats for the independent Medium extension. */
-export const formatBits = {
-    EAN13: 1,
-    UPCA: 2,
-    EAN8: 4,
-    UPCE: 8,
-    Code128: 16,
-    Code39: 32,
-    ITF: 64,
-    Codabar: 128,
-    Code93: 256,
-    QRCode: 512,
-    DataMatrix: 1024,
-    PDF417: 2048,
-    Aztec: 4096,
-    DataBar: 8192,
-    DataBarExpanded: 16384,
-    MaxiCode: 131072,
-};
-export const retailFormats = ["EAN13", "UPCA", "EAN8", "UPCE"];
-export const commonLinearFormats = [
-    ...retailFormats,
-    "Code128",
-    "Code39",
-    "ITF",
-];
-export const commonFormats = [...commonLinearFormats, "QRCode", "DataMatrix"];
-export const linearFormats = [
-    ...commonLinearFormats,
-    "Codabar",
-    "Code93",
-    "DataBar",
-    "DataBarExpanded",
-];
-export const matrixFormats = [
-    "QRCode",
-    "DataMatrix",
-    "PDF417",
-    "Aztec",
-    "MaxiCode",
-];
+import { commonFormats, commonLinearFormats, formatBits, linearFormats, matrixFormats, retailFormats, } from "./format-registry.js";
+export { commonFormats, commonLinearFormats, formatBits, linearFormats, matrixFormats, retailFormats, };
 export function resolveFormats(input) {
     if (input === "retail")
         return [...retailFormats];

package/dist/rust-session.d.ts

@@ -0,0 +1,19 @@
+export declare class ScannerError extends Error {
+    readonly code: string;
+    constructor(code: string, message: string);
+}
+export declare class RustScannerSession {
+    private readonly exports;
+    private handle;
+    private constructor();
+    static create(bytes: ArrayBuffer, mode: number, formats: number, addOnPolicy: number): Promise<RustScannerSession>;
+    scan(image: {
+        data: Uint8Array;
+        width: number;
+        height: number;
+        channels: number;
+        stride: number;
+    }, flags: number, formats: number): unknown;
+    dispose(): void;
+    private activeExports;
+}