@invarn/cibuild 2.9.4 → 2.9.7

package/dist/src/yaml/steps/fastlane.js

@@ -1,79 +0,0 @@
-/**
- * Fastlane step: run a fastlane lane
- */
-import { BaseStepExecutor } from './base.js';
-/**
- * Runs a fastlane lane with Gemfile detection and optional gem update.
- */
-export class FastlaneStepExecutor extends BaseStepExecutor {
-    getValidationRequirements(_inputs, _env, _config) {
-        return [
-            this.requireCommand('fastlane', 'fastlane is required (install via gem install fastlane or Bundler)'),
-        ];
-    }
-    getOutputs() {
-        return [];
-    }
-    async execute(inputs, _env, _config) {
-        const stepName = 'fastlane';
-        const lane = this.getRequiredInput(inputs, 'lane', stepName);
-        const workDir = this.getInput(inputs, 'work_dir', '');
-        const updateFastlane = this.getInput(inputs, 'update_fastlane', 'true') === 'true';
-        const verboseLog = ['yes', 'true'].includes(this.getInput(inputs, 'verbose_log', 'no'));
-        const enableCache = ['yes', 'true'].includes(this.getInput(inputs, 'enable_cache', 'yes'));
-        const commands = [];
-        commands.push('# fastlane — run a fastlane lane');
-        commands.push('echo "🚀 Running fastlane..."');
-        commands.push('');
-        // Change to working directory if specified
-        if (workDir) {
-            commands.push(`cd '${this.escapeBash(workDir)}'`);
-            commands.push('');
-        }
-        // Detect Gemfile for bundle exec
-        commands.push('# Detect Gemfile for bundle exec');
-        commands.push('USE_BUNDLE_EXEC="false"');
-        commands.push('if [ -f "Gemfile" ] || [ -f "Gemfile.lock" ]; then');
-        commands.push('  if grep -q "fastlane" Gemfile.lock 2>/dev/null || grep -q "fastlane" Gemfile 2>/dev/null; then');
-        commands.push('    USE_BUNDLE_EXEC="true"');
-        commands.push('    echo "Gemfile detected with fastlane — using bundle exec"');
-        commands.push('  fi');
-        commands.push('fi');
-        commands.push('');
-        // Optionally update fastlane
-        if (updateFastlane) {
-            commands.push('# Update fastlane gem (skipped if Gemfile manages it)');
-            commands.push('if [ "$USE_BUNDLE_EXEC" = "true" ]; then');
-            commands.push('  echo "Gemfile present — running bundle install instead of gem update"');
-            commands.push('  bundle install');
-            commands.push('else');
-            commands.push('  echo "Updating fastlane gem..."');
-            commands.push('  gem install fastlane --no-document');
-            commands.push('fi');
-            commands.push('');
-        }
-        // Build the fastlane command
-        const verboseFlag = verboseLog ? ' --verbose' : '';
-        commands.push('# Run fastlane');
-        commands.push('if [ "$USE_BUNDLE_EXEC" = "true" ]; then');
-        commands.push(`  bundle exec fastlane ${this.escapeBash(lane)}${verboseFlag}`);
-        commands.push('else');
-        commands.push(`  fastlane ${this.escapeBash(lane)}${verboseFlag}`);
-        commands.push('fi');
-        commands.push('');
-        // Cache collection
-        if (enableCache) {
-            commands.push('# Collect cache paths');
-            commands.push('if [ -f "Podfile.lock" ]; then');
-            commands.push('  echo "Cache: Pods directory detected"');
-            commands.push('fi');
-            commands.push('if [ -f "Cartfile.resolved" ]; then');
-            commands.push('  echo "Cache: Carthage directory detected"');
-            commands.push('fi');
-        }
-        commands.push('echo "✅ fastlane lane complete"');
-        const script = this.createBashScriptFromCommands(commands, stepName);
-        return this.createScriptStep(script, stepName);
-    }
-}
-//# sourceMappingURL=fastlane.js.map

package/dist/src/yaml/steps/fidelity-aspect-guard.d.ts

