@invarn/cibuild 2.9.5 → 2.9.7

package/dist/src/yaml/steps/cocoapods-skip-if-absent.test.js

@@ -1,132 +0,0 @@
-/**
- * `cocoapods-install` can be asked to skip a project that has no Podfile.
- *
- * The default stays a hard failure, because a pipeline that names this step is
- * asserting the project uses CocoaPods and a missing Podfile is a real error.
- *
- * The iOS template needs the other behaviour: it serves every iOS project and a
- * large share of them resolve dependencies through Swift Package Manager, where
- * "Podfile not found" would be a CocoaPods error in a project that does not use
- * CocoaPods. Until this input existed the template could not use this step at
- * all, so it ran `pod install` from an inline `script@1.0.0` — which put it out
- * of reach of the refused-fetch retry this step carries. That is the gap this
- * closes, and it is why the release order matters: this must ship before the
- * template is pointed at the step, or every SPM-only iOS repo breaks.
- */
-import { describe, test, expect } from '@jest/globals';
-import { CocoapodsInstallStepExecutor } from './ios-deps.js';
-import { testConfig } from './test-config.js';
-const build = async (inputs = {}) => {
-    const executor = new CocoapodsInstallStepExecutor();
-    const result = await executor.execute(inputs, {}, testConfig);
-    return result.script;
-};
-/** The body of the `if [ ! -f "Podfile" ]` branch, which is what changes. */
-const absentBranch = (script) => {
-    const lines = script.split('\n');
-    const start = lines.findIndex((l) => l.includes('if [ ! -f "Podfile" ]'));
-    expect(start).toBeGreaterThanOrEqual(0);
-    const end = lines.findIndex((l, i) => i > start && l.trim() === 'fi');
-    return lines.slice(start, end + 1).join('\n');
-};
-describe('by default a missing Podfile is still an error', () => {
-    test('exits non-zero', async () => {
-        expect(absentBranch(await build())).toContain('exit 1');
-    });
-    test('says what was not found', async () => {
-        expect(absentBranch(await build())).toContain('Podfile not found');
-    });
-    test('an explicit false is the same as omitting it', async () => {
-        expect(absentBranch(await build({ skip_if_absent: false }))).toContain('exit 1');
-    });
-});
-describe('skip_if_absent turns it into a clean no-op', () => {
-    test('exits zero instead of one', async () => {
-        const branch = absentBranch(await build({ skip_if_absent: true }));
-        expect(branch).toContain('exit 0');
-        expect(branch).not.toContain('exit 1');
-    });
-    test('says it skipped rather than that something failed', async () => {
-        const branch = absentBranch(await build({ skip_if_absent: true }));
-        expect(branch).toContain('skipping CocoaPods install');
-        expect(branch).not.toContain('Error');
-    });
-    test('still runs pod install when a Podfile IS present', async () => {
-        // The skip is a branch, not a mode — the rest of the step is untouched.
-        const script = await build({ skip_if_absent: true });
-        expect(script).toContain('POD_INVOCATION');
-        expect(script).toContain('$POD_INVOCATION $POD_CMD');
-    });
-    test('still wraps the pod fetch in the refused-fetch retry', async () => {
-        // This is the entire point of letting the template use the step.
-        const script = await build({ skip_if_absent: true });
-        expect(script).toContain('cibuild_fetch_was_refused');
-        expect(script).toContain('CIBUILD_FETCH_MAX_ATTEMPTS');
-    });
-    test('still chooses between bundle exec and bare pod', async () => {
-        const script = await build({ skip_if_absent: true });
-        expect(script).toContain('USE_BUNDLE_EXEC');
-        expect(script).toContain('$BUNDLE_CMD exec pod');
-    });
-});
-/**
- * The inline script the template used did two things, not one: it skipped a
- * project with no Podfile, AND it looked for that Podfile beside the Xcode
- * project rather than at the repository root. Both have to exist as inputs or
- * the template cannot be switched — about a quarter of iOS repositories keep
- * the app one directory down, and template inputs interpolate variables, not
- * `$(dirname …)`.
- */
-describe('project_path finds the Podfile beside the project', () => {
-    test('changes into the project directory, not the repo root', async () => {
-        const script = await build({ project_path: 'ios/MyApp.xcworkspace' });
-        expect(script).toContain(`WORK_DIR="$(dirname 'ios/MyApp.xcworkspace')"`);
-        expect(script).toContain('cd "$WORK_DIR"');
-    });
-    test('does not fall back to CIBUILD_SOURCE_DIR when it is given', async () => {
-        const script = await build({ project_path: 'ios/MyApp.xcworkspace' });
-        expect(script).not.toContain('cd "$CIBUILD_SOURCE_DIR"');
-    });
-    test('still falls back to CIBUILD_SOURCE_DIR when nothing is given', async () => {
-        expect(await build()).toContain('cd "$CIBUILD_SOURCE_DIR"');
-    });
-    test('an explicit source_root_path still wins over project_path', async () => {
-        const script = await build({
-            project_path: 'ios/MyApp.xcworkspace',
-            source_root_path: 'somewhere/else',
-        });
-        expect(script).toContain(`cd 'somewhere/else'`);
-        expect(script).not.toContain('dirname');
-    });
-    test('composes with skip_if_absent, which is how the template uses it', async () => {
-        const script = await build({ project_path: 'ios/MyApp.xcworkspace', skip_if_absent: true });
-        expect(script).toContain(`WORK_DIR="$(dirname 'ios/MyApp.xcworkspace')"`);
-        expect(absentBranch(script)).toContain('exit 0');
-        expect(script).toContain('cibuild_fetch_was_refused');
-    });
-});
-/**
- * The exact input combination the iOS template sends. Pinned here because the
- * template lives in another repository and deploys on a different cadence, so
- * nothing else would notice this step drifting away from what it sends.
- */
-describe('the iOS template combination', () => {
-    const templateInputs = {
-        project_path: 'MyApp.xcworkspace',
-        skip_if_absent: true,
-        command: 'install --repo-update',
-    };
-    test('produces pod install --repo-update, flags intact', async () => {
-        const script = await build(templateInputs);
-        expect(script).toContain('POD_CMD="install --repo-update"');
-    });
-    test('runs that under the refused-fetch retry, exactly once', async () => {
-        const script = await build(templateInputs);
-        expect(script).toContain('$POD_INVOCATION $POD_CMD');
-        expect(script.split('CIBUILD_FETCH_MAX_ATTEMPTS=').length - 1).toBe(1);
-    });
-    test('skips instead of failing when the repo has no Podfile', async () => {
-        expect(absentBranch(await build(templateInputs))).toContain('exit 0');
-    });
-});
-//# sourceMappingURL=cocoapods-skip-if-absent.test.js.map

