stim 1.13.0 → 1.15.0

package/dist/stage-CzaiwFsI.mjs

@@ -0,0 +1,143 @@
+import { t as getExecutor } from "./exec-CaErVv7t.mjs";
+import { cpSync, existsSync, mkdirSync, readdirSync, realpathSync, rmSync, statSync } from "node:fs";
+import { dirname, isAbsolute, join, relative, resolve, sep } from "node:path";
+import { validMacosResourceDestination } from "@stim-cli/core";
+//#region src/macos/stage.ts
+function validateInfoPlist(root, product, infoPlist) {
+	const plist = JSON.parse(getExecutor().runFile("plutil", [
+		"-convert",
+		"json",
+		"-o",
+		"-",
+		realpathSync(resolve(root, infoPlist))
+	]));
+	if (typeof plist.CFBundleIdentifier !== "string" || plist.CFBundleExecutable !== product) throw new Error("macos.infoPlist must name a CFBundleIdentifier and the selected product as CFBundleExecutable.");
+	if (plist.CFBundleURLTypes || plist.SUFeedURL) throw new Error("Use a development Info.plist without shared URL schemes or an update feed.");
+	if (plist.LSMinimumSystemVersion !== void 0 && typeof plist.LSMinimumSystemVersion !== "string") throw new Error("macos.infoPlist LSMinimumSystemVersion must be a string. See stim guide macos.");
+	return {
+		bundleId: plist.CFBundleIdentifier,
+		minimumSystemVersion: plist.LSMinimumSystemVersion
+	};
+}
+function resourceError(key, entry, reason) {
+	throw new Error(`${key} entry ${JSON.stringify(entry)}: ${reason}. See stim guide macos.`);
+}
+function containsSymlink(dir) {
+	return readdirSync(dir, { withFileTypes: true }).some((entry) => entry.isSymbolicLink() || entry.isDirectory() && containsSymlink(join(dir, entry.name)));
+}
+function overlaps(a, b) {
+	a = a.normalize("NFC").toLowerCase();
+	b = b.normalize("NFC").toLowerCase();
+	return a === b || a.startsWith(`${b}/`) || b.startsWith(`${a}/`);
+}
+function resolveBundleExtras(root, repository, resources = {}, assetCatalog) {
+	const boundary = realpathSync(repository);
+	const sourcePath = (key, entry) => {
+		if (typeof entry !== "string" || !entry || isAbsolute(entry) || entry.includes("\0")) resourceError(key, entry, "source must be a non-empty relative path");
+		let source;
+		try {
+			source = realpathSync(resolve(root, entry));
+		} catch {
+			resourceError(key, entry, "source does not exist");
+		}
+		const path = relative(boundary, source);
+		if (path === ".." || path.startsWith(`..${sep}`) || isAbsolute(path)) resourceError(key, entry, "source leaves the repository");
+		if (path === "") resourceError(key, entry, "source is the repository root");
+		const stat = statSync(source);
+		if (!stat.isFile() && !stat.isDirectory()) resourceError(key, entry, "source must be a regular file or directory");
+		if (stat.isDirectory() && containsSymlink(source)) resourceError(key, entry, "source directory contains a symbolic link");
+		return source;
+	};
+	let catalog;
+	if (assetCatalog !== void 0 && assetCatalog !== null) {
+		catalog = sourcePath("macos.assetCatalog", assetCatalog);
+		if (!catalog.endsWith(".xcassets") || !statSync(catalog).isDirectory()) resourceError("macos.assetCatalog", assetCatalog, "catalog must be a .xcassets directory");
+	}
+	if (!resources || typeof resources !== "object" || Array.isArray(resources)) resourceError("macos.resources", resources, "expected an object");
+	const entries = Object.entries(resources);
+	if (entries.length > 256) {
+		const [destination, source] = entries[256];
+		resourceError(`macos.resources[${JSON.stringify(destination)}]`, source, "at most 256 entries are allowed");
+	}
+	const reserved = catalog ? ["Assets.car"] : [];
+	const resolved = [];
+	for (const [destination, source] of entries) {
+		const key = `macos.resources[${JSON.stringify(destination)}]`;
+		if (!validMacosResourceDestination(destination)) resourceError(key, source, "invalid destination");
+		if (reserved.some((other) => overlaps(destination, other))) resourceError(key, source, "destination collides with another resource");
+		reserved.push(destination);
+		resolved.push([destination, sourcePath(key, source)]);
+	}
+	return {
+		resources: Object.fromEntries(resolved),
+		assetCatalog: catalog
+	};
+}
+function stageBundle(root, product, infoPlist, bin, bundle, bundleId, extras = { resources: {} }) {
+	const { minimumSystemVersion } = validateInfoPlist(root, product, infoPlist);
+	for (const entry of readdirSync(bin).filter((name) => name.endsWith(".bundle"))) for (const [destination, source] of Object.entries(extras.resources)) if (overlaps(destination, entry)) resourceError(`macos.resources[${JSON.stringify(destination)}]`, source, `destination collides with ${entry}`);
+	const exec = getExecutor();
+	rmSync(bundle, {
+		recursive: true,
+		force: true
+	});
+	const contents = join(bundle, "Contents");
+	mkdirSync(join(contents, "MacOS"), { recursive: true });
+	mkdirSync(join(contents, "Resources"), { recursive: true });
+	mkdirSync(join(contents, "Frameworks"), { recursive: true });
+	const executable = join(contents, "MacOS", product);
+	cpSync(join(bin, product), executable);
+	cpSync(resolve(root, infoPlist), join(contents, "Info.plist"));
+	exec.runFile("/usr/libexec/PlistBuddy", [
+		"-c",
+		`Set :CFBundleIdentifier ${bundleId}`,
+		join(contents, "Info.plist")
+	]);
+	for (const entry of readdirSync(bin)) if (entry.endsWith(".framework")) {
+		const target = join(contents, "Frameworks", entry);
+		cpSync(join(bin, entry), target, {
+			recursive: true,
+			dereference: false,
+			verbatimSymlinks: true
+		});
+		exec.runFile("codesign", [
+			"--force",
+			"--sign",
+			"-",
+			target
+		]);
+	} else if (entry.endsWith(".bundle")) cpSync(join(bin, entry), join(contents, "Resources", entry), { recursive: true });
+	const frameworkPath = "@executable_path/../Frameworks";
+	if (!exec.runFile("otool", ["-l", executable]).includes(frameworkPath)) exec.runFile("install_name_tool", [
+		"-add_rpath",
+		frameworkPath,
+		executable
+	]);
+	for (const [destination, source] of Object.entries(extras.resources)) {
+		const target = join(contents, "Resources", destination);
+		mkdirSync(dirname(target), { recursive: true });
+		cpSync(source, target, { recursive: true });
+	}
+	if (extras.assetCatalog) {
+		exec.runFile("xcrun", [
+			"actool",
+			extras.assetCatalog,
+			"--compile",
+			join(contents, "Resources"),
+			"--platform",
+			"macosx",
+			...minimumSystemVersion === void 0 ? [] : ["--minimum-deployment-target", minimumSystemVersion],
+			"--output-partial-info-plist",
+			"/dev/null"
+		]);
+		if (!existsSync(join(contents, "Resources", "Assets.car"))) resourceError("macos.assetCatalog", extras.assetCatalog, "actool did not produce Assets.car");
+	}
+	exec.runFile("codesign", [
+		"--force",
+		"--sign",
+		"-",
+		bundle
+	]);
+}
+//#endregion
+export { stageBundle as n, validateInfoPlist as r, resolveBundleExtras as t };

