@expo-harmony/cli 55.0.26-harmony.1 → 55.0.26-harmony.10

package/build/prebuild/index.js

@@ -0,0 +1,51 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.command = void 0;
+const command_1 = require("../command");
+const errors_1 = require("../errors");
+const projectLock_1 = require("../projectLock");
+const options_1 = require("./options");
+const command = async (argv, io) => {
+    const args = (0, command_1.parseCommandArgs)(args => (0, options_1.parsePrebuildArgs)(args, { allowProject: true }), argv, io);
+    if (!args)
+        return 0;
+    const { projectRoot: root, options } = args;
+    const { check, clean, passthrough } = options;
+    if (check && passthrough.length) {
+        throw new errors_1.HarmonyCliError('ERR_HARMONY_CONFIG_INVALID', '--check cannot be combined with mutating prebuild options.');
+    }
+    return (0, projectLock_1.withHarmonyProjectLockAsync)(root, check ? 'prebuild-check' : 'prebuild', async () => {
+        if (clean) {
+            const { assertSafeCleanTarget } = await import('./clean.js');
+            await assertSafeCleanTarget(root);
+        }
+        const { doctorAsync, formatDoctor } = await import('../doctor/doctor.js');
+        const doctor = await doctorAsync(root, {
+            requireBuildTools: false,
+            validateGeneratedProject: !clean,
+            validateModules: false,
+        });
+        if (!doctor.ok) {
+            io.error(formatDoctor(doctor));
+            throw new errors_1.HarmonyCliError('ERR_HARMONY_DOCTOR_FAILED', 'Harmony doctor found blocking errors.', {
+                operation: 'doctor',
+            });
+        }
+        for (const item of doctor.checks.filter(item => item.status === 'warn'))
+            io.warn(`! ${item.message}`);
+        if (check) {
+            const { checkAsync } = await import('./check.js');
+            const result = await checkAsync(root);
+            if (result.clean)
+                io.log('Harmony CNG output is up to date.');
+            else
+                for (const change of result.changes)
+                    io.log(`${change.type}: ${change.path}`);
+            return result.clean ? 0 : 2;
+        }
+        const { prebuildParsedAsync } = await import('./prebuild.js');
+        await prebuildParsedAsync(root, passthrough);
+        return 0;
+    });
+};
+exports.command = command;

package/build/prebuild/options.d.ts

@@ -0,0 +1,10 @@
+declare function parsePrebuildArgs(argv: string[], options?: {
+    allowProject?: boolean;
+}): {
+    check: boolean;
+    clean: boolean;
+    help: boolean;
+    passthrough: string[];
+    project: string;
+};
+export { parsePrebuildArgs };

package/build/prebuild/options.js

