stim 1.8.0 → 1.9.0

package/dist/simslim-B_LsGLuJ.mjs

@@ -0,0 +1,259 @@
+import { D as process_identity_exports, K as projectDeviceSlots, U as deviceSlotPlatforms, g as loadConfig, k as ownership_claim_exports, u as getConfigDir } from "./config-Cp9lM3wX.mjs";
+import { t as getExecutor } from "./exec-jIAlgilk.mjs";
+import { n as stripAnsi, r as waitForChild, t as createLineReader } from "./process-output-Fpl8PYi8.mjs";
+import { C as listAdbDevices } from "./android-_y4Ohi5z.mjs";
+import { c as iosRuntimeMatches, u as listAllIosSims } from "./ios-BL2NFckr.mjs";
+import { join } from "node:path";
+//#region src/engine/device-capacity.ts
+function liveOwnedDeviceCount({ sims = [], adbEmulators = [], config = null } = {}) {
+	let count = 0;
+	for (const sim of sims) if (sim?.state === "Booted" && sim.name?.startsWith("stim-")) count++;
+	const livePorts = new Set(adbEmulators.map((e) => e.consolePort));
+	for (const proj of Object.values(config?.projects || {})) for (const { platforms } of projectDeviceSlots(proj)) {
+		const android = platforms.android;
+		if (android?.owned && android.avdName && typeof android.consolePort === "number" && livePorts.has(android.consolePort)) count++;
+	}
+	return count;
+}
+function workspaceHasLiveDevice({ platform, project, slot = "default", sims = [], adbEmulators = [] } = {}) {
+	if (!platform) return false;
+	const record = deviceSlotPlatforms(project, slot)?.[platform];
+	if (!record) return false;
+	if (platform === "ios") return sims.some((s) => s.udid === record.deviceUdid && s.state === "Booted");
+	return typeof record.consolePort === "number" && adbEmulators.some((e) => e.consolePort === record.consolePort);
+}
+function deviceCapacityRefusal({ platform, project, slot = "default", max, sims = [], adb = null, config = null } = {}) {
+	if (!max || max <= 0) return null;
+	const adbEmulators = adb?.emulators || [];
+	if (workspaceHasLiveDevice({
+		platform,
+		project,
+		slot,
+		sims,
+		adbEmulators
+	})) return null;
+	const count = liveOwnedDeviceCount({
+		sims,
+		adbEmulators,
+		config
+	});
+	if (count < max) return null;
+	return {
+		code: "STIM_AT_CAPACITY",
+		message: `${count} Stim device(s) are already booted and concurrency.maxDevices is ${max}, so booting another would exceed the cap.`,
+		remedy: "stop an environment (stim stop) or raise concurrency.maxDevices"
+	};
+}
+function checkDeviceCapacity({ platform, project, slot = "default", max, sims = listAllIosSims, adb = listAdbDevices, config = loadConfig } = {}) {
+	if (!max || max <= 0) return null;
+	let simList = [];
+	let adbRes = {
+		emulators: [],
+		physical: [],
+		unhealthy: []
+	};
+	try {
+		simList = typeof sims === "function" ? sims() || [] : sims || [];
+	} catch {}
+	try {
+		adbRes = typeof adb === "function" ? adb() || adbRes : adb || adbRes;
+	} catch {}
+	let cfg = null;
+	try {
+		cfg = typeof config === "function" ? config() : config ?? null;
+	} catch {}
+	return deviceCapacityRefusal({
+		platform,
+		project,
+		slot,
+		max,
+		sims: simList,
+		adb: adbRes,
+		config: cfg
+	});
+}
+function deviceTypeMismatch(recordedTypeId, requestedName, deviceTypes) {
+	if (!requestedName || !recordedTypeId) return null;
+	const wanted = (deviceTypes || []).find((d) => d.name === requestedName);
+	if (!wanted) return null;
+	if (wanted.identifier === recordedTypeId) return null;
+	const recorded = (deviceTypes || []).find((d) => d.identifier === recordedTypeId);
+	return `this project's sim is ${recorded ? recorded.name : recordedTypeId}, but --device-type asked for ${requestedName}`;
+}
+function installedNames(names) {
+	const unique = [...new Set(names.filter((n) => typeof n === "string" && n !== ""))];
+	return unique.length > 0 ? unique.join(", ") : "none";
+}
+function unknownIosRuntimeRefusal(requested, runtimes) {
+	if (!requested) return null;
+	if ((runtimes || []).some((r) => iosRuntimeMatches(r, requested))) return null;
+	return {
+		message: `No installed simulator runtime matches "${requested}". Installed runtimes: ${installedNames((runtimes || []).map((r) => r.version))}.`,
+		remedy: "Pass `--runtime` (or set ios.runtime) a version printed above (\"26.5\") or a runtime's full name (\"iOS 26.5\"); nothing else matches. Install more runtimes through Xcode."
+	};
+}
+function creatableIosDeviceTypeNames(runtimes, runtime) {
+	return (runtime ? (runtimes || []).filter((r) => iosRuntimeMatches(r, runtime)) : runtimes || []).flatMap((r) => (r.supportedDeviceTypes || []).map((d) => d.name));
+}
+function unknownIosDeviceTypeRefusal(requested, runtimes, runtime) {
+	if (!requested) return null;
+	const creatable = creatableIosDeviceTypeNames(runtimes, runtime);
+	if (creatable.includes(requested)) return null;
+	return {
+		message: `No device type named "${requested}" can be created on ${runtime ? `runtime ${runtime}` : "any installed simulator runtime"}. ${runtime ? `Device types runtime ${runtime} supports` : "Device types the installed runtimes support"}: ${installedNames(creatable)}.`,
+		remedy: "Pass `--device-type` (or set ios.deviceType) one of the names printed above, exactly as `xcrun simctl list devicetypes` spells it. `xcrun simctl list devicetypes` also lists watchOS, tvOS and visionOS models, which no iOS runtime can create. Install more models through Xcode."
+	};
+}
+function unknownAndroidSystemImageRefusal(requested, images) {
+	if (!requested) return null;
+	if ((images || []).some((i) => i.pkg === requested)) return null;
+	return {
+		message: `No installed Android system image is named "${requested}". Installed system images: ${installedNames((images || []).map((i) => i.pkg))}.`,
+		remedy: "Pass `--system-image` (or set android.systemImage) to one of the package ids printed above. Install more with `sdkmanager \"system-images;android-36;google_apis;arm64-v8a\"`."
+	};
+}
+//#endregion
+//#region src/engine/simslim.ts
+async function reconcileSimSlim({ udid, profile, previouslyManaged = false, out = () => {}, spawn, timeoutMs = 72e4, cleanupMs = 1e4 }) {
+	if (!profile && !previouslyManaged) return {
+		managed: false,
+		profile: null
+	};
+	const action = profile ? "on" : "off";
+	const args = profile ? [
+		"on",
+		udid,
+		"--profile",
+		profile
+	] : ["off", udid];
+	const lines = [];
+	const onLine = (raw) => {
+		const line = stripAnsi(raw).trim();
+		if (!line) return;
+		lines.push(line);
+		if (lines.length > 20) lines.shift();
+		out(`SimSlim: ${line}`);
+	};
+	const stdout = createLineReader(onLine);
+	const stderr = createLineReader(onLine);
+	const root = join(getConfigDir(), "simslim-locks", `${encodeURIComponent(udid.toLowerCase())}.lock`);
+	const label = `SimSlim for ${udid}`;
+	const attempt = (0, ownership_claim_exports.tryAcquireClaim)({
+		root,
+		mode: "exclusive",
+		label
+	});
+	if (attempt.pending) (0, ownership_claim_exports.releaseClaim)(attempt.pending);
+	const claim = attempt.acquired;
+	if (!claim) throw new ownership_claim_exports.ClaimRefusedError({
+		root,
+		claimPath: attempt.held?.path ?? root,
+		label,
+		reason: "another SimSlim operation is still using this simulator"
+	});
+	let child;
+	let result;
+	let identity;
+	let cancellation;
+	const stopGroup = () => {
+		if (child?.pid !== void 0 && identity && (0, process_identity_exports.inspectProcessIdentity)(identity) === "same") try {
+			process.kill(-child.pid, "SIGKILL");
+		} catch {}
+	};
+	const cancel = (signal) => {
+		cancellation ??= signal;
+		stopGroup();
+	};
+	const onInterrupt = () => cancel("SIGINT");
+	const onTerminate = () => cancel("SIGTERM");
+	const groupAlive = () => child?.pid !== void 0 && (0, ownership_claim_exports.processGroupAlive)(child.pid);
+	const settled = () => result !== void 0 && !groupAlive();
+	const waitUntil = async (deadline, cancellable = false) => {
+		while (!settled() && Date.now() < deadline) {
+			if (cancellable && cancellation) break;
+			await new Promise((resolve) => setTimeout(resolve, Math.min(50, deadline - Date.now())));
+		}
+		return settled();
+	};
+	process.on("SIGINT", onInterrupt);
+	process.on("SIGTERM", onTerminate);
+	process.on("exit", stopGroup);
+	try {
+		(0, ownership_claim_exports.markClaimChildPending)(claim);
+		try {
+			child = (spawn ?? ((cmd, childArgs, opts) => getExecutor().spawn(cmd, childArgs, opts)))("simslim", args, {
+				stdio: [
+					"ignore",
+					"pipe",
+					"pipe"
+				],
+				detached: true
+			});
+		} catch (error) {
+			throw simslimLaunchError(error);
+		}
+		child.stdout?.on("data", (chunk) => stdout.push(chunk));
+		child.stderr?.on("data", (chunk) => stderr.push(chunk));
+		waitForChild(child).then((value) => {
+			result = value;
+		});
+		if (child.pid !== void 0) {
+			const captured = (0, process_identity_exports.captureProcessIdentity)(child.pid);
+			if (captured.ok) {
+				identity = {
+					pid: child.pid,
+					processToken: captured.token
+				};
+				try {
+					(0, ownership_claim_exports.setClaimChild)(claim, identity);
+				} catch {}
+			}
+		}
+		const completed = await waitUntil(Date.now() + timeoutMs, true);
+		if (cancellation || !completed) {
+			stopGroup();
+			const stopped = await waitUntil(Date.now() + cleanupMs);
+			const detail = lines.length ? ` ${lines.join(" | ")}` : "";
+			const recovery = stopped ? "Its process group has stopped. Retry stim ios to reconcile the retained simulator settings." : `Its process group could not be confirmed stopped. The claim remains at ${claim.path}. Inspect the SimSlim process group ${child.pid ?? "unknown"} before retrying. Only when nothing is using it, remove the claim: ${(0, ownership_claim_exports.claimRemoveCommand)(claim.path)}`;
+			const message = `SimSlim ${action} ${cancellation ? `interrupted by ${cancellation}` : `exceeded ${Math.round(timeoutMs / 1e3)}s`}. ${recovery}${detail}`;
+			if (cancellation) out(message);
+			throw Object.assign(new Error(message), { code: cancellation ? "EINTR" : "ETIMEDOUT" });
+		}
+	} finally {
+		if (!child || settled()) (0, ownership_claim_exports.releaseClaim)(claim);
+		else {
+			child.stdout?.destroy?.();
+			child.stderr?.destroy?.();
+			child.unref();
+		}
+		process.off("SIGINT", onInterrupt);
+		process.off("SIGTERM", onTerminate);
+		process.off("exit", stopGroup);
+		if (cancellation) process.exit(cancellation === "SIGINT" ? 130 : 143);
+	}
+	stdout.flush();
+	stderr.flush();
+	if (result?.error) throw simslimLaunchError(result.error);
+	if (result?.code !== 0) {
+		const detail = lines.length ? ` ${lines.join(" | ")}` : "";
+		throw new Error(`SimSlim ${action} failed with exit code ${result?.code ?? "unknown"}.${detail}`);
+	}
+	return {
+		managed: Boolean(profile),
+		profile: profile ?? null
+	};
+}
+function simslimLaunchError(error) {
+	const cause = error;
+	if (cause?.code === "ENOENT") return new Error("SimSlim is configured but the `simslim` command is not installed. Run `brew install mobai-app/tap/simslim`.", { cause });
+	return new Error(`Could not start SimSlim: ${String(cause?.message || cause)}`, { cause });
+}
+function simslimIsOnPath() {
+	try {
+		return Boolean(getExecutor().findExecutable("simslim"));
+	} catch {
+		return false;
+	}
+}
+//#endregion
+export { liveOwnedDeviceCount as a, unknownIosRuntimeRefusal as c, deviceTypeMismatch as i, simslimIsOnPath as n, unknownAndroidSystemImageRefusal as o, checkDeviceCapacity as r, unknownIosDeviceTypeRefusal as s, reconcileSimSlim as t };

