@gongbaodd/qr-renderer 0.1.0

package/dist/types/engine/engine.d.ts

@@ -0,0 +1,68 @@
+/**
+ * The editor engine: prepares and assembles posters with session state kept in
+ * memory, so an edit only re-runs what changed. Runs identically in Node
+ * (tests/scripts, sharp-backed imaging) and inside the browser worker (browser
+ * imaging) — it depends on neither platform.
+ *
+ * - Source cache: decoded poster and derived region keyed by the file sha256
+ *   identity; a placement/seed/settings edit re-runs geometry only, a
+ *   content/ecc/style edit regenerates the QR only, a new file re-decodes.
+ * - Stale suppression: latest-revision-wins. When a newer revision arrives
+ *   while an older one is still in flight, the older one's settled result is
+ *   dropped at the outcome boundary — no cancellation machinery is added
+ *   around codecs or detectors.
+ */
+import type { Imaging } from '../core/imaging/types';
+import type { EngineInput, EngineOutcome, PreparedPayload, AssemblePayload, RasterExportPayload } from './types';
+import type { Placement, Settings } from '../schema';
+export declare class EditorEngine {
+    private imaging;
+    private sources;
+    private qrBundles;
+    private latestPrepareRevision;
+    private latestAssemblyRevision;
+    constructor(imaging: Imaging);
+    /** Frees every cached source/QR bundle. */
+    invalidate(): void;
+    /** Step-2 payload for the current editor state. */
+    prepare(input: EngineInput, revision: number): Promise<EngineOutcome<PreparedPayload>>;
+    /** Step-4 payload: the schema-8 report plus Blob artifacts. */
+    assemble(input: EngineInput & {
+        placement: Placement;
+        seed: number;
+        qrMargin: 1;
+        plateCorners: Settings['plateCorners'];
+        regionMargin?: boolean;
+        rimModules?: number;
+        rimRounded?: boolean;
+        ecc?: Settings['ecc'];
+        pixelStyle?: Settings['pixelStyle'];
+        finderMarkers?: Settings['finderMarkers'];
+        markerSub?: Settings['markerSub'];
+        colors?: Settings['colors'];
+    }, revision: number): Promise<EngineOutcome<AssemblePayload>>;
+    /** Render the first verified smaller poster at or above the requested integer module pitch. */
+    exportRaster(input: EngineInput & {
+        placement: Placement;
+        seed: number;
+        qrMargin: 1;
+        plateCorners: Settings['plateCorners'];
+        regionMargin?: boolean;
+        rimModules?: number;
+        rimRounded?: boolean;
+        ecc?: Settings['ecc'];
+        pixelStyle?: Settings['pixelStyle'];
+        finderMarkers?: Settings['finderMarkers'];
+        markerSub?: Settings['markerSub'];
+        colors?: Settings['colors'];
+    }, targetPitch: number, revision: number): Promise<EngineOutcome<RasterExportPayload>>;
+    /** The settle-time revision check is the only stale gate: superseded runs drop here. */
+    private settle;
+    /** Shared prepare/assemble resolution with the source and QR caches applied. */
+    private resolveLayout;
+    /** Poster decode + region detection, keyed by content identity (sha256). */
+    private cachedSource;
+    private evictSources;
+    /** Generated QR bundle keyed by the content and the QR-shaping settings. */
+    private cachedQr;
+}

package/dist/types/engine/index.d.ts

