@invarn/cibuild 2.9.5 → 2.9.7

package/dist/src/yaml/steps/render-post-processor.js

@@ -1,270 +0,0 @@
-/**
- * Shared render-output post-processor.
- *
- * The single source of truth for turning a freshly rendered PNG into the
- * artifacts the fidelity loop compares: a content-trimmed image, a
- * reference-sized aligned copy, and the reported dimensions (rendered px /
- * logical pt / reference px). It operates on PNGs regardless of how they were
- * produced -- a SwiftUI `ImageRenderer` render or a Compose/Roborazzi render --
- * so crop/align/dimension behavior cannot drift between platforms.
- *
- * The pixel work is the pure-JS trim/align helper in trim-align.ts, invoked
- * through the ci binary (`ci fidelity-trim`) -- the one artifact present on
- * every backend -- so iOS and Android run the SAME bytes on macOS and Linux
- * alike. It replaced an embedded CoreGraphics/ImageIO helper that ran via
- * `swift` in script-interpreter mode and therefore could not run on Linux
- * workers (fidelity-linux 06); the bounding-box, fit-pad, and TRIMDIMS
- * semantics are a faithful port of that helper, guarded by a pixel-identity
- * corpus gate (trim-align-corpus.test.ts).
- *
- * This module is consumed by `ui-fidelity-render.ts` (iOS) and
- * `ui-fidelity-render-android.ts`; the surrounding JS orchestration is spliced
- * into each platform's generated runtime script.
- */
-import { existsSync } from 'node:fs';
-import { dirname, join } from 'node:path';
-import { fileURLToPath } from 'node:url';
-/**
- * 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.
- *
- * 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.
- *
- * NOTE: the comments inside the stage string ship inside generated runtime
- * scripts. Keep them free of platform-toolchain references -- there is a unit
- * gate asserting the stage never mentions the old interpreter.
- */
-export const RENDER_SCRIPT_TRIM_STAGE = '\n// ---- render trimming stage (package_source variants) ----\n' +
-    String.raw `
-// Round to two decimals, keeping the value a plain number.
-function roundTwo(value) {
-  return Math.round(value * 100) / 100;
-}
-
-// Parse the helper's "TRIMDIMS <rW> <rH> <refW> <refH> <srcW> <srcH>
-// [<offX> <offY>]" line (rendered/reference/source px + the crop origin;
-// last one wins). The origin is null on a 6-number line — an old helper may
-// well have trimmed something, so an absent origin means UNKNOWN, never zero.
-function parseTrimDims(stdout) {
-  var lines = String(stdout || '').split('\n');
-  for (var i = lines.length - 1; i >= 0; i--) {
-    var parts = lines[i].trim().split(/\s+/);
-    if (parts[0] === 'TRIMDIMS' && parts.length >= 7) {
-      var nums = [
-        Number(parts[1]), Number(parts[2]), Number(parts[3]),
-        Number(parts[4]), Number(parts[5]), Number(parts[6]),
-      ];
-      if (nums.every(function (n) { return Number.isFinite(n); })) {
-        var offset = null;
-        if (parts.length >= 9) {
-          var offX = Number(parts[7]);
-          var offY = Number(parts[8]);
-          if (Number.isFinite(offX) && Number.isFinite(offY)) {
-            offset = [offX, offY];
-          }
-        }
-        return {
-          rendered: [nums[0], nums[1]],
-          reference: [nums[2], nums[3]],
-          source: [nums[4], nums[5]],
-          offset: offset,
-        };
-      }
-    }
-  }
-  return null;
-}
-
-// Lazily copy the pkg ci binary to a scratch path so the trim can invoke it
-// WITHOUT re-executing process.execPath. Under pkg the generated render script
-// runs as an app-mode child of the ci binary, so process.execPath IS the ci
-// binary -- but pkg refuses to let a binary re-invoke ITSELF as a subcommand:
-// spawning process.execPath forces the child into Node-emulation, where
-// 'fidelity-trim' is treated as a main-module script path ("Cannot find module
-// '<cwd>/fidelity-trim'") and the subcommand dispatch never runs, so the trim
-// silently no-ops and untrimmed renders ship. A COPY of the binary at a
-// different path is NOT seen as a self-exec, so it runs the baked cli entrypoint
-// normally (with the bundled pngjs). Copied once per run; returns null if the
-// copy can't be made, and the caller then degrades to a best-effort no-op trim.
-// Verified on the runner: a copy-spawn dispatches and emits TRIMDIMS, while an
-// execPath self-exec crashes with the module-not-found above.
-var ciTrimBinCopy;
-function ciBinaryCopyForTrim() {
-  if (typeof ciTrimBinCopy !== 'undefined') return ciTrimBinCopy;
-  try {
-    var dest = path.join(os.tmpdir(), 'ci-fidelity-trim-bin');
-    if (!fs.existsSync(dest)) {
-      fs.copyFileSync(process.execPath, dest);
-      fs.chmodSync(dest, 493); // 0o755
-    }
-    ciTrimBinCopy = dest;
-  } catch (copyErr) {
-    ciTrimBinCopy = null;
-  }
-  return ciTrimBinCopy;
-}
-
-// Resolve how to reach the ci CLI's fidelity-trim helper from inside this
-// generated script. Three homes, in order:
-//  1. CIBUILD_CLI_JS -- an explicit JS entrypoint (preview harnesses, tests),
-//     run under the same node executing this script.
-//  2. Under pkg (the production runner path) process.execPath IS the ci binary,
-//     but pkg won't let it re-invoke itself as a subcommand, so spawn a COPY of
-//     it (see ciBinaryCopyForTrim). Fall back to the (best-effort) self-exec if
-//     the copy can't be made.
-//  3. A ci on PATH (brew/npm installs) when not running under pkg.
-function trimHelperInvocation(args) {
-  if (process.env.CIBUILD_CLI_JS) {
-    return {
-      cmd: process.execPath,
-      args: [process.env.CIBUILD_CLI_JS, 'fidelity-trim'].concat(args),
-    };
-  }
-  if (process.pkg) {
-    var copy = ciBinaryCopyForTrim();
-    return {
-      cmd: copy === null ? process.execPath : copy,
-      args: ['fidelity-trim'].concat(args),
-    };
-  }
-  return { cmd: 'ci', args: ['fidelity-trim'].concat(args) };
-}
-
-// Run the trim/align helper (pure JS inside the ci binary; the argv, TRIMDIMS
-// stdout line, and exit codes are the retired CoreGraphics helper's contract).
-function runTrimHelper(args) {
-  var invocation = trimHelperInvocation(args);
-  // Strip pkg's node-invoke sentinel (PKG_EXECPATH) from the child env as a
-  // belt-and-suspenders alongside the copy-binary indirection above, so the
-  // spawned ci runs its baked cli entrypoint and dispatches the subcommand.
-  var childEnv = Object.assign({}, process.env);
-  delete childEnv.PKG_EXECPATH;
-  var result = cp.spawnSync(invocation.cmd, invocation.args, {
-    encoding: 'utf-8',
-    maxBuffer: 16 * 1024 * 1024,
-    env: childEnv,
-  });
-  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;
-}
-
-// Crop the rendered PNG in place to its content bounding box, write an aligned
-// copy resized to the reference, and record the dimensions on the entry.
-// Best-effort: a failure is logged and the untrimmed render is kept.
-function trimRenderedImage(entry, renderedPath) {
-  var alignedRelative = 'ui-fidelity/aligned/' + entry.screen + '.png';
-  var alignedPath = path.resolve(artifactsDir, alignedRelative);
-  var referencePath =
-    entry.reference_image_path === null
-      ? ''
-      : path.resolve(artifactsDir, entry.reference_image_path);
-  try {
-    fs.mkdirSync(path.dirname(alignedPath), { recursive: true });
-  } catch (mkdirError) {
-    // best effort -- the helper reports a missing output dir itself
-  }
-  var result = runTrimHelper([renderedPath, renderedPath, alignedPath, referencePath]);
-  if (result.status !== 0) {
-    logError(
-      'trim failed for ' + renderedPath +
-        ' (continuing with the untrimmed render): ' + sanitizeMessage(outputTail(result))
-    );
-    return;
-  }
-  var dims = parseTrimDims(result.stdout);
-  if (dims !== null) {
-    var scale = CONFIG.scale;
-    entry.dimensions = {
-      rendered_px: dims.rendered,
-      logical_pt: [roundTwo(dims.rendered[0] / scale), roundTwo(dims.rendered[1] / scale)],
-      reference_px: dims.reference[0] > 0 && dims.reference[1] > 0 ? dims.reference : null,
-      // The PRE-TRIM raster: what the renderer actually PAINTED, before cropping
-      // to content. The gate's frame-fill check needs it to tell "the wrapper
-      // never reached its design frame" (a real defect) from "the wrapper filled
-      // the frame in a UNIFORM colour, so the trim cropped its own padding back
-      // off" (not a defect -- and previously indistinguishable, which meant a
-      // padding fix could never close its finding: post-trim px are identical
-      // before and after the fix).
-      source_px: dims.source,
-    };
-    // The crop origin, when the helper reported one: where the trimmed image
-    // sits inside the source raster. The dashboard subtracts it to place the
-    // layout dump's window-space geometry on the trimmed bytes; omitted (not
-    // null) when unknown, so a pre-offset helper's dimensions keep their old
-    // shape exactly.
-    if (dims.offset !== null) {
-      entry.dimensions.trim_offset_px = dims.offset;
-    }
-    // Surface how much margin was removed -- a no-op (source == rendered) means
-    // the view fills an opaque canvas with no transparent or uniform margin.
-    log(
-      'trimmed ' + entry.screen + ': ' + dims.source[0] + 'x' + dims.source[1] +
-        ' -> ' + dims.rendered[0] + 'x' + dims.rendered[1]
-    );
-  }
-  if (fs.existsSync(alignedPath)) {
-    entry.aligned_image_path = alignedRelative;
-  }
-}
-`;
-/**
- * Evaluates the embedded trim-stage source and returns its pure helpers, so
- * unit tests exercise exactly the code that ships inside the runtime script
- * (mirrors getRenderScriptInternals in ui-fidelity-render.ts). `cp`, `process`,
- * `fs`, `os` and `path` are injectable so the invocation/spawn/copy seams are
- * testable; at runtime the stage is spliced into the generated script where
- * those names are `require`d globals. Uninjected deps only matter for branches
- * that dereference them (the pkg copy path), so existing callers can omit them.
- */
-export function getPostProcessorInternals(overrides) {
-    const factory = new Function('cp', 'process', 'fs', 'os', 'path', RENDER_SCRIPT_TRIM_STAGE +
-        '\nreturn { parseTrimDims: parseTrimDims, roundTwo: roundTwo, ' +
-        'trimHelperInvocation: trimHelperInvocation, runTrimHelper: runTrimHelper };');
-    return factory(overrides?.cp, overrides?.processRef ?? process, overrides?.fs, overrides?.os, overrides?.path);
-}
-/**
- * Resolves the on-disk JS entrypoint of this cibuild installation's CLI
- * (dist/cli.cjs), for callers that spawn a generated render script directly
- * (the preview harnesses) and must hand it a working CIBUILD_CLI_JS. Returns
- * null when no built CLI exists nearby (e.g. running from src under jest) --
- * the script then falls back to `ci` on PATH.
- */
-export function resolveCliJsPath() {
-    let moduleDir;
-    try {
-        moduleDir = dirname(fileURLToPath(import.meta.url));
-    }
-    catch {
-        return null;
-    }
-    const candidates = [
-        // Bundled: import.meta.url is shimmed to dist/cli.cjs itself.
-        join(moduleDir, 'cli.cjs'),
-        // Compiled layout: dist/src/yaml/steps/*.js -> dist/cli.cjs.
-        join(moduleDir, '..', '..', '..', 'cli.cjs'),
-    ];
-    for (const candidate of candidates) {
-        try {
-            if (existsSync(candidate))
-                return candidate;
-        }
-        catch {
-            // keep looking
-        }
-    }
-    return null;
-}
-//# sourceMappingURL=render-post-processor.js.map

