@invarn/cibuild 2.9.4 → 2.9.7

package/dist/src/yaml/fidelity-input-digest.d.ts

@@ -1,37 +0,0 @@
-export interface PackageFile {
-    /** POSIX, package-relative path. Part of the digest so a rename is a change. */
-    path: string;
-    /** File contents. */
-    bytes: Buffer;
-}
-/**
- * Compute the input digest for one render package: its source files plus the
- * reference image the screen is judged against. Files are folded in sorted by
- * path so iteration order can't affect the result; each is folded in as its git
- * blob id (see the module header) so the digest is reproducible from a Git Trees
- * listing with no blob content. The path is length-prefixed and the blob id is
- * fixed-width, so boundaries are unambiguous.
- */
-export declare function sourceDigest(packageFiles: PackageFile[], referenceBytes: Buffer | null): string;
-/**
- * True when a render package is self-contained — no Gradle script reaches
- * outside the package root. Render packages are hermetic by construction; this
- * guard fails a non-hermetic package OUT of the cacheable set (its digest is not
- * emitted / not trusted for skip) so a change in an external module it depends
- * on can never replay a stale verdict. Pure: a function of the package files
- * only, so a dispatch-time caller can apply the identical check.
- */
-export declare function isHermeticPackage(packageFiles: PackageFile[]): boolean;
-/**
- * Runtime twin of {@link sourceDigest}, spliced into the self-contained render
- * script that runs on the macOS runner (which cannot import this module). It
- * walks the built package directory, reads the paired reference, and computes
- * the identical digest — a parity test pins it to `sourceDigest` so the twin
- * cannot drift.
- *
- * Exposes `computeSourceDigest(projectRoot, referencePath)`. Build outputs and
- * VCS/tooling dirs are excluded so they never perturb the content key. Reads
- * are best-effort: an unreadable reference folds in as "absent", never throws.
- */
-export declare const RENDER_SCRIPT_SOURCE_DIGEST_STAGE: string;
-//# sourceMappingURL=fidelity-input-digest.d.ts.map

package/dist/src/yaml/fidelity-input-digest.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"fidelity-input-digest.d.ts","sourceRoot":"","sources":["../../../src/yaml/fidelity-input-digest.ts"],"names":[],"mappings":"AAiCA,MAAM,WAAW,WAAW;IAC1B,gFAAgF;IAChF,IAAI,EAAE,MAAM,CAAC;IACb,qBAAqB;IACrB,KAAK,EAAE,MAAM,CAAC;CACf;AAuBD;;;;;;;GAOG;AACH,wBAAgB,YAAY,CAC1B,YAAY,EAAE,WAAW,EAAE,EAC3B,cAAc,EAAE,MAAM,GAAG,IAAI,GAC5B,MAAM,CAoBR;AAwBD;;;;;;;GAOG;AACH,wBAAgB,iBAAiB,CAAC,YAAY,EAAE,WAAW,EAAE,GAAG,OAAO,CAOtE;AAED;;;;;;;;;;GAUG;AACH,eAAO,MAAM,iCAAiC,EAAE,MAiF/C,CAAC"}

package/dist/src/yaml/fidelity-input-digest.js

