@invarn/cibuild 1.9.8 → 2.0.0

package/dist/src/yaml/steps/ui-fidelity-render.test.js

@@ -0,0 +1,770 @@
+/**
+ * Tests for the ui-fidelity-render step.
+ *
+ * The runtime tests execute the generated node script for real inside a temp
+ * project directory, with a PATH-shimmed fake `swift` binary so harness
+ * builds and renders are deterministic. Fake swift behavior is driven by env
+ * vars (FAKE_SWIFT_PROBE_FAIL, FAKE_SWIFT_COMPILE_FAIL, FAKE_SWIFT_RUN_FAIL,
+ * FAKE_SWIFT_RUN_SILENT). Like the real toolchain, its failure diagnostics
+ * embed the absolute harness package path, so the suite can prove those
+ * paths never reach protocol-result.json.
+ *
+ * The committed SwiftPM fixture (test/fixtures/ui-fidelity-package) is wired
+ * through the harness with the fake toolchain in every run; set
+ * CIBUILD_UI_FIDELITY_REAL_SWIFT=1 to also build and render it with the real
+ * Swift toolchain (macOS with Xcode required, slow).
+ */
+import { describe, test, expect, afterAll } from '@jest/globals';
+import { spawnSync } from 'node:child_process';
+import { chmodSync, existsSync, mkdirSync, mkdtempSync, readdirSync, readFileSync, realpathSync, rmSync, writeFileSync, } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { dirname, join, resolve } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { DEFAULT_RENDER_SIZE, DEFAULT_SCALE, UiFidelityRenderStepExecutor, generateRenderScript, getRenderScriptInternals, parseRenderSize, parseScale, } from './ui-fidelity-render.js';
+import { clearRegistry, getStepMetadata, hasStep } from './registry.js';
+import { initializeStepRegistry } from './index.js';
+import { testConfig } from './test-config.js';
+const PNG_MAGIC = Buffer.from([0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a]);
+/** The committed SwiftPM fixture used by examples/ui-fidelity-render.yml. */
+const FIXTURE_PACKAGE = resolve(dirname(fileURLToPath(import.meta.url)), '../../../test/fixtures/ui-fidelity-package');
+/**
+ * Fake `swift` CLI. Mirrors the exact invocations the render script makes:
+ *   swift build --package-path <dir> --target RenderProbe
+ *   swift build --package-path <dir> --product Render_<Screen>
+ *   swift run --package-path <dir> --skip-build Render_<Screen> <output.png>
+ */
+const FAKE_SWIFT_LINES = [
+    '#!/bin/bash',
+    '[ -n "$FAKE_SWIFT_LOG" ] && echo "$*" >> "$FAKE_SWIFT_LOG"',
+    'cmd="$1"; shift',
+    'case "$cmd" in',
+    '  build)',
+    '    product=""; target=""; pkg=""',
+    '    while [ $# -gt 0 ]; do',
+    '      case "$1" in',
+    '        --product) product="$2"; shift 2 ;;',
+    '        --target) target="$2"; shift 2 ;;',
+    '        --package-path) pkg="$2"; shift 2 ;;',
+    '        *) shift ;;',
+    '      esac',
+    '    done',
+    '    name="${product:-$target}"',
+    '    if [ "$name" = "RenderProbe" ]; then',
+    '      if [ -n "$FAKE_SWIFT_PROBE_FAIL" ]; then',
+    '        echo "$pkg/Sources/RenderProbe/Probe.swift:1:8: error: could not resolve package dependencies" >&2',
+    '        exit 1',
+    '      fi',
+    '      exit 0',
+    '    fi',
+    '    screen="${name#Render_}"',
+    '    case ",$FAKE_SWIFT_COMPILE_FAIL," in',
+    '      *",$screen,"*)',
+    '        echo "$pkg/Sources/Render_$screen/Render.swift:7:20: error: cannot find $screen in scope" >&2',
+    '        exit 1 ;;',
+    '    esac',
+    '    exit 0 ;;',
+    '  run)',
+    '    pos=()',
+    '    while [ $# -gt 0 ]; do',
+    '      case "$1" in',
+    '        --package-path) shift 2 ;;',
+    '        --skip-build) shift ;;',
+    '        *) pos+=("$1"); shift ;;',
+    '      esac',
+    '    done',
+    '    name="${pos[0]}"; out="${pos[1]}"',
+    '    screen="${name#Render_}"',
+    '    case ",$FAKE_SWIFT_RUN_FAIL," in',
+    '      *",$screen,"*)',
+    '        echo "Fatal error: render failed for $screen" >&2',
+    '        exit 1 ;;',
+    '    esac',
+    '    case ",$FAKE_SWIFT_RUN_SILENT," in',
+    '      *",$screen,"*)',
+    '        exit 0 ;;',
+    '    esac',
+    "    printf '\\x89PNG\\r\\n\\x1a\\n' > \"$out\"",
+    '    printf \'fake-render:%s\' "$screen" >> "$out"',
+    '    exit 0 ;;',
+    '  *)',
+    '    exit 0 ;;',
+    'esac',
+];
+const tempDirs = [];
+afterAll(() => {
+    for (const dir of tempDirs) {
+        try {
+            rmSync(dir, { recursive: true, force: true });
+        }
+        catch {
+            // best effort
+        }
+    }
+});
+function makeProject(params) {
+    const dir = mkdtempSync(join(tmpdir(), 'ui-fidelity-test-'));
+    tempDirs.push(dir);
+    mkdirSync(join(dir, '.ci', 'inputs'), { recursive: true });
+    const packageDir = join(dir, 'user-package');
+    mkdirSync(packageDir, { recursive: true });
+    const binDir = join(dir, 'bin');
+    mkdirSync(binDir, { recursive: true });
+    const swiftPath = join(binDir, 'swift');
+    writeFileSync(swiftPath, FAKE_SWIFT_LINES.join('\n') + '\n');
+    chmodSync(swiftPath, 0o755);
+    if (params !== undefined) {
+        writeFileSync(join(dir, '.ci', 'inputs', 'params.json'), typeof params === 'string' ? params : JSON.stringify(params));
+    }
+    return { dir, packageDir, binDir };
+}
+function writeReference(project, basename, label = basename) {
+    writeFileSync(join(project.dir, '.ci', 'inputs', basename), Buffer.concat([PNG_MAGIC, Buffer.from('ref:' + label)]));
+}
+async function buildScript(project, inputs = {}) {
+    const executor = new UiFidelityRenderStepExecutor();
+    const step = await executor.execute({ package_path: project.packageDir, target: 'FixtureViews', ...inputs }, {}, testConfig);
+    return step.script;
+}
+function runScript(project, script, env = {}) {
+    return spawnSync('node', ['-e', script], {
+        cwd: project.dir,
+        encoding: 'utf-8',
+        env: {
+            ...process.env,
+            PATH: project.binDir + ':' + (process.env.PATH ?? ''),
+            ...env,
+        },
+    });
+}
+function readResult(project) {
+    const resultPath = join(project.dir, '.ci', 'artifacts', 'protocol-result.json');
+    expect(existsSync(resultPath)).toBe(true);
+    return JSON.parse(readFileSync(resultPath, 'utf-8'));
+}
+function artifact(project, relative) {
+    return join(project.dir, '.ci', 'artifacts', relative);
+}
+function isPng(filePath) {
+    const head = readFileSync(filePath).subarray(0, PNG_MAGIC.length);
+    return head.equals(PNG_MAGIC);
+}
+/**
+ * Asserts that no error message in the result document contains an absolute
+ * runner-filesystem path: not the project dir (the script's cwd), not the OS
+ * temp dir (where harness packages live), in either symlinked
+ * (/var/folders/...) or resolved (/private/var/...) form.
+ */
+function expectNoAbsolutePathLeaks(project, result) {
+    const forbidden = new Set();
+    for (const dir of [project.dir, tmpdir()]) {
+        forbidden.add(dir);
+        try {
+            forbidden.add(realpathSync(dir));
+        }
+        catch {
+            // nonexistent — literal form only
+        }
+    }
+    for (const screen of result.screens) {
+        const message = screen.error?.message ?? '';
+        for (const dir of forbidden) {
+            expect(message).not.toContain(dir);
+        }
+    }
+}
+describe('registry integration', () => {
+    test('ui-fidelity-render is registered with its input schema', () => {
+        clearRegistry();
+        initializeStepRegistry();
+        expect(hasStep('ui-fidelity-render')).toBe(true);
+        const metadata = getStepMetadata('ui-fidelity-render');
+        expect(metadata?.platform).toBe('ios');
+        const inputs = metadata?.inputs ?? {};
+        expect(Object.keys(inputs).sort()).toEqual([
+            'package_path',
+            'render_size',
+            'scale',
+            'target',
+        ]);
+        expect(inputs.package_path.required).toBe(true);
+        expect(inputs.target.required).toBe(true);
+        expect(inputs.render_size.required).toBe(false);
+        expect(inputs.render_size.default).toBe(DEFAULT_RENDER_SIZE);
+        expect(inputs.scale.required).toBe(false);
+        expect(inputs.scale.default).toBe(DEFAULT_SCALE);
+    });
+});
+describe('UiFidelityRenderStepExecutor', () => {
+    test('returns a node StepDef', async () => {
+        const executor = new UiFidelityRenderStepExecutor();
+        const step = await executor.execute({ package_path: './pkg', target: 'MyViews' }, {}, testConfig);
+        expect(step.kind).toBe('node');
+        expect(step.name).toBe('ui-fidelity-render');
+        expect(step.script.length).toBeGreaterThan(0);
+    });
+    test('bakes resolved defaults into the script config', async () => {
+        const executor = new UiFidelityRenderStepExecutor();
+        const step = await executor.execute({ package_path: './pkg', target: 'MyViews' }, {}, testConfig);
+        expect(step.script).toContain('"width":393');
+        expect(step.script).toContain('"height":852');
+        expect(step.script).toContain('"scale":2');
+        expect(step.script).toContain('"target":"MyViews"');
+    });
+    test('honors explicit render_size and scale', async () => {
+        const executor = new UiFidelityRenderStepExecutor();
+        const step = await executor.execute({ package_path: './pkg', target: 'MyViews', render_size: '430x932', scale: 3 }, {}, testConfig);
+        expect(step.script).toContain('"width":430');
+        expect(step.script).toContain('"height":932');
+        expect(step.script).toContain('"scale":3');
+    });
+    test('throws when package_path is missing', async () => {
+        const executor = new UiFidelityRenderStepExecutor();
+        await expect(executor.execute({ target: 'MyViews' }, {}, testConfig)).rejects.toThrow("Missing required input 'package_path'");
+    });
+    test('throws when target is missing', async () => {
+        const executor = new UiFidelityRenderStepExecutor();
+        await expect(executor.execute({ package_path: './pkg' }, {}, testConfig)).rejects.toThrow("Missing required input 'target'");
+    });
+    test('rejects a target that is not a Swift module identifier', async () => {
+        const executor = new UiFidelityRenderStepExecutor();
+        await expect(executor.execute({ package_path: './pkg', target: 'My Views' }, {}, testConfig)).rejects.toThrow(/target/i);
+    });
+    test('rejects malformed render_size', async () => {
+        const executor = new UiFidelityRenderStepExecutor();
+        await expect(executor.execute({ package_path: './pkg', target: 'MyViews', render_size: 'huge' }, {}, testConfig)).rejects.toThrow(/render_size/);
+    });
+});
+describe('render size and scale parsing', () => {
+    test('default render size is 393x852 device points', () => {
+        expect(DEFAULT_RENDER_SIZE).toBe('393x852');
+        expect(parseRenderSize(DEFAULT_RENDER_SIZE)).toEqual({ width: 393, height: 852 });
+    });
+    test('default scale is 2', () => {
+        expect(DEFAULT_SCALE).toBe(2);
+        expect(parseScale(DEFAULT_SCALE)).toBe(2);
+    });
+    test('parses explicit sizes and string scales', () => {
+        expect(parseRenderSize('430x932')).toEqual({ width: 430, height: 932 });
+        expect(parseScale('3')).toBe(3);
+    });
+    test('rejects zero or malformed values', () => {
+        expect(() => parseRenderSize('0x852')).toThrow(/render_size/);
+        expect(() => parseRenderSize('393by852')).toThrow(/render_size/);
+        expect(() => parseScale('-1')).toThrow(/scale/);
+        expect(() => parseScale('big')).toThrow(/scale/);
+    });
+});
+describe('harness source generation', () => {
+    const internals = getRenderScriptInternals();
+    const options = {
+        packagePath: '/abs/path/to/user-package',
+        packageRef: 'user-package',
+        target: 'FixtureViews',
+        width: 393,
+        height: 852,
+        scale: 2,
+    };
+    test('Package.swift declares one executable target and product per screen', () => {
+        const manifest = internals.generateHarnessPackageSwift(['HomeView', 'SettingsView'], options);
+        expect(manifest).toContain('.executableTarget(name: "Render_HomeView"');
+        expect(manifest).toContain('.executableTarget(name: "Render_SettingsView"');
+        expect(manifest).toContain('.executable(name: "Render_HomeView", targets: ["Render_HomeView"])');
+        expect(manifest).toContain('.executable(name: "Render_SettingsView", targets: ["Render_SettingsView"])');
+        expect(manifest).toContain('.executableTarget(name: "RenderProbe"');
+        expect(manifest).toContain('.package(path: "/abs/path/to/user-package")');
+        expect(manifest).toContain('.product(name: "FixtureViews", package: "user-package")');
+        expect(manifest).toContain('platforms: [.macOS(.v13)]');
+    });
+    test('screen source constructs the view with a parameterless init', () => {
+        const source = internals.generateScreenSwift('HomeView', options);
+        expect(source).toContain('import FixtureViews');
+        expect(source).toContain('import SwiftUI');
+        expect(source).toContain('let view = HomeView().frame(width: width, height: height)');
+        expect(source).toContain('let width: CGFloat = 393');
+        expect(source).toContain('let height: CGFloat = 852');
+        expect(source).toContain('renderer.scale = 2');
+        expect(source).toContain('ImageRenderer(content: view)');
+        expect(source).toContain('@main');
+        expect(source).toContain('@MainActor');
+        expect(source).toContain('CGImageDestinationFinalize');
+        // Regression: .utf8 must apply to the concatenated message, not the
+        // trailing variable (caught by a real swift build).
+        expect(source).toContain('Data(("could not write PNG to " + outputPath).utf8)');
+        expect(source).not.toContain('outputPath.utf8');
+    });
+    test('probe source imports the target without referencing screens', () => {
+        const source = internals.generateProbeSwift(options);
+        expect(source).toContain('import FixtureViews');
+        expect(source).not.toContain('HomeView');
+    });
+    test('swift string literals escape quotes and backslashes', () => {
+        expect(internals.swiftStringLiteral('plain')).toBe('"plain"');
+        expect(internals.swiftStringLiteral('a"b')).toBe('"a\\"b"');
+        expect(internals.swiftStringLiteral('a\\b')).toBe('"a\\\\b"');
+    });
+});
+describe('render script runtime', () => {
+    test('happy path renders every screen and exits 0', async () => {
+        const project = makeProject({
+            screens: { HomeView: 'home.png', SettingsView: 'settings.png' },
+        });
+        writeReference(project, 'home.png');
+        writeReference(project, 'settings.png');
+        const script = await buildScript(project);
+        const run = runScript(project, script);
+        expect(run.status).toBe(0);
+        expect(isPng(artifact(project, 'ui-fidelity/rendered/HomeView.png'))).toBe(true);
+        expect(isPng(artifact(project, 'ui-fidelity/rendered/SettingsView.png'))).toBe(true);
+        expect(isPng(artifact(project, 'ui-fidelity/references/HomeView.png'))).toBe(true);
+        expect(isPng(artifact(project, 'ui-fidelity/references/SettingsView.png'))).toBe(true);
+        expect(readResult(project)).toEqual({
+            renderer: 'imagerenderer-spm',
+            screens: [
+                {
+                    screen: 'HomeView',
+                    status: 'rendered',
+                    error: null,
+                    reference_image_path: 'ui-fidelity/references/HomeView.png',
+                    rendered_image_path: 'ui-fidelity/rendered/HomeView.png',
+                },
+                {
+                    screen: 'SettingsView',
+                    status: 'rendered',
+                    error: null,
+                    reference_image_path: 'ui-fidelity/references/SettingsView.png',
+                    rendered_image_path: 'ui-fidelity/rendered/SettingsView.png',
+                },
+            ],
+        });
+    });
+    test('result entries follow params.json order and use relative paths', async () => {
+        const project = makeProject({
+            screens: { ZetaView: 'zeta.png', AlphaView: 'alpha.png' },
+        });
+        writeReference(project, 'zeta.png');
+        writeReference(project, 'alpha.png');
+        const run = runScript(project, await buildScript(project));
+        expect(run.status).toBe(0);
+        const result = readResult(project);
+        expect(result.screens.map((s) => s.screen)).toEqual(['ZetaView', 'AlphaView']);
+        for (const screen of result.screens) {
+            expect(screen.reference_image_path).not.toMatch(/^\//);
+            expect(screen.rendered_image_path).not.toMatch(/^\//);
+        }
+    });
+    test('a broken screen fails alone; other screens still render', async () => {
+        const project = makeProject({
+            screens: { HomeView: 'home.png', MissingView: 'missing-view.png' },
+        });
+        writeReference(project, 'home.png');
+        writeReference(project, 'missing-view.png');
+        const run = runScript(project, await buildScript(project), {
+            FAKE_SWIFT_COMPILE_FAIL: 'MissingView',
+        });
+        expect(run.status).not.toBe(0);
+        const result = readResult(project);
+        expect(result.screens).toHaveLength(2);
+        const [home, missing] = result.screens;
+        expect(home.screen).toBe('HomeView');
+        expect(home.status).toBe('rendered');
+        expect(home.error).toBeNull();
+        expect(isPng(artifact(project, 'ui-fidelity/rendered/HomeView.png'))).toBe(true);
+        expect(missing.screen).toBe('MissingView');
+        expect(missing.status).toBe('render_failed');
+        expect(missing.error?.code).toBe('VIEW_COMPILE_FAILED');
+        expect(missing.error?.message).toContain('cannot find MissingView in scope');
+        expect(missing.rendered_image_path).toBeNull();
+        expect(existsSync(artifact(project, 'ui-fidelity/rendered/MissingView.png'))).toBe(false);
+    });
+    test('a render-time crash marks only that screen RENDER_FAILED', async () => {
+        const project = makeProject({
+            screens: { HomeView: 'home.png', SettingsView: 'settings.png' },
+        });
+        writeReference(project, 'home.png');
+        writeReference(project, 'settings.png');
+        const run = runScript(project, await buildScript(project), {
+            FAKE_SWIFT_RUN_FAIL: 'SettingsView',
+        });
+        expect(run.status).not.toBe(0);
+        const result = readResult(project);
+        const [home, settings] = result.screens;
+        expect(home.status).toBe('rendered');
+        expect(settings.status).toBe('render_failed');
+        expect(settings.error?.code).toBe('RENDER_FAILED');
+        expect(settings.error?.message).toContain('render failed for SettingsView');
+    });
+    test('two screens sharing one reference get two distinct copies', async () => {
+        const project = makeProject({
+            screens: { HomeView: 'shared.png', SettingsView: 'shared.png' },
+        });
+        writeReference(project, 'shared.png');
+        const run = runScript(project, await buildScript(project));
+        expect(run.status).toBe(0);
+        const homeRef = artifact(project, 'ui-fidelity/references/HomeView.png');
+        const settingsRef = artifact(project, 'ui-fidelity/references/SettingsView.png');
+        expect(existsSync(homeRef)).toBe(true);
+        expect(existsSync(settingsRef)).toBe(true);
+        expect(readFileSync(homeRef).equals(readFileSync(settingsRef))).toBe(true);
+        const result = readResult(project);
+        expect(result.screens[0].reference_image_path).toBe('ui-fidelity/references/HomeView.png');
+        expect(result.screens[1].reference_image_path).toBe('ui-fidelity/references/SettingsView.png');
+    });
+    test('a missing reference fails that screen with REFERENCE_MISSING', async () => {
+        const project = makeProject({
+            screens: { HomeView: 'home.png', SettingsView: 'nonexistent.png' },
+        });
+        writeReference(project, 'home.png');
+        const run = runScript(project, await buildScript(project));
+        expect(run.status).not.toBe(0);
+        const result = readResult(project);
+        const [home, settings] = result.screens;
+        expect(home.status).toBe('rendered');
+        expect(settings.status).toBe('render_failed');
+        expect(settings.error?.code).toBe('REFERENCE_MISSING');
+        expect(settings.reference_image_path).toBeNull();
+        expect(settings.rendered_image_path).toBeNull();
+        expect(existsSync(artifact(project, 'ui-fidelity/references/SettingsView.png'))).toBe(false);
+    });
+    test("a reference of '..' or '.' fails only that screen with REFERENCE_MISSING", async () => {
+        const project = makeProject({
+            screens: { HomeView: '..', AboutView: '.', SettingsView: 'settings.png' },
+        });
+        writeReference(project, 'settings.png');
+        const run = runScript(project, await buildScript(project));
+        expect(run.status).not.toBe(0);
+        const [home, about, settings] = readResult(project).screens;
+        expect(home.status).toBe('render_failed');
+        expect(home.error?.code).toBe('REFERENCE_MISSING');
+        expect(about.status).toBe('render_failed');
+        expect(about.error?.code).toBe('REFERENCE_MISSING');
+        // Per-screen isolation: the valid screen still renders.
+        expect(settings.status).toBe('rendered');
+        expect(settings.error).toBeNull();
+        expect(isPng(artifact(project, 'ui-fidelity/rendered/SettingsView.png'))).toBe(true);
+    });
+    test('a reference that is a directory fails only that screen', async () => {
+        const project = makeProject({
+            screens: { HomeView: 'home-dir.png', SettingsView: 'settings.png' },
+        });
+        mkdirSync(join(project.dir, '.ci', 'inputs', 'home-dir.png'));
+        writeReference(project, 'settings.png');
+        const run = runScript(project, await buildScript(project));
+        expect(run.status).not.toBe(0);
+        const [home, settings] = readResult(project).screens;
+        expect(home.status).toBe('render_failed');
+        expect(home.error?.code).toBe('REFERENCE_MISSING');
+        expect(home.reference_image_path).toBeNull();
+        expect(settings.status).toBe('rendered');
+        expect(isPng(artifact(project, 'ui-fidelity/rendered/SettingsView.png'))).toBe(true);
+    });
+    test('a harness-level failure marks every screen RENDER_UNSUPPORTED', async () => {
+        const project = makeProject({
+            screens: { HomeView: 'home.png', SettingsView: 'settings.png' },
+        });
+        writeReference(project, 'home.png');
+        writeReference(project, 'settings.png');
+        const run = runScript(project, await buildScript(project), {
+            FAKE_SWIFT_PROBE_FAIL: '1',
+        });
+        expect(run.status).not.toBe(0);
+        const result = readResult(project);
+        expect(result.screens).toHaveLength(2);
+        for (const screen of result.screens) {
+            expect(screen.status).toBe('render_failed');
+            expect(screen.error?.code).toBe('RENDER_UNSUPPORTED');
+            expect(screen.error?.message).toContain('could not resolve package dependencies');
+            expect(screen.rendered_image_path).toBeNull();
+        }
+    });
+    test('a nonexistent package path marks every screen RENDER_UNSUPPORTED', async () => {
+        const project = makeProject({ screens: { HomeView: 'home.png' } });
+        writeReference(project, 'home.png');
+        const script = await buildScript(project, {
+            package_path: join(project.dir, 'no-such-package'),
+        });
+        const run = runScript(project, script);
+        expect(run.status).not.toBe(0);
+        const result = readResult(project);
+        expect(result.screens[0].error?.code).toBe('RENDER_UNSUPPORTED');
+    });
+    test('absent params.json fails with an empty-screens result document', async () => {
+        const project = makeProject();
+        const run = runScript(project, await buildScript(project));
+        expect(run.status).not.toBe(0);
+        expect(run.stderr).toContain('params.json');
+        expect(readResult(project)).toEqual({ renderer: 'imagerenderer-spm', screens: [] });
+    });
+    test('malformed params.json fails with an empty-screens result document', async () => {
+        const project = makeProject('{ not json');
+        const run = runScript(project, await buildScript(project));
+        expect(run.status).not.toBe(0);
+        expect(run.stderr).toContain('params.json');
+        expect(readResult(project)).toEqual({ renderer: 'imagerenderer-spm', screens: [] });
+    });
+    test('params.json without a screens object fails the same way', async () => {
+        const project = makeProject({ views: { HomeView: 'home.png' } });
+        const run = runScript(project, await buildScript(project));
+        expect(run.status).not.toBe(0);
+        expect(readResult(project)).toEqual({ renderer: 'imagerenderer-spm', screens: [] });
+    });
+    test('screens given as an array fails like malformed params', async () => {
+        const project = makeProject({ screens: ['HomeView'] });
+        const run = runScript(project, await buildScript(project));
+        expect(run.status).not.toBe(0);
+        expect(readResult(project)).toEqual({ renderer: 'imagerenderer-spm', screens: [] });
+    });
+    test('an empty screens object succeeds with an empty result document', async () => {
+        const project = makeProject({ screens: {} });
+        const logPath = join(project.dir, 'swift-invocations.log');
+        const run = runScript(project, await buildScript(project), { FAKE_SWIFT_LOG: logPath });
+        expect(run.status).toBe(0);
+        expect(readResult(project)).toEqual({ renderer: 'imagerenderer-spm', screens: [] });
+        // No screens means the harness is never built: swift is never invoked.
+        expect(existsSync(logPath)).toBe(false);
+    });
+    test('a screen name that is not a Swift identifier never reaches generated Swift', async () => {
+        const injection = 'HomeView()); }; import Foundation //';
+        const project = makeProject({
+            screens: { [injection]: 'evil.png', SettingsView: 'settings.png' },
+        });
+        writeReference(project, 'evil.png');
+        writeReference(project, 'settings.png');
+        const logPath = join(project.dir, 'swift-invocations.log');
+        const run = runScript(project, await buildScript(project), {
+            FAKE_SWIFT_LOG: logPath,
+            UI_FIDELITY_KEEP_HARNESS: '1',
+        });
+        expect(run.status).not.toBe(0);
+        const [bad, good] = readResult(project).screens;
+        expect(bad.screen).toBe(injection);
+        expect(bad.status).toBe('render_failed');
+        expect(bad.error?.code).toBe('INVALID_SCREEN_NAME');
+        expect(bad.rendered_image_path).toBeNull();
+        expect(good.status).toBe('rendered');
+        // The injected name never appears in any swift invocation, and the
+        // synthesized harness contains sources only for the valid screen.
+        const invocations = readFileSync(logPath, 'utf-8');
+        expect(invocations).not.toContain('import Foundation //');
+        const probeArgs = invocations.trim().split('\n')[0].split(' ');
+        const harnessDir = probeArgs[probeArgs.indexOf('--package-path') + 1];
+        tempDirs.push(harnessDir);
+        expect(readdirSync(join(harnessDir, 'Sources')).sort()).toEqual([
+            'RenderProbe',
+            'Render_SettingsView',
+        ]);
+        expect(readFileSync(join(harnessDir, 'Package.swift'), 'utf-8')).not.toContain('import Foundation //');
+    });
+    test('respects CIBUILD_ARTIFACTS_DIR', async () => {
+        const project = makeProject({ screens: { HomeView: 'home.png' } });
+        writeReference(project, 'home.png');
+        const run = runScript(project, await buildScript(project), {
+            CIBUILD_ARTIFACTS_DIR: 'custom-artifacts',
+        });
+        expect(run.status).toBe(0);
+        const resultPath = join(project.dir, 'custom-artifacts', 'protocol-result.json');
+        expect(existsSync(resultPath)).toBe(true);
+        expect(isPng(join(project.dir, 'custom-artifacts', 'ui-fidelity', 'rendered', 'HomeView.png'))).toBe(true);
+    });
+    test('synthesizes the harness on disk: probe first, then per-screen build and run', async () => {
+        const project = makeProject({
+            screens: { HomeView: 'home.png', SettingsView: 'settings.png' },
+        });
+        writeReference(project, 'home.png');
+        writeReference(project, 'settings.png');
+        const logPath = join(project.dir, 'swift-invocations.log');
+        const run = runScript(project, await buildScript(project), {
+            FAKE_SWIFT_LOG: logPath,
+            UI_FIDELITY_KEEP_HARNESS: '1',
+        });
+        expect(run.status).toBe(0);
+        const invocations = readFileSync(logPath, 'utf-8').trim().split('\n');
+        expect(invocations[0]).toContain('--target RenderProbe');
+        expect(invocations[1]).toContain('--product Render_HomeView');
+        expect(invocations[2]).toMatch(/^run /);
+        expect(invocations[2]).toContain('Render_HomeView');
+        expect(invocations[3]).toContain('--product Render_SettingsView');
+        expect(invocations[4]).toContain('Render_SettingsView');
+        const probeArgs = invocations[0].split(' ');
+        const harnessDir = probeArgs[probeArgs.indexOf('--package-path') + 1];
+        tempDirs.push(harnessDir);
+        expect(existsSync(join(harnessDir, 'Package.swift'))).toBe(true);
+        const manifest = readFileSync(join(harnessDir, 'Package.swift'), 'utf-8');
+        expect(manifest).toContain('.executableTarget(name: "Render_HomeView"');
+        expect(manifest).toContain('.executableTarget(name: "Render_SettingsView"');
+        const homeSource = readFileSync(join(harnessDir, 'Sources', 'Render_HomeView', 'Render.swift'), 'utf-8');
+        expect(homeSource).toContain('HomeView().frame(width: width, height: height)');
+        expect(existsSync(join(harnessDir, 'Sources', 'RenderProbe', 'Probe.swift'))).toBe(true);
+    });
+    test('a nonexistent relative package path is reported as configured, never resolved', async () => {
+        const project = makeProject({ screens: { HomeView: 'home.png' } });
+        writeReference(project, 'home.png');
+        const script = await buildScript(project, { package_path: 'no-such-package' });
+        const run = runScript(project, script);
+        expect(run.status).not.toBe(0);
+        const result = readResult(project);
+        expect(result.screens[0].error?.code).toBe('RENDER_UNSUPPORTED');
+        expect(result.screens[0].error?.message).toContain('no-such-package');
+        expectNoAbsolutePathLeaks(project, result);
+    });
+    test('an absolute package path is replaced by a placeholder in error messages', async () => {
+        const project = makeProject({ screens: { HomeView: 'home.png' } });
+        writeReference(project, 'home.png');
+        const script = await buildScript(project, {
+            package_path: join(project.dir, 'no-such-package'),
+        });
+        const run = runScript(project, script);
+        expect(run.status).not.toBe(0);
+        const result = readResult(project);
+        expect(result.screens[0].error?.code).toBe('RENDER_UNSUPPORTED');
+        expect(result.screens[0].error?.message).toContain('<package_path>');
+        expectNoAbsolutePathLeaks(project, result);
+    });
+    test('probe-failure diagnostics are scrubbed of absolute harness and package paths', async () => {
+        const project = makeProject({ screens: { HomeView: 'home.png' } });
+        writeReference(project, 'home.png');
+        const script = await buildScript(project, { package_path: 'user-package' });
+        const run = runScript(project, script, { FAKE_SWIFT_PROBE_FAIL: '1' });
+        expect(run.status).not.toBe(0);
+        const result = readResult(project);
+        const message = result.screens[0].error?.message ?? '';
+        expect(result.screens[0].error?.code).toBe('RENDER_UNSUPPORTED');
+        expect(message).toContain('the package at user-package does not build');
+        expect(message).toContain('<harness>/Sources/RenderProbe/Probe.swift');
+        expectNoAbsolutePathLeaks(project, result);
+    });
+    test('compiler diagnostics for a broken screen are scrubbed of absolute paths', async () => {
+        const project = makeProject({
+            screens: { HomeView: 'home.png', MissingView: 'missing-view.png' },
+        });
+        writeReference(project, 'home.png');
+        writeReference(project, 'missing-view.png');
+        const run = runScript(project, await buildScript(project), {
+            FAKE_SWIFT_COMPILE_FAIL: 'MissingView',
+        });
+        expect(run.status).not.toBe(0);
+        const result = readResult(project);
+        const missing = result.screens[1];
+        expect(missing.error?.code).toBe('VIEW_COMPILE_FAILED');
+        expect(missing.error?.message).toContain('<harness>/Sources/Render_MissingView/Render.swift');
+        expect(missing.error?.message).toContain('cannot find MissingView in scope');
+        expectNoAbsolutePathLeaks(project, result);
+    });
+    test('a renderer that exits 0 without a PNG reports the artifacts-relative path', async () => {
+        const project = makeProject({ screens: { HomeView: 'home.png' } });
+        writeReference(project, 'home.png');
+        const run = runScript(project, await buildScript(project), {
+            FAKE_SWIFT_RUN_SILENT: 'HomeView',
+        });
+        expect(run.status).not.toBe(0);
+        const result = readResult(project);
+        expect(result.screens[0].error?.code).toBe('RENDER_FAILED');
+        expect(result.screens[0].error?.message).toContain('.ci/artifacts/ui-fidelity/rendered/HomeView.png');
+        expectNoAbsolutePathLeaks(project, result);
+    });
+    test('an absolute CIBUILD_ARTIFACTS_DIR is replaced by a placeholder in error messages', async () => {
+        const project = makeProject({ screens: { HomeView: 'home.png' } });
+        writeReference(project, 'home.png');
+        const artifactsDir = join(project.dir, 'abs-artifacts');
+        const run = runScript(project, await buildScript(project), {
+            CIBUILD_ARTIFACTS_DIR: artifactsDir,
+            FAKE_SWIFT_RUN_SILENT: 'HomeView',
+        });
+        expect(run.status).not.toBe(0);
+        const resultPath = join(artifactsDir, 'protocol-result.json');
+        expect(existsSync(resultPath)).toBe(true);
+        const result = JSON.parse(readFileSync(resultPath, 'utf-8'));
+        expect(result.screens[0].error?.code).toBe('RENDER_FAILED');
+        expect(result.screens[0].error?.message).toContain('<artifacts>/ui-fidelity/rendered/HomeView.png');
+        expectNoAbsolutePathLeaks(project, result);
+    });
+    test('generateRenderScript output is directly executable', () => {
+        const project = makeProject({ screens: { HomeView: 'home.png' } });
+        writeReference(project, 'home.png');
+        const script = generateRenderScript({
+            packagePath: project.packageDir,
+            target: 'FixtureViews',
+            width: 393,
+            height: 852,
+            scale: 2,
+        });
+        const run = runScript(project, script);
+        expect(run.status).toBe(0);
+        expect(readResult(project).screens[0].status).toBe('rendered');
+    });
+});
+describe('committed fixture package', () => {
+    test('declares the FixtureViews library with the screens the example pipeline uses', () => {
+        const manifest = readFileSync(join(FIXTURE_PACKAGE, 'Package.swift'), 'utf-8');
+        expect(manifest).toContain('name: "ui-fidelity-package"');
+        expect(manifest).toContain('.library(name: "FixtureViews", targets: ["FixtureViews"])');
+        expect(manifest).toContain('.macOS(.v13)');
+        const sourcesDir = join(FIXTURE_PACKAGE, 'Sources', 'FixtureViews');
+        const home = readFileSync(join(sourcesDir, 'HomeView.swift'), 'utf-8');
+        expect(home).toContain('public struct HomeView: View');
+        expect(home).toContain('public init()');
+        const settings = readFileSync(join(sourcesDir, 'SettingsView.swift'), 'utf-8');
+        expect(settings).toContain('public struct SettingsView: View');
+        // BrokenView exists to prove per-screen isolation: its parameterless
+        // init is deliberately unavailable, so its harness target cannot compile.
+        const broken = readFileSync(join(sourcesDir, 'BrokenView.swift'), 'utf-8');
+        expect(broken).toContain('public struct BrokenView: View');
+        expect(broken).toContain('@available(*, unavailable');
+    });
+    test('wires through the harness as package_path (fake toolchain)', async () => {
+        const project = makeProject({
+            screens: { HomeView: 'home.png', SettingsView: 'settings.png' },
+        });
+        writeReference(project, 'home.png');
+        writeReference(project, 'settings.png');
+        const script = await buildScript(project, { package_path: FIXTURE_PACKAGE });
+        const logPath = join(project.dir, 'swift-invocations.log');
+        const run = runScript(project, script, {
+            FAKE_SWIFT_LOG: logPath,
+            UI_FIDELITY_KEEP_HARNESS: '1',
+        });
+        expect(run.status).toBe(0);
+        const result = readResult(project);
+        expect(result.screens.map((s) => s.status)).toEqual(['rendered', 'rendered']);
+        // The synthesized harness depends on the real fixture package on disk.
+        const probeArgs = readFileSync(logPath, 'utf-8').trim().split('\n')[0].split(' ');
+        const harnessDir = probeArgs[probeArgs.indexOf('--package-path') + 1];
+        tempDirs.push(harnessDir);
+        const manifest = readFileSync(join(harnessDir, 'Package.swift'), 'utf-8');
+        expect(manifest).toContain('.package(path: "' + FIXTURE_PACKAGE + '")');
+        expect(manifest).toContain('.product(name: "FixtureViews", package: "ui-fidelity-package")');
+    });
+    // Opt-in: builds the fixture with the real Swift toolchain and renders
+    // through ImageRenderer. Requires macOS with Xcode; takes a SwiftPM
+    // build, so it is skipped unless explicitly requested.
+    const realSwiftTest = process.env.CIBUILD_UI_FIDELITY_REAL_SWIFT === '1' ? test : test.skip;
+    realSwiftTest('real toolchain: renders HomeView and isolates BrokenView with sanitized diagnostics', async () => {
+        const project = makeProject({
+            screens: { HomeView: 'home.png', BrokenView: 'broken.png' },
+        });
+        writeReference(project, 'home.png');
+        writeReference(project, 'broken.png');
+        const script = await buildScript(project, { package_path: FIXTURE_PACKAGE });
+        // No PATH shim: the real `swift` binary does the work.
+        const run = spawnSync('node', ['-e', script], {
+            cwd: project.dir,
+            encoding: 'utf-8',
+            maxBuffer: 32 * 1024 * 1024,
+        });
+        expect(run.status).not.toBe(0);
+        const result = readResult(project);
+        const [home, broken] = result.screens;
+        expect(home.status).toBe('rendered');
+        expect(home.error).toBeNull();
+        const rendered = artifact(project, 'ui-fidelity/rendered/HomeView.png');
+        expect(isPng(rendered)).toBe(true);
+        expect(readFileSync(rendered).length).toBeGreaterThan(1000);
+        expect(broken.status).toBe('render_failed');
+        expect(broken.error?.code).toBe('VIEW_COMPILE_FAILED');
+        expect(broken.error?.message).toContain('BrokenView');
+        expect(broken.rendered_image_path).toBeNull();
+        // Real compiler diagnostics reference the harness temp dir; none of
+        // those absolute paths may reach the result document.
+        expectNoAbsolutePathLeaks(project, result);
+    }, 600_000);
+});
+//# sourceMappingURL=ui-fidelity-render.test.js.map