@@ -1,53 +0,0 @@
-/**
- * Fidelity aspect-ratio guard.
- *
- * One named composable per state is the authoring norm; the failure this
- * catches is the opposite — several states stacked into one composable, which
- * renders far taller (or wider) than the single-state reference it is paired
- * against. That shows up as a sharp divergence between the rendered and
- * reference aspect ratios, well before a human reads the diff.
- *
- * The guard is a pure comparison over the dimensions the render already
- * reports (`rendered_px`, `reference_px`). It emits a WARNING when the
- * divergence exceeds a documented fold factor — it never fails the render, and
- * it stays silent when there is no reference to compare against.
- */
-/** Pixel dimensions as `[width, height]`. */
-export type PixelSize = [number, number];
-/**
- * Fold factor beyond which a rendered/reference aspect-ratio divergence is
- * worth a warning. A faithful single-state wrapper sits near 1.0; trim and
- * reference alignment nudge it a few percent; a re-stacked 2-up wrapper roughly
- * doubles one dimension and lands near 2.0. 1.5 catches the stack while
- * tolerating the wobble.
- */
-export declare const ASPECT_RATIO_WARN_FACTOR = 1.5;
-/** The outcome of comparing a rendered aspect ratio to its reference. */
-export interface AspectRatioCheck {
-    /** True only when both sizes are present and strictly positive. */
-    comparable: boolean;
-    /** Rendered width/height, or null when not comparable. */
-    renderedAspect: number | null;
-    /** Reference width/height, or null when not comparable. */
-    referenceAspect: number | null;
-    /**
-     * Symmetric divergence `max(r/ref, ref/r)` (≥ 1), or null when not
-     * comparable. 1.0 means identical proportions.
-     */
-    divergence: number | null;
-    /** True when comparable and the divergence exceeds the fold factor. */
-    warn: boolean;
-}
-/**
- * Compares a rendered size against its reference size. Returns a
- * non-warning, non-comparable result when either size is missing or
- * non-positive — the guard only speaks when it has two real frames to compare.
- */
-export declare function evaluateAspectRatio(renderedPx: PixelSize | null, referencePx: PixelSize | null, factor?: number): AspectRatioCheck;
-/**
- * Human/agent-readable warning line for a divergent screen, or null when the
- * screen does not warrant one. The caller decides where to surface it (preview
- * result, preflight output) — it is advisory, never a failure.
- */
-export declare function formatAspectRatioWarning(screen: string, check: AspectRatioCheck): string | null;
-//# sourceMappingURL=fidelity-aspect-guard.d.ts.map

package/dist/src/yaml/steps/fidelity-aspect-guard.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"fidelity-aspect-guard.d.ts","sourceRoot":"","sources":["../../../../src/yaml/steps/fidelity-aspect-guard.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AAEH,6CAA6C;AAC7C,MAAM,MAAM,SAAS,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;AAEzC;;;;;;GAMG;AACH,eAAO,MAAM,wBAAwB,MAAM,CAAC;AAE5C,yEAAyE;AACzE,MAAM,WAAW,gBAAgB;IAC/B,mEAAmE;IACnE,UAAU,EAAE,OAAO,CAAC;IACpB,0DAA0D;IAC1D,cAAc,EAAE,MAAM,GAAG,IAAI,CAAC;IAC9B,2DAA2D;IAC3D,eAAe,EAAE,MAAM,GAAG,IAAI,CAAC;IAC/B;;;OAGG;IACH,UAAU,EAAE,MAAM,GAAG,IAAI,CAAC;IAC1B,uEAAuE;IACvE,IAAI,EAAE,OAAO,CAAC;CACf;AAaD;;;;GAIG;AACH,wBAAgB,mBAAmB,CACjC,UAAU,EAAE,SAAS,GAAG,IAAI,EAC5B,WAAW,EAAE,SAAS,GAAG,IAAI,EAC7B,MAAM,GAAE,MAAiC,GACxC,gBAAgB,CAyBlB;AAED;;;;GAIG;AACH,wBAAgB,wBAAwB,CACtC,MAAM,EAAE,MAAM,EACd,KAAK,EAAE,gBAAgB,GACtB,MAAM,GAAG,IAAI,CAUf"}

package/dist/src/yaml/steps/fidelity-aspect-guard.js