@@ -1,208 +0,0 @@
-/**
- * Deterministic per-package input digest.
- *
- * A content key over a render package's inputs — the committed wrapper source
- * files plus the paired reference image — so a consumer can tell when a render
- * would be byte-identical to one already produced and skip re-rendering. Pure:
- * a function of the input bytes only, never of absolute paths, timestamps, or
- * commit ids, so the same inputs yield the same digest on any machine or
- * branch.
- *
- * Scope: package-local inputs. Render packages are self-contained by
- * construction — a parameterless wrapper that reproduces one screen from
- * hardcoded fixtures, shipped with every dependency version pinned inline and
- * its own assets vendored — so the package IS its own dependency closure and a
- * package-local content key already invalidates on anything that can shift the
- * render. (A package that escapes its own root — an `includeBuild`, an external
- * `project(":…")` dependency, or a shared version catalog — would break that
- * property; such a package is not safely cacheable and is caught by a separate
- * hermeticity guard rather than folded into this digest.)
- *
- * Digest basis: each file is folded in as its **git blob id**
- * (`sha1("blob " + byteLength + "\0" + content)`) rather than its raw bytes.
- * That is the exact id the GitHub Git Trees API returns for a committed file, so
- * a caller holding only a tree listing — a webhook dispatch with no checkout —
- * can reproduce this digest from `(path, blobSha)` pairs WITHOUT fetching any
- * blob content. The framing is: sha256 over, for each file sorted by path,
- * `len(path) ‖ path ‖ blobSha(content)`, then the reference folded last as
- * `blobSha(reference)` (or a presence-distinct `len(0xffffffff)` marker when
- * there is no reference). `blobSha` is a fixed 20 bytes, so file boundaries stay
- * unambiguous with only the path length-prefixed.
- */
-import { createHash } from 'crypto';
-/** 4-byte big-endian length prefix, so concatenated fields can't alias
- *  (`["ab","c"]` must not hash equal to `["a","bc"]`). */
-function len(n) {
-    const b = Buffer.allocUnsafe(4);
-    b.writeUInt32BE(n >>> 0, 0);
-    return b;
-}
-/**
- * Git blob object id for a file's content: `sha1("blob " + len + "\0" + bytes)`.
- * The identical id the GitHub Git Trees API returns for the committed blob, so a
- * dispatch-time caller can read it from a tree listing instead of hashing bytes
- * it never fetched. Returned as 20 raw bytes (folded straight into the digest).
- */
-function gitBlobSha(bytes) {
-    const h = createHash('sha1');
-    h.update(`blob ${bytes.length}\0`);
-    h.update(bytes);
-    return h.digest();
-}
-/**
- * Compute the input digest for one render package: its source files plus the
- * reference image the screen is judged against. Files are folded in sorted by
- * path so iteration order can't affect the result; each is folded in as its git
- * blob id (see the module header) so the digest is reproducible from a Git Trees
- * listing with no blob content. The path is length-prefixed and the blob id is
- * fixed-width, so boundaries are unambiguous.
- */
-export function sourceDigest(packageFiles, referenceBytes) {
-    const sorted = [...packageFiles].sort((a, b) => a.path < b.path ? -1 : a.path > b.path ? 1 : 0);
-    const h = createHash('sha256');
-    for (const file of sorted) {
-        const pathBytes = Buffer.from(file.path, 'utf8');
-        h.update(len(pathBytes.length));
-        h.update(pathBytes);
-        h.update(gitBlobSha(file.bytes));
-    }
-    // Reference is folded in as its blob id, with a presence-distinct marker so
-    // "no reference" differs from "empty reference".
-    if (referenceBytes === null) {
-        h.update(len(0xffffffff));
-    }
-    else {
-        h.update(gitBlobSha(referenceBytes));
-    }
-    return h.digest('hex');
-}
-/**
- * A Gradle build script — the only files that can reach outside the package
- * root (source files and assets can mention `..` in prose without affecting the
- * build graph).
- */
-function isGradleScript(path) {
-    return path.endsWith('.gradle') || path.endsWith('.gradle.kts');
-}
-/**
- * Tokens by which a Gradle script reaches outside its own package root and so
- * breaks the "package is its own dependency closure" invariant this digest
- * relies on:
- *   - `includeBuild` — a composite/included build (another whole build).
- *   - `projectDir`   — a module relocated to a directory outside the layout.
- *   - `../`          — any parent-path reference (external file, script, or
- *                      version catalog).
- * Biased toward over-detection: a false positive only forces a re-render (safe),
- * whereas a miss would let a shared external change replay a stale verdict.
- */
-const GRADLE_ESCAPE = /includeBuild|projectDir|\.\.\//;
-/**
- * True when a render package is self-contained — no Gradle script reaches
- * outside the package root. Render packages are hermetic by construction; this
- * guard fails a non-hermetic package OUT of the cacheable set (its digest is not
- * emitted / not trusted for skip) so a change in an external module it depends
- * on can never replay a stale verdict. Pure: a function of the package files
- * only, so a dispatch-time caller can apply the identical check.
- */
-export function isHermeticPackage(packageFiles) {
-    for (const file of packageFiles) {
-        if (isGradleScript(file.path) && GRADLE_ESCAPE.test(file.bytes.toString('utf8'))) {
-            return false;
-        }
-    }
-    return true;
-}
-/**
- * Runtime twin of {@link sourceDigest}, spliced into the self-contained render
- * script that runs on the macOS runner (which cannot import this module). It
- * walks the built package directory, reads the paired reference, and computes
- * the identical digest — a parity test pins it to `sourceDigest` so the twin
- * cannot drift.
- *
- * Exposes `computeSourceDigest(projectRoot, referencePath)`. Build outputs and
- * VCS/tooling dirs are excluded so they never perturb the content key. Reads
- * are best-effort: an unreadable reference folds in as "absent", never throws.
- */
-export const RENDER_SCRIPT_SOURCE_DIGEST_STAGE = String.raw `
-// ---- source-digest stage: deterministic package input content key ----
-function __fidLen(n) {
-  var b = Buffer.allocUnsafe(4);
-  b.writeUInt32BE(n >>> 0, 0);
-  return b;
-}
-var __FID_SKIP_DIRS = { build: 1, '.gradle': 1, '.git': 1, '.idea': 1, 'node_modules': 1, DerivedData: 1 };
-function __fidCollectPackageFiles(root) {
-  var fs = require('fs');
-  var path = require('path');
-  var out = [];
-  function walk(dir, rel) {
-    var names;
-    try { names = fs.readdirSync(dir); } catch (e) { return; }
-    names.sort();
-    for (var i = 0; i < names.length; i++) {
-      var name = names[i];
-      var full = path.join(dir, name);
-      var relPath = rel ? rel + '/' + name : name;
-      var st;
-      try { st = fs.statSync(full); } catch (e) { continue; }
-      if (st.isDirectory()) {
-        if (__FID_SKIP_DIRS[name]) continue;
-        walk(full, relPath);
-      } else if (st.isFile()) {
-        out.push({ path: relPath, bytes: fs.readFileSync(full) });
-      }
-    }
-  }
-  walk(root, '');
-  return out;
-}
-function __fidBlobSha(bytes) {
-  var crypto = require('crypto');
-  var h = crypto.createHash('sha1');
-  h.update('blob ' + bytes.length + '\0');
-  h.update(bytes);
-  return h.digest();
-}
-function __fidSourceDigest(files, referenceBytes) {
-  var crypto = require('crypto');
-  var sorted = files.slice().sort(function (a, b) {
-    return a.path < b.path ? -1 : a.path > b.path ? 1 : 0;
-  });
-  var h = crypto.createHash('sha256');
-  for (var i = 0; i < sorted.length; i++) {
-    var pathBytes = Buffer.from(sorted[i].path, 'utf8');
-    h.update(__fidLen(pathBytes.length));
-    h.update(pathBytes);
-    h.update(__fidBlobSha(sorted[i].bytes));
-  }
-  if (referenceBytes === null || referenceBytes === undefined) {
-    h.update(__fidLen(0xffffffff));
-  } else {
-    h.update(__fidBlobSha(referenceBytes));
-  }
-  return h.digest('hex');
-}
-function computeSourceDigest(projectRoot, referencePath) {
-  var fs = require('fs');
-  var files = __fidCollectPackageFiles(projectRoot);
-  var ref = null;
-  try { if (referencePath) ref = fs.readFileSync(referencePath); } catch (e) { ref = null; }
-  return __fidSourceDigest(files, ref);
-}
-// Twin of isHermeticPackage: a package is cacheable only when no Gradle script
-// reaches outside its own root (includeBuild / projectDir / a parent path).
-var __FID_GRADLE_ESCAPE = /includeBuild|projectDir|\.\.\//;
-function __fidIsGradleScript(p) {
-  return p.slice(-7) === '.gradle' || p.slice(-11) === '.gradle.kts';
-}
-function __fidIsHermetic(files) {
-  for (var i = 0; i < files.length; i++) {
-    if (__fidIsGradleScript(files[i].path) &&
-        __FID_GRADLE_ESCAPE.test(files[i].bytes.toString('utf8'))) {
-      return false;
-    }
-  }
-  return true;
-}
-`;
-//# sourceMappingURL=fidelity-input-digest.js.map