package/dist/src/yaml/steps/envstore-loader.test.d.ts

@@ -1,15 +0,0 @@
-/**
- * The envstore loader carried by every generated step.
- *
- * These tests drive the *reader* — the preamble `createBashScript` prepends —
- * directly, with hostile envstore content written by hand. Going through a
- * producer such as git-clone would only prove the one value that producer
- * happens to write; the defect lives in the reader, so the reader is what gets
- * the hostile input.
- *
- * Each case actually runs bash. Assertions are made on files the script body
- * writes with `printf '%s'`, not on stdout, so a value's own newlines and
- * quoting cannot be confused with the test's framing.
- */
-export {};
-//# sourceMappingURL=envstore-loader.test.d.ts.map

package/dist/src/yaml/steps/envstore-loader.test.d.ts.map

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

package/dist/src/yaml/steps/envstore-loader.test.js

@@ -1,143 +0,0 @@
-/**
- * The envstore loader carried by every generated step.
- *
- * These tests drive the *reader* — the preamble `createBashScript` prepends —
- * directly, with hostile envstore content written by hand. Going through a
- * producer such as git-clone would only prove the one value that producer
- * happens to write; the defect lives in the reader, so the reader is what gets
- * the hostile input.
- *
- * Each case actually runs bash. Assertions are made on files the script body
- * writes with `printf '%s'`, not on stdout, so a value's own newlines and
- * quoting cannot be confused with the test's framing.
- */
-import { describe, test, expect, beforeEach, afterEach } from '@jest/globals';
-import { spawnSync } from 'child_process';
-import { mkdtempSync, mkdirSync, writeFileSync, readFileSync, rmSync, existsSync } from 'fs';
-import { join } from 'path';
-import { tmpdir } from 'os';
-import { BaseStepExecutor } from './base.js';
-/** Exposes the protected preamble builder so the reader can be tested on its own. */
-class PreambleProbe extends BaseStepExecutor {
-    async execute(_inputs, _env, _config) {
-        throw new Error('not used');
-    }
-    build(scriptContent) {
-        return this.createBashScript(scriptContent, 'envstore-loader-probe');
-    }
-}
-describe('envstore loader', () => {
-    let workDir;
-    beforeEach(() => {
-        workDir = mkdtempSync(join(tmpdir(), 'envstore-loader-'));
-    });
-    afterEach(() => {
-        rmSync(workDir, { recursive: true, force: true });
-    });
-    /**
-     * Writes an envstore, runs the generated preamble over it, and captures the
-     * named variables as the step body sees them.
-     */
-    function run(envs, capture, extraBody = '') {
-        const storePath = join(workDir, 'envstore.json');
-        const outDir = join(workDir, 'captured');
-        mkdirSync(outDir, { recursive: true });
-        writeFileSync(storePath, JSON.stringify({ envs: envs.map(e => ({ ...e, sensitive: false })) }), 'utf-8');
-        const body = [
-            ...capture.map(name => `printf '%s' "\${${name}-}" > "$CAPTURE_DIR/${name}"`),
-            extraBody,
-        ].join('\n');
-        const scriptPath = join(workDir, 'step.sh');
-        writeFileSync(scriptPath, new PreambleProbe().build(body), 'utf-8');
-        const proc = spawnSync('bash', [scriptPath], {
-            cwd: workDir,
-            encoding: 'utf-8',
-            env: {
-                ...process.env,
-                ENVMAN_ENVSTORE_PATH: storePath,
-                CAPTURE_DIR: outDir,
-            },
-        });
-        return {
-            status: proc.status,
-            stderr: proc.stderr ?? '',
-            captured(name) {
-                const file = join(outDir, name);
-                return existsSync(file) ? readFileSync(file, 'utf-8') : undefined;
-            },
-        };
-    }
-    test('a value containing newlines round-trips byte for byte', () => {
-        const body = 'first line\nsecond line\nthird line';
-        const result = run([{ key: 'GIT_CLONE_COMMIT_MESSAGE_BODY', value: body }], ['GIT_CLONE_COMMIT_MESSAGE_BODY']);
-        expect(result.status).toBe(0);
-        expect(result.captured('GIT_CLONE_COMMIT_MESSAGE_BODY')).toBe(body);
-    });
-    test('security: a value whose lines look like assignments sets nothing', () => {
-        const hostile = 'looks harmless\nPATH=/tmp/attacker-controlled\nNODE_OPTIONS=--require=/tmp/evil.js';
-        const result = run([{ key: 'GIT_CLONE_COMMIT_MESSAGE_BODY', value: hostile }], ['GIT_CLONE_COMMIT_MESSAGE_BODY', 'PATH', 'NODE_OPTIONS']);
-        expect(result.status).toBe(0);
-        // The value arrives intact...
-        expect(result.captured('GIT_CLONE_COMMIT_MESSAGE_BODY')).toBe(hostile);
-        // ...and none of its lines became a variable. Both are compared against
-        // what the parent environment held, which is what "unchanged" means here:
-        // the test runner itself sets NODE_OPTIONS.
-        expect(result.captured('PATH')).toBe(process.env.PATH ?? '');
-        expect(result.captured('NODE_OPTIONS')).toBe(process.env.NODE_OPTIONS ?? '');
-        expect(result.captured('NODE_OPTIONS')).not.toContain('/tmp/evil.js');
-    });
-    test('awkward bytes in a value all survive unchanged', () => {
-        const cases = [
-            { key: 'HAS_EQUALS', value: 'a=b=c' },
-            { key: 'HAS_QUOTES', value: `single ' double " both '"` },
-            { key: 'HAS_BACKTICKS', value: 'a `whoami` b' },
-            { key: 'HAS_SUBSHELL', value: 'a $(whoami) b ${HOME} c' },
-            { key: 'HAS_TRAILING_NEWLINE', value: 'ends with a newline\n' },
-            { key: 'HAS_LONE_CR', value: 'before\rafter' },
-            { key: 'HAS_BACKSLASHES', value: 'C:\\path\\to\\thing and \\n literal' },
-            { key: 'HAS_LEADING_SPACE', value: '   padded   ' },
-        ];
-        const result = run(cases, cases.map(c => c.key));
-        expect(result.status).toBe(0);
-        for (const { key, value } of cases) {
-            expect({ key, value: result.captured(key) }).toEqual({ key, value });
-        }
-    });
-    test('a non-identifier key is skipped without failing the step under set -e', () => {
-        const result = run([
-            { key: 'not a valid identifier', value: 'x' },
-            { key: '2_LEADING_DIGIT', value: 'x' },
-            { key: '', value: 'x' },
-            { key: 'GOOD_KEY', value: 'kept' },
-        ], ['GOOD_KEY'], 'echo reached-the-end');
-        expect(result.status).toBe(0);
-        expect(result.captured('GOOD_KEY')).toBe('kept');
-        expect(result.stderr).not.toContain('not a valid identifier');
-    });
-    test('regression: a multi-line commit message does not end the step', () => {
-        // The shape that killed the first real proof on 2026-08-30: git-clone
-        // publishes the commit body, and every later step died loading it.
-        const result = run([
-            { key: 'GIT_CLONE_COMMIT_MESSAGE_SUBJECT', value: 'Add Invarn pipeline' },
-            {
-                key: 'GIT_CLONE_COMMIT_MESSAGE_BODY',
-                value: 'cibuild sets CIBUILD_GIT_BRANCH, so pre-execution validation asked for a\nvalue nothing provides.\n\nSecond paragraph.',
-            },
-        ], ['GIT_CLONE_COMMIT_MESSAGE_SUBJECT'], 'echo step-completed');
-        expect(result.status).toBe(0);
-        expect(result.captured('GIT_CLONE_COMMIT_MESSAGE_SUBJECT')).toBe('Add Invarn pipeline');
-        expect(result.stderr).not.toContain('not a valid identifier');
-    });
-    test('an absent envstore leaves the step to run normally', () => {
-        const scriptPath = join(workDir, 'no-store.sh');
-        writeFileSync(scriptPath, new PreambleProbe().build('echo ran'), 'utf-8');
-        const proc = spawnSync('bash', [scriptPath], {
-            cwd: workDir,
-            encoding: 'utf-8',
-            env: { ...process.env, ENVMAN_ENVSTORE_PATH: join(workDir, 'missing.json') },
-        });
-        expect(proc.status).toBe(0);
-        expect(proc.stdout).toContain('ran');
-    });
-});
-//# sourceMappingURL=envstore-loader.test.js.map