@@ -0,0 +1,50 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parsePrebuildArgs = parsePrebuildArgs;
+const errors_1 = require("../errors");
+const args_1 = require("../args");
+const PrebuildOptions = {
+    ...args_1.CommonOptions,
+    'bun': { type: 'boolean' },
+    'check': { type: 'boolean' },
+    'clean': { type: 'boolean' },
+    'no-install': { type: 'boolean' },
+    'npm': { type: 'boolean' },
+    'platform': { short: 'p', type: 'string' },
+    'pnpm': { type: 'boolean' },
+    'skip-dependency-update': { type: 'string' },
+    'template': { short: 't', type: 'string' },
+    'yarn': { type: 'boolean' },
+};
+function parsePrebuildArgs(argv, options = {}) {
+    const { positionals, values } = (0, args_1.parseArgs)(PrebuildOptions, argv);
+    if (values.platform !== undefined) {
+        throw new errors_1.HarmonyCliError('ERR_HARMONY_CONFIG_INVALID', '--platform is fixed to harmony by expo-harmony.', { operation: 'parse-arguments' });
+    }
+    if (values.template !== undefined) {
+        throw new errors_1.HarmonyCliError('ERR_HARMONY_CONFIG_INVALID', '--template is managed by expo-harmony.', { operation: 'parse-arguments' });
+    }
+    if (positionals.length > (options.allowProject ? 1 : 0)) {
+        const unexpected = positionals[options.allowProject ? 1 : 0];
+        throw new errors_1.HarmonyCliError('ERR_HARMONY_CONFIG_INVALID', `Unexpected prebuild positional argument: ${unexpected}`, { operation: 'parse-arguments' });
+    }
+    const packageManagerFlags = ['npm', 'yarn', 'pnpm', 'bun'].filter(name => values[name]);
+    if (packageManagerFlags.length > 1) {
+        throw new errors_1.HarmonyCliError('ERR_HARMONY_CONFIG_INVALID', 'Choose at most one package manager: --npm, --yarn, --pnpm, or --bun.', { operation: 'parse-arguments' });
+    }
+    const passthrough = [];
+    for (const name of ['clean', 'npm', 'yarn', 'pnpm', 'bun', 'no-install']) {
+        if (values[name])
+            passthrough.push(`--${name}`);
+    }
+    if (values['skip-dependency-update'] !== undefined) {
+        passthrough.push('--skip-dependency-update', values['skip-dependency-update']);
+    }
+    return {
+        check: Boolean(values.check),
+        clean: Boolean(values.clean),
+        help: Boolean(values.help),
+        passthrough,
+        project: positionals[0],
+    };
+}

package/build/prebuild/prebuild.d.ts

@@ -0,0 +1,6 @@
+interface PrebuildOptions {
+    buildType?: 'debug' | 'release';
+    capture?: boolean;
+}
+declare function prebuildParsedAsync(projectRoot: string, passthrough: string[], options?: PrebuildOptions): Promise<import("../process").ProcessResult>;
+export { prebuildParsedAsync };

package/build/prebuild/prebuild.js

@@ -0,0 +1,70 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.prebuildParsedAsync = prebuildParsedAsync;
+const node_fs_1 = __importDefault(require("node:fs"));
+const errors_1 = require("../errors");
+const bare_1 = require("../native/bare");
+const process_1 = require("../process");
+const projectLock_1 = require("../projectLock");
+const expo_1 = require("../expo");
+const toolchain_1 = require("../native/toolchain");
+const project_1 = require("../native/project");
+const clean_1 = require("./clean");
+const template_1 = require("./template");
+async function prebuildParsedUnlockedAsync(projectRoot, passthrough, options = {}) {
+    if ((0, bare_1.isBareHarmonyProject)(projectRoot)) {
+        throw new errors_1.HarmonyCliError('ERR_HARMONY_BARE_PREBUILD', 'This Harmony project is manually maintained. Build it directly; prebuild cannot overwrite a bare project.', { operation: 'prebuild' });
+    }
+    if (passthrough.includes('--clean'))
+        await (0, clean_1.assertSafeCleanTarget)(projectRoot);
+    const expo = (0, expo_1.resolveExpoCli)(projectRoot);
+    const packed = await (0, template_1.packAsync)(projectRoot);
+    try {
+        const result = await (0, process_1.spawnAsync)(process.execPath, [
+            expo.cliPath,
+            'prebuild', projectRoot,
+            '--platform', 'harmony',
+            '--template', packed.tarball,
+            ...passthrough,
+        ], {
+            capture: Boolean(options.capture),
+            cwd: projectRoot,
+            env: {
+                ...(0, toolchain_1.createHarmonyToolchainEnv)(),
+                ...packed.env,
+                ...(options.buildType ? { EXPO_HARMONY_BUILD_TYPE: options.buildType } : {}),
+            },
+            operation: 'expo-prebuild',
+            outputLimit: 4 * 1024 * 1024,
+        });
+        if (result.code !== 0) {
+            const diagnostics = options.capture ? (0, process_1.formatDiagnostics)(result) : '';
+            throw new errors_1.HarmonyCliError('ERR_HARMONY_PREBUILD_FAILED', `Expo prebuild exited with code ${result.code}.${diagnostics ? `\n${diagnostics}` : ''}`, {
+                exitCode: result.code,
+                operation: 'expo-prebuild',
+            });
+        }
+        try {
+            const plan = await (0, project_1.resolveHarmonyBuildPlanAsync)(projectRoot, {
+                buildMode: options.buildType,
+            });
+            if (plan.workflow !== 'cng') {
+                throw new errors_1.HarmonyCliError('ERR_HARMONY_TEMPLATE_INVALID', 'Prebuild did not produce a CNG project.', { operation: 'prebuild' });
+            }
+            await node_fs_1.default.promises.access(plan.projectFiles.templateMarker, node_fs_1.default.constants.R_OK);
+        }
+        catch (cause) {
+            throw new errors_1.HarmonyCliError('ERR_HARMONY_TEMPLATE_INVALID', 'Expo prebuild exited successfully but the Harmony marker or CNG manifest is invalid.', { cause, operation: 'verify-prebuild' });
+        }
+        return result;
+    }
+    finally {
+        await packed.cleanup();
+    }
+}
+async function prebuildParsedAsync(projectRoot, passthrough, options = {}) {
+    return (0, projectLock_1.withHarmonyProjectLockAsync)(projectRoot, 'prebuild', () => prebuildParsedUnlockedAsync(projectRoot, passthrough, options));
+}

