@invarn/cibuild 1.8.0 → 1.9.0

package/dist/src/runner.d.ts

@@ -8,7 +8,7 @@ export declare class StepExecutionError extends Error {
 export declare class PipelineRunner {
     private config;
     constructor(config: CIConfig);
-    runStep(step: StepDef): Promise<void>;
+    runStep(step: StepDef, stepNumber?: number): Promise<void>;
     private formatDuration;
     validatePipeline(pipeline: PipelineDef): void;
     displayWarnings(warnings: string[], skippedSteps: number): void;

package/dist/src/runner.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"runner.d.ts","sourceRoot":"","sources":["../../src/runner.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,OAAO,EAAE,WAAW,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAC;AAKjE,qBAAa,kBAAmB,SAAQ,KAAK;IAElC,MAAM,EAAE,MAAM;IACd,QAAQ,EAAE,MAAM;IAChB,QAAQ,EAAE,MAAM;gBAFhB,MAAM,EAAE,MAAM,EACd,QAAQ,EAAE,MAAM,EAChB,QAAQ,EAAE,MAAM;CAK1B;AAED,qBAAa,cAAc;IACb,OAAO,CAAC,MAAM;gBAAN,MAAM,EAAE,QAAQ;IAE9B,OAAO,CAAC,IAAI,EAAE,OAAO,GAAG,OAAO,CAAC,IAAI,CAAC;IAsI3C,OAAO,CAAC,cAAc;IAYtB,gBAAgB,CAAC,QAAQ,EAAE,WAAW,GAAG,IAAI;IAwB7C,eAAe,CAAC,QAAQ,EAAE,MAAM,EAAE,EAAE,YAAY,EAAE,MAAM,GAAG,IAAI;IAczD,WAAW,CAAC,QAAQ,EAAE,WAAW,EAAE,QAAQ,CAAC,EAAE,MAAM,EAAE,EAAE,YAAY,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;CA0CpG"}
+{"version":3,"file":"runner.d.ts","sourceRoot":"","sources":["../../src/runner.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,OAAO,EAAE,WAAW,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAC;AAMjE,qBAAa,kBAAmB,SAAQ,KAAK;IAElC,MAAM,EAAE,MAAM;IACd,QAAQ,EAAE,MAAM;IAChB,QAAQ,EAAE,MAAM;gBAFhB,MAAM,EAAE,MAAM,EACd,QAAQ,EAAE,MAAM,EAChB,QAAQ,EAAE,MAAM;CAK1B;AAED,qBAAa,cAAc;IACb,OAAO,CAAC,MAAM;gBAAN,MAAM,EAAE,QAAQ;IAE9B,OAAO,CAAC,IAAI,EAAE,OAAO,EAAE,UAAU,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAoJhE,OAAO,CAAC,cAAc;IAYtB,gBAAgB,CAAC,QAAQ,EAAE,WAAW,GAAG,IAAI;IAwB7C,eAAe,CAAC,QAAQ,EAAE,MAAM,EAAE,EAAE,YAAY,EAAE,MAAM,GAAG,IAAI;IAczD,WAAW,CAAC,QAAQ,EAAE,WAAW,EAAE,QAAQ,CAAC,EAAE,MAAM,EAAE,EAAE,YAAY,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;CA2CpG"}

package/dist/src/runner.js

@@ -2,6 +2,7 @@ import { spawn } from "node:child_process";
 import { dirname, join, resolve } from "node:path";
 import { unlinkSync, existsSync, writeFileSync, chmodSync, mkdtempSync, rmSync, mkdirSync } from "node:fs";
 import { tmpdir } from "node:os";
+import { formatStepMarker, shouldEmitStepMarker } from "./step-marker.js";
 // Use absolute path for envstore so it works regardless of cd in scripts
 const ENVMAN_ENVSTORE_PATH = resolve(process.cwd(), ".ci", ".envstore.json");
 export class StepExecutionError extends Error {
@@ -21,7 +22,21 @@ export class PipelineRunner {
     constructor(config) {
         this.config = config;
     }
-    async runStep(step) {
+    async runStep(step, stepNumber) {
+        // Emit the INVARN_STEP marker before any other output so the
+        // dashboard's step-progress parser sees a step boundary even when
+        // the step's own logs are silent. Pairs with the parser at
+        // `lib/shared/step-progress.ts` in the Invarn repo. `stepNumber`
+        // is optional to keep `runStep` backward-compatible for direct
+        // callers (lib consumers) that don't run inside a pipeline loop.
+        //
+        // Gated on INVARN_RUNNER=1: cibuild is a public npm package
+        // (@invarn/cibuild) and must not leak Invarn's log-parsing protocol
+        // into external users' stdout. The Invarn runner opts in by exporting
+        // the var into the sandbox; see cibuild-runner/src/runner.ts.
+        if (stepNumber != null && shouldEmitStepMarker()) {
+            console.log(formatStepMarker(stepNumber, step.name));
+        }
         console.log(`\n[${step.id}] Running: ${step.name}`);
         console.log("─".repeat(60));
         const startTime = Date.now();
@@ -209,13 +224,14 @@ export -f envman
         }
         this.validatePipeline(pipeline);
         const stepsMap = new Map(pipeline.steps.map((s) => [s.id, s]));
-        for (const stepId of pipeline.stepsOrder) {
+        for (let i = 0; i < pipeline.stepsOrder.length; i++) {
+            const stepId = pipeline.stepsOrder[i];
             const step = stepsMap.get(stepId);
             if (!step) {
                 throw new Error(`Step ${stepId} not found`);
             }
             try {
-                await this.runStep(step);
+                await this.runStep(step, i + 1);
             }
             catch (err) {
                 if (step.isSkippable && err instanceof StepExecutionError) {

package/dist/src/step-marker.d.ts

@@ -0,0 +1,12 @@
+export declare function formatStepMarker(stepNumber: number, stepName: string): string;
+/**
+ * cibuild ships publicly on npm as `@invarn/cibuild`. Emitting the marker
+ * unconditionally would leak Invarn's log-parsing protocol into external
+ * users' stdout. The Invarn runner (cibuild-runner) opts in by exporting
+ * INVARN_RUNNER=1 into the sandbox; everywhere else this returns false
+ * and the runner stays quiet.
+ *
+ * Strict equality to "1" — no truthy parsing — keeps the contract crisp.
+ */
+export declare function shouldEmitStepMarker(env?: NodeJS.ProcessEnv): boolean;
+//# sourceMappingURL=step-marker.d.ts.map

package/dist/src/step-marker.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"step-marker.d.ts","sourceRoot":"","sources":["../../src/step-marker.ts"],"names":[],"mappings":"AAcA,wBAAgB,gBAAgB,CAAC,UAAU,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,MAAM,CAE7E;AAED;;;;;;;;GAQG;AACH,wBAAgB,oBAAoB,CAAC,GAAG,GAAE,MAAM,CAAC,UAAwB,GAAG,OAAO,CAElF"}

package/dist/src/step-marker.js

@@ -0,0 +1,29 @@
+/**
+ * Producer side of the INVARN_STEP marker contract.
+ *
+ * The dashboard's `lib/shared/step-progress.ts` parses runtime logs for
+ * lines matching `/▸ INVARN_STEP:(\d+):(.+)/` to populate
+ * `BuildEnrichment.parsedSteps`. The runner emits one marker per step
+ * via `console.log(formatStepMarker(...))` before executing it, so every
+ * build (agent or not) gets symmetric step telemetry.
+ *
+ * Step name is embedded as-is. The dashboard parser uses `(.+)` (greedy),
+ * so step names containing colons (`build:android:debug`) round-trip.
+ */
+const STEP_MARKER_PREFIX = '▸ INVARN_STEP';
+export function formatStepMarker(stepNumber, stepName) {
+    return `${STEP_MARKER_PREFIX}:${stepNumber}:${stepName}`;
+}
+/**
+ * cibuild ships publicly on npm as `@invarn/cibuild`. Emitting the marker
+ * unconditionally would leak Invarn's log-parsing protocol into external
+ * users' stdout. The Invarn runner (cibuild-runner) opts in by exporting
+ * INVARN_RUNNER=1 into the sandbox; everywhere else this returns false
+ * and the runner stays quiet.
+ *
+ * Strict equality to "1" — no truthy parsing — keeps the contract crisp.
+ */
+export function shouldEmitStepMarker(env = process.env) {
+    return env.INVARN_RUNNER === '1';
+}
+//# sourceMappingURL=step-marker.js.map

package/dist/src/step-marker.test.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Unit tests for the INVARN_STEP marker formatter.
+ *
+ * The dashboard's `lib/shared/step-progress.ts` parses runtime logs for
+ * lines matching `/▸ INVARN_STEP:(\d+):(.+)/` to populate
+ * `BuildEnrichment.parsedSteps`. This formatter is the producer side of
+ * that contract — the runner emits one marker per step before executing
+ * it so non-agent builds get symmetric step telemetry.
+ */
+export {};
+//# sourceMappingURL=step-marker.test.d.ts.map

package/dist/src/step-marker.test.d.ts.map

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

package/dist/src/step-marker.test.js

@@ -0,0 +1,45 @@
+/**
+ * Unit tests for the INVARN_STEP marker formatter.
+ *
+ * The dashboard's `lib/shared/step-progress.ts` parses runtime logs for
+ * lines matching `/▸ INVARN_STEP:(\d+):(.+)/` to populate
+ * `BuildEnrichment.parsedSteps`. This formatter is the producer side of
+ * that contract — the runner emits one marker per step before executing
+ * it so non-agent builds get symmetric step telemetry.
+ */
+import { describe, test, expect } from '@jest/globals';
+import { formatStepMarker, shouldEmitStepMarker } from './step-marker.js';
+describe('formatStepMarker', () => {
+    test('formats a step number and name as the wire-format marker', () => {
+        expect(formatStepMarker(1, 'install-deps')).toBe('▸ INVARN_STEP:1:install-deps');
+    });
+    test('preserves colons in the step name (the dashboard parser is greedy on the trailing capture)', () => {
+        expect(formatStepMarker(2, 'build:android:debug')).toBe('▸ INVARN_STEP:2:build:android:debug');
+    });
+    test('uses 1-indexed step numbers (matches the agent generator and dashboard parser)', () => {
+        expect(formatStepMarker(3, 'lint')).toBe('▸ INVARN_STEP:3:lint');
+    });
+});
+/**
+ * Gate that keeps the marker off when cibuild is used outside Invarn
+ * infrastructure. cibuild ships publicly on npm as @invarn/cibuild and
+ * must not leak Invarn's log-parsing protocol into external users' stdout.
+ * The Invarn runner (cibuild-runner) opts in by exporting INVARN_RUNNER=1
+ * into the sandbox alongside CIBUILD_NON_INTERACTIVE / CI.
+ */
+describe('shouldEmitStepMarker', () => {
+    test('returns true only when INVARN_RUNNER === "1"', () => {
+        expect(shouldEmitStepMarker({ INVARN_RUNNER: '1' })).toBe(true);
+    });
+    test('returns false when INVARN_RUNNER is absent (public/external cibuild use)', () => {
+        expect(shouldEmitStepMarker({})).toBe(false);
+    });
+    test('returns false for INVARN_RUNNER values that are not literally "1"', () => {
+        // Strict equality keeps the wire-level handshake unambiguous — no truthy parsing.
+        expect(shouldEmitStepMarker({ INVARN_RUNNER: '0' })).toBe(false);
+        expect(shouldEmitStepMarker({ INVARN_RUNNER: 'true' })).toBe(false);
+        expect(shouldEmitStepMarker({ INVARN_RUNNER: '' })).toBe(false);
+        expect(shouldEmitStepMarker({ INVARN_RUNNER: ' 1 ' })).toBe(false);
+    });
+});
+//# sourceMappingURL=step-marker.test.js.map

package/dist/src/yaml/steps/xcode-destination.d.ts

@@ -0,0 +1,47 @@
+/**
+ * Resolves `destination: "auto"` for xcode-* step executors.
+ *
+ * `auto` queries `xcrun simctl list devices available --json` and picks the
+ * newest iPhone in the highest installed iOS runtime, returning a canonical
+ * destination string for xcodebuild: `platform=iOS Simulator,OS=<v>,name=<n>`.
+ *
+ * The host shell-out lives in {@link resolveAutoDestination} so the parser
+ * ({@link resolveAutoDestinationFromSimctlJson}) stays pure and unit-testable
+ * against fixture JSON.
+ */
+/** Failure mode for "auto" resolution. Surfaces as the step's failure reason. */
+export declare class AutoDestinationError extends Error {
+    constructor(message: string);
+}
+/**
+ * Pure helper — parses `xcrun simctl list devices available --json` output
+ * and returns the canonical destination string.
+ *
+ * Selection rules (per spike spec):
+ *  - Highest available iOS runtime: highest semver among keys matching
+ *    `com.apple.CoreSimulator.SimRuntime.iOS-*`.
+ *  - Newest iPhone: device whose name starts with "iPhone" and has the highest
+ *    model number suffix (e.g. "iPhone 16 Pro Max" > "iPhone 15" >
+ *    "iPhone SE (3rd generation)"). Ties at the highest model number prefer
+ *    "Pro Max", then "Pro", then plain.
+ */
+export declare function resolveAutoDestinationFromSimctlJson(rawJson: string): string;
+/**
+ * Pass-through resolver used by xcode-* executors.
+ *
+ * Returns the literal value unchanged when it isn't the magic string `"auto"`.
+ * When it is, delegates to a resolver (default: {@link resolveAutoDestination},
+ * which shells out to `xcrun simctl`). The resolver injection point exists for
+ * tests, so executor-level tests can verify the "auto" branch without
+ * touching the host's xcrun.
+ */
+export declare function resolveDestinationInput(value: string, autoResolver?: () => string): string;
+/**
+ * Shell-out wrapper: runs `xcrun simctl list devices available --json` and
+ * delegates the parse to {@link resolveAutoDestinationFromSimctlJson}.
+ *
+ * Surfaces the documented failure modes (xcrun missing, simctl failure,
+ * no iPhone runtime) as {@link AutoDestinationError}.
+ */
+export declare function resolveAutoDestination(): string;
+//# sourceMappingURL=xcode-destination.d.ts.map

package/dist/src/yaml/steps/xcode-destination.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"xcode-destination.d.ts","sourceRoot":"","sources":["../../../../src/yaml/steps/xcode-destination.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAgBH,iFAAiF;AACjF,qBAAa,oBAAqB,SAAQ,KAAK;gBACjC,OAAO,EAAE,MAAM;CAI5B;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,oCAAoC,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,CA4B5E;AAiID;;;;;;;;GAQG;AACH,wBAAgB,uBAAuB,CACrC,KAAK,EAAE,MAAM,EACb,YAAY,GAAE,MAAM,MAA+B,GAClD,MAAM,CAGR;AAED;;;;;;GAMG;AACH,wBAAgB,sBAAsB,IAAI,MAAM,CA4B/C"}

package/dist/src/yaml/steps/xcode-destination.js

@@ -0,0 +1,202 @@
+/**
+ * Resolves `destination: "auto"` for xcode-* step executors.
+ *
+ * `auto` queries `xcrun simctl list devices available --json` and picks the
+ * newest iPhone in the highest installed iOS runtime, returning a canonical
+ * destination string for xcodebuild: `platform=iOS Simulator,OS=<v>,name=<n>`.
+ *
+ * The host shell-out lives in {@link resolveAutoDestination} so the parser
+ * ({@link resolveAutoDestinationFromSimctlJson}) stays pure and unit-testable
+ * against fixture JSON.
+ */
+import { execFileSync } from 'node:child_process';
+/** Failure mode for "auto" resolution. Surfaces as the step's failure reason. */
+export class AutoDestinationError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = 'AutoDestinationError';
+    }
+}
+/**
+ * Pure helper — parses `xcrun simctl list devices available --json` output
+ * and returns the canonical destination string.
+ *
+ * Selection rules (per spike spec):
+ *  - Highest available iOS runtime: highest semver among keys matching
+ *    `com.apple.CoreSimulator.SimRuntime.iOS-*`.
+ *  - Newest iPhone: device whose name starts with "iPhone" and has the highest
+ *    model number suffix (e.g. "iPhone 16 Pro Max" > "iPhone 15" >
+ *    "iPhone SE (3rd generation)"). Ties at the highest model number prefer
+ *    "Pro Max", then "Pro", then plain.
+ */
+export function resolveAutoDestinationFromSimctlJson(rawJson) {
+    let parsed;
+    try {
+        parsed = JSON.parse(rawJson);
+    }
+    catch {
+        throw new AutoDestinationError('Failed to resolve destination: auto — xcrun simctl returned no usable output. ' +
+            'Pin a specific destination string instead.');
+    }
+    const iosRuntime = pickHighestIosRuntime(parsed.devices ?? {});
+    if (!iosRuntime) {
+        throw new AutoDestinationError('Failed to resolve destination: auto — no iPhone simulator runtimes are installed. ' +
+            'Install one via Xcode → Settings → Platforms.');
+    }
+    const iphone = pickNewestIphone(iosRuntime.devices);
+    if (!iphone) {
+        throw new AutoDestinationError('Failed to resolve destination: auto — no iPhone simulator runtimes are installed. ' +
+            'Install one via Xcode → Settings → Platforms.');
+    }
+    return `platform=iOS Simulator,OS=${iosRuntime.version},name=${iphone.name}`;
+}
+const IOS_RUNTIME_PREFIX = 'com.apple.CoreSimulator.SimRuntime.iOS-';
+/**
+ * Picks the runtime with the highest semver among
+ * `com.apple.CoreSimulator.SimRuntime.iOS-*` keys whose device list contains
+ * at least one available iPhone.
+ */
+function pickHighestIosRuntime(devicesByRuntime) {
+    const candidates = [];
+    for (const [key, devices] of Object.entries(devicesByRuntime)) {
+        if (!key.startsWith(IOS_RUNTIME_PREFIX))
+            continue;
+        const versionSuffix = key.slice(IOS_RUNTIME_PREFIX.length); // e.g. "18-0"
+        const tuple = parseVersionTuple(versionSuffix.replace(/-/g, '.'));
+        if (tuple.length === 0)
+            continue;
+        const availableIphones = devices.filter((d) => isAvailableIphone(d));
+        if (availableIphones.length === 0)
+            continue;
+        candidates.push({
+            versionTuple: tuple,
+            version: tuple.join('.'),
+            devices: availableIphones,
+        });
+    }
+    if (candidates.length === 0)
+        return null;
+    candidates.sort((a, b) => compareTuples(b.versionTuple, a.versionTuple));
+    const winner = candidates[0];
+    return { version: winner.version, devices: winner.devices };
+}
+function isAvailableIphone(device) {
+    if (device.isAvailable === false)
+        return false;
+    return typeof device.name === 'string' && device.name.startsWith('iPhone');
+}
+/** Parses "18.0" or "18.0.1" into [18, 0] / [18, 0, 1]. */
+function parseVersionTuple(raw) {
+    const parts = raw.split('.');
+    const out = [];
+    for (const p of parts) {
+        const n = Number.parseInt(p, 10);
+        if (!Number.isFinite(n))
+            return [];
+        out.push(n);
+    }
+    return out;
+}
+function compareTuples(a, b) {
+    const len = Math.max(a.length, b.length);
+    for (let i = 0; i < len; i++) {
+        const av = a[i] ?? 0;
+        const bv = b[i] ?? 0;
+        if (av !== bv)
+            return av - bv;
+    }
+    return 0;
+}
+const VARIANT_RANK = [
+    { pattern: /\bpro\s+max\b/i, rank: 3 },
+    { pattern: /\bpro\b/i, rank: 2 },
+    { pattern: /\bplus\b/i, rank: 1 },
+];
+/**
+ * Picks the newest iPhone by model-number suffix, with Pro Max > Pro > plain
+ * tie-breaking. iPhones with no numeric model (e.g. "iPhone SE (3rd generation)")
+ * are ranked below numeric models.
+ */
+function pickNewestIphone(devices) {
+    const scored = [];
+    for (const device of devices) {
+        if (!isAvailableIphone(device))
+            continue;
+        scored.push({
+            device,
+            model: extractIphoneModelNumber(device.name),
+            variantRank: extractVariantRank(device.name),
+        });
+    }
+    if (scored.length === 0)
+        return null;
+    scored.sort((a, b) => {
+        if (a.model !== b.model)
+            return b.model - a.model;
+        if (a.variantRank !== b.variantRank)
+            return b.variantRank - a.variantRank;
+        return a.device.name.localeCompare(b.device.name);
+    });
+    return scored[0].device;
+}
+/**
+ * "iPhone 16 Pro Max" → 16. "iPhone 15" → 15. "iPhone SE (3rd generation)" → -1.
+ * We look at the token immediately after "iPhone".
+ */
+function extractIphoneModelNumber(name) {
+    const match = name.match(/^iPhone\s+(\d+)/i);
+    if (!match)
+        return -1;
+    return Number.parseInt(match[1], 10);
+}
+function extractVariantRank(name) {
+    for (const { pattern, rank } of VARIANT_RANK) {
+        if (pattern.test(name))
+            return rank;
+    }
+    return 0;
+}
+/**
+ * Pass-through resolver used by xcode-* executors.
+ *
+ * Returns the literal value unchanged when it isn't the magic string `"auto"`.
+ * When it is, delegates to a resolver (default: {@link resolveAutoDestination},
+ * which shells out to `xcrun simctl`). The resolver injection point exists for
+ * tests, so executor-level tests can verify the "auto" branch without
+ * touching the host's xcrun.
+ */
+export function resolveDestinationInput(value, autoResolver = resolveAutoDestination) {
+    if (value !== 'auto')
+        return value;
+    return autoResolver();
+}
+/**
+ * Shell-out wrapper: runs `xcrun simctl list devices available --json` and
+ * delegates the parse to {@link resolveAutoDestinationFromSimctlJson}.
+ *
+ * Surfaces the documented failure modes (xcrun missing, simctl failure,
+ * no iPhone runtime) as {@link AutoDestinationError}.
+ */
+export function resolveAutoDestination() {
+    let raw;
+    try {
+        raw = execFileSync('xcrun', ['simctl', 'list', 'devices', 'available', '--json'], {
+            encoding: 'utf-8',
+            stdio: ['ignore', 'pipe', 'pipe'],
+        });
+    }
+    catch (err) {
+        if (err && (err.code === 'ENOENT' || /not found/i.test(err.message ?? ''))) {
+            throw new AutoDestinationError('xcrun not available on this runner; cannot resolve destination: auto. ' +
+                'Pin a specific destination string instead.');
+        }
+        throw new AutoDestinationError('Failed to resolve destination: auto — xcrun simctl returned no usable output. ' +
+            'Pin a specific destination string instead.');
+    }
+    if (!raw || raw.trim() === '') {
+        throw new AutoDestinationError('Failed to resolve destination: auto — xcrun simctl returned no usable output. ' +
+            'Pin a specific destination string instead.');
+    }
+    return resolveAutoDestinationFromSimctlJson(raw);
+}
+//# sourceMappingURL=xcode-destination.js.map

package/dist/src/yaml/steps/xcode-destination.test.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Tests for the shared "auto destination" resolver.
+ *
+ * The resolver consumes the JSON `xcrun simctl list devices available --json`
+ * would produce on a macOS runner, and returns the canonical
+ * `platform=iOS Simulator,OS=<v>,name=<name>` string to feed to xcodebuild.
+ */
+export {};
+//# sourceMappingURL=xcode-destination.test.d.ts.map

package/dist/src/yaml/steps/xcode-destination.test.d.ts.map

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