package/dist/src/yaml/fidelity-input-digest.test.d.ts

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=fidelity-input-digest.test.d.ts.map

package/dist/src/yaml/fidelity-input-digest.test.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"fidelity-input-digest.test.d.ts","sourceRoot":"","sources":["../../../src/yaml/fidelity-input-digest.test.ts"],"names":[],"mappings":""}

package/dist/src/yaml/fidelity-input-digest.test.js

@@ -1,167 +0,0 @@
-/**
- * Unit tests for the deterministic per-package input digest.
- *
- * The digest is the content key the dashboard matches on to decide whether a
- * render would be identical to one it already has — so it must be a pure
- * function of the package's input bytes (wrapper source + reference), stable
- * across machines/branches, and never derived from paths-as-location, mtimes,
- * or commit ids.
- */
-import { describe, test, expect } from '@jest/globals';
-import { createHash } from 'crypto';
-import { createRequire } from 'module';
-import { sourceDigest, isHermeticPackage, RENDER_SCRIPT_SOURCE_DIGEST_STAGE, } from './fidelity-input-digest.js';
-function f(path, content) {
-    return { path, bytes: Buffer.from(content, 'utf8') };
-}
-/** Git blob object id: sha1('blob <len>\0<content>') — the SAME id the GitHub
- *  Git Trees API returns for a committed file. The digest is defined over these
- *  ids so a caller with only a tree listing (no blob content) can reproduce it. */
-function gitBlobSha(bytes) {
-    const h = createHash('sha1');
-    h.update(`blob ${bytes.length}\0`);
-    h.update(bytes);
-    return h.digest('hex');
-}
-/** 4-byte big-endian length prefix — mirrors the module-private `len`. */
-function len(n) {
-    const b = Buffer.allocUnsafe(4);
-    b.writeUInt32BE(n >>> 0, 0);
-    return b;
-}
-/** Extract the runner-side twin from the spliced stage source so a parity test
- *  can pin it to the pure function. `require` is injected because the stage
- *  runs in the runner's CJS scope, not this ESM test module. */
-const require = createRequire(import.meta.url);
-const twin = new Function('require', RENDER_SCRIPT_SOURCE_DIGEST_STAGE +
-    '\nreturn { __fidSourceDigest: __fidSourceDigest, __fidIsHermetic: __fidIsHermetic };')(require);
-describe('sourceDigest', () => {
-    test('is deterministic: identical inputs produce the same 64-hex digest', () => {
-        const files = [f('Proof.kt', 'fun Proof() {}'), f('build.gradle.kts', 'plugins {}')];
-        const ref = Buffer.from('reference-image-bytes');
-        const first = sourceDigest(files, ref);
-        expect(first).toMatch(/^[0-9a-f]{64}$/);
-        expect(sourceDigest(files, ref)).toBe(first);
-    });
-    test('changes when any package file byte changes', () => {
-        const ref = Buffer.from('ref');
-        const before = sourceDigest([f('Proof.kt', 'fun Proof() {}')], ref);
-        const after = sourceDigest([f('Proof.kt', 'fun Proof() { Box() }')], ref);
-        expect(after).not.toBe(before);
-    });
-    test('changes when only the reference image changes', () => {
-        const files = [f('Proof.kt', 'fun Proof() {}')];
-        const withA = sourceDigest(files, Buffer.from('reference-A'));
-        const withB = sourceDigest(files, Buffer.from('reference-B'));
-        expect(withB).not.toBe(withA);
-    });
-    test('is independent of file iteration order', () => {
-        const ref = Buffer.from('ref');
-        const a = f('a.kt', 'A');
-        const b = f('b.kt', 'B');
-        expect(sourceDigest([a, b], ref)).toBe(sourceDigest([b, a], ref));
-    });
-    test('is unambiguous across file boundaries (path/content cannot alias)', () => {
-        const ref = Buffer.from('ref');
-        // Same concatenated bytes, different split: must not collide.
-        const split = sourceDigest([f('ab', 'x'), f('', 'y')], ref);
-        const joined = sourceDigest([f('a', 'bxy')], ref);
-        expect(split).not.toBe(joined);
-    });
-    test('is reconstructible from git blob shas alone (dashboard tree-API parity)', () => {
-        // The dashboard computes this SAME digest at webhook time from a Git Trees
-        // API listing — which carries each committed file's blob sha but NOT its
-        // content. Pin the exact framing so that reconstruction (path + blob sha,
-        // no bytes) reproduces the digest byte-for-byte.
-        const files = [f('b.kt', 'B'), f('a.kt', 'A')];
-        const ref = Buffer.from('reference-image-bytes');
-        const sorted = [...files].sort((x, y) => (x.path < y.path ? -1 : x.path > y.path ? 1 : 0));
-        const h = createHash('sha256');
-        for (const file of sorted) {
-            const p = Buffer.from(file.path, 'utf8');
-            h.update(len(p.length));
-            h.update(p);
-            h.update(Buffer.from(gitBlobSha(file.bytes), 'hex'));
-        }
-        h.update(Buffer.from(gitBlobSha(ref), 'hex'));
-        expect(sourceDigest(files, ref)).toBe(h.digest('hex'));
-    });
-    test('matches the cross-consumer golden vector (pins the wire format)', () => {
-        // A fixed known-answer vector shared verbatim with the dashboard's
-        // dispatch-time digest, so the two implementations cannot drift apart
-        // silently. If this changes, the dashboard golden must change in lockstep.
-        const files = [f('a.kt', 'A'), f('proof/build.gradle.kts', 'plugins {}')];
-        expect(sourceDigest(files, Buffer.from('ref-bytes'))).toBe('7fc57f481eb011299d34824e0a506345d15e96946e345beac882f26adab47374');
-        expect(sourceDigest(files, null)).toBe('2596ecea7f591c23f9397707a92b008dabedbd1fd4acc0efb2440849e97ddd3c');
-    });
-    test('folds a null reference in with a presence-distinct marker (not a blob sha)', () => {
-        const files = [f('a.kt', 'A')];
-        const sorted = files;
-        const h = createHash('sha256');
-        for (const file of sorted) {
-            const p = Buffer.from(file.path, 'utf8');
-            h.update(len(p.length));
-            h.update(p);
-            h.update(Buffer.from(gitBlobSha(file.bytes), 'hex'));
-        }
-        h.update(len(0xffffffff));
-        expect(sourceDigest(files, null)).toBe(h.digest('hex'));
-    });
-});
-describe('isHermeticPackage', () => {
-    const hermetic = [
-        f('settings.gradle.kts', 'rootProject.name = "p"\ninclude(":proof")\n'),
-        f('build.gradle.kts', 'plugins { id("com.android.library") version "8.13.2" }'),
-        f('proof/build.gradle.kts', 'dependencies { implementation("androidx.compose.ui:ui") }'),
-        f('proof/src/main/kotlin/Proof.kt', 'fun Proof() {}'),
-    ];
-    test('accepts a self-contained package with everything pinned inline', () => {
-        expect(isHermeticPackage(hermetic)).toBe(true);
-    });
-    test('rejects a composite build (includeBuild reaches another build)', () => {
-        const files = [...hermetic, f('settings.gradle.kts', 'includeBuild("../design-system")')];
-        expect(isHermeticPackage(files)).toBe(false);
-    });
-    test('rejects a module relocated outside the root via projectDir', () => {
-        const files = [
-            f('settings.gradle.kts', 'include(":ds")\nproject(":ds").projectDir = file("../ds")'),
-        ];
-        expect(isHermeticPackage(files)).toBe(false);
-    });
-    test('rejects a parent-path escape (external file / version catalog)', () => {
-        const files = [
-            f('settings.gradle.kts', 'versionCatalogs { create("libs") { from(files("../gradle/libs.versions.toml")) } }'),
-        ];
-        expect(isHermeticPackage(files)).toBe(false);
-    });
-    test('ignores escape tokens outside Gradle scripts (only build scripts can escape)', () => {
-        // A source file or asset mentioning "../" is not a build-graph escape.
-        const files = [
-            f('settings.gradle.kts', 'include(":proof")'),
-            f('proof/src/main/kotlin/Doc.kt', '// see ../design-system for the original'),
-        ];
-        expect(isHermeticPackage(files)).toBe(true);
-    });
-});
-describe('runtime twin parity', () => {
-    const files = [f('Proof.kt', 'fun Proof() { Box() }'), f('build.gradle.kts', 'plugins {}')];
-    test('the spliced runner-side digest matches the pure sourceDigest (with reference)', () => {
-        const ref = Buffer.from('reference-image-bytes');
-        expect(twin.__fidSourceDigest(files, ref)).toBe(sourceDigest(files, ref));
-    });
-    test('the spliced runner-side digest matches the pure sourceDigest (no reference)', () => {
-        expect(twin.__fidSourceDigest(files, null)).toBe(sourceDigest(files, null));
-    });
-    test('the spliced runner-side hermeticity check matches isHermeticPackage', () => {
-        const hermetic = [
-            f('settings.gradle.kts', 'include(":proof")'),
-            f('proof/src/main/kotlin/Doc.kt', '// mentions ../elsewhere harmlessly'),
-        ];
-        const escaping = [f('settings.gradle', 'includeBuild("../other")')];
-        expect(twin.__fidIsHermetic(hermetic)).toBe(isHermeticPackage(hermetic));
-        expect(twin.__fidIsHermetic(escaping)).toBe(isHermeticPackage(escaping));
-        expect(twin.__fidIsHermetic(hermetic)).toBe(true);
-        expect(twin.__fidIsHermetic(escaping)).toBe(false);
-    });
-});
-//# sourceMappingURL=fidelity-input-digest.test.js.map