package/dist/src/yaml/steps/fastlane.d.ts

@@ -1,27 +0,0 @@
-/**
- * Fastlane step: run a fastlane lane
- */
-import { BaseStepExecutor } from './base.js';
-import type { StepDef, CIConfig } from '../../types.js';
-import type { ValidationRequirement, StepOutput } from '../validation-types.js';
-export interface FastlaneInputs {
-    /** Fastlane lane to run (required) */
-    lane?: string;
-    /** Working directory (parent of fastlane directory) */
-    work_dir?: string;
-    /** Update fastlane gem before run (true/false) */
-    update_fastlane?: string;
-    /** Enable verbose logging (yes/no) */
-    verbose_log?: string;
-    /** Enable collecting cache files (yes/no) */
-    enable_cache?: string;
-}
-/**
- * Runs a fastlane lane with Gemfile detection and optional gem update.
- */
-export declare class FastlaneStepExecutor extends BaseStepExecutor {
-    getValidationRequirements(_inputs: FastlaneInputs, _env: Record<string, string>, _config: CIConfig): ValidationRequirement[];
-    getOutputs(): StepOutput[];
-    execute(inputs: FastlaneInputs, _env: Record<string, string>, _config: CIConfig): Promise<StepDef>;
-}
-//# sourceMappingURL=fastlane.d.ts.map

