stim 1.13.0 → 1.15.0

package/dist/warm-progress-DVHLN4uC.mjs

@@ -0,0 +1,463 @@
+import { t as getExecutor } from "./exec-CaErVv7t.mjs";
+import { n as ownership_claim_exports } from "./process-identity-BmRm1qV0.mjs";
+import { o as pullRequestLookups } from "./pull-request-pxnDCQzn.mjs";
+import { E as withDirLock, a as updateWorkspaceState, b as workspaceDir, d as discoverAgentSessions, l as agentKey, p as ensureWorkspaceStorage, u as attributeAgentSessions } from "./workspace-state-CL2V2Ons.mjs";
+import { c as gitCommonDirOnDisk } from "./worktree-C0c5Udwa.mjs";
+import { I as ownedAvdDirectory } from "./android-Db2eEMaf.mjs";
+import { randomUUID } from "node:crypto";
+import { existsSync, mkdirSync, realpathSync, renameSync, rmSync, writeFileSync } from "node:fs";
+import { basename, dirname, join } from "node:path";
+import { ENDED_AGENT_RETENTION_MS, READY_PHASE_MS, WARM_KEY, agentSessionsCacheFile, diskUsageCacheFile, pullRequestCacheFile, readAgentSessionsCache, readDiskUsage, readEndedAgentSessions, readPullRequestCache, readWarmRecord, readWorkspaceAgent, readWorkspaceState, workspaceEndedAgentsFile, workspaceEndedAgentsLock } from "@stim-cli/core/state";
+import { homedir } from "node:os";
+//#region src/status-measures.ts
+const LIVE_DISK_MAX_AGE_MS = 3e5;
+const IDLE_DISK_MAX_AGE_MS = 36e5;
+const DU_TIMEOUT_MS = 12e4;
+const PULL_REQUEST_MAX_AGE_MS = 3e5;
+const PULL_REQUEST_CHECK_MS = 6e4;
+const GIT_TIMEOUT_MS = 5e3;
+const AGENT_DISCOVERY_MS = 15e3;
+const AGENT_CACHE_MAX_AGE_MS = 12e4;
+function writeCacheFile(file, entry) {
+	const temporary = `${file}.${randomUUID()}.tmp`;
+	try {
+		mkdirSync(dirname(file), { recursive: true });
+		writeFileSync(temporary, JSON.stringify(entry));
+		renameSync(temporary, file);
+	} catch {
+		rmSync(temporary, { force: true });
+	}
+}
+function forgetStatusMeasures(worktree, workspaces) {
+	const roots = [.../* @__PURE__ */ new Set([worktree, ...workspaces])];
+	const files = [pullRequestCacheFile(worktree), ...roots.flatMap((root) => [
+		diskUsageCacheFile(root),
+		diskUsageCacheFile(join(root, "node_modules")),
+		diskUsageCacheFile(workspaceDir(root))
+	])];
+	for (const file of files) try {
+		rmSync(file, { force: true });
+	} catch {}
+}
+function simulatorDataDir(udid) {
+	return join(homedir(), "Library", "Developer", "CoreSimulator", "Devices", udid);
+}
+function checkoutDir(state) {
+	if (state.worktree?.path) return state.worktree.path;
+	const common = gitCommonDirOnDisk(state.path);
+	return common && basename(common) === ".git" ? dirname(common) : state.path;
+}
+function deviceFolders(state) {
+	const folders = [];
+	for (const { ios, android } of [state, ...state.slots ?? []]) {
+		if (ios?.owned) folders.push({
+			device: ios,
+			path: simulatorDataDir(ios.udid)
+		});
+		if (android?.owned && !android.physical && android.name) {
+			const path = ownedAvdDirectory(android.name);
+			if (path) folders.push({
+				device: android,
+				path
+			});
+		}
+	}
+	return folders;
+}
+/** The folders an environment's disk use sums: its checkout, its node_modules folders and Stim's workspace folder. */
+function environmentFolders(state) {
+	const worktree = checkoutDir(state);
+	return {
+		worktree,
+		nodeModules: [.../* @__PURE__ */ new Set([join(worktree, "node_modules"), join(state.path, "node_modules")])],
+		build: workspaceDir(state.path)
+	};
+}
+/** The environment's disk use from the cached measurements; null before any folder was measured. */
+function environmentDisk(folders) {
+	const worktree = readDiskUsage(folders.worktree);
+	const modules = folders.nodeModules.map((path) => readDiskUsage(path));
+	const build = readDiskUsage(folders.build);
+	const measured = [
+		worktree,
+		...modules,
+		build
+	].filter((entry) => entry !== null);
+	if (!measured.length) return null;
+	return {
+		worktreeBytes: worktree?.bytes ?? null,
+		nodeModulesBytes: modules.every((entry) => entry !== null) ? modules.reduce((sum, entry) => sum + entry.bytes, 0) : null,
+		buildBytes: build?.bytes ?? null,
+		measuredAt: measured.map((entry) => entry.measuredAt).toSorted()[0]
+	};
+}
+function statusPullRequest(fact, checkedAt) {
+	return {
+		number: fact.number,
+		url: fact.url,
+		title: fact.title ?? "",
+		state: fact.state === "open" && fact.draft ? "draft" : fact.state,
+		checks: fact.checks ?? null,
+		reviewDecision: fact.reviewDecision ?? null,
+		checkedAt
+	};
+}
+function canonicalPath(path) {
+	try {
+		return realpathSync(path);
+	} catch {
+		return path;
+	}
+}
+function agentWorkspaces(states) {
+	return states.map((state) => ({
+		path: canonicalPath(state.path),
+		root: canonicalPath(checkoutDir(state)),
+		recorded: readWorkspaceAgent(readWorkspaceState(state.path))
+	}));
+}
+function applyAgentSessions(states, now) {
+	const cache = readAgentSessionsCache();
+	const sessions = cache && now - Date.parse(cache.discoveredAt) <= AGENT_CACHE_MAX_AGE_MS ? cache.sessions : [];
+	const discovered = new Set(sessions.map(agentKey));
+	const ended = states.map((state) => readEndedAgentSessions(state.path, now));
+	const workspaces = agentWorkspaces(states);
+	workspaces.forEach((workspace, i) => {
+		const { recorded } = workspace;
+		if (!recorded || discovered.has(agentKey(recorded))) return;
+		if (ended[i].some((session) => agentKey(session) === agentKey(recorded))) workspace.recorded = null;
+	});
+	attributeAgentSessions(workspaces, sessions, now).forEach((agents, i) => {
+		if (agents.length) states[i].agents = agents;
+		const running = new Set(agents.map(agentKey));
+		const endedAgents = ended[i].filter((session) => !running.has(agentKey(session)));
+		if (endedAgents.length) states[i].endedAgents = endedAgents;
+	});
+}
+function writeFileAtomic(file, entry) {
+	const temporary = `${file}.${randomUUID()}.tmp`;
+	try {
+		writeFileSync(temporary, JSON.stringify(entry));
+		renameSync(temporary, file);
+	} catch (error) {
+		rmSync(temporary, { force: true });
+		throw error;
+	}
+}
+function recordEndedAgents(states, gone, endedAt, now) {
+	const goneKeys = new Set(gone.map(agentKey));
+	const result = {
+		changed: false,
+		failed: false
+	};
+	attributeAgentSessions(agentWorkspaces(states), gone, now).forEach((sessions, i) => {
+		const root = states[i].path;
+		const ended = sessions.filter((session) => goneKeys.has(agentKey(session)));
+		if (!ended.length || !existsSync(workspaceDir(root))) return;
+		try {
+			withDirLock(workspaceEndedAgentsLock(root), () => {
+				const kept = new Map(readEndedAgentSessions(root, now).map((session) => [agentKey(session), session]));
+				for (const { pid: _pid, ...session } of ended) kept.set(agentKey(session), {
+					...session,
+					endedAt
+				});
+				writeFileAtomic(workspaceEndedAgentsFile(root), { sessions: [...kept.values()] });
+			});
+			result.changed = true;
+		} catch {
+			result.failed = true;
+		}
+	});
+	return result;
+}
+/**
+* Adds the cached measurements to a status read: each environment's `disk`, `agents` and `endedAgents`, each owned
+* device's `disk`, and each linked worktree's `pullRequest` when the cache holds a lookup for its current branch.
+* Reads files only.
+*/
+function applyStatusMeasures(states, worktrees) {
+	applyAgentSessions(states, Date.now());
+	for (const state of states) {
+		const disk = environmentDisk(environmentFolders(state));
+		if (disk) state.disk = disk;
+		for (const { device, path } of deviceFolders(state)) {
+			const measure = readDiskUsage(path);
+			if (measure) device.disk = measure;
+		}
+	}
+	for (const worktree of worktrees) {
+		const cached = worktree.branch ? readPullRequestCache(worktree.path) : null;
+		if (cached && cached.branch === worktree.branch) worktree.pullRequest = cached.pullRequest;
+	}
+}
+/** Kilobytes from `du -sk` output, or null when it printed none. */
+function parseDuKilobytes(output) {
+	const kb = Number(/^(\d+)\s/.exec(output)?.[1]);
+	return Number.isFinite(kb) ? kb : null;
+}
+function isStale(measure, maxAgeMs, now) {
+	return !measure || now - Date.parse(measure.measuredAt) >= maxAgeMs;
+}
+/**
+* Keeps the disk use, pull request and agent session caches fresh for `status --watch`, off its refresh path: one
+* agent session discovery at most every 15 seconds, which status ignores once it is over 2 minutes old, one `du -sk` at
+* a time, live environments first, each folder at most every 5 minutes while its environment is live and every hour otherwise, and one `gh api
+* graphql` per repository for worktrees whose lookup is over 5 minutes old or whose branch or HEAD moved. It
+* runs git only in the repository, never in a worktree, and only for worktrees whose git state status read. It rechecks
+* a folder's cache right before measuring, so two watchers rarely measure the same folder. A session the previous
+* discovery found and this one does not is recorded as ended in the workspaces it worked in. `updated` runs after each
+* write.
+*/
+function createStatusMeasurer({ updated, now = Date.now }) {
+	const exec = getExecutor();
+	let measuring = false;
+	let duMissing = false;
+	let checking = false;
+	let checkedAt = -Infinity;
+	let discovering = false;
+	let discoveredAt = -Infinity;
+	const failedAt = /* @__PURE__ */ new Map();
+	async function du(path) {
+		try {
+			return parseDuKilobytes(await exec.runFileAsync("du", ["-sk", path], { timeoutMs: DU_TIMEOUT_MS }));
+		} catch (error) {
+			const { code, status, stdout } = error;
+			if (code === "ENOENT") duMissing = true;
+			return status === 1 && typeof stdout === "string" ? parseDuKilobytes(stdout) : null;
+		}
+	}
+	async function measure(folders) {
+		for (const { path, maxAgeMs } of folders) {
+			if (duMissing || !isStale(readDiskUsage(path), maxAgeMs, now())) continue;
+			if (now() - (failedAt.get(path) ?? -Infinity) < maxAgeMs) continue;
+			let bytes = 0;
+			if (existsSync(path)) {
+				const kb = await du(path);
+				if (kb === null) {
+					failedAt.set(path, now());
+					continue;
+				}
+				bytes = kb * 1024;
+			} else if (!basename(path).startsWith("node_modules")) continue;
+			writeCacheFile(diskUsageCacheFile(path), {
+				path,
+				bytes,
+				measuredAt: new Date(now()).toISOString()
+			});
+			updated();
+		}
+	}
+	async function branchHead(repository, branch) {
+		try {
+			return (await exec.runFileAsync("git", [
+				"-C",
+				repository,
+				"rev-parse",
+				"--verify",
+				`refs/heads/${branch}`
+			], { timeoutMs: GIT_TIMEOUT_MS })).trim() || null;
+		} catch {
+			return null;
+		}
+	}
+	async function checkPullRequests(worktrees) {
+		const lookup = pullRequestLookups({ detail: true });
+		const byRepository = /* @__PURE__ */ new Map();
+		for (const { path, branch, repository, git } of worktrees) {
+			if (!branch || !repository || !git) continue;
+			const head = await branchHead(repository, branch);
+			if (!head) continue;
+			const cached = readPullRequestCache(path);
+			if (!(cached?.branch === branch && cached.head === head && now() - Date.parse(cached.checkedAt) < PULL_REQUEST_MAX_AGE_MS)) byRepository.set(repository, [...byRepository.get(repository) ?? [], {
+				path,
+				cwd: repository,
+				branch,
+				head
+			}]);
+		}
+		for (const [repository, queries] of byRepository) {
+			const results = await lookup(repository, queries);
+			const at = new Date(now()).toISOString();
+			results.forEach((result, i) => {
+				if (!("pullRequest" in result)) return;
+				const { path, branch, head } = queries[i];
+				const entry = {
+					path,
+					branch,
+					head,
+					checkedAt: at,
+					pullRequest: result.pullRequest ? statusPullRequest(result.pullRequest, at) : null
+				};
+				writeCacheFile(pullRequestCacheFile(path), entry);
+			});
+			if (results.some((result) => "pullRequest" in result)) updated();
+		}
+	}
+	async function discoverAgents(states) {
+		const at = now();
+		const sessions = await discoverAgentSessions({ now: at });
+		const previous = readAgentSessionsCache();
+		const running = new Set(sessions.map(agentKey));
+		const lastFound = previous ? Date.parse(previous.discoveredAt) : -Infinity;
+		const gone = at - lastFound <= ENDED_AGENT_RETENTION_MS ? previous.sessions.filter((session) => !running.has(agentKey(session))) : [];
+		const ended = gone.length ? recordEndedAgents(states, gone, previous.discoveredAt, at) : {
+			changed: false,
+			failed: false
+		};
+		if (ended.failed && at - lastFound <= AGENT_CACHE_MAX_AGE_MS) return;
+		writeCacheFile(agentSessionsCacheFile(), {
+			discoveredAt: new Date(at).toISOString(),
+			sessions
+		});
+		const shown = previous && at - Date.parse(previous.discoveredAt) <= AGENT_CACHE_MAX_AGE_MS;
+		if (ended.changed || !shown || JSON.stringify(previous.sessions) !== JSON.stringify(sessions)) updated();
+	}
+	return { schedule(states, worktrees) {
+		if (!discovering && now() - discoveredAt >= AGENT_DISCOVERY_MS) {
+			discovering = true;
+			discoveredAt = now();
+			discoverAgents(states).catch(() => {}).finally(() => {
+				discovering = false;
+			});
+		}
+		if (!measuring) {
+			const folders = /* @__PURE__ */ new Map();
+			for (const state of states.toSorted((a, b) => Number(b.live) - Number(a.live))) {
+				if (!existsSync(state.path)) continue;
+				const maxAgeMs = state.live ? LIVE_DISK_MAX_AGE_MS : IDLE_DISK_MAX_AGE_MS;
+				const { worktree, nodeModules, build } = environmentFolders(state);
+				for (const path of [
+					worktree,
+					...nodeModules,
+					build,
+					...deviceFolders(state).map((folder) => folder.path)
+				]) folders.set(path, Math.min(folders.get(path) ?? Infinity, maxAgeMs));
+			}
+			measuring = true;
+			measure([...folders].map(([path, maxAgeMs]) => ({
+				path,
+				maxAgeMs
+			}))).catch(() => {}).finally(() => {
+				measuring = false;
+			});
+		}
+		if (!checking && now() - checkedAt >= PULL_REQUEST_CHECK_MS) {
+			checking = true;
+			checkedAt = now();
+			checkPullRequests(worktrees).catch(() => {}).finally(() => {
+				checking = false;
+			});
+		}
+	} };
+}
+//#endregion
+//#region src/engine/warm-progress.ts
+const NO_WARM_PROGRESS = {
+	step: () => {},
+	finish: () => {}
+};
+function warmProgressClaimRoot(root) {
+	return join(workspaceDir(root), "warm.lock");
+}
+/**
+* Records that `stim worktree warm` runs in the workspace at `root`, under an ownership claim this process holds
+* until `finish`, so a warm that was killed reads as over. A process that cannot take the claim records nothing.
+*/
+function startWarmProgress(root, step, { note, now = Date.now }) {
+	let claim;
+	try {
+		ensureWorkspaceStorage(root);
+		const attempt = (0, ownership_claim_exports.tryAcquireClaim)({
+			root: warmProgressClaimRoot(root),
+			mode: "shared",
+			label: "worktree warm"
+		});
+		if (!attempt.acquired) throw new Error("another process holds its claim exclusively");
+		claim = attempt.acquired;
+	} catch (error) {
+		note(`Warm progress is not recorded for status: ${error?.message || error}`);
+		return NO_WARM_PROGRESS;
+	}
+	const startedAt = new Date(now()).toISOString();
+	const ours = (state) => {
+		const record = readWarmRecord(state);
+		return record?.phase === "warming" && record.claim.claimId === claim.claimId;
+	};
+	let warned = false;
+	const write = (update) => {
+		try {
+			updateWorkspaceState(root, update);
+		} catch (error) {
+			if (warned) return;
+			warned = true;
+			note(`Warm progress could not be recorded in the workspace state: ${error?.message || error}`);
+		}
+	};
+	const warming = (current) => ({
+		phase: "warming",
+		step: current,
+		startedAt,
+		claim: {
+			root: claim.root,
+			claimId: claim.claimId
+		}
+	});
+	write((state) => ({
+		...state,
+		[WARM_KEY]: warming(step)
+	}));
+	return {
+		step(next) {
+			write((state) => ours(state) ? {
+				...state,
+				[WARM_KEY]: warming(next)
+			} : state);
+		},
+		finish(succeeded) {
+			write((state) => {
+				if (!ours(state)) return state;
+				const { [WARM_KEY]: _, ...rest } = state;
+				return succeeded ? {
+					...rest,
+					[WARM_KEY]: {
+						phase: "ready",
+						at: new Date(now()).toISOString()
+					}
+				} : rest;
+			});
+			(0, ownership_claim_exports.releaseClaim)(claim);
+		}
+	};
+}
+/**
+* The lifecycle phase status reports. A warming record counts only while a warm holds the workspace's claim, and a ready
+* record only until the workspace is next used or `READY_PHASE_MS` passes.
+*/
+function workspacePhase(live, state, { now = Date.now(), survey = ownership_claim_exports.readClaimSet } = {}) {
+	if (live) return {
+		phase: "live",
+		phaseSince: null
+	};
+	const record = readWarmRecord(state);
+	if (record?.phase === "warming") {
+		if (survey(record.claim.root).live.length) return {
+			phase: "warming",
+			phaseSince: record.startedAt,
+			warmStep: record.step
+		};
+	}
+	if (record?.phase === "ready") {
+		const at = Date.parse(record.at);
+		const used = Date.parse(String(state?.lastUsedAt ?? ""));
+		if (now - at < READY_PHASE_MS && !(used > at)) return {
+			phase: "ready",
+			phaseSince: record.at
+		};
+	}
+	return {
+		phase: "idle",
+		phaseSince: null
+	};
+}
+//#endregion
+export { forgetStatusMeasures as a, createStatusMeasurer as i, workspacePhase as n, applyStatusMeasures as r, startWarmProgress as t };