package/dist/src/yaml/steps/render-post-processor.test.d.ts

@@ -1,13 +0,0 @@
-/**
- * Direct tests for the shared render-output post-processor.
- *
- * The dimension-reporting logic (TRIMDIMS parsing, the logical-pt rounding
- * primitive) and the helper-invocation resolution are pure JS embedded in the
- * trim-stage script. They are evaluated out of the shipped string via
- * getPostProcessorInternals() and tested directly, so these run in every CI
- * pass. The pixel logic itself lives in trim-align.ts (tested ungated in
- * trim-align.test.ts); the Swift-vs-JS equivalence is guarded by the corpus
- * gate in trim-align-corpus.test.ts.
- */
-export {};
-//# sourceMappingURL=render-post-processor.test.d.ts.map

package/dist/src/yaml/steps/render-post-processor.test.d.ts.map

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

package/dist/src/yaml/steps/render-post-processor.test.js

@@ -1,220 +0,0 @@
-/**
- * Direct tests for the shared render-output post-processor.
- *
- * The dimension-reporting logic (TRIMDIMS parsing, the logical-pt rounding
- * primitive) and the helper-invocation resolution are pure JS embedded in the
- * trim-stage script. They are evaluated out of the shipped string via
- * getPostProcessorInternals() and tested directly, so these run in every CI
- * pass. The pixel logic itself lives in trim-align.ts (tested ungated in
- * trim-align.test.ts); the Swift-vs-JS equivalence is guarded by the corpus
- * gate in trim-align-corpus.test.ts.
- */
-import { getPostProcessorInternals, RENDER_SCRIPT_TRIM_STAGE, } from './render-post-processor.js';
-describe('dimension reporting (TRIMDIMS parsing)', () => {
-    const { parseTrimDims } = getPostProcessorInternals();
-    test('parses a well-formed TRIMDIMS line into rendered/reference/source px', () => {
-        const dims = parseTrimDims('TRIMDIMS 320 640 160 320 400 800\n');
-        expect(dims).toEqual({
-            rendered: [320, 640],
-            reference: [160, 320],
-            source: [400, 800],
-            // A 6-number line is the pre-offset helper — the origin is unknown, not
-            // zero: an old binary may well have trimmed something.
-            offset: null,
-        });
-    });
-    test('parses the crop origin from an 8-number TRIMDIMS line', () => {
-        const dims = parseTrimDims('TRIMDIMS 320 640 160 320 400 800 40 77\n');
-        expect(dims).toEqual({
-            rendered: [320, 640],
-            reference: [160, 320],
-            source: [400, 800],
-            offset: [40, 77],
-        });
-    });
-    test('a non-numeric origin degrades to offset null, never to garbage', () => {
-        const dims = parseTrimDims('TRIMDIMS 320 640 160 320 400 800 x y\n');
-        expect(dims?.offset).toBeNull();
-        expect(dims?.rendered).toEqual([320, 640]);
-    });
-    test('returns null when no TRIMDIMS line is present', () => {
-        expect(parseTrimDims('rendered HomeView\nsome other log line\n')).toBeNull();
-        expect(parseTrimDims('')).toBeNull();
-    });
-    test('takes the last TRIMDIMS line and ignores surrounding log noise', () => {
-        const stdout = [
-            'TRIMDIMS 10 10 10 10 10 10',
-            'helper: warming up',
-            'TRIMDIMS 320 640 160 320 400 800',
-            'helper: done',
-        ].join('\n');
-        expect(parseTrimDims(stdout)).toEqual({
-            rendered: [320, 640],
-            reference: [160, 320],
-            source: [400, 800],
-            offset: null,
-        });
-    });
-    test('returns null for a truncated or non-numeric TRIMDIMS line', () => {
-        expect(parseTrimDims('TRIMDIMS 320 640 160 320\n')).toBeNull();
-        expect(parseTrimDims('TRIMDIMS 320 x 160 320 400 800\n')).toBeNull();
-    });
-    test('reports a zero reference pair when no reference was available', () => {
-        // The helper prints "0 0" for the reference when it cannot load one; the
-        // render step maps that to a null reference_px when reporting dimensions.
-        const dims = parseTrimDims('TRIMDIMS 320 640 0 0 400 800\n');
-        expect(dims?.reference).toEqual([0, 0]);
-    });
-});
-describe('logical-pt rounding (roundTwo)', () => {
-    const { roundTwo } = getPostProcessorInternals();
-    test('rounds a logical-point value to two decimals', () => {
-        expect(roundTwo(360 / 2)).toBe(180);
-        expect(roundTwo(343 / 2)).toBe(171.5);
-        expect(roundTwo(100 / 3)).toBe(33.33);
-    });
-});
-// The generated scripts run under whatever node executes the step (a system
-// node, the pkg-built ci binary's bootstrap, or a preview harness), so the
-// stage must resolve how to reach the ci CLI's fidelity-trim helper at run
-// time. The resolution order is load-bearing: an explicit CIBUILD_CLI_JS
-// (preview harnesses, tests) wins, then the pkg self-exec (the production
-// runner path), then a `ci` on PATH.
-describe('trim stage — helper invocation resolution', () => {
-    function internalsWith(processRef) {
-        return getPostProcessorInternals({ processRef });
-    }
-    test('an explicit CIBUILD_CLI_JS entrypoint wins and runs under this node', () => {
-        const { trimHelperInvocation } = internalsWith({
-            env: { CIBUILD_CLI_JS: '/opt/cibuild/cli.cjs' },
-            execPath: '/usr/local/bin/node',
-        });
-        expect(trimHelperInvocation(['in.png', 'out.png'])).toEqual({
-            cmd: '/usr/local/bin/node',
-            args: ['/opt/cibuild/cli.cjs', 'fidelity-trim', 'in.png', 'out.png'],
-        });
-    });
-    // Under pkg (the production runner path — process.pkg IS set, verified on the
-    // runner), process.execPath IS the ci binary, and pkg REFUSES to let a binary
-    // re-invoke itself as a subcommand: spawning process.execPath forces the child
-    // into Node-emulation, where 'fidelity-trim' becomes a main-module script path
-    // ("Cannot find module '<cwd>/fidelity-trim'") and the dispatch never runs —
-    // the trim silently no-ops and untrimmed renders ship. A COPY of the binary at
-    // a different path is not a self-exec, so it runs the baked cli entrypoint.
-    // (Verified on the runner: copy-spawn dispatches + emits TRIMDIMS.)
-    function pkgInternals(opts) {
-        const copyCalls = [];
-        const fakeFs = {
-            existsSync: () => false,
-            copyFileSync: (src, dest) => {
-                copyCalls.push([src, dest]);
-                if (opts?.copyThrows)
-                    throw new Error('EACCES');
-            },
-            chmodSync: () => { },
-        };
-        const fakeOs = { tmpdir: () => '/scratch' };
-        const fakePath = { join: (...parts) => parts.join('/') };
-        const internals = getPostProcessorInternals({
-            processRef: { env: {}, pkg: {}, execPath: '/opt/homebrew/bin/ci' },
-            fs: fakeFs,
-            os: fakeOs,
-            path: fakePath,
-        });
-        return { internals, copyCalls };
-    }
-    test('under pkg it spawns a COPY of the binary (not process.execPath)', () => {
-        const { internals, copyCalls } = pkgInternals();
-        expect(internals.trimHelperInvocation(['in.png', 'out.png', 'aligned.png', 'ref.png'])).toEqual({
-            cmd: '/scratch/ci-fidelity-trim-bin',
-            args: ['fidelity-trim', 'in.png', 'out.png', 'aligned.png', 'ref.png'],
-        });
-        // The copy is made once, from process.execPath.
-        expect(copyCalls).toEqual([['/opt/homebrew/bin/ci', '/scratch/ci-fidelity-trim-bin']]);
-    });
-    test('under pkg it degrades to process.execPath when the binary copy fails', () => {
-        const { internals } = pkgInternals({ copyThrows: true });
-        expect(internals.trimHelperInvocation(['in.png', 'out.png'])).toEqual({
-            cmd: '/opt/homebrew/bin/ci',
-            args: ['fidelity-trim', 'in.png', 'out.png'],
-        });
-    });
-    test('falls back to a ci on PATH when not running under pkg', () => {
-        const { trimHelperInvocation } = internalsWith({
-            env: {},
-            execPath: '/usr/local/bin/node',
-        });
-        expect(trimHelperInvocation(['in.png', 'out.png'])).toEqual({
-            cmd: 'ci',
-            args: ['fidelity-trim', 'in.png', 'out.png'],
-        });
-    });
-    // runTrimHelper strips pkg's node-invoke sentinel (PKG_EXECPATH) from the child
-    // env as belt-and-suspenders alongside the copy-binary indirection, so the
-    // spawned ci runs its baked cli entrypoint rather than re-entering
-    // Node-emulation. (Exercised here via the non-pkg `ci` home for a simple seam.)
-    test('runTrimHelper strips PKG_EXECPATH from the child env', () => {
-        const calls = [];
-        const fakeCp = {
-            spawnSync: (...args) => {
-                calls.push(args);
-                return { status: 0, stdout: 'TRIMDIMS 10 10 0 0 10 10\n', stderr: '' };
-            },
-        };
-        const { runTrimHelper } = getPostProcessorInternals({
-            cp: fakeCp,
-            processRef: {
-                // Node-emulation shape: the sentinel is set but process.pkg is NOT.
-                env: { PKG_EXECPATH: 'PKG_INVOKE_NODEJS', PATH: '/usr/bin:/bin', FOO: 'bar' },
-                execPath: '/usr/local/bin/node',
-                stdout: { write: () => true },
-                stderr: { write: () => true },
-            },
-        });
-        runTrimHelper(['in.png', 'out.png']);
-        expect(calls).toHaveLength(1);
-        const [cmd, , options] = calls[0];
-        // process.pkg undefined → resolves to `ci` on PATH (the real runner path).
-        expect(cmd).toBe('ci');
-        // The child env must have the node-invoke sentinel removed, the rest kept.
-        expect(options.env).toBeDefined();
-        expect(options.env?.PKG_EXECPATH).toBeUndefined();
-        expect(options.env?.PATH).toBe('/usr/bin:/bin');
-        expect(options.env?.FOO).toBe('bar');
-    });
-    test('runTrimHelper reports a spawn error as status 127 with the message appended', () => {
-        const calls = [];
-        const fakeCp = {
-            spawnSync: (...args) => {
-                calls.push(args);
-                return { status: null, stdout: '', stderr: '', error: new Error('ENOENT: ci not found') };
-            },
-        };
-        const { runTrimHelper } = getPostProcessorInternals({
-            cp: fakeCp,
-            processRef: {
-                env: {},
-                execPath: '/usr/local/bin/node',
-                stdout: { write: () => true },
-                stderr: { write: () => true },
-            },
-        });
-        const result = runTrimHelper(['in.png', 'out.png']);
-        expect(result.status).toBe(127);
-        expect(result.stderr).toContain('ENOENT: ci not found');
-        expect(calls).toHaveLength(1);
-        expect(calls[0][0]).toBe('ci');
-    });
-});
-// The whole point of the port (fidelity-linux 06): the shipped trim stage must
-// not reference the platform toolchain in any form — no helper source, no
-// interpreter spawn — so the Android render path can run on Linux workers.
-describe('trim stage — no platform-toolchain invocation remains', () => {
-    test('the stage script has no swift reference at all', () => {
-        expect(RENDER_SCRIPT_TRIM_STAGE.toLowerCase()).not.toContain('swift');
-    });
-    test('the stage spawns the fidelity-trim helper instead', () => {
-        expect(RENDER_SCRIPT_TRIM_STAGE).toContain("'fidelity-trim'");
-    });
-});
-//# sourceMappingURL=render-post-processor.test.js.map

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

