@invarn/cibuild 2.3.7 → 2.4.0

package/dist/src/yaml/steps/trim-align-corpus.test.js

@@ -0,0 +1,383 @@
+/**
+ * Corpus gate for the pure-JS trim/align port (fidelity-linux 06).
+ *
+ * Runs the RETIRED CoreGraphics/Swift helper (kept verbatim below as the
+ * equivalence oracle — it no longer ships) and the JS port over the same
+ * inputs and requires:
+ *
+ *  - pixel-identical TRIMMED outputs (decoded RGBA compare) — HARD. The
+ *    trimmed image is what feeds render digests and the fidelity history.
+ *  - identical TRIMDIMS lines — HARD.
+ *  - identical exit codes on failure inputs — HARD.
+ *  - pixel-identical ALIGNED outputs whenever the Swift path did not resample
+ *    (trimmed size == reference size, integer placement) — HARD. Where
+ *    CoreGraphics resampled, its proprietary `.high` interpolation is not
+ *    bit-reproducible outside CoreGraphics; those cases assert canvas
+ *    geometry and report the pixel deltas in the run summary instead.
+ *
+ * Inputs: crafted scenes covering every bounding-box branch (including
+ *  anti-aliased/semi-transparent edges, where the premultiplied-analysis
+ *  subtlety lives), plus every real PNG pair found under
+ *  CIBUILD_TRIM_CORPUS_DIR (rendered screens, Figma-extracted references,
+ *  alpha-heavy assets), each run as no-reference, self-reference, and
+ *  cross-reference cases.
+ *
+ * Gated behind CIBUILD_UI_FIDELITY_REAL_SWIFT=1 (needs a real `swift`).
+ */
+import { spawnSync } from 'node:child_process';
+import { existsSync, mkdtempSync, readdirSync, readFileSync, rmSync, writeFileSync, } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { PNG } from 'pngjs';
+import { describe, test, expect, afterAll } from '@jest/globals';
+import { runTrimAlign } from './trim-align.js';
+const realSwiftTest = process.env.CIBUILD_UI_FIDELITY_REAL_SWIFT === '1' ? test : test.skip;
+// The retired helper, verbatim (was TRIM_HELPER_SWIFT_SOURCE in
+// render-post-processor.ts). Do not edit: it is the oracle the port is
+// measured against.
+const RETIRED_TRIM_HELPER_SWIFT = [
+    'import Foundation',
+    'import ImageIO',
+    'import CoreGraphics',
+    'import UniformTypeIdentifiers',
+    '',
+    'func loadCGImage(_ path: String) -> CGImage? {',
+    '    guard let src = CGImageSourceCreateWithURL(URL(fileURLWithPath: path) as CFURL, nil),',
+    '          let img = CGImageSourceCreateImageAtIndex(src, 0, nil) else { return nil }',
+    '    return img',
+    '}',
+    '',
+    'func writePNG(_ image: CGImage, to path: String) -> Bool {',
+    '    guard let dest = CGImageDestinationCreateWithURL(URL(fileURLWithPath: path) as CFURL, UTType.png.identifier as CFString, 1, nil) else { return false }',
+    '    CGImageDestinationAddImage(dest, image, nil)',
+    '    return CGImageDestinationFinalize(dest)',
+    '}',
+    '',
+    'func fitPad(_ image: CGImage, toWidth w: Int, height h: Int) -> CGImage? {',
+    '    if w <= 0 || h <= 0 { return nil }',
+    '    let bytesPerRow = w * 4',
+    '    let space = CGColorSpaceCreateDeviceRGB()',
+    '    guard let ctx = CGContext(data: nil, width: w, height: h, bitsPerComponent: 8, bytesPerRow: bytesPerRow, space: space, bitmapInfo: CGImageAlphaInfo.premultipliedLast.rawValue) else { return nil }',
+    '    ctx.clear(CGRect(x: 0, y: 0, width: w, height: h))',
+    '    ctx.interpolationQuality = .high',
+    '    let scale = min(Double(w) / Double(image.width), Double(h) / Double(image.height))',
+    '    let drawW = Double(image.width) * scale',
+    '    let drawH = Double(image.height) * scale',
+    '    let originX = (Double(w) - drawW) / 2.0',
+    '    let originY = (Double(h) - drawH) / 2.0',
+    '    ctx.draw(image, in: CGRect(x: originX, y: originY, width: drawW, height: drawH))',
+    '    return ctx.makeImage()',
+    '}',
+    '',
+    'func contentBoundingBox(_ image: CGImage) -> CGRect? {',
+    '    let w = image.width, h = image.height',
+    '    if w == 0 || h == 0 { return nil }',
+    '    let bytesPerRow = w * 4',
+    '    var data = [UInt8](repeating: 0, count: bytesPerRow * h)',
+    '    let space = CGColorSpaceCreateDeviceRGB()',
+    '    guard let ctx = CGContext(data: &data, width: w, height: h, bitsPerComponent: 8, bytesPerRow: bytesPerRow, space: space, bitmapInfo: CGImageAlphaInfo.premultipliedLast.rawValue) else { return nil }',
+    '    ctx.draw(image, in: CGRect(x: 0, y: 0, width: w, height: h))',
+    '    let tolerance = 4',
+    '    func sample(_ x: Int, _ y: Int) -> (Int, Int, Int, Int) {',
+    '        let i = y * bytesPerRow + x * 4',
+    '        return (Int(data[i]), Int(data[i + 1]), Int(data[i + 2]), Int(data[i + 3]))',
+    '    }',
+    '    var aMinX = w, aMinY = h, aMaxX = -1, aMaxY = -1',
+    '    for y in 0..<h {',
+    '        let rowBase = y * bytesPerRow',
+    '        for x in 0..<w {',
+    '            if data[rowBase + x * 4 + 3] > 0 {',
+    '                if x < aMinX { aMinX = x }',
+    '                if x > aMaxX { aMaxX = x }',
+    '                if y < aMinY { aMinY = y }',
+    '                if y > aMaxY { aMaxY = y }',
+    '            }',
+    '        }',
+    '    }',
+    '    if aMaxX < 0 { return nil }',
+    '    let opaqueBox = CGRect(x: aMinX, y: aMinY, width: aMaxX - aMinX + 1, height: aMaxY - aMinY + 1)',
+    '    let corners = [sample(aMinX, aMinY), sample(aMaxX, aMinY), sample(aMinX, aMaxY), sample(aMaxX, aMaxY)]',
+    '    var background: (Int, Int, Int, Int)? = corners[0]',
+    '    for c in corners {',
+    '        if let bg = background {',
+    '            if c.3 == 0 || abs(c.0 - bg.0) > tolerance || abs(c.1 - bg.1) > tolerance || abs(c.2 - bg.2) > tolerance || abs(c.3 - bg.3) > tolerance {',
+    '                background = nil',
+    '            }',
+    '        }',
+    '    }',
+    '    guard let bg = background else { return opaqueBox }',
+    '    var minX = aMaxX + 1, minY = aMaxY + 1, maxX = aMinX - 1, maxY = aMinY - 1',
+    '    for y in aMinY...aMaxY {',
+    '        let rowBase = y * bytesPerRow',
+    '        for x in aMinX...aMaxX {',
+    '            let idx = rowBase + x * 4',
+    '            let a = Int(data[idx + 3])',
+    '            if a == 0 { continue }',
+    '            let r = Int(data[idx]), g = Int(data[idx + 1]), b = Int(data[idx + 2])',
+    '            if abs(r - bg.0) <= tolerance && abs(g - bg.1) <= tolerance && abs(b - bg.2) <= tolerance && abs(a - bg.3) <= tolerance { continue }',
+    '            if x < minX { minX = x }',
+    '            if x > maxX { maxX = x }',
+    '            if y < minY { minY = y }',
+    '            if y > maxY { maxY = y }',
+    '        }',
+    '    }',
+    '    if maxX < minX { return opaqueBox }',
+    '    return CGRect(x: minX, y: minY, width: maxX - minX + 1, height: maxY - minY + 1)',
+    '}',
+    '',
+    'let arguments = CommandLine.arguments',
+    'guard arguments.count >= 3 else {',
+    '    FileHandle.standardError.write(Data("usage: Trim <in.png> <out.png>".utf8))',
+    '    exit(64)',
+    '}',
+    'let inputPath = arguments[1]',
+    'let outputPath = arguments[2]',
+    'guard let image = loadCGImage(inputPath) else {',
+    '    FileHandle.standardError.write(Data(("could not read image at " + inputPath).utf8))',
+    '    exit(65)',
+    '}',
+    'guard let box = contentBoundingBox(image) else {',
+    '    FileHandle.standardError.write(Data("no content to trim (image is uniform)".utf8))',
+    '    exit(66)',
+    '}',
+    'guard let cropped = image.cropping(to: box) else {',
+    '    FileHandle.standardError.write(Data("could not crop image".utf8))',
+    '    exit(67)',
+    '}',
+    'let croppedWidth = cropped.width',
+    'let croppedHeight = cropped.height',
+    'guard writePNG(cropped, to: outputPath) else {',
+    '    FileHandle.standardError.write(Data(("could not write trimmed PNG to " + outputPath).utf8))',
+    '    exit(68)',
+    '}',
+    'var referenceWidth = 0',
+    'var referenceHeight = 0',
+    'if arguments.count >= 5 {',
+    '    let alignedPath = arguments[3]',
+    '    let referencePath = arguments[4]',
+    '    if let reference = loadCGImage(referencePath) {',
+    '        referenceWidth = reference.width',
+    '        referenceHeight = reference.height',
+    '        if let aligned = fitPad(cropped, toWidth: referenceWidth, height: referenceHeight) {',
+    '            _ = writePNG(aligned, to: alignedPath)',
+    '        }',
+    '    }',
+    '}',
+    'print("TRIMDIMS " + String(croppedWidth) + " " + String(croppedHeight) + " " + String(referenceWidth) + " " + String(referenceHeight) + " " + String(image.width) + " " + String(image.height))',
+].join('\n') + '\n';
+function craftPng(w, h, rects) {
+    const png = new PNG({ width: w, height: h });
+    for (const rect of rects) {
+        for (let y = rect.y; y < rect.y + rect.h; y++) {
+            for (let x = rect.x; x < rect.x + rect.w; x++) {
+                const i = (y * w + x) * 4;
+                png.data[i] = rect.r;
+                png.data[i + 1] = rect.g;
+                png.data[i + 2] = rect.b;
+                png.data[i + 3] = rect.a;
+            }
+        }
+    }
+    return PNG.sync.write(png);
+}
+/** A gradient-alpha disc over a white card — anti-aliased-edge analog. */
+function craftAntiAliasedScene() {
+    const w = 160;
+    const h = 120;
+    const png = new PNG({ width: w, height: h });
+    // White card with a transparent margin.
+    for (let y = 10; y < 110; y++) {
+        for (let x = 10; x < 150; x++) {
+            const i = (y * w + x) * 4;
+            png.data[i] = 255;
+            png.data[i + 1] = 255;
+            png.data[i + 2] = 255;
+            png.data[i + 3] = 255;
+        }
+    }
+    // Soft-edged blue disc: alpha falls off with distance (many partial alphas,
+    // including the 251..254 band where premultiplied analysis is sensitive).
+    const cx = 80;
+    const cy = 60;
+    for (let y = 20; y < 100; y++) {
+        for (let x = 30; x < 130; x++) {
+            const d = Math.sqrt((x - cx) ** 2 + (y - cy) ** 2);
+            if (d < 36) {
+                const alpha = d < 28 ? 255 : Math.max(0, Math.round(255 * (36 - d) / 8));
+                if (alpha === 0)
+                    continue;
+                const i = (y * w + x) * 4;
+                png.data[i] = 30;
+                png.data[i + 1] = 90;
+                png.data[i + 2] = 220;
+                png.data[i + 3] = Math.max(png.data[i + 3], alpha);
+            }
+        }
+    }
+    return PNG.sync.write(png);
+}
+function decode(filePath) {
+    const png = PNG.sync.read(readFileSync(filePath));
+    return { width: png.width, height: png.height, data: png.data };
+}
+function diffPixels(a, b) {
+    const totalPixels = a.width * a.height;
+    let differingPixels = 0;
+    let maxChannelDelta = 0;
+    for (let i = 0; i < a.data.length; i += 4) {
+        let pixelDiffers = false;
+        for (let c = 0; c < 4; c++) {
+            const delta = Math.abs(a.data[i + c] - b.data[i + c]);
+            if (delta > 0)
+                pixelDiffers = true;
+            if (delta > maxChannelDelta)
+                maxChannelDelta = delta;
+        }
+        if (pixelDiffers)
+            differingPixels++;
+    }
+    return { totalPixels, differingPixels, maxChannelDelta };
+}
+// ---- the gate -----------------------------------------------------------------------
+describe('trim/align corpus gate — retired Swift helper vs JS port', () => {
+    const dirs = [];
+    const resampledSummaries = [];
+    afterAll(() => {
+        if (resampledSummaries.length > 0) {
+            // eslint-disable-next-line no-console
+            console.log('[corpus] CG-resampled aligned outputs (geometry asserted, pixels reported):\n' +
+                resampledSummaries.join('\n'));
+        }
+        for (const dir of dirs) {
+            try {
+                rmSync(dir, { recursive: true, force: true });
+            }
+            catch {
+                // best effort
+            }
+        }
+    });
+    function scene() {
+        const dir = mkdtempSync(join(tmpdir(), 'trim-corpus-'));
+        dirs.push(dir);
+        return dir;
+    }
+    function runSwiftHelper(dir, input, output, aligned, reference) {
+        const helper = join(dir, 'Trim.swift');
+        if (!existsSync(helper))
+            writeFileSync(helper, RETIRED_TRIM_HELPER_SWIFT);
+        const args = [helper, input, output];
+        if (aligned && reference)
+            args.push(aligned, reference);
+        return spawnSync('swift', args, { encoding: 'utf-8', maxBuffer: 16 * 1024 * 1024 });
+    }
+    function lastTrimDims(stdout) {
+        const lines = String(stdout || '')
+            .split('\n')
+            .filter((l) => l.trim().startsWith('TRIMDIMS'));
+        return lines.length > 0 ? lines[lines.length - 1].trim() : null;
+    }
+    /**
+     * Runs both helpers over one (input, reference?) case and enforces the gate.
+     * Returns a human line describing the case outcome.
+     */
+    function compareCase(label, inputBytes, referenceBytes) {
+        const dir = scene();
+        const input = join(dir, 'in.png');
+        writeFileSync(input, inputBytes);
+        let reference;
+        if (referenceBytes !== null) {
+            reference = join(dir, 'ref.png');
+            writeFileSync(reference, referenceBytes);
+        }
+        const outSwift = join(dir, 'out-swift.png');
+        const alignedSwift = join(dir, 'aligned-swift.png');
+        const outJs = join(dir, 'out-js.png');
+        const alignedJs = join(dir, 'aligned-js.png');
+        const swiftRun = runSwiftHelper(dir, input, outSwift, reference ? alignedSwift : undefined, reference);
+        const jsArgs = reference ? [input, outJs, alignedJs, reference] : [input, outJs];
+        const jsRun = runTrimAlign(jsArgs);
+        // Same verdict on every input, success or failure.
+        expect(`${label}: js status ${jsRun.status}`).toBe(`${label}: js status ${swiftRun.status}`);
+        if (swiftRun.status !== 0)
+            return;
+        // TRIMDIMS identical.
+        const swiftDims = lastTrimDims(swiftRun.stdout);
+        const jsDims = lastTrimDims(jsRun.stdout);
+        expect(`${label}: ${jsDims}`).toBe(`${label}: ${swiftDims}`);
+        // Trimmed output pixel-identical (the fidelity-history surface).
+        const trimmedSwift = decode(outSwift);
+        const trimmedJs = decode(outJs);
+        expect(`${label}: trimmed ${trimmedJs.width}x${trimmedJs.height}`).toBe(`${label}: trimmed ${trimmedSwift.width}x${trimmedSwift.height}`);
+        const trimmedDiff = diffPixels(trimmedSwift, trimmedJs);
+        expect(`${label}: trimmed differing=${trimmedDiff.differingPixels} maxDelta=${trimmedDiff.maxChannelDelta}`).toBe(`${label}: trimmed differing=0 maxDelta=0`);
+        // Aligned output: identical when CG did not resample; geometry + report otherwise.
+        if (existsSync(alignedSwift) || existsSync(alignedJs)) {
+            expect(existsSync(alignedJs)).toBe(existsSync(alignedSwift));
+            if (existsSync(alignedSwift)) {
+                const aSwift = decode(alignedSwift);
+                const aJs = decode(alignedJs);
+                expect(`${label}: aligned ${aJs.width}x${aJs.height}`).toBe(`${label}: aligned ${aSwift.width}x${aSwift.height}`);
+                const identity = trimmedSwift.width === aSwift.width && trimmedSwift.height === aSwift.height;
+                const alignedDiff = diffPixels(aSwift, aJs);
+                if (identity) {
+                    expect(`${label}: aligned(identity) differing=${alignedDiff.differingPixels} maxDelta=${alignedDiff.maxChannelDelta}`).toBe(`${label}: aligned(identity) differing=0 maxDelta=0`);
+                }
+                else if (alignedDiff.differingPixels > 0) {
+                    resampledSummaries.push(`  ${label}: ${alignedDiff.differingPixels}/${alignedDiff.totalPixels} px differ, ` +
+                        `max channel delta ${alignedDiff.maxChannelDelta}`);
+                }
+            }
+        }
+    }
+    const RED = { r: 255, g: 0, b: 0, a: 255 };
+    const BLUE = { r: 0, g: 0, b: 255, a: 255 };
+    const WHITE = { r: 255, g: 255, b: 255, a: 255 };
+    const PINK = { r: 255, g: 240, b: 238, a: 255 };
+    realSwiftTest('crafted scenes: every bounding-box branch is pixel-identical', () => {
+        compareCase('transparent-frame', craftPng(200, 200, [{ x: 30, y: 50, w: 60, h: 40, ...RED }]), null);
+        compareCase('uniform-background-wrapper', craftPng(420, 320, [
+            { x: 20, y: 40, w: 375, h: 200, ...WHITE },
+            { x: 36, y: 56, w: 343, h: 168, ...PINK },
+        ]), null);
+        compareCase('corners-disagree', craftPng(120, 120, [
+            { x: 20, y: 20, w: 40, h: 80, ...RED },
+            { x: 60, y: 20, w: 40, h: 80, ...BLUE },
+        ]), null);
+        compareCase('fully-opaque-uniform', craftPng(64, 48, [{ x: 0, y: 0, w: 64, h: 48, ...WHITE }]), null);
+        compareCase('fully-transparent', craftPng(40, 40, []), null);
+        compareCase('anti-aliased-edges', craftAntiAliasedScene(), null);
+        compareCase('aligned-identity', craftPng(80, 40, [
+            { x: 0, y: 0, w: 40, h: 40, ...RED },
+            { x: 40, y: 0, w: 40, h: 40, ...BLUE },
+        ]), craftPng(80, 40, [{ x: 0, y: 0, w: 80, h: 40, ...WHITE }]));
+        compareCase('aligned-letterbox', craftPng(80, 40, [{ x: 0, y: 0, w: 80, h: 40, ...RED }]), craftPng(50, 50, [{ x: 0, y: 0, w: 50, h: 50, ...BLUE }]));
+        compareCase('aligned-aa-content', craftAntiAliasedScene(), craftPng(140, 100, [{ x: 0, y: 0, w: 140, h: 100, ...WHITE }]));
+    }, 900_000);
+    realSwiftTest('real corpus: every PNG pair under CIBUILD_TRIM_CORPUS_DIR is pixel-identical', () => {
+        const corpusDir = process.env.CIBUILD_TRIM_CORPUS_DIR;
+        if (!corpusDir) {
+            // eslint-disable-next-line no-console
+            console.log('[corpus] CIBUILD_TRIM_CORPUS_DIR not set — real-corpus pass skipped');
+            return;
+        }
+        const entries = readdirSync(corpusDir)
+            .filter((name) => name.toLowerCase().endsWith('.png'))
+            .sort();
+        expect(entries.length).toBeGreaterThan(0);
+        // eslint-disable-next-line no-console
+        console.log(`[corpus] ${entries.length} real PNGs from ${corpusDir}`);
+        for (let i = 0; i < entries.length; i++) {
+            const name = entries[i];
+            const bytes = readFileSync(join(corpusDir, name));
+            // No-reference case: trim only.
+            compareCase(`${name} (no-ref)`, bytes, null);
+            // Self-reference: reference dims = source dims (identity-leaning).
+            compareCase(`${name} (self-ref)`, bytes, bytes);
+            // Cross-reference: the next PNG as reference (arbitrary scale factors).
+            const next = entries[(i + 1) % entries.length];
+            compareCase(`${name} (ref=${next})`, bytes, readFileSync(join(corpusDir, next)));
+        }
+    }, 1_800_000);
+});
+//# sourceMappingURL=trim-align-corpus.test.js.map