@@ -1,72 +0,0 @@
-/**
- * Fidelity aspect-ratio guard.
- *
- * One named composable per state is the authoring norm; the failure this
- * catches is the opposite — several states stacked into one composable, which
- * renders far taller (or wider) than the single-state reference it is paired
- * against. That shows up as a sharp divergence between the rendered and
- * reference aspect ratios, well before a human reads the diff.
- *
- * The guard is a pure comparison over the dimensions the render already
- * reports (`rendered_px`, `reference_px`). It emits a WARNING when the
- * divergence exceeds a documented fold factor — it never fails the render, and
- * it stays silent when there is no reference to compare against.
- */
-/**
- * Fold factor beyond which a rendered/reference aspect-ratio divergence is
- * worth a warning. A faithful single-state wrapper sits near 1.0; trim and
- * reference alignment nudge it a few percent; a re-stacked 2-up wrapper roughly
- * doubles one dimension and lands near 2.0. 1.5 catches the stack while
- * tolerating the wobble.
- */
-export const ASPECT_RATIO_WARN_FACTOR = 1.5;
-function isPositiveSize(size) {
-    return (Array.isArray(size) &&
-        size.length === 2 &&
-        Number.isFinite(size[0]) &&
-        Number.isFinite(size[1]) &&
-        size[0] > 0 &&
-        size[1] > 0);
-}
-/**
- * Compares a rendered size against its reference size. Returns a
- * non-warning, non-comparable result when either size is missing or
- * non-positive — the guard only speaks when it has two real frames to compare.
- */
-export function evaluateAspectRatio(renderedPx, referencePx, factor = ASPECT_RATIO_WARN_FACTOR) {
-    if (!isPositiveSize(renderedPx) || !isPositiveSize(referencePx)) {
-        return {
-            comparable: false,
-            renderedAspect: null,
-            referenceAspect: null,
-            divergence: null,
-            warn: false,
-        };
-    }
-    const renderedAspect = renderedPx[0] / renderedPx[1];
-    const referenceAspect = referencePx[0] / referencePx[1];
-    const divergence = Math.max(renderedAspect / referenceAspect, referenceAspect / renderedAspect);
-    return {
-        comparable: true,
-        renderedAspect,
-        referenceAspect,
-        divergence,
-        warn: divergence > factor,
-    };
-}
-/**
- * Human/agent-readable warning line for a divergent screen, or null when the
- * screen does not warrant one. The caller decides where to surface it (preview
- * result, preflight output) — it is advisory, never a failure.
- */
-export function formatAspectRatioWarning(screen, check) {
-    if (!check.warn || check.divergence === null)
-        return null;
-    const r = check.renderedAspect?.toFixed(2);
-    const ref = check.referenceAspect?.toFixed(2);
-    return (`Screen "${screen}" renders at aspect ratio ${r}:1 but its reference is ` +
-        `${ref}:1 (${check.divergence.toFixed(1)}× divergence). This often means ` +
-        `multiple states were stacked into one composable — author one named ` +
-        `composable per state instead.`);
-}
-//# sourceMappingURL=fidelity-aspect-guard.js.map

package/dist/src/yaml/steps/fidelity-aspect-guard.test.d.ts

@@ -1,11 +0,0 @@
-/**
- * Unit tests for the fidelity aspect-ratio guard.
- *
- * A wrapper that stacks several states into one composable renders far taller
- * (or wider) than its single-state reference, so its aspect ratio diverges
- * sharply from the reference's. The guard is the early warning for that
- * re-stacking: it compares the rendered vs reference aspect ratios and flags a
- * divergence beyond a documented fold factor — a WARNING, never a failure.
- */
-export {};
-//# sourceMappingURL=fidelity-aspect-guard.test.d.ts.map

package/dist/src/yaml/steps/fidelity-aspect-guard.test.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"fidelity-aspect-guard.test.d.ts","sourceRoot":"","sources":["../../../../src/yaml/steps/fidelity-aspect-guard.test.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG"}

package/dist/src/yaml/steps/fidelity-aspect-guard.test.js