package/dist/src/yaml/steps/fastlane.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"fastlane.d.ts","sourceRoot":"","sources":["../../../../src/yaml/steps/fastlane.ts"],"names":[],"mappings":"AAAA;;GAEG;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,UAAU,EAAE,MAAM,wBAAwB,CAAC;AAEhF,MAAM,WAAW,cAAc;IAC7B,sCAAsC;IACtC,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,uDAAuD;IACvD,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,kDAAkD;IAClD,eAAe,CAAC,EAAE,MAAM,CAAC;IACzB,sCAAsC;IACtC,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,6CAA6C;IAC7C,YAAY,CAAC,EAAE,MAAM,CAAC;CACvB;AAED;;GAEG;AACH,qBAAa,oBAAqB,SAAQ,gBAAgB;IACxD,yBAAyB,CACvB,OAAO,EAAE,cAAc,EACvB,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,EAC5B,OAAO,EAAE,QAAQ,GAChB,qBAAqB,EAAE;IAM1B,UAAU,IAAI,UAAU,EAAE;IAIpB,OAAO,CAAC,MAAM,EAAE,cAAc,EAAE,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,EAAE,OAAO,EAAE,QAAQ,GAAG,OAAO,CAAC,OAAO,CAAC;CAuEzG"}

package/dist/src/yaml/steps/fastlane.js