package/build/prebuild/template.d.ts

@@ -0,0 +1,8 @@
+declare function packAsync(project: string): Promise<{
+    tarball: string;
+    env: {
+        [x: string]: string;
+    };
+    cleanup(): Promise<void>;
+}>;
+export { packAsync, };

package/build/prebuild/template.js

@@ -0,0 +1,86 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.packAsync = packAsync;
+const node_fs_1 = __importDefault(require("node:fs"));
+const node_module_1 = require("node:module");
+const node_os_1 = __importDefault(require("node:os"));
+const node_path_1 = __importDefault(require("node:path"));
+const errors_1 = require("../errors");
+const process_1 = require("../process");
+function resolve(project) {
+    const load = (0, node_module_1.createRequire)(node_path_1.default.join(project, 'package.json'));
+    let api;
+    try {
+        api = load('@expo-harmony/prebuild-config/internal/template');
+    }
+    catch (cause) {
+        throw new errors_1.HarmonyCliError('ERR_HARMONY_TEMPLATE_INVALID', 'Cannot load @expo-harmony/prebuild-config/internal/template from the project. Update the project-local prebuild config to a compatible version.', { cause, operation: 'resolve-template' });
+    }
+    if (typeof api?.ROOT_ENV !== 'string' || typeof api.resolveBundled !== 'function') {
+        throw new errors_1.HarmonyCliError('ERR_HARMONY_TEMPLATE_INVALID', 'The project-local @expo-harmony/prebuild-config template API is invalid.', { operation: 'resolve-template' });
+    }
+    let template;
+    try {
+        template = api.resolveBundled();
+    }
+    catch (cause) {
+        throw new errors_1.HarmonyCliError('ERR_HARMONY_TEMPLATE_INVALID', 'Cannot resolve the Harmony template declared by the project-local prebuild config.', { cause, operation: 'resolve-template' });
+    }
+    if (!template
+        || typeof template.root !== 'string'
+        || !node_path_1.default.isAbsolute(template.root)
+        || typeof template.version !== 'string'
+        || !template.version) {
+        throw new errors_1.HarmonyCliError('ERR_HARMONY_TEMPLATE_INVALID', 'The project-local @expo-harmony/prebuild-config returned an invalid template descriptor.', { operation: 'resolve-template' });
+    }
+    return {
+        env: { [api.ROOT_ENV]: template.root },
+        root: template.root,
+    };
+}
+async function packAsync(project) {
+    const template = resolve(project);
+    const temp = await node_fs_1.default.promises.mkdtemp(node_path_1.default.join(node_os_1.default.tmpdir(), 'expo-harmony-template-'));
+    const result = await (0, process_1.spawnAsync)('npm', [
+        'pack',
+        '--json',
+        '--ignore-scripts',
+        '--cache', node_path_1.default.join(temp, '.npm-cache'),
+        '--pack-destination', temp,
+        template.root,
+    ], { capture: true, cwd: project, operation: 'pack-template' });
+    if (result.code !== 0) {
+        await node_fs_1.default.promises.rm(temp, { recursive: true, force: true });
+        throw new errors_1.HarmonyCliError('ERR_HARMONY_TEMPLATE_INVALID', `npm pack failed: ${result.stderr.trim()}`, {
+            exitCode: result.code,
+            operation: 'pack-template',
+        });
+    }
+    let packs;
+    try {
+        packs = JSON.parse(result.stdout);
+    }
+    catch (cause) {
+        await node_fs_1.default.promises.rm(temp, { recursive: true, force: true });
+        throw new errors_1.HarmonyCliError('ERR_HARMONY_TEMPLATE_INVALID', 'npm pack returned invalid JSON.', {
+            cause,
+            operation: 'pack-template',
+        });
+    }
+    const filename = packs?.[0]?.filename;
+    const tarball = filename && node_path_1.default.join(temp, filename);
+    if (!tarball || !node_fs_1.default.existsSync(tarball)) {
+        await node_fs_1.default.promises.rm(temp, { recursive: true, force: true });
+        throw new errors_1.HarmonyCliError('ERR_HARMONY_TEMPLATE_INVALID', 'npm pack did not create a template tarball.', { operation: 'pack-template' });
+    }
+    return {
+        tarball,
+        env: template.env,
+        async cleanup() {
+            await node_fs_1.default.promises.rm(temp, { recursive: true, force: true });
+        },
+    };
+}