package/dist/start-CPO4wRg7.mjs

@@ -0,0 +1,2 @@
+import { a as registerStart, c as startDevServer, d as tailLines, f as wantsExpoOwnTunnel, i as readLogTail, l as startFacts, n as liveSupervisor, o as resolveWorkspaceMetroPort, r as parseWait, s as startCommand, t as failureEvidence, u as supervisorEntry } from "./start-CUD9nasA.mjs";
+export { startCommand as default, failureEvidence, liveSupervisor, parseWait, readLogTail, registerStart, resolveWorkspaceMetroPort, startDevServer, startFacts, supervisorEntry, tailLines, wantsExpoOwnTunnel };

package/dist/{start-BZhItkiL.mjs → start-CUD9nasA.mjs}

@@ -1,24 +1,27 @@
-import { O as process_identity_exports, T as upsertProject, p as getProject } from "./config-0jCcMM0E.mjs";
-import { t as getExecutor } from "./exec-DK8KaVHK.mjs";
+import { t as getExecutor } from "./exec-CaErVv7t.mjs";
+import { E as upsertProject, p as getProject } from "./config-D0DbpZtM.mjs";
+import { t as process_identity_exports } from "./process-identity-BmRm1qV0.mjs";
 import { i as levelRank } from "./ndjson-CDY9IkVC.mjs";