@@ -1,79 +0,0 @@
-/**
- * Fastlane step: run a fastlane lane
- */
-import { BaseStepExecutor } from './base.js';
-/**
- * Runs a fastlane lane with Gemfile detection and optional gem update.
- */
-export class FastlaneStepExecutor extends BaseStepExecutor {
-    getValidationRequirements(_inputs, _env, _config) {
-        return [
-            this.requireCommand('fastlane', 'fastlane is required (install via gem install fastlane or Bundler)'),
-        ];
-    }
-    getOutputs() {
-        return [];
-    }
-    async execute(inputs, _env, _config) {
-        const stepName = 'fastlane';
-        const lane = this.getRequiredInput(inputs, 'lane', stepName);
-        const workDir = this.getInput(inputs, 'work_dir', '');
-        const updateFastlane = this.getInput(inputs, 'update_fastlane', 'true') === 'true';
-        const verboseLog = ['yes', 'true'].includes(this.getInput(inputs, 'verbose_log', 'no'));
-        const enableCache = ['yes', 'true'].includes(this.getInput(inputs, 'enable_cache', 'yes'));
-        const commands = [];
-        commands.push('# fastlane — run a fastlane lane');
-        commands.push('echo "🚀 Running fastlane..."');
-        commands.push('');
-        // Change to working directory if specified
-        if (workDir) {
-            commands.push(`cd '${this.escapeBash(workDir)}'`);
-            commands.push('');
-        }
-        // Detect Gemfile for bundle exec
-        commands.push('# Detect Gemfile for bundle exec');
-        commands.push('USE_BUNDLE_EXEC="false"');
-        commands.push('if [ -f "Gemfile" ] || [ -f "Gemfile.lock" ]; then');
-        commands.push('  if grep -q "fastlane" Gemfile.lock 2>/dev/null || grep -q "fastlane" Gemfile 2>/dev/null; then');
-        commands.push('    USE_BUNDLE_EXEC="true"');
-        commands.push('    echo "Gemfile detected with fastlane — using bundle exec"');
-        commands.push('  fi');
-        commands.push('fi');
-        commands.push('');
-        // Optionally update fastlane
-        if (updateFastlane) {
-            commands.push('# Update fastlane gem (skipped if Gemfile manages it)');
-            commands.push('if [ "$USE_BUNDLE_EXEC" = "true" ]; then');
-            commands.push('  echo "Gemfile present — running bundle install instead of gem update"');
-            commands.push('  bundle install');
-            commands.push('else');
-            commands.push('  echo "Updating fastlane gem..."');
-            commands.push('  gem install fastlane --no-document');
-            commands.push('fi');
-            commands.push('');
-        }
-        // Build the fastlane command
-        const verboseFlag = verboseLog ? ' --verbose' : '';
-        commands.push('# Run fastlane');
-        commands.push('if [ "$USE_BUNDLE_EXEC" = "true" ]; then');
-        commands.push(`  bundle exec fastlane ${this.escapeBash(lane)}${verboseFlag}`);
-        commands.push('else');
-        commands.push(`  fastlane ${this.escapeBash(lane)}${verboseFlag}`);
-        commands.push('fi');
-        commands.push('');
-        // Cache collection
-        if (enableCache) {
-            commands.push('# Collect cache paths');
-            commands.push('if [ -f "Podfile.lock" ]; then');
-            commands.push('  echo "Cache: Pods directory detected"');
-            commands.push('fi');
-            commands.push('if [ -f "Cartfile.resolved" ]; then');
-            commands.push('  echo "Cache: Carthage directory detected"');
-            commands.push('fi');
-        }
-        commands.push('echo "✅ fastlane lane complete"');
-        const script = this.createBashScriptFromCommands(commands, stepName);
-        return this.createScriptStep(script, stepName);
-    }
-}
-//# sourceMappingURL=fastlane.js.map