@@ -1,50 +0,0 @@
-/**
- * Unit tests for the fidelity aspect-ratio guard.
- *
- * A wrapper that stacks several states into one composable renders far taller
- * (or wider) than its single-state reference, so its aspect ratio diverges
- * sharply from the reference's. The guard is the early warning for that
- * re-stacking: it compares the rendered vs reference aspect ratios and flags a
- * divergence beyond a documented fold factor — a WARNING, never a failure.
- */
-import { describe, test, expect } from '@jest/globals';
-import { evaluateAspectRatio, ASPECT_RATIO_WARN_FACTOR, } from './fidelity-aspect-guard.js';
-describe('evaluateAspectRatio', () => {
-    test('does not warn when rendered and reference aspect ratios match', () => {
-        // A faithful single-state banner: same proportions as its reference.
-        const check = evaluateAspectRatio([720, 1280], [360, 640]);
-        expect(check.comparable).toBe(true);
-        expect(check.warn).toBe(false);
-        expect(check.divergence).toBeCloseTo(1, 5);
-    });
-    test('warns when a stacked render is far off the reference aspect ratio', () => {
-        // The canonical miss: two banner states stacked in one Column render at
-        // ~2.2:1, judged against a single-state ~4.76:1 reference.
-        const rendered = [880, 400]; // 2.2:1
-        const reference = [952, 200]; // 4.76:1
-        const check = evaluateAspectRatio(rendered, reference);
-        expect(check.comparable).toBe(true);
-        expect(check.warn).toBe(true);
-        expect(check.divergence).toBeCloseTo(4.76 / 2.2, 1);
-    });
-    test('tolerates a small alignment/trim wobble within the fold factor', () => {
-        // Trim + reference alignment can nudge dimensions a few percent; that must
-        // not trip the warning.
-        const check = evaluateAspectRatio([726, 1280], [360, 640]);
-        expect(check.warn).toBe(false);
-    });
-    test('is not comparable when there is no reference', () => {
-        const check = evaluateAspectRatio([720, 1280], null);
-        expect(check.comparable).toBe(false);
-        expect(check.warn).toBe(false);
-    });
-    test('is not comparable when a dimension is zero or negative', () => {
-        expect(evaluateAspectRatio([720, 0], [360, 640]).comparable).toBe(false);
-        expect(evaluateAspectRatio([720, 1280], [0, 640]).comparable).toBe(false);
-    });
-    test('exposes a sane default fold factor', () => {
-        expect(ASPECT_RATIO_WARN_FACTOR).toBeGreaterThan(1);
-        expect(ASPECT_RATIO_WARN_FACTOR).toBeLessThan(2);
-    });
-});
-//# sourceMappingURL=fidelity-aspect-guard.test.js.map

package/dist/src/yaml/steps/fidelity-reference-provenance.d.ts

@@ -1,87 +0,0 @@
-/**
- * Reference-provenance assessment.
- *
- * A UI-fidelity reference is a PNG the gate cannot read, so reference validity
- * is asserted at export time as provenance metadata (`figmaNode`, `locale`,
- * `resolved`, `exportedAt`) and the gate checks that METADATA — never the
- * pixels, never via OCR.
- *
- * The assessment splits into two severities:
- *
- *  - FATAL faults → status `unverifiable` for the screen. A reference that is
- *    absent has nothing to judge against (`REFERENCE_ABSENT`); a screen with no
- *    provenance while the run declares a render locale keeps the legacy
- *    `NO_PROVENANCE` verdict (verifiable is earned only through the full
- *    export path, and it kills the ad-hoc-Figma-fetch root cause).
- *  - COPY-CHANNEL downgrades → the screen still renders and is judged on
- *    geometry, colors, typeface, spans, and lines; only copy comparisons are
- *    skipped, reported as a structured `copy_unverifiable` advisory naming the
- *    reason. Placeholder copy (`resolved == false`) and locale mismatches are
- *    normal customer reality — dynamic content is designed as placeholders —
- *    so the product adapts instead of refusing the screen or telling the
- *    customer to re-export.
- *
- * The check arms whenever per-screen provenance rides in params; a declared
- * render locale is only required for the locale comparison itself. Screens
- * with neither provenance nor a declared locale are unarmed and keep the
- * caller's legacy behaviour.
- *
- * Content differences (copy wording, geometry) are deliberately NOT evaluated
- * here — those are soft, judged findings that legitimately drift between
- * reference-export and gate-run.
- *
- * This module is the authoritative spec for the check. The Android render
- * runtime inlines an equivalent JS implementation (it ships as a self-contained
- * script string and cannot import this module); the render-step integration
- * tests exercise that inlined copy end-to-end against the same fixtures, so the
- * two cannot silently drift.
- */
-/** Export-time provenance as it travels in the run-input sidecar. */
-export interface ReferenceProvenanceMeta {
-    figmaNode?: string;
-    locale?: string;
-    resolved?: boolean;
-    exportedAt?: string;
-}
-/** A reason a reference cannot be honestly judged at all. */
-export interface ProvenanceFault {
-    /** Stable machine code (NO_PROVENANCE / REFERENCE_ABSENT). */
-    code: string;
-    /** Human/agent-readable reason, naming the screen. */
-    message: string;
-}
-/** Advisory code for a downgraded copy channel. */
-export declare const COPY_UNVERIFIABLE_CODE = "copy_unverifiable";
-/**
- * A copy-channel downgrade: the screen is judged normally except that copy
- * comparisons are unverifiable for the named reason.
- */
-export interface CopyChannelAdvisory {
-    code: typeof COPY_UNVERIFIABLE_CODE;
-    reason: 'unresolved_placeholders' | 'locale_mismatch';
-    /** Human/agent-readable reason, naming the screen. */
-    message: string;
-}
-/** The outcome of assessing one screen's reference provenance. */
-export interface ProvenanceAssessment {
-    /** Fatal: the screen cannot be judged (status `unverifiable`), or null. */
-    fault: ProvenanceFault | null;
-    /** Copy-channel downgrade riding in the per-screen result, or null. */
-    copyAdvisory: CopyChannelAdvisory | null;
-}
-/** The per-state status string written to protocol-result.json. */
-export declare const UNVERIFIABLE_STATUS = "unverifiable";
-/**
- * Whether provenance is "present" for arming purposes. A partial object (e.g.
- * a hand-dropped `{ figmaNode }`) is treated as no provenance — verifiable is
- * earned only through the full export path.
- */
-export declare function hasReferenceProvenance(p: ReferenceProvenanceMeta | null | undefined): p is ReferenceProvenanceMeta;
-/**
- * Assesses one screen's reference. Returns a fatal fault (screen
- * `unverifiable`), a copy-channel advisory (screen judged, copy skipped), or
- * neither. Never both: an absent reference wins over a downgrade because there
- * is nothing to judge against.
- */
-export declare function assessReferenceProvenance(screen: string, provenance: ReferenceProvenanceMeta | null | undefined, renderLocale: string | null, referenceExists: boolean): ProvenanceAssessment;
-//# sourceMappingURL=fidelity-reference-provenance.d.ts.map