package/build/process.d.ts

@@ -0,0 +1,41 @@
+export interface ProcessOptions {
+    capture?: boolean;
+    cwd?: string;
+    env?: NodeJS.ProcessEnv;
+    onStderr?: (chunk: Uint8Array) => void;
+    onStdout?: (chunk: Uint8Array) => void;
+    operation?: string;
+    outputLimit?: number;
+    signal?: AbortSignal;
+    stdio?: 'inherit' | 'pipe';
+    stopGraceMs?: number;
+    timeoutMs?: number;
+}
+export interface ProcessResult {
+    code: number;
+    signal: NodeJS.Signals | null;
+    stderr: string;
+    stdout: string;
+    timedOut: boolean;
+}
+interface CheckedProcessOptions {
+    code: string;
+    cwd: string;
+    env?: NodeJS.ProcessEnv;
+    message: string;
+    operation: string;
+    outputLimit?: number;
+    timeoutMs?: number;
+}
+declare function formatDiagnostics(result: Pick<ProcessResult, 'stderr' | 'stdout'>, limit?: number): string;
+declare function spawnAsync(command: string, args: string[], options?: ProcessOptions): Promise<ProcessResult>;
+declare function startManagedProcess(command: string, args: string[], options?: ProcessOptions): {
+    child: any;
+    completion: Promise<ProcessResult>;
+    getStderr: () => string;
+    getStdout: () => string;
+    stop: (signal?: NodeJS.Signals, graceMs?: number) => Promise<ProcessResult>;
+    wasStopped: () => boolean;
+};
+declare function runCheckedAsync(command: string, args: string[], options: CheckedProcessOptions): Promise<ProcessResult>;
+export { formatDiagnostics, runCheckedAsync, spawnAsync, startManagedProcess };

package/build/process.js