@@ -1,23 +0,0 @@
-/**
- * Script step implementation
- */
-import { BaseStepExecutor } from './base.js';
-import type { StepDef, CIConfig } from '../../types.js';
-import type { ValidationRequirement } from '../validation-types.js';
-/**
- * Inputs for script step
- */
-export interface ScriptInputs {
-    content?: string;
-    working_dir?: string;
-    runner_bin?: string;
-}
-/**
- * Script step executor
- * Executes arbitrary shell scripts with optional working directory
- */
-export declare class ScriptStepExecutor extends BaseStepExecutor {
-    getValidationRequirements(inputs: ScriptInputs, _env: Record<string, string>, _config: CIConfig): ValidationRequirement[];
-    execute(inputs: ScriptInputs, env: Record<string, string>, config: CIConfig): Promise<StepDef>;
-}
-//# sourceMappingURL=script.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"script.d.ts","sourceRoot":"","sources":["../../../../src/yaml/steps/script.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,MAAM,wBAAwB,CAAC;AAEpE;;GAEG;AACH,MAAM,WAAW,YAAY;IAC3B,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,UAAU,CAAC,EAAE,MAAM,CAAC;CACrB;AAED;;;GAGG;AACH,qBAAa,kBAAmB,SAAQ,gBAAgB;IACtD,yBAAyB,CACvB,MAAM,EAAE,YAAY,EACpB,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,EAC5B,OAAO,EAAE,QAAQ,GAChB,qBAAqB,EAAE;IAmBpB,OAAO,CAAC,MAAM,EAAE,YAAY,EAAE,GAAG,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,EAAE,MAAM,EAAE,QAAQ,GAAG,OAAO,CAAC,OAAO,CAAC;CAkDrG"}

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