package/dist/{idle-DxLi5OkN.mjs → watchman-Bx0wceoF.mjs}

@@ -1,10 +1,11 @@
-import { U as projectDeviceSlots } from "./config-0jCcMM0E.mjs";
-import { h as readWorkspaceState } from "./metro-BPeY1YMh.mjs";
-import { o as formatLongDuration } from "./command-output-BIL7rlX7.mjs";
-import { i as idleForMs, n as createActivityReader } from "./activity-DfVKZTEB.mjs";
-import { R as ownedAvdSerialResolver } from "./android-qx_31wJo.mjs";
-import { f as teardownOwnedAvd, m as teardownOwnedIosSim } from "./ownership-PUP4Dwai.mjs";
-import { r as activeBuildState, s as parseActiveBuild, t as ACTIVE_BUILD_KEY } from "./build-progress-l7d-X-ZP.mjs";
+import { t as getExecutor } from "./exec-CaErVv7t.mjs";
+import { H as projectDeviceSlots } from "./config-D0DbpZtM.mjs";
+import { r as readWorkspaceState } from "./workspace-state-CL2V2Ons.mjs";
+import { i as idleForMs, n as createActivityReader } from "./activity-B2-kb7k0.mjs";
+import { o as formatLongDuration } from "./command-output-CliHHn7a.mjs";
+import { z as ownedAvdSerialResolver } from "./android-Db2eEMaf.mjs";
+import { i as teardownOwnedAvd, o as teardownOwnedIosSim } from "./teardown-BYuQafiA.mjs";
+import { r as activeBuildState, s as parseActiveBuild, t as ACTIVE_BUILD_KEY } from "./build-progress-C2Jv1AtA.mjs";
 import chalk from "chalk";
 //#region src/commands/gc/results.ts
 const results = [];