@@ -0,0 +1,324 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.formatDiagnostics = formatDiagnostics;
+exports.runCheckedAsync = runCheckedAsync;
+exports.spawnAsync = spawnAsync;
+exports.startManagedProcess = startManagedProcess;
+const cross_spawn_1 = __importDefault(require("cross-spawn"));
+const tool_command_1 = require("@expo-harmony/expo-modules-autolinking/tool-command");
+const errors_1 = require("./errors");
+const DefaultOutputLimit = 1024 * 1024;
+const DefaultStopGraceMs = 3_000;
+class BoundedCapture {
+    limit;
+    buffers = [];
+    head = 0;
+    length = 0;
+    constructor(limit) {
+        this.limit = limit;
+    }
+    append(value) {
+        const buffer = typeof value === 'string' ? new TextEncoder().encode(value) : Uint8Array.from(value);
+        if (buffer.length >= this.limit) {
+            this.buffers = [buffer.subarray(buffer.length - this.limit)];
+            this.head = 0;
+            this.length = this.limit;
+            return;
+        }
+        while (this.length + buffer.length > this.limit && this.head < this.buffers.length) {
+            const first = this.buffers[this.head];
+            const excess = this.length + buffer.length - this.limit;
+            if (first.length > excess) {
+                this.buffers[this.head] = first.subarray(excess);
+                this.length -= excess;
+                break;
+            }
+            this.length -= first.length;
+            this.head += 1;
+        }
+        this.buffers.push(buffer);
+        this.length += buffer.length;
+        if (this.head > 128 && this.head * 2 > this.buffers.length) {
+            this.buffers = this.buffers.slice(this.head);
+            this.head = 0;
+        }
+    }
+    toString() {
+        return Buffer.concat(this.buffers.slice(this.head), this.length).toString('utf8');
+    }
+}
+function formatDiagnostics(result, limit = 4_000) {
+    return (result.stderr || result.stdout || '').slice(-limit).trim();
+}
+function spawnAsync(command, args, options = {}) {
+    return new Promise((resolve, reject) => {
+        if (options.signal?.aborted) {
+            throw new errors_1.HarmonyCliError('ERR_HARMONY_PROCESS_FAILED', `Cannot run ${command}: operation aborted.`, {
+                cause: options.signal.reason,
+                operation: options.operation || 'spawn',
+            });
+        }
+        const piped = Boolean(options.capture || options.onStdout || options.onStderr);
+        const limit = options.outputLimit || DefaultOutputLimit;
+        const child = (0, cross_spawn_1.default)(command, args, {
+            cwd: options.cwd,
+            env: options.env || process.env,
+            shell: false,
+            stdio: piped ? ['ignore', 'pipe', 'pipe'] : 'inherit',
+            windowsHide: true,
+        });
+        const stdout = new BoundedCapture(limit);
+        const stderr = new BoundedCapture(limit);
+        let timedOut = false;
+        let settled = false;
+        let escalation = null;
+        let stopping;
+        if (piped) {
+            child.stdout.on('data', (chunk) => {
+                stdout.append(chunk);
+                options.onStdout?.(chunk);
+            });
+            child.stderr.on('data', (chunk) => {
+                stderr.append(chunk);
+                options.onStderr?.(chunk);
+            });
+        }
+        const stop = (signal = 'SIGTERM') => {
+            if (stopping || settled)
+                return;
+            stopping = Promise.resolve().then(() => (0, tool_command_1.terminateProcess)(child, signal));
+            if (process.platform === 'win32') {
+                void finish(null, signal);
+            }
+            else {
+                stopping.catch((cause) => {
+                    void finish(null, null, cause);
+                });
+                escalation = setTimeout(() => {
+                    stopping = (0, tool_command_1.terminateProcess)(child, 'SIGKILL');
+                    stopping.catch((cause) => {
+                        void finish(null, null, cause);
+                    });
+                }, options.stopGraceMs || DefaultStopGraceMs);
+                escalation.unref?.();
+            }
+        };
+        const interrupt = () => stop('SIGINT');
+        const terminate = () => stop('SIGTERM');
+        process.once('SIGINT', interrupt);
+        process.once('SIGTERM', terminate);
+        const timeout = options.timeoutMs
+            ? setTimeout(() => {
+                timedOut = true;
+                stop('SIGTERM');
+            }, options.timeoutMs)
+            : null;
+        timeout?.unref?.();
+        const cleanup = () => {
+            if (timeout)
+                clearTimeout(timeout);
+            if (escalation)
+                clearTimeout(escalation);
+            process.removeListener('SIGINT', interrupt);
+            process.removeListener('SIGTERM', terminate);
+            options.signal?.removeEventListener('abort', abort);
+        };
+        const finish = async (code, signal, cause) => {
+            try {
+                await stopping;
+            }
+            catch (error) {
+                cause = error;
+            }
+            if (settled)
+                return;
+            settled = true;
+            cleanup();
+            if (cause)
+                reject(new errors_1.HarmonyCliError('ERR_HARMONY_PROCESS_FAILED', `Cannot run ${command}: ${cause.message}`, {
+                    cause,
+                    operation: options.operation || 'spawn',
+                }));
+            else
+                resolve({
+                    code: code === null ? 1 : code,
+                    signal,
+                    stderr: stderr.toString(),
+                    stdout: stdout.toString(),
+                    timedOut,
+                });
+        };
+        child.once('error', (cause) => {
+            void finish(null, null, cause);
+        });
+        child.once('close', (code, signal) => {
+            void finish(code, signal);
+        });
+        const abort = () => stop('SIGTERM');
+        options.signal?.addEventListener('abort', abort, { once: true });
+        if (options.signal?.aborted)
+            abort();
+    });
+}
+function startManagedProcess(command, args, options = {}) {
+    if (options.signal?.aborted) {
+        throw new errors_1.HarmonyCliError('ERR_HARMONY_PROCESS_FAILED', `Cannot launch ${command}: operation aborted.`, {
+            cause: options.signal.reason,
+            operation: options.operation || 'spawn',
+        });
+    }
+    const limit = options.outputLimit || DefaultOutputLimit;
+    const piped = options.stdio !== 'inherit';
+    const child = (0, cross_spawn_1.default)(command, args, {
+        cwd: options.cwd,
+        env: options.env || process.env,
+        shell: false,
+        stdio: piped ? ['ignore', 'pipe', 'pipe'] : 'inherit',
+        windowsHide: true,
+    });
+    const stdout = new BoundedCapture(limit);
+    const stderr = new BoundedCapture(limit);
+    let failure = null;
+    let closed = false;
+    let stopped = false;
+    let stopping;
+    let stopPromise;
+    let finish;
+    if (piped) {
+        child.stdout.on('data', (chunk) => {
+            stdout.append(chunk);
+            options.onStdout?.(chunk);
+        });
+        child.stderr.on('data', (chunk) => {
+            stderr.append(chunk);
+            options.onStderr?.(chunk);
+        });
+    }
+    const interrupt = () => {
+        void stop('SIGINT').catch(() => { });
+    };
+    const terminate = () => {
+        void stop('SIGTERM').catch(() => { });
+    };
+    const abort = () => {
+        void stop('SIGTERM').catch(() => { });
+    };
+    const cleanup = () => {
+        process.removeListener('SIGINT', interrupt);
+        process.removeListener('SIGTERM', terminate);
+        options.signal?.removeEventListener('abort', abort);
+    };
+    const completion = new Promise((resolve, reject) => {
+        child.once('error', (cause) => {
+            failure = new errors_1.HarmonyCliError('ERR_HARMONY_PROCESS_FAILED', `Cannot launch ${command}: ${cause.message}`, {
+                cause,
+                operation: options.operation || 'spawn',
+            });
+        });
+        finish = async (code, signal) => {
+            try {
+                await stopping;
+            }
+            catch (cause) {
+                failure = new errors_1.HarmonyCliError('ERR_HARMONY_PROCESS_FAILED', `Cannot stop ${command}: ${cause.message}`, {
+                    cause, operation: options.operation || 'spawn',
+                });
+            }
+            if (closed)
+                return;
+            closed = true;
+            cleanup();
+            if (failure)
+                reject(failure);
+            else
+                resolve({
+                    code: code === null ? 1 : code,
+                    signal,
+                    stderr: stderr.toString(),
+                    stdout: stdout.toString(),
+                    timedOut: false,
+                });
+        };
+        child.once('close', (code, signal) => {
+            void finish(code, signal);
+        });
+    });
+    // A readiness probe may be the first consumer. Keep early spawn failures from
+    // becoming unhandled rejections while the probe is still polling.
+    completion.catch(() => { });
+    async function stop(signal = 'SIGTERM', graceMs = DefaultStopGraceMs) {
+        if (stopPromise)
+            return stopPromise;
+        if (closed)
+            return completion;
+        stopped = true;
+        stopping = Promise.resolve().then(() => (0, tool_command_1.terminateProcess)(child, signal));
+        stopPromise = (async () => {
+            if (process.platform === 'win32') {
+                void finish(null, signal);
+                return completion;
+            }
+            try {
+                await stopping;
+            }
+            catch {
+                await finish(null, signal);
+                return completion;
+            }
+            let timer;
+            await Promise.race([
+                completion.catch(() => undefined),
+                new Promise((resolve) => {
+                    timer = setTimeout(resolve, graceMs);
+                    timer.unref?.();
+                }),
+            ]);
+            if (timer)
+                clearTimeout(timer);
+            if (!closed) {
+                stopping = (0, tool_command_1.terminateProcess)(child, 'SIGKILL');
+                try {
+                    await stopping;
+                }
+                catch {
+                    await finish(null, signal);
+                }
+            }
+            return completion.catch(() => undefined);
+        })();
+        stopPromise.catch(() => { });
+        return stopPromise;
+    }
+    process.once('SIGINT', interrupt);
+    process.once('SIGTERM', terminate);
+    if (options.signal?.aborted)
+        abort();
+    else
+        options.signal?.addEventListener('abort', abort, { once: true });
+    return {
+        child,
+        completion,
+        getStderr: () => stderr.toString(),
+        getStdout: () => stdout.toString(),
+        stop,
+        wasStopped: () => stopped,
+    };
+}
+async function runCheckedAsync(command, args, options) {
+    const result = await spawnAsync(command, args, {
+        capture: true,
+        cwd: options.cwd,
+        env: options.env,
+        operation: options.operation,
+        outputLimit: options.outputLimit || 2 * 1024 * 1024,
+        timeoutMs: options.timeoutMs,
+    });
+    if (result.code !== 0 || result.timedOut) {
+        const diagnostics = formatDiagnostics(result);
+        throw new errors_1.HarmonyCliError(options.code, `${options.message} exited with code ${result.code}${result.timedOut ? ' after timing out' : ''}.${diagnostics ? `\n${diagnostics}` : ''}`, { exitCode: result.code || 1, operation: options.operation });
+    }
+    return result;
+}

package/build/profile.d.ts

@@ -0,0 +1 @@
+export declare function timedAsync<T>(steps: Record<string, number>, name: string, operation: () => Promise<T> | T): Promise<T>;

package/build/profile.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.timedAsync = timedAsync;
+async function timedAsync(steps, name, operation) {
+    const started = performance.now();
+    try {
+        return await operation();
+    }
+    finally {
+        steps[name] = Math.max(0, Math.round(performance.now() - started));
+    }
+}

package/build/project.d.ts

@@ -0,0 +1,2 @@
+declare function resolveProject(start?: string): string;
+export { resolveProject };