package/dist/src/yaml/steps/trim-align.d.ts

@@ -0,0 +1,85 @@
+/**
+ * Pure-JS trim/align helper — the CoreGraphics port (fidelity-linux 06).
+ *
+ * This is a PORT of the embedded Swift helper that used to live in
+ * render-post-processor.ts (`TRIM_HELPER_SWIFT_SOURCE`), not a redesign: the
+ * bounding-box semantics (alpha pass, corner-derived uniform background,
+ * tolerance 4, never-crop-to-nothing fallback), the fit-pad geometry
+ * (aspect-preserving scale, centered, transparent letterbox) and the TRIMDIMS
+ * contract are byte-for-byte the Swift behavior. CoreGraphics/ImageIO do not
+ * exist on Linux, so the pixel work moved into the ci binary itself (pngjs is
+ * pure JS and bundles via bundle.mjs) — iOS and Android now run the SAME bytes,
+ * and output pixels can only change with our lockfile, never with a runner OS
+ * upgrade.
+ *
+ * Port-fidelity notes, load-bearing for the corpus gate:
+ * - The Swift helper ANALYZED pixels through a premultiplied-alpha CGContext
+ *   but CROPPED the original (straight-alpha) image. We mirror both: the
+ *   bounding box is computed over premultiplied values, the trimmed output is
+ *   a raw copy of the source pixels.
+ * - The Swift aligned output was drawn through a premultiplied context and
+ *   unpremultiplied on PNG encode, which is lossy on semi-transparent pixels;
+ *   we reproduce that roundtrip. Where CoreGraphics RESAMPLED (trimmed size ≠
+ *   reference size), its proprietary `.high` interpolation is not bit-exactly
+ *   reproducible — we use bilinear filtering in premultiplied space. The
+ *   trimmed image and TRIMDIMS never depend on resampling and are the
+ *   pixel-identical surface the corpus gate enforces.
+ */
+import { PNG } from 'pngjs';
+/** Content bounding box in top-left image coordinates. */
+export interface ContentBox {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+}
+/** Mirror of the Swift helper's exit codes. */
+export declare const TRIM_EXIT_USAGE = 64;
+export declare const TRIM_EXIT_UNREADABLE = 65;
+export declare const TRIM_EXIT_NO_CONTENT = 66;
+export declare const TRIM_EXIT_WRITE_FAILED = 68;
+/**
+ * Bounding box of content: pixels that are neither transparent nor part of a
+ * uniform solid background. Two passes, because the renderer forces the view
+ * into a fixed device frame whose margins are transparent: (1) bound the
+ * non-transparent pixels, then (2) detect a uniform opaque background from the
+ * CORNERS OF THAT OPAQUE BOX — not the raw frame, whose corners are the
+ * transparent device margin — and bound everything that is not that
+ * background. A wrapper that fills the canvas with .background(.white) is thus
+ * trimmed to its real content. When the opaque corners disagree, only
+ * transparency is trimmed. Top-left image coordinates.
+ *
+ * `data` is straight-alpha RGBA8 (as pngjs decodes); the color comparisons run
+ * on premultiplied values to mirror the Swift helper's analysis context.
+ */
+export declare function contentBoundingBox(data: Buffer | Uint8Array, width: number, height: number): ContentBox | null;
+/** Raw pixel copy of a region — the Swift `image.cropping(to:)` equivalent. */
+export declare function cropImage(src: PNG, box: ContentBox): PNG;
+/**
+ * Draw `src` centered on a transparent reference-sized canvas, scaled to fit
+ * while PRESERVING its aspect ratio. Unlike a stretch-to-fit (which distorts
+ * proportions when the aspect ratios differ), this keeps the rendered shape
+ * honest: an aspect mismatch shows as transparent letterbox/pillarbox padding
+ * rather than a squished image, while the canvas stays exactly reference-sized
+ * so the pair still overlays 1:1.
+ *
+ * Compositing happens in premultiplied space with an unpremultiply on the way
+ * out, mirroring the Swift context roundtrip. Resampling is bilinear (see the
+ * module docblock for why CG's `.high` filter is not reproducible).
+ */
+export declare function fitPad(src: PNG, width: number, height: number): PNG | null;
+/** Result of one helper invocation — the process-free CLI contract. */
+export interface TrimAlignResult {
+    status: number;
+    stdout: string;
+    stderr: string;
+}
+/**
+ * The helper entry point, argv-compatible with the retired Swift helper:
+ * `[in.png, out.png]` or `[in.png, out.png, aligned.png, reference.png]`.
+ * Crops the input to its content bounding box, optionally writes a
+ * reference-sized aligned copy (best-effort), and reports a TRIMDIMS line.
+ * Same exit codes, same stdout/stderr shape as the Swift helper.
+ */
+export declare function runTrimAlign(argv: string[]): TrimAlignResult;
+//# sourceMappingURL=trim-align.d.ts.map