@@ -188,4 +189,50 @@ function shutDownIdleDevices(devices, idleMs, recollect) {
 	};
 }
 //#endregion
-export { parseIdleDuration as a, recordGcResult as c, idleShutdownCandidates as i, takeGcResults as l, collectOwnedDeviceActivity as n, shutDownIdleDevices as o, idleDeviceLines as r, workspaceBuildInProgress as s, collectIdleDevices as t };
+//#region src/watchman.ts
+/** Runs one watchman command with `--no-spawn`, so Stim never starts a daemon, and parses its JSON answer. */
+const runWatchman = async (args, timeoutMs) => JSON.parse(await getExecutor().runFileAsync("watchman", ["--no-spawn", ...args], { timeoutMs }));
+function parseWatchRoots(payload) {
+	const roots = payload?.roots;
+	if (!Array.isArray(roots)) return null;
+	return roots.filter((root) => typeof root === "string");
+}
+function parseSubscriberNames(payload) {
+	if (!payload || typeof payload !== "object" || "error" in payload) return null;
+	const subscribers = payload.subscribers;
+	if (subscribers === void 0) return [];
+	if (!Array.isArray(subscribers)) return null;
+	const names = [];
+	for (const subscriber of subscribers) {
+		const name = subscriber?.info?.name;
+		if (typeof name !== "string") return null;
+		names.push(name);
+	}
+	return names;
+}
+function parseTriggerCount(payload) {
+	const triggers = payload?.triggers;
+	return Array.isArray(triggers) ? triggers.length : null;
+}
+function parseWatchmanPid(payload) {
+	const pid = payload?.pid;
+	return typeof pid === "number" && Number.isInteger(pid) && pid > 0 ? pid : null;
+}
+/** The connected clients in a `debug-status` answer, or null when the answer does not list them. */
+function parseWatchmanClients(payload) {
+	if (!payload || typeof payload !== "object" || "error" in payload) return null;
+	const clients = payload.clients;
+	if (!Array.isArray(clients)) return null;
+	const parsed = [];
+	for (const client of clients) {
+		const peer = client?.peer;
+		if (typeof peer?.pid !== "number") return null;
+		parsed.push({
+			pid: peer.pid,
+			name: typeof peer.name === "string" ? peer.name : null
+		});
+	}
+	return parsed;
+}
+//#endregion
+export { parseWatchmanPid as a, collectOwnedDeviceActivity as c, parseIdleDuration as d, shutDownIdleDevices as f, takeGcResults as h, parseWatchmanClients as i, idleDeviceLines as l, recordGcResult as m, parseTriggerCount as n, runWatchman as o, workspaceBuildInProgress as p, parseWatchRoots as r, collectIdleDevices as s, parseSubscriberNames as t, idleShutdownCandidates as u };

