@invarn/cibuild 2.9.4 → 2.9.7

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

@@ -1,1389 +0,0 @@
-/**
- * ui-fidelity-render-android step implementation.
- *
- * Renders parameterless Jetpack Compose wrappers from a self-contained Gradle
- * project to PNGs via Roborazzi + Robolectric on the JVM — no device, no
- * emulator — on a macOS runner. The step returns a self-contained node script
- * that, at runtime:
- *
- *   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 } }`.
- *      The gate arms whenever a screen's provenance is present (or, legacy, when
- *      `render_locale` is declared) and checks provenance METADATA only (never
- *      pixels/OCR). An absent reference — or an unprovenanced screen while
- *      `render_locale` is declared — is FATAL: status `unverifiable`, failing
- *      loud instead of yielding a confident-but-false PASS. `resolved == false`
- *      (placeholder copy) or `locale != render_locale` downgrade ONLY the copy
- *      channel: the screen renders and is judged on geometry, colors, typeface,
- *      spans, and lines, while copy comparisons are skipped and reported as a
- *      per-screen `copy_advisory` (`copy_unverifiable` + reason) in
- *      protocol-result.json. 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).
- *   3. Runs the project's Roborazzi record task (default
- *      `recordRoborazziDebug`) once. A build/compile failure means the project
- *      does not render and every screen is marked RENDER_UNSUPPORTED — the
- *      Android analog of the iOS probe gate (one Gradle module compiles as a
- *      unit, so a wrapper compile error cannot be isolated to one screen).
- *   4. Locates each screen's Roborazzi golden inside the project (recorded as
- *      `build/outputs/roborazzi/...render<ScreenName>.png` from a test method
- *      named render<ScreenName>, or a flat `<ScreenName>.png`), runs it through
- *      the shared render-output
- *      post-processor (content trim, reference alignment, dimension
- *      reporting), and writes, inside the artifacts dir
- *      (${CIBUILD_ARTIFACTS_DIR:-.ci/artifacts}):
- *      - ui-fidelity/rendered/<Screen>.png
- *      - ui-fidelity/references/<Screen>.png
- *      - ui-fidelity/aligned/<Screen>.png
- *      - protocol-result.json (always written, even on partial/total failure)
- *   5. Exits non-zero iff the archive was invalid or any screen is not
- *      "rendered".
- *
- * The result payload and artifact layout are identical in shape to the iOS
- * ui-fidelity-render step, so the dashboard compare view, the artifact
- * download tool, and the agent's compare flow are reused unchanged. Image
- * paths in protocol-result.json are relative to the artifacts dir, and error
- * messages are sanitized so absolute runner paths are rewritten before they
- * are stored.
- */
-import { BaseStepExecutor } from './base.js';
-import { parseScale, DEFAULT_SCALE } from './ui-fidelity-render.js';
-import { RENDER_SCRIPT_TRIM_STAGE } from './render-post-processor.js';
-import { RENDER_SCRIPT_FACTS_STAGE, RENDER_SCRIPT_GEOMETRY_STAGE } from './structural-facts.js';
-import { RENDER_SCRIPT_SOURCE_DIGEST_STAGE } from '../fidelity-input-digest.js';
-/**
- * Default Roborazzi record task. Run from the project root so Gradle resolves
- * it in whichever subproject declares it.
- */
-export const DEFAULT_GRADLE_TASK = 'recordRoborazziDebug';
-/** Valid values for the package_source input. */
-export const PACKAGE_SOURCES = ['repo', 'inputs', 'url'];
-/**
- * Default package source: the Gradle project ships as package.tar.gz in the
- * run-inputs directory (the agent-upload path). "repo" instead renders the
- * committed project at package_path, for a triggered (agent-less) run.
- * "url" (fidelity-linux 03) downloads the same package.tar.gz from a signed
- * package_url into the run-inputs directory and then proceeds byte-for-byte
- * like inputs mode — the clone-free delivery for triggered runs, on macOS
- * and Linux workers alike.
- */
-export const DEFAULT_PACKAGE_SOURCE = 'inputs';
-/** Valid values for the reference_source input. */
-export const REFERENCE_SOURCES = ['repo', 'inputs'];
-/**
- * Default reference source: references arrive as run inputs (a plain basename
- * under `.ci/inputs`), matching the agent-upload path.
- */
-export const DEFAULT_REFERENCE_SOURCE = 'inputs';
-/** Basename of the shipped Gradle-project archive inside the run-inputs dir. */
-export const PACKAGE_ARCHIVE_BASENAME = 'package.tar.gz';
-/** Renderer identifier recorded in protocol-result.json. */
-export const ANDROID_RENDERER = 'roborazzi-robolectric';
-/**
- * Validates a Gradle task name: a non-empty token of letters, digits, and the
- * separators Gradle allows in a task path (`:`, `-`, `_`). Rejects shell
- * metacharacters so the task is safe to pass to the runner.
- */
-export function isValidGradleTask(task) {
-    return /^[A-Za-z0-9_:-]+$/.test(task);
-}
-/**
- * Runtime body of the generated node script. Plain dependency-free CJS (the
- * runner executes it via "node -e"). Must not contain backticks or "${" —
- * String.raw keeps escape sequences literal. The renderer id and archive name
- * are concatenated in as JS string literals by generateAndroidRenderScript.
- */
-const ANDROID_RENDER_SCRIPT_MAIN = String.raw `
-// ---- runtime ----
-
-var fs = require('fs');
-var path = require('path');
-var os = require('os');
-var cp = require('child_process');
-
-var SCREEN_NAME = /^[A-Za-z_][A-Za-z0-9_]*$/;
-
-var artifactsDir = process.env.CIBUILD_ARTIFACTS_DIR || '.ci/artifacts';
-var inputsDir = path.join('.ci', 'inputs');
-var paramsPath = path.join(inputsDir, 'params.json');
-var resultPath = path.join(artifactsDir, 'protocol-result.json');
-
-var currentEntries = [];
-var buildError = null;
-// params.reference_geometry (design-px geometry per screen), set in main() and
-// read by the structural assembler. Null when the run declared none → Signal B
-// is skipped and the structural block carries facts only.
-var referenceGeometry = null;
-// params.reference_text (Signal C: Figma characters per element id per screen),
-// set in main() and read by the structural assembler. Null when none declared →
-// the appearance container carries presence facts only (no copy facts).
-var referenceText = null;
-// params.reference_color (Signal C: Figma fills per element id per screen, as
-// { fill, text } hex), set in main() and read by the structural assembler. Null
-// when none declared → no color facts.
-var referenceColor = null;
-// params.reference_spans (Signal C span facts, issue 16: the declared highlight
-// extent per element id per screen, as { text, background }), set in main() and
-// read by the structural assembler. Null when none declared → no span facts.
-var referenceSpans = null;
-// params.reference_lines (Signal C line facts, issue 18: the declared line
-// split per element id per screen, as an array of line texts), set in main()
-// and read by the structural assembler. Null when none declared → no line facts.
-var referenceLines = null;
-// params.reference_typeface (Signal C typeface facts, typeface issue 04: the
-// DESIGN font per element id per screen, as { family, weight }, built by the
-// caller from Figma node metadata), set in main() and read by the structural
-// assembler. Null when none declared → no typeface facts.
-var referenceTypeface = null;
-// params.reference_baseline (Signal C: 'figma' (default) or 'previous_render').
-// Marks whether the appearance reference is the design (divergences) or the
-// previous catalog render (regressions/drift, the no-Figma path).
-var referenceBaseline = null;
-// params.reference_frame (composition runs: the design frame's { w, h } per
-// screen, design px treated 1:1 with dp), set in main() and read by the
-// structural assembler, which asserts the captured root against it. Null when
-// none declared → no frame assertion, no placement gate.
-var referenceFrame = null;
-// params.proof_kind ('component' default | 'composition'), set in main(). The
-// frame assertion and the placement gate only apply to composition runs.
-var proofKind = 'component';
-
-function log(message) {
-  console.log('[ui-fidelity-render-android] ' + message);
-}
-
-function logError(message) {
-  console.error('[ui-fidelity-render-android] ' + message);
-}
-
-// ---- result-document path hygiene ----
-//
-// protocol-result.json must contain relative paths only. Error messages can
-// embed absolute runner paths (extracted project dir, gradle diagnostics), so
-// every message stored in the result document is passed through
-// sanitizeMessage(), which rewrites each known absolute directory -- and its
-// symlink-resolved variant -- to a relative path or a stable placeholder.
-
-var pathReplacements = [];
-
-function registerPathReplacement(absolutePath, replacement) {
-  if (!absolutePath || !path.isAbsolute(absolutePath)) return;
-  pathReplacements.push([absolutePath, replacement]);
-  try {
-    var real = fs.realpathSync(absolutePath);
-    if (real !== absolutePath) pathReplacements.push([real, replacement]);
-  } catch (realpathError) {
-    // path does not exist (yet) -- keep the literal form only
-  }
-}
-
-function sanitizeMessage(message) {
-  var sanitized = String(message);
-  pathReplacements
-    .slice()
-    .sort(function (a, b) { return b[0].length - a[0].length; })
-    .forEach(function (pair) {
-      sanitized = sanitized.split(pair[0]).join(pair[1]);
-    });
-  return sanitized;
-}
-
-registerPathReplacement(path.resolve(artifactsDir), path.isAbsolute(artifactsDir) ? '<artifacts>' : artifactsDir);
-registerPathReplacement(process.cwd(), '.');
-registerPathReplacement(os.tmpdir(), '<tmp>');
-
-function setBuildError(code, message) {
-  buildError = { code: code, message: sanitizeMessage(message) };
-  logError(code + ': ' + buildError.message);
-}
-
-function setError(entry, code, message) {
-  entry.status = 'render_failed';
-  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 twins 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.
-
-// Provenance is only "present" when the fields the gate reasons over are there.
-// A partial object (e.g. a hand-dropped { figmaNode }) is treated as no
-// provenance — verifiable is earned only through the full export path.
-function hasReferenceProvenance(provenance) {
-  return (
-    provenance != null &&
-    typeof provenance === 'object' &&
-    typeof provenance.locale === 'string' &&
-    typeof provenance.resolved === 'boolean'
-  );
-}
-
-// Assesses one screen's reference. Returns { fault, copyAdvisory }: a fatal
-// fault makes the screen unverifiable; a copy advisory downgrades only the
-// copy channel (the screen still renders and is judged on geometry, colors,
-// typeface, spans, and lines). An absent reference wins over a downgrade —
-// there is nothing to judge against.
-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: the caller keeps 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',
-        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',
-        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 };
-}
-
-function outputTail(result) {
-  var combined = ((result.stdout || '') + '\n' + (result.stderr || '')).trim();
-  if (combined.length > 2000) combined = '...' + combined.slice(-2000);
-  return combined;
-}
-
-// protocol-result.json is ALWAYS written, with one entry per screen in
-// params.json order, even on partial or total failure. All paths inside it
-// are relative to the artifacts dir.
-function writeResult() {
-  fs.mkdirSync(artifactsDir, { recursive: true });
-  var doc = {
-    renderer: RENDERER,
-    package_source: 'inputs',
-    error: buildError,
-    screens: currentEntries,
-  };
-  fs.writeFileSync(resultPath, JSON.stringify(doc, null, 2) + '\n');
-  log('wrote ' + resultPath);
-}
-
-// ---- shipped Gradle-project stage ----
-//
-// The caller ships a self-contained Gradle project as
-// .ci/inputs/package.tar.gz. Before any render it is located, extracted into a
-// scratch directory, and validated. Failures here are PER-BUILD structured
-// errors recorded as the result document's top-level error object. The
-// extracted size is bounded as a decompression-bomb guard.
-
-var DEFAULT_MAX_EXTRACTED_BYTES = 64 * 1024 * 1024;
-var maxExtractedBytes =
-  Number(process.env.UI_FIDELITY_MAX_PACKAGE_BYTES || '') || DEFAULT_MAX_EXTRACTED_BYTES;
-var shippedExtractDir = null;
-
-function runTar(args) {
-  var result = cp.spawnSync('tar', args, { encoding: 'utf-8', maxBuffer: 64 * 1024 * 1024 });
-  if (result.error) {
-    result.status = result.status == null ? 127 : result.status;
-    result.stderr = (result.stderr || '') + String(result.error.message || result.error);
-  }
-  return result;
-}
-
-function isUnsafeArchiveMember(name) {
-  if (name.charAt(0) === '/') return true;
-  var segments = name.split('/');
-  for (var i = 0; i < segments.length; i++) {
-    if (segments[i] === '..') return true;
-  }
-  return false;
-}
-
-function extractedSize(dir) {
-  var total = 0;
-  var stack = [dir];
-  while (stack.length > 0) {
-    var current = stack.pop();
-    var names = fs.readdirSync(current);
-    for (var i = 0; i < names.length; i++) {
-      var entryPath = path.join(current, names[i]);
-      var stat = fs.lstatSync(entryPath);
-      if (stat.isDirectory()) stack.push(entryPath);
-      else total += stat.size;
-    }
-  }
-  return total;
-}
-
-// Entries macOS archiving tools add but that say nothing about the project
-// layout are ignored when locating the project root.
-function isJunkEntry(name) {
-  return name === '.DS_Store' || name === '__MACOSX' || name.indexOf('._') === 0;
-}
-
-// A Gradle project root is identified by a settings script at its top.
-function hasSettings(dir) {
-  try {
-    if (fs.statSync(path.join(dir, 'settings.gradle.kts')).isFile()) return true;
-  } catch (e1) {
-    // not the .kts variant
-  }
-  try {
-    return fs.statSync(path.join(dir, 'settings.gradle')).isFile();
-  } catch (e2) {
-    return false;
-  }
-}
-
-// Project-root rule: a settings script at the extraction root wins; otherwise
-// exactly one top-level directory with a settings script at its top is the
-// root; anything else is a structured per-build error.
-function findProjectRoot(extractDir) {
-  if (hasSettings(extractDir)) return extractDir;
-  var entries = fs.readdirSync(extractDir).filter(function (name) {
-    return !isJunkEntry(name);
-  });
-  if (entries.length === 0) {
-    setBuildError('ANDROID_ARCHIVE_INVALID', PACKAGE_ARCHIVE_NAME + ' is empty');
-    return null;
-  }
-  if (entries.length > 1) {
-    setBuildError(
-      'ANDROID_ARCHIVE_INVALID',
-      PACKAGE_ARCHIVE_NAME + ' must contain a single project root; found ' +
-        entries.length + ' top-level entries (' + entries.sort().join(', ') +
-        ') and no settings.gradle(.kts) at the archive root'
-    );
-    return null;
-  }
-  var rootPath = path.join(extractDir, entries[0]);
-  if (!fs.statSync(rootPath).isDirectory()) {
-    setBuildError(
-      'ANDROID_ARCHIVE_INVALID',
-      PACKAGE_ARCHIVE_NAME + ' must contain a project directory; its only ' +
-        'top-level entry (' + entries[0] + ') is not a directory'
-    );
-    return null;
-  }
-  if (!hasSettings(rootPath)) {
-    setBuildError(
-      'ANDROID_PROJECT_ROOT_MISSING',
-      'no settings.gradle(.kts) at the top of the project root (' + entries[0] + ') in ' +
-        PACKAGE_ARCHIVE_NAME
-    );
-    return null;
-  }
-  return rootPath;
-}
-
-// Locates, extracts, and validates the shipped archive. Returns the project
-// root to build from, or null after recording a structured build error.
-function prepareShippedProject() {
-  var archivePath = path.join(inputsDir, PACKAGE_ARCHIVE_NAME);
-  var archiveStat = null;
-  try {
-    archiveStat = fs.statSync(archivePath);
-  } catch (statError) {
-    archiveStat = null;
-  }
-  if (!archiveStat || !archiveStat.isFile()) {
-    setBuildError(
-      'ANDROID_ARCHIVE_MISSING',
-      'no ' + PACKAGE_ARCHIVE_NAME + ' in ' + inputsDir + '; ship the Gradle ' +
-        'render project as a run input named ' + PACKAGE_ARCHIVE_NAME
-    );
-    return null;
-  }
-
-  var listing = runTar(['-tzf', archivePath]);
-  if (listing.status !== 0) {
-    setBuildError(
-      'ANDROID_ARCHIVE_INVALID',
-      PACKAGE_ARCHIVE_NAME + ' is not a readable gzipped tar archive:\n' + outputTail(listing)
-    );
-    return null;
-  }
-  var members = (listing.stdout || '').split('\n').filter(function (name) { return name !== ''; });
-  var unsafe = members.filter(isUnsafeArchiveMember);
-  if (unsafe.length > 0) {
-    setBuildError(
-      'ANDROID_ARCHIVE_INVALID',
-      PACKAGE_ARCHIVE_NAME + ' contains unsafe member paths (absolute or dot-dot): ' +
-        unsafe.slice(0, 5).join(', ')
-    );
-    return null;
-  }
-
-  shippedExtractDir = fs.mkdtempSync(path.join(os.tmpdir(), 'ui-fidelity-android-project-'));
-  registerPathReplacement(shippedExtractDir, '<project>');
-  log('extracting ' + PACKAGE_ARCHIVE_NAME + ' (' + archiveStat.size + ' bytes)');
-  var extraction = runTar(['-xzf', archivePath, '-C', shippedExtractDir]);
-  if (extraction.status !== 0) {
-    setBuildError(
-      'ANDROID_ARCHIVE_INVALID',
-      PACKAGE_ARCHIVE_NAME + ' could not be extracted:\n' + outputTail(extraction)
-    );
-    return null;
-  }
-
-  var totalBytes = extractedSize(shippedExtractDir);
-  if (totalBytes > maxExtractedBytes) {
-    setBuildError(
-      'ANDROID_ARCHIVE_TOO_LARGE',
-      PACKAGE_ARCHIVE_NAME + ' extracts to ' + totalBytes + ' bytes, over the ' +
-        maxExtractedBytes + '-byte limit; ship a leaner project'
-    );
-    return null;
-  }
-
-  var projectRoot = findProjectRoot(shippedExtractDir);
-  if (projectRoot === null) return null;
-  var rootLabel = path.relative(shippedExtractDir, projectRoot);
-  log('project root: ' + (rootLabel === '' ? '.' : rootLabel));
-  return projectRoot;
-}
-
-function cleanupShippedProject() {
-  if (shippedExtractDir === null) return;
-  if (process.env.UI_FIDELITY_KEEP_HARNESS) {
-    log('keeping extracted project (UI_FIDELITY_KEEP_HARNESS set)');
-    return;
-  }
-  try {
-    fs.rmSync(shippedExtractDir, { recursive: true, force: true });
-  } catch (cleanupError) {
-    // best effort
-  }
-  shippedExtractDir = null;
-}
-
-// ---- render stage ----
-//
-// Trim/align runs through the shared trim stage's runTrimHelper (the pure-JS
-// helper inside the ci binary — the same bytes iOS uses), so this step has no
-// platform-toolchain dependency and runs on macOS and Linux workers alike.
-
-// Runs the project's Roborazzi record task once, from the project root, so
-// Gradle resolves the task in whichever module declares it. Prefers the shipped
-// wrapper; falls back to a gradle on PATH.
-function runGradle(projectRoot, task) {
-  var wrapper = path.join(projectRoot, 'gradlew');
-  var hasWrapper = false;
-  try {
-    hasWrapper = fs.statSync(wrapper).isFile();
-  } catch (statError) {
-    hasWrapper = false;
-  }
-  var cmd = hasWrapper ? wrapper : 'gradle';
-  log((hasWrapper ? './gradlew ' : 'gradle ') + task);
-  var result = cp.spawnSync(cmd, [task], {
-    cwd: projectRoot,
-    encoding: 'utf-8',
-    maxBuffer: 64 * 1024 * 1024,
-  });
-  if (result.stdout) process.stdout.write(result.stdout);
-  if (result.stderr) process.stderr.write(result.stderr);
-  if (result.error) {
-    result.status = result.status == null ? 127 : result.status;
-    result.stderr = (result.stderr || '') + String(result.error.message || result.error);
-  }
-  return result;
-}
-
-// The golden's trailing method segment that renders a screen: Roborazzi's
-// record task names goldens <package>.<Class>.<method>.png and ignores an
-// explicit capture filename, so the contract is a test method named
-// render<ScreenName> (or a flat <ScreenName>.png). Matching the final
-// dot-delimited segment keeps it collision-safe (renderXProof never matches
-// screen "Proof").
-function roborazziPngMatches(basename, screen) {
-  if (basename.slice(-4) !== '.png') return false;
-  var stem = basename.slice(0, -4);
-  var lastDot = stem.lastIndexOf('.');
-  var method = lastDot === -1 ? stem : stem.slice(lastDot + 1);
-  return method === screen || method === 'render' + screen;
-}
-
-// The structural-pass layout dump (Signal A) is emitted next to the PNG in a
-// roborazzi output dir, but Roborazzi controls the PNG's golden filename and
-// ignores explicit capture names, so the dump can't reliably share the PNG's
-// stem. Match it the same collision-safe way as the PNG instead — by the final
-// dot-delimited segment of "<...>.layout.json" — so the emitter can write a
-// simple "<Screen>.layout.json" regardless of the PNG's golden name.
-function roborazziLayoutMatches(basename, screen) {
-  var suffix = '.layout.json';
-  if (basename.slice(-suffix.length) !== suffix) return false;
-  var stem = basename.slice(0, -suffix.length);
-  var lastDot = stem.lastIndexOf('.');
-  var seg = lastDot === -1 ? stem : stem.slice(lastDot + 1);
-  return seg === screen || seg === 'render' + screen;
-}
-
-// Roborazzi writes PNGs to <module>/build/outputs/roborazzi/. Collect every
-// such directory in the project so a screen's PNG can be located regardless of
-// which module rendered it.
-function findRoborazziDirs(root) {
-  var found = [];
-  var stack = [root];
-  while (stack.length > 0) {
-    var dir = stack.pop();
-    var entries;
-    try {
-      entries = fs.readdirSync(dir, { withFileTypes: true });
-    } catch (readError) {
-      continue;
-    }
-    for (var i = 0; i < entries.length; i++) {
-      var entry = entries[i];
-      if (!entry.isDirectory()) continue;
-      var full = path.join(dir, entry.name);
-      if (
-        entry.name === 'roborazzi' &&
-        path.basename(path.dirname(full)) === 'outputs' &&
-        path.basename(path.dirname(path.dirname(full))) === 'build'
-      ) {
-        found.push(full);
-      } else {
-        stack.push(full);
-      }
-    }
-  }
-  return found;
-}
-
-// Builds the project once and pairs each screen's rendered PNG with its
-// reference via the shared post-processor. A build failure means the project
-// does not render and EVERY screen is RENDER_UNSUPPORTED (one Gradle module is
-// one compile unit, so a wrapper compile error cannot be isolated to a single
-// screen — the analog of the iOS probe gate). A screen whose PNG is absent
-// after a successful build is RENDER_FAILED on its own.
-function renderScreens(renderable, projectRoot) {
-  // Snapshot the package's input files BEFORE the build runs, so the digest is
-  // over the pristine committed source and never perturbed by build outputs.
-  var packageFiles = __fidCollectPackageFiles(projectRoot);
-  // A package is safely cacheable only when it is hermetic — no Gradle script
-  // reaches outside its own root. Then the package IS its whole dependency
-  // closure, so the content key cannot miss an external change. A non-hermetic
-  // package emits no digest, so a later dispatch never skips it.
-  var packageHermetic = __fidIsHermetic(packageFiles);
-  var gradle = runGradle(projectRoot, CONFIG.gradleTask);
-  if (gradle.status !== 0) {
-    var detail = outputTail(gradle);
-    currentEntries.forEach(function (entry) {
-      setError(
-        entry,
-        'RENDER_UNSUPPORTED',
-        'the Gradle render project did not build:\n' + detail
-      );
-    });
-    return;
-  }
-
-  var workDir = fs.mkdtempSync(path.join(os.tmpdir(), 'ui-fidelity-android-trim-'));
-  registerPathReplacement(workDir, '<work>');
-  try {
-    var roborazziDirs = findRoborazziDirs(projectRoot);
-    renderable.forEach(function (entry) {
-      var source = null;
-      for (var i = 0; i < roborazziDirs.length && source === null; i++) {
-        var names;
-        try {
-          names = fs.readdirSync(roborazziDirs[i]);
-        } catch (readError) {
-          names = [];
-        }
-        for (var j = 0; j < names.length; j++) {
-          if (roborazziPngMatches(names[j], entry.screen)) {
-            source = path.join(roborazziDirs[i], names[j]);
-            break;
-          }
-        }
-      }
-      if (source === null) {
-        setError(
-          entry,
-          'RENDER_FAILED',
-          'no PNG was produced for ' + entry.screen + '; the render test must record a ' +
-            'golden named render' + entry.screen + ' (build/outputs/roborazzi/...render' +
-            entry.screen + '.png)'
-        );
-        return;
-      }
-      var relative = 'ui-fidelity/rendered/' + entry.screen + '.png';
-      var outputPath = path.resolve(artifactsDir, relative);
-      try {
-        fs.copyFileSync(source, outputPath);
-      } catch (copyError) {
-        setError(
-          entry,
-          'RENDER_FAILED',
-          'could not copy the render for ' + entry.screen + ': ' +
-            (copyError && copyError.message ? copyError.message : String(copyError))
-        );
-        return;
-      }
-      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);
-      trimRenderedImage(entry, outputPath);
-      // Signal A: the render emits a per-node layout dump into a roborazzi
-      // output dir (named "<Screen>.layout.json" or "...render<Screen>.layout.json").
-      // Locate it the same way as the PNG and derive structural facts; absent or
-      // malformed is a clean no-op.
-      var layoutSource = null;
-      for (var li = 0; li < roborazziDirs.length && layoutSource === null; li++) {
-        var lnames;
-        try {
-          lnames = fs.readdirSync(roborazziDirs[li]);
-        } catch (lReadError) {
-          lnames = [];
-        }
-        for (var lj = 0; lj < lnames.length; lj++) {
-          if (roborazziLayoutMatches(lnames[lj], entry.screen)) {
-            layoutSource = path.join(roborazziDirs[li], lnames[lj]);
-            break;
-          }
-        }
-      }
-      if (layoutSource !== null) {
-        // Signal A: write the facts + layout artifacts (deep-dive path).
-        deriveAndWriteFacts(entry, layoutSource);
-        // ADR-0004: assemble the inline structural block (facts + Signal-B
-        // geometry deltas vs reference_geometry) onto the screen entry, so the
-        // judge reads the signals from protocol-result.json without fetching
-        // artifacts. CONFIG.scale is the render density (dp = px / scale).
-        assembleStructural(entry, layoutSource, referenceGeometry, CONFIG.scale, referenceText, referenceColor, referenceBaseline, referenceFrame, proofKind, referenceSpans, referenceLines, referenceTypeface);
-      }
-    });
-  } finally {
-    if (process.env.UI_FIDELITY_KEEP_HARNESS) {
-      log('keeping trim work dir (UI_FIDELITY_KEEP_HARNESS set)');
-    } else {
-      try {
-        fs.rmSync(workDir, { recursive: true, force: true });
-      } catch (cleanupError) {
-        // best effort
-      }
-    }
-  }
-}
-
-function main() {
-  // 1. Read and validate .ci/inputs/params.json.
-  var paramsProblem = null;
-  var params = null;
-  if (!fs.existsSync(paramsPath)) {
-    paramsProblem = 'not found at ' + paramsPath;
-  } else {
-    try {
-      params = JSON.parse(fs.readFileSync(paramsPath, 'utf-8'));
-    } catch (parseError) {
-      paramsProblem = 'is not valid JSON: ' +
-        (parseError && parseError.message ? parseError.message : String(parseError));
-    }
-  }
-  if (!paramsProblem) {
-    if (
-      !params || typeof params !== 'object' || Array.isArray(params) ||
-      !params.screens || typeof params.screens !== 'object' || Array.isArray(params.screens)
-    ) {
-      paramsProblem =
-        'must have the shape { "screens": { "<ScreenName>": "<referenceFileBasename>" } }';
-    }
-  }
-  if (paramsProblem) {
-    // Screens cannot be enumerated, so the result document is written with an
-    // empty screens array and the step fails.
-    logError('params.json ' + paramsProblem);
-    writeResult();
-    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
-      : {};
-  // Signal-B design numbers (advisory): { "<Screen>": { "<tagId>": {w,h,x,y} } }
-  // in design px. Absent → the structural block carries Signal-A facts only.
-  referenceGeometry =
-    params.reference_geometry &&
-    typeof params.reference_geometry === 'object' &&
-    !Array.isArray(params.reference_geometry)
-      ? params.reference_geometry
-      : null;
-  // Signal-C copy reference: { "<Screen>": { "<elementId>": "<text>" } } — the
-  // Figma characters mapped to element ids. Absent → presence facts only.
-  referenceText =
-    params.reference_text &&
-    typeof params.reference_text === 'object' &&
-    !Array.isArray(params.reference_text)
-      ? params.reference_text
-      : null;
-  // Signal-C color reference: { "<Screen>": { "<elementId>": { fill, text } } } —
-  // the Figma fills mapped to element ids. Absent → no color facts.
-  referenceColor =
-    params.reference_color &&
-    typeof params.reference_color === 'object' &&
-    !Array.isArray(params.reference_color)
-      ? params.reference_color
-      : null;
-  // Signal-C span reference (issue 16): { "<Screen>": { "<elementId>":
-  // { text, background } } } — the substring the design highlights on that
-  // text element. Absent → no span facts.
-  referenceSpans =
-    params.reference_spans &&
-    typeof params.reference_spans === 'object' &&
-    !Array.isArray(params.reference_spans)
-      ? params.reference_spans
-      : null;
-  // Signal-C line reference (issue 18): { "<Screen>": { "<elementId>":
-  // ["line 1", "line 2"] } } — the exact line texts the design breaks that
-  // text element into. Absent → no line facts.
-  referenceLines =
-    params.reference_lines &&
-    typeof params.reference_lines === 'object' &&
-    !Array.isArray(params.reference_lines)
-      ? params.reference_lines
-      : null;
-  // Signal-C typeface reference (typeface issue 04): { "<Screen>":
-  // { "<elementId>": { family, weight } } } — the DESIGN font per element, from
-  // Figma node metadata. Diffed against the RESOLVED (painted) font the dump
-  // captured. Absent → no typeface facts.
-  referenceTypeface =
-    params.reference_typeface &&
-    typeof params.reference_typeface === 'object' &&
-    !Array.isArray(params.reference_typeface)
-      ? params.reference_typeface
-      : null;
-  // Signal-C baseline marker: 'previous_render' when the appearance reference was
-  // sourced from the previous catalog render (no-Figma drift path), else 'figma'.
-  referenceBaseline =
-    params.reference_baseline === 'previous_render' ? 'previous_render' : 'figma';
-  // Composition-run inputs: the declared kind gates the frame assertion; the
-  // per-screen design frame is what the captured root is asserted against.
-  proofKind = params.proof_kind === 'composition' ? 'composition' : 'component';
-  referenceFrame =
-    params.reference_frame &&
-    typeof params.reference_frame === 'object' &&
-    !Array.isArray(params.reference_frame)
-      ? params.reference_frame
-      : null;
-
-  var screens = Object.keys(params.screens);
-  currentEntries = screens.map(function (screen) {
-    return {
-      screen: screen,
-      status: 'render_failed',
-      error: null,
-      copy_advisory: null,
-      reference_image_path: null,
-      rendered_image_path: null,
-      aligned_image_path: null,
-      dimensions: null,
-      layout_path: null,
-      facts_path: null,
-    };
-  });
-  log('screens: ' + (screens.join(', ') || '(none)'));
-
-  fs.mkdirSync(path.join(artifactsDir, 'ui-fidelity', 'rendered'), { recursive: true });
-  fs.mkdirSync(path.join(artifactsDir, 'ui-fidelity', 'references'), { recursive: true });
-  fs.mkdirSync(path.join(artifactsDir, 'ui-fidelity', 'aligned'), { recursive: true });
-  fs.mkdirSync(path.join(artifactsDir, 'ui-fidelity', 'layout'), { recursive: true });
-  fs.mkdirSync(path.join(artifactsDir, 'ui-fidelity', 'facts'), { recursive: true });
-
-  // 2. Per-screen validation + reference copies. Each screen gets its OWN copy
-  //    named by screen, even when two screens share a reference basename.
-  currentEntries.forEach(function (entry) {
-    if (!SCREEN_NAME.test(entry.screen)) {
-      setError(
-        entry,
-        'INVALID_SCREEN_NAME',
-        'screen name ' + JSON.stringify(entry.screen) +
-          ' is not a valid identifier (letters, digits, underscores)'
-      );
-      return;
-    }
-    var basename = params.screens[entry.screen];
-    if (
-      typeof basename !== 'string' || basename === '' ||
-      basename === '.' || basename === '..' ||
-      basename !== path.basename(basename)
-    ) {
-      setError(
-        entry,
-        'REFERENCE_MISSING',
-        'reference for ' + entry.screen + ' must be a plain file basename inside ' +
-          inputsDir + ', got: ' + JSON.stringify(basename)
-      );
-      return;
-    }
-    var source = path.join(inputsDir, basename);
-    var sourceStat = null;
-    try {
-      sourceStat = fs.statSync(source);
-    } catch (statError) {
-      sourceStat = null;
-    }
-    var referenceExists = !!(sourceStat && sourceStat.isFile());
-
-    // Provenance assessment, armed whenever this screen's provenance rides in
-    // params (the references/ snapshot lifts it automatically) or the run
-    // declares a render locale (legacy arming, which keeps NO_PROVENANCE
-    // fatal). Fatal faults (reference absent, no provenance while armed) make
-    // the screen UNVERIFIABLE — hard, loud, never a silent PASS. Unresolved
-    // placeholders and locale mismatches downgrade ONLY the copy channel: the
-    // screen renders and is judged on geometry, colors, typeface, spans, and
-    // lines, while copy comparisons are skipped and reported as a structured
-    // copy_unverifiable advisory.
-    var screenProvenance = provenanceMap[entry.screen];
-    if (renderLocale !== null || hasReferenceProvenance(screenProvenance)) {
-      var assessment = assessReferenceProvenance(
-        entry.screen,
-        screenProvenance,
-        renderLocale,
-        referenceExists
-      );
-      if (assessment.fault) {
-        setUnverifiable(entry, assessment.fault.code, assessment.fault.message);
-        return;
-      }
-      if (assessment.copyAdvisory) {
-        entry.copy_advisory = {
-          code: assessment.copyAdvisory.code,
-          reason: assessment.copyAdvisory.reason,
-          message: sanitizeMessage(assessment.copyAdvisory.message),
-        };
-        // Copy comparisons are unverifiable for this screen: drop its
-        // reference text so no copy facts (text_mismatch / text_missing) are
-        // derived downstream.
-        if (referenceText && referenceText[entry.screen]) {
-          delete referenceText[entry.screen];
-        }
-        log(
-          entry.screen + ': copy channel downgraded (' +
-            assessment.copyAdvisory.reason + '), non-copy judging proceeds'
-        );
-      }
-    } else if (!referenceExists) {
-      // Legacy (no provenance, no render locale): an absent reference stays a
-      // render_failed REFERENCE_MISSING, exactly as before.
-      setError(
-        entry,
-        'REFERENCE_MISSING',
-        sourceStat
-          ? 'reference for ' + entry.screen + ' is not a regular file: ' + source
-          : 'reference image not found: ' + source
-      );
-      return;
-    }
-    var relative = 'ui-fidelity/references/' + entry.screen + '.png';
-    try {
-      fs.copyFileSync(source, path.join(artifactsDir, relative));
-    } catch (copyError) {
-      setError(
-        entry,
-        'REFERENCE_MISSING',
-        'could not copy reference for ' + entry.screen + ': ' +
-          (copyError && copyError.message ? copyError.message : String(copyError))
-      );
-      return;
-    }
-    entry.reference_image_path = relative;
-  });
-
-  // 3. Extract + validate the shipped Gradle project, then render the
-  //    renderable screens. The project stage runs even when no screen is
-  //    renderable, so packaging mistakes are always reported.
-  var renderable = currentEntries.filter(function (entry) { return entry.error === null; });
-  try {
-    var projectRoot = prepareShippedProject();
-    if (projectRoot !== null) {
-      if (renderable.length > 0) {
-        renderScreens(renderable, projectRoot);
-      } else if (currentEntries.length > 0) {
-        log('no renderable screens, skipping render');
-      }
-    }
-  } finally {
-    cleanupShippedProject();
-  }
-
-  // 4. Exit code: zero only when the shipped project (if any) was valid and
-  //    every screen rendered.
-  writeResult();
-  if (buildError !== null) {
-    logError('archive validation failed: ' + buildError.code);
-    return 1;
-  }
-  var failed = currentEntries.filter(function (entry) { return entry.status !== 'rendered'; });
-  if (failed.length > 0) {
-    logError(failed.length + ' of ' + currentEntries.length + ' screen(s) not rendered');
-    return 1;
-  }
-  log('all ' + currentEntries.length + ' screen(s) rendered');
-  return 0;
-}
-
-var exitCode = 1;
-try {
-  exitCode = main();
-} catch (unexpectedError) {
-  logError(
-    'unexpected failure: ' +
-      (unexpectedError && unexpectedError.stack ? unexpectedError.stack : String(unexpectedError))
-  );
-  try {
-    currentEntries.forEach(function (entry) {
-      if (entry.status !== 'rendered' && entry.error === null) {
-        setError(
-          entry,
-          'INTERNAL_ERROR',
-          String(unexpectedError && unexpectedError.message ? unexpectedError.message : unexpectedError)
-        );
-      }
-    });
-    writeResult();
-  } catch (writeError) {
-    logError('could not write protocol-result.json: ' + writeError);
-  }
-  exitCode = 1;
-}
-process.exit(exitCode);
-`;
-/**
- * Replaces exactly one occurrence of `anchor` in `source`. Throws when the
- * anchor is missing or ambiguous, so any drift between the default runtime text
- * and a *_source variant fails loudly at module load.
- */
-function replaceOnce(source, anchor, replacement) {
-    const first = source.indexOf(anchor);
-    if (first === -1 || source.indexOf(anchor, first + anchor.length) !== -1) {
-        throw new Error('ui-fidelity-render-android: expected exactly one occurrence of anchor: ' + anchor);
-    }
-    return source.slice(0, first) + replacement + source.slice(first + anchor.length);
-}
-/**
- * Builds the runtime main for package_source "repo" by patching the default
- * (inputs) runtime text: the result document records package_source "repo", and
- * the project is resolved from the committed checkout at package_path instead of
- * being extracted from a shipped tarball. ANDROID_RENDER_SCRIPT_MAIN itself is
- * never modified, so omitting package_source keeps the generated script
- * byte-identical to the default. Mirrors the iOS package_source patch.
- */
-function buildAndroidPackageRepoMain(base) {
-    let main = base;
-    // The result document advertises the repo package source.
-    main = replaceOnce(main, "package_source: 'inputs',", "package_source: 'repo',");
-    // Render directly from the committed project at package_path; no archive
-    // extract/validate. A missing or non-Gradle directory is a clean per-build
-    // error (the same exit-on-buildError path the inputs archive validation uses).
-    main = replaceOnce(main, '  // 3. Extract + validate the shipped Gradle project, then render the\n' +
-        '  //    renderable screens. The project stage runs even when no screen is\n' +
-        '  //    renderable, so packaging mistakes are always reported.\n' +
-        '  var renderable = currentEntries.filter(function (entry) { return entry.error === null; });\n' +
-        '  try {\n' +
-        '    var projectRoot = prepareShippedProject();\n' +
-        '    if (projectRoot !== null) {\n' +
-        '      if (renderable.length > 0) {\n' +
-        '        renderScreens(renderable, projectRoot);\n' +
-        '      } else if (currentEntries.length > 0) {\n' +
-        "        log('no renderable screens, skipping render');\n" +
-        '      }\n' +
-        '    }\n' +
-        '  } finally {\n' +
-        '    cleanupShippedProject();\n' +
-        '  }', '  // 3. Resolve the committed Gradle project at package_path and render the\n' +
-        '  //    renderable screens directly from the checkout (no archive extract).\n' +
-        '  var renderable = currentEntries.filter(function (entry) { return entry.error === null; });\n' +
-        '  var projectRoot = path.resolve(CONFIG.packagePath);\n' +
-        '  registerPathReplacement(\n' +
-        '    projectRoot,\n' +
-        "    path.isAbsolute(CONFIG.packagePath) ? '<package_path>' : CONFIG.packagePath\n" +
-        '  );\n' +
-        '  if (!fs.existsSync(projectRoot)) {\n' +
-        "    setBuildError('ANDROID_PROJECT_MISSING', 'package_path does not exist: ' + projectRoot);\n" +
-        '  } else if (!hasSettings(projectRoot)) {\n' +
-        '    setBuildError(\n' +
-        "      'ANDROID_PROJECT_ROOT_MISSING',\n" +
-        "      'no settings.gradle(.kts) at the top of package_path: ' + projectRoot\n" +
-        '    );\n' +
-        '  } else if (renderable.length > 0) {\n' +
-        '    renderScreens(renderable, projectRoot);\n' +
-        '  } else if (currentEntries.length > 0) {\n' +
-        "    log('no renderable screens, skipping render');\n" +
-        '  }');
-    return main;
-}
-const ANDROID_RENDER_SCRIPT_MAIN_REPO = buildAndroidPackageRepoMain(ANDROID_RENDER_SCRIPT_MAIN);
-/**
- * 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/`. Mirrors the iOS reference_source: repo patch. The
- * downstream stat/copy/provenance logic is unchanged; only how `source` is
- * computed differs, so a triggered (agent-less) run can point at a committed
- * reference that lives in the cloned repo.
- */
-function buildAndroidReferenceRepoMain(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);');
-}
-/**
- * Builds the runtime main for package_source "url" (fidelity-linux 03) by
- * patching the default (inputs) runtime text. Three departures from the
- * default, all forced by the same fact — a clone-free worker has no checkout:
- *
- * 1. The package is DOWNLOADED (curl, already a runner requirement in this
- *    mode) to `.ci/inputs/package.tar.gz` and extracted BEFORE the per-screen
- *    reference stage, because committed references travel inside it. A failed
- *    download is one structured per-build error, never per-screen noise.
- * 2. Each screen's reference is the committed repo-relative path resolved
- *    INSIDE the extracted package: the path must sit under packagePath, and
- *    the remainder resolves against the extracted project root.
- * 3. The render stage reuses the already-extracted root (no second extract);
- *    cleanup mirrors the inputs path. The result document records
- *    package_source "url".
- *
- * ANDROID_RENDER_SCRIPT_MAIN itself is never modified, so omitting
- * package_source keeps the generated script byte-identical to the default.
- */
-function buildAndroidPackageUrlMain(base) {
-    let main = base;
-    // The result document advertises the url package source.
-    main = replaceOnce(main, "package_source: 'inputs',", "package_source: 'url',");
-    // Download + extract FIRST — the reference stage below reads from inside
-    // the extracted package.
-    main = replaceOnce(main, '  // 2. Per-screen validation + reference copies. Each screen gets its OWN copy\n' +
-        '  //    named by screen, even when two screens share a reference basename.\n' +
-        '  currentEntries.forEach(function (entry) {', '  // 2a. Download + extract the shipped package FIRST (URL mode): committed\n' +
-        '  //     references live inside it, so the per-screen reference copies below\n' +
-        '  //     need the extracted project root. A failed download or an invalid\n' +
-        '  //     archive is ONE structured per-build error; per-screen reference\n' +
-        '  //     work then stops cleanly (no bogus REFERENCE_MISSING noise).\n' +
-        '  var urlProjectRoot = null;\n' +
-        '  (function () {\n' +
-        '    try {\n' +
-        '      fs.mkdirSync(inputsDir, { recursive: true });\n' +
-        '    } catch (mkdirError) {\n' +
-        '      // statSync below reports the real failure\n' +
-        '    }\n' +
-        '    var dest = path.join(inputsDir, PACKAGE_ARCHIVE_NAME);\n' +
-        "    log('downloading render package');\n" +
-        '    var download = cp.spawnSync(\n' +
-        "      'curl',\n" +
-        "      ['-fsSL', '--retry', '2', '--max-time', '300', '-o', dest, CONFIG.packageUrl],\n" +
-        "      { encoding: 'utf-8', maxBuffer: 16 * 1024 * 1024 }\n" +
-        '    );\n' +
-        '    if (download.error) {\n' +
-        '      download.status = download.status == null ? 127 : download.status;\n' +
-        "      download.stderr = (download.stderr || '') + String(download.error.message || download.error);\n" +
-        '    }\n' +
-        '    if (download.status !== 0) {\n' +
-        '      setBuildError(\n' +
-        "        'ANDROID_PACKAGE_DOWNLOAD_FAILED',\n" +
-        "        'render package download failed (curl exit ' + download.status + '):\\n' + outputTail(download)\n" +
-        '      );\n' +
-        '      return;\n' +
-        '    }\n' +
-        '    urlProjectRoot = prepareShippedProject();\n' +
-        '  })();\n' +
-        '\n' +
-        '  // 2. Per-screen validation + reference copies. Each screen gets its OWN copy\n' +
-        '  //    named by screen, even when two screens share a reference basename.\n' +
-        '  currentEntries.forEach(function (entry) {');
-    // References resolve INSIDE the extracted package: repo-relative path minus
-    // the packagePath prefix, against the extracted project root.
-    main = replaceOnce(main, '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' +
-        '    if (urlProjectRoot === null) {\n' +
-        '      // Package unavailable: the per-build error above carries the cause.\n' +
-        '      return;\n' +
-        '    }\n' +
-        "    var packagePrefix = CONFIG.packagePath.replace(/^\\.\\//, '').replace(/\\/+$/, '');\n" +
-        "    var normalizedRef = refPath.replace(/^\\.\\//, '');\n" +
-        "    if (normalizedRef.indexOf(packagePrefix + '/') !== 0) {\n" +
-        '      setError(\n' +
-        '        entry,\n' +
-        "        'REFERENCE_MISSING',\n" +
-        "        'reference for ' + entry.screen + ' must live inside the shipped package (' +\n" +
-        "          packagePrefix + '), got: ' + JSON.stringify(refPath)\n" +
-        '      );\n' +
-        '      return;\n' +
-        '    }\n' +
-        '    var source = path.join(urlProjectRoot, normalizedRef.slice(packagePrefix.length + 1));');
-    // Render from the package extracted in stage 2a — no second extract.
-    main = replaceOnce(main, '  // 3. Extract + validate the shipped Gradle project, then render the\n' +
-        '  //    renderable screens. The project stage runs even when no screen is\n' +
-        '  //    renderable, so packaging mistakes are always reported.\n' +
-        '  var renderable = currentEntries.filter(function (entry) { return entry.error === null; });\n' +
-        '  try {\n' +
-        '    var projectRoot = prepareShippedProject();\n' +
-        '    if (projectRoot !== null) {\n' +
-        '      if (renderable.length > 0) {\n' +
-        '        renderScreens(renderable, projectRoot);\n' +
-        '      } else if (currentEntries.length > 0) {\n' +
-        "        log('no renderable screens, skipping render');\n" +
-        '      }\n' +
-        '    }\n' +
-        '  } finally {\n' +
-        '    cleanupShippedProject();\n' +
-        '  }', '  // 3. Render from the package downloaded + extracted in stage 2a. The\n' +
-        '  //    extraction already reported packaging mistakes as the per-build\n' +
-        '  //    error, so a null root here just skips the render.\n' +
-        '  var renderable = currentEntries.filter(function (entry) { return entry.error === null; });\n' +
-        '  try {\n' +
-        '    if (urlProjectRoot !== null) {\n' +
-        '      if (renderable.length > 0) {\n' +
-        '        renderScreens(renderable, urlProjectRoot);\n' +
-        '      } else if (currentEntries.length > 0) {\n' +
-        "        log('no renderable screens, skipping render');\n" +
-        '      }\n' +
-        '    }\n' +
-        '  } finally {\n' +
-        '    cleanupShippedProject();\n' +
-        '  }');
-    return main;
-}
-const ANDROID_RENDER_SCRIPT_MAIN_URL = buildAndroidPackageUrlMain(ANDROID_RENDER_SCRIPT_MAIN);
-/**
- * Generates the self-contained runtime node script for the step. Pure function
- * of its config — exported so tests can execute the script directly.
- *
- * When config.referenceSource is absent the reference block is byte-identical
- * to the default (JSON.stringify drops the undefined key, and the unpatched
- * runtime is used).
- */
-export function generateAndroidRenderScript(config) {
-    let main = config.packageSource === 'repo'
-        ? ANDROID_RENDER_SCRIPT_MAIN_REPO
-        : config.packageSource === 'url'
-            ? ANDROID_RENDER_SCRIPT_MAIN_URL
-            : ANDROID_RENDER_SCRIPT_MAIN;
-    // Reference-from-repo is an independent dimension layered on top of whichever
-    // package base applies. Absent → byte-identical reference block (default
-    // basename behaviour). URL mode embeds its own reference sourcing and the
-    // executor rejects the combination before this point.
-    if (config.referenceSource === 'repo') {
-        main = buildAndroidReferenceRepoMain(main);
-    }
-    return [
-        "'use strict';",
-        '// ui-fidelity-render-android runtime script (generated by cibuild at YAML conversion time)',
-        'var CONFIG = ' + JSON.stringify(config) + ';',
-        'var RENDERER = ' + JSON.stringify(ANDROID_RENDERER) + ';',
-        'var PACKAGE_ARCHIVE_NAME = ' + JSON.stringify(PACKAGE_ARCHIVE_BASENAME) + ';',
-        RENDER_SCRIPT_TRIM_STAGE,
-        RENDER_SCRIPT_FACTS_STAGE,
-        RENDER_SCRIPT_GEOMETRY_STAGE,
-        RENDER_SCRIPT_SOURCE_DIGEST_STAGE,
-        main,
-    ].join('\n');
-}
-/**
- * ui-fidelity-render-android step executor. Returns a node-kind StepDef whose
- * script performs the render at runtime on the macOS runner.
- */
-export class UiFidelityRenderAndroidStepExecutor extends BaseStepExecutor {
-    getValidationRequirements(inputs, _env, _config) {
-        // No platform-toolchain requirement: trim/align is pure JS inside the ci
-        // binary (fidelity-linux 06), so the step validates on macOS and Linux
-        // runners alike.
-        const requirements = [
-            this.requireCommand('tar', 'Archive tool used to extract the shipped Gradle project', 'Install tar on the runner'),
-        ];
-        // URL mode (fidelity-linux 03) downloads the package at runtime; existing
-        // inputs/repo runs gain no new requirement.
-        if (this.getInput(inputs, 'package_source', undefined) === 'url') {
-            requirements.push(this.requireCommand('curl', 'Downloader used to fetch the render package by signed URL', 'Install curl on the runner'));
-        }
-        return requirements;
-    }
-    async execute(inputs, _env, _config) {
-        const stepName = 'ui-fidelity-render-android';
-        const scale = parseScale(this.getInput(inputs, 'scale', DEFAULT_SCALE));
-        const gradleTask = String(this.getInput(inputs, 'gradle_task', DEFAULT_GRADLE_TASK));
-        if (!isValidGradleTask(gradleTask)) {
-            throw new Error(`Invalid gradle_task '${gradleTask}' for step '${stepName}': ` +
-                'expected a Gradle task path (letters, digits, and : - _)');
-        }
-        // package_source: validate when provided, but only record (and patch the
-        // script for) the non-default modes so omitting it — or setting the default
-        // "inputs" — keeps the default archive-extract script byte-identical. In
-        // repo mode package_path is required (the committed project to render); in
-        // url mode (fidelity-linux 03) package_url and package_path are required
-        // (the signed download + the prefix committed reference paths sit under).
-        const rawPackageSource = this.getInput(inputs, 'package_source', undefined);
-        let packageSource;
-        if (rawPackageSource !== undefined) {
-            const value = String(rawPackageSource);
-            if (!PACKAGE_SOURCES.includes(value)) {
-                throw new Error(`Invalid package_source '${value}' for step '${stepName}': ` +
-                    `expected one of: ${PACKAGE_SOURCES.join(', ')}`);
-            }
-            if (value === 'repo' || value === 'url') {
-                packageSource = value;
-            }
-        }
-        let packagePath;
-        if (packageSource === 'repo' || packageSource === 'url') {
-            packagePath = String(this.getRequiredInput(inputs, 'package_path', stepName));
-        }
-        let packageUrl;
-        if (packageSource === 'url') {
-            packageUrl = String(this.getRequiredInput(inputs, 'package_url', stepName));
-            if (!/^https?:\/\//.test(packageUrl)) {
-                throw new Error(`Invalid package_url for step '${stepName}': expected an http(s) URL`);
-            }
-        }
-        // reference_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 default basename 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(', ')}`);
-            }
-            // URL mode owns reference sourcing (inside the extracted package) —
-            // an explicit reference_source alongside it is a contradiction.
-            if (packageSource === 'url') {
-                throw new Error(`Invalid reference_source for step '${stepName}': ` +
-                    "package_source 'url' resolves references inside the downloaded " +
-                    'package; omit reference_source');
-            }
-            if (value === 'repo') {
-                referenceSource = 'repo';
-            }
-        }
-        const config = { scale, gradleTask };
-        if (packageSource !== undefined) {
-            config.packageSource = packageSource;
-        }
-        if (packagePath !== undefined) {
-            config.packagePath = packagePath;
-        }
-        if (packageUrl !== undefined) {
-            config.packageUrl = packageUrl;
-        }
-        if (referenceSource !== undefined) {
-            config.referenceSource = referenceSource;
-        }
-        const script = generateAndroidRenderScript(config);
-        return this.createNodeStep(script, stepName);
-    }
-}
-//# sourceMappingURL=ui-fidelity-render-android.js.map