stim 1.20.2 → 1.22.0

package/dist/operation-exec-BW0em61G.mjs

@@ -0,0 +1,171 @@
+import { m as operationState, r as WorkspaceProcessCleanupError, t as getExecutor } from "./exec-DEoAhcze.mjs";
+import { sep } from "node:path";
+//#region src/cancellation.ts
+function cancelledError(what, cause) {
+	return Object.assign(new Error(`The ${what} was cancelled.`, cause === void 0 ? void 0 : { cause }), { code: "STIM_CANCELLED" });
+}
+function throwIfCancelled(signal, what) {
+	if (signal?.aborted) throw cancelledError(what);
+}
+function cancellableSleep(ms, { signal, what = "wait", ref = true } = {}) {
+	return new Promise((resolve, reject) => {
+		if (signal?.aborted) return reject(cancelledError(what));
+		const onAbort = () => {
+			clearTimeout(timer);
+			reject(cancelledError(what));
+		};
+		const timer = setTimeout(() => {
+			signal?.removeEventListener("abort", onAbort);
+			resolve();
+		}, ms);
+		if (!ref) timer.unref();
+		signal?.addEventListener("abort", onAbort, { once: true });
+	});
+}
+//#endregion
+//#region src/workspace/git.ts
+const GIT_TIMEOUT_MS = 1e4;
+const GIT_CONCURRENCY = 6;
+function gitCall(cwd, args, { write, signal: _signal, timeoutMs = GIT_TIMEOUT_MS, ...opts }) {
+	return {
+		args: [
+			...write ? [] : ["--no-optional-locks"],
+			"-C",
+			cwd,
+			...args
+		],
+		opts: {
+			cwd,
+			...opts,
+			timeoutMs
+		}
+	};
+}
+/** Runs git in `cwd`, bounded by `timeoutMs` (10 s by default); throws like `runFile`. */
+function git(cwd, args, opts = {}) {
+	const call = gitCall(cwd, args, opts);
+	return getExecutor().runFile("git", call.args, call.opts);
+}
+/** `git`, returning null instead of throwing. */
+function gitQuiet(cwd, args, opts = {}) {
+	const call = gitCall(cwd, args, opts);
+	return getExecutor().runFileQuiet("git", call.args, call.opts);
+}
+const queue = [];
+let running = 0;
+/** `git` without blocking the event loop, at most six at a time; the budget starts when the call leaves the queue. */
+async function gitAsync(cwd, args, opts = {}) {
+	const signal = opts.signal ?? getExecutor().reportSignal?.();
+	signal?.throwIfAborted();
+	if (running < GIT_CONCURRENCY) running++;
+	else await new Promise((resolve, reject) => {
+		const proceed = () => {
+			signal?.removeEventListener("abort", cancel);
+			resolve();
+		};
+		const cancel = () => {
+			const index = queue.indexOf(proceed);
+			if (index !== -1) queue.splice(index, 1);
+			reject(signal?.reason);
+		};
+		queue.push(proceed);
+		signal?.addEventListener("abort", cancel, { once: true });
+		if (signal?.aborted) cancel();
+	});
+	let cleanupFailed = false;
+	try {
+		signal?.throwIfAborted();
+		const call = gitCall(cwd, args, opts);
+		return await getExecutor().runFileAsync("git", call.args, {
+			...call.opts,
+			signal
+		});
+	} catch (error) {
+		cleanupFailed = error instanceof WorkspaceProcessCleanupError || error instanceof Error && "reportCleanup" in error;
+		throw error;
+	} finally {
+		const next = queue.shift();
+		if (next) next();
+		else running--;
+		if (!cleanupFailed) signal?.throwIfAborted();
+	}
+}
+/** `gitAsync`, returning null for ordinary failures; cancellation and unresolved cleanup reject. */
+async function gitQuietAsync(cwd, args, opts = {}) {
+	try {
+		return await gitAsync(cwd, args, opts);
+	} catch (error) {
+		if (error instanceof WorkspaceProcessCleanupError || error instanceof Error && "reportCleanup" in error) throw error;
+		(opts.signal ?? getExecutor().reportSignal?.())?.throwIfAborted();
+		return null;
+	}
+}
+//#endregion
+//#region src/workspace/git-read.ts
+function childEnvironment(env) {
+	return {
+		env: Object.fromEntries(Object.entries(env).flatMap(([name, value]) => value === void 0 ? [] : [[name, value]])),
+		omitEnv: Object.keys(process.env).filter((name) => env[name] === void 0)
+	};
+}
+function killOnAbort(signal) {
+	return (child) => {
+		if (!signal || getExecutor().reportSignal?.()) return;
+		if (signal.aborted) return void child.kill("SIGKILL");
+		const kill = () => child.kill("SIGKILL");
+		signal.addEventListener("abort", kill, { once: true });
+		child.once("close", () => signal.removeEventListener("abort", kill));
+	};
+}
+/** `git rev-parse <args>` in `cwd` as a native path, or null; Git runs with exactly `env` and dies when `signal` aborts. */
+function gitPath(cwd, args, env, signal) {
+	return gitAsync(cwd, ["rev-parse", ...args], {
+		...childEnvironment(env),
+		signal
+	}).then((out) => {
+		const path = out.trim();
+		if (!path) return null;
+		return sep === "/" ? path : path.replaceAll("/", sep);
+	}, () => null);
+}
+//#endregion
+//#region src/engine/operation-exec.ts
+async function runOperationFile(context, executor, file, args, options) {
+	const signal = context ? operationState(context).runSignal ?? context.signal : options.signal;
+	throwIfCancelled(signal, file);
+	const environment = context ? childEnvironment(context.env) : {
+		env: {},
+		omitEnv: []
+	};
+	const output = await executor.runFileAsync(file, args, {
+		...environment,
+		...options,
+		...context ? { env: {
+			...environment.env,
+			...options.env
+		} } : {},
+		omitEnv: [...environment.omitEnv.filter((name) => options.env?.[name] === void 0), ...options.omitEnv ?? []],
+		declareFor: context,
+		signal
+	});
+	throwIfCancelled(signal, file);
+	return output;
+}
+/** Contextual probes return null for ordinary failures and propagate cancellation or unresolved cleanup; other calls retain the executor's quiet behavior. */
+async function runOperationFileQuiet(context, executor, file, args, options) {
+	const signal = context ? operationState(context).runSignal ?? context.signal : options.signal;
+	signal?.throwIfAborted();
+	try {
+		const output = context ? await runOperationFile(context, executor, file, args, options) : await executor.runFileQuietAsync(file, args, options);
+		options.signal?.throwIfAborted();
+		signal?.throwIfAborted();
+		return output;
+	} catch (error) {
+		if (error instanceof WorkspaceProcessCleanupError || error instanceof Error && "reportCleanup" in error) throw error;
+		options.signal?.throwIfAborted();
+		signal?.throwIfAborted();
+		return null;
+	}
+}
+//#endregion
+export { killOnAbort as a, gitQuiet as c, cancelledError as d, throwIfCancelled as f, gitPath as i, gitQuietAsync as l, runOperationFileQuiet as n, git as o, childEnvironment as r, gitAsync as s, runOperationFile as t, cancellableSleep as u };

