@invarn/cibuild 2.1.0 → 2.1.1

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

@@ -9,6 +9,15 @@
  *   1. Reads `.ci/inputs/params.json`
  *      ({ "screens": { "<ScreenName>": "<referenceFileBasename>" } });
  *      reference images live at `.ci/inputs/<basename>`.
+ *      Optional reference-provenance sidecar (manifest-driven multi-state path):
+ *      `"render_locale": "<locale>"` plus
+ *      `"provenance": { "<ScreenName>": { figmaNode, locale, resolved, exportedAt } }`.
+ *      When `render_locale` is present, each screen's reference is gated on its
+ *      provenance METADATA (never pixels/OCR): absent, unprovenanced,
+ *      `resolved == false`, or `locale != render_locale` → status
+ *      `unverifiable` for that screen, so a rotten reference fails loud instead
+ *      of yielding a confident-but-false PASS. Content differences (copy,
+ *      geometry) are NOT gated here — they stay soft, judged findings.
  *   2. Extracts and validates the shipped Gradle project shipped as
  *      `.ci/inputs/package.tar.gz` (single project root carrying a settings
  *      script, bounded extracted size, safe member paths).
@@ -136,6 +145,54 @@ function setError(entry, code, message) {
   entry.error = { code: code, message: sanitizeMessage(message) };
 }
 
+// A reference the gate cannot honestly judge: a hard, mechanical metadata
+// verdict (never pixels/OCR). Distinct status so a rotten reference fails loud
+// instead of producing a confident-but-false PASS.
+function setUnverifiable(entry, code, message) {
+  entry.status = 'unverifiable';
+  entry.error = { code: code, message: sanitizeMessage(message) };
+}
+
+// Inlined twin of src/yaml/steps/fidelity-reference-provenance.ts (this script
+// ships self-contained and cannot import it). The render-step integration tests
+// exercise BOTH against the same fixtures so they cannot silently drift. Returns
+// a { code, message } fault, or null when the reference is verifiable.
+function provenanceFault(screen, provenance, renderLocale, referenceExists) {
+  var hasProvenance =
+    provenance != null &&
+    typeof provenance === 'object' &&
+    typeof provenance.locale === 'string' &&
+    typeof provenance.resolved === 'boolean';
+  if (!hasProvenance) {
+    return {
+      code: 'NO_PROVENANCE',
+      message:
+        'reference for ' + screen + ' has no export provenance; a reference is ' +
+        'verifiable only when exported through the deterministic path',
+    };
+  }
+  if (provenance.resolved === false) {
+    return {
+      code: 'UNRESOLVED_REFERENCE',
+      message:
+        'reference for ' + screen + ' still has unresolved copy placeholders ' +
+        '(resolved=false) — export it with the copy filled in',
+    };
+  }
+  if (provenance.locale !== renderLocale) {
+    return {
+      code: 'LOCALE_MISMATCH',
+      message:
+        'reference for ' + screen + ' is locale "' + provenance.locale +
+        '" but the render locale is "' + renderLocale + '"',
+    };
+  }
+  if (!referenceExists) {
+    return { code: 'REFERENCE_ABSENT', message: 'reference image for ' + screen + ' is absent' };
+  }
+  return null;
+}
+
 function outputTail(result) {
   var combined = ((result.stdout || '') + '\n' + (result.stderr || '')).trim();
   if (combined.length > 2000) combined = '...' + combined.slice(-2000);
@@ -549,6 +606,18 @@ function main() {
     return 1;
   }
 
+  // Reference-provenance sidecar. Enforcement is ON only when the run declares
+  // its render locale (the manifest-driven multi-state path always does);
+  // legacy single-reference runs without it keep their existing behaviour.
+  var renderLocale =
+    typeof params.render_locale === 'string' && params.render_locale !== ''
+      ? params.render_locale
+      : null;
+  var provenanceMap =
+    params.provenance && typeof params.provenance === 'object' && !Array.isArray(params.provenance)
+      ? params.provenance
+      : {};
+
   var screens = Object.keys(params.screens);
   currentEntries = screens.map(function (screen) {
     return {
@@ -600,7 +669,25 @@ function main() {
     } catch (statError) {
       sourceStat = null;
     }
-    if (!sourceStat || !sourceStat.isFile()) {
+    var referenceExists = !!(sourceStat && sourceStat.isFile());
+
+    if (renderLocale) {
+      // Provenance enforcement: a reference that is absent, unprovenanced,
+      // unresolved, or in the wrong locale is UNVERIFIABLE (hard, loud) — not a
+      // render_failed and never a silent PASS.
+      var fault = provenanceFault(
+        entry.screen,
+        provenanceMap[entry.screen],
+        renderLocale,
+        referenceExists
+      );
+      if (fault) {
+        setUnverifiable(entry, fault.code, fault.message);
+        return;
+      }
+    } else if (!referenceExists) {
+      // Legacy (no render locale declared): an absent reference stays a
+      // render_failed REFERENCE_MISSING, exactly as before.
       setError(
         entry,
         'REFERENCE_MISSING',

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

@@ -286,6 +286,104 @@ describe('android render runtime — render + trim (happy path)', () => {
         expect(doc.screens.map((s) => s.status)).toEqual(['rendered', 'rendered']);
     });
 });
+describe('android render runtime — reference provenance (UNVERIFIABLE)', () => {
+    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 is unverifiable', 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) is unverifiable', async () => {
+        const project = provProject({
+            screens: { XProof: 'x.png' },
+            render_locale: 'en',
+            provenance: { XProof: { ...GOOD_PROV, resolved: false } },
+        });
+        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('UNRESOLVED_REFERENCE');
+    });
+    test('an Italian reference against an English render is unverifiable', async () => {
+        const project = provProject({
+            screens: { XProof: 'x.png' },
+            render_locale: 'en',
+            provenance: { XProof: { ...GOOD_PROV, locale: 'it' } },
+        });
+        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('LOCALE_MISMATCH');
+    });
+    test('an absent reference with good provenance is unverifiable', 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('a good provenanced reference renders normally (a content diff is left to the judge)', 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();
+    });
+    test('independent verdicts: a sibling stays rendered while one state is unverifiable', 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' });
+        const doc = readResult(project);
+        expect(doc.screens.find((s) => s.screen === 'XProof')?.status).toBe('rendered');
+        const y = doc.screens.find((s) => s.screen === 'YProof');
+        expect(y?.status).toBe('unverifiable');
+        expect(y?.error?.code).toBe('UNRESOLVED_REFERENCE');
+    });
+    test('without a render_locale, provenance is not 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');
+    });
+});
 describe('android render runtime — error isolation', () => {
     function twoScreenProject() {
         const project = makeProject({ screens: { XProof: 'x.png', YProof: 'y.png' } });

package/package.json

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