@invarn/cibuild 2.0.8 → 2.1.0

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

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

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

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

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

@@ -0,0 +1,377 @@
+import { spawnSync } from 'node:child_process';
+import { chmodSync, cpSync, mkdirSync, mkdtempSync, readFileSync, rmSync, writeFileSync, } from 'node:fs';
+import { gzipSync } from 'node:zlib';
+import { tmpdir } from 'node:os';
+import { dirname, join, resolve } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { ANDROID_RENDERER, UiFidelityRenderAndroidStepExecutor, } from './ui-fidelity-render-android.js';
+import { testConfig } from './test-config.js';
+const PNG_MAGIC = Buffer.from([0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a]);
+const tempDirs = [];
+afterAll(() => {
+    for (const dir of tempDirs) {
+        try {
+            rmSync(dir, { recursive: true, force: true });
+        }
+        catch {
+            // best effort
+        }
+    }
+});
+// ---- fake toolchain ----------------------------------------------------------
+// Fake `gradlew`, shipped inside the archive at the project root. With
+// FAKE_GRADLE_FAIL set it prints a compiler-style diagnostic and exits 1
+// (the project-does-not-build path). Otherwise it writes one PNG per screen
+// named in FAKE_ROBORAZZI_SCREENS (comma-separated) to
+// proof/build/outputs/roborazzi/<Screen>.png, mimicking a Roborazzi record.
+const FAKE_GRADLEW_LINES = [
+    '#!/bin/bash',
+    '[ -n "$FAKE_GRADLE_LOG" ] && echo "$*" >> "$FAKE_GRADLE_LOG"',
+    'if [ -n "$FAKE_GRADLE_FAIL" ]; then',
+    '  echo "> Task :proof:compileDebugKotlin FAILED" >&2',
+    '  echo "e: XProof.kt:7:20 unresolved reference: Missing" >&2',
+    '  exit 1',
+    'fi',
+    'out="proof/build/outputs/roborazzi"',
+    'mkdir -p "$out"',
+    'IFS=","',
+    'for s in $FAKE_ROBORAZZI_SCREENS; do',
+    '  [ -z "$s" ] && continue',
+    "  printf '\\x89PNG\\r\\n\\x1a\\n' > \"$out/$s.png\"",
+    '  printf \'roborazzi:%s\' "$s" >> "$out/$s.png"',
+    'done',
+    'exit 0',
+];
+// Fake `swift`, providing only the script-interpreter branch the shared trim
+// stage uses: `swift <Trim.swift> <in> <out> <aligned> <ref>`. Overwrites
+// <out> with a "trimmed:<in basename>" PNG, writes an "aligned:<in basename>"
+// PNG, and emits a fixed TRIMDIMS line. FAKE_TRIM_FAIL exercises warn-and-continue.
+const FAKE_SWIFT_LINES = [
+    '#!/bin/bash',
+    'case "$1" in',
+    '  *.swift)',
+    '    if [ -n "$FAKE_TRIM_FAIL" ]; then echo "trim: simulated failure" >&2; exit 1; fi',
+    '    in_png="$2"; out_png="$3"; aligned_png="$4"',
+    "    printf '\\x89PNG\\r\\n\\x1a\\n' > \"$out_png\"",
+    '    printf \'trimmed:%s\' "$(basename "$in_png")" >> "$out_png"',
+    '    if [ -n "$aligned_png" ]; then',
+    "      printf '\\x89PNG\\r\\n\\x1a\\n' > \"$aligned_png\"",
+    '      printf \'aligned:%s\' "$(basename "$in_png")" >> "$aligned_png"',
+    '    fi',
+    '    echo "TRIMDIMS 320 640 160 320 400 800"',
+    '    exit 0 ;;',
+    '  *) exit 0 ;;',
+    'esac',
+];
+function makeProject(params) {
+    const dir = mkdtempSync(join(tmpdir(), 'ui-fidelity-android-'));
+    tempDirs.push(dir);
+    mkdirSync(join(dir, '.ci', 'inputs'), { recursive: true });
+    const binDir = join(dir, 'bin');
+    mkdirSync(binDir, { recursive: true });
+    const swiftPath = join(binDir, 'swift');
+    writeFileSync(swiftPath, FAKE_SWIFT_LINES.join('\n') + '\n');
+    chmodSync(swiftPath, 0o755);
+    if (params !== undefined) {
+        writeFileSync(join(dir, '.ci', 'inputs', 'params.json'), typeof params === 'string' ? params : JSON.stringify(params));
+    }
+    return { dir, binDir };
+}
+function writeReference(project, basename, label = basename) {
+    writeFileSync(join(project.dir, '.ci', 'inputs', basename), Buffer.concat([PNG_MAGIC, Buffer.from('ref:' + label)]));
+}
+function isPng(filePath) {
+    try {
+        return readFileSync(filePath).subarray(0, 8).equals(PNG_MAGIC);
+    }
+    catch {
+        return false;
+    }
+}
+function artifact(project, relative) {
+    return join(project.dir, '.ci', 'artifacts', relative);
+}
+function tarHeader(name, size, typeflag, mode) {
+    const header = Buffer.alloc(512);
+    header.write(name, 0, 100, 'utf-8');
+    header.write(mode.toString(8).padStart(7, '0') + '\0', 100, 8, 'ascii');
+    header.write('0000000\0', 108, 8, 'ascii');
+    header.write('0000000\0', 116, 8, 'ascii');
+    header.write(size.toString(8).padStart(11, '0') + '\0', 124, 12, 'ascii');
+    header.write('00000000000\0', 136, 12, 'ascii');
+    header.write('        ', 148, 8, 'ascii');
+    header.write(typeflag, 156, 1, 'ascii');
+    header.write('ustar\0' + '00', 257, 8, 'ascii');
+    let checksum = 0;
+    for (const byte of header)
+        checksum += byte;
+    header.write(checksum.toString(8).padStart(6, '0') + '\0 ', 148, 8, 'ascii');
+    return header;
+}
+function makeTarGz(entries) {
+    const blocks = [];
+    for (const entry of entries) {
+        const isDir = entry.name.endsWith('/');
+        const content = Buffer.isBuffer(entry.content)
+            ? entry.content
+            : Buffer.from(entry.content ?? '', 'utf-8');
+        const mode = entry.mode ?? (isDir ? 0o755 : 0o644);
+        blocks.push(tarHeader(entry.name, isDir ? 0 : content.length, isDir ? '5' : '0', mode));
+        if (!isDir && content.length > 0) {
+            const padded = Buffer.alloc(Math.ceil(content.length / 512) * 512);
+            content.copy(padded);
+            blocks.push(padded);
+        }
+    }
+    blocks.push(Buffer.alloc(1024));
+    return gzipSync(Buffer.concat(blocks));
+}
+/** Entries for a well-formed shipped Gradle project under the given root. */
+function gradleProjectEntries(root = 'project') {
+    const prefix = root === '' ? '' : root + '/';
+    const entries = root === '' ? [] : [{ name: prefix }];
+    entries.push({ name: prefix + 'settings.gradle.kts', content: 'rootProject.name = "p"\ninclude(":proof")\n' }, { name: prefix + 'gradlew', content: FAKE_GRADLEW_LINES.join('\n') + '\n', mode: 0o755 }, { name: prefix + 'proof/build.gradle.kts', content: '// module\n' });
+    return entries;
+}
+function stageArchive(project, archive) {
+    writeFileSync(join(project.dir, '.ci', 'inputs', 'package.tar.gz'), Buffer.isBuffer(archive) ? archive : makeTarGz(archive));
+}
+// ---- script build + run ------------------------------------------------------
+async function buildScript(inputs = {}) {
+    const executor = new UiFidelityRenderAndroidStepExecutor();
+    const step = await executor.execute(inputs, {}, testConfig);
+    return step.script;
+}
+function runScript(project, script, env = {}) {
+    return spawnSync('node', ['-e', script], {
+        cwd: project.dir,
+        encoding: 'utf-8',
+        env: {
+            ...process.env,
+            PATH: project.binDir + ':' + (process.env.PATH ?? ''),
+            ...env,
+        },
+    });
+}
+function readResult(project) {
+    return JSON.parse(readFileSync(join(project.dir, '.ci', 'artifacts', 'protocol-result.json'), 'utf-8'));
+}
+describe('UiFidelityRenderAndroidStepExecutor', () => {
+    test('returns a node StepDef named ui-fidelity-render-android', async () => {
+        const executor = new UiFidelityRenderAndroidStepExecutor();
+        const step = await executor.execute({}, {}, testConfig);
+        expect(step.kind).toBe('node');
+        expect(step.name).toBe('ui-fidelity-render-android');
+        expect(step.script.length).toBeGreaterThan(0);
+    });
+});
+describe('android render runtime — params validation', () => {
+    test('writes a contract-shaped, empty-screens result and fails when params.json is absent', async () => {
+        const project = makeProject();
+        const script = await buildScript();
+        const run = runScript(project, script);
+        expect(run.status).toBe(1);
+        const doc = readResult(project);
+        expect(doc.renderer).toBe(ANDROID_RENDERER);
+        expect(doc.error).toBeNull();
+        expect(doc.screens).toEqual([]);
+    });
+    test('fails when params.json is malformed', async () => {
+        const project = makeProject('{ not json');
+        const run = runScript(project, await buildScript());
+        expect(run.status).toBe(1);
+        expect(readResult(project).screens).toEqual([]);
+    });
+});
+describe('android render runtime — reference setup', () => {
+    test('records REFERENCE_MISSING for a screen whose reference is absent', async () => {
+        const project = makeProject({ screens: { XProof: 'x.png' } });
+        const run = runScript(project, await buildScript());
+        expect(run.status).toBe(1);
+        const screen = readResult(project).screens.find((s) => s.screen === 'XProof');
+        expect(screen?.error?.code).toBe('REFERENCE_MISSING');
+        expect(screen?.reference_image_path).toBeNull();
+    });
+    test('copies a present reference into the artifacts and records its path', async () => {
+        const project = makeProject({ screens: { XProof: 'x.png' } });
+        writeReference(project, 'x.png');
+        const run = runScript(project, await buildScript());
+        const screen = readResult(project).screens.find((s) => s.screen === 'XProof');
+        expect(screen?.reference_image_path).toBe('ui-fidelity/references/XProof.png');
+        expect(isPng(artifact(project, 'ui-fidelity/references/XProof.png'))).toBe(true);
+    });
+});
+describe('android render runtime — archive validation', () => {
+    function projectWithRef() {
+        const project = makeProject({ screens: { XProof: 'x.png' } });
+        writeReference(project, 'x.png');
+        return project;
+    }
+    test('missing archive yields ANDROID_ARCHIVE_MISSING with every screen entry present', async () => {
+        const project = projectWithRef();
+        const run = runScript(project, await buildScript());
+        expect(run.status).toBe(1);
+        const doc = readResult(project);
+        expect(doc.error?.code).toBe('ANDROID_ARCHIVE_MISSING');
+        expect(doc.screens.map((s) => s.screen)).toEqual(['XProof']);
+    });
+    test('a corrupt archive yields ANDROID_ARCHIVE_INVALID', async () => {
+        const project = projectWithRef();
+        stageArchive(project, Buffer.from('not a gzip'));
+        const run = runScript(project, await buildScript());
+        expect(readResult(project).error?.code).toBe('ANDROID_ARCHIVE_INVALID');
+        expect(run.status).toBe(1);
+    });
+    test('an archive with dot-dot members yields ANDROID_ARCHIVE_INVALID', async () => {
+        const project = projectWithRef();
+        stageArchive(project, [{ name: '../escape.txt', content: 'x' }]);
+        runScript(project, await buildScript());
+        expect(readResult(project).error?.code).toBe('ANDROID_ARCHIVE_INVALID');
+    });
+    test('an extraction larger than the size bound yields ANDROID_ARCHIVE_TOO_LARGE', async () => {
+        const project = projectWithRef();
+        stageArchive(project, gradleProjectEntries());
+        runScript(project, await buildScript(), { UI_FIDELITY_MAX_PACKAGE_BYTES: '10' });
+        expect(readResult(project).error?.code).toBe('ANDROID_ARCHIVE_TOO_LARGE');
+    });
+    test('an archive without a Gradle settings file yields ANDROID_PROJECT_ROOT_MISSING', async () => {
+        const project = projectWithRef();
+        stageArchive(project, [
+            { name: 'project/' },
+            { name: 'project/build.gradle.kts', content: '// no settings\n' },
+        ]);
+        runScript(project, await buildScript());
+        expect(readResult(project).error?.code).toBe('ANDROID_PROJECT_ROOT_MISSING');
+    });
+    test('archive validation failures fail the step even with zero screens', async () => {
+        const project = makeProject({ screens: {} });
+        const run = runScript(project, await buildScript());
+        expect(run.status).toBe(1);
+        expect(readResult(project).error?.code).toBe('ANDROID_ARCHIVE_MISSING');
+    });
+});
+describe('android render runtime — render + trim (happy path)', () => {
+    test('renders each screen, trims via the shared post-processor, and records the contract shape', async () => {
+        const project = makeProject({ screens: { XProof: 'x.png' } });
+        writeReference(project, 'x.png');
+        stageArchive(project, gradleProjectEntries());
+        const run = runScript(project, await buildScript(), { FAKE_ROBORAZZI_SCREENS: 'XProof' });
+        expect(run.status).toBe(0);
+        const doc = readResult(project);
+        expect(doc.error).toBeNull();
+        const screen = doc.screens.find((s) => s.screen === 'XProof');
+        expect(screen?.status).toBe('rendered');
+        expect(screen?.error).toBeNull();
+        expect(screen?.rendered_image_path).toBe('ui-fidelity/rendered/XProof.png');
+        expect(screen?.aligned_image_path).toBe('ui-fidelity/aligned/XProof.png');
+        // dimensions from the (fake) trim helper's TRIMDIMS, logical_pt = px / scale 2.
+        expect(screen?.dimensions).toEqual({
+            rendered_px: [320, 640],
+            logical_pt: [160, 320],
+            reference_px: [160, 320],
+        });
+        expect(isPng(artifact(project, 'ui-fidelity/rendered/XProof.png'))).toBe(true);
+        expect(isPng(artifact(project, 'ui-fidelity/aligned/XProof.png'))).toBe(true);
+        // The rendered file holds the trim helper's output, not the raw render.
+        expect(readFileSync(artifact(project, 'ui-fidelity/rendered/XProof.png'), 'utf-8')).toContain('trimmed:XProof.png');
+    });
+    test('renders multiple screens independently in one Gradle run', async () => {
+        const project = makeProject({ screens: { XProof: 'x.png', YProof: 'y.png' } });
+        writeReference(project, 'x.png');
+        writeReference(project, 'y.png');
+        stageArchive(project, gradleProjectEntries());
+        const run = runScript(project, await buildScript(), { FAKE_ROBORAZZI_SCREENS: 'XProof,YProof' });
+        expect(run.status).toBe(0);
+        const doc = readResult(project);
+        expect(doc.screens.map((s) => s.status)).toEqual(['rendered', 'rendered']);
+    });
+});
+describe('android render runtime — error isolation', () => {
+    function twoScreenProject() {
+        const project = makeProject({ screens: { XProof: 'x.png', YProof: 'y.png' } });
+        writeReference(project, 'x.png');
+        writeReference(project, 'y.png');
+        stageArchive(project, gradleProjectEntries());
+        return project;
+    }
+    test('a Gradle build failure marks every screen RENDER_UNSUPPORTED', async () => {
+        const project = twoScreenProject();
+        const run = runScript(project, await buildScript(), { FAKE_GRADLE_FAIL: '1' });
+        expect(run.status).toBe(1);
+        const doc = readResult(project);
+        // Build-level failure is reported per screen (not an archive-level error).
+        expect(doc.error).toBeNull();
+        for (const screen of doc.screens) {
+            expect(screen.status).toBe('render_failed');
+            expect(screen.error?.code).toBe('RENDER_UNSUPPORTED');
+            expect(screen.error?.message).toContain('did not build');
+        }
+    });
+    test('a screen whose PNG is not produced is RENDER_FAILED while others render', async () => {
+        const project = twoScreenProject();
+        // Only XProof records a PNG; YProof's is absent.
+        const run = runScript(project, await buildScript(), { FAKE_ROBORAZZI_SCREENS: 'XProof' });
+        expect(run.status).toBe(1);
+        const doc = readResult(project);
+        const x = doc.screens.find((s) => s.screen === 'XProof');
+        const y = doc.screens.find((s) => s.screen === 'YProof');
+        expect(x?.status).toBe('rendered');
+        expect(y?.status).toBe('render_failed');
+        expect(y?.error?.code).toBe('RENDER_FAILED');
+    });
+});
+// The fake gradlew/swift cannot exercise the real Roborazzi/Robolectric render
+// or the CoreGraphics trim. This end-to-end guard ships the committed Roborazzi
+// fixture as the render package and runs the whole step with the real
+// toolchain, proving the tracer bullet: ship a lean Gradle project, get a
+// paired result back. Gated behind CIBUILD_UI_FIDELITY_REAL_ANDROID=1 (the
+// Android analog of the iOS real-Swift gate); needs the Android toolchain +
+// warm Roborazzi caches on the dev machine.
+describe('android render runtime — real toolchain', () => {
+    const realAndroidTest = process.env.CIBUILD_UI_FIDELITY_REAL_ANDROID === '1' ? test : test.skip;
+    // A real 1x1 PNG so the trim helper's reference load/align step succeeds.
+    const ONE_BY_ONE_PNG = Buffer.from('iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAAC0lEQVR42mNk+M9QDwADhgGAWjR9awAAAABJRU5ErkJggg==', 'base64');
+    const FIXTURE_DIR = resolve(dirname(fileURLToPath(import.meta.url)), '../../../../cibuild-runner/scripts/roborazzi-fixture');
+    realAndroidTest('renders the Roborazzi fixture at 720x1280 and returns a paired result', async () => {
+        const dir = mkdtempSync(join(tmpdir(), 'ui-fidelity-android-real-'));
+        tempDirs.push(dir);
+        const project = { dir, binDir: '' };
+        mkdirSync(join(dir, '.ci', 'inputs'), { recursive: true });
+        writeFileSync(join(dir, '.ci', 'inputs', 'params.json'), JSON.stringify({ screens: { XProof: 'ref.png' } }));
+        writeFileSync(join(dir, '.ci', 'inputs', 'ref.png'), ONE_BY_ONE_PNG);
+        // Archive the committed fixture (minus build/.gradle noise) as the
+        // shipped render package, with the real system tar.
+        const stage = mkdtempSync(join(tmpdir(), 'ui-fidelity-android-fixture-'));
+        tempDirs.push(stage);
+        cpSync(FIXTURE_DIR, join(stage, 'project'), { recursive: true });
+        const archive = join(dir, '.ci', 'inputs', 'package.tar.gz');
+        const tar = spawnSync('tar', ['-czf', archive, '-C', stage, '--exclude', '*/build', '--exclude', '*/.gradle', 'project'], { encoding: 'utf-8' });
+        expect(tar.stderr).toBe('');
+        expect(tar.status).toBe(0);
+        const script = await buildScript();
+        const run = spawnSync('node', ['-e', script], {
+            cwd: dir,
+            encoding: 'utf-8',
+            env: { ...process.env },
+            maxBuffer: 64 * 1024 * 1024,
+        });
+        if (run.status !== 0) {
+            // eslint-disable-next-line no-console
+            console.error('STDOUT\n' + run.stdout + '\nSTDERR\n' + run.stderr);
+        }
+        expect(run.status).toBe(0);
+        const doc = readResult(project);
+        expect(doc.error).toBeNull();
+        const screen = doc.screens.find((s) => s.screen === 'XProof');
+        expect(screen?.status).toBe('rendered');
+        expect(screen?.error).toBeNull();
+        // The raw render before trimming is the fixture's full 720x1280 canvas.
+        expect(run.stdout).toContain('XProof: 720x1280');
+        // Paired, contract-shaped artifacts are produced.
+        expect(isPng(artifact(project, 'ui-fidelity/rendered/XProof.png'))).toBe(true);
+        expect(isPng(artifact(project, 'ui-fidelity/aligned/XProof.png'))).toBe(true);
+        expect(screen?.dimensions?.rendered_px[0]).toBeGreaterThan(0);
+        expect(screen?.dimensions?.rendered_px[1]).toBeGreaterThan(0);
+    }, 600_000);
+});
+//# sourceMappingURL=ui-fidelity-render-android.test.js.map

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

