stim 1.20.2 → 1.22.0

package/dist/build-plan-DUC8Ka9y.mjs

@@ -0,0 +1,248 @@
+import { y as trackReportResource } from "./exec-DEoAhcze.mjs";
+import { i as formatDuration, l as phaseLine, m as shortHash, u as plural } from "./command-output-gwpm28fu.mjs";
+import { Ht as makeTemporaryDirectory, Wt as removeTemporaryEntryAsync } from "./settings-C7O8A6ZI.mjs";
+import { G as readStats, L as estimateBuild, Vn as easAuthNote } from "./budget-Cvwn54qV.mjs";
+import { o as entryDir, t as artifactIn } from "./build-cache-Dv7RN200.mjs";
+import { a as staleNativeDirRefusal, c as predictBuildMiss } from "./prebuild-D4JoEAEs.mjs";
+import chalk from "chalk";
+import { PROVIDER_LOAD_TIMEOUT_ENV, PROVIDER_LOAD_TIMEOUT_MS, buildResolveTimeoutMs, resolveTieredBuild, timeoutFromEnv } from "@stim-cli/cache";
+//#region src/commands/build-plan.ts
+const DISCARD = {
+	file: "",
+	written: 0,
+	dropped: 0,
+	lastError: null,
+	write: () => true,
+	close: () => ({
+		file: "",
+		written: 0,
+		dropped: 0,
+		lastError: null
+	})
+};
+async function providerHit({ root, platform, cacheKey, providerConfig }, deps) {
+	if (!providerConfig) return null;
+	let destinationDir;
+	try {
+		destinationDir = makeTemporaryDirectory(root, "stim-plan-");
+	} catch (error) {
+		deps.note(chalk.yellow(phaseLine("cache", `provider not checked: ${error?.message || error}`)));
+		return null;
+	}
+	let pending = Promise.resolve();
+	const cleanupFailure = Object.assign(/* @__PURE__ */ new Error(`Cache provider cleanup did not finish within 35 seconds. Retained ${destinationDir}.`), {
+		code: "STIM_CLAIM_UNAVAILABLE",
+		reportCleanup: true,
+		remedy: "Confirm that no cache work is still using the retained download directory before inspecting its permissions and removing it."
+	});
+	let cleanup;
+	let close;
+	const closed = new Promise((resolve) => {
+		close = resolve;
+	});
+	const finish = () => cleanup ??= finishProviderDownload(pending, destinationDir, cleanupFailure).finally(() => close());
+	trackReportResource(deps.operation, closed, finish, deps.operation?.signal, cleanupFailure);
+	try {
+		const found = await resolveTieredBuild({
+			local: {
+				resolve: () => null,
+				store: () => null
+			},
+			loadProvider: async () => {
+				const loaded = await deps.loadCacheProvider({
+					projectRoot: root,
+					config: providerConfig,
+					...deps.operation ? { env: deps.operation.env } : {},
+					timeoutMs: timeoutFromEnv(PROVIDER_LOAD_TIMEOUT_ENV, PROVIDER_LOAD_TIMEOUT_MS, deps.operation?.env)
+				});
+				const capability = loaded?.provider?.builds;
+				if (!capability) return loaded;
+				return {
+					...loaded,
+					provider: {
+						...loaded.provider,
+						builds: {
+							store: capability.store.bind(capability),
+							resolve: (request) => {
+								const resolving = Promise.resolve().then(() => capability.resolve(request));
+								pending = resolving.then(() => void 0, (cause) => {
+									if (cause instanceof Error && "reportCleanup" in cause) throw cause;
+								});
+								return resolving;
+							}
+						}
+					}
+				};
+			},
+			signal: deps.operation?.signal,
+			timeoutMs: buildResolveTimeoutMs(deps.operation?.env),
+			target: {
+				projectRoot: root,
+				platform,
+				key: cacheKey
+			},
+			destinationDir,
+			warn: (_code, message) => deps.note(chalk.yellow(phaseLine("cache", message)))
+		});
+		return found ? found.providerName ?? "the cache provider" : null;
+	} finally {
+		await finish();
+	}
+}
+async function finishProviderDownload(pending, destinationDir, cleanupFailure) {
+	let timer;
+	if (!await Promise.race([pending.then(() => true), new Promise((resolve) => {
+		timer = setTimeout(() => resolve(false), 35e3);
+	})]).finally(() => clearTimeout(timer))) throw cleanupFailure;
+	try {
+		await removeTemporaryEntryAsync(destinationDir);
+	} catch (cause) {
+		throw Object.assign(new Error(`Cache provider download cleanup failed. Retained ${destinationDir}.`, { cause }), {
+			code: "STIM_CLAIM_UNAVAILABLE",
+			reportCleanup: true,
+			remedy: "Check the retained directory permissions and remove it before retrying."
+		});
+	}
+}
+async function expoRemoteHit(lookup, deps) {
+	if (!lookup.expoRemote) return null;
+	const { root, platform, isExpo, fingerprint } = lookup;
+	const loaded = await deps.loadProjectProvider(root, {
+		isExpo,
+		context: deps.operation
+	});
+	if (loaded?.unavailable) {
+		deps.note(chalk.yellow(phaseLine("cache", `provider not usable: ${loaded.unavailable}`)));
+		return null;
+	}
+	if (!loaded?.provider) return null;
+	const name = loaded.name ?? "the build cache provider";
+	if (name === "eas") {
+		const auth = await deps.checkEasAuth({
+			context: deps.operation,
+			projectRoot: root,
+			owner: loaded.owner || null
+		});
+		const authNote = easAuthNote(auth);
+		if (authNote) deps.note(chalk.yellow(phaseLine("cache", authNote)));
+		if (auth?.code === "logged-out") return null;
+	}
+	const hit = await deps.resolveRemote({
+		context: deps.operation,
+		provider: loaded.provider,
+		platform,
+		projectRoot: root,
+		fingerprintHash: fingerprint,
+		runOptions: lookup.expoRemote.runOptions,
+		logWriter: DISCARD
+	});
+	if (hit?.timedOut) deps.note(chalk.yellow(phaseLine("cache", `${name} did not answer; counted as a miss`)));
+	else if (hit?.failed) deps.note(chalk.yellow(phaseLine("cache", `${name} could not be used: ${hit.failed}`)));
+	return hit?.appPath ? name : null;
+}
+async function planCachedBuild(lookup, deps) {
+	const { root, platform, isExpo, fingerprint, sources, cacheKey, cachePolicy } = lookup;
+	deps.operation?.signal.throwIfAborted();
+	let cacheHit = false;
+	let provider = null;
+	if (cachePolicy.read) {
+		if (artifactIn(entryDir(platform, cacheKey))) cacheHit = "local";
+		else {
+			provider = (cachePolicy.remote ? await providerHit(lookup, deps) : null) ?? await expoRemoteHit(lookup, deps);
+			if (provider) cacheHit = "remote";
+		}
+	}
+	deps.operation?.signal.throwIfAborted();
+	let prebuild = null;
+	let refusal = null;
+	let missReason;
+	if (!cacheHit) {
+		prebuild = await deps.planPrebuild(root, platform, {
+			isExpo,
+			fingerprint,
+			sources
+		}, deps.operation?.signal);
+		if (prebuild === "refuse") refusal = staleNativeDirRefusal(platform);
+		else if (cachePolicy.read) missReason = predictBuildMiss({
+			root,
+			platform,
+			current: {
+				hash: fingerprint,
+				sources
+			},
+			prebuild: prebuild === "generate" || prebuild === "regenerate" ? prebuild : null
+		});
+	}
+	return planPayload(lookup, {
+		fingerprint,
+		cacheKey,
+		cacheHit,
+		provider,
+		cacheSkipped: !cachePolicy.read,
+		prebuild,
+		...missReason ? { missReason } : {},
+		refusal
+	});
+}
+function planPayload({ platform, slot, projectKey }, found) {
+	const { refusal, missReason, ...rest } = found;
+	const outcome = refusal ? null : found.cacheHit ? "hit" : "cold";
+	const estimate = outcome ? estimateBuild(readStats().record?.history?.[projectKey], platform, outcome) : {
+		expectedMs: null,
+		basis: 0
+	};
+	return {
+		platform,
+		...slot === "default" ? {} : { slot },
+		...rest,
+		outcome,
+		expectedMs: estimate.expectedMs,
+		basis: estimate.basis,
+		...missReason ? { missReason } : {},
+		...refusal ? { refusal } : {}
+	};
+}
+function cacheLine(plan) {
+	if (plan.refusal) return `the build would refuse with ${plan.refusal.code}`;
+	if (plan.cacheHit === "local") return "local cache hit";
+	if (plan.cacheHit === "remote") return `remote cache hit (${plan.provider})`;
+	return `${plan.cacheSkipped ? "cache reads are off" : "cache miss"}: compiles${plan.prebuild === "generate" || plan.prebuild === "regenerate" ? `, ${plan.prebuild}s the native dir` : ""}`;
+}
+function printPlan(plan, json) {
+	if (json) {
+		console.log(JSON.stringify(plan));
+		return;
+	}
+	const slot = plan.slot ? ` [${plan.slot}]` : "";
+	console.log(phaseLine("plan", `${plan.platform}${slot} ${shortHash(plan.fingerprint)} -> ${cacheLine(plan)}`));
+	if (plan.placement) console.log(phaseLine("placement", plan.placement));
+	if (plan.missReason) console.log(phaseLine("cache", `miss: ${plan.missReason.summary}`));
+	if (plan.refusal) {
+		console.log(phaseLine("error", plan.refusal.message));
+		console.log(phaseLine("remedy", plan.refusal.remedy));
+		return;
+	}
+	console.log(phaseLine("expect", plan.expectedMs === null ? `unknown: no ${plan.outcome} run of this project is recorded yet` : `~${formatDuration(plan.expectedMs)} (median of ${plural(plan.basis, `${plan.outcome} run`)})`));
+}
+function refusePlan({ code, message, remedy }, json, lines = []) {
+	console.error(chalk.red(phaseLine("error", message)));
+	for (const line of lines) console.error(chalk.dim(phaseLine("", line)));
+	console.error(chalk.dim(phaseLine("remedy", remedy)));
+	console.error(chalk.red(phaseLine("failed", code)));
+	if (json) console.log(JSON.stringify({
+		code,
+		message,
+		remedy
+	}));
+	process.exitCode = 1;
+}
+const PLAN_ONLY_REMEDY = "Drop the flag to plan the owned simulator or emulator build, or run the command without --plan.";
+function planFlagRefusal(flag) {
+	return {
+		code: "STIM_BAD_ARG",
+		message: `${flag} does not apply to --plan, which predicts the next local build without choosing a device.`,
+		remedy: PLAN_ONLY_REMEDY
+	};
+}
+//#endregion
+export { refusePlan as a, printPlan as i, planFlagRefusal as n, planPayload as r, planCachedBuild as t };

