@gongbaodd/qr-renderer 0.1.0

package/dist/types/core/qr.d.ts

@@ -0,0 +1,57 @@
+import type { PixelStyle } from './pattern';
+import type { QrPalette } from './palette';
+import type { LoadedPng } from './image';
+import type { QrMetadata, QrSourceTrim, VerificationCheck } from './types';
+export declare const GENERATED_QR_PATH = "<generated>";
+export interface GeneratedQr {
+    image: LoadedPng;
+    version: number;
+}
+export type MarkerStyle = 'square' | 'rounded';
+export type MarkerShape = 'square' | 'circle' | 'octagon' | 'squircle';
+export type MarkerInner = 'square' | 'circle' | 'plus' | 'diamond' | 'squircle';
+export type MarkerSub = 'square' | 'circle';
+export type FinderMarkerSettings = {
+    style: MarkerStyle;
+    shape: MarkerShape;
+    inner: MarkerInner;
+};
+export type FinderMarkerSettingsMap = Record<'tl' | 'tr' | 'bl', FinderMarkerSettings>;
+/** Builds the same two-module-margin QR profile accepted from legacy PNG inputs. */
+export declare function generateQrFromContent(content: string, ecc?: 'L' | 'M' | 'Q' | 'H', pixelStyle?: PixelStyle, markerStyle?: MarkerStyle, markerShape?: MarkerShape, markerInner?: MarkerInner, markerSub?: MarkerSub, finderMarkers?: FinderMarkerSettingsMap, palette?: QrPalette): Promise<GeneratedQr>;
+export declare function decodeQrBuffer(buffer: Uint8Array): Promise<string>;
+export interface DecodedQr {
+    text: string;
+    decoder: 'zxing' | 'jsqr';
+    version?: number;
+}
+export declare function decodeQrRaw(data: Uint8Array, width: number, height: number): string;
+export declare function decodeQrRawDetailed(data: Uint8Array, width: number, height: number): DecodedQr;
+export declare function inspectQrSource(image: LoadedPng, decodedText: string, detectedVersion?: number): QrMetadata;
+export interface ResolvedQrSource {
+    /** The file as supplied, kept for input reporting. */
+    source: LoadedPng;
+    /** A square image with a two-module quiet zone, ready for metadata and normalization. */
+    image: LoadedPng;
+    /** `added` when the input was a trimmed code grid and the margin was rebuilt locally. */
+    quietZoneSource: 'source' | 'added';
+    trim?: QrSourceTrim;
+}
+/**
+ * Resolves a QR input to a square image with a two-module quiet zone. The documented profile is
+ * preferred; a bare code grid (no margin, or a margin that is not a whole module) is recovered by
+ * locating the integer-scaled module grid and re-padding it with a fresh light margin, so a tight
+ * crop such as `source/qr.png` is accepted without resampling a single code pixel.
+ */
+export declare function resolveQrSource(source: LoadedPng, detectedVersion?: number): Promise<ResolvedQrSource>;
+export declare function normalizeQr(image: LoadedPng, targetSize: number): Promise<Uint8Array>;
+/**
+ * Converts the normalized QR's light pixels to alpha for preview and standalone PNG export.
+ * The alpha ramps linearly between the palette's ink lightness and background lightness, and
+ * RGB channels keep each pixel's own color, so colored palettes stay visible on transparency.
+ * The default black/white palette reproduces the historical `alpha = 255 - luminance` behavior.
+ */
+export declare function transparentQrBackground(png: Uint8Array, palette?: QrPalette): Promise<Uint8Array>;
+export declare function verifyQrVariant(name: VerificationCheck['name'], buffer: Uint8Array, expectedText: string): Promise<VerificationCheck>;
+/** Crop whole modules from the central third, away from the corner finder markers. */
+export declare function cropQrPattern(qr: Uint8Array, totalModules: number, modulePixels: number): Promise<Uint8Array>;

package/dist/types/core/rotate.d.ts