@@ -157,34 +157,6 @@ export interface RenderScriptInternals {
     generateProbeSwift(options: HarnessGeneratorOptions): string;
     generateScreenSwift(screen: string, options: HarnessGeneratorOptions): string;
 }
-/**
- * Runtime support for trimming the rendered output (package_source variants).
- *
- * The render entry forces the view into a fixed device-sized frame, so a
- * component smaller than the canvas renders with transparent margins. After a
- * screen renders, crop the PNG in place to the bounding box of its
- * non-transparent pixels, so the rendered artifact is the component itself,
- * tight -- no canvas, no background ambiguity for the human comparing screens.
- *
- * The crop is done by a small CoreGraphics helper run in Swift's
- * script-interpreter mode (so it needs no extra harness target and reuses the
- * one `swift` the runner already has). Best-effort: a trim failure is logged
- * (warn-and-continue) and the untrimmed render is kept -- a cosmetic post-step
- * never fails an otherwise good render. This is prep, not scoring: it produces
- * a tighter image for the human's judgment and computes nothing about
- * fidelity.
- */
-/**
- * The CoreGraphics trim/align helper source, run via
- * `swift <Trim.swift> <in> <out> <aligned> <ref>` (script-interpreter mode).
- * Crops a PNG to its content bounding box (transparent or uniform-background
- * margins), writes a reference-sized aligned copy, and prints a TRIMDIMS line.
- *
- * Exported so a real-toolchain test can exercise the pixel logic directly --
- * the fake `swift` in the unit tests cannot, which is why a background-detection
- * bug shipped twice undetected before a real-pixel guard existed.
- */
-export declare const TRIM_HELPER_SWIFT_SOURCE: string;
 /**
  * Evaluates the embedded generator source and returns the real functions, so
  * unit tests exercise exactly the code that ships inside the runtime script.

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

@@ -1 +1 @@
-{"version":3,"file":"ui-fidelity-render.d.ts","sourceRoot":"","sources":["../../../../src/yaml/steps/ui-fidelity-render.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiDG;AAEH,OAAO,EAAE,gBAAgB,EAAE,MAAM,WAAW,CAAC;AAC7C,OAAO,KAAK,EAAE,OAAO,EAAE,QAAQ,EAAE,MAAM,gBAAgB,CAAC;AACxD,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,wBAAwB,CAAC;AAEpE;;GAEG;AACH,MAAM,WAAW,sBAAsB;IACrC;;;;;;OAMG;IACH,cAAc,CAAC,EAAE,MAAM,GAAG,QAAQ,CAAC;IACnC;;;OAGG;IACH,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB;;;;;OAKG;IACH,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,mFAAmF;IACnF,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,6DAA6D;IAC7D,KAAK,CAAC,EAAE,MAAM,GAAG,MAAM,CAAC;CACzB;AAED;;;;;GAKG;AACH,eAAO,MAAM,mBAAmB,YAAY,CAAC;AAE7C,mFAAmF;AACnF,eAAO,MAAM,aAAa,IAAI,CAAC;AAE/B,iDAAiD;AACjD,eAAO,MAAM,eAAe,6BAA8B,CAAC;AAC3D,MAAM,MAAM,aAAa,GAAG,CAAC,OAAO,eAAe,CAAC,CAAC,MAAM,CAAC,CAAC;AAE7D,sEAAsE;AACtE,eAAO,MAAM,sBAAsB,EAAE,aAAsB,CAAC;AAE5D,+EAA+E;AAC/E,eAAO,MAAM,wBAAwB,mBAAmB,CAAC;AAEzD;;;;;;;GAOG;AACH,eAAO,MAAM,2BAA2B,QAAmB,CAAC;AAE5D,MAAM,WAAW,UAAU;IACzB,KAAK,EAAE,MAAM,CAAC;IACd,MAAM,EAAE,MAAM,CAAC;CAChB;AAED;;;GAGG;AACH,wBAAgB,eAAe,CAAC,KAAK,EAAE,MAAM,GAAG,UAAU,CAWzD;AAED;;;GAGG;AACH,wBAAgB,UAAU,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,GAAG,MAAM,CAQzD;AAED;;;;;;;;;;;GAWG;AACH,MAAM,WAAW,kBAAkB;IACjC,2EAA2E;IAC3E,WAAW,EAAE,MAAM,GAAG,IAAI,CAAC;IAC3B,yEAAyE;IACzE,MAAM,EAAE,MAAM,GAAG,IAAI,CAAC;IACtB,KAAK,EAAE,MAAM,CAAC;IACd,MAAM,EAAE,MAAM,CAAC;IACf,KAAK,EAAE,MAAM,CAAC;IACd,aAAa,CAAC,EAAE,aAAa,CAAC;CAC/B;AAED,4DAA4D;AAC5D,MAAM,WAAW,uBAAuB;IACtC,WAAW,EAAE,MAAM,CAAC;IACpB,UAAU,EAAE,MAAM,CAAC;IACnB,MAAM,EAAE,MAAM,CAAC;IACf,KAAK,EAAE,MAAM,CAAC;IACd,MAAM,EAAE,MAAM,CAAC;IACf,KAAK,EAAE,MAAM,CAAC;CACf;AAED,gFAAgF;AAChF,MAAM,WAAW,qBAAqB;IACpC,kBAAkB,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAAC;IAC1C,2BAA2B,CAAC,OAAO,EAAE,MAAM,EAAE,EAAE,OAAO,EAAE,uBAAuB,GAAG,MAAM,CAAC;IACzF,kBAAkB,CAAC,OAAO,EAAE,uBAAuB,GAAG,MAAM,CAAC;IAC7D,mBAAmB,CAAC,MAAM,EAAE,MAAM,EAAE,OAAO,EAAE,uBAAuB,GAAG,MAAM,CAAC;CAC/E;AA83BD;;;;;;;;;;;;;;;;GAgBG;AACH;;;;;;;;;GASG;AACH,eAAO,MAAM,wBAAwB,EAAE,MAiJpB,CAAC;AAkRpB;;;GAGG;AACH,wBAAgB,wBAAwB,IAAI,qBAAqB,CAShE;AAED;;;;;;;GAOG;AACH,wBAAgB,oBAAoB,CAAC,MAAM,EAAE,kBAAkB,GAAG,MAAM,CAUvE;AAED;;;;GAIG;AACH,qBAAa,4BAA6B,SAAQ,gBAAgB;IAChE,yBAAyB,CACvB,MAAM,EAAE,sBAAsB,EAC9B,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,EAC5B,OAAO,EAAE,QAAQ,GAChB,qBAAqB,EAAE;IAoCpB,OAAO,CACX,MAAM,EAAE,sBAAsB,EAC9B,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,EAC5B,OAAO,EAAE,QAAQ,GAChB,OAAO,CAAC,OAAO,CAAC;CA0DpB"}
+{"version":3,"file":"ui-fidelity-render.d.ts","sourceRoot":"","sources":["../../../../src/yaml/steps/ui-fidelity-render.ts"],"names":[],"mappings":"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"}