package/dist/{cache-manifest-XH-fvDUj.mjs → cache-manifest-DSeQjt-Q.mjs}

@@ -1,7 +1,7 @@
-import { d as getConfigDir } from "./config-BYDxlMY3.mjs";
+import { d as getConfigDir } from "./config-DlrsduwG.mjs";
+import { cacheDirRefusal, readCacheManifest, updateCacheManifest } from "@stim-cli/core";
 import { join, resolve } from "path";
 import { existsSync } from "fs";
-import { cacheDirRefusal, readCacheManifest, updateCacheManifest } from "@stim-cli/core";
 import { homedir } from "os";
 //#region src/cache/cache-manifest.ts
 function manifestPath() {

package/dist/cache-manifest.mjs

@@ -1,2 +1,2 @@
-import { a as unregister, i as registeredCaches, n as readManifest, r as register, t as manifestPath } from "./cache-manifest-XH-fvDUj.mjs";
+import { a as unregister, i as registeredCaches, n as readManifest, r as register, t as manifestPath } from "./cache-manifest-DSeQjt-Q.mjs";
 export { manifestPath, readManifest, register, registeredCaches, unregister };

package/dist/{ccache-zdKiYQ3E.mjs → ccache-Btwc36-I.mjs}

@@ -1,10 +1,10 @@
-import { _ as loadConfig } from "./config-BYDxlMY3.mjs";
-import { t as getExecutor } from "./exec-DqKo9GKJ.mjs";
-import { r as register } from "./cache-manifest-XH-fvDUj.mjs";
-import { m as defaultAndroidLayout } from "./settings-B717odTD.mjs";
-import { h as sharedCcache, w as workspaceLogsDir } from "./workspace-state-DJt_MMvf.mjs";
-import { l as phaseLine } from "./command-output-BTy8hZ0F.mjs";
-import { o as machineNumber } from "./budget-f7516Zk0.mjs";
+import { t as getExecutor } from "./exec-DEoAhcze.mjs";
+import { a as sharedCcache, m as workspaceLogsDir } from "./paths-DQtTgsBf.mjs";
+import { _ as loadConfig } from "./config-DlrsduwG.mjs";
+import { l as phaseLine } from "./command-output-gwpm28fu.mjs";
+import { m as defaultAndroidLayout } from "./settings-C7O8A6ZI.mjs";
+import { r as register } from "./cache-manifest-DSeQjt-Q.mjs";
+import { o as machineNumber } from "./budget-Cvwn54qV.mjs";
 import { readFileSync, realpathSync } from "node:fs";
 import { isAbsolute, join, relative } from "node:path";
 import chalk from "chalk";
@@ -106,7 +106,7 @@ function canonical(root) {
 		return root;
 	}
 }