package/dist/src/yaml/fidelity-manifest.d.ts

@@ -1,126 +0,0 @@
-/**
- * Multi-state UI-fidelity manifest parser/validator.
- *
- * The manifest lives at the app-repo root as `.invarn/fidelity.yml` and is the
- * single seam the android-ui-fidelity skill and any orchestrator share. It
- * declares each **Surface** (one app screen) and that surface's first-class
- * **States** (guest vs logged-in; empty vs progress vs complete). Each State is
- * one named proof composable paired with one **Reference**, and the Reference
- * carries export-time **provenance** so the gate can assert validity by
- * metadata rather than by reading pixels.
- *
- * This module owns the schema (the TypeScript types below) and a validator that
- * rejects malformed entries with a clear, distinct message — the shared
- * contract the reference-provenance (UNVERIFIABLE) and baseline-filter slices
- * key on.
- */
-/**
- * Export-time provenance stamped onto a Reference. The gate checks this
- * metadata, never the PNG's pixels: a missing/placeholder/wrong-locale
- * reference is caught here instead of by OCR.
- */
-export interface ReferenceProvenance {
-    /** The Figma node the reference was exported from (e.g. "12:345"). */
-    figmaNode: string;
-    /** The locale the reference was exported in (must match the render locale). */
-    locale: string;
-    /** False when copy placeholders (`{date}`/`{amount}`) are still unfilled. */
-    resolved: boolean;
-    /** ISO-8601 export timestamp. */
-    exportedAt: string;
-}
-/** A single-state design image plus its provenance. */
-export interface StateReference {
-    /** Reference image path (repo-relative), or a Figma node URL. */
-    path: string;
-    /** Export-time provenance; absence makes the State UNVERIFIABLE. */
-    provenance: ReferenceProvenance;
-}
-/**
- * One allowlisted, product-owned divergence for a State. Keyed on
- * structured/normalized fields only; `actual` is the pinned render value, so a
- * changed value re-flags by construction.
- */
-export interface BaselineEntry {
-    /** Divergence category (e.g. "copy", "geometry") — drives equality. */
-    category: string;
-    /** Stable element id from layout.json. Unpinnable divergences aren't here. */
-    element: string;
-    /** The reference/design value. */
-    expected: string;
-    /** The pinned actual render value — required. */
-    actual: string;
-}
-/** One addressable visual State of a Surface. */
-export interface FidelityState {
-    /** State name (e.g. "Guest", "LoggedIn"); unique within the surface. */
-    name: string;
-    /** Named proof composable `<Surface><State>Proof`; 1:1 with a screens key. */
-    proof: string;
-    /** The single-state reference this State is paired against. */
-    reference: StateReference;
-    /** Per-state baseline of accepted divergences. */
-    accepted?: BaselineEntry[];
-}
-/** One app screen and its first-class States. One proof module per surface. */
-export interface FidelitySurface {
-    /** Surface name. */
-    name: string;
-    /** Render platform (e.g. "android"). */
-    platform: string;
-    /** Proof module path (one module per surface, N composables inside). */
-    module?: string;
-    /** The real source files this surface proves. */
-    source?: string[];
-    /** Globs whose changes imply a re-gate. */
-    touchedBy?: string[];
-    /** The surface's States. */
-    states: FidelityState[];
-}
-/** The parsed `.invarn/fidelity.yml` manifest. */
-export interface FidelityManifest {
-    version: number;
-    surfaces: FidelitySurface[];
-}
-/** Thrown when a manifest is absent, unparseable, or schema-invalid. */
-export declare class FidelityManifestError extends Error {
-    readonly filePath?: string | undefined;
-    constructor(message: string, filePath?: string | undefined);
-}
-/** Reads and parses a manifest from disk. */
-export declare function loadFidelityManifest(filePath: string): FidelityManifest;
-/** Parses and validates manifest YAML text. */
-export declare function parseFidelityManifest(text: string, filePath?: string): FidelityManifest;
-/**
- * The per-dispatch inputs for one surface, derived from its manifest entry.
- * Shapes the `params` sidecar the render runtime and preflight already consume
- * (`screens` + `render_locale` + `provenance`), the reference files to upload,
- * and the per-proof `accepted[]` baseline the post-judgment filter reads.
- */
-export interface SurfaceDispatchInputs {
-    /** params.screens: proof composable name → reference basename. */
-    screens: Record<string, string>;
-    /** params.render_locale: the single locale every reference is checked against. */
-    render_locale: string;
-    /** params.provenance: proof composable name → its reference provenance. */
-    provenance: Record<string, ReferenceProvenance>;
-    /** Reference files to upload, one per state, addressed by repo path. */
-    references: {
-        proof: string;
-        path: string;
-    }[];
-    /** Per-proof accepted[] baseline (only states that declare one). */
-    accepted: Record<string, BaselineEntry[]>;
-}
-/**
- * Build the per-dispatch inputs for one surface: one run carries all of the
- * surface's states, each paired with its own reference and provenance. The
- * render locale defaults to the references' shared locale (they must agree);
- * pass `renderLocale` to override (a deliberate mismatch then surfaces as
- * UNVERIFIABLE at the gate). Reference basenames must be unique, since the
- * upload layer addresses files by basename.
- */
-export declare function buildSurfaceDispatchInputs(surface: FidelitySurface, opts?: {
-    renderLocale?: string;
-}): SurfaceDispatchInputs;
-//# sourceMappingURL=fidelity-manifest.d.ts.map