package/dist/{web-sWXd5iek.mjs → web-k6w8-HnE.mjs}

@@ -1,22 +1,27 @@
-import { 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 { o as readNdjsonGenerations } from "./ndjson-CDY9IkVC.mjs";
-import { M as workspaceLogsDir, c as resolveProjectMetro, f as reserveMetroPort, g as recordWorkspaceUse, h as readWorkspaceState, k as workspaceDir } from "./metro-BPeY1YMh.mjs";
-import { s as gitCommonDir, y as repoRoot } from "./worktree-DeBQSVtR.mjs";
-import { i as findCommandWorkspace, r as detectIsExpo, s as isPackageResolvable } from "./project-DGeclhvO.mjs";
-import { n as windowsLauncherArgs } from "./detached-entry-DJHoca49.mjs";
-import { a as withWorkspaceProcessLock, i as reserveBrowserPort, n as getNamedPort } from "./named-ports-n7tnJsI8.mjs";
-import { f as refuseNoProject, l as phaseLine } from "./command-output-BIL7rlX7.mjs";
-import { P as settingShapeErrors, R as webSettings, a as SETTING_SHAPE_REMEDY, j as resolveSettings } from "./settings-xB0Frkg6.mjs";
-import { d as teardownBrowserHeld, t as resolveSupervisorTarget } from "./ownership-PUP4Dwai.mjs";
-import { a as readWebRecord, f as webSupervisorLogFile, o as updateWebRecord, r as cdpEndpoint, u as webLogFile } from "./state-l1pYwOre.mjs";
-import { i as findChrome, t as CHROME_INSTALL_REMEDY } from "./chrome-B5hWgQJS.mjs";
-import { c as readMetroRecords } from "./launch-verify-CuJaBpEa.mjs";
-import { f as spawnEntry } from "./start-BZhItkiL.mjs";
-import { a as sleep, n as ensureWorkspaceStorageSafely } from "./native-runtime-CiiFHt0e.mjs";
-import { n as sendToOwnedPage, t as liveWebRecord } from "./page-BTu7I60K.mjs";
-import { mkdirSync, openSync } from "node:fs";
+import { C as workspaceLogsDir, b as workspaceDir, i as recordWorkspaceUse, r as readWorkspaceState } from "./workspace-state-CL2V2Ons.mjs";
+import { s as gitCommonDir, y as repoRoot } from "./worktree-C0c5Udwa.mjs";
+import { i as findCommandWorkspace, r as detectIsExpo, s as isPackageResolvable } from "./project-CV3tDFHl.mjs";
+import { n as windowsLauncherArgs } from "./detached-entry-CiTEgMR1.mjs";
+import { t as withWorkspaceProcessLock } from "./workspace-process-lock-BL7Q0HCO.mjs";
+import { f as refuseNoProject, l as phaseLine } from "./command-output-CliHHn7a.mjs";
+import { a as workspaceLinks, i as workspaceLinkLine } from "./stim-desktop-Cnz8CPnl.mjs";
+import { l as resolveProjectMetro } from "./metro-Di8EN2Tb.mjs";
+import { L as settingShapeErrors, N as resolveSettings, S as metroPortSetting, V as webSettings, a as SETTING_SHAPE_REMEDY } from "./settings-CduVcoxj.mjs";
+import { r as teardownBrowserHeld } from "./teardown-BYuQafiA.mjs";
+import { i as reserveBrowserPort, n as getNamedPort } from "./named-ports-Dj_XBNaL.mjs";
+import { d as webLogFile, o as readWebRecord, p as webSupervisorLogFile, r as cdpEndpoint, s as updateWebRecord } from "./state-DFm77wRn.mjs";
+import { u as resolveSupervisorTarget } from "./stop-cause-CZ_Mr-v9.mjs";
+import { a as findChrome, t as CHROME_INSTALL_REMEDY } from "./chrome-BrcVWQyD.mjs";
+import { t as spawnEntry } from "./spawn-entry-DncpJvWL.mjs";
+import { c as readMetroRecords } from "./launch-verify-CLlofxRt.mjs";
+import { o as resolveWorkspaceMetroPort } from "./start-CUD9nasA.mjs";
+import { a as sleep, n as ensureWorkspaceStorageSafely } from "./native-runtime-i6OkVg-w.mjs";
+import { n as sendToOwnedPage, t as liveWebRecord } from "./page-QF_Ke10s.mjs";
 import { randomUUID } from "node:crypto";
+import { mkdirSync, openSync } from "node:fs";
 import chalk from "chalk";
 //#region src/web/launch.ts
 const VERIFY_WAIT_MS = 2e4;
@@ -243,13 +248,19 @@ async function runWeb({ root, headed, note }) {
 	const [shapeError] = settingShapeErrors(settings);
 	if (shapeError) return failure("STIM_BAD_ARG", shapeError, SETTING_SHAPE_REMEDY);
 	const web = webSettings(settings);
+	const usesMetro = web.url === null || web.url.includes("{port:metro}");
+	const pin = usesMetro ? metroPortSetting(root) : null;
+	if (pin?.error) return failure("STIM_BAD_ARG", pin.error, SETTING_SHAPE_REMEDY);
 	const chrome = findChrome();
 	if (!chrome) return failure("STIM_WEB_NO_CHROME", "Google Chrome or Chromium is not installed.", CHROME_INSTALL_REMEDY);
-	const usesMetro = web.url === null || web.url.includes("{port:metro}");
 	if (web.url === null && !detectIsExpo(root)) return failure("STIM_WEB_NO_URL", "This is not an Expo app, so Stim does not know which page to open.", "Start your web dev server on a named port, then set the page: `stim settings set web.url 'http://localhost:{port:web}/' --scope workspace`. See `stim guide web`.");
 	if (web.url === null && !isPackageResolvable(root, "react-native-web")) return failure("STIM_WEB_DEPS_MISSING", "This Expo app cannot render on the web: react-native-web is not installed.", `Run \`${EXPO_WEB_DEPENDENCIES}\` and \`stim start\`, then run \`stim web\` again.`);
 	let metroPort = getProject(root)?.metroPort ?? null;
-	if (usesMetro && metroPort === null) metroPort = await reserveMetroPort(root);
+	if (usesMetro && (pin?.port !== null || metroPort === null)) {
+		const result = await resolveWorkspaceMetroPort(root, note, "web");
+		if (typeof result !== "number") return failure(result.code, result.message, result.remedy);
+		metroPort = result;
+	}
 	const metro = usesMetro && metroPort !== null ? await resolveProjectMetro(metroPort, root) : null;
 	const supervisor = resolveSupervisorTarget({
 		state: readWorkspaceState(root)?.supervisor,
@@ -266,7 +277,7 @@ async function runWeb({ root, headed, note }) {
 	try {
 		url = await resolveWebUrl(web.url ?? "http://localhost:{port:metro}/", {
 			metroPort,
-			namedPort: (label) => getNamedPort(root, label, { log: note })
+			namedPort: (label) => getNamedPort(root, label)
 		});
 	} catch (error) {
 		return failure("STIM_BAD_ARG", `web.url: ${error.message}`, SETTING_SHAPE_REMEDY);
@@ -300,7 +311,7 @@ async function runWeb({ root, headed, note }) {
 		}
 		const stopped = await teardownBrowserHeld(root);
 		if (stopped.status === "failed" || stopped.status === "skipped") return failure("STIM_WEB_BROWSER_HELD", `The previous owned Chrome could not be stopped: ${stopped.reason ?? "unknown reason"}.`, "Run `stim status` and `stim guide errors teardown`.");
-		const port = await reserveBrowserPort(root, { log: note });
+		const port = await reserveBrowserPort(root);
 		const since = Date.now();
 		note(chalk.dim(phaseLine("device", `starting ${config.headless ? "headless " : ""}Chrome on DevTools port ${port}`)));
 		const launchId = randomUUID();
@@ -351,6 +362,7 @@ async function runWeb({ root, headed, note }) {
 			viewport: record.viewport,
 			profile: record.profile,
 			cdpEndpoint: live ? cdpEndpoint(live.cdpPort) : null,
+			targetId: live?.targetId ?? null,
 			reused: launch.reused,
 			launched: verdict.launched,
 			metroPort: usesMetro ? metroPort : null,
@@ -382,12 +394,17 @@ function webCommand(program) {
 		}
 		const { facts, remedy } = result;
 		if (remedy) printNote(chalk.yellow(phaseLine("launch", remedy)));
+		const links = workspaceLinks(root, { platform: "web" });
 		if (json) {
-			console.log(JSON.stringify(facts));
+			console.log(JSON.stringify(links ? {
+				...facts,
+				links
+			} : facts));
 			return;
 		}
 		const launched = facts.launched === true ? chalk.green("loaded") : chalk.yellow(facts.launched === "bundling" ? "bundling" : "unverified");
 		console.log(facts.running ? `${facts.url} ${launched} in ${facts.version ?? "Chrome"} (pid ${facts.pid}, ${facts.headless ? "headless" : "headed"}, ${facts.viewport}). DevTools: ${facts.cdpEndpoint}. Logs: stim logs --errors.` : `${facts.url} ${launched}, and the owned Chrome is no longer running. Run stim logs --errors, then stim web again.`);
+		if (links) console.error(chalk.dim(workspaceLinkLine(links)));
 	});
 }
 //#endregion