-function resolveCcache({ root, layout = defaultAndroidLayout(root), dir = sharedCcache(), lookup = lookupCcache, onNote = (line) => console.error(line) }) {
+function resolveCcache({ root, layout = defaultAndroidLayout(root), dir = sharedCcache(), lookup = lookupCcache, env = process.env, onNote = (line) => console.error(line) }) {
 	const binary = lookup();
 	if (!binary) {
 		onNote(chalk.dim(phaseLine("cache", "ccache off (not installed; brew install ccache)")));
@@ -121,6 +121,7 @@ function resolveCcache({ root, layout = defaultAndroidLayout(root), dir = shared
 	const statsLog = ccacheStatsLog(root);
 	register({
 		dir,
+		registeredBy: root,
 		name: "ccache",
 		prune: "atomic",
 		note: "ccache keeps itself under CCACHE_MAXSIZE, so it is emptied whole or not at all"
@@ -134,7 +135,7 @@ function resolveCcache({ root, layout = defaultAndroidLayout(root), dir = shared
 			dir,
 			workspaceRoot: canonical(root),
 			statsLog,
-			maxSize: ccacheMaxSize()
+			maxSize: ccacheMaxSize(loadConfig(), env)
 		})
 	};
 }

package/dist/{cdp-Dq_ypAlJ.mjs → cdp-3fwICjzi.mjs}

@@ -1,8 +1,10 @@
+import { d as cancelledError, f as throwIfCancelled } from "./operation-exec-BW0em61G.mjs";
 import { WebSocket } from "ws";
 //#region src/web/cdp.ts
 const COMMAND_TIMEOUT_MS = 15e3;
-function connectCdp(url, { timeoutMs = 5e3 } = {}) {
+function connectCdp(url, { timeoutMs = 5e3, signal } = {}) {
 	return new Promise((resolve, reject) => {
+		if (signal?.aborted) return reject(cancelledError("browser operation"));
 		const socket = new WebSocket(url, {
 			perMessageDeflate: false,
 			maxPayload: 268435456
@@ -12,10 +14,13 @@ function connectCdp(url, { timeoutMs = 5e3 } = {}) {
 		const closeListeners = [];
 		let nextId = 1;
 		let closed = false;
+		let opened = false;
 		const timer = setTimeout(() => {
 			socket.terminate();
 			reject(/* @__PURE__ */ new Error(`DevTools did not accept a connection at ${url} within ${timeoutMs}ms`));
 		}, timeoutMs);
+		const abort = () => socket.terminate();
+		signal?.addEventListener("abort", abort, { once: true });
 		socket.on("message", (data) => {
 			let message;
 			try {
@@ -42,7 +47,11 @@ function connectCdp(url, { timeoutMs = 5e3 } = {}) {
 		});
 		socket.on("close", () => {
 			closed = true;
-			for (const waiter of pending.values()) waiter.reject(/* @__PURE__ */ new Error("DevTools connection closed"));
+			clearTimeout(timer);
+			signal?.removeEventListener("abort", abort);
+			const error = signal?.aborted ? cancelledError("browser operation") : /* @__PURE__ */ new Error("DevTools connection closed");
+			if (!opened) reject(error);
+			for (const waiter of pending.values()) waiter.reject(error);
 			pending.clear();
 			for (const listener of closeListeners) listener();
 		});
@@ -51,9 +60,11 @@ function connectCdp(url, { timeoutMs = 5e3 } = {}) {
 			reject(error);
 		});
 		socket.on("open", () => {
+			opened = true;
 			clearTimeout(timer);
 			resolve({
 				send(method, params = {}, sessionId) {
+					if (signal?.aborted) return Promise.reject(cancelledError("browser operation"));
 					if (closed) return Promise.reject(/* @__PURE__ */ new Error("DevTools connection closed"));
 					const id = nextId++;
 					return new Promise((resolveCommand, rejectCommand) => {
@@ -97,10 +108,12 @@ function connectCdp(url, { timeoutMs = 5e3 } = {}) {
 * Connects to the browser DevTools endpoint on loopback `port` only when the process serving it is `chromePid`,
 * the Chrome Stim started. Chrome reports its own browser process through `SystemInfo.getProcessInfo`.
 */
-async function connectOwnedBrowser(port, chromePid) {
-	const { webSocketDebuggerUrl } = await (await fetch(`http://127.0.0.1:${port}/json/version`, { signal: AbortSignal.timeout(2e3) })).json();
+async function connectOwnedBrowser(port, chromePid, signal) {
+	throwIfCancelled(signal, "browser operation");
+	const { webSocketDebuggerUrl } = await (await fetch(`http://127.0.0.1:${port}/json/version`, { signal: signal ? AbortSignal.any([signal, AbortSignal.timeout(2e3)]) : AbortSignal.timeout(2e3) })).json();
 	if (typeof webSocketDebuggerUrl !== "string" || !webSocketDebuggerUrl.startsWith(`ws://127.0.0.1:${port}/`)) throw new Error(`port ${port} does not serve a browser DevTools endpoint`);
-	const cdp = await connectCdp(webSocketDebuggerUrl);
+	throwIfCancelled(signal, "browser operation");
+	const cdp = await connectCdp(webSocketDebuggerUrl, { signal });
 	try {
 		const { processInfo } = await cdp.send("SystemInfo.getProcessInfo");
 		const browser = processInfo?.find((entry) => entry.type === "browser")?.id;

package/dist/{chrome-BnzZMqsR.mjs → chrome-Bbw689-6.mjs}

@@ -1,7 +1,7 @@
-import { t as getExecutor } from "./exec-DqKo9GKJ.mjs";
+import { t as getExecutor } from "./exec-DEoAhcze.mjs";
 import { existsSync } from "node:fs";
-import { join } from "node:path";
 import { homedir } from "node:os";
+import { join } from "node:path";
 //#region src/web/chrome.ts
 const CHROME_INSTALL_REMEDY = "Install Google Chrome from https://www.google.com/chrome/ (or Chromium), then run `stim doctor`.";
 const MAC_APPS = [["Google Chrome.app", "Google Chrome"], ["Chromium.app", "Chromium"]];
@@ -21,8 +21,11 @@ function chromeCandidates(host, { home = homedir(), env = process.env } = {}) {
 	return [];
 }
 /** The installed Chrome or Chromium executable Stim launches, or null when none is installed. */
-function findChrome({ host = process.platform, exists = existsSync, findExecutable = (name) => getExecutor().findExecutable(name) } = {}) {
-	const installed = chromeCandidates(host).find((path) => exists(path));
+function findChrome({ host = process.platform, env = process.env, home = env.HOME || env.USERPROFILE || homedir(), exists = existsSync, findExecutable = (name) => getExecutor().findExecutable(name) } = {}) {
+	const installed = chromeCandidates(host, {
+		home,
+		env
+	}).find((path) => exists(path));
 	if (installed) return installed;
 	for (const name of PATH_NAMES) {
 		const found = findExecutable(name);

package/dist/{cli-CLP3diBm.mjs → cli-CHZa9Lvk.mjs}

@@ -1,27 +1,27 @@
-import { y as refuseRelativeStimPaths } from "./config-BYDxlMY3.mjs";
-import { r as debugLog } from "./exec-DqKo9GKJ.mjs";
+import { b as debugLog } from "./exec-DEoAhcze.mjs";
+import { y as refuseRelativeStimPaths } from "./config-DlrsduwG.mjs";
 import { readFileSync } from "node:fs";
 import { runId } from "@stim-cli/core/state";
 import { Command } from "commander";
 //#region bin/cli.ts
 const commands = /* @__PURE__ */ new Map([
-	["doctor", () => import("./doctor-CB8oZKCk.mjs")],
-	["worktree", () => import("./worktree-DpLdCHga.mjs")],
-	["start", () => import("./start-TXeMmmO2.mjs")],
-	["ports", () => import("./ports-DdSUicVo.mjs")],
-	["stop", () => import("./stop-DR6VoDIk.mjs")],
-	["ios", () => import("./ios-BwVCF7oA.mjs")],
-	["android", () => import("./android-Dlzxshgp.mjs")],
-	["web", () => import("./web-Dq-i3wzJ.mjs")],
-	["macos", () => import("./macos-D7uDvO-z.mjs")],
-	["reload", () => import("./reload-C8JhxjSh.mjs")],
-	["device", () => import("./device-DuiPJQSn.mjs")],
-	["logs", () => import("./logs-BGrEUaEs.mjs")],
-	["settings", () => import("./settings-BORNaaCO.mjs")],
-	["status", () => import("./status-WgFbkRzj.mjs")],
-	["stats", () => import("./stats-BoY5sEPU.mjs")],
-	["gc", () => import("./gc-qWOMdnER.mjs")],
-	["guide", () => import("./guide-G9cAbVAc.mjs")]
+	["doctor", () => import("./doctor-thjWAV0z.mjs")],
+	["worktree", () => import("./worktree-ZqZVjD9K.mjs")],
+	["start", () => import("./start-Br-oxqMD.mjs")],
+	["ports", () => import("./ports-Cy1RkmuQ.mjs")],
+	["stop", () => import("./stop-DTZ9uTw3.mjs")],
+	["ios", () => import("./ios-Ds1clbIt.mjs")],
+	["android", () => import("./android-DGkNqa_c.mjs")],
+	["web", () => import("./web-CZ07gd77.mjs")],
+	["macos", () => import("./macos-DVlSSyUg.mjs")],
+	["reload", () => import("./reload-D7AVlb8N.mjs")],
+	["device", () => import("./device-DklWZLqb.mjs")],
+	["logs", () => import("./logs-jTS_lHSo.mjs")],
+	["settings", () => import("./settings-DpR-1Wnn.mjs")],
+	["status", () => import("./status-EvrK72L2.mjs")],
+	["stats", () => import("./stats-D3GerlFW.mjs")],
+	["gc", () => import("./gc-DnNDQyaP.mjs")],
+	["guide", () => import("./guide-Br0LEfKy.mjs")]
 ]);
 const pkg = JSON.parse(readFileSync(new URL("../package.json", import.meta.url), "utf-8"));
 const program = new Command();
@@ -52,7 +52,7 @@ try {
 			}));
 		}
 		try {
-			const { triggerMaintenance } = await import("./trigger-9_USgmxz.mjs");
+			const { triggerMaintenance } = await import("./trigger-yb_nFzPF.mjs");
 			triggerMaintenance(action.name());
 		} catch {}
 	});

package/dist/cli.mjs

@@ -4,6 +4,6 @@ const encode = (version) => version.split(".", 3).reduce((sum, part) => sum * 1e
 if (encode(process.versions.node) < encode("22.12.0")) {
 	process.stderr.write(`STIM_NODE_UNSUPPORTED: Stim needs Node 22.12.0 or later; this is Node ${process.versions.node} at ${process.execPath}. To run Stim where a project pins an older Node, see https://stim.appandflow.com/docs/requirements#older-node-pins\n`);
 	process.exitCode = 1;
-} else import("./cli-CLP3diBm.mjs");
+} else import("./cli-CHZa9Lvk.mjs");
 //#endregion
 export {};