@invarn/cibuild 1.9.9 → 2.0.0

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

@@ -0,0 +1,610 @@
+/**
+ * ui-fidelity-render step implementation.
+ *
+ * Renders parameterless SwiftUI views from a user's SwiftPM package to PNGs
+ * with SwiftUI's ImageRenderer on a macOS runner — no app build, no
+ * simulator. The step returns a self-contained node script that, at runtime:
+ *
+ *   1. Reads `.ci/inputs/params.json`
+ *      ({ "screens": { "<ViewTypeName>": "<referenceFileBasename>" } });
+ *      reference images live at `.ci/inputs/<basename>`.
+ *   2. Synthesizes a throwaway SwiftPM harness package that depends on the
+ *      user's package and contains ONE executable target per screen, so a
+ *      compile failure for one screen (unknown view type, unavailable init)
+ *      never breaks the others. A screen-free probe target distinguishes
+ *      "this screen is broken" from "the whole package does not build for
+ *      macOS" (RENDER_UNSUPPORTED).
+ *   3. Builds and runs each per-screen executable, which constructs the view
+ *      strictly as `<ViewTypeName>()`, renders at render_size x scale on the
+ *      MainActor, and writes a PNG via CGImage + ImageIO.
+ *   4. Writes, inside the artifacts dir (${CIBUILD_ARTIFACTS_DIR:-.ci/artifacts}):
+ *      - ui-fidelity/rendered/<Screen>.png
+ *      - ui-fidelity/references/<Screen>.png (one copy per screen, even when
+ *        two screens share a reference basename)
+ *      - protocol-result.json (always written, even on partial/total failure;
+ *        when params.json is absent/malformed the screens array is empty
+ *        because screens cannot be enumerated)
+ *   5. Exits non-zero iff any screen is not "rendered".
+ *
+ * protocol-result.json contains relative paths only: image paths are relative
+ * to the artifacts dir, and error messages are sanitized so absolute runner
+ * paths (resolved package_path, harness temp dir, compiler diagnostics) are
+ * rewritten to relative paths or placeholders before they are stored.
+ */
+import { BaseStepExecutor } from './base.js';
+/**
+ * Default render size in device points. 393x852 is the iPhone-class portrait
+ * canvas shared by the iPhone 14 Pro / 15 / 16 — the most common modern
+ * iPhone logical resolution, so renders line up with design references by
+ * default.
+ */
+export const DEFAULT_RENDER_SIZE = '393x852';
+/** Default display scale (@2x), matching how references are typically exported. */
+export const DEFAULT_SCALE = 2;
+/**
+ * Parses a "<width>x<height>" render size string (device points).
+ * @throws Error when the value is malformed or non-positive
+ */
+export function parseRenderSize(value) {
+    const match = /^(\d+)x(\d+)$/.exec(String(value).trim());
+    const width = match ? Number(match[1]) : 0;
+    const height = match ? Number(match[2]) : 0;
+    if (!match || width <= 0 || height <= 0) {
+        throw new Error(`Invalid render_size '${value}' for step 'ui-fidelity-render': ` +
+            `expected "<width>x<height>" in device points, e.g. "${DEFAULT_RENDER_SIZE}"`);
+    }
+    return { width, height };
+}
+/**
+ * Parses the scale input into a positive finite number.
+ * @throws Error when the value is not a positive number
+ */
+export function parseScale(value) {
+    const scale = typeof value === 'number' ? value : Number(String(value).trim());
+    if (!Number.isFinite(scale) || scale <= 0) {
+        throw new Error(`Invalid scale '${value}' for step 'ui-fidelity-render': expected a positive number`);
+    }
+    return scale;
+}
+/**
+ * Swift source generators, written as plain dependency-free JS so the exact
+ * same code is embedded into the runtime node script AND directly evaluable
+ * in unit tests (see getRenderScriptInternals). String.raw keeps escape
+ * sequences literal; the body must not contain backticks or "${".
+ */
+const RENDER_SCRIPT_GENERATORS = String.raw `
+// ---- Swift source generation (pure string builders) ----
+
+function swiftStringLiteral(value) {
+  var out = '"';
+  var s = String(value);
+  for (var i = 0; i < s.length; i++) {
+    var ch = s[i];
+    var code = s.charCodeAt(i);
+    if (ch === '\\') out += '\\\\';
+    else if (ch === '"') out += '\\"';
+    else if (ch === '\n') out += '\\n';
+    else if (ch === '\r') out += '\\r';
+    else if (ch === '\t') out += '\\t';
+    else if (code < 0x20) out += '\\u{' + code.toString(16) + '}';
+    else out += ch;
+  }
+  return out + '"';
+}
+
+// One executable target (and product) per screen: SwiftPM compiles the user
+// package once, while a per-screen harness compile failure stays isolated to
+// that screen. RenderProbe imports the user package without referencing any
+// screen, so its failure means the package itself does not build for macOS.
+function generateHarnessPackageSwift(screens, options) {
+  var dependency =
+    '.product(name: ' + swiftStringLiteral(options.target) +
+    ', package: ' + swiftStringLiteral(options.packageRef) + ')';
+  var lines = [];
+  lines.push('// swift-tools-version:5.9');
+  lines.push('import PackageDescription');
+  lines.push('');
+  lines.push('let package = Package(');
+  lines.push('    name: "UIFidelityRenderHarness",');
+  lines.push('    platforms: [.macOS(.v13)],');
+  lines.push('    products: [');
+  screens.forEach(function (screen) {
+    lines.push(
+      '        .executable(name: "Render_' + screen +
+      '", targets: ["Render_' + screen + '"]),'
+    );
+  });
+  lines.push('    ],');
+  lines.push('    dependencies: [');
+  lines.push('        .package(path: ' + swiftStringLiteral(options.packagePath) + ')');
+  lines.push('    ],');
+  lines.push('    targets: [');
+  lines.push('        .executableTarget(name: "RenderProbe", dependencies: [' + dependency + ']),');
+  screens.forEach(function (screen) {
+    lines.push(
+      '        .executableTarget(name: "Render_' + screen +
+      '", dependencies: [' + dependency + ']),'
+    );
+  });
+  lines.push('    ]');
+  lines.push(')');
+  return lines.join('\n') + '\n';
+}
+
+function generateProbeSwift(options) {
+  var lines = [];
+  lines.push('import ' + options.target);
+  lines.push('');
+  lines.push('@main');
+  lines.push('struct Probe {');
+  lines.push('    static func main() {}');
+  lines.push('}');
+  return lines.join('\n') + '\n';
+}
+
+// ImageRenderer is MainActor-isolated, so the @main entry point runs on the
+// MainActor. The view is constructed strictly via the parameterless init.
+function generateScreenSwift(screen, options) {
+  var lines = [];
+  lines.push('import Foundation');
+  lines.push('import ImageIO');
+  lines.push('import SwiftUI');
+  lines.push('import UniformTypeIdentifiers');
+  lines.push('import ' + options.target);
+  lines.push('');
+  lines.push('@main');
+  lines.push('struct RenderEntry {');
+  lines.push('    @MainActor');
+  lines.push('    static func main() {');
+  lines.push('        let arguments = CommandLine.arguments');
+  lines.push('        guard arguments.count >= 2 else {');
+  lines.push('            FileHandle.standardError.write(Data("usage: Render_' + screen + ' <output.png>".utf8))');
+  lines.push('            exit(64)');
+  lines.push('        }');
+  lines.push('        let outputPath = arguments[1]');
+  lines.push('        let width: CGFloat = ' + options.width);
+  lines.push('        let height: CGFloat = ' + options.height);
+  lines.push('        let view = ' + screen + '().frame(width: width, height: height)');
+  lines.push('        let renderer = ImageRenderer(content: view)');
+  lines.push('        renderer.scale = ' + options.scale);
+  lines.push('        renderer.proposedSize = ProposedViewSize(width: width, height: height)');
+  lines.push('        guard let image = renderer.cgImage else {');
+  lines.push('            FileHandle.standardError.write(Data("ImageRenderer produced no image for ' + screen + '".utf8))');
+  lines.push('            exit(65)');
+  lines.push('        }');
+  lines.push('        let url = URL(fileURLWithPath: outputPath)');
+  lines.push('        guard let destination = CGImageDestinationCreateWithURL(url as CFURL, UTType.png.identifier as CFString, 1, nil) else {');
+  lines.push('            FileHandle.standardError.write(Data(("could not create PNG destination at " + outputPath).utf8))');
+  lines.push('            exit(66)');
+  lines.push('        }');
+  lines.push('        CGImageDestinationAddImage(destination, image, nil)');
+  lines.push('        guard CGImageDestinationFinalize(destination) else {');
+  lines.push('            FileHandle.standardError.write(Data(("could not write PNG to " + outputPath).utf8))');
+  lines.push('            exit(66)');
+  lines.push('        }');
+  lines.push('    }');
+  lines.push('}');
+  return lines.join('\n') + '\n';
+}
+`;
+/**
+ * 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.
+ */
+const RENDER_SCRIPT_MAIN = String.raw `
+// ---- runtime ----
+
+var fs = require('fs');
+var path = require('path');
+var os = require('os');
+var cp = require('child_process');
+
+var RENDERER = 'imagerenderer-spm';
+var SWIFT_IDENTIFIER = /^[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 = [];
+
+function log(message) {
+  console.log('[ui-fidelity-render] ' + message);
+}
+
+function logError(message) {
+  console.error('[ui-fidelity-render] ' + message);
+}
+
+// ---- result-document path hygiene ----
+//
+// protocol-result.json must contain relative paths only. Error messages can
+// embed absolute runner paths (resolved package_path, harness temp dir,
+// swift compiler diagnostics, copy failures), so every message stored in the
+// result document is passed through sanitizeMessage(), which rewrites each
+// known absolute directory -- and its symlink-resolved variant, since macOS
+// tools print /var/folders/... as /private/var/folders/... -- 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;
+}
+
+var resolvedPackagePath = path.resolve(CONFIG.packagePath);
+registerPathReplacement(
+  resolvedPackagePath,
+  path.isAbsolute(CONFIG.packagePath) ? '<package_path>' : CONFIG.packagePath
+);
+registerPathReplacement(
+  path.resolve(artifactsDir),
+  path.isAbsolute(artifactsDir) ? '<artifacts>' : artifactsDir
+);
+registerPathReplacement(process.cwd(), '.');
+registerPathReplacement(os.tmpdir(), '<tmp>');
+
+// 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, screens: currentEntries };
+  fs.writeFileSync(resultPath, JSON.stringify(doc, null, 2) + '\n');
+  log('wrote ' + resultPath);
+}
+
+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;
+}
+
+function runSwift(args) {
+  log('swift ' + args.join(' '));
+  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;
+}
+
+function renderWithHarness(renderable, packagePath) {
+  var harnessDir = fs.mkdtempSync(path.join(os.tmpdir(), 'ui-fidelity-harness-'));
+  registerPathReplacement(harnessDir, '<harness>');
+  log('harness package: ' + harnessDir);
+  try {
+    var screens = renderable.map(function (entry) { return entry.screen; });
+    var generatorOptions = {
+      packagePath: packagePath,
+      packageRef: path.basename(packagePath),
+      target: CONFIG.target,
+      width: CONFIG.width,
+      height: CONFIG.height,
+      scale: CONFIG.scale,
+    };
+
+    fs.writeFileSync(
+      path.join(harnessDir, 'Package.swift'),
+      generateHarnessPackageSwift(screens, generatorOptions)
+    );
+    var probeDir = path.join(harnessDir, 'Sources', 'RenderProbe');
+    fs.mkdirSync(probeDir, { recursive: true });
+    fs.writeFileSync(path.join(probeDir, 'Probe.swift'), generateProbeSwift(generatorOptions));
+    screens.forEach(function (screen) {
+      var sourceDir = path.join(harnessDir, 'Sources', 'Render_' + screen);
+      fs.mkdirSync(sourceDir, { recursive: true });
+      fs.writeFileSync(
+        path.join(sourceDir, 'Render.swift'),
+        generateScreenSwift(screen, generatorOptions)
+      );
+    });
+
+    // Harness-level gate: the probe imports the user package without touching
+    // any screen. If it fails, the package does not resolve/compile for
+    // macOS and EVERY screen is marked RENDER_UNSUPPORTED.
+    var probe = runSwift(['build', '--package-path', harnessDir, '--target', 'RenderProbe']);
+    if (probe.status !== 0) {
+      var probeDetail = outputTail(probe);
+      currentEntries.forEach(function (entry) {
+        setError(
+          entry,
+          'RENDER_UNSUPPORTED',
+          'the package at ' + packagePath + ' does not build for macOS:\n' + probeDetail
+        );
+      });
+      return;
+    }
+
+    renderable.forEach(function (entry) {
+      var product = 'Render_' + entry.screen;
+      var build = runSwift(['build', '--package-path', harnessDir, '--product', product]);
+      if (build.status !== 0) {
+        setError(
+          entry,
+          'VIEW_COMPILE_FAILED',
+          'harness for ' + entry.screen + ' did not compile (is ' + entry.screen +
+            ' a public View with a parameterless init in ' + CONFIG.target + '?):\n' +
+            outputTail(build)
+        );
+        return;
+      }
+      var relative = 'ui-fidelity/rendered/' + entry.screen + '.png';
+      var outputPath = path.resolve(artifactsDir, relative);
+      var run = runSwift(['run', '--package-path', harnessDir, '--skip-build', product, outputPath]);
+      if (run.status !== 0) {
+        setError(
+          entry,
+          'RENDER_FAILED',
+          'renderer for ' + entry.screen + ' exited with code ' + run.status + ':\n' + outputTail(run)
+        );
+        return;
+      }
+      if (!fs.existsSync(outputPath)) {
+        setError(
+          entry,
+          'RENDER_FAILED',
+          'renderer for ' + entry.screen + ' exited 0 but produced no PNG at ' + outputPath
+        );
+        return;
+      }
+      entry.rendered_image_path = relative;
+      entry.status = 'rendered';
+      entry.error = null;
+      log('rendered ' + entry.screen + ' -> ' + relative);
+    });
+  } finally {
+    if (process.env.UI_FIDELITY_KEEP_HARNESS) {
+      log('keeping harness package (UI_FIDELITY_KEEP_HARNESS set)');
+    } else {
+      try {
+        fs.rmSync(harnessDir, { 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": { "<ViewTypeName>": "<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,
+    };
+  });
+  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 });
+
+  // 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 (!SWIFT_IDENTIFIER.test(entry.screen)) {
+      setError(
+        entry,
+        'INVALID_SCREEN_NAME',
+        'screen name ' + JSON.stringify(entry.screen) + ' is not a valid Swift type identifier'
+      );
+      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';
+    // The copy is guarded per screen so an unexpected filesystem failure
+    // never escapes this forEach and takes the other screens down with it.
+    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. Render the remaining screens through the synthesized harness.
+  var renderable = currentEntries.filter(function (entry) { return entry.error === null; });
+  if (renderable.length > 0) {
+    if (!fs.existsSync(resolvedPackagePath)) {
+      currentEntries.forEach(function (entry) {
+        setError(entry, 'RENDER_UNSUPPORTED', 'package_path does not exist: ' + resolvedPackagePath);
+      });
+    } else {
+      renderWithHarness(renderable, resolvedPackagePath);
+    }
+  } else if (currentEntries.length > 0) {
+    log('no renderable screens, skipping harness build');
+  }
+
+  // 4. Exit code: zero only when every screen rendered.
+  writeResult();
+  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);
+`;
+/**
+ * Evaluates the embedded generator source and returns the real functions, so
+ * unit tests exercise exactly the code that ships inside the runtime script.
+ */
+export function getRenderScriptInternals() {
+    const factory = new Function(RENDER_SCRIPT_GENERATORS +
+        '\nreturn { swiftStringLiteral: swiftStringLiteral,' +
+        ' generateHarnessPackageSwift: generateHarnessPackageSwift,' +
+        ' generateProbeSwift: generateProbeSwift,' +
+        ' generateScreenSwift: generateScreenSwift };');
+    return factory();
+}
+/**
+ * Generates the self-contained runtime node script for the step.
+ * Pure function of its config — exported so tests can execute the script.
+ */
+export function generateRenderScript(config) {
+    return [
+        "'use strict';",
+        '// ui-fidelity-render runtime script (generated by cibuild at YAML conversion time)',
+        'var CONFIG = ' + JSON.stringify(config) + ';',
+        RENDER_SCRIPT_GENERATORS,
+        RENDER_SCRIPT_MAIN,
+    ].join('\n');
+}
+/**
+ * ui-fidelity-render step executor.
+ * Returns a node-kind StepDef whose script performs the render at runtime on
+ * the macOS runner.
+ */
+export class UiFidelityRenderStepExecutor extends BaseStepExecutor {
+    getValidationRequirements(inputs, _env, _config) {
+        return [
+            this.requireInput('package_path', inputs, 'Path to the SwiftPM package containing the screens'),
+            this.requireInput('target', inputs, 'SPM library product to import in the render harness'),
+            this.requireCommand('swift', 'Swift toolchain used to build and run the render harness', 'Install Xcode (or the Swift toolchain) on the runner'),
+        ];
+    }
+    async execute(inputs, _env, _config) {
+        const stepName = 'ui-fidelity-render';
+        const packagePath = String(this.getRequiredInput(inputs, 'package_path', stepName));
+        const target = String(this.getRequiredInput(inputs, 'target', stepName));
+        if (!/^[A-Za-z_][A-Za-z0-9_]*$/.test(target)) {
+            throw new Error(`Invalid target '${target}' for step '${stepName}': ` +
+                'must be a Swift module identifier (letters, digits, underscores)');
+        }
+        const { width, height } = parseRenderSize(String(this.getInput(inputs, 'render_size', DEFAULT_RENDER_SIZE)));
+        const scale = parseScale(this.getInput(inputs, 'scale', DEFAULT_SCALE));
+        const script = generateRenderScript({ packagePath, target, width, height, scale });
+        return this.createNodeStep(script, stepName);
+    }
+}
+//# sourceMappingURL=ui-fidelity-render.js.map

package/dist/src/yaml/steps/ui-fidelity-render.test.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Tests for the ui-fidelity-render step.
+ *
+ * The runtime tests execute the generated node script for real inside a temp
+ * project directory, with a PATH-shimmed fake `swift` binary so harness
+ * builds and renders are deterministic. Fake swift behavior is driven by env
+ * vars (FAKE_SWIFT_PROBE_FAIL, FAKE_SWIFT_COMPILE_FAIL, FAKE_SWIFT_RUN_FAIL,
+ * FAKE_SWIFT_RUN_SILENT). Like the real toolchain, its failure diagnostics
+ * embed the absolute harness package path, so the suite can prove those
+ * paths never reach protocol-result.json.
+ *
+ * The committed SwiftPM fixture (test/fixtures/ui-fidelity-package) is wired
+ * through the harness with the fake toolchain in every run; set
+ * CIBUILD_UI_FIDELITY_REAL_SWIFT=1 to also build and render it with the real
+ * Swift toolchain (macOS with Xcode required, slow).
+ */
+export {};
+//# sourceMappingURL=ui-fidelity-render.test.d.ts.map

package/dist/src/yaml/steps/ui-fidelity-render.test.d.ts.map

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