-import { E as supervisorLogFile, M as workspaceLogsDir, S as ensureWorkspaceStorage, a as pidExists, b as writeWorkspaceState, c as resolveProjectMetro, f as reserveMetroPort, g as recordWorkspaceUse, h as readWorkspaceState$1, l as signalProcessTree, m as clearWorkspaceStateKeys } from "./metro-BPeY1YMh.mjs";
-import { s as gitCommonDir, y as repoRoot } from "./worktree-DeBQSVtR.mjs";
-import { a as findProjectRoot, d as readAppJson, n as appProjectProblem, r as detectIsExpo, t as NO_PROJECT_REFUSAL, u as readAppConfigText } from "./project-DGeclhvO.mjs";
-import { n as windowsLauncherArgs } from "./detached-entry-DJHoca49.mjs";
-import { c as readMetroTunnel, i as clearManagedMetroTunnel } from "./state-DwAU2_-D.mjs";
-import { a as withWorkspaceProcessLock, o as workspaceProcessLockError } from "./named-ports-n7tnJsI8.mjs";
-import { _ as stepTimer, l as phaseLine } from "./command-output-BIL7rlX7.mjs";
-import { A as resolveCacheProviderConfig, B as detectProviders, C as ngrokUrlSetting, E as publicUrlSetting, I as tunnelModeSetting, L as unknownSettingKeys, O as remoteAndroidSetting, P as settingShapeErrors, V as planMetroReach, a as SETTING_SHAPE_REMEDY, b as metroIdleStopMinutesSetting, d as cacheProviderSettingError, j as resolveSettings, k as remoteIosSetting, x as metroTunnelSettingError, z as PUBLIC_METRO_ENV } from "./settings-xB0Frkg6.mjs";
-import { a as terminateChild, c as withManagedTunnelLock, i as stopTunnel, o as withManagedRemoteWorktreeLock, r as startTunnelSequence, t as resolveSupervisorTarget } from "./ownership-PUP4Dwai.mjs";
-import { d as readProjectConfig } from "./remote-cache--aehr4Pr.mjs";
-import { I as stopOwnedMetroForReset, t as budgetGate } from "./budget-E5o91NR1.mjs";
+import { C as workspaceLogsDir, _ as supervisorLogFile, c as writeWorkspaceState, i as recordWorkspaceUse, n as clearWorkspaceStateKeys, p as ensureWorkspaceStorage, r as readWorkspaceState$1 } from "./workspace-state-CL2V2Ons.mjs";
+import { s as gitCommonDir, y as repoRoot } from "./worktree-C0c5Udwa.mjs";
+import { a as findProjectRoot$1, d as readAppJson, n as appProjectProblem, r as detectIsExpo, t as NO_PROJECT_REFUSAL, u as readAppConfigText } from "./project-CV3tDFHl.mjs";
+import { n as windowsLauncherArgs } from "./detached-entry-CiTEgMR1.mjs";
+import { c as readMetroTunnel, i as clearManagedMetroTunnel } from "./state-CaeaHbDA.mjs";
+import { n as workspaceProcessLockError, t as withWorkspaceProcessLock } from "./workspace-process-lock-BL7Q0HCO.mjs";
+import { _ as stepTimer, l as phaseLine } from "./command-output-CliHHn7a.mjs";
+import { a as workspaceLinks, i as workspaceLinkLine } from "./stim-desktop-Cnz8CPnl.mjs";
+import { l as resolveProjectMetro, o as pidExists, p as reserveMetroPort, u as signalProcessTree } from "./metro-Di8EN2Tb.mjs";
+import { A as remoteAndroidSetting, B as unknownSettingKeys, C as metroTunnelSettingError, H as PUBLIC_METRO_ENV, L as settingShapeErrors, M as resolveCacheProviderConfig, N as resolveSettings, O as publicUrlSetting, S as metroPortSetting, T as ngrokUrlSetting, U as detectProviders, W as planMetroReach, a as SETTING_SHAPE_REMEDY, d as cacheProviderSettingError, f as deviceIdleShutdownMinutesSetting, j as remoteIosSetting, x as metroIdleStopMinutesSetting, z as tunnelModeSetting } from "./settings-CduVcoxj.mjs";
+import { _ as withManagedTunnelLock, f as startTunnelSequence, h as withManagedRemoteWorktreeLock, m as terminateChild, p as stopTunnel, u as resolveSupervisorTarget } from "./stop-cause-CZ_Mr-v9.mjs";
+import { t as spawnEntry } from "./spawn-entry-DncpJvWL.mjs";
+import { d as readProjectConfig } from "./remote-cache-CO2elm_b.mjs";
+import { t as budgetGate, tt as stopOwnedMetroForReset } from "./budget-CMiqghig.mjs";
 import { appendFileSync, mkdirSync, openSync, readFileSync } from "node:fs";
+import { dirname } from "node:path";
+import { EventEmitter } from "node:events";
 import { existsSync as existsSync$1, readFileSync as readFileSync$1, readdirSync as readdirSync$1 } from "fs";