package/dist/src/yaml/steps/fidelity-reference-provenance.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"fidelity-reference-provenance.d.ts","sourceRoot":"","sources":["../../../../src/yaml/steps/fidelity-reference-provenance.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAqCG;AAEH,qEAAqE;AACrE,MAAM,WAAW,uBAAuB;IACtC,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB,UAAU,CAAC,EAAE,MAAM,CAAC;CACrB;AAED,6DAA6D;AAC7D,MAAM,WAAW,eAAe;IAC9B,8DAA8D;IAC9D,IAAI,EAAE,MAAM,CAAC;IACb,sDAAsD;IACtD,OAAO,EAAE,MAAM,CAAC;CACjB;AAED,mDAAmD;AACnD,eAAO,MAAM,sBAAsB,sBAAsB,CAAC;AAE1D;;;GAGG;AACH,MAAM,WAAW,mBAAmB;IAClC,IAAI,EAAE,OAAO,sBAAsB,CAAC;IACpC,MAAM,EAAE,yBAAyB,GAAG,iBAAiB,CAAC;IACtD,sDAAsD;IACtD,OAAO,EAAE,MAAM,CAAC;CACjB;AAED,kEAAkE;AAClE,MAAM,WAAW,oBAAoB;IACnC,2EAA2E;IAC3E,KAAK,EAAE,eAAe,GAAG,IAAI,CAAC;IAC9B,uEAAuE;IACvE,YAAY,EAAE,mBAAmB,GAAG,IAAI,CAAC;CAC1C;AAED,mEAAmE;AACnE,eAAO,MAAM,mBAAmB,iBAAiB,CAAC;AAElD;;;;GAIG;AACH,wBAAgB,sBAAsB,CACpC,CAAC,EAAE,uBAAuB,GAAG,IAAI,GAAG,SAAS,GAC5C,CAAC,IAAI,uBAAuB,CAO9B;AAED;;;;;GAKG;AACH,wBAAgB,yBAAyB,CACvC,MAAM,EAAE,MAAM,EACd,UAAU,EAAE,uBAAuB,GAAG,IAAI,GAAG,SAAS,EACtD,YAAY,EAAE,MAAM,GAAG,IAAI,EAC3B,eAAe,EAAE,OAAO,GACvB,oBAAoB,CAqDtB"}

package/dist/src/yaml/steps/fidelity-reference-provenance.js

