stim 1.25.0 → 1.27.0

package/dist/native-run-D5OJsGwA.mjs

@@ -1,276 +0,0 @@
-import { D as ownership_claim_exports, b as operationState, g as signalDeclaredSpawns, h as refuseDeclaredSpawns, p as allowDeclaredSpawns, u as withWorkspaceProcessLock, y as isTermination } from "./exec-VFRpu1iA.mjs";
-import { d as workspaceDir } from "./paths-DQtTgsBf.mjs";
-import { a as formatElapsed, l as phaseLine } from "./command-output-BBvS1H6v.mjs";
-import { l as withWorkspaceStateLockAsync, o as updateWorkspaceState, r as readWorkspaceState, t as clearWorkspaceStateKey } from "./workspace-state-CPSp3mav.mjs";
-import { t as canonicalPath } from "./paths-BsJMoPP2.mjs";
-import { existsSync, mkdirSync } from "node:fs";
-import { basename, dirname, join } from "node:path";
-import { setTimeout } from "node:timers/promises";
-//#region src/cache/cache-claim.ts
-const LABEL = "cache";
-const POLL_MS = 500;
-const EMPTYING_WAIT_MS = 6e5;
-/**
-* The claim set guarding a cache Stim can only empty whole. It sits beside the cache's resolved directory, so emptying
-* the cache never removes it and every path that reaches the same cache names the same set; before the cache exists,
-* its resolved parent stands in for it.
-*/
-function cacheClaimRoot(dir) {
-	return `${existsSync(dir) ? canonicalPath(dir) : join(canonicalPath(dirname(dir)), basename(dir))}.claims`;
-}
-function describe(holder) {
-	const { platform, projectRoot } = holder.details;
-	const where = typeof projectRoot === "string" ? ` in ${projectRoot}` : "";
-	return holder.mode === "shared" ? `the ${typeof platform === "string" ? platform : "iOS"} build (pid ${holder.owner.pid}${where}) may be using it` : `pid ${holder.owner.pid} is emptying it`;
-}
-/** Why the cache at `dir` may be in use, from its claim set, without taking or removing any claim. */
-function cacheUser(dir) {
-	const root = cacheClaimRoot(dir);
-	const survey = (0, ownership_claim_exports.readClaimSet)(root);
-	const problem = survey.unresolved[0];
-	if (problem) return `the cache claim ${problem.path} is unresolved, so a build may be using it`;
-	const holder = survey.live[0];
-	return holder ? describe(holder) : void 0;
-}
-/**
-* Takes the exclusive claim an emptier holds while it removes the cache's contents; a string is why it cannot.
-* It never waits for a build that holds the cache.
-*/
-function claimForEmptying(dir) {
-	try {
-		const attempt = (0, ownership_claim_exports.tryAcquireClaim)({
-			root: cacheClaimRoot(dir),
-			mode: "exclusive",
-			label: LABEL
-		});
-		if (attempt.acquired) return attempt.acquired;
-		if (attempt.pending) (0, ownership_claim_exports.releaseClaim)(attempt.pending);
-		const holder = attempt.held ?? attempt.waitingFor?.[0];
-		return holder ? describe(holder) : `its claim at ${cacheClaimRoot(dir)} could not be taken`;
-	} catch (error) {
-		if ((0, ownership_claim_exports.isClaimRefusal)(error) || (0, ownership_claim_exports.isClaimUnavailable)(error)) return error.message;
-		return `its claim at ${cacheClaimRoot(dir)} could not be taken: ${error instanceof Error ? error.message : String(error)}`;
-	}
-}
-/**
-* Takes the shared claim a build holds on the compilation cache it compiles with, waiting while an emptier holds it.
-* A claim set Stim cannot resolve, or no process identity, is a failure: the build never runs unguarded.
-*/
-async function shareCompilationCache({ dir, projectRoot, note, signal }) {
-	const started = Date.now();
-	let told = false;
-	for (;;) {
-		signal?.throwIfAborted();
-		let attempt;
-		let root = `${dir}.claims`;
-		try {
-			mkdirSync(dirname(dir), { recursive: true });
-			root = cacheClaimRoot(dir);
-			attempt = (0, ownership_claim_exports.tryAcquireClaim)({
-				root,
-				mode: "shared",
-				label: LABEL,
-				details: {
-					platform: "ios",
-					projectRoot
-				}
-			});
-		} catch (error) {
-			return { failure: (0, ownership_claim_exports.claimFailure)(error, null) ?? {
-				code: ownership_claim_exports.CLAIM_UNAVAILABLE,
-				message: `Stim could not take the compilation cache claim at ${root}: ${error instanceof Error ? error.message : String(error)}.`,
-				remedy: `Restore write access to ${dirname(root)}, then retry the same Stim command.`
-			} };
-		}
-		if (attempt.acquired) return { claim: attempt.acquired };
-		const emptier = attempt.held ? `pid ${attempt.held.owner.pid}` : "another process";
-		const waited = Date.now() - started;
-		if (waited >= EMPTYING_WAIT_MS) return { failure: {
-			code: "STIM_BUILD_FAILED",
-			message: `${emptier} has been emptying the compilation cache at ${dir} for ${formatElapsed(waited)}.`,
-			remedy: "Run the same command again once it has finished."
-		} };
-		if (!told) note(phaseLine("build", `waiting for ${emptier} to finish emptying the compilation cache at ${dir}`));
-		told = true;
-		await setTimeout(POLL_MS);
-	}
-}
-//#endregion
-//#region src/engine/native-run.ts
-const NATIVE_RUN_LOCK = "native-run";
-const NATIVE_RUN_WAIT_MS = 18e5;
-const WAIT_HEARTBEAT_MS = 3e4;
-const CANCEL_REQUEST_KEY = "nativeRunCancel";
-const REQUEST_POLL_MS = 250;
-function nativeRunHolder(holder) {
-	const { command, platform, slot, interrupt } = holder.details;
-	return {
-		command: typeof command === "string" ? command : null,
-		platform: typeof platform === "string" ? platform : null,
-		slot: typeof slot === "string" ? slot : "default",
-		takesSignals: interrupt === "signal"
-	};
-}
-function describeNativeRunHolder(holder, now) {
-	const { command, slot } = nativeRunHolder(holder);
-	const started = Date.parse(holder.startedAt);
-	const facts = [`pid ${holder.owner.pid}`];
-	if (Number.isFinite(started)) facts.push(`running for ${formatElapsed(now - started)}`);
-	if (command === null) return `another Stim run (${facts.join(", ")})`;
-	if (command === "build") return `an artifact build (${facts.join(", ")})`;
-	return `\`stim ${command}${slot === "default" ? "" : ` --slot ${slot}`}\` (${facts.join(", ")})`;
-}
-/**
-* Report a wait on the native-run lock: one line as soon as a holder is seen, a line for each new
-* holder, and a heartbeat every WAIT_HEARTBEAT_MS while the same holder keeps it.
-*/
-function nativeRunWaitNotice({ write, now = Date.now, describe = describeNativeRunHolder }) {
-	let claimId = null;
-	let lastAt = 0;
-	return (holder, firstLine) => {
-		const at = now();
-		if (holder.claimId !== claimId) {
-			claimId = holder.claimId;
-			lastAt = at;
-			write(firstLine ?? `waiting for ${describe(holder, at)} in this workspace to finish`);
-			return;
-		}
-		if (at - lastAt < WAIT_HEARTBEAT_MS) return;
-		lastAt = at;
-		write(`still waiting for ${describe(holder, at)}`);
-	};
-}
-/**
-* What `stop` does about the run holding the native-run lock. A build is interrupted only when the stop
-* leaves it nothing to deploy to: the whole workspace stops, the build targets the stopped slot, or the
-* stopped slot is the workspace's only device. A build for another slot that stays is left running and
-* the stop proceeds without the lock. Only an owner whose identity is proven live is signalled.
-*/
-function decideStopAction({ stopSlot, holder, ownerIdentity, deviceSlots }) {
-	if (holder.command === "macos" || holder.command === "build") {
-		if (stopSlot !== void 0) return { action: "proceed" };
-		return ownerIdentity === "same" ? { action: "interrupt" } : { action: "refuse" };
-	}
-	if (holder.command !== "ios" && holder.command !== "android") return { action: "wait" };
-	if (!(stopSlot === void 0 || holder.slot === stopSlot || deviceSlots.includes(stopSlot) && deviceSlots.every((slot) => slot === stopSlot))) return { action: "proceed" };
-	return ownerIdentity === "same" ? { action: "interrupt" } : { action: "refuse" };
-}
-const requestListeners = /* @__PURE__ */ new Map();
-/**
-* Ask the run holding `claimId` to cancel: the request is written to the workspace state, where the run's watch
-* finds it, and a run in this process is told at once.
-*/
-function requestNativeRunCancel(root, claimId, pid = process.pid) {
-	updateWorkspaceState(root, (state) => ({
-		...state,
-		[CANCEL_REQUEST_KEY]: {
-			claimId,
-			pid,
-			at: (/* @__PURE__ */ new Date()).toISOString()
-		}
-	}));
-	requestListeners.get(claimId)?.();
-}
-function cancelRequestFor(root, claimId) {
-	const request = readWorkspaceState(root)?.[CANCEL_REQUEST_KEY];
-	if (request?.claimId !== claimId || typeof request.pid !== "number") return null;
-	return { pid: request.pid };
-}
-function clearNativeRunCancel(root, claimId) {
-	try {
-		clearWorkspaceStateKey(root, CANCEL_REQUEST_KEY, (value) => value?.claimId === claimId);
-	} catch {}
-}
-/** The active native run of `context`'s operation aborts this signal when it is cancelled. */
-function runCancellationSignal(context) {
-	return operationState(context).runSignal;
-}
-/** Why `context`'s native run was cancelled, or null while it was not. */
-function runCancellation(context) {
-	return operationState(context).cancelled;
-}
-function cancelledFailure(context, platform, { code, message }) {
-	const cancelled = runCancellation(context);
-	if (cancelled === null || code === "STIM_CLAIM_UNAVAILABLE") return null;
-	return {
-		code: "STIM_CANCELLED",
-		message: `The ${platform} run was ${cancelled} before it finished.`,
-		remedy: `Run \`stim ${platform}\` again when you want the app on a device.`,
-		lines: [`it stopped at ${code ?? "an unfinished step"}${message ? `: ${message}` : ""}`]
-	};
-}
-function cancelOnAbort({ context, root, claim, write, controller }) {
-	const state = operationState(context);
-	const cancel = () => {
-		if (controller.signal.aborted) return;
-		const request = cancelRequestFor(root, claim.claimId);
-		const cancelled = request ? `cancelled by \`stim stop\` (pid ${request.pid})` : "cancelled by an interrupt";
-		state.cancelled = cancelled;
-		state.handled = true;
-		controller.abort();
-		refuseDeclaredSpawns(context, `the run was ${cancelled}`);
-		const signalled = signalDeclaredSpawns(context, "SIGINT");
-		if (signalled > 0 || request) state.draining = true;
-		write(signalled > 0 ? `${cancelled}; stopping the running build tool` : request ? `${cancelled}; stopping before the next build tool or install` : cancelled);
-	};
-	const onAbort = () => {
-		if (!isTermination(context.signal.reason)) cancel();
-	};
-	const onRequest = () => {
-		if (controller.signal.aborted || !cancelRequestFor(root, claim.claimId)) return;
-		cancel();
-		state.abortOperation?.("stop");
-	};
-	context.signal.addEventListener("abort", onAbort);
-	if (context.signal.aborted) onAbort();
-	requestListeners.set(claim.claimId, onRequest);
-	const watch = setInterval(onRequest, REQUEST_POLL_MS);
-	watch.unref();
-	return async () => {
-		clearInterval(watch);
-		requestListeners.delete(claim.claimId);
-		context.signal.removeEventListener("abort", onAbort);
-		allowDeclaredSpawns(context);
-		await withWorkspaceStateLockAsync(root, () => clearNativeRunCancel(root, claim.claimId)).catch(() => {});
-	};
-}
-/**
-* Run an `ios`, `android` or `macos` invocation under the workspace's native-run lock: the claim records the
-* command, platform and slot, and a wait for another holder is reported on `write`. An abort of `context.signal`
-* forwards an interrupt to the running declared build tool and refuses any later one; a run `stim stop` cancelled
-* stops before its next build tool or install. A `SIGTERM` abort reason is left to the caller.
-*/
-function withNativeBuildRun(context, root, details, fn, { write }) {
-	const notice = nativeRunWaitNotice({ write });
-	const state = operationState(context);
-	return withWorkspaceProcessLock(workspaceDir(root), NATIVE_RUN_LOCK, async (claim) => {
-		state.cancelled = null;
-		const controller = new AbortController();
-		state.runSignal = controller.signal;
-		const dispose = cancelOnAbort({
-			context,
-			root,
-			claim,
-			write,
-			controller
-		});
-		try {
-			return await fn(claim);
-		} finally {
-			await dispose();
-			state.runSignal = void 0;
-		}
-	}, {
-		external: true,
-		signal: context.signal,
-		waitMs: NATIVE_RUN_WAIT_MS,
-		declareSpawnsFor: context,
-		details: {
-			...details,
-			interrupt: state.takesSignals ? "signal" : "request"
-		},
-		onHeld: (holder) => notice(holder)
-	});
-}
-//#endregion
-export { decideStopAction as a, nativeRunWaitNotice as c, runCancellationSignal as d, withNativeBuildRun as f, shareCompilationCache as h, clearNativeRunCancel as i, requestNativeRunCancel as l, claimForEmptying as m, NATIVE_RUN_WAIT_MS as n, describeNativeRunHolder as o, cacheUser as p, cancelledFailure as r, nativeRunHolder as s, NATIVE_RUN_LOCK as t, runCancellation as u };

package/dist/paths-DQtTgsBf.mjs

@@ -1,42 +0,0 @@
-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 };