@invarn/cibuild 2.0.7 → 2.0.9

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

@@ -0,0 +1,726 @@
+/**
+ * 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>`.
+ *   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';
+/**
+ * Default Roborazzi record task. Run from the project root so Gradle resolves
+ * it in whichever subproject declares it.
+ */
+export const DEFAULT_GRADLE_TASK = 'recordRoborazziDebug';
+/** 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;
+
+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) };
+}
+
+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 ----
+//
+// runSwift drives the shared CoreGraphics trim/align helper in script-
+// interpreter mode (the same helper iOS uses); it is available because the
+// render runs on the macOS runner fleet regardless of the JVM render engine.
+
+function runSwift(args) {
+  var result = cp.spawnSync('swift', args, { encoding: 'utf-8', maxBuffer: 16 * 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;
+}
+
+// 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;
+}
+
+// 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) {
+  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;
+      log('rendered ' + entry.screen + ' -> ' + relative);
+      trimRenderedImage(entry, outputPath, workDir);
+    });
+  } 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;
+  }
+
+  var screens = Object.keys(params.screens);
+  currentEntries = screens.map(function (screen) {
+    return {
+      screen: screen,
+      status: 'render_failed',
+      error: null,
+      reference_image_path: null,
+      rendered_image_path: null,
+      aligned_image_path: null,
+      dimensions: 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 });
+
+  // 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;
+    }
+    if (!sourceStat || !sourceStat.isFile()) {
+      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);
+`;
+/**
+ * Generates the self-contained runtime node script for the step. Pure function
+ * of its config — exported so tests can execute the script directly.
+ */
+export function generateAndroidRenderScript(config) {
+    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,
+        ANDROID_RENDER_SCRIPT_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) {
+        return [
+            this.requireCommand('swift', 'Swift toolchain used to run the CoreGraphics trim/align helper', 'Install Xcode (or the Swift toolchain) on the runner'),
+            this.requireCommand('tar', 'Archive tool used to extract the shipped Gradle project', 'Install tar on the runner'),
+        ];
+    }
+    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 : - _)');
+        }
+        const config = { scale, gradleTask };
+        const script = generateAndroidRenderScript(config);
+        return this.createNodeStep(script, stepName);
+    }
+}
+//# sourceMappingURL=ui-fidelity-render-android.js.map