package/dist/src/yaml/steps/fidelity-aspect-guard.d.ts

@@ -1,53 +0,0 @@
-/**
- * Fidelity aspect-ratio guard.
- *
- * One named composable per state is the authoring norm; the failure this
- * catches is the opposite — several states stacked into one composable, which
- * renders far taller (or wider) than the single-state reference it is paired
- * against. That shows up as a sharp divergence between the rendered and
- * reference aspect ratios, well before a human reads the diff.
- *
- * The guard is a pure comparison over the dimensions the render already
- * reports (`rendered_px`, `reference_px`). It emits a WARNING when the
- * divergence exceeds a documented fold factor — it never fails the render, and
- * it stays silent when there is no reference to compare against.
- */
-/** Pixel dimensions as `[width, height]`. */
-export type PixelSize = [number, number];
-/**
- * Fold factor beyond which a rendered/reference aspect-ratio divergence is
- * worth a warning. A faithful single-state wrapper sits near 1.0; trim and
- * reference alignment nudge it a few percent; a re-stacked 2-up wrapper roughly
- * doubles one dimension and lands near 2.0. 1.5 catches the stack while
- * tolerating the wobble.
- */
-export declare const ASPECT_RATIO_WARN_FACTOR = 1.5;
-/** The outcome of comparing a rendered aspect ratio to its reference. */
-export interface AspectRatioCheck {
-    /** True only when both sizes are present and strictly positive. */
-    comparable: boolean;
-    /** Rendered width/height, or null when not comparable. */
-    renderedAspect: number | null;
-    /** Reference width/height, or null when not comparable. */
-    referenceAspect: number | null;
-    /**
-     * Symmetric divergence `max(r/ref, ref/r)` (≥ 1), or null when not
-     * comparable. 1.0 means identical proportions.
-     */
-    divergence: number | null;
-    /** True when comparable and the divergence exceeds the fold factor. */
-    warn: boolean;
-}
-/**
- * Compares a rendered size against its reference size. Returns a
- * non-warning, non-comparable result when either size is missing or
- * non-positive — the guard only speaks when it has two real frames to compare.
- */
-export declare function evaluateAspectRatio(renderedPx: PixelSize | null, referencePx: PixelSize | null, factor?: number): AspectRatioCheck;
-/**
- * Human/agent-readable warning line for a divergent screen, or null when the
- * screen does not warrant one. The caller decides where to surface it (preview
- * result, preflight output) — it is advisory, never a failure.
- */
-export declare function formatAspectRatioWarning(screen: string, check: AspectRatioCheck): string | null;
-//# sourceMappingURL=fidelity-aspect-guard.d.ts.map