@@ -0,0 +1,34 @@
+/**
+ * Engine entry point. `createEditorEngine` is the only way to build an engine:
+ * callers inject their environment's `Imaging` implementation (sharp in Node,
+ * jSquash + resvg in the browser worker), so no platform leak enters the engine.
+ */
+import type { Imaging } from '../core/imaging/types';
+import { EditorEngine } from './engine';
+import type { EngineOutcome, PreparedPayload, AssemblePayload, RasterExportPayload, EngineInput, EngineError } from './types';
+import type { Placement, Settings } from '../schema';
+export type { EditorEngine };
+export type { EngineOutcome, PreparedPayload, AssemblePayload, RasterExportPayload, EngineInput, EngineError };
+export type { EngineInput as EngineRequest };
+export type AssembleInput = EngineInput & {
+    placement: Placement;
+    seed: number;
+    qrMargin: 1;
+    plateCorners: Settings['plateCorners'];
+    regionMargin?: boolean;
+    rimModules?: number;
+    rimRounded?: boolean;
+    ecc?: Settings['ecc'];
+    pixelStyle?: Settings['pixelStyle'];
+    finderMarkers?: Settings['finderMarkers'];
+    markerSub?: Settings['markerSub'];
+    colors?: Settings['colors'];
+};
+/** The Comlink-exposed surface: every call goes through {@link EngineOutcome}. */
+export interface EditorEngineApi {
+    prepare: (input: EngineInput, revision: number) => Promise<EngineOutcome<PreparedPayload>>;
+    assemble: (input: AssembleInput, revision: number) => Promise<EngineOutcome<AssemblePayload>>;
+    exportRaster: (input: AssembleInput, targetPitch: number, revision: number) => Promise<EngineOutcome<RasterExportPayload>>;
+    invalidate: () => void;
+}
+export declare function createEditorEngine(imaging: Imaging): Promise<EditorEngineApi>;

package/dist/types/engine/mapping.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Error mapping, moved verbatim from the former `src/server/http.ts` catch
+ * block (its route handler dies in phase 5). Every engine entry wraps thrown
+ * domain errors with the same codes and editor-field mapping, so UI error
+ * handling does not change when the pipeline leaves the server.
+ */
+import type { EngineError } from './types';
+export declare class EngineMappingError extends Error {
+    readonly code: string;
+    readonly field: string | undefined;
+    constructor(code: string, message: string, field: string | undefined);
+}
+/** Wraps any thrown error with the editor-facing code/message/field. */
+export declare function toEngineError(error: unknown): EngineError;

package/dist/types/engine/pipeline.d.ts

