@invarn/cibuild 2.3.8 → 2.4.1

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

@@ -1,16 +1,13 @@
 /**
  * Direct tests for the shared render-output post-processor.
  *
- * Two layers, matching how the module is built:
- *  - The platform-neutral dimension-reporting logic (TRIMDIMS parsing, the
- *    logical-pt rounding primitive) is pure JS embedded in the trim-stage
- *    script. It is evaluated out of the shipped string via
- *    getPostProcessorInternals() and tested directly, so these run in every
- *    CI pass.
- *  - The CoreGraphics pixel logic (content trim, uniform-background crop, the
- *    transparent-frame fallback, align-to-reference) cannot run under a fake
- *    `swift`, so it is exercised over crafted PNGs with the real toolchain,
- *    gated behind CIBUILD_UI_FIDELITY_REAL_SWIFT=1 (the same gate iOS uses).
+ * The dimension-reporting logic (TRIMDIMS parsing, the logical-pt rounding
+ * primitive) and the helper-invocation resolution are pure JS embedded in the
+ * trim-stage script. They are evaluated out of the shipped string via
+ * getPostProcessorInternals() and tested directly, so these run in every CI
+ * pass. The pixel logic itself lives in trim-align.ts (tested ungated in
+ * trim-align.test.ts); the Swift-vs-JS equivalence is guarded by the corpus
+ * gate in trim-align-corpus.test.ts.
  */
 export {};
 //# sourceMappingURL=render-post-processor.test.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"render-post-processor.test.d.ts","sourceRoot":"","sources":["../../../../src/yaml/steps/render-post-processor.test.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG"}