@@ -1,111 +0,0 @@
-/**
- * Reference-provenance assessment.
- *
- * A UI-fidelity reference is a PNG the gate cannot read, so reference validity
- * is asserted at export time as provenance metadata (`figmaNode`, `locale`,
- * `resolved`, `exportedAt`) and the gate checks that METADATA — never the
- * pixels, never via OCR.
- *
- * The assessment splits into two severities:
- *
- *  - FATAL faults → status `unverifiable` for the screen. A reference that is
- *    absent has nothing to judge against (`REFERENCE_ABSENT`); a screen with no
- *    provenance while the run declares a render locale keeps the legacy
- *    `NO_PROVENANCE` verdict (verifiable is earned only through the full
- *    export path, and it kills the ad-hoc-Figma-fetch root cause).
- *  - COPY-CHANNEL downgrades → the screen still renders and is judged on
- *    geometry, colors, typeface, spans, and lines; only copy comparisons are
- *    skipped, reported as a structured `copy_unverifiable` advisory naming the
- *    reason. Placeholder copy (`resolved == false`) and locale mismatches are
- *    normal customer reality — dynamic content is designed as placeholders —
- *    so the product adapts instead of refusing the screen or telling the
- *    customer to re-export.
- *
- * The check arms whenever per-screen provenance rides in params; a declared
- * render locale is only required for the locale comparison itself. Screens
- * with neither provenance nor a declared locale are unarmed and keep the
- * caller's legacy behaviour.
- *
- * Content differences (copy wording, geometry) are deliberately NOT evaluated
- * here — those are soft, judged findings that legitimately drift between
- * reference-export and gate-run.
- *
- * This module is the authoritative spec for the check. The Android render
- * runtime inlines an equivalent JS implementation (it ships as a self-contained
- * script string and cannot import this module); the render-step integration
- * tests exercise that inlined copy end-to-end against the same fixtures, so the
- * two cannot silently drift.
- */
-/** Advisory code for a downgraded copy channel. */
-export const COPY_UNVERIFIABLE_CODE = 'copy_unverifiable';
-/** The per-state status string written to protocol-result.json. */
-export const UNVERIFIABLE_STATUS = 'unverifiable';
-/**
- * Whether provenance is "present" for arming purposes. A partial object (e.g.
- * a hand-dropped `{ figmaNode }`) is treated as no provenance — verifiable is
- * earned only through the full export path.
- */
-export function hasReferenceProvenance(p) {
-    return (p != null &&
-        typeof p === 'object' &&
-        typeof p.locale === 'string' &&
-        typeof p.resolved === 'boolean');
-}
-/**
- * Assesses one screen's reference. Returns a fatal fault (screen
- * `unverifiable`), a copy-channel advisory (screen judged, copy skipped), or
- * neither. Never both: an absent reference wins over a downgrade because there
- * is nothing to judge against.
- */
-export function assessReferenceProvenance(screen, provenance, renderLocale, referenceExists) {
-    if (!hasReferenceProvenance(provenance)) {
-        if (renderLocale !== null) {
-            return {
-                fault: {
-                    code: 'NO_PROVENANCE',
-                    message: `reference for ${screen} has no export provenance; a reference is ` +
-                        `verifiable only when exported through the deterministic path`,
-                },
-                copyAdvisory: null,
-            };
-        }
-        // Unarmed: no provenance rode in and no locale was declared — the caller
-        // keeps its legacy behaviour (including its own reference-existence check).
-        return { fault: null, copyAdvisory: null };
-    }
-    if (!referenceExists) {
-        return {
-            fault: {
-                code: 'REFERENCE_ABSENT',
-                message: `reference image for ${screen} is absent`,
-            },
-            copyAdvisory: null,
-        };
-    }
-    if (provenance.resolved === false) {
-        return {
-            fault: null,
-            copyAdvisory: {
-                code: COPY_UNVERIFIABLE_CODE,
-                reason: 'unresolved_placeholders',
-                message: `reference for ${screen} carries unresolved copy placeholders ` +
-                    `(resolved=false); copy comparisons are skipped — geometry, color, ` +
-                    `typeface, span, and line judging still hold`,
-            },
-        };
-    }
-    if (renderLocale !== null && provenance.locale !== renderLocale) {
-        return {
-            fault: null,
-            copyAdvisory: {
-                code: COPY_UNVERIFIABLE_CODE,
-                reason: 'locale_mismatch',
-                message: `reference for ${screen} is locale "${provenance.locale}" but the ` +
-                    `render locale is "${renderLocale}"; copy comparisons are skipped — ` +
-                    `geometry, color, typeface, span, and line judging still hold`,
-            },
-        };
-    }
-    return { fault: null, copyAdvisory: null };
-}
-//# sourceMappingURL=fidelity-reference-provenance.js.map