@@ -0,0 +1,77 @@
+/**
+ * Environment-agnostic prepare/assemble pipeline for the editor. This is a
+ * faithful decomposition of the former `src/server/editor.ts` orchestration;
+ * server specifics (sharp metadata checks, multipart bounds) are replaced by
+ * the shared `png-guard` header checks and the injected `Imaging` backend.
+ *
+ * Keep this module independent of Worker, React, HTTP, and Node: it takes the
+ * `Imaging` implementation as an argument instead of importing a backend.
+ */
+import { normalizeQr } from '../core/qr';
+import { type QrPalette } from '../core/palette';
+import type { Imaging } from '../core/imaging/types';
+import type { LoadedPng } from '../core/image';
+import type { QrMetadata, QrPlacement, RegionMask, ResolvedLayout } from '../core/types';
+import type { Placement, Settings } from '../schema';
+import type { EngineInput, PreparedPayload, AssemblePayload, RasterExportPayload } from './types';
+/** Builds a Blob with the mime type implied by the artifact name (PNG/SVG/JSON). */
+export declare function bytesToBlob(name: string, bytes: Uint8Array): Blob;
+export declare const engineDefaults: Settings;
+/** Client-side replacement for the old sharp-metadata `readImage`. */
+export { normalizeQr };
+export declare function readImage(imaging: Imaging, bytes: Uint8Array, name: string): Promise<LoadedPng>;
+/** Same whole-square constraint and module geometry as assembly; no raster rendering needed. */
+export declare function validatePlacement({ regionMask, qrMetadata, placement, settings, }: {
+    regionMask: RegionMask;
+    qrMetadata: QrMetadata;
+    placement: Placement;
+    settings: Settings;
+}): QrPlacement;
+/** The decoded poster and its region: the expensive, source-bound half of resolveBuffers. */
+export interface PreparedSource {
+    poster: LoadedPng;
+    maskInput?: LoadedPng;
+    regionMask: RegionMask;
+}
+export declare function prepareSource(imaging: Imaging, posterBytes: Uint8Array, maskBytes?: Uint8Array): Promise<PreparedSource>;
+/** The content-bound half: the generated QR, its decode round trip, and metadata. */
+export interface QrBundle {
+    qrSource: LoadedPng;
+    decoded: ResolvedLayout['decoded'];
+    qrMetadata: QrMetadata;
+}
+export declare function resolveQr(imaging: Imaging, input: EngineInput): Promise<QrBundle>;
+/** Verbatim placement/recentering/fit logic from the former `resolveBuffers`. */
+export declare function applyPlacement({ source, qr, input, settings, unchecked, }: {
+    source: PreparedSource;
+    qr: QrBundle;
+    input: Pick<EngineInput, 'placement' | 'previousTotalModules'>;
+    settings: Settings;
+    unchecked?: boolean;
+}): {
+    layout: ResolvedLayout;
+    validation: string | null;
+    bestPlacement: Placement;
+};
+/** Straight composition of the three stages — the uncached path, used by tests and scripts. */
+export declare function resolveBuffers(imaging: Imaging, input: EngineInput): Promise<{
+    layout: ResolvedLayout;
+    validation: string | null;
+}>;
+export declare function toPreparedPayload(imaging: Imaging, layout: ResolvedLayout, validation: string | null, palette?: QrPalette, bestPlacement?: Placement): Promise<PreparedPayload>;
+/** Identical request merge and verification gate as the former `assembleFromBuffers`. */
+export declare function assemblePayload(imaging: Imaging, input: EngineInput & {
+    placement: Placement;
+    seed: number;
+    qrMargin: 1;
+    plateCorners: Settings['plateCorners'];
+    regionMargin?: boolean;
+    rimModules?: number;
+    rimRounded?: boolean;
+    ecc?: Settings['ecc'];
+    pixelStyle?: Settings['pixelStyle'];
+    finderMarkers?: Settings['finderMarkers'];
+    markerSub?: Settings['markerSub'];
+    colors?: Settings['colors'];
+}): Promise<AssemblePayload>;
+export declare function assembleRasterVariant(imaging: Imaging, original: ResolvedLayout, settings: Settings, originalPlacement: QrPlacement, targetPitch: number, transparentBlank: boolean): Promise<RasterExportPayload>;

package/dist/types/engine/types.d.ts

@@ -0,0 +1,66 @@
+/**
+ * Engine contracts shared by the Node test harness and the Comlink worker.
+ * Engine operations never throw across an API boundary: they settle to a
+ * discriminated {@link EngineOutcome}, so every consumer (the editor store,
+ * worker client, tests) handles errors and stale runs the same way.
+ */
+import type { Placement, Settings } from '../schema';
+/** An editor-facing error: the exact codes/fields the old HTTP pipeline produced. */
+export interface EngineError {
+    code: string;
+    message: string;
+    /** Editor field the error maps to (`content`, `poster`, `mask`, `placement`). */
+    field?: string | undefined;
+}
+/** Engine input: source bytes plus the current editor revision. */
+export interface EngineInput {
+    posterBytes: Uint8Array;
+    transparentBlank?: boolean;
+    content: string;
+    maskBytes?: Uint8Array;
+    placement?: Placement;
+    previousTotalModules?: number | undefined;
+    settings?: Partial<Settings>;
+}
+/** The step-2 payload: preview artifacts as Blobs (built in the worker; Blobs cross postMessage by reference). */
+export interface PreparedPayload {
+    width: number;
+    height: number;
+    mask: Blob;
+    overlay: Blob;
+    qr: Blob;
+    qrMetadata: {
+        totalModules: number;
+        version: number;
+    };
+    placement: Placement;
+    bestPlacement: Placement;
+    validation: string | null;
+}
+/** The step-4 payload mirrors the schema-8 envelope: report plus Blob artifacts. */
+export interface AssemblePayload {
+    report: import('../core/types').AssembleReport;
+    artifacts: Record<string, Blob>;
+    recipe?: Blob;
+    recipeError?: string;
+}
+export interface RasterExportPayload {
+    poster: Blob;
+    width: number;
+    height: number;
+    modulePixels: number;
+    bytes: number;
+}
+export type EngineOutcome<T> = {
+    ok: true;
+    revision: number;
+    value: T;
+} | {
+    ok: false;
+    stale: true;
+    revision: number;
+} | {
+    ok: false;
+    error: EngineError;
+    revision: number;
+};