+{"version":3,"file":"render-post-processor.test.d.ts","sourceRoot":"","sources":["../../../../src/yaml/steps/render-post-processor.test.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG"}

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

@@ -1,22 +1,15 @@
 /**
  * Direct tests for the shared render-output post-processor.
  *
- * Two layers, matching how the module is built:
- *  - The platform-neutral dimension-reporting logic (TRIMDIMS parsing, the
- *    logical-pt rounding primitive) is pure JS embedded in the trim-stage
- *    script. It is evaluated out of the shipped string via
- *    getPostProcessorInternals() and tested directly, so these run in every
- *    CI pass.
- *  - The CoreGraphics pixel logic (content trim, uniform-background crop, the
- *    transparent-frame fallback, align-to-reference) cannot run under a fake
- *    `swift`, so it is exercised over crafted PNGs with the real toolchain,
- *    gated behind CIBUILD_UI_FIDELITY_REAL_SWIFT=1 (the same gate iOS uses).
+ * The dimension-reporting logic (TRIMDIMS parsing, the logical-pt rounding
+ * primitive) and the helper-invocation resolution are pure JS embedded in the
+ * trim-stage script. They are evaluated out of the shipped string via
+ * getPostProcessorInternals() and tested directly, so these run in every CI
+ * pass. The pixel logic itself lives in trim-align.ts (tested ungated in
+ * trim-align.test.ts); the Swift-vs-JS equivalence is guarded by the corpus
+ * gate in trim-align-corpus.test.ts.
  */
-import { spawnSync } from 'node:child_process';
-import { mkdtempSync, readFileSync, rmSync, writeFileSync } from 'node:fs';
-import { tmpdir } from 'node:os';
-import { join } from 'node:path';
-import { getPostProcessorInternals, TRIM_HELPER_SWIFT_SOURCE, } from './render-post-processor.js';
+import { getPostProcessorInternals, RENDER_SCRIPT_TRIM_STAGE, } from './render-post-processor.js';
 describe('dimension reporting (TRIMDIMS parsing)', () => {
     const { parseTrimDims } = getPostProcessorInternals();
     test('parses a well-formed TRIMDIMS line into rendered/reference/source px', () => {
@@ -63,176 +56,80 @@ describe('logical-pt rounding (roundTwo)', () => {
         expect(roundTwo(100 / 3)).toBe(33.33);
     });
 });
-// The CoreGraphics bounding-box/resize logic cannot run under a fake `swift`,
-// so it is exercised over crafted PNGs with the real toolchain. This is the
-// regression guard for the bug where a wrapper that fills its canvas with an
-// opaque .background(...) was not trimmed to its content: the renderer forces
-// the view into a fixed device frame whose margins are transparent, so the
-// helper must detect a solid background from the corners of the opaque region,
-// not the raw frame.
-describe('trim helper pixel logic (real toolchain)', () => {
-    const realSwiftTest = process.env.CIBUILD_UI_FIDELITY_REAL_SWIFT === '1' ? test : test.skip;
-    const { parseTrimDims } = getPostProcessorInternals();
-    const dirs = [];
-    afterAll(() => {
-        for (const dir of dirs) {
-            try {
-                rmSync(dir, { recursive: true, force: true });
-            }
-            catch {
-                // best effort
-            }
-        }
-    });
-    // PNG IHDR carries width/height as big-endian uint32 at byte offsets 16/20.
-    function pngSize(filePath) {
-        const buf = readFileSync(filePath);
-        return { width: buf.readUInt32BE(16), height: buf.readUInt32BE(20) };
-    }
-    // A parameterized fixture maker: paints opaque rectangles (colors in 0..1)
-    // onto an otherwise transparent canvas, so a single Swift program can craft
-    // every input shape the bounding-box logic must handle.
-    const MAKE_FIXTURE_SWIFT = [
-        'import Foundation',
-        'import ImageIO',
-        'import CoreGraphics',
-        'import UniformTypeIdentifiers',
-        'let out = CommandLine.arguments[1]',
-        'let spec = try! JSONSerialization.jsonObject(with: CommandLine.arguments[2].data(using: .utf8)!) as! [String: Any]',
-        'let w = spec["w"] as! Int, h = spec["h"] as! Int',
-        'let cs = CGColorSpaceCreateDeviceRGB()',
-        'let c = CGContext(data: nil, width: w, height: h, bitsPerComponent: 8, bytesPerRow: 0, space: cs, bitmapInfo: CGImageAlphaInfo.premultipliedLast.rawValue)!',
-        'c.clear(CGRect(x: 0, y: 0, width: w, height: h))',
-        'func num(_ v: Any) -> Double { return Double("\\(v)")! }',
-        'for r in spec["rects"] as! [[String: Any]] {',
-        '    c.setFillColor(red: num(r["r"]!), green: num(r["g"]!), blue: num(r["b"]!), alpha: num(r["a"]!))',
-        '    c.fill(CGRect(x: num(r["x"]!), y: num(r["y"]!), width: num(r["w"]!), height: num(r["h"]!)))',
-        '}',
-        'let d = CGImageDestinationCreateWithURL(URL(fileURLWithPath: out) as CFURL, UTType.png.identifier as CFString, 1, nil)!',
-        'CGImageDestinationAddImage(d, c.makeImage()!, nil)',
-        '_ = CGImageDestinationFinalize(d)',
-    ].join('\n') + '\n';
-    const RED = { r: 1, g: 0, b: 0, a: 1 };
-    const BLUE = { r: 0, g: 0, b: 1, a: 1 };
-    const WHITE = { r: 1, g: 1, b: 1, a: 1 };
-    const PINK = { r: 1, g: 240 / 255, b: 238 / 255, a: 1 };
-    // Prints "<r> <g> <b> <a>" (0..255) for one pixel, so a test can tell padding
-    // (transparent) apart from content (opaque) in an aligned image.
-    const PROBE_SWIFT = [
-        'import Foundation',
-        'import ImageIO',
-        'import CoreGraphics',
-        'let src = CGImageSourceCreateWithURL(URL(fileURLWithPath: CommandLine.arguments[1]) as CFURL, nil)!',
-        'let img = CGImageSourceCreateImageAtIndex(src, 0, nil)!',
-        'let x = Int(CommandLine.arguments[2])!, y = Int(CommandLine.arguments[3])!',
-        'let w = img.width, h = img.height',
-        'var data = [UInt8](repeating: 0, count: w * h * 4)',
-        'let cs = CGColorSpaceCreateDeviceRGB()',
-        'let c = CGContext(data: &data, width: w, height: h, bitsPerComponent: 8, bytesPerRow: w * 4, space: cs, bitmapInfo: CGImageAlphaInfo.premultipliedLast.rawValue)!',
-        'c.draw(img, in: CGRect(x: 0, y: 0, width: w, height: h))',
-        'let i = y * w * 4 + x * 4',
-        'print("\\(data[i]) \\(data[i+1]) \\(data[i+2]) \\(data[i+3])")',
-    ].join('\n') + '\n';
-    function scene() {
-        const dir = mkdtempSync(join(tmpdir(), 'ui-fidelity-postproc-'));
-        dirs.push(dir);
-        writeFileSync(join(dir, 'Make.swift'), MAKE_FIXTURE_SWIFT);
-        writeFileSync(join(dir, 'Trim.swift'), TRIM_HELPER_SWIFT_SOURCE);
-        writeFileSync(join(dir, 'Probe.swift'), PROBE_SWIFT);
-        return dir;
+// The generated scripts run under whatever node executes the step (a system
+// node, the pkg-built ci binary's bootstrap, or a preview harness), so the
+// stage must resolve how to reach the ci CLI's fidelity-trim helper at run
+// time. The resolution order is load-bearing: an explicit CIBUILD_CLI_JS
+// (preview harnesses, tests) wins, then the pkg self-exec (the production
+// runner path), then a `ci` on PATH.
+describe('trim stage — helper invocation resolution', () => {
+    function internalsWith(processRef) {
+        return getPostProcessorInternals({ processRef });
     }
-    // Alpha (0..255) of one pixel in a PNG.
-    function alphaAt(dir, filePath, x, y) {
-        const probe = spawnSync('swift', [join(dir, 'Probe.swift'), filePath, String(x), String(y)], {
-            encoding: 'utf-8',
+    test('an explicit CIBUILD_CLI_JS entrypoint wins and runs under this node', () => {
+        const { trimHelperInvocation } = internalsWith({
+            env: { CIBUILD_CLI_JS: '/opt/cibuild/cli.cjs' },
+            execPath: '/usr/local/bin/node',
         });
-        expect(probe.status).toBe(0);
-        return Number(probe.stdout.trim().split(/\s+/)[3]);
-    }
-    function craft(dir, name, w, h, rects) {
-        const out = join(dir, name);
-        const make = spawnSync('swift', [join(dir, 'Make.swift'), out, JSON.stringify({ w, h, rects })], { encoding: 'utf-8' });
-        expect(make.stderr + '').toBe('');
-        expect(make.status).toBe(0);
-        return out;
-    }
-    function trim(dir, input, output, aligned, reference) {
-        const args = [join(dir, 'Trim.swift'), input, output];
-        if (aligned && reference)
-            args.push(aligned, reference);
-        const result = spawnSync('swift', args, { encoding: 'utf-8' });
-        expect(result.status).toBe(0);
-        return result;
-    }
-    realSwiftTest('trims a transparent frame down to its single content rectangle', () => {
-        const dir = scene();
-        const input = craft(dir, 'in.png', 200, 200, [{ x: 30, y: 50, w: 60, h: 40, ...RED }]);
-        const out = join(dir, 'out.png');
-        trim(dir, input, out);
-        expect(pngSize(out)).toEqual({ width: 60, height: 40 });
-    }, 600_000);
-    realSwiftTest('crops an opaque uniform-background wrapper to its content card', () => {
-        const dir = scene();
-        // 420x320 transparent canvas, 375x200 white wrapper, 343x168 pink card.
-        const input = craft(dir, 'in.png', 420, 320, [
-            { x: 20, y: 40, w: 375, h: 200, ...WHITE },
-            { x: 36, y: 56, w: 343, h: 168, ...PINK },
-        ]);
-        const out = join(dir, 'out.png');
-        trim(dir, input, out);
-        // Lands on the content card, NOT the white wrapper (375x200) or the raw
-        // canvas (420x320).
-        expect(pngSize(out)).toEqual({ width: 343, height: 168 });
-    }, 600_000);
-    realSwiftTest('trims only transparency when the opaque corners disagree (fallback)', () => {
-        const dir = scene();
-        // Two differently-colored halves: the opaque bounding box is 80x80 but its
-        // corners are not one uniform color, so no background is detected and only
-        // the transparent margin is removed.
-        const input = craft(dir, 'in.png', 120, 120, [
-            { x: 20, y: 20, w: 40, h: 80, ...RED },
-            { x: 60, y: 20, w: 40, h: 80, ...BLUE },
-        ]);
-        const out = join(dir, 'out.png');
-        trim(dir, input, out);
-        expect(pngSize(out)).toEqual({ width: 80, height: 80 });
-    }, 600_000);
-    realSwiftTest('writes a reference-sized aligned image and reports all three dimensions', () => {
-        const dir = scene();
-        const input = craft(dir, 'in.png', 200, 200, [{ x: 30, y: 50, w: 60, h: 40, ...RED }]);
-        const reference = craft(dir, 'ref.png', 100, 50, [{ x: 0, y: 0, w: 100, h: 50, ...BLUE }]);
-        const out = join(dir, 'out.png');
-        const aligned = join(dir, 'aligned.png');
-        const result = trim(dir, input, out, aligned, reference);
-        // The trimmed render is the content; the aligned copy is fit onto a
-        // reference-sized canvas (preserving aspect) for a 1:1 overlay.
-        expect(pngSize(out)).toEqual({ width: 60, height: 40 });
-        expect(pngSize(aligned)).toEqual({ width: 100, height: 50 });
-        // The TRIMDIMS line reports rendered (trimmed) / reference / pre-trim
-        // source px, parsed by the same helper the runtime uses.
-        expect(parseTrimDims(result.stdout)).toEqual({
-            rendered: [60, 40],
-            reference: [100, 50],
-            source: [200, 200],
+        expect(trimHelperInvocation(['in.png', 'out.png'])).toEqual({
+            cmd: '/usr/local/bin/node',
+            args: ['/opt/cibuild/cli.cjs', 'fidelity-trim', 'in.png', 'out.png'],
+        });
+    });
+    test('under the pkg bootstrap the ci binary re-executes itself', () => {
+        const { trimHelperInvocation } = internalsWith({
+            env: {},
+            pkg: {},
+            execPath: '/opt/homebrew/bin/ci',
+        });
+        expect(trimHelperInvocation(['in.png', 'out.png', 'aligned.png', 'ref.png'])).toEqual({
+            cmd: '/opt/homebrew/bin/ci',
+            args: ['fidelity-trim', 'in.png', 'out.png', 'aligned.png', 'ref.png'],
         });
-    }, 600_000);
-    realSwiftTest('fits a wide render into a square reference without distortion (transparent letterbox)', () => {
-        const dir = scene();
-        // Content fills its canvas: a 2:1 render (80x40), all opaque red.
-        const input = craft(dir, 'in.png', 80, 40, [{ x: 0, y: 0, w: 80, h: 40, ...RED }]);
-        // Square 1:1 reference (50x50) — a deliberately different aspect ratio.
-        const reference = craft(dir, 'ref.png', 50, 50, [{ x: 0, y: 0, w: 50, h: 50, ...BLUE }]);
-        const out = join(dir, 'out.png');
-        const aligned = join(dir, 'aligned.png');
-        trim(dir, input, out, aligned, reference);
-        // Aligned stays exactly reference-sized (overlay pair holds).
-        expect(pngSize(aligned)).toEqual({ width: 50, height: 50 });
-        // Aspect preserved: the 2:1 content fits by width (50x25) and is centered,
-        // so both letterbox bands are transparent while the center is opaque
-        // content. A stretch-to-fit would make every one of these opaque.
-        expect(alphaAt(dir, aligned, 25, 3)).toBe(0); // top band
-        expect(alphaAt(dir, aligned, 25, 46)).toBe(0); // bottom band
-        expect(alphaAt(dir, aligned, 25, 25)).toBe(255); // content (center)
-    }, 600_000);
+    });
+    test('falls back to a ci on PATH', () => {
+        const { trimHelperInvocation } = internalsWith({
+            env: {},
+            execPath: '/usr/local/bin/node',
+        });
+        expect(trimHelperInvocation(['in.png', 'out.png'])).toEqual({
+            cmd: 'ci',
+            args: ['fidelity-trim', 'in.png', 'out.png'],
+        });
+    });
+    test('runTrimHelper reports a spawn error as status 127 with the message appended', () => {
+        const calls = [];
+        const fakeCp = {
+            spawnSync: (...args) => {
+                calls.push(args);
+                return { status: null, stdout: '', stderr: '', error: new Error('ENOENT: ci not found') };
+            },
+        };
+        const { runTrimHelper } = getPostProcessorInternals({
+            cp: fakeCp,
+            processRef: {
+                env: {},
+                execPath: '/usr/local/bin/node',
+                stdout: { write: () => true },
+                stderr: { write: () => true },
+            },
+        });
+        const result = runTrimHelper(['in.png', 'out.png']);
+        expect(result.status).toBe(127);
+        expect(result.stderr).toContain('ENOENT: ci not found');
+        expect(calls).toHaveLength(1);
+        expect(calls[0][0]).toBe('ci');
+    });
+});
+// The whole point of the port (fidelity-linux 06): the shipped trim stage must
+// not reference the platform toolchain in any form — no helper source, no
+// interpreter spawn — so the Android render path can run on Linux workers.
+describe('trim stage — no platform-toolchain invocation remains', () => {
+    test('the stage script has no swift reference at all', () => {
+        expect(RENDER_SCRIPT_TRIM_STAGE.toLowerCase()).not.toContain('swift');
+    });
+    test('the stage spawns the fidelity-trim helper instead', () => {
+        expect(RENDER_SCRIPT_TRIM_STAGE).toContain("'fidelity-trim'");
+    });
 });
 //# sourceMappingURL=render-post-processor.test.js.map

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

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

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