@invarn/cibuild 2.3.8 → 2.4.1

package/dist/src/cli.js

@@ -77,6 +77,14 @@ Examples:
     `);
         process.exit(0);
     }
+    // Handle fidelity-trim — the internal trim/align helper spawned by the
+    // generated UI-fidelity render scripts (kept flag-free and fast: it must
+    // behave identically whether invoked as `ci`, the pkg binary re-exec, or
+    // `node dist/cli.cjs`).
+    if (args[0] === "fidelity-trim") {
+        const { handleFidelityTrimCommand } = await import("./commands/fidelity-trim.js");
+        process.exit(handleFidelityTrimCommand(args.slice(1)));
+    }
     // Handle envman subcommand — delegates to envman CLI
     if (args[0] === "envman") {
         // Re-write process.argv so envman sees its own args

package/dist/src/commands/fidelity-trim.d.ts

@@ -0,0 +1,13 @@
+/**
+ * `ci fidelity-trim <in.png> <out.png> [<aligned.png> <reference.png>]`
+ *
+ * Internal command: the trim/align helper the generated UI-fidelity render
+ * scripts (iOS + Android) spawn after each screen renders. It crops a render
+ * to its content bounding box in place, optionally writes a reference-sized
+ * aligned copy, and prints a `TRIMDIMS` line — the exact argv/stdout/exit-code
+ * contract of the retired embedded Swift (CoreGraphics) helper, now pure JS so
+ * the same bytes run on macOS and Linux workers.
+ */
+/** Runs the helper and returns its exit status (0 on success). */
+export declare function handleFidelityTrimCommand(args: string[]): number;
+//# sourceMappingURL=fidelity-trim.d.ts.map

package/dist/src/commands/fidelity-trim.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"fidelity-trim.d.ts","sourceRoot":"","sources":["../../../src/commands/fidelity-trim.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAIH,kEAAkE;AAClE,wBAAgB,yBAAyB,CAAC,IAAI,EAAE,MAAM,EAAE,GAAG,MAAM,CAKhE"}

package/dist/src/commands/fidelity-trim.js

@@ -0,0 +1,21 @@
+/**
+ * `ci fidelity-trim <in.png> <out.png> [<aligned.png> <reference.png>]`
+ *
+ * Internal command: the trim/align helper the generated UI-fidelity render
+ * scripts (iOS + Android) spawn after each screen renders. It crops a render
+ * to its content bounding box in place, optionally writes a reference-sized
+ * aligned copy, and prints a `TRIMDIMS` line — the exact argv/stdout/exit-code
+ * contract of the retired embedded Swift (CoreGraphics) helper, now pure JS so
+ * the same bytes run on macOS and Linux workers.
+ */
+import { runTrimAlign } from '../yaml/steps/trim-align.js';
+/** Runs the helper and returns its exit status (0 on success). */
+export function handleFidelityTrimCommand(args) {
+    const result = runTrimAlign(args);
+    if (result.stdout)
+        process.stdout.write(result.stdout);
+    if (result.stderr)
+        process.stderr.write(result.stderr);
+    return result.status;
+}
+//# sourceMappingURL=fidelity-trim.js.map

package/dist/src/commands/fidelity-trim.test.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Tests for the `ci fidelity-trim` command — the process seam over the pure
+ * trim/align core. The generated fidelity render scripts (iOS + Android) spawn
+ * this instead of the retired Swift helper, so the argv contract, TRIMDIMS
+ * stdout line, and exit codes are load-bearing.
+ */
+export {};
+//# sourceMappingURL=fidelity-trim.test.d.ts.map

package/dist/src/commands/fidelity-trim.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"fidelity-trim.test.d.ts","sourceRoot":"","sources":["../../../src/commands/fidelity-trim.test.ts"],"names":[],"mappings":"AAAA;;;;;GAKG"}

package/dist/src/commands/fidelity-trim.test.js

@@ -0,0 +1,79 @@
+/**
+ * Tests for the `ci fidelity-trim` command — the process seam over the pure
+ * trim/align core. The generated fidelity render scripts (iOS + Android) spawn
+ * this instead of the retired Swift helper, so the argv contract, TRIMDIMS
+ * stdout line, and exit codes are load-bearing.
+ */
+import { mkdtempSync, rmSync, writeFileSync, readFileSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { PNG } from 'pngjs';
+import { describe, test, expect, afterAll, jest } from '@jest/globals';
+import { handleFidelityTrimCommand } from './fidelity-trim.js';
+const dirs = [];
+function scene() {
+    const dir = mkdtempSync(join(tmpdir(), 'fidelity-trim-cmd-'));
+    dirs.push(dir);
+    return dir;
+}
+afterAll(() => {
+    for (const dir of dirs) {
+        try {
+            rmSync(dir, { recursive: true, force: true });
+        }
+        catch {
+            // best effort
+        }
+    }
+});
+function craftOpaqueRect(w, h, x, y, rw, rh) {
+    const png = new PNG({ width: w, height: h });
+    for (let yy = y; yy < y + rh; yy++) {
+        for (let xx = x; xx < x + rw; xx++) {
+            const i = (yy * w + xx) * 4;
+            png.data[i] = 255;
+            png.data[i + 3] = 255;
+        }
+    }
+    return PNG.sync.write(png);
+}
+describe('handleFidelityTrimCommand', () => {
+    test('trims in place, prints TRIMDIMS to stdout, returns 0', () => {
+        const dir = scene();
+        const input = join(dir, 'in.png');
+        writeFileSync(input, craftOpaqueRect(100, 80, 10, 20, 30, 40));
+        const out = join(dir, 'out.png');
+        const stdout = jest.spyOn(process.stdout, 'write').mockImplementation(() => true);
+        const stderr = jest.spyOn(process.stderr, 'write').mockImplementation(() => true);
+        try {
+            const status = handleFidelityTrimCommand([input, out]);
+            expect(status).toBe(0);
+            const printed = stdout.mock.calls.map((c) => String(c[0])).join('');
+            expect(printed).toBe('TRIMDIMS 30 40 0 0 100 80\n');
+            expect(stderr).not.toHaveBeenCalled();
+        }
+        finally {
+            stdout.mockRestore();
+            stderr.mockRestore();
+        }
+        const trimmed = PNG.sync.read(readFileSync(out));
+        expect([trimmed.width, trimmed.height]).toEqual([30, 40]);
+    });
+    test('propagates the helper exit code and stderr on failure', () => {
+        const dir = scene();
+        const stdout = jest.spyOn(process.stdout, 'write').mockImplementation(() => true);
+        const stderr = jest.spyOn(process.stderr, 'write').mockImplementation(() => true);
+        try {
+            const status = handleFidelityTrimCommand([join(dir, 'missing.png'), join(dir, 'out.png')]);
+            expect(status).toBe(65);
+            const printed = stderr.mock.calls.map((c) => String(c[0])).join('');
+            expect(printed).toContain('could not read image at');
+            expect(stdout).not.toHaveBeenCalled();
+        }
+        finally {
+            stdout.mockRestore();
+            stderr.mockRestore();
+        }
+    });
+});
+//# sourceMappingURL=fidelity-trim.test.js.map

package/dist/src/yaml/steps/render-post-processor.d.ts

@@ -6,15 +6,20 @@
  * reference-sized aligned copy, and the reported dimensions (rendered px /
  * logical pt / reference px). It operates on PNGs regardless of how they were
  * produced -- a SwiftUI `ImageRenderer` render or a Compose/Roborazzi render --
- * so crop/align/dimension behavior cannot drift between platforms. Both render
- * paths run on the macOS runner fleet, so the pixel work is one CoreGraphics
- * helper invoked in Swift's script-interpreter mode; the surrounding JS
- * orchestration is spliced into each platform's generated runtime script.
+ * so crop/align/dimension behavior cannot drift between platforms.
  *
- * This module is consumed by `ui-fidelity-render.ts` (iOS) and, once it lands,
- * the Android render step. The iOS step embeds these exact strings, so its
- * generated script -- and therefore its rendered output -- stays byte-identical
- * to before this extraction.
+ * The pixel work is the pure-JS trim/align helper in trim-align.ts, invoked
+ * through the ci binary (`ci fidelity-trim`) -- the one artifact present on
+ * every backend -- so iOS and Android run the SAME bytes on macOS and Linux
+ * alike. It replaced an embedded CoreGraphics/ImageIO helper that ran via
+ * `swift` in script-interpreter mode and therefore could not run on Linux
+ * workers (fidelity-linux 06); the bounding-box, fit-pad, and TRIMDIMS
+ * semantics are a faithful port of that helper, guarded by a pixel-identity
+ * corpus gate (trim-align-corpus.test.ts).
+ *
+ * This module is consumed by `ui-fidelity-render.ts` (iOS) and
+ * `ui-fidelity-render-android.ts`; the surrounding JS orchestration is spliced
+ * into each platform's generated runtime script.
  */
 /**
  * Runtime support for trimming the rendered output (package_source variants).
@@ -25,25 +30,15 @@
  * non-transparent pixels, so the rendered artifact is the component itself,
  * tight -- no canvas, no background ambiguity for the human comparing screens.
  *
- * The crop is done by a small CoreGraphics helper run in Swift's
- * script-interpreter mode (so it needs no extra harness target and reuses the
- * one `swift` the runner already has). Best-effort: a trim failure is logged
- * (warn-and-continue) and the untrimmed render is kept -- a cosmetic post-step
- * never fails an otherwise good render. This is prep, not scoring: it produces
- * a tighter image for the human's judgment and computes nothing about
- * fidelity.
- */
-/**
- * The CoreGraphics trim/align helper source, run via
- * `swift <Trim.swift> <in> <out> <aligned> <ref>` (script-interpreter mode).
- * Crops a PNG to its content bounding box (transparent or uniform-background
- * margins), writes a reference-sized aligned copy, and prints a TRIMDIMS line.
+ * Best-effort: a trim failure is logged (warn-and-continue) and the untrimmed
+ * render is kept -- a cosmetic post-step never fails an otherwise good render.
+ * This is prep, not scoring: it produces a tighter image for the human's
+ * judgment and computes nothing about fidelity.
  *
- * Exported so a real-toolchain test can exercise the pixel logic directly --
- * the fake `swift` in the unit tests cannot, which is why a background-detection
- * bug shipped twice undetected before a real-pixel guard existed.
+ * NOTE: the comments inside the stage string ship inside generated runtime
+ * scripts. Keep them free of platform-toolchain references -- there is a unit
+ * gate asserting the stage never mentions the old interpreter.
  */
-export declare const TRIM_HELPER_SWIFT_SOURCE: string;
 export declare const RENDER_SCRIPT_TRIM_STAGE: string;
 /** A rendered/reference/source dimension pair in pixels, as TRIMDIMS reports. */
 export type TrimDimsPair = [number, number];
@@ -53,21 +48,46 @@ export interface TrimDims {
     reference: TrimDimsPair;
     source: TrimDimsPair;
 }
+/** How the stage will spawn the fidelity-trim helper. */
+export interface TrimHelperInvocation {
+    cmd: string;
+    args: string[];
+}
 /**
- * The pure, platform-neutral dimension-reporting helpers embedded in the
- * trim-stage script. `parseTrimDims` reads the helper's TRIMDIMS stdout line;
- * `roundTwo` is the logical-pt rounding primitive.
+ * The platform-neutral helpers embedded in the trim-stage script.
+ * `parseTrimDims` reads the helper's TRIMDIMS stdout line; `roundTwo` is the
+ * logical-pt rounding primitive; `trimHelperInvocation` resolves how the
+ * generated script reaches `ci fidelity-trim` at run time, and
+ * `runTrimHelper` spawns it.
  */
 export interface PostProcessorInternals {
     parseTrimDims(stdout: string): TrimDims | null;
     roundTwo(value: number): number;
+    trimHelperInvocation(args: string[]): TrimHelperInvocation;
+    runTrimHelper(args: string[]): {
+        status: number | null;
+        stdout: string;
+        stderr: string;
+    };
 }
 /**
  * Evaluates the embedded trim-stage source and returns its pure helpers, so
  * unit tests exercise exactly the code that ships inside the runtime script
- * (mirrors getRenderScriptInternals in ui-fidelity-render.ts). The other
- * trim-stage functions reference runtime globals (fs, path, runSwift, ...)
- * only when called, so defining them here is harmless.
+ * (mirrors getRenderScriptInternals in ui-fidelity-render.ts). `cp` and
+ * `process` are injectable so the invocation/spawn seams are testable; the
+ * other trim-stage functions reference runtime globals (fs, path, ...) only
+ * when called, so defining them here is harmless.
+ */
+export declare function getPostProcessorInternals(overrides?: {
+    cp?: unknown;
+    processRef?: unknown;
+}): PostProcessorInternals;
+/**
+ * Resolves the on-disk JS entrypoint of this cibuild installation's CLI
+ * (dist/cli.cjs), for callers that spawn a generated render script directly
+ * (the preview harnesses) and must hand it a working CIBUILD_CLI_JS. Returns
+ * null when no built CLI exists nearby (e.g. running from src under jest) --
+ * the script then falls back to `ci` on PATH.
  */
-export declare function getPostProcessorInternals(): PostProcessorInternals;
+export declare function resolveCliJsPath(): string | null;
 //# sourceMappingURL=render-post-processor.d.ts.map

package/dist/src/yaml/steps/render-post-processor.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"render-post-processor.d.ts","sourceRoot":"","sources":["../../../../src/yaml/steps/render-post-processor.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;GAiBG;AAEH;;;;;;;;;;;;;;;;GAgBG;AACH;;;;;;;;;GASG;AACH,eAAO,MAAM,wBAAwB,EAAE,MA8JpB,CAAC;AAEpB,eAAO,MAAM,wBAAwB,EAAE,MAsFtC,CAAC;AAEF,iFAAiF;AACjF,MAAM,MAAM,YAAY,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;AAE5C,iFAAiF;AACjF,MAAM,WAAW,QAAQ;IACvB,QAAQ,EAAE,YAAY,CAAC;IACvB,SAAS,EAAE,YAAY,CAAC;IACxB,MAAM,EAAE,YAAY,CAAC;CACtB;AAED;;;;GAIG;AACH,MAAM,WAAW,sBAAsB;IACrC,aAAa,CAAC,MAAM,EAAE,MAAM,GAAG,QAAQ,GAAG,IAAI,CAAC;IAC/C,QAAQ,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAAC;CACjC;AAED;;;;;;GAMG;AACH,wBAAgB,yBAAyB,IAAI,sBAAsB,CAMlE"}
+{"version":3,"file":"render-post-processor.d.ts","sourceRoot":"","sources":["../../../../src/yaml/steps/render-post-processor.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;GAsBG;AAMH;;;;;;;;;;;;;;;;;GAiBG;AACH,eAAO,MAAM,wBAAwB,EAAE,MA+GtC,CAAC;AAEF,iFAAiF;AACjF,MAAM,MAAM,YAAY,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;AAE5C,iFAAiF;AACjF,MAAM,WAAW,QAAQ;IACvB,QAAQ,EAAE,YAAY,CAAC;IACvB,SAAS,EAAE,YAAY,CAAC;IACxB,MAAM,EAAE,YAAY,CAAC;CACtB;AAED,yDAAyD;AACzD,MAAM,WAAW,oBAAoB;IACnC,GAAG,EAAE,MAAM,CAAC;IACZ,IAAI,EAAE,MAAM,EAAE,CAAC;CAChB;AAED;;;;;;GAMG;AACH,MAAM,WAAW,sBAAsB;IACrC,aAAa,CAAC,MAAM,EAAE,MAAM,GAAG,QAAQ,GAAG,IAAI,CAAC;IAC/C,QAAQ,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAAC;IAChC,oBAAoB,CAAC,IAAI,EAAE,MAAM,EAAE,GAAG,oBAAoB,CAAC;IAC3D,aAAa,CAAC,IAAI,EAAE,MAAM,EAAE,GAAG;QAAE,MAAM,EAAE,MAAM,GAAG,IAAI,CAAC;QAAC,MAAM,EAAE,MAAM,CAAC;QAAC,MAAM,EAAE,MAAM,CAAA;KAAE,CAAC;CAC1F;AAED;;;;;;;GAOG;AACH,wBAAgB,yBAAyB,CAAC,SAAS,CAAC,EAAE;IACpD,EAAE,CAAC,EAAE,OAAO,CAAC;IACb,UAAU,CAAC,EAAE,OAAO,CAAC;CACtB,GAAG,sBAAsB,CASzB;AAED;;;;;;GAMG;AACH,wBAAgB,gBAAgB,IAAI,MAAM,GAAG,IAAI,CAqBhD"}

package/dist/src/yaml/steps/render-post-processor.js

@@ -6,16 +6,24 @@
  * reference-sized aligned copy, and the reported dimensions (rendered px /
  * logical pt / reference px). It operates on PNGs regardless of how they were
  * produced -- a SwiftUI `ImageRenderer` render or a Compose/Roborazzi render --
- * so crop/align/dimension behavior cannot drift between platforms. Both render
- * paths run on the macOS runner fleet, so the pixel work is one CoreGraphics
- * helper invoked in Swift's script-interpreter mode; the surrounding JS
- * orchestration is spliced into each platform's generated runtime script.
+ * so crop/align/dimension behavior cannot drift between platforms.
  *
- * This module is consumed by `ui-fidelity-render.ts` (iOS) and, once it lands,
- * the Android render step. The iOS step embeds these exact strings, so its
- * generated script -- and therefore its rendered output -- stays byte-identical
- * to before this extraction.
+ * The pixel work is the pure-JS trim/align helper in trim-align.ts, invoked
+ * through the ci binary (`ci fidelity-trim`) -- the one artifact present on
+ * every backend -- so iOS and Android run the SAME bytes on macOS and Linux
+ * alike. It replaced an embedded CoreGraphics/ImageIO helper that ran via
+ * `swift` in script-interpreter mode and therefore could not run on Linux
+ * workers (fidelity-linux 06); the bounding-box, fit-pad, and TRIMDIMS
+ * semantics are a faithful port of that helper, guarded by a pixel-identity
+ * corpus gate (trim-align-corpus.test.ts).
+ *
+ * This module is consumed by `ui-fidelity-render.ts` (iOS) and
+ * `ui-fidelity-render-android.ts`; the surrounding JS orchestration is spliced
+ * into each platform's generated runtime script.
  */
+import { existsSync } from 'node:fs';
+import { dirname, join } from 'node:path';
+import { fileURLToPath } from 'node:url';
 /**
  * Runtime support for trimming the rendered output (package_source variants).
  *
@@ -25,197 +33,17 @@
  * non-transparent pixels, so the rendered artifact is the component itself,
  * tight -- no canvas, no background ambiguity for the human comparing screens.
  *
- * The crop is done by a small CoreGraphics helper run in Swift's
- * script-interpreter mode (so it needs no extra harness target and reuses the
- * one `swift` the runner already has). Best-effort: a trim failure is logged
- * (warn-and-continue) and the untrimmed render is kept -- a cosmetic post-step
- * never fails an otherwise good render. This is prep, not scoring: it produces
- * a tighter image for the human's judgment and computes nothing about
- * fidelity.
- */
-/**
- * The CoreGraphics trim/align helper source, run via
- * `swift <Trim.swift> <in> <out> <aligned> <ref>` (script-interpreter mode).
- * Crops a PNG to its content bounding box (transparent or uniform-background
- * margins), writes a reference-sized aligned copy, and prints a TRIMDIMS line.
+ * Best-effort: a trim failure is logged (warn-and-continue) and the untrimmed
+ * render is kept -- a cosmetic post-step never fails an otherwise good render.
+ * This is prep, not scoring: it produces a tighter image for the human's
+ * judgment and computes nothing about fidelity.
  *
- * Exported so a real-toolchain test can exercise the pixel logic directly --
- * the fake `swift` in the unit tests cannot, which is why a background-detection
- * bug shipped twice undetected before a real-pixel guard existed.
+ * NOTE: the comments inside the stage string ship inside generated runtime
+ * scripts. Keep them free of platform-toolchain references -- there is a unit
+ * gate asserting the stage never mentions the old interpreter.
  */
-export const TRIM_HELPER_SWIFT_SOURCE = [
-    '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)',
-    '}',
-    '',
-    '// Draw `image` centered on a transparent reference-sized canvas, scaled to fit',
-    '// while PRESERVING its aspect ratio. Unlike `resize` (which stretches to exact',
-    '// dimensions and 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.',
-    '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()',
-    '}',
-    '',
-    '// 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.',
-    '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))',
-    '    // Tight tolerance: exact solid fills match, near-colored content does not.',
-    '    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]))',
-    '    }',
-    '    // Pass 1: bounding box of all non-transparent pixels.',
-    '    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)',
-    '    // Detect a uniform opaque background from the corners of the opaque box.',
-    '    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',
-    '            }',
-    '        }',
-    '    }',
-    '    // No uniform background: the opaque box is the content.',
-    '    guard let bg = background else { return opaqueBox }',
-    '    // Pass 2: within the opaque box, bound everything that is not the background.',
-    '    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 }',
-    '        }',
-    '    }',
-    '    // All background, no distinct content: keep the opaque box, never crop to nothing.',
-    '    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)',
-    '}',
-    '',
-    '// Optional aligned output: the trimmed image fit onto a reference-sized',
-    '// canvas, preserving aspect ratio (transparent letterbox/pillarbox padding',
-    '// when aspect ratios differ). A reference-sized, undistorted overlay pair.',
-    '// Best-effort; dimensions are reported either way.',
-    '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)',
-    '        }',
-    '    }',
-    '}',
-    '',
-    '// Report: rendered (trimmed) px, reference px (0 0 when unavailable), then',
-    '// the pre-trim source px so the caller can log how much margin was removed.',
-    'print("TRIMDIMS " + String(croppedWidth) + " " + String(croppedHeight) + " " + String(referenceWidth) + " " + String(referenceHeight) + " " + String(image.width) + " " + String(image.height))'
-].join('\n') + '\n';
 export const RENDER_SCRIPT_TRIM_STAGE = '\n// ---- render trimming stage (package_source variants) ----\n' +
-    'var TRIM_HELPER_SWIFT = ' +
-    JSON.stringify(TRIM_HELPER_SWIFT_SOURCE) +
-    ';\n' +
     String.raw `