package/dist/{slot-launch-ZUUe0TQP.mjs → slot-launch-DU9A-gYw.mjs}

@@ -1,7 +1,7 @@
-import { f as getProject } from "./config-B7iyKWkL.mjs";
-import { r as readWorkspaceState } from "./workspace-state-BT5E3SA2.mjs";
-import { h as deviceShellArg } from "./app-install-BDbsSgCl.mjs";
-import { n as fileLeaseIo } from "./device-lease-Ffz_M5t0.mjs";
+import { f as getProject } from "./config-Cp9lM3wX.mjs";
+import { r as readWorkspaceState } from "./workspace-state-DF2gCFhx.mjs";
+import { d as deviceShellArg } from "./app-install-Uf3a83Tv.mjs";
+import { n as fileLeaseIo } from "./device-lease-Crs-HkJY.mjs";
 //#region src/engine/slot-launch.ts
 function launchSlotScope(root, slot = "default") {
 	if (slot !== "default") return slot;

package/dist/spawn-claims-Dn3C_N6w.mjs

@@ -0,0 +1,49 @@
+import { D as process_identity_exports, k as ownership_claim_exports } from "./config-Cp9lM3wX.mjs";
+//#region src/engine/spawn-claims.ts
+const declaring = /* @__PURE__ */ new Set();
+/** Record every child later started through `spawnDeclared` on `claim` until `stopDeclaringSpawnsOn(claim)`. */
+function declareSpawnsOn(claim) {
+	if (claim) declaring.add(claim);
+}
+function stopDeclaringSpawnsOn(claim) {
+	if (claim) declaring.delete(claim);
+}
+/**
+* Start a child that every claim passed to `declareSpawnsOn` records until it exits. The child keeps
+* the caller's process group, so a terminal interrupt still reaches it; the claim follows the child
+* itself. A claim that cannot be marked stops the spawn rather than letting it run unprotected. A claim
+* records one child, so declared spawns must not overlap.
+*/
+function spawnDeclared(spawn) {
+	const claims = [...declaring];
+	if (claims.length === 0) return spawn();
+	const forget = () => {
+		for (const claim of claims) try {
+			(0, ownership_claim_exports.clearClaimChild)(claim);
+		} catch {}
+	};
+	let child;
+	try {
+		for (const claim of claims) (0, ownership_claim_exports.markClaimChildPending)(claim);
+		child = spawn();
+	} catch (error) {
+		forget();
+		throw error;
+	}
+	const pid = child.pid;
+	if (pid === void 0) {
+		forget();
+		return child;
+	}
+	const captured = (0, process_identity_exports.captureProcessIdentity)(pid);
+	if (captured.ok) for (const claim of claims) try {
+		(0, ownership_claim_exports.setClaimChild)(claim, {
+			pid,
+			processToken: captured.token
+		});
+	} catch {}
+	child.once("exit", forget);
+	return child;
+}
+//#endregion
+export { spawnDeclared as n, stopDeclaringSpawnsOn as r, declareSpawnsOn as t };

package/dist/{start-CmxtOKjU.mjs → start-DYkkKF0s.mjs}

@@ -1,23 +1,24 @@
-import { t as getExecutor } from "./exec-B29XNuhP.mjs";
-import { S as upsertProject, a as clearSupervisor, f as getProject, w as process_identity_exports } from "./config-B7iyKWkL.mjs";
-import { _ as workspaceLogsDir, c as ensureWorkspaceStorage, f as supervisorLogFile, o as writeWorkspaceState, r as readWorkspaceState } from "./workspace-state-BT5E3SA2.mjs";
-import { g as repoRoot, s as gitCommonDir } from "./worktree-FG_ZKKdb.mjs";
-import { a as findProjectRoot, i as detectIsExpo, n as detectAndroidPackage, r as detectBundleId, t as appProjectProblem } from "./project-DDZWf_16.mjs";
+import { D as process_identity_exports, a as clearSupervisor, f as getProject, w as upsertProject } from "./config-Cp9lM3wX.mjs";
+import { t as getExecutor } from "./exec-jIAlgilk.mjs";
+import { i as levelRank } from "./ndjson-9uFNRwfe.mjs";
+import { b as workspaceLogsDir, c as writeWorkspaceState, i as recordWorkspaceUse, m as supervisorLogFile, r as readWorkspaceState, u as ensureWorkspaceStorage } from "./workspace-state-DF2gCFhx.mjs";
+import { _ as repoRoot, s as gitCommonDir } from "./worktree-R_cUlE7s.mjs";
+import { a as detectIsExpo, i as detectBundleId, n as appProjectProblem, o as findProjectRoot, r as detectAndroidPackage, t as NO_PROJECT_REFUSAL } from "./project-DS112DYB.mjs";
 import { n as supervisorError } from "./errors-B6W7FkxQ.mjs";
-import { n as windowsLauncherArgs } from "./detached-entry-Bpo6ZY_I.mjs";
-import { i as clearManagedMetroTunnel, o as clearWorkspaceSupervisor, s as readMetroTunnel } from "./state-DZobzxLW.mjs";
-import { a as resolveProjectMetro, i as pidExists, l as reserveMetroPort, n as killMetroTree, o as signalProcessTree } from "./metro-C7bcJ0uo.mjs";
-import { A as resolveSettings, D as remoteDeviceSettingError, E as remoteAndroidSetting, F as tunnelModeSetting, I as unknownSettingKeys, L as PUBLIC_METRO_ENV, N as settingShapeErrors, O as remoteIosSetting, R as detectProviders, S as ngrokUrlSetting, T as publicUrlSetting, a as SETTING_SHAPE_REMEDY, b as metroTunnelSettingError, d as cacheProviderSettingError, k as resolveCacheProviderConfig, z as planMetroReach } from "./settings-BXXorVM2.mjs";
-import { g as stepTimer, l as phaseLine } from "./command-output-B3ycpsYv.mjs";
-import { n as workspaceProcessLockError, t as withWorkspaceProcessLock } from "./workspace-process-lock-BYfZz_S-.mjs";
+import { n as windowsLauncherArgs } from "./detached-entry-KEu0_AXL.mjs";
+import { i as clearManagedMetroTunnel, o as clearWorkspaceSupervisor, s as readMetroTunnel } from "./state-NcJzMEBF.mjs";
+import { a as pidExists, c as resolveProjectMetro, f as reserveMetroPort, l as signalProcessTree, n as killMetroTree } from "./metro-DrLHaMn2.mjs";
+import { D as remoteIosSetting, E as remoteAndroidSetting, F as unknownSettingKeys, G as planMetroReach, M as settingShapeErrors, O as resolveCacheProviderConfig, P as tunnelModeSetting, U as PUBLIC_METRO_ENV, W as detectProviders, i as SETTING_SHAPE_REMEDY, k as resolveSettings, u as cacheProviderSettingError, w as publicUrlSetting, x as ngrokUrlSetting, y as metroTunnelSettingError } from "./settings-D030k0t4.mjs";
+import { _ as stepTimer, l as phaseLine } from "./command-output-gByVmIjy.mjs";
+import { n as workspaceProcessLockError, t as withWorkspaceProcessLock } from "./workspace-process-lock-DWaiRD0e.mjs";
 import { t as spawnEntry } from "./spawn-entry-nCE6m770.mjs";
-import { c as queryLogs } from "./logs-query-BGL-Pl12.mjs";
-import { a as withManagedRemoteWorktreeLock, i as terminateChild, n as startTunnelSequence, r as stopTunnel, s as withManagedTunnelLock, t as resolveSupervisorTarget } from "./ownership-wolE-0Do.mjs";
+import { l as queryLogs } from "./logs-query-Cqma3WIu.mjs";
+import { a as terminateChild, c as withManagedTunnelLock, i as stopTunnel, o as withManagedRemoteWorktreeLock, r as startTunnelSequence, t as resolveSupervisorTarget } from "./ownership-DCQPuWEc.mjs";
 import { appendFileSync, mkdirSync, openSync, readFileSync } from "node:fs";
 import { dirname } from "node:path";
 import { EventEmitter } from "node:events";
-import { CACHE_PROVIDER_ENV, cacheProviderEnv } from "@stim-cli/cache";
 import chalk from "chalk";
+import { CACHE_PROVIDER_ENV, cacheProviderEnv } from "@stim-cli/cache";
 //#region src/supervisor/cache-reset.ts
 async function stopOwnedMetroForReset(root) {
 	const project = getProject(root);
@@ -179,11 +180,7 @@ function registerStart(program, overrides = {}) {
 		});
 		const waitSeconds = wait.seconds;
 		const root = findProjectRoot(process.cwd());
-		if (!root) return fail({
-			code: "STIM_NO_PROJECT",
-			message: "Not in a React Native project (no package.json found).",
-			remedy: "Run this from the app directory -- the one holding package.json."
-		});
+		if (!root) return fail(NO_PROJECT_REFUSAL);
 		const projectProblem = appProjectProblem(root);
 		if (projectProblem) return fail({
 			code: "STIM_NO_PROJECT",
@@ -199,6 +196,7 @@ function registerStart(program, overrides = {}) {
 				remedy: "Check that STIM_HOME is writable and has free space. An EPERM on a directory you can write is a sandbox: allow writes to STIM_HOME, or run Stim with the sandbox disabled (`stim guide errors sandbox`)."
 			});
 		}
+		recordWorkspaceUse(root);
 		const isExpo = detectIsExpo(root);
 		const worktreeRoot = repoRoot(root) ?? root;
 		const settingsContext = {
@@ -222,13 +220,7 @@ function registerStart(program, overrides = {}) {
 		if (settingError) return fail({
 			code: "STIM_BAD_ARG",
 			message: settingError,
-			remedy: `Set metro.tunnel to one of: auto, expo, ngrok, cloudflared, off.`
-		});
-		const remoteSettingError = remoteDeviceSettingError(settings);
-		if (remoteSettingError) return fail({
-			code: "STIM_BAD_ARG",
-			message: remoteSettingError,
-			remedy: "Set ios.remote and android.remote to either proxy or eas."
+			remedy: "Set metro.tunnel to \"ngrok\" and metro.ngrokUrl to an HTTPS URL, or remove metro.ngrokUrl."
 		});
 		const remote = Boolean(opts.remote) || remoteIosSetting(settings) !== null || remoteAndroidSetting(settings) !== null;
 		const tunnelMode = tunnelModeSetting(settings) ?? "auto";
@@ -820,8 +812,15 @@ function registerStart(program, overrides = {}) {
 	});
 }
 async function resolvePort(root, note) {
-	const recorded = getProject(root)?.metroPort;
+	const project = getProject(root);
+	const recorded = project?.metroPort;
 	if (!recorded) return await reserveMetroPort(root);
+	const supervisor = resolveSupervisorTarget({
+		state: readWorkspaceState(root)?.supervisor,
+		record: project.supervisor,
+		reservedPort: recorded
+	});
+	if (supervisor.status !== "none" && supervisor.status !== "stale") return recorded;
 	const held = await resolveProjectMetro(recorded, root);
 	if (!held.notOurs) return recorded;
 	const fresh = await reserveMetroPort(root);
@@ -859,11 +858,8 @@ function failureEvidence({ logFile, logsDir, sinceTs }) {
 	let errors = [];
 	let all = [];
 	try {
-		errors = queryLogs({
-			dir: logsDir,
-			minLevel: "error"
-		});
 		all = queryLogs({ dir: logsDir });
+		errors = all.filter((record) => levelRank(record.level) >= levelRank("error"));
 	} catch {}
 	const since = (rs) => rs.filter((r) => typeof r.ts === "number" && r.ts >= sinceTs).slice(-8);
 	let recent = since(errors);

package/dist/{state-DZobzxLW.mjs → state-NcJzMEBF.mjs}

@@ -1,5 +1,5 @@
-import { F as deviceSlotKey, L as parseDeviceSlotKey, w as process_identity_exports } from "./config-B7iyKWkL.mjs";
-import { a as withWorkspaceStateLock, i as updateWorkspaceState, p as supervisorPidFile, r as readWorkspaceState, t as clearWorkspaceStateKey, y as workspaceStateFile } from "./workspace-state-BT5E3SA2.mjs";
+import { D as process_identity_exports, H as deviceSlotKey, W as parseDeviceSlotKey } from "./config-Cp9lM3wX.mjs";
+import { S as workspaceStateFile, a as updateWorkspaceState, h as supervisorPidFile, o as withWorkspaceStateLock, r as readWorkspaceState, t as clearWorkspaceStateKey } from "./workspace-state-DF2gCFhx.mjs";
 import { existsSync, mkdirSync, readFileSync, rmSync, writeFileSync } from "node:fs";
 import { dirname } from "node:path";
 //#region src/supervisor/state.ts
@@ -75,10 +75,12 @@ function readRemoteSession(root) {
 	if (typeof id !== "string" || id.length === 0) return null;
 	const platform = record.platform;
 	const startedAt = record.startedAt;
+	const webPreviewUrl = record.webPreviewUrl;
 	return {
 		platform: platform === "ios" || platform === "android" ? platform : null,
 		sessionId: id,
-		startedAt: typeof startedAt === "string" ? startedAt : null
+		startedAt: typeof startedAt === "string" ? startedAt : null,
+		webPreviewUrl: typeof webPreviewUrl === "string" && webPreviewUrl.length > 0 ? webPreviewUrl : null
 	};
 }
 function readRemoteSessionId(root) {

package/dist/{stats-CLg5RuDS.mjs → stats-B63-JVAY.mjs}

@@ -1,7 +1,7 @@
-import { g as repoRoot, s as gitCommonDir } from "./worktree-FG_ZKKdb.mjs";
-import { a as findProjectRoot } from "./project-DDZWf_16.mjs";
-import { o as formatLongDuration } from "./command-output-B3ycpsYv.mjs";
-import { a as statsProjectKey, r as readStats } from "./stats-BYcZ6n1h.mjs";
+import { _ as repoRoot, s as gitCommonDir } from "./worktree-R_cUlE7s.mjs";
+import { o as findProjectRoot } from "./project-DS112DYB.mjs";
+import { o as formatLongDuration } from "./command-output-gByVmIjy.mjs";
+import { a as statsProjectKey, r as readStats } from "./stats-DG9e66Rz.mjs";
 import chalk from "chalk";
 //#region src/commands/stats.ts
 const PLATFORMS = ["ios", "android"];

package/dist/{stats-BYcZ6n1h.mjs → stats-DG9e66Rz.mjs}

@@ -1,7 +1,8 @@
-import { C as withConfigLock, u as getConfigDir } from "./config-B7iyKWkL.mjs";
+import { T as withConfigLock, u as getConfigDir } from "./config-Cp9lM3wX.mjs";
 import { readFileSync, realpathSync, renameSync, rmSync, writeFileSync } from "node:fs";
 import { basename, dirname, join, relative, resolve } from "node:path";
 const PLATFORMS = ["ios", "android"];
+const OUTCOMES = ["hit", "cold"];
 function statsFile() {
 	return join(getConfigDir(), "stats.json");
 }
@@ -41,10 +42,25 @@ function updateStats(record, run, now) {
 		credit,
 		phases
 	});
+	const history = { ...record.history };
+	if (run.phases && !run.failed && !run.waitedForBuild) {
+		const outcome = isHit(run.cacheHit) ? "hit" : "cold";
+		const project = { ...history[run.projectKey] };
+		const lists = { ...project[run.platform] };
+		const sample = {
+			at,
+			durationMs,
+			phases: wholePhases(run.phases)
+		};
+		lists[outcome] = [...lists[outcome] ?? [], sample].slice(-10);
+		project[run.platform] = lists;
+		history[run.projectKey] = project;
+	}
 	return {
 		version: 1,
 		machine,
-		projects
+		projects,
+		...Object.keys(history).length ? { history } : {}
 	};
 }
 function readStats() {
@@ -108,7 +124,7 @@ function recordRunStats(run, now) {
 		};
 	});
 }