@@ -0,0 +1,149 @@
+/**
+ * Pure rotation geometry for the placement step. The QR generator is unaware of
+ * rotation: it always produces the complete upright square plate. Rotation is a
+ * property of placement — clockwise degrees around the unrotated square's
+ * centre, applied once when compositing the finished plate onto the poster.
+ *
+ * `x`, `y`, and `size` keep describing the **unrotated square**, so the existing
+ * editor contract (integer origin, module-multiple size) is unchanged.
+ */
+/** Any placement-like box that can carry a rotation, in degrees. */
+export interface RotatableBox {
+    x: number;
+    y: number;
+    size: number;
+    rotation?: number | undefined;
+}
+/** Canonicalizes an angle to finite degrees in `[0, 360)`; non-finite input maps to 0. */
+export declare function canonicalizeRotation(deg: number | undefined): number;
+/** Centre of the unrotated placement square in poster pixels. */
+export declare function placementCenter(box: RotatableBox): {
+    x: number;
+    y: number;
+};
+/**
+ * The placement transform precomputed: centre, canonical half size, and the
+ * rotation's cos/sin. Tight per-pixel loops (field building, assembly sampling)
+ * reuse it instead of recomputing trigonometry for every pixel, and the fast
+ * mappers are the same math as the point helpers below.
+ */
+export interface PlacementInverse {
+    centerX: number;
+    centerY: number;
+    size: number;
+    cos: number;
+    sin: number;
+}
+/** Precomputes the inverse placement transform of {@link posterToPlatePoint}. */
+export declare function placementInverse(box: RotatableBox): PlacementInverse;
+/** Fast {@link plateToPosterPoint} over a precomputed {@link PlacementInverse}. */
+export declare function forwardMap(inv: PlacementInverse, localX: number, localY: number): {
+    x: number;
+    y: number;
+};
+/** Fast {@link posterToPlatePoint} over a precomputed {@link PlacementInverse}. */
+export declare function inverseMap(inv: PlacementInverse, posterX: number, posterY: number): {
+    x: number;
+    y: number;
+};
+/**
+ * Maps a plate-local point (origin = the unrotated square's top-left) forward to
+ * poster coordinates: the same centre and angle the Konva preview uses, so
+ * preview, validation, and assembly cannot disagree about the footprint.
+ */
+export declare function plateToPosterPoint(localX: number, localY: number, box: RotatableBox): {
+    x: number;
+    y: number;
+};
+/**
+ * Inverse of {@link plateToPosterPoint}: maps a poster-space sample point back
+ * into plate-local coordinates. Assembly and mask containment iterate
+ * destination pixels and use this to find the source pixel they read.
+ */
+export declare function posterToPlatePoint(posterX: number, posterY: number, box: RotatableBox): {
+    x: number;
+    y: number;
+};
+/** The four corners of the rotated plate square, in consistent clockwise order. */
+export declare function rotatedSquareCorners(box: RotatableBox): readonly [{
+    x: number;
+    y: number;
+}, {
+    x: number;
+    y: number;
+}, {
+    x: number;
+    y: number;
+}, {
+    x: number;
+    y: number;
+}];
+/** Integer pixel bounds covering the rotated plate's footprint, clipped to the canvas. */
+export declare function rotatedFootprintBounds(box: RotatableBox, width: number, height: number): {
+    left: number;
+    top: number;
+    right: number;
+    bottom: number;
+};
+/** Tight integer poster-space AABB of the painted region, end coordinates exclusive. */
+export interface PixelBounds {
+    x0: number;
+    y0: number;
+    x1: number;
+    y1: number;
+}
+/**
+ * The upright assembly's working canvas, expressed in plate-local coordinates
+ * (origin = the unrotated placement square's top-left). The frame is the integer
+ * AABB that contains every poster pixel's inverse-rotated sample point, so the
+ * whole-module pipeline can run there and the finished overlay can ride the same
+ * placement transform back onto the poster. See doc/plan/rotated-mask-fill.md.
+ */
+export interface QrFrame {
+    /** Plate-local x/y of the working canvas' top-left; can be negative. */
+    left: number;
+    top: number;
+    width: number;
+    height: number;
+    /** The unrotated QR box expressed in working-canvas coordinates. */
+    qr: {
+        x: number;
+        y: number;
+        size: number;
+    };
+}
+/**
+ * The working frame for a rotated placement: the plate-local AABB of the
+ * inverse-mapped painted-region bounds, floored/ceiled to whole pixels. Every
+ * poster pixel whose sample point can land inside the region maps into this
+ * frame, so mask sampling and overlay generation never look outside it.
+ */
+export declare function qrWorkingFrame(placement: RotatableBox, regionBounds: PixelBounds): QrFrame;
+/**
+ * Samples the original region mask into the working frame with the same inverse
+ * transform assembly's plate pixels use: each working pixel centre maps forward
+ * to its poster sample point, and the working mask keeps that poster pixel's
+ * selection. Off-poster samples are 0, so safe-area checks stay whole blocks.
+ */
+export declare function sampleMaskIntoQrFrame(mask: Uint8Array, posterWidth: number, posterHeight: number, frame: QrFrame, placement: RotatableBox): Uint8Array;
+/** Tight poster-space AABB of a painted-region mask, end coordinates exclusive. */
+export declare function regionPixelBounds(mask: {
+    data: Uint8Array;
+    width: number;
+    height: number;
+}): PixelBounds;
+/**
+ * Whether a plate-local point lies inside the plate square `[0, size) × [0, size)`.
+ * Nearest-neighbour sampling maps a poster pixel centre here and copies the
+ * source pixel at `floor(x), floor(y)` when it does.
+ */
+export declare function localPointInPlate(localX: number, localY: number, size: number): boolean;
+/**
+ * The rotated-frame invariant: every poster pixel centre that belongs to the valid
+ * placed QR square must map to a working pixel inside the working frame. A frame
+ * built from wrong region bounds would silently drop plate cells, and the assembly's
+ * `qrPixels` check never sees a plate cell it cannot address. Rejected with the
+ * layout error both validation and assembly report, so a bad placement is flagged
+ * before export instead of clipping silently (doc/plan/rotated-working-frame-clipping.md).
+ */
+export declare function assertFrameHoldsPlacement(frame: QrFrame, placement: RotatableBox, posterWidth: number, posterHeight: number): void;