package/dist/src/yaml/steps/fidelity-reference-provenance.test.d.ts

@@ -1,22 +0,0 @@
-/**
- * Unit tests for the reference-provenance assessment.
- *
- * A UI-fidelity reference is a PNG; the gate cannot read its text. So validity
- * is asserted at export time as provenance metadata, and the gate checks the
- * METADATA, never the pixels (no OCR).
- *
- * The assessment splits into two severities:
- *  - FATAL faults (reference absent; no provenance while a render locale is
- *    declared): the screen cannot be judged at all → status `unverifiable`.
- *  - COPY-CHANNEL downgrades (unresolved placeholders, locale mismatch): the
- *    screen renders and is judged on every non-copy channel; copy comparisons
- *    are skipped and reported as a `copy_unverifiable` advisory. Placeholder
- *    copy in a design is normal customer reality — the product adapts, the
- *    customer is never told to re-export.
- *
- * The check arms whenever provenance is present; a declared render locale is
- * only required for the locale comparison itself (and preserves the legacy
- * NO_PROVENANCE behaviour for unprovenanced screens).
- */
-export {};
-//# sourceMappingURL=fidelity-reference-provenance.test.d.ts.map

package/dist/src/yaml/steps/fidelity-reference-provenance.test.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"fidelity-reference-provenance.test.d.ts","sourceRoot":"","sources":["../../../../src/yaml/steps/fidelity-reference-provenance.test.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;GAmBG"}

package/dist/src/yaml/steps/fidelity-reference-provenance.test.js

