@invarn/cibuild 2.2.6 → 2.2.8

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

@@ -50,6 +50,7 @@
  */
 import { BaseStepExecutor } from './base.js';
 import { RENDER_SCRIPT_TRIM_STAGE } from './render-post-processor.js';
+import { RENDER_SCRIPT_SOURCE_DIGEST_STAGE } from '../fidelity-input-digest.js';
 /**
  * Default render size in device points. 393x852 is the iPhone-class portrait
  * canvas shared by the iPhone 14 Pro / 15 / 16 — the most common modern
@@ -63,6 +64,10 @@ export const DEFAULT_SCALE = 2;
 export const PACKAGE_SOURCES = ['repo', 'inputs'];
 /** Default package source: the package lives in the repo checkout. */
 export const DEFAULT_PACKAGE_SOURCE = 'repo';
+/** Valid values for the reference_source input. */
+export const REFERENCE_SOURCES = ['repo', 'inputs'];
+/** Default reference source: references arrive as run inputs (v1 behaviour). */
+export const DEFAULT_REFERENCE_SOURCE = 'inputs';
 /** Basename of the shipped package archive inside the run-inputs directory. */
 export const PACKAGE_ARCHIVE_BASENAME = 'package.tar.gz';
 /**
@@ -335,6 +340,13 @@ function runSwift(args) {
 }
 
 function renderWithHarness(renderable, packagePath) {
+  // Snapshot the user package's input files BEFORE any Swift build, so build
+  // products (.build, DerivedData) never perturb the content key. A package is
+  // safely cacheable only when it is hermetic — its own files are its whole
+  // dependency closure; a non-hermetic one emits no digest and so is never
+  // skipped by a consumer.
+  var packageFiles = __fidCollectPackageFiles(packagePath);
+  var packageHermetic = __fidIsHermetic(packageFiles);
   var harnessDir = fs.mkdtempSync(path.join(os.tmpdir(), 'ui-fidelity-harness-'));
   registerPathReplacement(harnessDir, '<harness>');
   log('harness package: ' + harnessDir);
@@ -416,6 +428,20 @@ function renderWithHarness(renderable, packagePath) {
       entry.rendered_image_path = relative;
       entry.status = 'rendered';
       entry.error = null;
+      // Content key over the package source + this screen's reference: lets a
+      // consumer skip a re-render whose inputs are unchanged. Emitted only for a
+      // hermetic package; otherwise omitted so no stale verdict can be replayed.
+      if (packageHermetic) {
+        var referenceBytes = null;
+        try {
+          if (entry.reference_image_path) {
+            referenceBytes = fs.readFileSync(path.resolve(artifactsDir, entry.reference_image_path));
+          }
+        } catch (digestReferenceError) {
+          referenceBytes = null;
+        }
+        entry.source_digest = __fidSourceDigest(packageFiles, referenceBytes);
+      }
       log('rendered ' + entry.screen + ' -> ' + relative);
     });
   } finally {
@@ -1112,6 +1138,41 @@ function buildPackageSourceMain() {
     return main;
 }
 const RENDER_SCRIPT_MAIN_WITH_PACKAGE_SOURCE = buildPackageSourceMain();
+/**
+ * Patches the reference-sourcing block to read each screen's reference from a
+ * repo-relative path (resolved against the checkout) instead of a plain
+ * basename under `.ci/inputs/`. Applied on top of EITHER base main (v1 or the
+ * package_source variant) — the package patches never touch this block, so the
+ * anchor is present and unique in both. The downstream stat/copy logic is
+ * unchanged; only how `source` is computed differs.
+ */
+function buildReferenceRepoMain(base) {
+    return replaceOnce(base, 'var basename = params.screens[entry.screen];\n' +
+        '    if (\n' +
+        "      typeof basename !== 'string' || basename === '' ||\n" +
+        "      basename === '.' || basename === '..' ||\n" +
+        '      basename !== path.basename(basename)\n' +
+        '    ) {\n' +
+        '      setError(\n' +
+        '        entry,\n' +
+        "        'REFERENCE_MISSING',\n" +
+        "        'reference for ' + entry.screen + ' must be a plain file basename inside ' +\n" +
+        "          inputsDir + ', got: ' + JSON.stringify(basename)\n" +
+        '      );\n' +
+        '      return;\n' +
+        '    }\n' +
+        '    var source = path.join(inputsDir, basename);', 'var refPath = params.screens[entry.screen];\n' +
+        "    if (typeof refPath !== 'string' || refPath === '') {\n" +
+        '      setError(\n' +
+        '        entry,\n' +
+        "        'REFERENCE_MISSING',\n" +
+        "        'reference for ' + entry.screen + ' must be a non-empty repo-relative path, got: ' +\n" +
+        '          JSON.stringify(refPath)\n' +
+        '      );\n' +
+        '      return;\n' +
+        '    }\n' +
+        '    var source = path.resolve(refPath);');
+}
 /**
  * Evaluates the embedded generator source and returns the real functions, so
  * unit tests exercise exactly the code that ships inside the runtime script.
@@ -1133,14 +1194,21 @@ export function getRenderScriptInternals() {
  * unpatched v1 runtime is used).
  */
 export function generateRenderScript(config) {
+    let main = config.packageSource === undefined
+        ? RENDER_SCRIPT_MAIN
+        : RENDER_SCRIPT_MAIN_WITH_PACKAGE_SOURCE;
+    // Reference-from-repo is an independent dimension layered on top of whichever
+    // package base applies. Absent → byte-identical reference block (v1).
+    if (config.referenceSource === 'repo') {
+        main = buildReferenceRepoMain(main);
+    }
     return [
         "'use strict';",
         '// ui-fidelity-render runtime script (generated by cibuild at YAML conversion time)',
         'var CONFIG = ' + JSON.stringify(config) + ';',
         RENDER_SCRIPT_GENERATORS,
-        config.packageSource === undefined
-            ? RENDER_SCRIPT_MAIN
-            : RENDER_SCRIPT_MAIN_WITH_PACKAGE_SOURCE,
+        RENDER_SCRIPT_SOURCE_DIGEST_STAGE,
+        main,
     ].join('\n');
 }
 /**
@@ -1196,12 +1264,30 @@ export class UiFidelityRenderStepExecutor extends BaseStepExecutor {
             throw new Error(`Invalid target '${target}' for step '${stepName}': ` +
                 'must be a Swift module identifier (letters, digits, underscores)');
         }
+        // reference_source mirrors package_source: validate when provided, but only
+        // record (and patch the script for) the non-default "repo" so omitting it —
+        // or setting the default "inputs" — keeps the v1 reference block intact.
+        const rawReferenceSource = this.getInput(inputs, 'reference_source', undefined);
+        let referenceSource;
+        if (rawReferenceSource !== undefined) {
+            const value = String(rawReferenceSource);
+            if (!REFERENCE_SOURCES.includes(value)) {
+                throw new Error(`Invalid reference_source '${value}' for step '${stepName}': ` +
+                    `expected one of: ${REFERENCE_SOURCES.join(', ')}`);
+            }
+            if (value === 'repo') {
+                referenceSource = 'repo';
+            }
+        }
         const { width, height } = parseRenderSize(String(this.getInput(inputs, 'render_size', DEFAULT_RENDER_SIZE)));
         const scale = parseScale(this.getInput(inputs, 'scale', DEFAULT_SCALE));
         const config = { packagePath, target, width, height, scale };
         if (packageSource !== undefined) {
             config.packageSource = packageSource;
         }
+        if (referenceSource !== undefined) {
+            config.referenceSource = referenceSource;
+        }
         const script = generateRenderScript(config);
         return this.createNodeStep(script, stepName);
     }

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

@@ -319,10 +319,13 @@ describe('registry integration', () => {
         expect(Object.keys(inputs).sort()).toEqual([
             'package_path',
             'package_source',
+            'reference_source',
             'render_size',
             'scale',
             'target',
         ]);
+        expect(inputs.reference_source.required).toBe(false);
+        expect(inputs.reference_source.default).toBe('inputs');
         // package_path/target are enforced by the executor in repo mode (the
         // default); a package_source:inputs config is valid without either, so
         // neither is unconditionally required at the schema level.
@@ -528,6 +531,7 @@ describe('render script runtime', () => {
                     error: null,
                     reference_image_path: 'ui-fidelity/references/HomeView.png',
                     rendered_image_path: 'ui-fidelity/rendered/HomeView.png',
+                    source_digest: expect.stringMatching(/^[0-9a-f]{64}$/),
                 },
                 {
                     screen: 'SettingsView',
@@ -535,6 +539,7 @@ describe('render script runtime', () => {
                     error: null,
                     reference_image_path: 'ui-fidelity/references/SettingsView.png',
                     rendered_image_path: 'ui-fidelity/rendered/SettingsView.png',
+                    source_digest: expect.stringMatching(/^[0-9a-f]{64}$/),
                 },
             ],
         });
@@ -644,6 +649,17 @@ describe('render script runtime', () => {
         expect(settings.error).toBeNull();
         expect(isPng(artifact(project, 'ui-fidelity/rendered/SettingsView.png'))).toBe(true);
     });
+    test('emits a source_digest content key on a rendered screen entry', async () => {
+        const project = makeProject({ screens: { HomeView: 'home.png' } });
+        writeReference(project, 'home.png');
+        // A committed package file so the digest is over real package source.
+        writeFileSync(join(project.packageDir, 'Package.swift'), '// swift-tools-version:5.9\nimport PackageDescription\n');
+        const run = runScript(project, await buildScript(project));
+        expect(run.status).toBe(0);
+        const home = readResult(project).screens[0];
+        expect(home.status).toBe('rendered');
+        expect(home.source_digest).toMatch(/^[0-9a-f]{64}$/);
+    });
     test('a reference that is a directory fails only that screen', async () => {
         const project = makeProject({
             screens: { HomeView: 'home-dir.png', SettingsView: 'settings.png' },
@@ -913,6 +929,7 @@ describe('render script runtime (package_source: repo)', () => {
                     error: null,
                     reference_image_path: 'ui-fidelity/references/HomeView.png',
                     rendered_image_path: 'ui-fidelity/rendered/HomeView.png',
+                    source_digest: expect.stringMatching(/^[0-9a-f]{64}$/),
                     aligned_image_path: 'ui-fidelity/aligned/HomeView.png',
                     dimensions: {
                         rendered_px: [320, 640],
@@ -1092,6 +1109,7 @@ describe('render script runtime (package_source: inputs)', () => {
                     error: null,
                     reference_image_path: 'ui-fidelity/references/HomeView.png',
                     rendered_image_path: 'ui-fidelity/rendered/HomeView.png',
+                    source_digest: expect.stringMatching(/^[0-9a-f]{64}$/),
                     aligned_image_path: 'ui-fidelity/aligned/HomeView.png',
                     dimensions: {
                         rendered_px: [320, 640],
@@ -1105,6 +1123,7 @@ describe('render script runtime (package_source: inputs)', () => {
                     error: null,
                     reference_image_path: 'ui-fidelity/references/SettingsView.png',
                     rendered_image_path: 'ui-fidelity/rendered/SettingsView.png',
+                    source_digest: expect.stringMatching(/^[0-9a-f]{64}$/),
                     aligned_image_path: 'ui-fidelity/aligned/SettingsView.png',
                     dimensions: {
                         rendered_px: [320, 640],
@@ -1509,4 +1528,56 @@ describe('committed fixture package', () => {
         expectNoAbsolutePathLeaks(project, result);
     }, 600_000);
 });
+describe('reference_source: repo', () => {
+    test('rejects an unknown reference_source value', async () => {
+        const executor = new UiFidelityRenderStepExecutor();
+        await expect(executor.execute({ package_path: './pkg', target: 'MyViews', reference_source: 'artifact' }, {}, testConfig)).rejects.toThrow(/reference_source/);
+    });
+    test('omitting reference_source bakes no referenceSource into the script config', async () => {
+        const script = await buildScript(makeProject());
+        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: { HomeView: 'refs/home.png', SettingsView: 'design/settings.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', 'home.png'), Buffer.concat([PNG_MAGIC, Buffer.from('ref:home')]));
+        writeFileSync(join(project.dir, 'design', 'settings.png'), Buffer.concat([PNG_MAGIC, Buffer.from('ref:settings')]));
+        const script = await buildScript(project, { reference_source: 'repo' });
+        const run = runScript(project, script);
+        expect(run.status).toBe(0);
+        expect(isPng(artifact(project, 'ui-fidelity/references/HomeView.png'))).toBe(true);
+        expect(isPng(artifact(project, 'ui-fidelity/references/SettingsView.png'))).toBe(true);
+        const result = readResult(project);
+        expect(result.screens.map((s) => s.status)).toEqual(['rendered', 'rendered']);
+        expect(result.screens.map((s) => s.reference_image_path)).toEqual([
+            'ui-fidelity/references/HomeView.png',
+            'ui-fidelity/references/SettingsView.png',
+        ]);
+    });
+    test('fails one screen when its committed reference is missing, renders the rest', async () => {
+        const project = makeProject({
+            screens: { HomeView: 'refs/home.png', GhostView: 'refs/ghost.png' },
+        });
+        mkdirSync(join(project.dir, 'refs'), { recursive: true });
+        writeFileSync(join(project.dir, 'refs', 'home.png'), Buffer.concat([PNG_MAGIC, Buffer.from('ref:home')]));
+        // refs/ghost.png intentionally absent.
+        const run = runScript(project, await buildScript(project, { reference_source: 'repo' }));
+        expect(run.status).not.toBe(0);
+        const result = readResult(project);
+        const home = result.screens.find((s) => s.screen === 'HomeView');
+        const ghost = result.screens.find((s) => s.screen === 'GhostView');
+        expect(home?.status).toBe('rendered');
+        expect(ghost?.status).toBe('render_failed');
+        expect(ghost?.error?.code).toBe('REFERENCE_MISSING');
+    });
+});
 //# sourceMappingURL=ui-fidelity-render.test.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@invarn/cibuild",
-  "version": "2.2.6",
+  "version": "2.2.8",
   "description": "CI Build CLI — local pipeline orchestration and validation",
   "type": "module",
   "main": "dist/cli.cjs",