package/dist/src/yaml/steps/fidelity-aspect-guard.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"fidelity-aspect-guard.d.ts","sourceRoot":"","sources":["../../../../src/yaml/steps/fidelity-aspect-guard.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AAEH,6CAA6C;AAC7C,MAAM,MAAM,SAAS,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;AAEzC;;;;;;GAMG;AACH,eAAO,MAAM,wBAAwB,MAAM,CAAC;AAE5C,yEAAyE;AACzE,MAAM,WAAW,gBAAgB;IAC/B,mEAAmE;IACnE,UAAU,EAAE,OAAO,CAAC;IACpB,0DAA0D;IAC1D,cAAc,EAAE,MAAM,GAAG,IAAI,CAAC;IAC9B,2DAA2D;IAC3D,eAAe,EAAE,MAAM,GAAG,IAAI,CAAC;IAC/B;;;OAGG;IACH,UAAU,EAAE,MAAM,GAAG,IAAI,CAAC;IAC1B,uEAAuE;IACvE,IAAI,EAAE,OAAO,CAAC;CACf;AAaD;;;;GAIG;AACH,wBAAgB,mBAAmB,CACjC,UAAU,EAAE,SAAS,GAAG,IAAI,EAC5B,WAAW,EAAE,SAAS,GAAG,IAAI,EAC7B,MAAM,GAAE,MAAiC,GACxC,gBAAgB,CAyBlB;AAED;;;;GAIG;AACH,wBAAgB,wBAAwB,CACtC,MAAM,EAAE,MAAM,EACd,KAAK,EAAE,gBAAgB,GACtB,MAAM,GAAG,IAAI,CAUf"}

package/dist/src/yaml/steps/fidelity-aspect-guard.js

@@ -1,72 +0,0 @@
-/**
- * Fidelity aspect-ratio guard.
- *
- * One named composable per state is the authoring norm; the failure this
- * catches is the opposite — several states stacked into one composable, which
- * renders far taller (or wider) than the single-state reference it is paired
- * against. That shows up as a sharp divergence between the rendered and
- * reference aspect ratios, well before a human reads the diff.
- *
- * The guard is a pure comparison over the dimensions the render already
- * reports (`rendered_px`, `reference_px`). It emits a WARNING when the
- * divergence exceeds a documented fold factor — it never fails the render, and
- * it stays silent when there is no reference to compare against.
- */
-/**
- * Fold factor beyond which a rendered/reference aspect-ratio divergence is
- * worth a warning. A faithful single-state wrapper sits near 1.0; trim and
- * reference alignment nudge it a few percent; a re-stacked 2-up wrapper roughly
- * doubles one dimension and lands near 2.0. 1.5 catches the stack while
- * tolerating the wobble.
- */
-export const ASPECT_RATIO_WARN_FACTOR = 1.5;
-function isPositiveSize(size) {
-    return (Array.isArray(size) &&
-        size.length === 2 &&
-        Number.isFinite(size[0]) &&
-        Number.isFinite(size[1]) &&
-        size[0] > 0 &&
-        size[1] > 0);
-}
-/**
- * Compares a rendered size against its reference size. Returns a
- * non-warning, non-comparable result when either size is missing or
- * non-positive — the guard only speaks when it has two real frames to compare.
- */
-export function evaluateAspectRatio(renderedPx, referencePx, factor = ASPECT_RATIO_WARN_FACTOR) {
-    if (!isPositiveSize(renderedPx) || !isPositiveSize(referencePx)) {
-        return {
-            comparable: false,
-            renderedAspect: null,
-            referenceAspect: null,
-            divergence: null,
-            warn: false,
-        };
-    }
-    const renderedAspect = renderedPx[0] / renderedPx[1];
-    const referenceAspect = referencePx[0] / referencePx[1];
-    const divergence = Math.max(renderedAspect / referenceAspect, referenceAspect / renderedAspect);
-    return {
-        comparable: true,
-        renderedAspect,
-        referenceAspect,
-        divergence,
-        warn: divergence > factor,
-    };
-}
-/**
- * Human/agent-readable warning line for a divergent screen, or null when the
- * screen does not warrant one. The caller decides where to surface it (preview
- * result, preflight output) — it is advisory, never a failure.
- */
-export function formatAspectRatioWarning(screen, check) {
-    if (!check.warn || check.divergence === null)
-        return null;
-    const r = check.renderedAspect?.toFixed(2);
-    const ref = check.referenceAspect?.toFixed(2);
-    return (`Screen "${screen}" renders at aspect ratio ${r}:1 but its reference is ` +
-        `${ref}:1 (${check.divergence.toFixed(1)}× divergence). This often means ` +
-        `multiple states were stacked into one composable — author one named ` +
-        `composable per state instead.`);
-}
-//# sourceMappingURL=fidelity-aspect-guard.js.map

