@invarn/cibuild 2.9.6 → 2.9.8

package/dist/src/yaml/steps/test-config.d.ts

@@ -1,5 +0,0 @@
-import type { CIConfig } from '../../types.js';
-export declare const testConfig: CIConfig;
-/** Config without peer cache (no NFS peer runner) */
-export declare const testConfigNoPeer: CIConfig;
-//# sourceMappingURL=test-config.d.ts.map

package/dist/src/yaml/steps/test-config.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"test-config.d.ts","sourceRoot":"","sources":["../../../../src/yaml/steps/test-config.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,gBAAgB,CAAC;AAE/C,eAAO,MAAM,UAAU,EAAE,QAexB,CAAC;AAEF,qDAAqD;AACrD,eAAO,MAAM,gBAAgB,EAAE,QAM9B,CAAC"}

package/dist/src/yaml/steps/test-config.js

@@ -1,25 +0,0 @@
-export const testConfig = {
-    artifactsDir: './artifacts',
-    interpreters: {
-        python: 'python3',
-        ruby: 'ruby',
-        node: 'node',
-        bash: '/bin/bash',
-    },
-    maxConcurrentJobs: 1,
-    paths: {
-        buildsDir: '.ci-builds',
-        cacheDir: '.ci-cache',
-        peerCacheDir: '/Volumes/My Shared Files/cibuild-peer-cache',
-        derivedDataDir: '~/Library/Developer/Xcode/DerivedData',
-    },
-};
-/** Config without peer cache (no NFS peer runner) */
-export const testConfigNoPeer = {
-    ...testConfig,
-    paths: {
-        ...testConfig.paths,
-        peerCacheDir: undefined,
-    },
-};
-//# sourceMappingURL=test-config.js.map

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

@@ -1,28 +0,0 @@
-/**
- * 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`).
- */
-export {};
-//# sourceMappingURL=trim-align-corpus.test.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"trim-align-corpus.test.d.ts","sourceRoot":"","sources":["../../../../src/yaml/steps/trim-align-corpus.test.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG"}

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

@@ -1,383 +0,0 @@
-/**
- * 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

@@ -1,87 +0,0 @@
-/**
- * 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
- * (`TRIMDIMS <rW> <rH> <refW> <refH> <srcW> <srcH> <offX> <offY>` — the crop
- * origin appended 2026-08-01, older consumers ignore it). 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

@@ -1 +0,0 @@
-{"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;;;;;;;;GAQG;AACH,wBAAgB,YAAY,CAAC,IAAI,EAAE,MAAM,EAAE,GAAG,eAAe,CA8F5D"}