stim 1.8.0 → 1.10.0

package/dist/{teardown-BJqEzPo_.mjs → ownership-DZjdx8Gq.mjs}

@@ -1,528 +1,84 @@
-import { t as getExecutor } from "./exec-B29XNuhP.mjs";
-import { C as withConfigLock, E as ownership_claim_exports, I as deviceSlotPlatforms, N as assignSlotDevice, R as projectDeviceSlots, T as acquireAvdClaim, d as getConfigPath, g as loadConfig, s as ensureConfig, u as getConfigDir, y as saveConfig, z as removeSlotDevice } from "./config-B7iyKWkL.mjs";
-import { r as createNdjsonWriter } from "./ndjson-BZwI1NBv.mjs";
-import { _ as workspaceLogsDir } from "./workspace-state-BT5E3SA2.mjs";
-import { l as resolvePackageJson } from "./project-DDZWf_16.mjs";
-import { n as stripAnsi } from "./process-output-Dl5uKE03.mjs";
-import { I as resolveOwnedAvdSerial, O as ownedAvdDirectory, R as shutdownAndroidEmulator, T as listOrphanedAvdDirectories, c as assertOwnedAvdStopped, d as avdStorageRoots, h as deleteAvd, j as ownedAvdSystemImage, k as ownedAvdMatchesConfiguration, l as avdPathExists, z as waitForAndroidEmulatorShutdown } from "./android-DWssqHQ8.mjs";
-import { l as phaseLine } from "./command-output-B3ycpsYv.mjs";
-import { n as expoBinFromPackage, r as expoBinPath, s as findBinUpward } from "./server-expo-BVAA1OqJ.mjs";
-import { C as shutdownIosSim, _ as renameIosSim, a as deleteIosSim, d as listIosDeviceTypes, g as parseRuntimeVersion, h as parkedSimName, o as deleteParkedIosSim, r as clearAppDataContainer, s as findAppDataContainer, x as resolveOwnedIosSim } from "./ios-BcCiI4TS.mjs";
-import { createRequire } from "node:module";
-import { existsSync, lstatSync, readFileSync, renameSync, rmSync } from "node:fs";
-import { randomUUID } from "node:crypto";
-import { dirname, join } from "node:path";
-import { pathToFileURL } from "node:url";
-import { format, isDeepStrictEqual } from "node:util";
-import { AsyncLocalStorage } from "node:async_hooks";
-//#region src/engine/remote-cache.ts
-const EAS_PROVIDER_PACKAGE = "eas-build-cache-provider";
-const RESOLVE_TIMEOUT_MS = 3e4;
-const UPLOAD_TIMEOUT_MS = 6e4;
-const CONFIG_TIMEOUT_MS = 3e4;
-const DYNAMIC_CONFIG_FILES = [
-	"app.config.ts",
-	"app.config.js",
-	"app.config.mjs",
-	"app.config.cjs"
-];
-const TIMED_OUT = Symbol("timed-out");
-function dynamicConfigFile(root) {
-	for (const name of DYNAMIC_CONFIG_FILES) if (existsSync(join(root, name))) return name;
-	return null;
-}
-function providerFromConfig(config) {
-	if (!config || typeof config !== "object") return null;
-	const expoField = config.expo;
-	const exp = expoField && typeof expoField === "object" ? expoField : config;
-	return exp.buildCacheProvider ?? exp.experiments?.buildCacheProvider ?? null;
-}
-function ownerFromConfig(config) {
-	if (!config || typeof config !== "object") return null;
-	const expoField = config.expo;
-	const owner = (expoField && typeof expoField === "object" ? expoField : config).owner;
-	return typeof owner === "string" && owner.trim() !== "" ? owner.trim() : null;
-}
-function normalizeProvider(raw) {
-	if (raw === null || raw === void 0 || raw === "") return null;
-	if (raw === "eas") return {
-		name: "eas",
-		reference: EAS_PROVIDER_PACKAGE,
-		options: {}
-	};
-	if (typeof raw === "object") {
-		const obj = raw;
-		if (typeof obj.plugin === "string" && obj.plugin.trim() !== "") {
-			const reference = obj.plugin.trim();
-			return {
-				name: reference,
-				reference,
-				options: obj.options && typeof obj.options === "object" ? obj.options : {}
-			};
-		}
-	}
-	return { invalid: typeof raw === "string" ? `"${raw}"` : JSON.stringify(raw) };
-}
-function runOptionsFor(platform) {
-	return platform === "android" ? { variant: "debug" } : { configuration: "Debug" };
-}
-function isProviderPlugin(plugin) {
-	if (!plugin || typeof plugin !== "object") return false;
-	const p = plugin;
-	const resolves = typeof p.resolveBuildCache === "function" || typeof p.resolveRemoteBuildCache === "function";
-	const uploads = typeof p.uploadBuildCache === "function" || typeof p.uploadRemoteBuildCache === "function";
-	return resolves && uploads;
-}
-function cacheLevel(value) {
-	return value === "local" || value === "remote" ? value : false;
-}
-function exitAfterFlush(code = 0, { exit = (c) => process.exit(c), stream = process.stdout } = {}) {
-	try {
-		stream.write("", () => exit(code));
-	} catch {
-		exit(code);
-	}
-}
-function readProjectConfig(root, { run = null, timeoutMs = CONFIG_TIMEOUT_MS } = {}) {
-	const dynamic = dynamicConfigFile(root);
-	if (!dynamic) {
-		const file = join(root, "app.json");
-		if (!existsSync(file)) return {
-			config: null,
-			source: null
-		};
-		try {
-			return {
-				config: JSON.parse(readFileSync(file, "utf-8")),
-				source: "app.json"
-			};
-		} catch (err) {
-			return { unavailable: `app.json could not be parsed: ${firstLine(err)}` };
-		}
-	}
-	const bin = expoBinPath(root);
-	if (!bin) return { unavailable: `${dynamic} is code, so it has to be evaluated to read its buildCacheProvider, and the \`expo\` package is not resolvable from this project (no expo/package.json to read a bin from, and no node_modules/.bin/expo here or in any parent)` };
-	const exec = run || ((file, args, opts) => getExecutor().runFile(file, args, opts));
-	let stdout;
-	try {
-		stdout = exec(bin, [
-			"config",
-			"--json",
-			root
-		], { timeoutMs });
-	} catch (err) {
-		return { unavailable: `\`expo config --json\` failed: ${firstLine(err)}` };
-	}
-	try {
-		return {
-			config: JSON.parse(String(stdout)),
-			source: dynamic
-		};
-	} catch (err) {
-		return { unavailable: `\`expo config --json\` did not print JSON: ${firstLine(err)}` };
-	}
-}
-async function loadPlugin(projectRoot, reference, { requireFrom = null } = {}) {
-	const localRequire = requireFrom ? requireFrom(projectRoot) : createRequire(join(projectRoot, "package.json"));
-	const file = localRequire.resolve(reference);
-	let mod;
-	try {
-		mod = localRequire(file);
-	} catch (err) {
-		if (err?.code !== "ERR_REQUIRE_ESM") throw err;
-		mod = await import(pathToFileURL(file).href);
-	}
-	const plugin = mod?.default ?? mod;
-	if (!isProviderPlugin(plugin)) throw new Error(`"${reference}" does not export resolveBuildCache and uploadBuildCache functions`);
-	return plugin;
-}
-async function loadProjectProvider(projectRoot, { isExpo = true, run = null, requireFrom = null, timeoutMs = CONFIG_TIMEOUT_MS } = {}) {
-	if (!isExpo) return { none: true };
-	const read = readProjectConfig(projectRoot, {
-		run,
-		timeoutMs
-	});
-	if (read.unavailable) return { unavailable: read.unavailable };
-	const normalized = normalizeProvider(providerFromConfig(read.config));
-	if (!normalized) return { none: true };
-	if (normalized.invalid) return { unavailable: `buildCacheProvider is ${normalized.invalid}, which is not "eas" or { plugin: <module> }` };
-	if (normalized.reference === "@stim-cli/expo-build-cache") return { none: true };
-	let plugin;
-	try {
-		plugin = await loadPlugin(projectRoot, normalized.reference, { requireFrom });
-	} catch (err) {
-		const missing = err?.code === "MODULE_NOT_FOUND";
-		return { unavailable: normalized.name === "eas" && missing ? `the EAS build cache needs the \`${EAS_PROVIDER_PACKAGE}\` package, which is not installed in this project` : `${normalized.name} could not be loaded: ${firstLine(err)}` };
-	}
-	return {
-		provider: {
-			plugin,
-			options: normalized.options ?? {}
-		},
-		name: normalized.name,
-		owner: ownerFromConfig(read.config)
-	};
-}
-const WHOAMI_TIMEOUT_MS = 15e3;
-const EAS_CLI_PACKAGE = "eas-cli";
-const EAS_CLI_BIN = "eas";
-function parseWhoami({ stdout = "", stderr = "", exitCode = 0 } = {}) {
-	const out = stripAnsi(stdout);
-	const combined = `${out}\n${stripAnsi(stderr)}`;
-	if (/^\s*Not logged in\s*$/m.test(combined)) return { loggedOut: true };
-	if (exitCode !== 0) return { unknown: firstLine(combined.trim() || `eas whoami exited ${exitCode}`) };
-	const lines = out.split("\n").map((line) => line.trim()).filter((line) => line !== "");
-	if (lines.length === 0) return { unknown: "eas whoami printed nothing" };
-	const raw = lines[0];
-	if (raw === void 0) return { unknown: "eas whoami printed nothing" };
-	const viaToken = /\(authenticated using EXPO_TOKEN\)\s*$/.test(raw);
-	const display = raw.replace(/\s*\(authenticated using EXPO_TOKEN\)\s*$/, "").trim();
-	const accounts = [];
-	for (const line of lines) {
-		const name = /^\u2022\s*(\S+)\s*\(Role:/.exec(line)?.[1];
-		if (name !== void 0) accounts.push(name);
-	}
-	if (accounts.length === 0 && !display.endsWith("(robot)") && display !== "robot") accounts.push(display);
-	return {
-		loggedIn: true,
-		account: display,
-		accounts: accounts.length ? accounts : null,
-		viaToken
-	};
-}
-function isEasAuthFailureText(text) {
-	const t = stripAnsi(text || "");
-	if (t.trim() === "") return false;
-	return /not logged in/i.test(t) || /\beas login\b/i.test(t) || /EXPO_TOKEN/.test(t) || /unauthorized/i.test(t) || /not authorized/i.test(t) || /authentication (failed|required)/i.test(t);
-}
-function easAuthNote(status) {
-	const { code, account, owner, reason, phase = "resolve" } = status || {};
-	const because = reason ? ` (${reason})` : "";
-	if (code === "logged-out") return `eas is not authenticated${because} -- run \`eas login\` (or set EXPO_TOKEN); ` + (phase === "upload" ? "this build stayed in the local cache" : "building with the local cache only");
-	if (code === "wrong-account") return `eas is authenticated as ${account}, and this project's owner is ${owner} -- run \`eas login\` as a member of ${owner} (or set EXPO_TOKEN); consulting the EAS cache anyway`;
-	return null;
-}
-function resolveEasCliBin(projectRoot, { lookupPath = null } = {}) {
-	const fromPackage = expoBinFromPackage(resolvePackageJson(projectRoot, EAS_CLI_PACKAGE), EAS_CLI_BIN);
-	if (fromPackage) return {
-		file: fromPackage,
-		source: "project"
-	};
-	const shim = findBinUpward(projectRoot, EAS_CLI_BIN);
-	if (shim) return {
-		file: shim,
-		source: "project"
-	};
-	const onPath = lookupPath ? lookupPath() : getExecutor().findExecutable(EAS_CLI_BIN);
-	const file = (String(onPath || "").split("\n")[0] ?? "").trim();
-	return file ? {
-		file,
-		source: "path"
-	} : null;
-}
-const easAuthCache = /* @__PURE__ */ new Map();
-function checkEasAuth({ projectRoot, owner = null, run = null, resolveBin = null, timeoutMs = WHOAMI_TIMEOUT_MS, cache = easAuthCache }) {
-	const key = `${projectRoot}::${owner || ""}`;
-	if (cache?.has(key)) return cache.get(key);
-	const answer = probeEasAuth({
-		projectRoot,
-		owner,
-		run,
-		resolveBin,
-		timeoutMs
-	});
-	cache?.set(key, answer);
-	return answer;
-}
-function probeEasAuth({ projectRoot, owner, run, resolveBin, timeoutMs }) {
-	const bin = (resolveBin || resolveEasCliBin)(projectRoot);
-	if (!bin) return {
-		failed: true,
-		code: "no-cli",
-		reason: "no `eas` executable is resolvable from this project or on PATH",
-		remedy: "Install eas-cli (`npm i -g eas-cli`, or as a project devDependency), then run `eas login`."
-	};
-	const exec = run || ((file, args, opts) => getExecutor().runFile(file, args, opts));
-	let result;
-	try {
-		result = {
-			stdout: String(exec(bin.file, ["whoami"], { timeoutMs }) ?? ""),
-			exitCode: 0
-		};
-	} catch (e) {
-		const err = e;
-		if (err?.code === "ETIMEDOUT" || err?.signal === "SIGTERM" || err?.killed) return { unknown: `eas whoami timed out after ${timeoutMs}ms` };
-		result = {
-			stdout: String(err?.stdout ?? ""),
-			stderr: String(err?.stderr ?? err?.message ?? ""),
-			exitCode: typeof err?.status === "number" ? err.status : 1
-		};
-	}
-	const parsed = parseWhoami(result);
-	if (parsed.loggedOut) return {
-		failed: true,
-		code: "logged-out",
-		reason: "eas whoami says \"Not logged in\"",
-		remedy: "Run `eas login` (or set EXPO_TOKEN)."
-	};
-	if (parsed.unknown) return { unknown: parsed.unknown };
-	if (owner && Array.isArray(parsed.accounts) && !parsed.accounts.includes(owner)) return {
-		failed: true,
-		code: "wrong-account",
-		account: parsed.account,
-		accounts: parsed.accounts,
-		owner,
-		reason: `eas is authenticated as ${parsed.account} (accounts: ${parsed.accounts.join(", ")}), which does not include this project's owner ${owner}`,
-		remedy: `Run \`eas login\` as a member of ${owner}, or set EXPO_TOKEN to a token for it.`
-	};
-	return {
-		ok: true,
-		account: parsed.account,
-		accounts: parsed.accounts,
-		viaToken: parsed.viaToken,
-		source: bin.source
-	};
-}
-const capturing = [];
-const abandoned = /* @__PURE__ */ new Set();
-let patched = null;
-const PROVIDER_CONTEXT = new AsyncLocalStorage();
-function uploadDestination(lines) {
-	const text = (lines || []).map(stripAnsi);
-	for (const line of text) {
-		const url = /(https?:\/\/[^\s'"]+)/.exec(line)?.[1];
-		if (url !== void 0) return url.replace(/[.,)\]]+$/, "");
-	}
-	for (const line of text) {
-		const slug = /\bto\s+(@?[\w.-]+\/[\w.-]+)/i.exec(line)?.[1];
-		if (slug !== void 0) return slug.replace(/[.,)\]]+$/, "");
-	}
-	return null;
-}
-function providerNote(text) {
-	return `${"cache".padEnd(11)} ${text}`;
-}
-function currentFrame() {
-	const store = PROVIDER_CONTEXT.getStore();
-	return store && (capturing.includes(store) || abandoned.has(store)) ? store : null;
-}
-function install() {
-	if (patched && process.stdout.write === patched.patchedWrite) return;
-	const stdout = process.stdout;
-	const write = stdout.write.bind(stdout);
-	const log = console.log;
-	const passthrough = write;
-	const patchedWrite = ((chunk, encoding, callback) => {
-		const frame = currentFrame();
-		if (!frame) return passthrough(chunk, encoding, callback);
-		const cb = typeof encoding === "function" ? encoding : callback;
-		absorb(frame, typeof chunk === "string" ? chunk : String(chunk));
-		if (typeof cb === "function") cb();
-		return true;
+import { D as process_identity_exports, H as projectDeviceSlots, I as assignSlotDevice, O as acquireAvdClaim, T as withConfigLock, U as removeSlotDevice, d as getConfigPath, g as loadConfig, k as ownership_claim_exports, s as ensureConfig, u as getConfigDir, x as saveConfig, z as deviceSlotPlatforms } from "./config-BEq0Qw_a.mjs";
+import { t as getExecutor } from "./exec-DK8KaVHK.mjs";
+import { c as signalProcessTree, i as pidExists } from "./metro-BWLOJ_Wr.mjs";
+import { r as workspaceProcessLockPath, t as withWorkspaceProcessLock } from "./workspace-process-lock-BXA96myD.mjs";
+import { t as createLineReader } from "./process-output-Fpl8PYi8.mjs";
+import { l as phaseLine } from "./command-output-D5z2_bcF.mjs";
+import { A as ownedAvdDirectory, C as isStimOwnedAvdName, D as listOrphanedAvdDirectories, G as wipeAvdUserData, H as sleepSync, P as ownedAvdSystemImage, U as waitForAndroidEmulatorShutdown, V as shutdownAndroidEmulator, f as avdStorageRoots, g as deleteAvd, j as ownedAvdMatchesConfiguration, l as assertOwnedAvdStopped, u as avdPathExists, z as resolveOwnedAvdSerial } from "./android-787HhP5w.mjs";
+import { S as resolveOwnedIosSim, a as deleteParkedIosSim, d as listIosDeviceTypes, g as parseRuntimeVersion, h as parkedSimName, i as deleteIosSim, o as eraseIosSim, v as renameIosSim, w as shutdownIosSim } from "./ios-B2Fpqvlb.mjs";
+import { closeSync, lstatSync, mkdirSync, openSync, readFileSync, renameSync, rmSync, unlinkSync } from "node:fs";
+import { basename, dirname, join, resolve, sep } from "node:path";
+import { createHash, randomUUID } from "node:crypto";
+import { isDeepStrictEqual } from "node:util";
+import { resolve4 } from "node:dns/promises";
+import { request } from "node:https";
+//#region src/devices/agent-device-cleanup.ts
+function parseAgentDeviceSessions(output) {
+	const result = JSON.parse(output);
+	if (result?.success !== true || !Array.isArray(result.data?.sessions)) throw new Error("agent-device did not return a successful session list");
+	return result.data.sessions.flatMap((entry) => {
+		if (!entry || typeof entry !== "object") return [];
+		const row = entry;
+		const id = row.platform === "ios" ? row.device_udid : row.id;
+		if (row.platform !== "ios" && row.platform !== "android" || typeof row.name !== "string" || !row.name.trim() || typeof id !== "string" || !id || typeof row.createdAt !== "number" || !Number.isFinite(row.createdAt) || row.platform === "ios" && row.id !== void 0 && row.id !== id) return [];
+		return [{
+			name: row.name,
+			platform: row.platform,
+			id,
+			createdAt: row.createdAt
+		}];
 	});
-	const patchedLog = (...args) => {
-		const frame = currentFrame();
-		if (!frame) return log(...args);
-		absorb(frame, `${format(...args)}\n`);
-	};
-	stdout.write = patchedWrite;
-	console.log = patchedLog;
-	patched = {
-		stdout,
-		write,
-		log,
-		patchedWrite,
-		patchedLog
-	};
-}
-function uninstall() {
-	if (!patched || capturing.length || abandoned.size) return;
-	if (patched.stdout.write === patched.patchedWrite) patched.stdout.write = patched.write;
-	if (console.log === patched.patchedLog) console.log = patched.log;
-	patched = null;
 }
-function absorb(frame, chunk) {
-	try {
-		process.stderr.write(chunk);
-	} catch {}
-	frame.pending += chunk;
-	let index = frame.pending.indexOf("\n");
-	while (index !== -1) {
-		emitLine(frame, frame.pending.slice(0, index));
-		frame.pending = frame.pending.slice(index + 1);
-		index = frame.pending.indexOf("\n");
-	}
+function report(message) {
+	process.stderr.write(`${phaseLine("device", message)}\n`);
 }
-function emitLine(frame, raw) {
-	const line = stripAnsi(raw).trim();
-	if (line === "") return;
-	frame.lines.push(line);
-	const writer = frame.writer();
-	try {
-		writer?.write({
-			src: "build",
-			level: "debug",
-			event: "provider",
-			msg: line
+function closeOwnedDeviceSessions(device, stillOwned) {
+	const exec = getExecutor();
+	const deadline = Date.now() + 15e3;
+	const run = (args) => {
+		const remaining = deadline - Date.now();
+		if (remaining <= 0) throw new Error("agent-device cleanup timed out");
+		return exec.runFile("agent-device", [
+			...args,
+			"--json",
+			"--daemon-transport",
+			"socket"
+		], {
+			timeoutMs: Math.min(5e3, remaining),
+			killSignal: "SIGKILL"
 		});
-	} catch {}
-	frame.onLine?.(line);
-}
-function beginCapture({ logWriter = null, projectRoot = null, platform = null, onLine = null } = {}) {
-	let own = null;
-	const frame = {
-		lines: [],
-		pending: "",
-		onLine,
-		writer: () => {
-			if (logWriter) return logWriter;
-			if (own) return own;
-			if (!projectRoot || !platform) return null;
-			own = createNdjsonWriter(join(workspaceLogsDir(projectRoot), `build-${platform}.ndjson`));
-			return own;
-		},
-		close: () => {
-			own?.close?.();
-			own = null;
-		}
 	};
-	capturing.push(frame);
-	install();
-	return frame;
-}
-function endCapture(frame) {
-	if (!frame) return;
-	const at = capturing.lastIndexOf(frame);
-	if (at !== -1) capturing.splice(at, 1);
-	abandoned.delete(frame);
-	if (frame.pending !== "") {
-		const rest = frame.pending;
-		frame.pending = "";
-		emitLine(frame, rest);
-	}
-	frame.close();
-	uninstall();
-}
-function abandonCapture(frame, work) {
-	if (!frame) return;
-	const at = capturing.lastIndexOf(frame);
-	if (at !== -1) capturing.splice(at, 1);
-	abandoned.add(frame);
-	Promise.resolve(work).then(() => endCapture(frame), () => endCapture(frame));
-}
-async function resolveRemote({ provider, platform, projectRoot, fingerprintHash, runOptions = null, timeoutMs = RESOLVE_TIMEOUT_MS, logWriter = null } = {}) {
-	if (!provider?.plugin || !fingerprintHash) return null;
-	const opts = runOptions || runOptionsFor(platform);
-	const outcome = await withBudget(async () => {
-		const props = {
-			fingerprintHash: await providerFingerprint({
-				provider,
-				platform,
-				projectRoot,
-				runOptions: opts
-			}) ?? fingerprintHash,
-			platform,
-			runOptions: opts,
-			projectRoot
-		};
-		return typeof provider.plugin.resolveBuildCache === "function" ? provider.plugin.resolveBuildCache(props, provider.options) : provider.plugin.resolveRemoteBuildCache(props, provider.options);
-	}, timeoutMs, {
-		logWriter,
-		projectRoot,
-		platform
-	});
-	if (outcome.timedOut) return { timedOut: true };
-	if (outcome.error) return { failed: firstLine(outcome.error) };
-	const appPath = typeof outcome.value === "string" ? outcome.value.trim() : "";
-	if (!appPath) return null;
-	if (!existsSync(appPath)) return { failed: `returned ${appPath}, which does not exist` };
-	return { appPath };
-}
-async function uploadRemote({ provider, platform, projectRoot, fingerprintHash, buildPath, runOptions = null, timeoutMs = UPLOAD_TIMEOUT_MS, logWriter = null, note = (line) => console.error(line) } = {}) {
-	if (!provider?.plugin || !fingerprintHash || !buildPath) return { skipped: true };
-	const opts = runOptions || runOptionsFor(platform);
-	let announced = false;
-	const onLine = (line) => {
-		if (announced) return;
-		const dest = uploadDestination([line]);
-		if (!dest) return;
-		announced = true;
-		note(providerNote(`uploading to ${dest}`));
-	};
-	const outcome = await withBudget(async () => {
-		const props = {
-			projectRoot,
-			platform,
-			fingerprintHash: await providerFingerprint({
-				provider,
-				platform,
-				projectRoot,
-				runOptions: opts
-			}) ?? fingerprintHash,
-			buildPath,
-			runOptions: opts
-		};
-		return typeof provider.plugin.uploadBuildCache === "function" ? provider.plugin.uploadBuildCache(props, provider.options) : provider.plugin.uploadRemoteBuildCache(props, provider.options);
-	}, timeoutMs, {
-		logWriter,
-		projectRoot,
-		platform,
-		onLine
-	});
-	if (outcome.timedOut) return { timedOut: true };
-	if (outcome.error) return { failed: firstLine(outcome.error) };
-	const destination = uploadDestination(outcome.lines);
-	return destination ? {
-		uploaded: true,
-		destination
-	} : { uploaded: true };
-}
-async function providerFingerprint({ provider, platform, projectRoot, runOptions }) {
-	if (typeof provider.plugin.calculateFingerprintHash !== "function") return null;
-	try {
-		const hash = await provider.plugin.calculateFingerprintHash({
-			projectRoot,
-			platform,
-			runOptions
-		}, provider.options);
-		return typeof hash === "string" && hash.trim() !== "" ? hash.trim() : null;
-	} catch {
-		return null;
-	}
-}
-async function withBudget(factory, ms, capture) {
-	let timer = null;
-	const timeout = new Promise((resolve) => {
-		timer = setTimeout(() => resolve(TIMED_OUT), ms);
-		timer?.unref?.();
-	});
-	const frame = beginCapture(capture || {});
-	const work = Promise.resolve().then(() => PROVIDER_CONTEXT.run(frame, factory)).then((value) => ({ value }), (error) => ({ error }));
+	const list = () => parseAgentDeviceSessions(run([
+		"session",
+		"list",
+		"--session",
+		"stim-teardown-inventory"
+	]));
 	try {
-		const settled = await Promise.race([work, timeout]);
-		if (settled === TIMED_OUT) {
-			abandonCapture(frame, work);
-			return {
-				timedOut: true,
-				lines: frame.lines
-			};
+		if (!exec.findExecutable("agent-device")) return;
+		const sessions = list().filter((session) => session.platform === device.platform && session.id === device.id);
+		for (const session of sessions) try {
+			if (!list().some((current) => current.name === session.name && current.platform === session.platform && current.id === session.id && current.createdAt === session.createdAt)) continue;
+			if (!stillOwned()) return;
+			if (JSON.parse(run([
+				"close",
+				"--session",
+				session.name,
+				"--session-lock",
+				"reject",
+				"--platform",
+				device.platform,
+				device.platform === "ios" ? "--udid" : "--serial",
+				device.id
+			]))?.success !== true) throw new Error("agent-device did not confirm session close");
+			report(`closed agent-device session ${session.name} on ${device.id}`);
+		} catch (error) {
+			report(`could not close agent-device session ${session.name} on ${device.id}: ${error.message}`);
 		}
-		endCapture(frame);
-		return {
-			...settled,
-			lines: frame.lines
-		};
-	} catch (err) {
-		endCapture(frame);
-		throw err;
-	} finally {
-		if (timer) clearTimeout(timer);
+	} catch (error) {
+		report(`could not list agent-device sessions for ${device.id}: ${error.message}`);
 	}
 }
-function firstLine(err) {
-	const line = (String(err?.message || err || "unknown error").trim().split("\n")[0] ?? "").trim();
-	return line.length > 200 ? `${line.slice(0, 197)}...` : line;
-}
 const POOL_SETTING_REMEDY = "Run `stim guide settings` for the device pool bounds and where it can be set.";
 const MAX_SETTING = {
 	ios: {
@@ -720,74 +276,6 @@ function dropParked(platform, udid) {
 	return removeParkedAfter(platform, udid, () => {}) !== null;
 }
 //#endregion
-//#region src/devices/agent-device-cleanup.ts
-function parseAgentDeviceSessions(output) {
-	const result = JSON.parse(output);
-	if (result?.success !== true || !Array.isArray(result.data?.sessions)) throw new Error("agent-device did not return a successful session list");
-	return result.data.sessions.flatMap((entry) => {
-		if (!entry || typeof entry !== "object") return [];
-		const row = entry;
-		const id = row.platform === "ios" ? row.device_udid : row.id;
-		if (row.platform !== "ios" && row.platform !== "android" || typeof row.name !== "string" || !row.name.trim() || typeof id !== "string" || !id || typeof row.createdAt !== "number" || !Number.isFinite(row.createdAt) || row.platform === "ios" && row.id !== void 0 && row.id !== id) return [];
-		return [{
-			name: row.name,
-			platform: row.platform,
-			id,
-			createdAt: row.createdAt
-		}];
-	});
-}
-function report(message) {
-	process.stderr.write(`${phaseLine("device", message)}\n`);
-}
-function closeOwnedDeviceSessions(device, stillOwned) {
-	const exec = getExecutor();
-	const deadline = Date.now() + 15e3;
-	const run = (args) => {
-		const remaining = deadline - Date.now();
-		if (remaining <= 0) throw new Error("agent-device cleanup timed out");
-		return exec.runFile("agent-device", [
-			...args,
-			"--json",
-			"--daemon-transport",
-			"socket"
-		], {
-			timeoutMs: Math.min(5e3, remaining),
-			killSignal: "SIGKILL"
-		});
-	};
-	const list = () => parseAgentDeviceSessions(run([
-		"session",
-		"list",
-		"--session",
-		"stim-teardown-inventory"
-	]));
-	try {
-		if (!exec.findExecutable("agent-device")) return;
-		const sessions = list().filter((session) => session.platform === device.platform && session.id === device.id);
-		for (const session of sessions) try {
-			if (!list().some((current) => current.name === session.name && current.platform === session.platform && current.id === session.id && current.createdAt === session.createdAt)) continue;
-			if (!stillOwned()) return;
-			if (JSON.parse(run([
-				"close",
-				"--session",
-				session.name,
-				"--session-lock",
-				"reject",
-				"--platform",
-				device.platform,
-				device.platform === "ios" ? "--udid" : "--serial",
-				device.id
-			]))?.success !== true) throw new Error("agent-device did not confirm session close");
-			report(`closed agent-device session ${session.name} on ${device.id}`);
-		} catch (error) {
-			report(`could not close agent-device session ${session.name} on ${device.id}: ${error.message}`);
-		}
-	} catch (error) {
-		report(`could not list agent-device sessions for ${device.id}: ${error.message}`);
-	}
-}
-//#endregion
 //#region src/devices/teardown.ts
 function teardownParkedAvd(avdName) {
 	try {
@@ -837,19 +325,33 @@ function teardownParkedIosSim(udid, { label, deleteSim = deleteParkedIosSim } =
 		};
 	}
 }
-function parkOwnedIosSim(udid, park) {
-	const resolved = resolveOwnedIosSim(udid);
-	if (resolved.missing) throw new Error(`simulator ${udid} disappeared after shutdown`);
-	if (resolved.notOwned) throw new Error(`simulator ${udid} is now named ${JSON.stringify(resolved.notOwned)}`);
-	const sim = resolved.sim;
-	if (sim.state !== "Shutdown") throw new Error(`simulator ${udid} is still ${sim.state} after shutdown`);
+const IOS_SHUTDOWN_SETTLE_MS = 15e3;
+const IOS_SHUTDOWN_POLL_MS = 250;
+const IOS_SHUTDOWN_ATTEMPTS = 2;
+function settleIosSimShutdown(udid, { now = Date.now, sleep = sleepSync }) {
+	let resolved = resolveOwnedIosSim(udid);
+	for (let attempt = 1;; attempt++) {
+		const deadline = now() + IOS_SHUTDOWN_SETTLE_MS;
+		while (resolved.sim && resolved.sim.state !== "Shutdown" && now() < deadline) {
+			sleep(IOS_SHUTDOWN_POLL_MS);
+			resolved = resolveOwnedIosSim(udid);
+		}
+		if (!resolved.sim || resolved.sim.state === "Shutdown" || attempt === IOS_SHUTDOWN_ATTEMPTS) return resolved;
+		shutdownIosSim(udid);
+		resolved = resolveOwnedIosSim(udid);
+	}
+}
+function iosShutdownFailureReason(udid, state) {
+	return `simulator ${udid} is still ${state} after ${IOS_SHUTDOWN_ATTEMPTS} shutdown attempts and ${IOS_SHUTDOWN_ATTEMPTS * IOS_SHUTDOWN_SETTLE_MS / 1e3}s of waiting`;
+}
+function parkOwnedIosSim(settled, udid, park) {
+	if (settled.missing) throw new Error(`simulator ${udid} disappeared after shutdown`);
+	if (settled.notOwned) throw new Error(`simulator ${udid} is now named ${JSON.stringify(settled.notOwned)}`);
+	const sim = settled.sim;
+	if (sim.state !== "Shutdown") throw new Error(iosShutdownFailureReason(udid, sim.state));
 	const model = listIosDeviceTypes().find((d) => d.identifier === sim.deviceTypeIdentifier)?.name ?? null;
 	const runtime = parseRuntimeVersion(sim.runtime);
-	if (park.bundleId) {
-		if (!sim.dataPath) throw new Error(`simulator ${udid} did not report a data path for app cleanup`);
-		const container = findAppDataContainer(sim.dataPath, park.bundleId);
-		if (container) clearAppDataContainer(container);
-	}
+	eraseIosSim(sim.udid);
 	const name = parkedSimName(sim.udid, {
 		model,
 		runtime
@@ -861,9 +363,7 @@ function parkOwnedIosSim(udid, park) {
 		deviceTypeIdentifier: sim.deviceTypeIdentifier,
 		runtimeIdentifier: sim.runtime,
 		parkedAt: (/* @__PURE__ */ new Date()).toISOString(),
-		simslimManaged: Boolean(park.simslimManaged),
-		...park.bundleId ? { bundleId: park.bundleId } : {},
-		...park.cacheKey ? { cacheKey: park.cacheKey } : {}
+		simslimManaged: Boolean(park.simslimManaged)
 	};
 	return {
 		record,
@@ -876,14 +376,14 @@ function parkOwnedIosSim(udid, park) {
 		})
 	};
 }
-function teardownOwnedIosSim(udid, { del = false, label, park } = {}) {
+function teardownOwnedIosSim(udid, { del = false, label, park, shutdownClock = {} } = {}) {
 	let parkFallback;
 	try {
 		const resolved = resolveOwnedIosSim(udid);
 		if (resolved.notOwned) return {
 			status: "skipped",
 			kind: "not-owned",
-			reason: `sim is now named "${resolved.notOwned}", not Stim-owned by name`
+			reason: `sim "${resolved.notOwned}" is not Stim-owned: Stim has no record of creating it`
 		};
 		if (resolved.missing) return { status: "missing" };
 		closeOwnedDeviceSessions({
@@ -900,7 +400,7 @@ function teardownOwnedIosSim(udid, { del = false, label, park } = {}) {
 		shutdownIosSim(udid);
 		const sim = resolved.sim;
 		if (del && park && park.max > 0) try {
-			const { record, evicted } = parkOwnedIosSim(udid, park);
+			const { record, evicted } = parkOwnedIosSim(settleIosSimShutdown(udid, shutdownClock), udid, park);
 			const removed = [];
 			const failures = [];
 			for (const entry of evicted) {
@@ -924,11 +424,23 @@ function teardownOwnedIosSim(udid, { del = false, label, park } = {}) {
 		} catch (e) {
 			parkFallback = String(e?.message || e);
 		}
-		if (del) deleteIosSim(udid);
+		if (del) {
+			deleteIosSim(udid);
+			return {
+				status: "torn-down",
+				label: label ?? sim.name ?? udid,
+				...parkFallback ? { parkFallback } : {}
+			};
+		}
+		const settled = settleIosSimShutdown(udid, shutdownClock);
+		if (settled.sim && settled.sim.state !== "Shutdown") return {
+			status: "failed",
+			label: label ?? sim.name ?? udid,
+			reason: iosShutdownFailureReason(udid, settled.sim.state)
+		};
 		return {
 			status: "torn-down",
-			label: label ?? sim.name ?? udid,
-			...parkFallback ? { parkFallback } : {}
+			label: label ?? sim.name ?? udid
 		};
 	} catch (e) {
 		return {
@@ -988,13 +500,13 @@ function teardownUnregisteredAvd(avdName, del, owner, surveyed) {
 	};
 }
 function teardownOwnedAvd(avdName, options = {}) {
-	if (!/^stim-[A-Za-z0-9._-]+$/.test(avdName)) return {
-		status: "skipped",
-		kind: "not-owned",
-		reason: `AVD ${avdName} is not Stim-owned by name`
-	};
 	let claim;
 	try {
+		if (!isStimOwnedAvdName(avdName, options.orphanedDirectory ? options.orphanedDirectory.directory : void 0)) return {
+			status: "skipped",
+			kind: "not-owned",
+			reason: `AVD ${avdName} is not Stim-owned: Stim has no record of creating it`
+		};
 		claim = acquireAvdClaim(avdName);
 		const result = teardownClaimedAvd(avdName, claim, options);
 		if (result.status === "torn-down" || result.status === "missing") options.onRemoved?.();
@@ -1016,7 +528,7 @@ function teardownClaimedAvd(avdName, claim, { del = false, park, owner, orphaned
 		if (resolved.notOwned) return {
 			status: "skipped",
 			kind: "not-owned",
-			reason: `AVD ${avdName} is not Stim-owned by name`
+			reason: `AVD ${avdName} is not Stim-owned: Stim has no record of creating it`
 		};
 		if (resolved.missing) return teardownUnregisteredAvd(avdName, del, owner, orphanedDirectory);
 		if (onlyIfMissing) return {
@@ -1052,7 +564,7 @@ function teardownClaimedAvd(avdName, claim, { del = false, park, owner, orphaned
 			if (current.notOwned) return {
 				status: "skipped",
 				kind: "not-owned",
-				reason: `AVD ${avdName} is not Stim-owned by name`
+				reason: `AVD ${avdName} is not Stim-owned: Stim has no record of creating it`
 			};
 			if (current.missing) return teardownUnregisteredAvd(avdName, del, owner);
 			if (current.serial) throw new Error(`Owned AVD ${avdName} started again before deletion.`);
@@ -1061,6 +573,9 @@ function teardownClaimedAvd(avdName, claim, { del = false, park, owner, orphaned
 			if (park && park.max > 0) try {
 				const systemImage = ownedAvdSystemImage(avdName);
 				if (!systemImage || !park.configuration || !ownedAvdMatchesConfiguration(avdName, park.configuration)) throw new Error("the AVD has no verified creation configuration");
+				const directory = ownedAvdDirectory(avdName);
+				if (!directory) throw new Error("the AVD data directory could not be resolved");
+				wipeAvdUserData(directory);
 				const evicted = parkSim({
 					platform: "android",
 					projectPath: park.projectPath,
@@ -1125,4 +640,541 @@ function teardownClaimedAvd(avdName, claim, { del = false, park, owner, orphaned
 	}
 }
 //#endregion
-export { resolveRemote as C, resolveEasCliBin as S, exitAfterFlush as _, POOL_SETTING_REMEDY as a, ownerFromConfig as b, isLegacyDeletionClaim as c, selectParked as d, RESOLVE_TIMEOUT_MS as f, easAuthNote as g, checkEasAuth as h, teardownParkedIosSim as i, parkedMaxSetting as l, cacheLevel as m, teardownOwnedIosSim as n, adoptParked as o, UPLOAD_TIMEOUT_MS as p, teardownParkedAvd as r, dropParked as s, teardownOwnedAvd as t, readParked as u, isEasAuthFailureText as v, uploadRemote as w, providerFromConfig as x, loadProjectProvider as y };
+//#region src/engine/public-http-probe.ts
+const DNS_TIMEOUT_MS = 5e3;
+async function resolveAddresses(hostname, signal) {
+	if (signal.aborted) throw signal.reason;
+	let timer;
+	let onAbort;
+	const unavailable = new Promise((_resolve, reject) => {
+		onAbort = () => reject(signal.reason);
+		signal.addEventListener("abort", onAbort, { once: true });
+		if (signal.aborted) onAbort();
+		else timer = setTimeout(() => reject(/* @__PURE__ */ new Error("DNS lookup timed out")), DNS_TIMEOUT_MS);
+	});
+	try {
+		return await Promise.race([resolve4(hostname), unavailable]);
+	} finally {
+		clearTimeout(timer);
+		if (onAbort) signal.removeEventListener("abort", onAbort);
+	}
+}
+async function probePublicHttp(url, signal) {
+	try {
+		return (await fetch(url, {
+			signal,
+			redirect: "follow"
+		})).status;
+	} catch (error) {
+		const cause = error?.cause;
+		if (cause?.code !== "ENOTFOUND" && cause?.code !== "EAI_AGAIN") return null;
+	}
+	const hostname = new URL(url).hostname;
+	if (!hostname.endsWith(".trycloudflare.com")) return null;
+	let addresses;
+	try {
+		addresses = await resolveAddresses(hostname, signal);
+	} catch {
+		return null;
+	}
+	const firstAddress = addresses[0];
+	if (!firstAddress) return null;
+	return new Promise((resolve) => {
+		const request$1 = request(url, {
+			signal,
+			lookup: (_hostname, options, callback) => {
+				if (options.all) callback(null, addresses.map((address) => ({
+					address,
+					family: 4
+				})));
+				else callback(null, firstAddress, 4);
+			}
+		}, (response) => {
+			response.resume();
+			resolve(response.statusCode ?? null);
+		});
+		request$1.on("error", () => resolve(null));
+		request$1.end();
+	});
+}
+//#endregion
+//#region src/engine/tunnel.ts
+function tunnelArgv(provider, port, ngrokUrl, logFile) {
+	if (provider === "cloudflared") return {
+		bin: "cloudflared",
+		args: [
+			"tunnel",
+			"--url",
+			`http://127.0.0.1:${port}`,
+			...logFile ? ["--logfile", logFile] : []
+		]
+	};
+	return {
+		bin: "ngrok",
+		args: [
+			"http",
+			String(port),
+			`--log=${logFile || "stdout"}`,
+			"--log-format=json",
+			...ngrokUrl ? ["--url", ngrokUrl] : []
+		]
+	};
+}
+const CLOUDFLARED_URL_RE = /https:\/\/[a-z0-9-]+\.trycloudflare\.com/i;
+function parseCloudflaredLine(line) {
+	const match = line.match(CLOUDFLARED_URL_RE);
+	return match ? match[0] : null;
+}
+function parseNgrokLine(line) {
+	let data;
+	try {
+		data = JSON.parse(line);
+	} catch {
+		return null;
+	}
+	if (typeof data !== "object" || data === null) return null;
+	const url = data.url;
+	return typeof url === "string" && /^https?:\/\//i.test(url) ? url : null;
+}
+function parserFor(provider) {
+	return provider === "cloudflared" ? parseCloudflaredLine : parseNgrokLine;
+}
+const URL_TIMEOUT_MS = 15e3;
+const REACHABLE_TIMEOUT_MS = 24e4;
+const REACHABLE_POLL_MS = 2e3;
+const defaultSleep = (ms) => new Promise((r) => setTimeout(r, ms));
+async function withManagedTunnelLock(root, fn, options = {}) {
+	return withWorkspaceProcessLock(managedTunnelLockRoot(root), "metro-tunnel", fn, {
+		...options,
+		rejectOwnerPurposes: ["workspace removal"]
+	});
+}
+async function withManagedTunnelRemovalLock(root, fn, options = {}) {
+	return withWorkspaceProcessLock(managedTunnelLockRoot(root), "metro-tunnel", fn, {
+		...options,
+		ownerPurpose: "workspace removal"
+	});
+}
+async function withManagedRemoteWorktreeLock(worktreeRoot, fn, options = {}) {
+	return withWorkspaceProcessLock(managedRemoteWorktreeLockRoot(worktreeRoot), "managed-remote", fn, {
+		...options,
+		external: true,
+		rejectOwnerPurposes: ["worktree removal"]
+	});
+}
+async function withManagedRemoteWorktreeRemovalLock(worktreeRoot, fn, options = {}) {
+	return withWorkspaceProcessLock(managedRemoteWorktreeLockRoot(worktreeRoot), "managed-remote", fn, {
+		...options,
+		external: true,
+		ownerPurpose: "worktree removal"
+	});
+}
+function managedLockHolders(root) {
+	const locks = [{
+		label: "managed tunnel",
+		path: workspaceProcessLockPath(managedTunnelLockRoot(root), "metro-tunnel", false)
+	}, {
+		label: "managed remote",
+		path: workspaceProcessLockPath(managedRemoteWorktreeLockRoot(root), "managed-remote", true)
+	}];
+	const reasons = [];
+	for (const { label, path } of locks) {
+		const claims = (0, ownership_claim_exports.readClaimSet)(path);
+		const holder = claims.live[0];
+		if (holder) {
+			const purpose = typeof holder.details.purpose === "string" ? ` for ${holder.details.purpose}` : "";
+			reasons.push(`the ${label} lock is held${purpose}`);
+		} else if (claims.unresolved[0]) reasons.push(`the ${label} lock cannot be resolved: ${claims.unresolved[0].reason}`);
+	}
+	return reasons;
+}
+function managedTunnelLockRoot(root) {
+	const key = createHash("sha256").update(resolve(root)).digest("hex");
+	return join(getConfigDir(), "process-locks", key);
+}
+function managedRemoteWorktreeLockRoot(worktreeRoot) {
+	const key = createHash("sha256").update(resolve(worktreeRoot)).digest("hex");
+	return join(getConfigDir(), "process-locks", "worktrees", key);
+}
+async function defaultProbeReachable(url, signal) {
+	const status = await probePublicHttp(url, signal);
+	return status !== null && status > 0;
+}
+function waitForUrl(child, parseLine, timeoutMs) {
+	return new Promise((resolve) => {
+		let settled = false;
+		let timer;
+		let onOut;
+		let onErr;
+		let onError;
+		let onExit;
+		const finish = (url, exited = false) => {
+			if (settled) return;
+			settled = true;
+			clearTimeout(timer);
+			child.stdout?.removeListener("data", onOut);
+			child.stderr?.removeListener("data", onErr);
+			child.removeListener("error", onError);
+			child.removeListener("exit", onExit);
+			resolve({
+				url,
+				exited
+			});
+		};
+		const onLine = (line) => {
+			if (settled) return;
+			const url = parseLine(line);
+			if (url) finish(url);
+		};
+		const outReader = createLineReader(onLine);
+		const errReader = createLineReader(onLine);
+		onOut = (chunk) => outReader.push(chunk);
+		onErr = (chunk) => errReader.push(chunk);
+		onError = () => finish(null);
+		onExit = () => finish(null, true);
+		child.stdout?.setEncoding?.("utf-8");
+		child.stderr?.setEncoding?.("utf-8");
+		child.stdout?.on("data", onOut);
+		child.stderr?.on("data", onErr);
+		child.on("error", onError);
+		child.on("exit", onExit);
+		timer = setTimeout(() => finish(null), timeoutMs);
+	});
+}
+function waitForFileUrl(child, logFile, parseLine, timeoutMs) {
+	return new Promise((resolve) => {
+		let settled = false;
+		const finish = (url, exited = false) => {
+			if (settled) return;
+			settled = true;
+			clearInterval(interval);
+			clearTimeout(timer);
+			child.removeListener("error", onError);
+			child.removeListener("exit", onExit);
+			resolve({
+				url,
+				exited
+			});
+		};
+		const probe = () => {
+			try {
+				for (const line of readFileSync(logFile, "utf-8").split(/\r?\n/)) {
+					const url = parseLine(line);
+					if (url) return finish(url);
+				}
+			} catch {}
+		};
+		const onError = () => finish(null);
+		const onExit = () => finish(null, true);
+		child.on("error", onError);
+		child.on("exit", onExit);
+		const interval = setInterval(probe, 25);
+		const timer = setTimeout(() => finish(null), timeoutMs);
+		probe();
+	});
+}
+function createTunnelLogFile(provider) {
+	const dir = join(getConfigDir(), "tunnel-logs");
+	mkdirSync(dir, { recursive: true });
+	const path = join(dir, `${provider}-${randomUUID()}.log`);
+	closeSync(openSync(path, "wx", 384));
+	return path;
+}
+function removeTunnelLogFile(path) {
+	if (!path) return;
+	try {
+		unlinkSync(path);
+	} catch {}
+}
+function removeRecordedTunnelLogFile(path) {
+	if (!path) return;
+	const dir = resolve(join(getConfigDir(), "tunnel-logs"));
+	const resolved = resolve(path);
+	if (!resolved.startsWith(`${dir}${sep}`) || resolve(join(dir, basename(resolved))) !== resolved) return;
+	removeTunnelLogFile(resolved);
+}
+async function waitUntilReachable({ url, now, sleep, probe, timeoutMs }) {
+	const deadline = now() + timeoutMs;
+	for (;;) {
+		if (await probe(url, new AbortController().signal).catch(() => false)) return true;
+		if (now() >= deadline) return false;
+		await sleep(REACHABLE_POLL_MS);
+	}
+}
+const CLEANUP_TIMEOUT_MS = 1e3;
+const CLEANUP_POLL_MS = 25;
+async function startTunnel({ provider, port, spawnFn = null, urlTimeoutMs = URL_TIMEOUT_MS, reachableTimeoutMs = REACHABLE_TIMEOUT_MS, probeReachable = defaultProbeReachable, now = Date.now, sleep = defaultSleep, ngrokUrl = null, requireReachable = true, cleanupTimeoutMs = CLEANUP_TIMEOUT_MS, isChildAlive = pidExists, readProcessToken = process_identity_exports.captureProcessToken, logFile = null }) {
+	const spawn = spawnFn || ((cmd, args, opts) => getExecutor().spawn(cmd, args, opts));
+	const outputFile = logFile || (spawnFn ? null : createTunnelLogFile(provider));
+	const { bin, args } = tunnelArgv(provider, port, ngrokUrl, outputFile);
+	let child;
+	try {
+		child = spawn(bin, args, {
+			stdio: outputFile ? [
+				"ignore",
+				"ignore",
+				"ignore"
+			] : [
+				"ignore",
+				"pipe",
+				"pipe"
+			],
+			detached: true
+		});
+	} catch (err) {
+		removeTunnelLogFile(outputFile);
+		return {
+			failed: true,
+			reason: `Could not start ${provider}: ${describe(err)}`
+		};
+	}
+	let childExited = false;
+	child.once("exit", () => {
+		childExited = true;
+	});
+	const cleanup = async (alreadyExited = childExited) => {
+		const stopped = await terminateChild(child, {
+			alreadyExited,
+			timeoutMs: cleanupTimeoutMs,
+			now,
+			sleep,
+			isAlive: isChildAlive
+		});
+		if (stopped) removeTunnelLogFile(outputFile);
+		return stopped ? { status: "stopped" } : {
+			status: "failed",
+			reason: `Sent SIGKILL but could not confirm that pid ${child.pid ?? "unknown"} exited.`
+		};
+	};
+	const failAfterCleanup = async (reason, alreadyExited = childExited) => {
+		const stopped = await cleanup(alreadyExited);
+		return stopped.status === "stopped" ? {
+			failed: true,
+			reason
+		} : {
+			failed: true,
+			reason: `${reason} ${stopped.reason}`,
+			cleanupFailed: true
+		};
+	};
+	const pid = child.pid;
+	if (!pid) return failAfterCleanup(`${provider} started but reported no pid.`);
+	const captureChildIdentity = () => {
+		try {
+			return readProcessToken(pid);
+		} catch {
+			return null;
+		}
+	};
+	const initialProcessToken = captureChildIdentity();
+	if (!initialProcessToken) return failAfterCleanup(`${provider} started but its process identity token could not be read.`);
+	const { url, exited } = outputFile ? await waitForFileUrl(child, outputFile, parserFor(provider), urlTimeoutMs) : await waitForUrl(child, parserFor(provider), urlTimeoutMs);
+	if (!url) return failAfterCleanup(exited ? `${provider} exited before printing a tunnel URL.` : `${provider} did not print a tunnel URL within ${urlTimeoutMs}ms.`, exited || childExited);
+	if (!outputFile) resumeChildPipes(child);
+	if (requireReachable) {
+		if (!await waitUntilReachable({
+			url,
+			now,
+			sleep,
+			probe: probeReachable,
+			timeoutMs: reachableTimeoutMs
+		})) return failAfterCleanup(`${url} did not become reachable within ${reachableTimeoutMs}ms; ${provider} may still be registering, or the network path is blocked.`);
+	}
+	const finalProcessToken = captureChildIdentity();
+	if (!finalProcessToken || finalProcessToken !== initialProcessToken) return failAfterCleanup(`${provider} process identity changed before its tunnel could be recorded.`);
+	if (!outputFile) unrefChildPipes(child);
+	child.unref?.();
+	if (childExited) return failAfterCleanup(`${provider} exited before its tunnel could be recorded.`, true);
+	return {
+		url,
+		pid,
+		processToken: initialProcessToken,
+		logFile: outputFile,
+		cleanup: () => cleanup()
+	};
+}
+async function startTunnelSequence({ providers, port, ngrokUrl = null, requireReachable = true, start = startTunnel }) {
+	const failures = [];
+	for (const provider of providers) {
+		const result = await start({
+			provider,
+			port,
+			ngrokUrl: provider === "ngrok" ? ngrokUrl : null,
+			requireReachable
+		});
+		if (!("failed" in result)) return {
+			provider,
+			...result
+		};
+		failures.push(`${provider}: ${result.reason}`);
+		if (result.cleanupFailed) return {
+			failed: true,
+			reason: failures.join(" ")
+		};
+	}
+	return {
+		failed: true,
+		reason: failures.join(" ") || "No managed tunnel provider was selected."
+	};
+}
+function closeChildPipes(child) {
+	child.stdout?.destroy?.();
+	child.stderr?.destroy?.();
+}
+function unrefChildPipes(child) {
+	resumeChildPipes(child);
+	for (const stream of [child.stdout, child.stderr]) stream?.unref?.();
+}
+function resumeChildPipes(child) {
+	child.stdout?.resume?.();
+	child.stderr?.resume?.();
+}
+async function signalAndWaitForExit(child, signal, { timeoutMs, now, sleep, isAlive, platform }) {
+	let exited = false;
+	const onExit = () => {
+		exited = true;
+	};
+	child.once("exit", onExit);
+	try {
+		if (platform === "win32" && child.pid) signalProcessTree(child.pid, signal, { platform });
+		child.kill(signal);
+	} catch (err) {
+		child.removeListener("exit", onExit);
+		return isEsrch(err);
+	}
+	const hasExited = () => exited;
+	const deadline = now() + timeoutMs;
+	while (!hasExited() && now() < deadline) await sleep(CLEANUP_POLL_MS);
+	if (!hasExited() && child.pid && !isAlive(child.pid)) exited = true;
+	child.removeListener("exit", onExit);
+	return hasExited();
+}
+async function terminateChild(child, { alreadyExited, timeoutMs, now, sleep, isAlive, platform = process.platform }) {
+	if (alreadyExited) {
+		closeChildPipes(child);
+		return true;
+	}
+	if (await signalAndWaitForExit(child, "SIGTERM", {
+		timeoutMs,
+		now,
+		sleep,
+		isAlive,
+		platform
+	})) {
+		closeChildPipes(child);
+		return true;
+	}
+	const killed = await signalAndWaitForExit(child, "SIGKILL", {
+		timeoutMs,
+		now,
+		sleep,
+		isAlive,
+		platform
+	});
+	closeChildPipes(child);
+	return killed;
+}
+function describe(err) {
+	return err?.message || String(err);
+}
+const STOP_TIMEOUT_MS = 5e3;
+const STOP_POLL_MS = 100;
+function isEsrch(err) {
+	return err?.code === "ESRCH";
+}
+async function stopTunnel(record, { isAlive = pidExists, inspectIdentity = process_identity_exports.inspectProcessIdentity, platform = process.platform, kill = (pid) => signalProcessTree(pid, "SIGTERM", { platform }), now = Date.now, sleep = defaultSleep, timeoutMs = STOP_TIMEOUT_MS } = {}) {
+	const missing = () => {
+		removeRecordedTunnelLogFile(record?.logFile);
+		return { status: "missing" };
+	};
+	const pid = record?.pid;
+	if (!pid || !isAlive(pid)) return missing();
+	if (!record.processToken) return {
+		status: "failed",
+		reason: `tunnel pid ${pid} has no process identity token, so Stim cannot verify ownership. Keep the record. Inspect the process, stop it with the provider tooling, remove the stale metroTunnel state, and retry.`
+	};
+	const identity = inspectIdentity(record);
+	if (identity === "gone" || identity === "different") return missing();
+	if (identity !== "same") return {
+		status: "failed",
+		reason: `could not verify the process identity for tunnel pid ${pid}; refusing to signal it.`
+	};
+	try {
+		kill(pid);
+	} catch (err) {
+		return isEsrch(err) ? missing() : {
+			status: "failed",
+			reason: describe(err)
+		};
+	}
+	const deadline = now() + timeoutMs;
+	const exited = () => {
+		if (!isAlive(pid)) return true;
+		const current = inspectIdentity(record);
+		return current === "gone" || current === "different";
+	};
+	while (now() < deadline && !exited()) await sleep(STOP_POLL_MS);
+	if (!exited()) return {
+		status: "failed",
+		reason: `pid ${pid} did not exit within ${timeoutMs}ms.`
+	};
+	removeRecordedTunnelLogFile(record.logFile);
+	return { status: "stopped" };
+}
+//#endregion
+//#region src/supervisor/ownership.ts
+function resolveSupervisorTarget({ state, record, reservedPort, isAlive = pidExists, inspectIdentity = process_identity_exports.inspectProcessIdentity } = {}) {
+	const statePid = numberOrNull(state?.pid);
+	const recordPid = numberOrNull(record?.pid);
+	const pid = statePid ?? recordPid;
+	if (!pid) return { status: "none" };
+	if (statePid && recordPid && statePid !== recordPid) return {
+		status: "unverified",
+		pid,
+		reason: `workspace state.json records supervisor pid ${statePid} but the registry records pid ${recordPid}`
+	};
+	if (!isAlive(pid)) return {
+		status: "stale",
+		pid
+	};
+	const port = numberOrNull(state?.port) ?? numberOrNull(record?.port);
+	if (reservedPort !== null && reservedPort !== void 0 && port !== null && port !== reservedPort) return {
+		status: "unverified",
+		pid,
+		reason: `supervisor pid ${pid} records port ${port}, but this project reserved port ${reservedPort}`
+	};
+	if (reservedPort !== null && reservedPort !== void 0 && port === null) return {
+		status: "unverified",
+		pid,
+		reason: `supervisor pid ${pid} has no recorded port, so it cannot be matched against reserved port ${reservedPort}`
+	};
+	const identityRecord = statePid ? state : record;
+	if (statePid && recordPid && state?.processToken !== record?.processToken) return {
+		status: "unverified",
+		pid,
+		reason: "workspace state and registry process identities disagree"
+	};
+	const identity = inspectIdentity(identityRecord);
+	if (identity === "gone" || identity === "different") return {
+		status: "stale",
+		pid
+	};
+	if (identity !== "same") return {
+		status: "unverified",
+		pid,
+		reason: "the recorded process identity could not be verified"
+	};
+	return {
+		status: "ours",
+		processToken: identityRecord.processToken,
+		pid,
+		port,
+		mode: state?.mode ?? record?.mode ?? null,
+		startedAt: state?.startedAt ?? record?.startedAt ?? null
+	};
+}
+function numberOrNull(v) {
+	return typeof v === "number" && Number.isSafeInteger(v) && v > 0 ? v : null;
+}
+//#endregion
+export { dropParked as _, terminateChild as a, readParked as b, withManagedTunnelLock as c, teardownOwnedAvd as d, teardownOwnedIosSim as f, adoptParked as g, POOL_SETTING_REMEDY as h, stopTunnel as i, withManagedTunnelRemovalLock as l, teardownParkedIosSim as m, managedLockHolders as n, withManagedRemoteWorktreeLock as o, teardownParkedAvd as p, startTunnelSequence as r, withManagedRemoteWorktreeRemovalLock as s, resolveSupervisorTarget as t, probePublicHttp as u, isLegacyDeletionClaim as v, selectParked as x, parkedMaxSetting as y };