package/dist/src/yaml/fidelity-manifest.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"fidelity-manifest.d.ts","sourceRoot":"","sources":["../../../src/yaml/fidelity-manifest.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AAKH;;;;GAIG;AACH,MAAM,WAAW,mBAAmB;IAClC,sEAAsE;IACtE,SAAS,EAAE,MAAM,CAAC;IAClB,+EAA+E;IAC/E,MAAM,EAAE,MAAM,CAAC;IACf,6EAA6E;IAC7E,QAAQ,EAAE,OAAO,CAAC;IAClB,iCAAiC;IACjC,UAAU,EAAE,MAAM,CAAC;CACpB;AAED,uDAAuD;AACvD,MAAM,WAAW,cAAc;IAC7B,iEAAiE;IACjE,IAAI,EAAE,MAAM,CAAC;IACb,oEAAoE;IACpE,UAAU,EAAE,mBAAmB,CAAC;CACjC;AAED;;;;GAIG;AACH,MAAM,WAAW,aAAa;IAC5B,uEAAuE;IACvE,QAAQ,EAAE,MAAM,CAAC;IACjB,8EAA8E;IAC9E,OAAO,EAAE,MAAM,CAAC;IAChB,kCAAkC;IAClC,QAAQ,EAAE,MAAM,CAAC;IACjB,iDAAiD;IACjD,MAAM,EAAE,MAAM,CAAC;CAChB;AAED,iDAAiD;AACjD,MAAM,WAAW,aAAa;IAC5B,wEAAwE;IACxE,IAAI,EAAE,MAAM,CAAC;IACb,8EAA8E;IAC9E,KAAK,EAAE,MAAM,CAAC;IACd,+DAA+D;IAC/D,SAAS,EAAE,cAAc,CAAC;IAC1B,kDAAkD;IAClD,QAAQ,CAAC,EAAE,aAAa,EAAE,CAAC;CAC5B;AAED,+EAA+E;AAC/E,MAAM,WAAW,eAAe;IAC9B,oBAAoB;IACpB,IAAI,EAAE,MAAM,CAAC;IACb,wCAAwC;IACxC,QAAQ,EAAE,MAAM,CAAC;IACjB,wEAAwE;IACxE,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,iDAAiD;IACjD,MAAM,CAAC,EAAE,MAAM,EAAE,CAAC;IAClB,2CAA2C;IAC3C,SAAS,CAAC,EAAE,MAAM,EAAE,CAAC;IACrB,4BAA4B;IAC5B,MAAM,EAAE,aAAa,EAAE,CAAC;CACzB;AAED,kDAAkD;AAClD,MAAM,WAAW,gBAAgB;IAC/B,OAAO,EAAE,MAAM,CAAC;IAChB,QAAQ,EAAE,eAAe,EAAE,CAAC;CAC7B;AAED,wEAAwE;AACxE,qBAAa,qBAAsB,SAAQ,KAAK;aACD,QAAQ,CAAC,EAAE,MAAM;gBAAlD,OAAO,EAAE,MAAM,EAAkB,QAAQ,CAAC,EAAE,MAAM,YAAA;CAI/D;AAED,6CAA6C;AAC7C,wBAAgB,oBAAoB,CAAC,QAAQ,EAAE,MAAM,GAAG,gBAAgB,CAQvE;AAED,+CAA+C;AAC/C,wBAAgB,qBAAqB,CACnC,IAAI,EAAE,MAAM,EACZ,QAAQ,CAAC,EAAE,MAAM,GAChB,gBAAgB,CAoBlB;AAwDD;;;;;GAKG;AACH,MAAM,WAAW,qBAAqB;IACpC,kEAAkE;IAClE,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAChC,kFAAkF;IAClF,aAAa,EAAE,MAAM,CAAC;IACtB,2EAA2E;IAC3E,UAAU,EAAE,MAAM,CAAC,MAAM,EAAE,mBAAmB,CAAC,CAAC;IAChD,wEAAwE;IACxE,UAAU,EAAE;QAAE,KAAK,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,CAAA;KAAE,EAAE,CAAC;IAC9C,oEAAoE;IACpE,QAAQ,EAAE,MAAM,CAAC,MAAM,EAAE,aAAa,EAAE,CAAC,CAAC;CAC3C;AAQD;;;;;;;GAOG;AACH,wBAAgB,0BAA0B,CACxC,OAAO,EAAE,eAAe,EACxB,IAAI,GAAE;IAAE,YAAY,CAAC,EAAE,MAAM,CAAA;CAAO,GACnC,qBAAqB,CA+BvB"}