@invarn/cibuild 2.9.4 → 2.9.7

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

@@ -1,1106 +0,0 @@
-import { spawn, spawnSync } from 'node:child_process';
-import { chmodSync, cpSync, existsSync, mkdirSync, mkdtempSync, readFileSync, rmSync, writeFileSync, } from 'node:fs';
-import { gzipSync } from 'node:zlib';
-import { tmpdir } from 'node:os';
-import { dirname, join, resolve } from 'node:path';
-import { fileURLToPath } from 'node:url';
-import { ANDROID_RENDERER, DEFAULT_GRADLE_TASK, UiFidelityRenderAndroidStepExecutor, } from './ui-fidelity-render-android.js';
-import { DEFAULT_SCALE } 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]);
-const tempDirs = [];
-afterAll(() => {
-    for (const dir of tempDirs) {
-        try {
-            rmSync(dir, { recursive: true, force: true });
-        }
-        catch {
-            // best effort
-        }
-    }
-});
-// ---- fake toolchain ----------------------------------------------------------
-// Fake `gradlew`, shipped inside the archive at the project root. With
-// FAKE_GRADLE_FAIL set it prints a compiler-style diagnostic and exits 1
-// (the project-does-not-build path). Otherwise it writes one PNG per screen
-// named in FAKE_ROBORAZZI_SCREENS (comma-separated) to
-// proof/build/outputs/roborazzi/<Screen>.png, mimicking a Roborazzi record.
-const FAKE_GRADLEW_LINES = [
-    '#!/bin/bash',
-    '[ -n "$FAKE_GRADLE_LOG" ] && echo "$*" >> "$FAKE_GRADLE_LOG"',
-    'if [ -n "$FAKE_GRADLE_FAIL" ]; then',
-    '  echo "> Task :proof:compileDebugKotlin FAILED" >&2',
-    '  echo "e: XProof.kt:7:20 unresolved reference: Missing" >&2',
-    '  exit 1',
-    'fi',
-    'out="proof/build/outputs/roborazzi"',
-    'mkdir -p "$out"',
-    'IFS=","',
-    'for s in $FAKE_ROBORAZZI_SCREENS; do',
-    '  [ -z "$s" ] && continue',
-    "  printf '\\x89PNG\\r\\n\\x1a\\n' > \"$out/$s.png\"",
-    '  printf \'roborazzi:%s\' "$s" >> "$out/$s.png"',
-    // When FAKE_ROBORAZZI_LAYOUT is set, also emit the layout-dump sidecar next
-    // to the PNG (matching basename, .layout.json) — a clipping card with an
-    // overflowing tag, so the deriver yields one clipped-by-parent fact.
-    '  if [ -n "$FAKE_ROBORAZZI_LAYOUT" ]; then',
-    // Layout sidecar basename: flat "<screen>.layout.json" by default, or an
-    // explicit golden-style dotted name via FAKE_ROBORAZZI_LAYOUT_NAME to prove
-    // the consumer finds it by dot-segment match, decoupled from the PNG stem.
-    '    lname="${FAKE_ROBORAZZI_LAYOUT_NAME:-$s.layout.json}"',
-    // The tag node carries the resolved-typeface enrichment (a Roboto fallback)
-    // so a run with reference_typeface can prove the params → fact plumbing.
-    `    printf '%s' '{"renderSdk":34,"canvas":{"left":0,"top":0,"right":200,"bottom":400},"nodes":[{"id":"card","bounds":{"left":20,"top":20,"right":180,"bottom":200},"parentId":null,"clipsChildren":true},{"id":"tag","bounds":{"left":60,"top":150,"right":140,"bottom":224},"parentId":"card","clipsChildren":false,"text":"TAG","resolvedTypeface":{"family":"Roboto-Regular","weight":400}}]}' > "$out/$lname"`,
-    '  fi',
-    'done',
-    'exit 0',
-];
-// Fake `ci`, providing only the branch the shared trim stage uses:
-// `ci fidelity-trim <in> <out> <aligned> <ref>`. Overwrites <out> with a
-// "trimmed:<in basename>" PNG, writes an "aligned:<in basename>" PNG, and
-// emits a fixed TRIMDIMS line. FAKE_TRIM_FAIL exercises warn-and-continue.
-const FAKE_CI_LINES = [
-    '#!/bin/bash',
-    'case "$1" in',
-    '  fidelity-trim)',
-    '    if [ -n "$FAKE_TRIM_FAIL" ]; then echo "trim: simulated failure" >&2; exit 1; fi',
-    '    in_png="$2"; out_png="$3"; aligned_png="$4"',
-    "    printf '\\x89PNG\\r\\n\\x1a\\n' > \"$out_png\"",
-    '    printf \'trimmed:%s\' "$(basename "$in_png")" >> "$out_png"',
-    '    if [ -n "$aligned_png" ]; then',
-    "      printf '\\x89PNG\\r\\n\\x1a\\n' > \"$aligned_png\"",
-    '      printf \'aligned:%s\' "$(basename "$in_png")" >> "$aligned_png"',
-    '    fi',
-    '    echo "TRIMDIMS 320 640 160 320 400 800 40 77"',
-    '    exit 0 ;;',
-    '  *) exit 0 ;;',
-    'esac',
-];
-function makeProject(params) {
-    const dir = mkdtempSync(join(tmpdir(), 'ui-fidelity-android-'));
-    tempDirs.push(dir);
-    mkdirSync(join(dir, '.ci', 'inputs'), { recursive: true });
-    const binDir = join(dir, 'bin');
-    mkdirSync(binDir, { recursive: true });
-    const ciPath = join(binDir, 'ci');
-    writeFileSync(ciPath, FAKE_CI_LINES.join('\n') + '\n');
-    chmodSync(ciPath, 0o755);
-    if (params !== undefined) {
-        writeFileSync(join(dir, '.ci', 'inputs', 'params.json'), typeof params === 'string' ? params : JSON.stringify(params));
-    }
-    return { dir, binDir };
-}
-function writeReference(project, basename, label = basename) {
-    writeFileSync(join(project.dir, '.ci', 'inputs', basename), Buffer.concat([PNG_MAGIC, Buffer.from('ref:' + label)]));
-}
-function isPng(filePath) {
-    try {
-        return readFileSync(filePath).subarray(0, 8).equals(PNG_MAGIC);
-    }
-    catch {
-        return false;
-    }
-}
-function artifact(project, relative) {
-    return join(project.dir, '.ci', 'artifacts', relative);
-}
-function tarHeader(name, size, typeflag, mode) {
-    const header = Buffer.alloc(512);
-    header.write(name, 0, 100, 'utf-8');
-    header.write(mode.toString(8).padStart(7, '0') + '\0', 100, 8, 'ascii');
-    header.write('0000000\0', 108, 8, 'ascii');
-    header.write('0000000\0', 116, 8, 'ascii');
-    header.write(size.toString(8).padStart(11, '0') + '\0', 124, 12, 'ascii');
-    header.write('00000000000\0', 136, 12, 'ascii');
-    header.write('        ', 148, 8, 'ascii');
-    header.write(typeflag, 156, 1, 'ascii');
-    header.write('ustar\0' + '00', 257, 8, 'ascii');
-    let checksum = 0;
-    for (const byte of header)
-        checksum += byte;
-    header.write(checksum.toString(8).padStart(6, '0') + '\0 ', 148, 8, 'ascii');
-    return header;
-}
-function makeTarGz(entries) {
-    const blocks = [];
-    for (const entry of entries) {
-        const isDir = entry.name.endsWith('/');
-        const content = Buffer.isBuffer(entry.content)
-            ? entry.content
-            : Buffer.from(entry.content ?? '', 'utf-8');
-        const mode = entry.mode ?? (isDir ? 0o755 : 0o644);
-        blocks.push(tarHeader(entry.name, isDir ? 0 : content.length, isDir ? '5' : '0', mode));
-        if (!isDir && content.length > 0) {
-            const padded = Buffer.alloc(Math.ceil(content.length / 512) * 512);
-            content.copy(padded);
-            blocks.push(padded);
-        }
-    }
-    blocks.push(Buffer.alloc(1024));
-    return gzipSync(Buffer.concat(blocks));
-}
-/** Entries for a well-formed shipped Gradle project under the given root. */
-function gradleProjectEntries(root = 'project') {
-    const prefix = root === '' ? '' : root + '/';
-    const entries = root === '' ? [] : [{ name: prefix }];
-    entries.push({ name: prefix + 'settings.gradle.kts', content: 'rootProject.name = "p"\ninclude(":proof")\n' }, { name: prefix + 'gradlew', content: FAKE_GRADLEW_LINES.join('\n') + '\n', mode: 0o755 }, { name: prefix + 'proof/build.gradle.kts', content: '// module\n' });
-    return entries;
-}
-function stageArchive(project, archive) {
-    writeFileSync(join(project.dir, '.ci', 'inputs', 'package.tar.gz'), Buffer.isBuffer(archive) ? archive : makeTarGz(archive));
-}
-// ---- script build + run ------------------------------------------------------
-async function buildScript(inputs = {}) {
-    const executor = new UiFidelityRenderAndroidStepExecutor();
-    const step = await executor.execute(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) {
-    return JSON.parse(readFileSync(join(project.dir, '.ci', 'artifacts', 'protocol-result.json'), 'utf-8'));
-}
-describe('registry integration', () => {
-    test('ui-fidelity-render-android is registered with its input schema', () => {
-        clearRegistry();
-        initializeStepRegistry();
-        expect(hasStep('ui-fidelity-render-android')).toBe(true);
-        const metadata = getStepMetadata('ui-fidelity-render-android');
-        expect(metadata?.platform).toBe('android');
-        const inputs = metadata?.inputs ?? {};
-        expect(Object.keys(inputs).sort()).toEqual([
-            'gradle_task',
-            'package_path',
-            'package_source',
-            'reference_source',
-            'scale',
-        ]);
-        expect(inputs.package_source.required).toBe(false);
-        expect(inputs.package_source.default).toBe('inputs');
-        expect(inputs.reference_source.required).toBe(false);
-        expect(inputs.reference_source.default).toBe('inputs');
-        // package_path is enforced by the executor only in repo mode; the default
-        // (inputs) config is valid without it, so it is not unconditionally required.
-        expect(inputs.package_path.required).toBe(false);
-        expect(inputs.scale.required).toBe(false);
-        expect(inputs.scale.default).toBe(DEFAULT_SCALE);
-        expect(inputs.gradle_task.required).toBe(false);
-        expect(inputs.gradle_task.default).toBe(DEFAULT_GRADLE_TASK);
-    });
-});
-describe('default byte compatibility', () => {
-    // Snapshot of the script generated for the default inputs (no package_source,
-    // no reference_source), captured from the executor with everything else at its
-    // default. Omitting both *_source inputs must keep the generated script
-    // byte-identical to this snapshot, so existing protocols are provably
-    // untouched. Update the snapshot only for a deliberate, reviewed change to the
-    // default runtime.
-    const DEFAULT_SCRIPT_SNAPSHOT = resolve(dirname(fileURLToPath(import.meta.url)), '../../../test/fixtures/ui-fidelity-render-android-v1-script.txt');
-    test('omitting package_source and reference_source generates a byte-identical script', async () => {
-        const executor = new UiFidelityRenderAndroidStepExecutor();
-        const step = await executor.execute({}, {}, testConfig);
-        expect(step.script).toBe(readFileSync(DEFAULT_SCRIPT_SNAPSHOT, 'utf-8'));
-    });
-});
-describe('UiFidelityRenderAndroidStepExecutor', () => {
-    test('returns a node StepDef named ui-fidelity-render-android', async () => {
-        const executor = new UiFidelityRenderAndroidStepExecutor();
-        const step = await executor.execute({}, {}, testConfig);
-        expect(step.kind).toBe('node');
-        expect(step.name).toBe('ui-fidelity-render-android');
-        expect(step.script.length).toBeGreaterThan(0);
-    });
-});
-describe('android render runtime — params validation', () => {
-    test('writes a contract-shaped, empty-screens result and fails when params.json is absent', async () => {
-        const project = makeProject();
-        const script = await buildScript();
-        const run = runScript(project, script);
-        expect(run.status).toBe(1);
-        const doc = readResult(project);
-        expect(doc.renderer).toBe(ANDROID_RENDERER);
-        expect(doc.error).toBeNull();
-        expect(doc.screens).toEqual([]);
-    });
-    test('fails when params.json is malformed', async () => {
-        const project = makeProject('{ not json');
-        const run = runScript(project, await buildScript());
-        expect(run.status).toBe(1);
-        expect(readResult(project).screens).toEqual([]);
-    });
-});
-describe('android render runtime — reference setup', () => {
-    test('records REFERENCE_MISSING for a screen whose reference is absent', async () => {
-        const project = makeProject({ screens: { XProof: 'x.png' } });
-        const run = runScript(project, await buildScript());
-        expect(run.status).toBe(1);
-        const screen = readResult(project).screens.find((s) => s.screen === 'XProof');
-        expect(screen?.error?.code).toBe('REFERENCE_MISSING');
-        expect(screen?.reference_image_path).toBeNull();
-    });
-    test('copies a present reference into the artifacts and records its path', async () => {
-        const project = makeProject({ screens: { XProof: 'x.png' } });
-        writeReference(project, 'x.png');
-        const run = runScript(project, await buildScript());
-        const screen = readResult(project).screens.find((s) => s.screen === 'XProof');
-        expect(screen?.reference_image_path).toBe('ui-fidelity/references/XProof.png');
-        expect(isPng(artifact(project, 'ui-fidelity/references/XProof.png'))).toBe(true);
-    });
-});
-describe('android render runtime — archive validation', () => {
-    function projectWithRef() {
-        const project = makeProject({ screens: { XProof: 'x.png' } });
-        writeReference(project, 'x.png');
-        return project;
-    }
-    test('missing archive yields ANDROID_ARCHIVE_MISSING with every screen entry present', async () => {
-        const project = projectWithRef();
-        const run = runScript(project, await buildScript());
-        expect(run.status).toBe(1);
-        const doc = readResult(project);
-        expect(doc.error?.code).toBe('ANDROID_ARCHIVE_MISSING');
-        expect(doc.screens.map((s) => s.screen)).toEqual(['XProof']);
-    });
-    test('a corrupt archive yields ANDROID_ARCHIVE_INVALID', async () => {
-        const project = projectWithRef();
-        stageArchive(project, Buffer.from('not a gzip'));
-        const run = runScript(project, await buildScript());
-        expect(readResult(project).error?.code).toBe('ANDROID_ARCHIVE_INVALID');
-        expect(run.status).toBe(1);
-    });
-    test('an archive with dot-dot members yields ANDROID_ARCHIVE_INVALID', async () => {
-        const project = projectWithRef();
-        stageArchive(project, [{ name: '../escape.txt', content: 'x' }]);
-        runScript(project, await buildScript());
-        expect(readResult(project).error?.code).toBe('ANDROID_ARCHIVE_INVALID');
-    });
-    test('an extraction larger than the size bound yields ANDROID_ARCHIVE_TOO_LARGE', async () => {
-        const project = projectWithRef();
-        stageArchive(project, gradleProjectEntries());
-        runScript(project, await buildScript(), { UI_FIDELITY_MAX_PACKAGE_BYTES: '10' });
-        expect(readResult(project).error?.code).toBe('ANDROID_ARCHIVE_TOO_LARGE');
-    });
-    test('an archive without a Gradle settings file yields ANDROID_PROJECT_ROOT_MISSING', async () => {
-        const project = projectWithRef();
-        stageArchive(project, [
-            { name: 'project/' },
-            { name: 'project/build.gradle.kts', content: '// no settings\n' },
-        ]);
-        runScript(project, await buildScript());
-        expect(readResult(project).error?.code).toBe('ANDROID_PROJECT_ROOT_MISSING');
-    });
-    test('archive validation failures fail the step even with zero screens', async () => {
-        const project = makeProject({ screens: {} });
-        const run = runScript(project, await buildScript());
-        expect(run.status).toBe(1);
-        expect(readResult(project).error?.code).toBe('ANDROID_ARCHIVE_MISSING');
-    });
-});
-describe('android render runtime — render + trim (happy path)', () => {
-    test('renders each screen, trims via the shared post-processor, and records the contract shape', async () => {
-        const project = makeProject({ screens: { XProof: 'x.png' } });
-        writeReference(project, 'x.png');
-        stageArchive(project, gradleProjectEntries());
-        const run = runScript(project, await buildScript(), { FAKE_ROBORAZZI_SCREENS: 'XProof' });
-        expect(run.status).toBe(0);
-        const doc = readResult(project);
-        expect(doc.error).toBeNull();
-        const screen = doc.screens.find((s) => s.screen === 'XProof');
-        expect(screen?.status).toBe('rendered');
-        expect(screen?.error).toBeNull();
-        expect(screen?.rendered_image_path).toBe('ui-fidelity/rendered/XProof.png');
-        expect(screen?.aligned_image_path).toBe('ui-fidelity/aligned/XProof.png');
-        // dimensions from the (fake) trim helper's TRIMDIMS, logical_pt = px / scale 2.
-        expect(screen?.dimensions).toEqual({
-            rendered_px: [320, 640],
-            logical_pt: [160, 320],
-            reference_px: [160, 320],
-            // the fake helper's TRIMDIMS pre-trim source px (fields 5-6)
-            source_px: [400, 800],
-            // …and the crop origin (fields 7-8): where the trimmed image sits in the
-            // source, so geometry captured in window coordinates can be placed on
-            // the trimmed bytes (the 2026-08-01 spotlight diagnosis).
-            trim_offset_px: [40, 77],
-        });
-        expect(isPng(artifact(project, 'ui-fidelity/rendered/XProof.png'))).toBe(true);
-        expect(isPng(artifact(project, 'ui-fidelity/aligned/XProof.png'))).toBe(true);
-        // The rendered file holds the trim helper's output, not the raw render.
-        expect(readFileSync(artifact(project, 'ui-fidelity/rendered/XProof.png'), 'utf-8')).toContain('trimmed:XProof.png');
-    });
-    test('derives structural facts from the layout dump and records layout_path + facts_path', async () => {
-        const project = makeProject({ screens: { XProof: 'x.png' } });
-        writeReference(project, 'x.png');
-        stageArchive(project, gradleProjectEntries());
-        const run = runScript(project, await buildScript(), {
-            FAKE_ROBORAZZI_SCREENS: 'XProof',
-            FAKE_ROBORAZZI_LAYOUT: '1',
-        });
-        expect(run.status).toBe(0);
-        const screen = readResult(project).screens.find((s) => s.screen === 'XProof');
-        expect(screen?.status).toBe('rendered');
-        expect(screen?.layout_path).toBe('ui-fidelity/layout/XProof.json');
-        expect(screen?.facts_path).toBe('ui-fidelity/facts/XProof.json');
-        // The layout dump is copied verbatim as a build artifact.
-        expect(existsSync(artifact(project, 'ui-fidelity/layout/XProof.json'))).toBe(true);
-        // The facts artifact surfaces the bottom clip the eye would miss.
-        const facts = JSON.parse(readFileSync(artifact(project, 'ui-fidelity/facts/XProof.json'), 'utf-8'));
-        expect(facts).toEqual({
-            screen: 'XProof',
-            facts: [
-                {
-                    kind: 'clipped_by_parent',
-                    nodeId: 'tag',
-                    clipperId: 'card',
-                    edges: ['bottom'],
-                    clippedPx: { bottom: 24 },
-                },
-            ],
-        });
-    });
-    test('emits a source_digest content key on a rendered screen entry', async () => {
-        const project = makeProject({ screens: { XProof: 'x.png' } });
-        writeReference(project, 'x.png');
-        stageArchive(project, gradleProjectEntries());
-        const run = runScript(project, await buildScript(), {
-            FAKE_ROBORAZZI_SCREENS: 'XProof',
-        });
-        expect(run.status).toBe(0);
-        const screen = readResult(project).screens.find((s) => s.screen === 'XProof');
-        expect(screen?.status).toBe('rendered');
-        expect(screen?.source_digest).toMatch(/^[0-9a-f]{64}$/);
-    });
-    test('omits source_digest for a non-hermetic package (Gradle script escapes the root)', async () => {
-        const project = makeProject({ screens: { XProof: 'x.png' } });
-        writeReference(project, 'x.png');
-        // A settings script that pulls in a sibling build via a parent path — the
-        // package is no longer its own dependency closure, so it must not be
-        // cacheable: it still renders, but emits no content key.
-        const entries = gradleProjectEntries().map((e) => e.name.endsWith('settings.gradle.kts')
-            ? { ...e, content: 'rootProject.name = "p"\ninclude(":proof")\nincludeBuild("../design-system")\n' }
-            : e);
-        stageArchive(project, entries);
-        const run = runScript(project, await buildScript(), { FAKE_ROBORAZZI_SCREENS: 'XProof' });
-        expect(run.status).toBe(0);
-        const screen = readResult(project).screens.find((s) => s.screen === 'XProof');
-        expect(screen?.status).toBe('rendered');
-        expect(screen?.source_digest == null).toBe(true);
-    });
-    test('assembles the inline structural block (facts) onto the screen entry', async () => {
-        const project = makeProject({ screens: { XProof: 'x.png' } });
-        writeReference(project, 'x.png');
-        stageArchive(project, gradleProjectEntries());
-        const run = runScript(project, await buildScript(), {
-            FAKE_ROBORAZZI_SCREENS: 'XProof',
-            FAKE_ROBORAZZI_LAYOUT: '1',
-        });
-        expect(run.status).toBe(0);
-        const screen = readResult(project).screens.find((s) => s.screen === 'XProof');
-        // Signal A surfaces inline; max deltas stay null (no comparison ran).
-        expect(screen?.structural?.summary).toEqual({ clean: false, factCount: 1, maxSizeDeltaDp: null, maxClipDeltaDp: null });
-        expect(screen?.structural?.facts).toHaveLength(1);
-        // Description vs comparison: with no reference_geometry the geometry block
-        // still persists the authored-tag nodes' rendered boxes — and nothing else
-        // (no design/deltas/sizeFlag).
-        expect(screen?.structural?.geometry).toEqual({
-            unit: 'dp',
-            density: 2,
-            elements: [
-                { id: 'card', rendered: { w: 80, h: 90, x: 10, y: 10 } },
-                { id: 'tag', rendered: { w: 40, h: 37, x: 30, y: 75 } },
-            ],
-        });
-        // The verdict obligation is baked onto the run result by the runner: the
-        // clip fact (node 'tag') becomes a must-explain row with a null verdict.
-        expect(screen?.structural?.review?.verdict).toBeNull();
-        expect(screen?.structural?.review?.mustExplain).toEqual(['tag']);
-        expect(screen?.structural?.review?.rows.every((r) => r.verdict === null)).toBe(true);
-    });
-    test('adds Signal-B geometry deltas to the structural block when reference_geometry is given', async () => {
-        // The fake layout dump: card bounds 160x180px, tag 80x74px (density 2 → dp
-        // card 80x90, tag 40x37). Declare design numbers so the card reads +10dp tall.
-        const project = makeProject({
-            screens: { XProof: 'x.png' },
-            reference_geometry: { XProof: { card: { w: 80, h: 80 }, tag: { w: 40, h: 37 } } },
-        });
-        writeReference(project, 'x.png');
-        stageArchive(project, gradleProjectEntries());
-        const run = runScript(project, await buildScript(), {
-            FAKE_ROBORAZZI_SCREENS: 'XProof',
-            FAKE_ROBORAZZI_LAYOUT: '1',
-        });
-        expect(run.status).toBe(0);
-        const screen = readResult(project).screens.find((s) => s.screen === 'XProof');
-        expect(screen?.structural?.summary).toEqual({ clean: false, factCount: 1, maxSizeDeltaDp: 10, maxClipDeltaDp: 0 });
-        const geometry = screen?.structural?.geometry;
-        expect(geometry?.unit).toBe('dp');
-        expect(geometry?.density).toBe(2);
-        const card = geometry?.elements.find((e) => e.id === 'card');
-        expect(card).toEqual({
-            id: 'card',
-            // rendered now carries x/y (dp); design stays w/h-only (no x/y in ref).
-            rendered: { w: 80, h: 90, x: 10, y: 10 },
-            design: { w: 80, h: 80 },
-            deltas: [{ dimension: 'h', delta: 10 }],
-            sizeFlag: true,
-            // Render ancestry (icon-ink-ratio 05), measured by the EMBEDDED port that
-            // actually runs on the runner: `card` is a root in this dump, so its chain
-            // is empty. Empty is a measurement — the judge reads an ABSENT field as
-            // "this render predates ancestry" and stays silent on it.
-            ancestors: [],
-        });
-        const tag = geometry?.elements.find((e) => e.id === 'tag');
-        expect(tag?.sizeFlag).toBe(false);
-        expect(tag?.deltas).toEqual([]);
-        // ...and `tag` is nested inside `card`, so the chain the judge compares
-        // against the design tree is non-trivial here.
-        expect(tag?.ancestors).toEqual(['card']);
-    });
-    test('derives a flagged typeface fact when reference_typeface is given and the resolved font diverges (typeface issue 04)', async () => {
-        // The fake dump resolved Roboto-Regular 400 on `tag`; the design declares
-        // Poppins 600 → exactly one typeface fact on the run result. A matching
-        // declaration on a second run produces none.
-        const project = makeProject({
-            screens: { XProof: 'x.png' },
-            reference_typeface: { XProof: { tag: { family: 'Poppins', weight: 600 } } },
-        });
-        writeReference(project, 'x.png');
-        stageArchive(project, gradleProjectEntries());
-        const run = runScript(project, await buildScript(), {
-            FAKE_ROBORAZZI_SCREENS: 'XProof',
-            FAKE_ROBORAZZI_LAYOUT: '1',
-        });
-        expect(run.status).toBe(0);
-        const screen = readResult(project).screens.find((s) => s.screen === 'XProof');
-        const typefaceFacts = (screen?.structural?.appearance?.facts ?? []).filter((f) => f.kind === 'typeface');
-        expect(typefaceFacts).toEqual([
-            {
-                kind: 'typeface',
-                elementId: 'tag',
-                channel: 'text',
-                rendered: { family: 'Roboto-Regular', weight: 400 },
-                reference: { family: 'Poppins', weight: 600 },
-            },
-        ]);
-        // The resolved font is persisted as the next drift baseline.
-        expect(screen?.structural?.appearance?.rendered?.typeface).toEqual({
-            tag: { family: 'Roboto-Regular', weight: 400 },
-        });
-        // Matching declaration → no typeface fact (and no advisory).
-        const clean = makeProject({
-            screens: { XProof: 'x.png' },
-            reference_typeface: { XProof: { tag: { family: 'Roboto-Regular', weight: 400 } } },
-        });
-        writeReference(clean, 'x.png');
-        stageArchive(clean, gradleProjectEntries());
-        const cleanRun = runScript(clean, await buildScript(), {
-            FAKE_ROBORAZZI_SCREENS: 'XProof',
-            FAKE_ROBORAZZI_LAYOUT: '1',
-        });
-        expect(cleanRun.status).toBe(0);
-        const cleanScreen = readResult(clean).screens.find((s) => s.screen === 'XProof');
-        expect((cleanScreen?.structural?.appearance?.facts ?? []).filter((f) => f.kind === 'typeface')).toEqual([]);
-        expect(cleanScreen?.structural?.appearance?.advisories).toBeUndefined();
-    });
-    test('finds the layout dump by dot-segment match even when its name differs from the PNG stem', async () => {
-        const project = makeProject({ screens: { XProof: 'x.png' } });
-        writeReference(project, 'x.png');
-        stageArchive(project, gradleProjectEntries());
-        // Golden-style dotted layout name (as real Roborazzi would name a sidecar),
-        // distinct from the flat PNG the fake writes — the consumer must still find it.
-        const run = runScript(project, await buildScript(), {
-            FAKE_ROBORAZZI_SCREENS: 'XProof',
-            FAKE_ROBORAZZI_LAYOUT: '1',
-            FAKE_ROBORAZZI_LAYOUT_NAME: 'com.example.XProofTest.renderXProof.layout.json',
-        });
-        expect(run.status).toBe(0);
-        const screen = readResult(project).screens.find((s) => s.screen === 'XProof');
-        expect(screen?.facts_path).toBe('ui-fidelity/facts/XProof.json');
-        const facts = JSON.parse(readFileSync(artifact(project, 'ui-fidelity/facts/XProof.json'), 'utf-8'));
-        expect(facts.facts).toHaveLength(1);
-        expect(facts.facts[0].kind).toBe('clipped_by_parent');
-    });
-    test('degrades cleanly when no layout dump is emitted (no facts, render still succeeds)', async () => {
-        const project = makeProject({ screens: { XProof: 'x.png' } });
-        writeReference(project, 'x.png');
-        stageArchive(project, gradleProjectEntries());
-        // No FAKE_ROBORAZZI_LAYOUT → the render emits a PNG but no sidecar.
-        const run = runScript(project, await buildScript(), { FAKE_ROBORAZZI_SCREENS: 'XProof' });
-        expect(run.status).toBe(0);
-        const screen = readResult(project).screens.find((s) => s.screen === 'XProof');
-        expect(screen?.status).toBe('rendered');
-        expect(screen?.layout_path ?? null).toBeNull();
-        expect(screen?.facts_path ?? null).toBeNull();
-        expect(existsSync(artifact(project, 'ui-fidelity/facts/XProof.json'))).toBe(false);
-    });
-    test('renders multiple screens independently in one Gradle run', async () => {
-        const project = makeProject({ screens: { XProof: 'x.png', YProof: 'y.png' } });
-        writeReference(project, 'x.png');
-        writeReference(project, 'y.png');
-        stageArchive(project, gradleProjectEntries());
-        const run = runScript(project, await buildScript(), { FAKE_ROBORAZZI_SCREENS: 'XProof,YProof' });
-        expect(run.status).toBe(0);
-        const doc = readResult(project);
-        expect(doc.screens.map((s) => s.status)).toEqual(['rendered', 'rendered']);
-    });
-});
-describe('android render runtime — reference provenance', () => {
-    const GOOD_PROV = {
-        figmaNode: '12:345',
-        locale: 'en',
-        resolved: true,
-        exportedAt: '2026-06-18T10:00:00Z',
-    };
-    // Stage a valid project so per-build archive validation passes and the only
-    // signal under test is the per-screen provenance verdict.
-    function provProject(params) {
-        const project = makeProject(params);
-        stageArchive(project, gradleProjectEntries());
-        return project;
-    }
-    test('a reference with no provenance stays unverifiable when a render locale is declared', async () => {
-        const project = provProject({
-            screens: { XProof: 'x.png' },
-            render_locale: 'en',
-            provenance: {},
-        });
-        writeReference(project, 'x.png');
-        runScript(project, await buildScript());
-        const screen = readResult(project).screens.find((s) => s.screen === 'XProof');
-        expect(screen?.status).toBe('unverifiable');
-        expect(screen?.error?.code).toBe('NO_PROVENANCE');
-    });
-    test('a placeholder reference (resolved=false) renders and downgrades only the copy channel', async () => {
-        const project = provProject({
-            screens: { XProof: 'x.png' },
-            render_locale: 'en',
-            provenance: { XProof: { ...GOOD_PROV, resolved: false } },
-        });
-        writeReference(project, 'x.png');
-        const run = runScript(project, await buildScript(), { FAKE_ROBORAZZI_SCREENS: 'XProof' });
-        expect(run.status).toBe(0);
-        const screen = readResult(project).screens.find((s) => s.screen === 'XProof');
-        expect(screen?.status).toBe('rendered');
-        expect(screen?.error).toBeNull();
-        expect(screen?.copy_advisory?.code).toBe('copy_unverifiable');
-        expect(screen?.copy_advisory?.reason).toBe('unresolved_placeholders');
-    });
-    test('the placeholder downgrade is identical without a render_locale (same input, same verdict)', async () => {
-        // Live evidence bld_5f8dc6330c9e61f578297f00 / bld_c92bc240ab8aac7dfe258b27:
-        // the same resolved:false reference was judged in one run and refused in
-        // the other purely because of the optional render_locale param.
-        const project = provProject({
-            screens: { XProof: 'x.png' },
-            provenance: { XProof: { ...GOOD_PROV, resolved: false } },
-        });
-        writeReference(project, 'x.png');
-        const run = runScript(project, await buildScript(), { FAKE_ROBORAZZI_SCREENS: 'XProof' });
-        expect(run.status).toBe(0);
-        const screen = readResult(project).screens.find((s) => s.screen === 'XProof');
-        expect(screen?.status).toBe('rendered');
-        expect(screen?.copy_advisory?.reason).toBe('unresolved_placeholders');
-    });
-    test('an Italian reference against an English render downgrades the copy channel', async () => {
-        const project = provProject({
-            screens: { XProof: 'x.png' },
-            render_locale: 'en',
-            provenance: { XProof: { ...GOOD_PROV, locale: 'it' } },
-        });
-        writeReference(project, 'x.png');
-        const run = runScript(project, await buildScript(), { FAKE_ROBORAZZI_SCREENS: 'XProof' });
-        expect(run.status).toBe(0);
-        const screen = readResult(project).screens.find((s) => s.screen === 'XProof');
-        expect(screen?.status).toBe('rendered');
-        expect(screen?.copy_advisory?.code).toBe('copy_unverifiable');
-        expect(screen?.copy_advisory?.reason).toBe('locale_mismatch');
-    });
-    test('locale comparison requires a declared render_locale — its absence skips only that', async () => {
-        const project = provProject({
-            screens: { XProof: 'x.png' },
-            provenance: { XProof: { ...GOOD_PROV, locale: 'it' } },
-        });
-        writeReference(project, 'x.png');
-        runScript(project, await buildScript(), { FAKE_ROBORAZZI_SCREENS: 'XProof' });
-        const screen = readResult(project).screens.find((s) => s.screen === 'XProof');
-        expect(screen?.status).toBe('rendered');
-        expect(screen?.copy_advisory ?? null).toBeNull();
-    });
-    test('an absent reference with good provenance stays fatal (REFERENCE_ABSENT)', async () => {
-        const project = provProject({
-            screens: { XProof: 'x.png' },
-            render_locale: 'en',
-            provenance: { XProof: GOOD_PROV },
-        });
-        // No writeReference — the file is absent.
-        runScript(project, await buildScript());
-        const screen = readResult(project).screens.find((s) => s.screen === 'XProof');
-        expect(screen?.status).toBe('unverifiable');
-        expect(screen?.error?.code).toBe('REFERENCE_ABSENT');
-    });
-    test('an absent reference is fatal even without a render_locale (armed by provenance presence)', async () => {
-        const project = provProject({
-            screens: { XProof: 'x.png' },
-            provenance: { XProof: GOOD_PROV },
-        });
-        runScript(project, await buildScript());
-        const screen = readResult(project).screens.find((s) => s.screen === 'XProof');
-        expect(screen?.status).toBe('unverifiable');
-        expect(screen?.error?.code).toBe('REFERENCE_ABSENT');
-    });
-    test('a good provenanced reference renders normally with no copy advisory', async () => {
-        const project = provProject({
-            screens: { XProof: 'x.png' },
-            render_locale: 'en',
-            provenance: { XProof: GOOD_PROV },
-        });
-        writeReference(project, 'x.png');
-        const run = runScript(project, await buildScript(), { FAKE_ROBORAZZI_SCREENS: 'XProof' });
-        expect(run.status).toBe(0);
-        const screen = readResult(project).screens.find((s) => s.screen === 'XProof');
-        expect(screen?.status).toBe('rendered');
-        expect(screen?.error).toBeNull();
-        expect(screen?.copy_advisory ?? null).toBeNull();
-    });
-    test('independent verdicts: a clean sibling carries no advisory while the placeholder state does', async () => {
-        const project = provProject({
-            screens: { XProof: 'x.png', YProof: 'y.png' },
-            render_locale: 'en',
-            provenance: { XProof: GOOD_PROV, YProof: { ...GOOD_PROV, resolved: false } },
-        });
-        writeReference(project, 'x.png');
-        writeReference(project, 'y.png');
-        runScript(project, await buildScript(), { FAKE_ROBORAZZI_SCREENS: 'XProof,YProof' });
-        const doc = readResult(project);
-        const x = doc.screens.find((s) => s.screen === 'XProof');
-        expect(x?.status).toBe('rendered');
-        expect(x?.copy_advisory ?? null).toBeNull();
-        const y = doc.screens.find((s) => s.screen === 'YProof');
-        expect(y?.status).toBe('rendered');
-        expect(y?.copy_advisory?.reason).toBe('unresolved_placeholders');
-    });
-    test('without provenance and without a render_locale, nothing is enforced (legacy behaviour)', async () => {
-        const project = provProject({ screens: { XProof: 'x.png' } });
-        writeReference(project, 'x.png');
-        runScript(project, await buildScript(), { FAKE_ROBORAZZI_SCREENS: 'XProof' });
-        const screen = readResult(project).screens.find((s) => s.screen === 'XProof');
-        expect(screen?.status).toBe('rendered');
-        expect(screen?.copy_advisory ?? null).toBeNull();
-    });
-    test('a downgraded copy channel derives no copy facts while geometry facts still hold', async () => {
-        // The fake layout dump carries a text node ("tag": "TAG") that clips its
-        // parent. With reference text that mismatches, a clean run derives a
-        // text_mismatch fact — a downgraded run must derive NONE while keeping
-        // the clipped_by_parent geometry fact.
-        const factKinds = async (resolved) => {
-            const project = provProject({
-                screens: { XProof: 'x.png' },
-                render_locale: 'en',
-                provenance: { XProof: { ...GOOD_PROV, resolved } },
-                reference_text: { XProof: { tag: 'DIFFERENT' } },
-            });
-            writeReference(project, 'x.png');
-            runScript(project, await buildScript(), {
-                FAKE_ROBORAZZI_SCREENS: 'XProof',
-                FAKE_ROBORAZZI_LAYOUT: '1',
-            });
-            const screen = readResult(project).screens.find((s) => s.screen === 'XProof');
-            const structural = (screen?.structural?.facts ?? []).map((f) => f.kind);
-            const appearance = (screen?.structural?.appearance?.facts ?? []).map((f) => f.kind);
-            return [...structural, ...appearance];
-        };
-        const clean = await factKinds(true);
-        expect(clean).toContain('text_mismatch');
-        expect(clean).toContain('clipped_by_parent');
-        const downgraded = await factKinds(false);
-        expect(downgraded).not.toContain('text_mismatch');
-        expect(downgraded).not.toContain('text_missing');
-        expect(downgraded).toContain('clipped_by_parent');
-    });
-});
-describe('android render runtime — error isolation', () => {
-    function twoScreenProject() {
-        const project = makeProject({ screens: { XProof: 'x.png', YProof: 'y.png' } });
-        writeReference(project, 'x.png');
-        writeReference(project, 'y.png');
-        stageArchive(project, gradleProjectEntries());
-        return project;
-    }
-    test('a Gradle build failure marks every screen RENDER_UNSUPPORTED', async () => {
-        const project = twoScreenProject();
-        const run = runScript(project, await buildScript(), { FAKE_GRADLE_FAIL: '1' });
-        expect(run.status).toBe(1);
-        const doc = readResult(project);
-        // Build-level failure is reported per screen (not an archive-level error).
-        expect(doc.error).toBeNull();
-        for (const screen of doc.screens) {
-            expect(screen.status).toBe('render_failed');
-            expect(screen.error?.code).toBe('RENDER_UNSUPPORTED');
-            expect(screen.error?.message).toContain('did not build');
-        }
-    });
-    test('a screen whose PNG is not produced is RENDER_FAILED while others render', async () => {
-        const project = twoScreenProject();
-        // Only XProof records a PNG; YProof's is absent.
-        const run = runScript(project, await buildScript(), { FAKE_ROBORAZZI_SCREENS: 'XProof' });
-        expect(run.status).toBe(1);
-        const doc = readResult(project);
-        const x = doc.screens.find((s) => s.screen === 'XProof');
-        const y = doc.screens.find((s) => s.screen === 'YProof');
-        expect(x?.status).toBe('rendered');
-        expect(y?.status).toBe('render_failed');
-        expect(y?.error?.code).toBe('RENDER_FAILED');
-    });
-});
-/** Materialize a well-formed Gradle render project (fake gradlew) on disk. */
-function writeGradleProjectDir(dir) {
-    mkdirSync(join(dir, 'proof'), { recursive: true });
-    writeFileSync(join(dir, 'settings.gradle.kts'), 'rootProject.name = "p"\ninclude(":proof")\n');
-    const gradlew = join(dir, 'gradlew');
-    writeFileSync(gradlew, FAKE_GRADLEW_LINES.join('\n') + '\n');
-    chmodSync(gradlew, 0o755);
-    writeFileSync(join(dir, 'proof', 'build.gradle.kts'), '// module\n');
-}
-describe('package_source: repo', () => {
-    test('rejects an unknown package_source value', async () => {
-        const executor = new UiFidelityRenderAndroidStepExecutor();
-        await expect(executor.execute({ package_source: 'cloud' }, {}, testConfig)).rejects.toThrow(/package_source/);
-    });
-    test('package_source repo requires package_path', async () => {
-        const executor = new UiFidelityRenderAndroidStepExecutor();
-        await expect(executor.execute({ package_source: 'repo' }, {}, testConfig)).rejects.toThrow(/package_path/);
-    });
-    test('omitting package_source bakes no packageSource/packagePath into the config', async () => {
-        const script = await buildScript();
-        const configLine = script.split('\n').find((l) => l.startsWith('var CONFIG = '));
-        expect(configLine).toBeDefined();
-        expect(configLine).not.toContain('packageSource');
-        expect(configLine).not.toContain('packagePath');
-    });
-    test('renders the checked-out Gradle project at package_path (no archive)', async () => {
-        const project = makeProject({ screens: { XProof: 'x.png' } });
-        writeReference(project, 'x.png');
-        // The committed project lives at a repo-relative path; no package.tar.gz.
-        writeGradleProjectDir(join(project.dir, 'android-app'));
-        const run = runScript(project, await buildScript({ package_source: 'repo', package_path: 'android-app' }), { FAKE_ROBORAZZI_SCREENS: 'XProof' });
-        expect(run.status).toBe(0);
-        const doc = readResult(project);
-        expect(doc.package_source).toBe('repo');
-        expect(doc.error).toBeNull();
-        const screen = doc.screens.find((s) => s.screen === 'XProof');
-        expect(screen?.status).toBe('rendered');
-        expect(screen?.rendered_image_path).toBe('ui-fidelity/rendered/XProof.png');
-        // The render came from the checkout, not an extracted tarball.
-        expect(existsSync(join(project.dir, '.ci', 'inputs', 'package.tar.gz'))).toBe(false);
-    });
-    test('a missing package_path directory fails cleanly with a per-build error', async () => {
-        const project = makeProject({ screens: { XProof: 'x.png' } });
-        writeReference(project, 'x.png');
-        // No project at the path.
-        const run = runScript(project, await buildScript({ package_source: 'repo', package_path: 'nope' }), { FAKE_ROBORAZZI_SCREENS: 'XProof' });
-        expect(run.status).toBe(1);
-        const doc = readResult(project);
-        expect(doc.package_source).toBe('repo');
-        expect(doc.error?.code).toBe('ANDROID_PROJECT_MISSING');
-    });
-    test('a package_path without a settings script fails cleanly', async () => {
-        const project = makeProject({ screens: { XProof: 'x.png' } });
-        writeReference(project, 'x.png');
-        // A directory that is not a Gradle project root.
-        mkdirSync(join(project.dir, 'not-a-project'), { recursive: true });
-        writeFileSync(join(project.dir, 'not-a-project', 'README.md'), '# nope\n');
-        const run = runScript(project, await buildScript({ package_source: 'repo', package_path: 'not-a-project' }), { FAKE_ROBORAZZI_SCREENS: 'XProof' });
-        expect(run.status).toBe(1);
-        expect(readResult(project).error?.code).toBe('ANDROID_PROJECT_ROOT_MISSING');
-    });
-    test('composes with reference_source repo (project + reference both from the checkout)', async () => {
-        const project = makeProject({ screens: { XProof: 'refs/x.png' } });
-        mkdirSync(join(project.dir, 'refs'), { recursive: true });
-        writeFileSync(join(project.dir, 'refs', 'x.png'), Buffer.concat([PNG_MAGIC, Buffer.from('ref:x')]));
-        writeGradleProjectDir(join(project.dir, 'android-app'));
-        const run = runScript(project, await buildScript({
-            package_source: 'repo',
-            package_path: 'android-app',
-            reference_source: 'repo',
-        }), { FAKE_ROBORAZZI_SCREENS: 'XProof' });
-        expect(run.status).toBe(0);
-        const doc = readResult(project);
-        expect(doc.package_source).toBe('repo');
-        const screen = doc.screens.find((s) => s.screen === 'XProof');
-        expect(screen?.status).toBe('rendered');
-        expect(screen?.reference_image_path).toBe('ui-fidelity/references/XProof.png');
-    });
-});
-// Clone-free package delivery (fidelity-linux 03): the dispatched YAML carries
-// a signed package_url; the runtime downloads it to .ci/inputs/package.tar.gz
-// and proceeds byte-for-byte like inputs mode, resolving each screen's
-// committed reference INSIDE the extracted package (repo-relative path minus
-// the package_path prefix) — there is no checkout on a clone-free worker.
-describe('package_source: url', () => {
-    /**
-     * Serve one tar.gz (or a 404) from a loopback HTTP server IN A CHILD
-     * PROCESS. runScript executes the generated script via spawnSync, which
-     * blocks this process's event loop — an in-process server would deadlock
-     * against the script's curl. The child prints its port once listening.
-     */
-    const SERVE_PACKAGE_SRC = [
-        "var http = require('http');",
-        "var fs = require('fs');",
-        'var filePath = process.argv[1];',
-        'var server = http.createServer(function (req, res) {',
-        "  if (filePath === '-') { res.statusCode = 404; res.end('gone'); return; }",
-        "  res.setHeader('content-type', 'application/gzip');",
-        '  res.end(fs.readFileSync(filePath));',
-        '});',
-        "server.listen(0, '127.0.0.1', function () {",
-        "  console.log('PORT ' + server.address().port);",
-        '});',
-    ].join('\n');
-    async function servePackage(archive) {
-        let filePath = '-';
-        if (archive !== null) {
-            const dir = mkdtempSync(join(tmpdir(), 'ui-fidelity-url-serve-'));
-            tempDirs.push(dir);
-            filePath = join(dir, 'package.tar.gz');
-            writeFileSync(filePath, archive);
-        }
-        const child = spawn('node', ['-e', SERVE_PACKAGE_SRC, filePath], {
-            stdio: ['ignore', 'pipe', 'inherit'],
-        });
-        const port = await new Promise((resolvePort, rejectPort) => {
-            let buffered = '';
-            const timer = setTimeout(() => rejectPort(new Error('package server did not start')), 10_000);
-            child.stdout.on('data', (chunk) => {
-                buffered += chunk.toString();
-                const match = /PORT (\d+)/.exec(buffered);
-                if (match) {
-                    clearTimeout(timer);
-                    resolvePort(Number(match[1]));
-                }
-            });
-            child.on('exit', () => rejectPort(new Error('package server exited early')));
-        });
-        return {
-            url: `http://127.0.0.1:${port}/api/fidelity/packages/blob1?exp=1&sig=ab`,
-            close: () => new Promise((resolveClose) => {
-                child.once('exit', () => resolveClose(undefined));
-                child.kill('SIGKILL');
-            }),
-        };
-    }
-    /** Archive shaped like the dashboard's assembly: package-dir contents at the
-     *  archive root, committed references under references/. */
-    function packagedProject() {
-        return makeTarGz([
-            ...gradleProjectEntries(''),
-            { name: 'references/x.png', content: Buffer.concat([PNG_MAGIC, Buffer.from('ref:url-x')]) },
-        ]);
-    }
-    test('package_source url requires package_url and package_path', async () => {
-        const executor = new UiFidelityRenderAndroidStepExecutor();
-        await expect(executor.execute({ package_source: 'url', package_path: 'android-app' }, {}, testConfig)).rejects.toThrow(/package_url/);
-        await expect(executor.execute({ package_source: 'url', package_url: 'https://x.test/p' }, {}, testConfig)).rejects.toThrow(/package_path/);
-    });
-    test('rejects reference_source alongside package_source url (URL mode owns references)', async () => {
-        const executor = new UiFidelityRenderAndroidStepExecutor();
-        await expect(executor.execute({
-            package_source: 'url',
-            package_url: 'https://x.test/p',
-            package_path: 'android-app',
-            reference_source: 'repo',
-        }, {}, testConfig)).rejects.toThrow(/reference_source/);
-    });
-    test('url mode requires curl on the runner (validation requirement)', () => {
-        const executor = new UiFidelityRenderAndroidStepExecutor();
-        const urlReqs = executor.getValidationRequirements({ package_source: 'url' }, {}, testConfig);
-        expect(urlReqs.some((r) => r.name === 'curl')).toBe(true);
-        // Default inputs mode keeps tar only — no new requirement for existing runs.
-        const defaultReqs = executor.getValidationRequirements({}, {}, testConfig);
-        expect(defaultReqs.some((r) => r.name === 'curl')).toBe(false);
-    });
-    test('downloads the package, renders, and resolves references inside it', async () => {
-        const project = makeProject({ screens: { XProof: 'android-app/references/x.png' } });
-        const served = await servePackage(packagedProject());
-        try {
-            const run = runScript(project, await buildScript({
-                package_source: 'url',
-                package_url: served.url,
-                package_path: 'android-app',
-            }), { FAKE_ROBORAZZI_SCREENS: 'XProof' });
-            expect(run.status).toBe(0);
-            const doc = readResult(project);
-            expect(doc.package_source).toBe('url');
-            const screen = doc.screens.find((s) => s.screen === 'XProof');
-            expect(screen?.status).toBe('rendered');
-            expect(screen?.reference_image_path).toBe('ui-fidelity/references/XProof.png');
-            expect(isPng(artifact(project, 'ui-fidelity/references/XProof.png'))).toBe(true);
-        }
-        finally {
-            await served.close();
-        }
-    });
-    test('a failed download is one structured build error, not per-screen noise', async () => {
-        const project = makeProject({ screens: { XProof: 'android-app/references/x.png' } });
-        const served = await servePackage(null); // 404
-        try {
-            const run = runScript(project, await buildScript({
-                package_source: 'url',
-                package_url: served.url,
-                package_path: 'android-app',
-            }));
-            expect(run.status).not.toBe(0);
-            const doc = readResult(project);
-            expect(doc.error?.code).toBe('ANDROID_PACKAGE_DOWNLOAD_FAILED');
-            const screen = doc.screens.find((s) => s.screen === 'XProof');
-            // The failure is the build's, not the screen's — no bogus
-            // REFERENCE_MISSING masking the real cause.
-            expect(screen?.error).toBeNull();
-        }
-        finally {
-            await served.close();
-        }
-    });
-    test('a reference outside the package directory fails that screen only', async () => {
-        const project = makeProject({
-            screens: {
-                XProof: 'android-app/references/x.png',
-                Stray: 'design/elsewhere/stray.png',
-            },
-        });
-        const served = await servePackage(packagedProject());
-        try {
-            const run = runScript(project, await buildScript({
-                package_source: 'url',
-                package_url: served.url,
-                package_path: 'android-app',
-            }), { FAKE_ROBORAZZI_SCREENS: 'XProof' });
-            expect(run.status).not.toBe(0);
-            const doc = readResult(project);
-            expect(doc.screens.find((s) => s.screen === 'XProof')?.status).toBe('rendered');
-            const stray = doc.screens.find((s) => s.screen === 'Stray');
-            expect(stray?.status).toBe('render_failed');
-            expect(stray?.error?.code).toBe('REFERENCE_MISSING');
-        }
-        finally {
-            await served.close();
-        }
-    });
-});
-describe('reference_source: repo', () => {
-    test('rejects an unknown reference_source value', async () => {
-        const executor = new UiFidelityRenderAndroidStepExecutor();
-        await expect(executor.execute({ reference_source: 'artifact' }, {}, testConfig)).rejects.toThrow(/reference_source/);
-    });
-    test('omitting reference_source bakes no referenceSource into the script config', async () => {
-        const script = await buildScript();
-        const configLine = script.split('\n').find((l) => l.startsWith('var CONFIG = '));
-        expect(configLine).toBeDefined();
-        expect(configLine).not.toContain('referenceSource');
-    });
-    test('reads each screen reference from its repo-relative path in the checkout', async () => {
-        const project = makeProject({
-            screens: { XProof: 'refs/x.png', YProof: 'design/y.png' },
-        });
-        // Committed references live at repo-relative paths (resolved against cwd),
-        // NOT in .ci/inputs.
-        mkdirSync(join(project.dir, 'refs'), { recursive: true });
-        mkdirSync(join(project.dir, 'design'), { recursive: true });
-        writeFileSync(join(project.dir, 'refs', 'x.png'), Buffer.concat([PNG_MAGIC, Buffer.from('ref:x')]));
-        writeFileSync(join(project.dir, 'design', 'y.png'), Buffer.concat([PNG_MAGIC, Buffer.from('ref:y')]));
-        stageArchive(project, gradleProjectEntries());
-        const run = runScript(project, await buildScript({ reference_source: 'repo' }), {
-            FAKE_ROBORAZZI_SCREENS: 'XProof,YProof',
-        });
-        expect(run.status).toBe(0);
-        const doc = readResult(project);
-        expect(doc.screens.map((s) => s.status)).toEqual(['rendered', 'rendered']);
-        expect(doc.screens.map((s) => s.reference_image_path)).toEqual([
-            'ui-fidelity/references/XProof.png',
-            'ui-fidelity/references/YProof.png',
-        ]);
-        expect(isPng(artifact(project, 'ui-fidelity/references/XProof.png'))).toBe(true);
-        expect(isPng(artifact(project, 'ui-fidelity/references/YProof.png'))).toBe(true);
-    });
-    test('fails one screen when its committed reference is missing, renders the rest', async () => {
-        const project = makeProject({
-            screens: { XProof: 'refs/x.png', GhostProof: 'refs/ghost.png' },
-        });
-        mkdirSync(join(project.dir, 'refs'), { recursive: true });
-        writeFileSync(join(project.dir, 'refs', 'x.png'), Buffer.concat([PNG_MAGIC, Buffer.from('ref:x')]));
-        // refs/ghost.png intentionally absent.
-        stageArchive(project, gradleProjectEntries());
-        const run = runScript(project, await buildScript({ reference_source: 'repo' }), {
-            FAKE_ROBORAZZI_SCREENS: 'XProof',
-        });
-        expect(run.status).not.toBe(0);
-        const doc = readResult(project);
-        expect(doc.screens.find((s) => s.screen === 'XProof')?.status).toBe('rendered');
-        const ghost = doc.screens.find((s) => s.screen === 'GhostProof');
-        expect(ghost?.status).toBe('render_failed');
-        expect(ghost?.error?.code).toBe('REFERENCE_MISSING');
-    });
-});
-// The fake gradlew/swift cannot exercise the real Roborazzi/Robolectric render
-// or the CoreGraphics trim. This end-to-end guard ships the committed Roborazzi
-// fixture as the render package and runs the whole step with the real
-// toolchain, proving the tracer bullet: ship a lean Gradle project, get a
-// paired result back. Gated behind CIBUILD_UI_FIDELITY_REAL_ANDROID=1 (the
-// Android analog of the iOS real-Swift gate); needs the Android toolchain +
-// warm Roborazzi caches on the dev machine.
-describe('android render runtime — real toolchain', () => {
-    const realAndroidTest = process.env.CIBUILD_UI_FIDELITY_REAL_ANDROID === '1' ? test : test.skip;
-    // A real 1x1 PNG so the trim helper's reference load/align step succeeds.
-    const ONE_BY_ONE_PNG = Buffer.from('iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAAC0lEQVR42mNk+M9QDwADhgGAWjR9awAAAABJRU5ErkJggg==', 'base64');
-    const FIXTURE_DIR = resolve(dirname(fileURLToPath(import.meta.url)), '../../../../cibuild-runner/scripts/roborazzi-fixture');
-    realAndroidTest('renders the Roborazzi fixture at 720x1280 and returns a paired result', async () => {
-        const dir = mkdtempSync(join(tmpdir(), 'ui-fidelity-android-real-'));
-        tempDirs.push(dir);
-        const project = { dir, binDir: '' };
-        mkdirSync(join(dir, '.ci', 'inputs'), { recursive: true });
-        writeFileSync(join(dir, '.ci', 'inputs', 'params.json'), JSON.stringify({ screens: { XProof: 'ref.png' } }));
-        writeFileSync(join(dir, '.ci', 'inputs', 'ref.png'), ONE_BY_ONE_PNG);
-        // Archive the committed fixture (minus build/.gradle noise) as the
-        // shipped render package, with the real system tar.
-        const stage = mkdtempSync(join(tmpdir(), 'ui-fidelity-android-fixture-'));
-        tempDirs.push(stage);
-        cpSync(FIXTURE_DIR, join(stage, 'project'), { recursive: true });
-        const archive = join(dir, '.ci', 'inputs', 'package.tar.gz');
-        const tar = spawnSync('tar', ['-czf', archive, '-C', stage, '--exclude', '*/build', '--exclude', '*/.gradle', 'project'], { encoding: 'utf-8' });
-        expect(tar.stderr).toBe('');
-        expect(tar.status).toBe(0);
-        const script = await buildScript();
-        const run = spawnSync('node', ['-e', script], {
-            cwd: dir,
-            encoding: 'utf-8',
-            env: { ...process.env },
-            maxBuffer: 64 * 1024 * 1024,
-        });
-        if (run.status !== 0) {
-            // eslint-disable-next-line no-console
-            console.error('STDOUT\n' + run.stdout + '\nSTDERR\n' + run.stderr);
-        }
-        expect(run.status).toBe(0);
-        const doc = readResult(project);
-        expect(doc.error).toBeNull();
-        const screen = doc.screens.find((s) => s.screen === 'XProof');
-        expect(screen?.status).toBe('rendered');
-        expect(screen?.error).toBeNull();
-        // The raw render before trimming is the fixture's full 720x1280 canvas.
-        expect(run.stdout).toContain('XProof: 720x1280');
-        // Paired, contract-shaped artifacts are produced.
-        expect(isPng(artifact(project, 'ui-fidelity/rendered/XProof.png'))).toBe(true);
-        expect(isPng(artifact(project, 'ui-fidelity/aligned/XProof.png'))).toBe(true);
-        expect(screen?.dimensions?.rendered_px[0]).toBeGreaterThan(0);
-        expect(screen?.dimensions?.rendered_px[1]).toBeGreaterThan(0);
-    }, 600_000);
-});
-//# sourceMappingURL=ui-fidelity-render-android.test.js.map