package/dist/src/yaml/steps/fidelity-aspect-guard.test.d.ts

@@ -1,11 +0,0 @@
-/**
- * Unit tests for the fidelity aspect-ratio guard.
- *
- * A wrapper that stacks several states into one composable renders far taller
- * (or wider) than its single-state reference, so its aspect ratio diverges
- * sharply from the reference's. The guard is the early warning for that
- * re-stacking: it compares the rendered vs reference aspect ratios and flags a
- * divergence beyond a documented fold factor — a WARNING, never a failure.
- */
-export {};
-//# sourceMappingURL=fidelity-aspect-guard.test.d.ts.map

package/dist/src/yaml/steps/fidelity-aspect-guard.test.d.ts.map

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

package/dist/src/yaml/steps/fidelity-aspect-guard.test.js

@@ -1,50 +0,0 @@
-/**
- * Unit tests for the fidelity aspect-ratio guard.
- *
- * A wrapper that stacks several states into one composable renders far taller
- * (or wider) than its single-state reference, so its aspect ratio diverges
- * sharply from the reference's. The guard is the early warning for that
- * re-stacking: it compares the rendered vs reference aspect ratios and flags a
- * divergence beyond a documented fold factor — a WARNING, never a failure.
- */
-import { describe, test, expect } from '@jest/globals';
-import { evaluateAspectRatio, ASPECT_RATIO_WARN_FACTOR, } from './fidelity-aspect-guard.js';
-describe('evaluateAspectRatio', () => {
-    test('does not warn when rendered and reference aspect ratios match', () => {
-        // A faithful single-state banner: same proportions as its reference.
-        const check = evaluateAspectRatio([720, 1280], [360, 640]);
-        expect(check.comparable).toBe(true);
-        expect(check.warn).toBe(false);
-        expect(check.divergence).toBeCloseTo(1, 5);
-    });
-    test('warns when a stacked render is far off the reference aspect ratio', () => {
-        // The canonical miss: two banner states stacked in one Column render at
-        // ~2.2:1, judged against a single-state ~4.76:1 reference.
-        const rendered = [880, 400]; // 2.2:1
-        const reference = [952, 200]; // 4.76:1
-        const check = evaluateAspectRatio(rendered, reference);
-        expect(check.comparable).toBe(true);
-        expect(check.warn).toBe(true);
-        expect(check.divergence).toBeCloseTo(4.76 / 2.2, 1);
-    });
-    test('tolerates a small alignment/trim wobble within the fold factor', () => {
-        // Trim + reference alignment can nudge dimensions a few percent; that must
-        // not trip the warning.
-        const check = evaluateAspectRatio([726, 1280], [360, 640]);
-        expect(check.warn).toBe(false);
-    });
-    test('is not comparable when there is no reference', () => {
-        const check = evaluateAspectRatio([720, 1280], null);
-        expect(check.comparable).toBe(false);
-        expect(check.warn).toBe(false);
-    });
-    test('is not comparable when a dimension is zero or negative', () => {
-        expect(evaluateAspectRatio([720, 0], [360, 640]).comparable).toBe(false);
-        expect(evaluateAspectRatio([720, 1280], [0, 640]).comparable).toBe(false);
-    });
-    test('exposes a sane default fold factor', () => {
-        expect(ASPECT_RATIO_WARN_FACTOR).toBeGreaterThan(1);
-        expect(ASPECT_RATIO_WARN_FACTOR).toBeLessThan(2);
-    });
-});
-//# sourceMappingURL=fidelity-aspect-guard.test.js.map