package/dist/types/node.d.ts

@@ -0,0 +1,17 @@
+import { type PortableRecipe } from './recipe';
+export type RecipeArtifact = 'poster.png' | 'qr.png';
+export interface RenderRecipeOptions {
+    artifact?: RecipeArtifact;
+}
+export interface RenderRecipeResult {
+    png: Uint8Array;
+    filename: RecipeArtifact;
+}
+/** Render an already parsed editor recipe with the Node.js imaging backend. */
+export declare function renderRecipeJson(rawRecipe: unknown, options?: RenderRecipeOptions): Promise<RenderRecipeResult>;
+/**
+ * Parse and render UTF-8 JSON bytes/string from the editor's recipe export.
+ * Filesystem access stays with the caller so this entry never writes or reads paths.
+ */
+export declare function renderRecipeFile(input: Uint8Array | string, options?: RenderRecipeOptions): Promise<RenderRecipeResult>;
+export type { PortableRecipe };

package/dist/types/png-guard.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Client-side upload guards with the same semantics as the old server `readImage`:
+ * PNG signature, dimensions from IHDR, single-frame (no `acTL` animation chunks),
+ * and the byte/megapixel limits. Parses the header bytes only — no full decode.
+ */
+export type GuardCode = 'PNG_INVALID' | 'UPLOAD_LIMIT';
+/** Thrown with the exact codes the editor UI maps to field errors. */
+export declare class PngGuardError extends Error {
+    readonly code: GuardCode;
+    readonly field: string;
+    constructor(code: GuardCode, message: string, field: string);
+}
+export interface PngHeaderInfo {
+    width: number;
+    height: number;
+}
+export declare function parsePngHeader(bytes: Uint8Array, field: string): PngHeaderInfo;

package/dist/types/recipe.d.ts