package/dist/{ownership-DCtw_2IA.mjs → ownership-C5fo5Edb.mjs}

@@ -1,6 +1,6 @@
-import { k as process_identity_exports } from "./config-BYDxlMY3.mjs";
-import { c as writeWorkspaceState, o as withWorkspaceStateLock, r as readWorkspaceState } from "./workspace-state-DJt_MMvf.mjs";
-import { s as pidExists } from "./metro-DnCEjCxs.mjs";
+import { g as process_identity_exports } from "./exec-DEoAhcze.mjs";
+import { c as withWorkspaceStateLock, d as writeWorkspaceState, r as readWorkspaceState } from "./workspace-state-U08dEzhG.mjs";
+import { c as pidExists } from "./metro-DiXtA3Ty.mjs";
 import { realpathSync } from "node:fs";
 //#region src/collector/state.ts
 function collectorRoot(root) {

package/dist/{page-DRHy329N.mjs → page-DBL2PiUU.mjs}

@@ -1,5 +1,6 @@
-import { k as process_identity_exports } from "./config-BYDxlMY3.mjs";
-import { t as connectOwnedBrowser } from "./cdp-Dq_ypAlJ.mjs";
+import { g as process_identity_exports } from "./exec-DEoAhcze.mjs";
+import { f as throwIfCancelled } from "./operation-exec-BW0em61G.mjs";
+import { t as connectOwnedBrowser } from "./cdp-3fwICjzi.mjs";
 //#region src/web/page.ts
 /** The record of a verified live browser: its supervisor and Chrome are the processes the record names. */
 function liveWebRecord(record) {
@@ -12,21 +13,27 @@ const NAVIGATE_ACK_MS = 1e3;
 * Sends one page-level DevTools command to the owned page, through a connection verified to reach its Chrome.
 * Resolves to the URL the page was on when the command was sent.
 */
-async function sendToOwnedPage(record, method, params = {}) {
-	const cdp = await connectOwnedBrowser(record.cdpPort, record.chromeProcess.pid);
+async function sendToOwnedPage(record, method, params = {}, signal) {
+	const cdp = await connectOwnedBrowser(record.cdpPort, record.chromeProcess.pid, signal);
+	let navigateTimer;
 	try {
 		const { targetInfo } = await cdp.send("Target.getTargetInfo", { targetId: record.targetId });
+		throwIfCancelled(signal, "browser operation");
 		const { sessionId } = await cdp.send("Target.attachToTarget", {
 			targetId: record.targetId,
 			flatten: true
 		});
+		throwIfCancelled(signal, "browser operation");
 		const reply = cdp.send(method, params, sessionId);
 		if (method === "Page.navigate") {
 			reply.catch(() => {});
-			await Promise.race([reply, new Promise((resolve) => setTimeout(resolve, NAVIGATE_ACK_MS))]);
+			await Promise.race([reply, new Promise((resolve) => {
+				navigateTimer = setTimeout(resolve, NAVIGATE_ACK_MS);
+			})]);
 		} else await reply;
 		return targetInfo.url;
 	} finally {
+		clearTimeout(navigateTimer);
 		cdp.close();
 	}
 }

package/dist/paths-BsJMoPP2.mjs

@@ -0,0 +1,12 @@
+import { resolve } from "path";
+import { realpathSync } from "fs";
+//#region src/commands/gc/paths.ts
+function canonicalPath(p) {
+	try {
+		return realpathSync(p);
+	} catch {
+		return resolve(p);
+	}
+}
+//#endregion
+export { canonicalPath as t };

package/dist/paths-DQtTgsBf.mjs

@@ -0,0 +1,42 @@
+import { existsSync, renameSync, rmSync, writeFileSync } from "node:fs";
+import { buildCacheRoot as sharedBuildCache, ensurePrivateDir, withDirLock as withDirLock$1, withDirLockAsync as withDirLockAsync$1, workspaceId as workspaceId$1, workspaceName as workspaceName$1, workspaceStateDir as workspaceDir } from "@stim-cli/core";
+import { emulatorLogFile, readJsonObject, sharedCcache as sharedCcache$1, sharedCompilationCache as sharedCompilationCache$1, supervisorLogFile, supervisorPidFile, workspaceAgentDeviceDir, workspaceDerivedData, workspaceLogErrorIndex, workspaceLogsDir as workspaceLogsDir$1, workspaceMetadataFile, workspaceStateFile as workspaceStateFile$1, workspaceStateLock } from "@stim-cli/core/state";
+import { join, resolve } from "path";
+//#region src/workspace/paths.ts
+function ensureWorkspaceStorage(projectRoot) {
+	const canonicalRoot = resolve(projectRoot);
+	const dir = workspaceDir(canonicalRoot);
+	const file = workspaceMetadataFile(canonicalRoot);
+	ensurePrivateDir(dir);
+	return withDirLock$1(join(dir, "metadata.lock"), () => {
+		if (!existsSync(file)) {
+			const metadata = {
+				projectRoot: canonicalRoot,
+				workspace: workspaceName$1(canonicalRoot),
+				version: 1
+			};
+			const tmp = `${file}.${process.pid}.${Math.random().toString(36).slice(2)}.tmp`;
+			writeFileSync(tmp, `${JSON.stringify(metadata, null, 2)}\n`);
+			try {
+				renameSync(tmp, file);
+			} catch (error) {
+				rmSync(tmp, { force: true });
+				throw error;
+			}
+			return dir;
+		}
+		if (readJsonObject(file)?.projectRoot === canonicalRoot) return dir;
+		const error = /* @__PURE__ */ new Error(`Stim workspace collision at ${dir}: its workspace.json does not belong to ${canonicalRoot}.`);
+		error.code = "STIM_WORKSPACE_COLLISION";
+		throw error;
+	});
+}
+/** Initializes or validates workspace storage after asynchronously acquiring its metadata lock. */
+function ensureWorkspaceStorageAsync(projectRoot, signal) {
+	signal?.throwIfAborted();
+	const dir = workspaceDir(resolve(projectRoot));
+	ensurePrivateDir(dir);
+	return withDirLockAsync$1(join(dir, "metadata.lock"), () => ensureWorkspaceStorage(projectRoot), { signal });
+}
+//#endregion
+export { workspaceStateLock as _, sharedCcache$1 as a, supervisorPidFile as c, workspaceDir as d, workspaceId$1 as f, workspaceStateFile$1 as g, workspaceName$1 as h, sharedBuildCache as i, workspaceAgentDeviceDir as l, workspaceLogsDir$1 as m, ensureWorkspaceStorage as n, sharedCompilationCache$1 as o, workspaceLogErrorIndex as p, ensureWorkspaceStorageAsync as r, supervisorLogFile as s, emulatorLogFile as t, workspaceDerivedData as u, withDirLock$1 as v, withDirLockAsync$1 as y };

package/dist/{placement-log-MOfPVgaM.mjs → placement-log-BnGgJRRZ.mjs}

@@ -1,6 +1,6 @@
-import { m as buildPlacementSettings } from "./client-qQAaXSUs.mjs";
+import { n as buildPlacementSettings } from "./selection-DSMbWEX2.mjs";
 //#region src/placement-log.ts
-/** `machine` is `local` when the run stays on this Mac. */
+/** `machine` is `local` when the run stays on this machine. */
 function placementRecord(input) {
 	const { choice, fallback } = input;
 	const event = input.event ?? (input.kind === "build" ? "build_placement" : "device_placement");
@@ -42,8 +42,8 @@ function devicePlacementRecord({ platform, fromFlag, easFallback = false, placed
 	});
 }
 /**
-* The record for where a build runs. `stays` is the reason this Mac builds it, `chose` the remote Mac that takes it,
-* and `fallback` why a remote Mac that was meant to build it did not.
+* The record for where a build runs. `stays` is the reason this machine builds it, `chose` the remote machine that takes it,
+* and `fallback` why a remote machine that was meant to build it did not.
 */
 function buildPlacementRecord({ platform, buildMachine, candidates = [], ...outcome }) {
 	const base = {
@@ -75,7 +75,7 @@ function buildPlacementRecord({ platform, buildMachine, candidates = [], ...outc
 		choice: {
 			machine: "local",
 			code,
-			msg: "building on this Mac"
+			msg: "building on this machine"
 		},
 		fallback: {
 			code,

package/dist/{plan-placement-V0TdzYXp.mjs → plan-placement-DIsMtN-d.mjs}

@@ -1,18 +1,18 @@
-import { S as hostingMachines } from "./client-qQAaXSUs.mjs";
-import { r as readHostedNative } from "./ios-state-CBLe1xYw.mjs";
-import { l as probeHost, s as automaticDevicePlacement } from "./build-plan-B7SZsc2N.mjs";
+import { d as hostingMachines } from "./selection-DSMbWEX2.mjs";
+import { r as readHostedNative } from "./ios-state-Dtw5K2aI.mjs";
+import { i as probeHost, n as automaticDevicePlacement } from "./eas-fallback-CSgAulr5.mjs";
 import { automaticMachineEnabled } from "@stim-cli/core/state";
 //#region src/device-host/plan-placement.ts
 /**
 * Where `--plan` assumes the next run puts its simulator or emulator, with no session, reservation or state write.
 * A named Mac, or the Mac a recorded session already holds, answers with the device its `device-host.offer` would
-* give; `auto` repeats the placement decision a run makes now and, when that stays on this Mac, notes any Mac
+* give; `auto` repeats the placement decision a run makes now and, when that stays on this machine, notes any Mac
 * whose device would key differently. The result predicts the cache key only; a run reads its own device.
 */
-async function planHostedDevice({ root, slot, platform, machine, selectors, sameKey, eas, deps = {} }) {
-	const { automatic = automaticDevicePlacement, probe = probeHost, machines = hostingMachines } = deps;
+async function planHostedDevice({ root, slot, platform, machine, selectors, sameKey, eas, deps = {}, operation }) {
+	const { automatic = automaticDevicePlacement, probe = probeHost, machines = () => hostingMachines(void 0, operation?.signal) } = deps;
 	const named = async (name) => {
-		const result = await probe(name, platform, selectors);
+		const result = await probe(name, platform, selectors, void 0, operation?.signal);
 		if ("failure" in result.probe) return {
 			kind: "unknown",
 			reason: `${name} did not give a ${platform} device (${result.probe.failure})`
@@ -38,6 +38,7 @@ async function planHostedDevice({ root, slot, platform, machine, selectors, same
 			platform,
 			selectors,
 			noWait: false,
+			signal: operation?.signal,
 			...eas ? { eas } : {}
 		}, {
 			read: () => ({}),
@@ -52,17 +53,20 @@ async function planHostedDevice({ root, slot, platform, machine, selectors, same
 			choice: placed.target.choice,
 			placement: `on ${placed.target.host.machine}, as auto would now`
 		};
-		const names = (machines() ?? []).filter((name) => automaticMachineEnabled("device", name));
-		const differs = (await Promise.all(names.map((name) => probe(name, platform, selectors)))).flatMap(({ probe: each }) => "offer" in each && each.offer.choice && sameKey(each.offer.choice) === false ? [each.machine] : []);
+		const names = (await machines() ?? []).filter((name) => automaticMachineEnabled("device", name));
+		operation?.signal.throwIfAborted();
+		const offers = await Promise.all(names.map((name) => probe(name, platform, selectors, void 0, operation?.signal)));
+		const differs = (await Promise.all(offers.map(async ({ probe: each }) => "offer" in each && each.offer.choice && await sameKey(each.offer.choice) === false ? [each.machine] : []))).flat();
 		if (differs.length) return {
 			kind: "local",
-			placement: `this Mac; auto may use ${differs.join(", ")}, which builds for another architecture, so its key differs`
+			placement: `this machine; auto may use ${differs.join(", ")}, which builds for another architecture, so its key differs`
 		};
 		return {
 			kind: "local",
-			placement: names.length ? `this Mac; auto may use ${names.join(", ")}` : "this Mac"
+			placement: names.length ? `this machine; auto may use ${names.join(", ")}` : "this machine"
 		};
 	} catch (error) {
+		operation?.signal.throwIfAborted();
 		return {
 			kind: "unknown",
 			reason: error.message

package/dist/{ports-DdSUicVo.mjs → ports-Cy1RkmuQ.mjs}

@@ -1,6 +1,6 @@
-import { p as getProject } from "./config-BYDxlMY3.mjs";
-import { n as findCommandWorkspace } from "./project-_phNIJfs.mjs";
-import { n as getNamedPort, t as clearNamedPorts } from "./named-ports-4WopRPg-.mjs";
+import { p as getProject } from "./config-DlrsduwG.mjs";
+import { n as findCommandWorkspace } from "./project-wM_XFTvE.mjs";
+import { n as getNamedPort, t as clearNamedPorts } from "./named-ports-DkEzOfzO.mjs";
 //#region src/commands/ports.ts
 async function inProject(action) {
 	try {