package/dist/src/yaml/steps/trim-align.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"trim-align.d.ts","sourceRoot":"","sources":["../../../../src/yaml/steps/trim-align.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AAGH,OAAO,EAAE,GAAG,EAAE,MAAM,OAAO,CAAC;AAE5B,0DAA0D;AAC1D,MAAM,WAAW,UAAU;IACzB,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,KAAK,EAAE,MAAM,CAAC;IACd,MAAM,EAAE,MAAM,CAAC;CAChB;AAED,+CAA+C;AAC/C,eAAO,MAAM,eAAe,KAAK,CAAC;AAClC,eAAO,MAAM,oBAAoB,KAAK,CAAC;AACvC,eAAO,MAAM,oBAAoB,KAAK,CAAC;AACvC,eAAO,MAAM,sBAAsB,KAAK,CAAC;AA0BzC;;;;;;;;;;;;;GAaG;AACH,wBAAgB,kBAAkB,CAChC,IAAI,EAAE,MAAM,GAAG,UAAU,EACzB,KAAK,EAAE,MAAM,EACb,MAAM,EAAE,MAAM,GACb,UAAU,GAAG,IAAI,CAkGnB;AAED,+EAA+E;AAC/E,wBAAgB,SAAS,CAAC,GAAG,EAAE,GAAG,EAAE,GAAG,EAAE,UAAU,GAAG,GAAG,CAOxD;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,MAAM,CAAC,GAAG,EAAE,GAAG,EAAE,KAAK,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG,GAAG,GAAG,IAAI,CAyE1E;AAED,uEAAuE;AACvE,MAAM,WAAW,eAAe;IAC9B,MAAM,EAAE,MAAM,CAAC;IACf,MAAM,EAAE,MAAM,CAAC;IACf,MAAM,EAAE,MAAM,CAAC;CAChB;AAED;;;;;;GAMG;AACH,wBAAgB,YAAY,CAAC,IAAI,EAAE,MAAM,EAAE,GAAG,eAAe,CA6E5D"}