package/dist/types/core/squircle.d.ts

@@ -0,0 +1,2 @@
+/** Return a fourth-power superellipse as a compact SVG path. */
+export declare function squirclePath(cx: number, cy: number, radius: number): string;

package/dist/types/core/types.d.ts

@@ -0,0 +1,475 @@
+import type { LoadedPng } from './image';
+import type { DecodedQr } from './qr';
+export interface ImageDimensions {
+    width: number;
+    height: number;
+}
+export interface BoundingBox {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+}
+export interface Point {
+    x: number;
+    y: number;
+}
+export interface RegionMask extends ImageDimensions {
+    /** Row-major binary coverage: 0 is outside, 255 is inside M. */
+    data: Uint8Array;
+    source: 'auto' | 'file';
+    area: number;
+    bounds: BoundingBox;
+    centroid: Point;
+    detection?: {
+        strongBlackThreshold: number;
+        tolerantLumaThreshold: number;
+        separationRadius: number;
+        densityThreshold: number;
+        candidateAreas: number[];
+        dominanceRatio: number | null;
+    };
+}
+export interface QrMetadata extends ImageDimensions {
+    decodedText: string;
+    version: number;
+    qrModules: number;
+    quietZoneModules: 2;
+    totalModules: number;
+    sourceModulePixels: number;
+    quietZoneLightRatio: number;
+    /** `added` when the input was a bare code grid and the two-module margin was rebuilt locally. */
+    quietZoneSource?: 'added';
+    /** Trimmed-away margin of a code-grid input, in source pixels. */
+    sourceTrim?: QrSourceTrim;
+}
+export interface QrSourceTrim {
+    left: number;
+    top: number;
+    right: number;
+    bottom: number;
+    modulePixels: number;
+}
+export interface QrPlacement {
+    x: number;
+    y: number;
+    size: number;
+    /** Clockwise degrees the finished plate is rotated around the square's centre; canonical [0, 360). */
+    rotation: number;
+    modulePixels: number;
+    totalModules: number;
+    mode: 'auto' | 'manual';
+    /** Extra decorative modules reserved around the QR; retained for report compatibility. */
+    artPaddingModules: number;
+}
+export interface ResolvedLayout {
+    /** The poster exactly as supplied. */
+    poster: LoadedPng;
+    /** The QR file exactly as supplied, kept for input reporting. */
+    qrSource: LoadedPng;
+    /** The QR image placement uses: the input, or a code grid re-padded with a quiet zone. */
+    qrImage: LoadedPng;
+    maskInput?: LoadedPng;
+    regionMask: RegionMask;
+    decoded: DecodedQr;
+    qrMetadata: QrMetadata;
+    placement: QrPlacement;
+    normalizedQr: Uint8Array;
+}
+export interface VerificationCheck {
+    name: 'sourceQr' | 'normalizedQr' | 'beforeAi' | 'halfScale' | 'jpeg80' | 'poster' | 'posterHalfScale' | 'posterJpeg80' | 'outsideRegionPixels' | 'qrPixels' | 'qrPlateCorners' | 'moduleCut' | 'alphaPreserved' | 'transparentBackground';
+    passed: boolean;
+    decodedText?: string;
+    decoder?: 'zxing' | 'jsqr';
+    version?: number;
+    error?: string;
+}
+export interface VerificationResult {
+    expectedText: string;
+    checks: VerificationCheck[];
+    qualified: boolean;
+    /** Checks that a mode deliberately does not run, so a qualified report stays honest. */
+    skippedChecks?: VerificationCheck['name'][];
+}
+export interface ReportV1 {
+    schemaVersion: 1;
+    status: 'prepared' | 'verification_failed';
+    qualified: boolean;
+    dryRun: true;
+    createdAt: string;
+    durationMs: number;
+    inputs: {
+        poster: {
+            path: string;
+            sha256: string;
+            width: number;
+            height: number;
+        };
+        qr: {
+            path: string;
+            sha256: string;
+            width: number;
+            height: number;
+        };
+        mask?: {
+            path: string;
+            sha256: string;
+        };
+    };
+    region: {
+        source: 'auto' | 'file';
+        area: number;
+        bounds: BoundingBox;
+        centroid: Point;
+        detection?: RegionMask['detection'];
+    };
+    qr: QrMetadata & {
+        normalizedSize: number;
+        normalizedModulePixels: number;
+    };
+    placement: QrPlacement;
+    artifacts: Record<'regionMask' | 'qr' | 'layoutPreview' | 'editMask' | 'beforeAi', string>;
+    verification: VerificationResult;
+    warnings: string[];
+}
+export interface QrBoxInput {
+    x: number;
+    y: number;
+    size: number;
+    /** Optional clockwise rotation in degrees; defaults to 0 (upright). */
+    rotation?: number;
+}
+export interface PosterInputOptions {
+    inputPath: string;
+    outputDir: string;
+    maskPath?: string;
+    qrBox?: QrBoxInput;
+    force?: boolean;
+}
+/** Generate a QR from content, or retain the legacy QR PNG input for programmatic callers. */
+export type QrInputOptions = {
+    content: string;
+    qrPath?: never;
+    expectedText?: never;
+} | {
+    content?: never;
+    qrPath: string;
+    expectedText?: string;
+};
+export type PreparePosterOptions = PosterInputOptions & QrInputOptions & {
+    dryRun: true;
+};
+export interface PrepareResult {
+    report: ReportV1;
+    outputDir: string;
+}
+export interface CompositePosterInputs {
+    original: Uint8Array;
+    generated: Uint8Array;
+    regionMask: RegionMask;
+    qr: Uint8Array;
+    placement: QrPlacement;
+}
+export type GeneratePosterOptions = PosterInputOptions & QrInputOptions & {
+    apiKey?: string;
+    baseUrl?: string;
+    model?: string;
+    prompt?: string;
+    generatedImagePath?: string;
+};
+export interface ReportV2 extends Omit<ReportV1, 'schemaVersion' | 'status' | 'dryRun' | 'artifacts'> {
+    schemaVersion: 2;
+    status: 'generated' | 'verification_failed' | 'generation_failed';
+    dryRun: false;
+    artifacts: ReportV1['artifacts'] & {
+        aiRaw?: string;
+        poster?: string;
+        patternReference?: string;
+        referenceCanvas?: string;
+    };
+    generation: {
+        source: 'qwen' | 'file';
+        model: string;
+        prompt: string;
+        canvas: ImageDimensions;
+        durationMs: number;
+        requestId?: string;
+        usage?: unknown;
+        error?: string;
+    };
+    phoneScan: 'untested';
+}
+export interface GenerateResult {
+    report: ReportV2;
+    outputDir: string;
+}
+export type PatternPreviewOptions = PosterInputOptions & QrInputOptions & {
+    /** Module pitch in poster pixels; defaults to the pitch the pipeline places on the poster. */
+    modulePixels?: number;
+    /** Seed for the random text line; defaults to a fresh random seed per run. */
+    seed?: number;
+};
+export interface PatternReport {
+    schemaVersion: 3;
+    mode: 'pattern-preview';
+    status: 'generated';
+    createdAt: string;
+    durationMs: number;
+    inputs: ReportV1['inputs'];
+    region: ReportV1['region'];
+    placement: QrPlacement;
+    pitchSource: 'placement' | 'override';
+    pattern: {
+        seed: number;
+        alphabet: string;
+        textLength: number;
+        textSha256: string;
+        ecc: 'M';
+        version: number;
+        qrModules: number;
+        quietZoneModules: 2;
+        totalModules: number;
+        modulePixels: number;
+        pixelStyle: 'square' | 'rounded' | 'dot';
+        removedTypes: Array<'Position' | 'Alignment'>;
+        /** Dropped marker cells are refilled with seeded random bits, never left light. */
+        markerRefill: 'seeded-random';
+        refilledModules: number;
+        codeSize: number;
+        canvas: ImageDimensions;
+        crop: {
+            left: number;
+            top: number;
+        };
+    };
+    artifacts: {
+        pattern: string;
+        patternSha256: string;
+    };
+    warnings: string[];
+}
+export interface PatternPreviewResult {
+    report: PatternReport;
+    outputDir: string;
+}
+export interface PatternCutOptions {
+    /** Rendered pattern PNG to cut, poster-sized. */
+    inputPath: string;
+    /** Same-size mask PNG: transparent or dark pixels select the cut shape. */
+    maskPath: string;
+    outputDir: string;
+    /** Corner fillet radius in pixels; defaults to 5. */
+    radius?: number;
+    /** Douglas-Peucker tolerance in pixels for the traced outline; defaults to 3. */
+    smoothTolerance?: number;
+    force?: boolean;
+}
+export interface PatternCutReport {
+    schemaVersion: 4;
+    mode: 'pattern-cut';
+    status: 'generated';
+    createdAt: string;
+    durationMs: number;
+    inputs: {
+        pattern: {
+            path: string;
+            sha256: string;
+            width: number;
+            height: number;
+        };
+        mask: {
+            path: string;
+            sha256: string;
+            width: number;
+            height: number;
+        };
+    };
+    cut: {
+        radius: number;
+        smoothTolerance: number;
+        /** A mask pixel selects the shape when it is transparent or dark. */
+        keep: 'transparent-or-dark';
+        minLoopArea: number;
+        /** Solid black band retained inside the letter outline, in pixels. */
+        borderWidth: number;
+    };
+    shape: {
+        loopsTraced: number;
+        loopsKept: number;
+        specksDropped: number;
+        verticesTraced: number;
+        verticesSimplified: number;
+        holes: number;
+        /** Area of the simplified cut polygon before corner rounding. */
+        area: number;
+        radiusClamped: boolean;
+        bounds: BoundingBox;
+    };
+    artifacts: {
+        svg: string;
+        svgSha256: string;
+        png: string;
+        pngSha256: string;
+    };
+    warnings: string[];
+}
+export interface PatternCutResult {
+    report: PatternCutReport;
+    outputDir: string;
+}
+export type AssemblePosterOptions = PosterInputOptions & QrInputOptions & {
+    /** Seed for the pattern random text line and the marker refill; defaults to a fresh seed per run. */
+    seed?: number;
+    /** Depth of the light band kept beside each finder marker: one whole module. */
+    qrMargin?: 1;
+    /** Keep one safe-module ring along the inside edge of the selected region light. */
+    regionMargin?: boolean;
+    /**
+     * Plate corner treatment: zero keeps the diagonal corner block beside each finder marker light,
+     * and any positive value hands those three blocks to the texture. Defaults to two module pitches
+     * (12px on the bundled version-5 fixture), which rounds the plate. The region silhouette is always
+     * whole modules, so there is no fillet to size.
+     */
+    radius?: number;
+    /** Outer dark rim thickness in modules, 0 disables the rim. Range 0-5. */
+    rimModules?: number;
+    /** When true the rim's outer corners are rounded with antialiased edges. */
+    rimRounded?: boolean;
+    /** Not used by assembly: the cut is module-aligned rather than traced. Rejected when supplied. */
+    smoothTolerance?: number;
+};
+export interface AssembleReport {
+    schemaVersion: 8;
+    mode: 'assemble';
+    status: 'generated' | 'verification_failed';
+    qualified: boolean;
+    createdAt: string;
+    durationMs: number;
+    inputs: ReportV1['inputs'];
+    region: ReportV1['region'];
+    qr: ReportV1['qr'] & {
+        /** The pixels actually composited: the code grid plus the light band beside the markers. */
+        overlay: {
+            /** The light band is kept beside the finder markers only. */
+            band: 'markers';
+            /** Depth of the light band beside each marker, in modules. */
+            quietZoneModules: number;
+            /** Finder footprint each band arm spans, in modules. */
+            markerModules: number;
+            /** Crop of the normalized QR the plate copies verbatim: the code grid, no quiet zone. */
+            crop: {
+                left: number;
+                top: number;
+                size: number;
+            };
+            x: number;
+            y: number;
+        };
+    };
+    placement: QrPlacement;
+    pattern: PatternReport['pattern'] & {
+        /** The settings palette the generated QR and the texture were rendered with. */
+        colors: {
+            pixel: string;
+            marker: string;
+            background: string;
+        };
+        /**
+         * The texture window is phase-locked to the placed QR, so both share one module lattice.
+         * `phase` is the residual offset of the texture's module boundaries from the QR lattice:
+         * `0,0` means they coincide.
+         */
+        alignment: {
+            alignedToQr: boolean;
+            phase: {
+                x: number;
+                y: number;
+            };
+        };
+    };
+    cut: {
+        /** Poster-space module pitch the cut is quantized to; equals the placed QR pitch. */
+        modulePixels: number;
+        /** Poster-space origin of the module lattice, in `[0, modulePixels)`. */
+        lattice: {
+            x: number;
+            y: number;
+        };
+        /** Requested `--cut-radius`; zero leaves the plate square, a positive value rounds it. */
+        radius: number;
+        /** Modules whose whole pixel block is inside the painted region. */
+        safeModules: number;
+        /** Modules the region covers only in part; the cut leaves them as the original artwork. */
+        droppedPartialModules: number;
+        /** Region pixels inside those dropped modules. */
+        droppedPartialPixels: number;
+        /** Modules the cut draws: safe modules minus the QR plate hole. */
+        drawnModules: number;
+        /** Outer rings of drawn modules forced dark; rounded is antialiased. */
+        rim: {
+            modules: number;
+            style: 'cell' | 'rounded-antialiased';
+        };
+        /** Light ring of safe modules along the region edge, 0 when disabled. */
+        regionMarginModules: 0 | 1;
+        /** Modules of the plate handed back to the texture: the diagonal block at each marker corner. */
+        plateCornerModules: number;
+        /** The cut shape is the detected or supplied painted region itself. */
+        keep: 'region-mask';
+        /** Whole modules replace the original pixels; antialiased blends the edge. */
+        edgeBlend: 'cell-aligned-over-original' | 'antialiased';
+    };
+    /** The plate the texture is cut around and the QR is drawn in; all of it is whole modules. */
+    qrPlate: {
+        /** The light band is kept beside the finder markers only. */
+        band: 'markers';
+        /** Depth of the light band beside each marker: one whole module. */
+        marginModules: 1;
+        /** The band actually painted, in pixels: `marginModules * modulePixels`. */
+        marginPixels: number;
+        /** Finder footprint each band arm spans, in modules. */
+        markerModules: number;
+        /** Light cells the band keeps beside the three markers, corner blocks included. */
+        bandCells: number;
+        /** The code grid the plate copies verbatim; the band sits outside it. */
+        box: BoundingBox;
+        /** Modules the hole covers: code grid plus band, corner blocks already handed back. */
+        holeModules: number;
+        /** Modules handed back to the texture, 0 when `--cut-radius` is zero. */
+        cornerModules: number;
+        /** Pixels those modules leave as texture instead of the QR's own light band. */
+        cornerTexturePixels: number;
+    };
+    shape: {
+        /** Canvas-pixel bounds of the drawn modules. */
+        bounds: BoundingBox;
+        /** Pixels the drawn modules cover: texture, rim, or light margin. */
+        area: number;
+        /** Modules the cut draws. */
+        modules: number;
+        /** Drawn modules forced dark as the rim. */
+        rimModules: number;
+        /** Drawn modules painted light as the region edge or tight-QR quiet margin. */
+        marginModules: number;
+        /** Drawn modules carrying the texture. */
+        textureModules: number;
+    };
+    artifacts: {
+        poster: string;
+        posterSha256: string;
+        regionMask: string;
+        qr: string;
+        qrSha256: string;
+        patternCutPng: string;
+        patternCutPngSha256: string;
+        patternCutSvg: string;
+        patternCutSvgSha256: string;
+    };
+    verification: VerificationResult;
+    phoneScan: 'untested';
+    warnings: string[];
+}
+export interface AssembleResult {
+    report: AssembleReport;
+    outputDir: string;
+}