-function createRunRecorder({ platform, write, now, note }) {
+function createRunRecorder({ platform, write, now, note, phases }) {
 	let projectKey = null;
 	let cacheKey = null;
 	let coldBuildMs = 0;
@@ -130,6 +146,7 @@ function createRunRecorder({ platform, write, now, note }) {
 		record({ failed, cacheHit = false, waited = null, durationMs }) {
 			if (!projectKey || !cacheKey || recorded) return;
 			recorded = true;
+			const ran = failed ? {} : phases?.() ?? {};
 			try {
 				const outcome = write({
 					platform,
@@ -139,7 +156,8 @@ function createRunRecorder({ platform, write, now, note }) {
 					waitedForBuild: Boolean(waited),
 					durationMs,
 					...coldBuildMs > 0 ? { coldBuildMs } : {},
-					...podsMs > 0 ? { podsMs } : {}
+					...podsMs > 0 ? { podsMs } : {},
+					...Object.keys(ran).length ? { phases: ran } : {}
 				}, now());
 				if (outcome?.note) note(outcome.note);
 			} catch (error) {
@@ -206,12 +224,55 @@ function normalize(record) {
 	const projects = {};
 	const source = record.projects;
 	if (source && typeof source === "object" && !Array.isArray(source)) for (const [key, scope] of Object.entries(source)) projects[key] = normalizeScope(scope);
+	const history = {};
+	if (isObject(record.history)) for (const [key, scope] of Object.entries(record.history)) {
+		const normalized = normalizeHistory(scope);
+		if (Object.keys(normalized).length) history[key] = normalized;
+	}
 	return {
 		version: 1,
 		machine: normalizeScope(record.machine),
-		projects
+		projects,
+		...Object.keys(history).length ? { history } : {}
 	};
 }
+function isObject(value) {
+	return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+}
+function normalizeHistory(scope) {
+	const history = {};
+	if (!isObject(scope)) return history;
+	for (const platform of PLATFORMS) {
+		const lists = scope[platform];
+		if (!isObject(lists)) continue;
+		const normalized = {};
+		for (const outcome of OUTCOMES) {
+			const samples = lists[outcome];
+			if (!Array.isArray(samples)) continue;
+			const kept = samples.filter(isObject).flatMap((sample) => {
+				const durationMs = wholeMs(sample.durationMs);
+				if (durationMs <= 0) return [];
+				return [{
+					at: timestamp(sample.at),
+					durationMs,
+					phases: wholePhases(sample.phases)
+				}];
+			});
+			if (kept.length) normalized[outcome] = kept.slice(-10);
+		}
+		if (Object.keys(normalized).length) history[platform] = normalized;
+	}
+	return history;
+}
+function wholePhases(phases) {
+	const out = {};
+	if (!isObject(phases)) return out;
+	for (const [name, ms] of Object.entries(phases)) {
+		const value = Number(ms);
+		if (Number.isFinite(value) && value >= 0) out[name] = Math.round(value);
+	}
+	return out;
+}
 function normalizeScope(scope) {
 	const normalized = {};
 	if (!scope || typeof scope !== "object" || Array.isArray(scope)) return normalized;