-import { join } from "path";
+import { join as join$1 } from "path";
 import { IDLE_STOP_KEY, queryLogs } from "@stim-cli/core/state";
-import { basename as basename$1, dirname as dirname$1, join as join$1 } from "node:path";
-import { EventEmitter } from "node:events";
-import { fileURLToPath } from "node:url";
 import chalk from "chalk";
 import { CACHE_PROVIDER_ENV, cacheProviderEnv } from "@stim-cli/cache";
 //#region src/workspace/app-id.ts
@@ -60,7 +63,7 @@ function detectAndroidPackage(projectRoot) {
 	return detectAppIds(projectRoot).androidPackage;
 }
 function detectBundleIdFromPbxproj(projectRoot) {
-	const iosDir = join(projectRoot, "ios");
+	const iosDir = join$1(projectRoot, "ios");
 	if (!existsSync$1(iosDir)) return null;
 	let entries;
 	try {
@@ -70,7 +73,7 @@ function detectBundleIdFromPbxproj(projectRoot) {
 	}
 	for (const entry of entries) {
 		if (!entry.isDirectory() || !entry.name.endsWith(".xcodeproj")) continue;
-		const pbx = join(iosDir, entry.name, "project.pbxproj");
+		const pbx = join$1(iosDir, entry.name, "project.pbxproj");
 		if (!existsSync$1(pbx)) continue;
 		let text;
 		try {
@@ -93,7 +96,7 @@ function detectBundleIdFromPbxproj(projectRoot) {
 	return null;
 }
 function detectAndroidPackageFromGradle(projectRoot) {
-	const gradle = join(projectRoot, "android", "app", "build.gradle");
+	const gradle = join$1(projectRoot, "android", "app", "build.gradle");
 	if (!existsSync$1(gradle)) return null;
 	let text;
 	try {
@@ -108,18 +111,6 @@ function detectAndroidPackageFromGradle(projectRoot) {
 	return null;
 }
 //#endregion
-//#region src/spawn-entry.ts
-const DEV_ENTRIES = {
-	"supervisor-run": "./supervisor/run.ts",
-	"collector-run": "./collector/run.ts",
-	"web-run": "./web/run.ts"
-};
-function spawnEntry(name) {
-	const here = fileURLToPath(import.meta.url);
-	if (basename$1(dirname$1(here)) === "src") return fileURLToPath(new URL(DEV_ENTRIES[name], import.meta.url));
-	return join$1(dirname$1(here), `${name}.mjs`);
-}
-//#endregion
 //#region src/commands/start.ts
 const DEFAULT_WAIT_SECONDS = 60;
 const POLL_MS = 500;
@@ -194,14 +185,14 @@ function recordedSupervisorProcess(pid) {
 	});
 }
 const RECORDED_SUPERVISOR_WAIT_MS = 15e3;
-function providersOnPath() {
+function providersOnPath(mode) {
 	return detectProviders((bin) => {
 		try {
 			return Boolean(getExecutor().findExecutable(bin));
 		} catch {
 			return false;
 		}
-	});
+	}, mode);
 }
 const DEFAULT_START_DEPS = {
 	providers: providersOnPath,
@@ -260,7 +251,7 @@ function registerStart(program, overrides = {}) {
 			remedy: "Pass a whole number of seconds, e.g. --wait 90."
 		});
 		const waitSeconds = wait.seconds;
-		const root = findProjectRoot(process.cwd());
+		const root = findProjectRoot$1(process.cwd());
 		if (!root) return fail(NO_PROJECT_REFUSAL);
 		const projectProblem = appProjectProblem(root);
 		if (projectProblem) return fail({
@@ -313,7 +304,8 @@ function registerStart(program, overrides = {}) {
 			out,
 			facts: result.facts,
 			waited: result.waited,
-			reclaimed: result.reclaimed
+			reclaimed: result.reclaimed,
+			links: workspaceLinks(root)
 		});
 	});
 }
@@ -376,6 +368,11 @@ async function startDevServer({ root, settings, waitSeconds = DEFAULT_WAIT_SECON
 			};
 			if (resetCache) {
 				await gateBudget();
+				const pin = metroPortSetting(root);
+				if (pin.port !== null || pin.error) {
+					const pinCheck = await resolveWorkspaceMetroPort(root, note, "start", false);
+					if (typeof pinCheck !== "number") return fail(pinCheck);
+				}
 				try {
 					await stopOwnedMetroForReset(root);
 				} catch (error) {
@@ -390,7 +387,7 @@ async function startDevServer({ root, settings, waitSeconds = DEFAULT_WAIT_SECON
 			}
 			const logsDir = workspaceLogsDir(root);
 			const logFile = supervisorLogFile(root);
-			const port = await resolvePort(root, note);
+			const port = await resolvePort(root, note, fail);
 			let publicOrigin = remote ? publicUrl : null;
 			let resolution = await resolveProjectMetro(port, root);
 			let supervisor = liveSupervisor({
@@ -510,7 +507,9 @@ async function startDevServer({ root, settings, waitSeconds = DEFAULT_WAIT_SECON
 					...tunnel ? ["--tunnel"] : [],
 					...resetCache ? ["--reset-cache"] : [],
 					"--idle-stop-minutes",
-					String(metroIdleStopMinutesSetting(settings))
+					String(metroIdleStopMinutesSetting(settings)),
+					"--device-idle-minutes",
+					String(deviceIdleShutdownMinutesSetting(settings))
 				];
 				const childEnv = {
 					...process.env,
@@ -540,7 +539,7 @@ async function startDevServer({ root, settings, waitSeconds = DEFAULT_WAIT_SECON
 				return null;
 			};
 			if (remote && !tunnel && !publicUrl && tunnelMode !== "off") {
-				const available = d.providers();
+				const available = d.providers(tunnelMode);
 				const plan = planMetroReach({
 					mode: tunnelMode,
 					metroPort: port,
@@ -554,7 +553,7 @@ async function startDevServer({ root, settings, waitSeconds = DEFAULT_WAIT_SECON
 					remedy: plan.remedy
 				});
 				if ("start" in plan) {
-					const candidates = tunnelMode === "auto" ? available : [plan.start];
+					const candidates = tunnelMode === "auto" ? available.filter((provider) => provider !== "tailscale") : [plan.start];
 					const expectedStableUrl = ngrokUrlSetting(settings);
 					let acquisition;
 					try {
@@ -722,6 +721,7 @@ async function startDevServer({ root, settings, waitSeconds = DEFAULT_WAIT_SECON
 					if ("failed" in acquisition) return fail(acquisition.failed);
 					publicOrigin = acquisition.origin;
 					managedTunnel = acquisition.tunnel;
+					if (managedTunnel.record.provider === "tailscale") note(phaseLine("lan", `tailnet-only Metro: ${publicOrigin}`));
 					resolution = await resolveProjectMetro(port, root);
 					supervisor = liveSupervisor({
 						state: readWorkspaceState$1(root),
@@ -911,7 +911,7 @@ async function startDevServer({ root, settings, waitSeconds = DEFAULT_WAIT_SECON
 		};
 		const startLocked = async () => {
 			try {
-				return await withWorkspaceProcessLock(dirname$1(workspaceLogsDir(root)), "metro-start", runStart, { external: true });
+				return await withWorkspaceProcessLock(dirname(workspaceLogsDir(root)), "metro-start", runStart, { external: true });
 			} catch (error) {
 				if (workspaceProcessLockError(error) !== "timeout") throw error;
 				return fail({
@@ -956,24 +956,69 @@ async function startDevServer({ root, settings, waitSeconds = DEFAULT_WAIT_SECON
 		};
 	}
 }
-async function resolvePort(root, note) {
+async function resolvePort(root, note, fail) {
+	const result = await resolveWorkspaceMetroPort(root, note, "start");
+	return typeof result === "number" ? result : fail(result);
+}
+async function resolveWorkspaceMetroPort(root, note, command, reserve = true) {
+	const setting = metroPortSetting(root);
+	if (setting.error) return {
+		code: "STIM_BAD_ARG",
+		message: setting.error,
+		remedy: SETTING_SHAPE_REMEDY
+	};
+	const pinned = setting.port;
 	const project = getProject(root);
 	const recorded = project?.metroPort;
-	if (!recorded) return await reserveMetroPort(root);
-	const supervisor = resolveSupervisorTarget({
-		state: readWorkspaceState$1(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);
-	if (fresh !== recorded) {
-		note(chalk.yellow(`Port ${recorded} is held by something else (${held.notOurs}).`));
-		note(chalk.dim(`Reserved port ${fresh} for this project instead.`));
+	if (pinned === null && command === "web") return recorded ?? await reserveMetroPort(root);
+	if (recorded) {
+		const supervisor = resolveSupervisorTarget({
+			state: readWorkspaceState$1(root)?.supervisor,
+			record: project.supervisor,
+			reservedPort: recorded
+		});
+		if (supervisor.status !== "none" && supervisor.status !== "stale") {
+			if (pinned === null || recorded === pinned) return recorded;
+			if (supervisor.status === "unverified") return {
+				code: "STIM_BAD_ARG",
+				message: `Cannot move this workspace's Metro to metro.port ${pinned}: ${supervisor.reason}.`,
+				remedy: `Stop that supervisor with the tool that started it, then retry, or restore metro.port to ${recorded}. Stim leaves unverified processes alone.`
+			};
+			return {
+				code: "STIM_BAD_ARG",
+				message: `This workspace's dev server is running on port ${recorded}, and metro.port pins it to ${pinned}.`,
+				remedy: "Run `stim stop`, then retry, or unset or restore metro.port."
+			};
+		}
+	}
+	if (pinned !== null) {
+		const held = await resolveProjectMetro(pinned, root);
+		if (held.notOurs) return {
+			code: "STIM_BAD_ARG",
+			message: `Port ${pinned} is held by something else (${held.notOurs}), and metro.port pins this workspace's Metro to it.`,
+			remedy: "Stop the process on that port, or set another metro.port."
+		};
+		if (recorded === pinned) return recorded;
+	} else if (recorded) {
+		const held = await resolveProjectMetro(recorded, root);
+		if (!held.notOurs) return recorded;
+		const fresh = await reserveMetroPort(root);
+		if (fresh !== recorded) {
+			note(chalk.yellow(`Port ${recorded} is held by something else (${held.notOurs}).`));
+			note(chalk.dim(`Reserved port ${fresh} for this project instead.`));
+		}
+		return fresh;
+	}
+	if (!reserve && pinned !== null) return pinned;
+	try {
+		return await reserveMetroPort(root, void 0, void 0, pinned);
+	} catch (error) {
+		return {
+			code: "STIM_BAD_ARG",
+			message: error.message,
+			remedy: "Give each workspace its own metro.port, in the workspace layer or the environment."
+		};
 	}
-	return fresh;
 }
 async function waitForMetro({ root, port, seconds, aborted = () => false, probe = resolveProjectMetro }) {
 	const deadline = Date.now() + seconds * 1e3;
@@ -1014,17 +1059,19 @@ function failureEvidence({ logFile, logsDir, sinceTs }) {
 	if (recent.length > 0) lines.push(fellBack ? "Full records: `stim logs`" : "Full records: `stim logs --errors`");
 	return lines;
 }
-function report({ json, out, facts, waited, reclaimed }) {
+function report({ json, out, facts, waited, reclaimed, links }) {
 	if (json) {
-		console.log(JSON.stringify(reclaimed.length ? {
+		console.log(JSON.stringify({
 			...facts,
-			reclaimed
-		} : facts));
+			...links ? { links } : {},
+			...reclaimed.length ? { reclaimed } : {}
+		}));
 		return;
 	}
 	const who = facts.supervisorPid ? `supervisor pid ${facts.supervisorPid}${facts.mode ? ` (${facts.mode})` : ""}` : "started outside Stim";
 	out(chalk.green(`OK: dev server on port ${facts.port}, ${who}${facts.alreadyRunning ? " (already running)" : ""} ${waited}`));
 	out(chalk.dim(phaseLine("logs", facts.logsDir)));
+	if (links) console.error(chalk.dim(workspaceLinkLine(links)));
 }
 //#endregion
-export { registerStart as a, startFacts as c, wantsExpoOwnTunnel as d, spawnEntry as f, detectBundleId as h, readLogTail as i, supervisorEntry as l, detectAppIds as m, liveSupervisor as n, startCommand as o, detectAndroidPackage as p, parseWait as r, startDevServer as s, failureEvidence as t, tailLines as u };
+export { registerStart as a, startDevServer as c, tailLines as d, wantsExpoOwnTunnel as f, detectBundleId as h, readLogTail as i, startFacts as l, detectAppIds as m, liveSupervisor as n, resolveWorkspaceMetroPort as o, detectAndroidPackage as p, parseWait as r, startCommand as s, failureEvidence as t, supervisorEntry as u };

package/dist/state-B4PQFXMW.d.mts

@@ -0,0 +1,12 @@
+import "@stim-cli/core/state";
+import * as import__stim_cli_core_process_identity from "@stim-cli/core/process-identity";
+//#endregion
+//#region src/supervisor/state.d.ts
+declare const MODE_BARE = "bare-inproc";
+declare const MODE_EXPO = "expo-child";
+declare function clearWorkspaceSupervisor(root: string, expected?: process_identity_d_exports.ProcessRecord | null): boolean;
+declare function clearExpoMetroTunnel(root: string): void;
+declare function writePidFile(root: string, pid: number): string;
+declare function readPidFile(root: string): number | null;
+//#endregion
+export { readPidFile as a, clearWorkspaceSupervisor as i, MODE_EXPO as n, writePidFile as o, clearExpoMetroTunnel as r, MODE_BARE as t };

package/dist/state-BxCgeTQu.mjs

@@ -0,0 +1,41 @@
+import { t as process_identity_exports } from "./process-identity-BmRm1qV0.mjs";
+import { C as workspaceLogsDir, a as updateWorkspaceState, b as workspaceDir, r as readWorkspaceState$1 } from "./workspace-state-CL2V2Ons.mjs";
+import { join } from "node:path";
+import { readMacosRecord } from "@stim-cli/core/state";
+//#region src/macos/state.ts
+const macosDir = (root) => join(workspaceDir(root), "macos");
+const macosLogFile = (root) => join(workspaceLogsDir(root), "macos.ndjson");
+const macosRuntimeClaim = (root) => join(macosDir(root), "runtime.lock");
+function macosProcess(pid) {
+	const processToken = (0, process_identity_exports.captureProcessToken)(pid);
+	const start = (0, process_identity_exports.processStartMicros)(pid);
+	if (!processToken || start.status !== "running") throw Object.assign(/* @__PURE__ */ new Error(`Cannot verify macOS process ${pid}; refusing unmanaged launch.`), { code: "STIM_CLAIM_UNAVAILABLE" });
+	return {
+		pid,
+		processToken,
+		startedAtMicros: start.startedAtMicros
+	};
+}
+function requiredMacosRecord(root) {
+	const record = readMacosRecord(root);
+	if (!record && readWorkspaceState$1(root)?.macos !== void 0) throw Object.assign(/* @__PURE__ */ new Error("The recorded macOS owner is malformed; repair its workspace state before running."), { code: "STIM_MACOS_OWNER_UNVERIFIED" });
+	return record;
+}
+function updateMacosRecord(root, owner, patch) {
+	let updated = false;
+	updateWorkspaceState(root, (state) => {
+		const record = readMacosRecord(root);
+		if (!record || !(0, process_identity_exports.sameProcessRecord)(record.supervisor, owner)) return state;
+		updated = true;
+		return {
+			...state,
+			macos: {
+				...record,
+				...patch
+			}
+		};
+	});
+	return updated;
+}
+//#endregion
+export { requiredMacosRecord as a, macosRuntimeClaim as i, macosLogFile as n, updateMacosRecord as o, macosProcess as r, macosDir as t };

package/dist/{state-DwAU2_-D.mjs → state-CaeaHbDA.mjs}

@@ -1,5 +1,6 @@
-import { O as process_identity_exports, V as parseDeviceSlotKey, z as deviceSlotKey } from "./config-0jCcMM0E.mjs";
-import { D as supervisorPidFile, P as workspaceStateFile, _ as updateWorkspaceState, h as readWorkspaceState, p as clearWorkspaceStateKey, v as withWorkspaceStateLock } from "./metro-BPeY1YMh.mjs";
+import { B as parseDeviceSlotKey, R as deviceSlotKey } from "./config-D0DbpZtM.mjs";
+import { t as process_identity_exports } from "./process-identity-BmRm1qV0.mjs";
+import { T as workspaceStateFile, a as updateWorkspaceState, o as withWorkspaceStateLock, r as readWorkspaceState, t as clearWorkspaceStateKey, v as supervisorPidFile } from "./workspace-state-CL2V2Ons.mjs";
 import { existsSync, mkdirSync, readFileSync, rmSync, writeFileSync } from "node:fs";
 import { dirname } from "node:path";
 //#region src/supervisor/state.ts
@@ -22,7 +23,7 @@ function readMetroTunnel(root) {
 		const startedAt = record.startedAt;
 		const processToken = record.processToken;
 		const logFile = record.logFile;
-		if (provider !== "ngrok" && provider !== "cloudflared" || typeof pid !== "number" || typeof port !== "number") return null;
+		if (provider !== "ngrok" && provider !== "cloudflared" && provider !== "tailscale" || typeof pid !== "number" || typeof port !== "number") return null;
 		return {
 			kind: "managed",
 			provider,
@@ -88,11 +89,13 @@ function readRemoteSession(root) {
 	const platform = record.platform;
 	const startedAt = record.startedAt;
 	const webPreviewUrl = record.webPreviewUrl;
+	const deviceType = record.deviceType;
 	return {
 		platform: platform === "ios" || platform === "android" ? platform : null,
 		sessionId: id,
 		startedAt: typeof startedAt === "string" ? startedAt : null,
-		webPreviewUrl: typeof webPreviewUrl === "string" && webPreviewUrl.length > 0 ? webPreviewUrl : null
+		webPreviewUrl: typeof webPreviewUrl === "string" && webPreviewUrl.length > 0 ? webPreviewUrl : null,
+		deviceType: typeof deviceType === "string" && deviceType.length > 0 ? deviceType : null
 	};
 }
 function readRemoteSessionId(root) {

package/dist/{state-l1pYwOre.mjs → state-DFm77wRn.mjs}

@@ -1,8 +1,10 @@
-import { A as ownership_claim_exports, O as process_identity_exports } from "./config-0jCcMM0E.mjs";
-import { M as workspaceLogsDir, _ as updateWorkspaceState, a as pidExists, b as writeWorkspaceState, h as readWorkspaceState$1, k as workspaceDir, p as clearWorkspaceStateKey } from "./metro-BPeY1YMh.mjs";
-import { readlinkSync, rmSync } from "node:fs";
-import { WEB_VIEWPORTS } from "@stim-cli/core/state";
+import { n as ownership_claim_exports, t as process_identity_exports } from "./process-identity-BmRm1qV0.mjs";
+import { C as workspaceLogsDir, a as updateWorkspaceState, b as workspaceDir, c as writeWorkspaceState, r as readWorkspaceState$1, t as clearWorkspaceStateKey } from "./workspace-state-CL2V2Ons.mjs";
+import { o as pidExists } from "./metro-Di8EN2Tb.mjs";
+import { readFileSync, readlinkSync, rmSync } from "node:fs";
 import { join } from "node:path";
+import { rotatedLogPath } from "@stim-cli/core";
+import { WEB_VIEWPORTS } from "@stim-cli/core/state";
 import { hostname } from "node:os";
 //#region src/web/profile.ts
 const SINGLETON_FILES = [
@@ -144,5 +146,65 @@ function webFacts(record) {
 		status: supervisor === "same" && chrome === "running" ? "running" : "orphaned"
 	};
 }
+const PAGE_FAILURES = /* @__PURE__ */ new Set(["web_document_failed", "web_page_crashed"]);
+const NAVIGATION = Buffer.from("\"event\":\"web_navigation\"");
+const PAGE_EVENT = "\"event\":\"web_";
+/**
+* The latest page load in the web log's `lines`: the newest `web_navigation` marker, whether a document failure, a
+* crash or the load event followed it, and the newest in-app route change after it. Null before the first
+* navigation.
+*/
+function latestPageLoad(lines) {
+	let failure = null;
+	let loaded = false;
+	let route = null;
+	for (let i = lines.length - 1; i >= 0; i--) {
+		let record;
+		try {
+			record = JSON.parse(lines[i]);
+		} catch {
+			continue;
+		}
+		if (record.event === "web_navigation" && typeof record.url === "string") {
+			const moved = route !== null && route !== record.url ? { route } : {};
+			if (failure !== null) return {
+				url: record.url,
+				state: "failed",
+				error: failure,
+				...moved
+			};
+			return {
+				url: record.url,
+				state: loaded ? "loaded" : "loading",
+				...moved
+			};
+		}
+		if (typeof record.event !== "string") continue;
+		if (record.event === "web_route" && typeof record.url === "string") route ??= record.url;
+		if (PAGE_FAILURES.has(record.event)) failure = typeof record.msg === "string" ? record.msg : record.event;
+		else if (record.event === "web_page_loaded") loaded = true;
+	}
+	return null;
+}
+/** The page lines from the newest navigation on, in the web log or, right after a rotation, its previous file. */
+function pageLines(file) {
+	for (const path of [file, rotatedLogPath(file)]) {
+		let bytes;
+		try {
+			bytes = readFileSync(path);
+		} catch {
+			continue;
+		}
+		const at = bytes.lastIndexOf(NAVIGATION);
+		if (at < 0) continue;
+		const start = bytes.lastIndexOf(10, at) + 1;
+		return bytes.subarray(start).toString("utf8").split("\n").filter((line) => line.includes(PAGE_EVENT));
+	}
+	return null;
+}
+function readWebPage(root) {
+	const lines = pageLines(webLogFile(root));
+	return lines ? latestPageLoad(lines) : null;
+}
 //#endregion
-export { readWebRecord as a, webDir as c, webProfileDir as d, webSupervisorLogFile as f, removeSingletonFiles as g, liveProfileHolder as h, clearWebRecord as i, webFacts as l, chromeProcessState as m, browserLogFile as n, updateWebRecord as o, writeWebRecord as p, cdpEndpoint as r, webClaimRoot as s, CDP_PORT_LABEL as t, webLogFile as u };
+export { removeSingletonFiles as _, readWebPage as a, webClaimRoot as c, webLogFile as d, webProfileDir as f, liveProfileHolder as g, chromeProcessState as h, clearWebRecord as i, webDir as l, writeWebRecord as m, browserLogFile as n, readWebRecord as o, webSupervisorLogFile as p, cdpEndpoint as r, updateWebRecord as s, CDP_PORT_LABEL as t, webFacts as u };