@@ -0,0 +1,132 @@
+import { z } from 'zod';
+import type { Imaging } from './core/imaging/types';
+import type { AssembleInput } from './engine/index';
+export declare const RECIPE_FORMAT = "mahu-qr-recipe";
+export declare const RECIPE_SCHEMA_VERSION = 1;
+export declare const RECIPE_RENDERER_VERSION = "mahu-qr-renderer-1";
+export declare const MAX_RECIPE_BYTES: number;
+export declare const recipeSchema: z.ZodObject<{
+    format: z.ZodLiteral<"mahu-qr-recipe">;
+    schemaVersion: z.ZodLiteral<1>;
+    rendererVersion: z.ZodLiteral<"mahu-qr-renderer-1">;
+    content: z.ZodString;
+    source: z.ZodObject<{
+        poster: z.ZodObject<{
+            mimeType: z.ZodLiteral<"image/png">;
+            encoding: z.ZodLiteral<"base64">;
+            sha256: z.ZodString;
+            data: z.ZodString;
+        }, z.core.$strict>;
+        regionMask: z.ZodObject<{
+            mimeType: z.ZodLiteral<"image/png">;
+            encoding: z.ZodLiteral<"base64">;
+            sha256: z.ZodString;
+            data: z.ZodString;
+        }, z.core.$strict>;
+        width: z.ZodNumber;
+        height: z.ZodNumber;
+        transparentBlank: z.ZodBoolean;
+    }, z.core.$strict>;
+    placement: z.ZodObject<{
+        x: z.ZodNumber;
+        y: z.ZodNumber;
+        size: z.ZodNumber;
+        rotation: z.ZodDefault<z.ZodNumber>;
+    }, z.core.$strict>;
+    settings: z.ZodObject<{
+        seed: z.ZodNumber;
+        qrMargin: z.ZodDefault<z.ZodLiteral<1>>;
+        plateCorners: z.ZodDefault<z.ZodEnum<{
+            light: "light";
+            texture: "texture";
+        }>>;
+        regionMargin: z.ZodDefault<z.ZodBoolean>;
+        rimModules: z.ZodDefault<z.ZodNumber>;
+        rimRounded: z.ZodDefault<z.ZodBoolean>;
+        ecc: z.ZodDefault<z.ZodEnum<{
+            H: "H";
+            L: "L";
+            M: "M";
+            Q: "Q";
+        }>>;
+        pixelStyle: z.ZodDefault<z.ZodEnum<{
+            dot: "dot";
+            rounded: "rounded";
+            square: "square";
+        }>>;
+        finderMarkers: z.ZodDefault<z.ZodObject<{
+            tl: z.ZodDefault<z.ZodObject<{
+                style: z.ZodDefault<z.ZodEnum<{
+                    rounded: "rounded";
+                    square: "square";
+                }>>;
+                shape: z.ZodDefault<z.ZodEnum<{
+                    circle: "circle";
+                    octagon: "octagon";
+                    square: "square";
+                    squircle: "squircle";
+                }>>;
+                inner: z.ZodDefault<z.ZodEnum<{
+                    circle: "circle";
+                    diamond: "diamond";
+                    plus: "plus";
+                    square: "square";
+                    squircle: "squircle";
+                }>>;
+            }, z.core.$strip>>;
+            tr: z.ZodDefault<z.ZodObject<{
+                style: z.ZodDefault<z.ZodEnum<{
+                    rounded: "rounded";
+                    square: "square";
+                }>>;
+                shape: z.ZodDefault<z.ZodEnum<{
+                    circle: "circle";
+                    octagon: "octagon";
+                    square: "square";
+                    squircle: "squircle";
+                }>>;
+                inner: z.ZodDefault<z.ZodEnum<{
+                    circle: "circle";
+                    diamond: "diamond";
+                    plus: "plus";
+                    square: "square";
+                    squircle: "squircle";
+                }>>;
+            }, z.core.$strip>>;
+            bl: z.ZodDefault<z.ZodObject<{
+                style: z.ZodDefault<z.ZodEnum<{
+                    rounded: "rounded";
+                    square: "square";
+                }>>;
+                shape: z.ZodDefault<z.ZodEnum<{
+                    circle: "circle";
+                    octagon: "octagon";
+                    square: "square";
+                    squircle: "squircle";
+                }>>;
+                inner: z.ZodDefault<z.ZodEnum<{
+                    circle: "circle";
+                    diamond: "diamond";
+                    plus: "plus";
+                    square: "square";
+                    squircle: "squircle";
+                }>>;
+            }, z.core.$strip>>;
+        }, z.core.$strip>>;
+        markerSub: z.ZodDefault<z.ZodEnum<{
+            circle: "circle";
+            square: "square";
+        }>>;
+        colors: z.ZodDefault<z.ZodObject<{
+            pixel: z.ZodString;
+            marker: z.ZodString;
+            background: z.ZodString;
+        }, z.core.$strip>>;
+    }, z.core.$strict>;
+}, z.core.$strict>;
+export type PortableRecipe = z.infer<typeof recipeSchema>;
+export declare function createRecipeBlob(input: AssembleInput, finalMask: Blob): Promise<Blob>;
+export declare function renderRecipe(imaging: Imaging, rawRecipe: unknown, artifact: 'poster.png' | 'qr.png'): Promise<{
+    png: Blob;
+    filename: string;
+}>;

package/dist/types/schema.d.ts