@@ -1,63 +0,0 @@
-/**
- * Script step implementation
- */
-import { BaseStepExecutor } from './base.js';
-/**
- * Script step executor
- * Executes arbitrary shell scripts with optional working directory
- */
-export class ScriptStepExecutor extends BaseStepExecutor {
-    getValidationRequirements(inputs, _env, _config) {
-        const requirements = [];
-        // content is required
-        requirements.push(this.requireInput('content', inputs, 'Script content to execute', 'Provide content input with your script'));
-        // Check runner if non-bash
-        const runner = this.getInput(inputs, 'runner_bin', 'bash');
-        if (runner !== 'bash' && !runner.includes('bash')) {
-            requirements.push(this.requireCommand(runner, `Script runner: ${runner}`, `Install ${runner} or use bash as the runner`));
-        }
-        return requirements;
-    }
-    async execute(inputs, env, config) {
-        const stepName = 'script';
-        // Get script content - this is required
-        const content = this.getRequiredInput(inputs, 'content', stepName);
-        // Get working directory - optional, defaults to current directory
-        const workingDir = this.getInput(inputs, 'working_dir', '');
-        // Get runner bin - optional, defaults to bash
-        const runnerBin = this.getInput(inputs, 'runner_bin', 'bash');
-        const commands = [];
-        // Change to working directory if specified
-        if (workingDir && workingDir.trim() !== '') {
-            commands.push(`# Changing to working directory: ${this.escapeBash(workingDir)}`);
-            commands.push(`cd '${this.escapeBash(workingDir)}'`);
-            commands.push('');
-        }
-        // Add the user's script content
-        commands.push('# User script content');
-        commands.push(content);
-        const script = this.createBashScriptFromCommands(commands, stepName);
-        // Determine the kind based on runner_bin
-        let kind = 'script';
-        if (runnerBin.includes('python')) {
-            kind = 'python';
-        }
-        else if (runnerBin.includes('ruby')) {
-            kind = 'ruby';
-        }
-        else if (runnerBin.includes('node')) {
-            kind = 'node';
-        }
-        // For non-bash runners, return the content directly
-        if (kind !== 'script') {
-            return {
-                id: '',
-                name: stepName,
-                kind,
-                script: content,
-            };
-        }
-        return this.createScriptStep(script, stepName);
-    }
-}
-//# sourceMappingURL=script.js.map

package/dist/src/yaml/steps/spec-validation.test.d.ts

@@ -1,6 +0,0 @@
-/**
- * Validates that step spec YAML files stay in sync with the step registry
- * and that bitrise-map.yml is consistent.
- */
-export {};
-//# sourceMappingURL=spec-validation.test.d.ts.map

package/dist/src/yaml/steps/spec-validation.test.d.ts.map

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