@@ -1,118 +0,0 @@
-/**
- * Unit tests for the reference-provenance assessment.
- *
- * A UI-fidelity reference is a PNG; the gate cannot read its text. So validity
- * is asserted at export time as provenance metadata, and the gate checks the
- * METADATA, never the pixels (no OCR).
- *
- * The assessment splits into two severities:
- *  - FATAL faults (reference absent; no provenance while a render locale is
- *    declared): the screen cannot be judged at all → status `unverifiable`.
- *  - COPY-CHANNEL downgrades (unresolved placeholders, locale mismatch): the
- *    screen renders and is judged on every non-copy channel; copy comparisons
- *    are skipped and reported as a `copy_unverifiable` advisory. Placeholder
- *    copy in a design is normal customer reality — the product adapts, the
- *    customer is never told to re-export.
- *
- * The check arms whenever provenance is present; a declared render locale is
- * only required for the locale comparison itself (and preserves the legacy
- * NO_PROVENANCE behaviour for unprovenanced screens).
- */
-import { describe, test, expect } from '@jest/globals';
-import { assessReferenceProvenance, hasReferenceProvenance, UNVERIFIABLE_STATUS, COPY_UNVERIFIABLE_CODE, } from './fidelity-reference-provenance.js';
-const GOOD = {
-    figmaNode: '12:345',
-    locale: 'en',
-    resolved: true,
-    exportedAt: '2026-06-18T10:00:00Z',
-};
-describe('assessReferenceProvenance', () => {
-    test('a present, provenanced, resolved, locale-matching reference is clean', () => {
-        expect(assessReferenceProvenance('Guest', GOOD, 'en', true)).toEqual({
-            fault: null,
-            copyAdvisory: null,
-        });
-    });
-    test('provenance present without a declared render locale is clean too', () => {
-        expect(assessReferenceProvenance('Guest', GOOD, null, true)).toEqual({
-            fault: null,
-            copyAdvisory: null,
-        });
-    });
-    test('an absent reference with provenance is FATAL (REFERENCE_ABSENT), locale or not', () => {
-        expect(assessReferenceProvenance('Guest', GOOD, 'en', false).fault?.code).toBe('REFERENCE_ABSENT');
-        expect(assessReferenceProvenance('Guest', GOOD, null, false).fault?.code).toBe('REFERENCE_ABSENT');
-    });
-    test('unresolved placeholders downgrade the copy channel — never the screen', () => {
-        const assessment = assessReferenceProvenance('Guest', { ...GOOD, resolved: false }, 'en', true);
-        expect(assessment.fault).toBeNull();
-        expect(assessment.copyAdvisory?.code).toBe(COPY_UNVERIFIABLE_CODE);
-        expect(assessment.copyAdvisory?.reason).toBe('unresolved_placeholders');
-    });
-    test('unresolved placeholders downgrade identically without a render locale', () => {
-        // Live evidence: the same resolved:false reference must earn the same
-        // verdict whether or not the run declared render_locale.
-        const assessment = assessReferenceProvenance('Guest', { ...GOOD, resolved: false }, null, true);
-        expect(assessment.fault).toBeNull();
-        expect(assessment.copyAdvisory?.reason).toBe('unresolved_placeholders');
-    });
-    test('a wrong-locale reference downgrades the copy channel (LOCALE reason)', () => {
-        // Italian reference vs an English render.
-        const assessment = assessReferenceProvenance('Guest', { ...GOOD, locale: 'it' }, 'en', true);
-        expect(assessment.fault).toBeNull();
-        expect(assessment.copyAdvisory?.code).toBe(COPY_UNVERIFIABLE_CODE);
-        expect(assessment.copyAdvisory?.reason).toBe('locale_mismatch');
-    });
-    test('locale comparison requires a declared render locale — its absence skips only that', () => {
-        const assessment = assessReferenceProvenance('Guest', { ...GOOD, locale: 'it' }, null, true);
-        expect(assessment).toEqual({ fault: null, copyAdvisory: null });
-    });
-    test('an absent reference wins over a copy downgrade (nothing to judge against)', () => {
-        const assessment = assessReferenceProvenance('Guest', { ...GOOD, resolved: false }, 'en', false);
-        expect(assessment.fault?.code).toBe('REFERENCE_ABSENT');
-        expect(assessment.copyAdvisory).toBeNull();
-    });
-    test('no provenance with a declared render locale stays FATAL (NO_PROVENANCE, legacy arming)', () => {
-        expect(assessReferenceProvenance('Guest', null, 'en', true).fault?.code).toBe('NO_PROVENANCE');
-        expect(assessReferenceProvenance('Guest', undefined, 'en', true).fault?.code).toBe('NO_PROVENANCE');
-    });
-    test('incomplete provenance (missing locale/resolved) is treated as no provenance', () => {
-        expect(assessReferenceProvenance('Guest', { figmaNode: 'x', exportedAt: 'y' }, 'en', true).fault
-            ?.code).toBe('NO_PROVENANCE');
-    });
-    test('no provenance and no render locale is unarmed — the caller keeps legacy behaviour', () => {
-        expect(assessReferenceProvenance('Guest', null, null, false)).toEqual({
-            fault: null,
-            copyAdvisory: null,
-        });
-        expect(assessReferenceProvenance('Guest', null, null, true)).toEqual({
-            fault: null,
-            copyAdvisory: null,
-        });
-    });
-    test('faults and advisories carry the screen name and a human reason', () => {
-        const fatal = assessReferenceProvenance('LoggedIn', GOOD, 'en', false);
-        expect(fatal.fault?.message).toContain('LoggedIn');
-        const downgraded = assessReferenceProvenance('LoggedIn', { ...GOOD, resolved: false }, 'en', true);
-        expect(downgraded.copyAdvisory?.message).toContain('LoggedIn');
-        expect(downgraded.copyAdvisory.message.length).toBeGreaterThan(10);
-    });
-    test('the downgrade message never tells the customer to fix their design', () => {
-        const assessment = assessReferenceProvenance('Guest', { ...GOOD, resolved: false }, 'en', true);
-        expect(assessment.copyAdvisory?.message.toLowerCase()).not.toContain('export it');
-    });
-});
-describe('hasReferenceProvenance', () => {
-    test('full export-path provenance is present; partial or missing is not', () => {
-        expect(hasReferenceProvenance(GOOD)).toBe(true);
-        expect(hasReferenceProvenance(null)).toBe(false);
-        expect(hasReferenceProvenance(undefined)).toBe(false);
-        expect(hasReferenceProvenance({ figmaNode: 'x' })).toBe(false);
-    });
-});
-describe('status strings', () => {
-    test('exposes the unverifiable status string the result document uses', () => {
-        expect(UNVERIFIABLE_STATUS).toBe('unverifiable');
-    });
-});
-//# sourceMappingURL=fidelity-reference-provenance.test.js.map