@@ -0,0 +1,211 @@
+import { z } from 'zod';
+export declare const MAX_IMAGE_BYTES: number;
+export declare const MAX_PIXELS = 4000000;
+export declare const MAX_BODY_BYTES: number;
+export declare const contentSchema: z.ZodString;
+export declare const rotationSchema: z.ZodDefault<z.ZodNumber>;
+export declare const placementSchema: z.ZodObject<{
+    x: z.ZodNumber;
+    y: z.ZodNumber;
+    size: z.ZodNumber;
+    rotation: z.ZodDefault<z.ZodNumber>;
+}, z.core.$strict>;
+export declare const settingsSchema: z.ZodObject<{
+    seed: z.ZodNumber;
+    qrMargin: z.ZodDefault<z.ZodLiteral<1>>;
+    plateCorners: z.ZodDefault<z.ZodEnum<{
+        light: "light";
+        texture: "texture";
+    }>>;
+    regionMargin: z.ZodDefault<z.ZodBoolean>;
+    rimModules: z.ZodDefault<z.ZodNumber>;
+    rimRounded: z.ZodDefault<z.ZodBoolean>;
+    ecc: z.ZodDefault<z.ZodEnum<{
+        H: "H";
+        L: "L";
+        M: "M";
+        Q: "Q";
+    }>>;
+    pixelStyle: z.ZodDefault<z.ZodEnum<{
+        dot: "dot";
+        rounded: "rounded";
+        square: "square";
+    }>>;
+    finderMarkers: z.ZodDefault<z.ZodObject<{
+        tl: z.ZodDefault<z.ZodObject<{
+            style: z.ZodDefault<z.ZodEnum<{
+                rounded: "rounded";
+                square: "square";
+            }>>;
+            shape: z.ZodDefault<z.ZodEnum<{
+                circle: "circle";
+                octagon: "octagon";
+                square: "square";
+                squircle: "squircle";
+            }>>;
+            inner: z.ZodDefault<z.ZodEnum<{
+                circle: "circle";
+                diamond: "diamond";
+                plus: "plus";
+                square: "square";
+                squircle: "squircle";
+            }>>;
+        }, z.core.$strip>>;
+        tr: z.ZodDefault<z.ZodObject<{
+            style: z.ZodDefault<z.ZodEnum<{
+                rounded: "rounded";
+                square: "square";
+            }>>;
+            shape: z.ZodDefault<z.ZodEnum<{
+                circle: "circle";
+                octagon: "octagon";
+                square: "square";
+                squircle: "squircle";
+            }>>;
+            inner: z.ZodDefault<z.ZodEnum<{
+                circle: "circle";
+                diamond: "diamond";
+                plus: "plus";
+                square: "square";
+                squircle: "squircle";
+            }>>;
+        }, z.core.$strip>>;
+        bl: z.ZodDefault<z.ZodObject<{
+            style: z.ZodDefault<z.ZodEnum<{
+                rounded: "rounded";
+                square: "square";
+            }>>;
+            shape: z.ZodDefault<z.ZodEnum<{
+                circle: "circle";
+                octagon: "octagon";
+                square: "square";
+                squircle: "squircle";
+            }>>;
+            inner: z.ZodDefault<z.ZodEnum<{
+                circle: "circle";
+                diamond: "diamond";
+                plus: "plus";
+                square: "square";
+                squircle: "squircle";
+            }>>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>;
+    markerSub: z.ZodDefault<z.ZodEnum<{
+        circle: "circle";
+        square: "square";
+    }>>;
+    colors: z.ZodDefault<z.ZodObject<{
+        pixel: z.ZodString;
+        marker: z.ZodString;
+        background: z.ZodString;
+    }, z.core.$strip>>;
+}, z.core.$strict>;
+export declare const requestSchema: z.ZodObject<{
+    revision: z.ZodNumber;
+    content: z.ZodString;
+    placement: z.ZodOptional<z.ZodObject<{
+        x: z.ZodNumber;
+        y: z.ZodNumber;
+        size: z.ZodNumber;
+        rotation: z.ZodDefault<z.ZodNumber>;
+    }, z.core.$strict>>;
+    previousTotalModules: z.ZodOptional<z.ZodNumber>;
+    settings: z.ZodObject<{
+        seed: z.ZodNumber;
+        qrMargin: z.ZodDefault<z.ZodLiteral<1>>;
+        plateCorners: z.ZodDefault<z.ZodEnum<{
+            light: "light";
+            texture: "texture";
+        }>>;
+        regionMargin: z.ZodDefault<z.ZodBoolean>;
+        rimModules: z.ZodDefault<z.ZodNumber>;
+        rimRounded: z.ZodDefault<z.ZodBoolean>;
+        ecc: z.ZodDefault<z.ZodEnum<{
+            H: "H";
+            L: "L";
+            M: "M";
+            Q: "Q";
+        }>>;
+        pixelStyle: z.ZodDefault<z.ZodEnum<{
+            dot: "dot";
+            rounded: "rounded";
+            square: "square";
+        }>>;
+        finderMarkers: z.ZodDefault<z.ZodObject<{
+            tl: z.ZodDefault<z.ZodObject<{
+                style: z.ZodDefault<z.ZodEnum<{
+                    rounded: "rounded";
+                    square: "square";
+                }>>;
+                shape: z.ZodDefault<z.ZodEnum<{
+                    circle: "circle";
+                    octagon: "octagon";
+                    square: "square";
+                    squircle: "squircle";
+                }>>;
+                inner: z.ZodDefault<z.ZodEnum<{
+                    circle: "circle";
+                    diamond: "diamond";
+                    plus: "plus";
+                    square: "square";
+                    squircle: "squircle";
+                }>>;
+            }, z.core.$strip>>;
+            tr: z.ZodDefault<z.ZodObject<{
+                style: z.ZodDefault<z.ZodEnum<{
+                    rounded: "rounded";
+                    square: "square";
+                }>>;
+                shape: z.ZodDefault<z.ZodEnum<{
+                    circle: "circle";
+                    octagon: "octagon";
+                    square: "square";
+                    squircle: "squircle";
+                }>>;
+                inner: z.ZodDefault<z.ZodEnum<{
+                    circle: "circle";
+                    diamond: "diamond";
+                    plus: "plus";
+                    square: "square";
+                    squircle: "squircle";
+                }>>;
+            }, z.core.$strip>>;
+            bl: z.ZodDefault<z.ZodObject<{
+                style: z.ZodDefault<z.ZodEnum<{
+                    rounded: "rounded";
+                    square: "square";
+                }>>;
+                shape: z.ZodDefault<z.ZodEnum<{
+                    circle: "circle";
+                    octagon: "octagon";
+                    square: "square";
+                    squircle: "squircle";
+                }>>;
+                inner: z.ZodDefault<z.ZodEnum<{
+                    circle: "circle";
+                    diamond: "diamond";
+                    plus: "plus";
+                    square: "square";
+                    squircle: "squircle";
+                }>>;
+            }, z.core.$strip>>;
+        }, z.core.$strip>>;
+        markerSub: z.ZodDefault<z.ZodEnum<{
+            circle: "circle";
+            square: "square";
+        }>>;
+        colors: z.ZodDefault<z.ZodObject<{
+            pixel: z.ZodString;
+            marker: z.ZodString;
+            background: z.ZodString;
+        }, z.core.$strip>>;
+    }, z.core.$strict>;
+}, z.core.$strict>;
+export type Placement = z.infer<typeof placementSchema>;
+export type Settings = z.infer<typeof settingsSchema>;
+export type EditorRequest = z.infer<typeof requestSchema>;
+/** A placement under construction may omit rotation (canonicalized to 0). */
+export type PlacementInput = z.input<typeof placementSchema>;
+export declare function canonicalPlacement(box: PlacementInput, totalModules: number): Placement;
+export declare function recenterPlacement(box: PlacementInput, previousModules: number, nextModules: number): Placement;
+export declare function fitsMask(mask: Uint8Array, width: number, height: number, box: PlacementInput): boolean;

package/dist/types/worker-shim.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Dedicated workers have no `window`, but the engine's QR decoder imports
+ * ZXing, whose PDF417 tables touch `window.BigInt` at module scope. Aliasing
+ * `window` to the worker global keeps that import alive in every bundler
+ * (Turbopack shims `window` in worker output; Vite does not). Must be the
+ * first import of the worker entry, before the engine evaluates. The check
+ * reads the property off `globalThis` so minifiers cannot fold it away, and
+ * it is a no-op on the main thread, where `window` already exists.
+ */
+declare const workerGlobal: {
+    window?: unknown;
+};