-// Write the helper into the harness dir once (idempotent across screens).
-function ensureTrimHelper(harnessDir) {
-  var helperPath = path.join(harnessDir, 'Trim.swift');
-  if (!fs.existsSync(helperPath)) {
-    fs.writeFileSync(helperPath, TRIM_HELPER_SWIFT);
-  }
-  return helperPath;
-}
-
 // Round to two decimals, keeping the value a plain number.
 function roundTwo(value) {
   return Math.round(value * 100) / 100;
@@ -244,11 +72,48 @@ function parseTrimDims(stdout) {
   return null;
 }
 
+// Resolve how to reach the ci CLI's fidelity-trim helper from inside this
+// generated script. Three homes, in order:
+//  1. CIBUILD_CLI_JS -- an explicit JS entrypoint (preview harnesses, tests),
+//     run under the same node executing this script.
+//  2. The pkg-built ci binary re-executing itself -- the production runner
+//     path, where this script runs under the pkg bootstrap and
+//     process.execPath IS the ci binary.
+//  3. A ci on PATH (brew/npm installs).
+function trimHelperInvocation(args) {
+  if (process.env.CIBUILD_CLI_JS) {
+    return {
+      cmd: process.execPath,
+      args: [process.env.CIBUILD_CLI_JS, 'fidelity-trim'].concat(args),
+    };
+  }
+  if (process.pkg) {
+    return { cmd: process.execPath, args: ['fidelity-trim'].concat(args) };
+  }
+  return { cmd: 'ci', args: ['fidelity-trim'].concat(args) };
+}
+
+// Run the trim/align helper (pure JS inside the ci binary; the argv, TRIMDIMS
+// stdout line, and exit codes are the retired CoreGraphics helper's contract).
+function runTrimHelper(args) {
+  var invocation = trimHelperInvocation(args);
+  var result = cp.spawnSync(invocation.cmd, invocation.args, {
+    encoding: 'utf-8',
+    maxBuffer: 16 * 1024 * 1024,
+  });
+  if (result.stdout) process.stdout.write(result.stdout);
+  if (result.stderr) process.stderr.write(result.stderr);
+  if (result.error) {
+    result.status = result.status == null ? 127 : result.status;
+    result.stderr = (result.stderr || '') + String(result.error.message || result.error);
+  }
+  return result;
+}
+
 // Crop the rendered PNG in place to its content bounding box, write an aligned
 // copy resized to the reference, and record the dimensions on the entry.
 // Best-effort: a failure is logged and the untrimmed render is kept.
-function trimRenderedImage(entry, renderedPath, harnessDir) {
-  var helperPath = ensureTrimHelper(harnessDir);
+function trimRenderedImage(entry, renderedPath) {
   var alignedRelative = 'ui-fidelity/aligned/' + entry.screen + '.png';
   var alignedPath = path.resolve(artifactsDir, alignedRelative);
   var referencePath =
@@ -260,7 +125,7 @@ function trimRenderedImage(entry, renderedPath, harnessDir) {
   } catch (mkdirError) {
     // best effort -- the helper reports a missing output dir itself
   }
-  var result = runSwift([helperPath, renderedPath, renderedPath, alignedPath, referencePath]);
+  var result = runTrimHelper([renderedPath, renderedPath, alignedPath, referencePath]);
   if (result.status !== 0) {
     logError(
       'trim failed for ' + renderedPath +
@@ -291,13 +156,47 @@ function trimRenderedImage(entry, renderedPath, harnessDir) {
 /**
  * Evaluates the embedded trim-stage source and returns its pure helpers, so
  * unit tests exercise exactly the code that ships inside the runtime script
- * (mirrors getRenderScriptInternals in ui-fidelity-render.ts). The other
- * trim-stage functions reference runtime globals (fs, path, runSwift, ...)
- * only when called, so defining them here is harmless.
+ * (mirrors getRenderScriptInternals in ui-fidelity-render.ts). `cp` and
+ * `process` are injectable so the invocation/spawn seams are testable; the
+ * other trim-stage functions reference runtime globals (fs, path, ...) only
+ * when called, so defining them here is harmless.
+ */
+export function getPostProcessorInternals(overrides) {
+    const factory = new Function('cp', 'process', RENDER_SCRIPT_TRIM_STAGE +
+        '\nreturn { parseTrimDims: parseTrimDims, roundTwo: roundTwo, ' +
+        'trimHelperInvocation: trimHelperInvocation, runTrimHelper: runTrimHelper };');
+    return factory(overrides?.cp, overrides?.processRef ?? process);
+}
+/**
+ * Resolves the on-disk JS entrypoint of this cibuild installation's CLI
+ * (dist/cli.cjs), for callers that spawn a generated render script directly
+ * (the preview harnesses) and must hand it a working CIBUILD_CLI_JS. Returns
+ * null when no built CLI exists nearby (e.g. running from src under jest) --
+ * the script then falls back to `ci` on PATH.
  */
-export function getPostProcessorInternals() {
-    const factory = new Function(RENDER_SCRIPT_TRIM_STAGE +
-        '\nreturn { parseTrimDims: parseTrimDims, roundTwo: roundTwo };');
-    return factory();
+export function resolveCliJsPath() {
+    let moduleDir;
+    try {
+        moduleDir = dirname(fileURLToPath(import.meta.url));
+    }
+    catch {
+        return null;
+    }
+    const candidates = [
+        // Bundled: import.meta.url is shimmed to dist/cli.cjs itself.
+        join(moduleDir, 'cli.cjs'),
+        // Compiled layout: dist/src/yaml/steps/*.js -> dist/cli.cjs.
+        join(moduleDir, '..', '..', '..', 'cli.cjs'),
+    ];
+    for (const candidate of candidates) {
+        try {
+            if (existsSync(candidate))
+                return candidate;
+        }
+        catch {
+            // keep looking
+        }
+    }
+    return null;
 }
 //# sourceMappingURL=render-post-processor.js.map