stim 1.20.2 → 1.22.0

package/dist/macos-Ch5VJmcS.mjs

@@ -1,584 +0,0 @@
-import { E as upsertProject, k as process_identity_exports, u as getConcurrencyLimits } from "./config-BYDxlMY3.mjs";
-import { t as getExecutor } from "./exec-DqKo9GKJ.mjs";
-import { t as spawnEntry } from "./spawn-entry-Dcb7sDUz.mjs";
-import { K as resolveProjectSettings, Q as settingShapeErrors, a as SETTING_SHAPE_REMEDY } from "./settings-B717odTD.mjs";
-import { c as writeWorkspaceState, i as recordWorkspaceUse, p as ensureWorkspaceStorage, w as workspaceLogsDir$1, x as workspaceDir, y as workspaceAgentDeviceDir } from "./workspace-state-DJt_MMvf.mjs";
-import { l as phaseLine } from "./command-output-BTy8hZ0F.mjs";
-import { d as projectRegistry, o as ownedDeviceLabel, r as findProjectRoot } from "./project-_phNIJfs.mjs";
-import { a as spawnDeclared } from "./spawn-claims-DVS5RkMS.mjs";
-import { F as acquireBuildSlot, L as releaseBuildSlot } from "./workspaces-C36s2jb9.mjs";
-import { Dt as recordFinishedBuild, Et as recordBuildPhase, Ot as startBuildProgress, kt as tapBuildLog, yt as NO_BUILD_PROGRESS } from "./budget-f7516Zk0.mjs";
-import { a as withWorkspaceProcessLock } from "./named-ports-4WopRPg-.mjs";
-import { S as withNativeBuildRun } from "./tailnet-Dh-qiYzG.mjs";
-import { r as createNdjsonWriter } from "./ndjson-GOnbyvso.mjs";
-import { _ as requireLocalBuild, c as offloadPlacement, f as setRemoteLogSink, g as parseBuildMachineOption, h as namedBuildMachine, i as closeOffload, l as placementLoad, n as buildPlacementCandidates, o as offloadBuild, p as OffloadRefusal, r as chooseBuildMachine, u as remotePhaseText, y as resolveBuildPlacement } from "./client-qQAaXSUs.mjs";
-import { D as sanitizeDeviceLabel } from "./ios-RkW4pnQf.mjs";
-import { i as macosProcess, n as macosDir, o as requiredMacosRecord, r as macosLogFile } from "./state-CG_OFoaA.mjs";
-import { t as buildPlacementRecord } from "./placement-log-MOfPVgaM.mjs";
-import { c as connectHost } from "./hosted-client-ZEKpS9vw.mjs";
-import { t as placeHostedMacos } from "./hosted-macos-BACVAVqE.mjs";
-import { i as validateInfoPlist, t as resolveBundleExtras } from "./stage-KNTQopqv.mjs";
-import { r as stopMacosAppHeld, t as stopBundleInstances } from "./stop-DPEhunlw.mjs";
-import { closeSync, existsSync, mkdirSync, mkdtempSync, openSync, realpathSync, renameSync, rmSync } from "node:fs";
-import { join } from "node:path";
-import { machineCapacity, readMacosRecord, validHostedAppArguments } from "@stim-cli/core/state";
-import { LOG_ROTATE_BYTES } from "@stim-cli/core";
-import { createHash, randomUUID } from "node:crypto";
-//#region src/macos/build.ts
-async function buildMacosBundle({ root, recipe, bundle, bundleId, displayName, scratch, writer, note, record, buildMachine, progress = NO_BUILD_PROGRESS }) {
-	if (record) record.buildMachine = buildMachine;
-	setRemoteLogSink((entry) => writer.write({
-		...entry,
-		platform: "macos"
-	}));
-	const write = (msg) => {
-		writer.write({
-			src: "build",
-			platform: "macos",
-			level: "info",
-			msg
-		});
-		note(msg);
-	};
-	let offloadFallback = null;
-	let asked = [];
-	let failedMachine;
-	const fallBack = (reason) => {
-		writer.write(buildPlacementRecord({
-			platform: "macos",
-			buildMachine,
-			candidates: asked,
-			event: "placement_fallback",
-			fallback: {
-				code: failedMachine ? "offload-failed" : "no-remote-mac-took-it",
-				reason,
-				machine: failedMachine
-			}
-		}));
-		if (namedBuildMachine(buildMachine)) throw new OffloadRefusal(buildMachine, reason);
-		requireLocalBuild(buildMachine);
-		offloadFallback = reason;
-		if (record) record.offloadFallback = reason;
-		writer.write({
-			src: "build",
-			platform: "macos",
-			level: "warn",
-			event: "offload_failed",
-			msg: reason
-		});
-		write(`${reason} -> building here`);
-		write(`placement: here (${reason})`);
-	};
-	mkdirSync(macosDir(root), { recursive: true });
-	const staging = mkdtempSync(join(macosDir(root), "staging-"));
-	const promote = (path) => {
-		const backup = join(staging, "previous.app");
-		const previous = existsSync(bundle);
-		if (previous) renameSync(bundle, backup);
-		try {
-			renameSync(path, bundle);
-		} catch (error) {
-			if (previous) renameSync(backup, bundle);
-			throw error;
-		}
-	};
-	let choice = null;
-	try {
-		try {
-			const { mode, machines, localEnabled } = buildPlacementCandidates(buildMachine);
-			const here = machineCapacity();
-			const placement = offloadPlacement({
-				mode,
-				localEnabled,
-				machines: machines.length,
-				here,
-				unsupported: null,
-				selected: buildMachine
-			});
-			if (placement.offload) {
-				const chosen = await chooseBuildMachine({
-					projectRoot: root,
-					target: recipe.offload.target(),
-					mode,
-					here,
-					machines,
-					selected: buildMachine,
-					note: (line) => write(`offload: ${line}`),
-					onCandidates: (each) => asked = each
-				});
-				if (typeof chosen === "string") throw new Error(chosen);
-				choice = chosen;
-				failedMachine = chosen.machine;
-				writer.write(buildPlacementRecord({
-					platform: "macos",
-					buildMachine,
-					candidates: asked,
-					chose: {
-						machine: chosen.machine,
-						reason: `${placement.reason}${placementLoad(chosen)}`
-					}
-				}));
-				write(`placement: ${choice.machine} (${placement.reason}${placementLoad(choice)})`);
-				const outcome = await offloadBuild({
-					choice,
-					request: recipe.offload.request(bundleId),
-					stagingDir: join(staging, "offload"),
-					onPhase: (phase, line) => note(remotePhaseText(phase, line, choice.machine)),
-					onEnter: (phase) => {
-						if (record && [
-							"compile",
-							"build",
-							"prebuild",
-							"pods"
-						].includes(phase)) record.builtOn = choice.machine;
-						progress.place({
-							host: choice.machine,
-							phase
-						});
-						progress.step(phase === "fetch" ? "install" : "compile");
-					},
-					onRecord: (entry) => writer.write({
-						...entry,
-						offloadedTo: choice.machine
-					}),
-					note: write
-				});
-				progress.place(null);
-				if (!outcome.ok) throw new Error(`${outcome.machine}: ${outcome.reason}`);
-				progress.step("install");
-				recipe.validateFetched(outcome.artifactPath, bundleId, displayName);
-				promote(outcome.artifactPath);
-				if (record) {
-					record.offloadedTo = outcome.machine;
-					record.builtOn = outcome.machine;
-				}
-				return {
-					bundleId,
-					offloadedTo: outcome.machine,
-					offloadFallback: null,
-					handoff: outcome.handoff ?? null
-				};
-			}
-			writer.write(buildPlacementRecord({
-				platform: "macos",
-				buildMachine,
-				stays: {
-					code: placement.code,
-					reason: placement.reason
-				}
-			}));
-			write(`placement: here (${placement.reason})`);
-		} catch (error) {
-			fallBack(error instanceof Error ? error.message : String(error));
-		} finally {
-			if (choice) closeOffload(choice);
-		}
-		let slot;
-		try {
-			slot = await acquireBuildSlot({
-				automatic: buildMachine === "auto",
-				max: getConcurrencyLimits().maxBuilds,
-				root,
-				logFile: writer.file,
-				out: note,
-				waitingFor: (info) => progress.waitingFor(info, "build-slot")
-			});
-			requireLocalBuild(buildMachine);
-			if (record) record.builtOn = "here";
-			progress.step("compile");
-			const bin = await recipe.compile({
-				scratch,
-				writer,
-				note
-			});
-			progress.step("install");
-			const staged = join(staging, `${recipe.product}.app`);
-			recipe.stage(bin, staged, bundleId, displayName);
-			promote(staged);
-			return {
-				bundleId,
-				offloadedTo: null,
-				offloadFallback,
-				handoff: null
-			};
-		} finally {
-			releaseBuildSlot(slot);
-		}
-	} finally {
-		try {
-			rmSync(staging, {
-				recursive: true,
-				force: true
-			});
-		} catch {}
-	}
-}
-//#endregion
-//#region src/macos/app-name.ts
-const DOT = String.fromCodePoint(183);
-const ELLIPSIS = String.fromCodePoint(8230);
-const LABEL_MAX = 24;
-const PRODUCT_MAX = 40;
-function clip(text, max) {
-	const chars = [...text];
-	return chars.length <= max ? text : `${chars.slice(0, max - 1).join("")}${ELLIPSIS}`;
-}
-/** The visible app name for a run: `<product> <dot> <label>`, or just the product when the label is empty. */
-function macosAppName(product, label) {
-	const name = clip(product.replace(/[\p{Cc}/:\\]+/gu, " ").trim(), PRODUCT_MAX) || "App";
-	const suffix = clip(sanitizeDeviceLabel(label), LABEL_MAX);
-	return suffix ? `${name} ${DOT} ${suffix}` : name;
-}
-function workspaceAppName(root, product) {
-	return macosAppName(product, ownedDeviceLabel(root));
-}
-//#endregion
-//#region src/macos/plan.ts
-function planMacos(root, buildMachineFlag) {
-	if (process.platform !== "darwin") throw new Error("stim macos requires a Mac with Swift installed.");
-	root = realpathSync(root);
-	if (!existsSync(join(root, "Package.swift"))) throw new Error("Run stim macos from the directory containing Package.swift.");
-	const { context, settings } = resolveProjectSettings(root);
-	const [shape] = settingShapeErrors(settings);
-	if (shape) throw new Error(`${shape} ${SETTING_SHAPE_REMEDY}`);
-	const selected = resolveBuildPlacement(buildMachineFlag);
-	if (selected.failure) throw Object.assign(new Error(selected.failure.message), selected.failure);
-	const macos = settings.macos;
-	if (!macos?.product || !macos.infoPlist) throw Object.assign(/* @__PURE__ */ new Error("Set macos.product and macos.infoPlist explicitly in .stim.json. See stim guide macos."), { code: "STIM_BAD_ARG" });
-	validateInfoPlist(root, macos.product, macos.infoPlist);
-	resolveBundleExtras(root, context.repoRoot ?? root, macos.resources, macos.assetCatalog);
-	return {
-		platform: "macos",
-		product: macos.product,
-		buildMachine: selected.selected,
-		fingerprint: null,
-		cacheKey: null,
-		cacheHit: false,
-		provider: null,
-		cacheSkipped: false,
-		prebuild: null,
-		outcome: null,
-		expectedMs: null,
-		basis: 0
-	};
-}
-//#endregion
-//#region src/commands/macos.ts
-/**
-* Builds the Debug app and launches it here, or with `remote` on that approved remote Mac. A named host never falls
-* back to a local launch.
-*/
-async function runMacos(root, note = console.error, remote, buildMachineFlag) {
-	const backend = remote?.trim().toLowerCase();
-	if (backend === "eas" || backend === "proxy") throw Object.assign(/* @__PURE__ */ new Error("stim macos --remote takes a remote Mac name from remote.machines; macOS has no eas or proxy backend."), { code: "STIM_BAD_ARG" });
-	if (backend === "auto") throw Object.assign(/* @__PURE__ */ new Error("stim macos --remote auto is not available yet: automatic placement has not shipped. Name a hosting Mac from remote.machines."), { code: "STIM_BAD_ARG" });
-	if (process.platform !== "darwin") throw new Error("stim macos requires a Mac with Swift installed.");
-	root = realpathSync(root);
-	const operation = projectRegistry.selectMacos(root);
-	if ("problem" in operation) throw Object.assign(new Error(operation.problem.message), {
-		code: "STIM_NO_PROJECT",
-		remedy: operation.problem.remedy
-	});
-	const { settings } = resolveProjectSettings(root);
-	const [shape] = settingShapeErrors(settings);
-	if (shape) throw new Error(`${shape} ${SETTING_SHAPE_REMEDY}`);
-	const selected = resolveBuildPlacement(buildMachineFlag);
-	if (selected.failure) throw Object.assign(new Error(selected.failure.message), selected.failure);
-	const buildMachine = selected.selected;
-	const macos = (await operation.load()).prepare(settings);
-	ensureWorkspaceStorage(root);
-	return withNativeBuildRun(root, {
-		command: "macos",
-		platform: "macos"
-	}, async (claim) => {
-		const progress = startBuildProgress({
-			root,
-			platform: "macos",
-			slot: "default",
-			claim,
-			note
-		});
-		return withWorkspaceProcessLock(workspaceDir(root), "macos-launch", async () => {
-			const previous = requiredMacosRecord(root);
-			if (previous?.host && previous.host.machine !== remote) throw new Error(`This workspace's macOS app runs on ${previous.host.machine}. Run stim stop first, then stim macos${remote ? ` --remote ${remote}` : ""}.`);
-			if (remote && !validHostedAppArguments(macos.arguments)) throw new Error("macos.arguments is too large for a hosted app: at most 32 arguments of 1024 characters (8192 in total), without NUL or line breaks.");
-			if (remote) (await connectHost(remote)).connection.close();
-			if (!previous?.host) await stopMacosAppHeld(root);
-			upsertProject(root, {});
-			recordWorkspaceUse(root);
-			const bundle = join(macosDir(root), `${macos.product}.app`);
-			const record = {
-				product: macos.product,
-				bundle,
-				bundleId: "",
-				executable: join(bundle, "Contents", "MacOS", macos.product),
-				launchId: randomUUID(),
-				arguments: macos.arguments,
-				supervisor: macosProcess(process.pid),
-				build: {
-					state: "running",
-					startedAt: (/* @__PURE__ */ new Date()).toISOString(),
-					buildMachine
-				},
-				...previous?.host ? {
-					host: previous.host,
-					hostLaunched: previous.hostLaunched ?? false
-				} : {}
-			};
-			const handoff = await buildBundle(root, macos, record, remote !== void 0, note, progress);
-			progress.step("launch");
-			const launched = () => {
-				try {
-					recordBuildPhase(root, "macos", record.build.startedAt, "launch", progress.durations().launch ?? 0);
-				} catch (error) {
-					note(`The launch time could not be recorded in the build history: ${error?.message || error}`);
-				}
-			};
-			if (!remote) {
-				const here = await launchHere(root, record, note);
-				launched();
-				return here;
-			}
-			const connection = await connectHost(remote);
-			const write = (patch) => writeWorkspaceState(root, { macos: {
-				...record,
-				...patch
-			} });
-			let placement = record.host;
-			try {
-				const run = await placeHostedMacos(connection, {
-					root,
-					bundle: record.bundle,
-					bundleId: record.bundleId,
-					handoff,
-					arguments: macos.arguments,
-					recorded: previous?.host,
-					reserved: (reserved) => {
-						placement = reserved;
-						write({
-							host: reserved,
-							hostLaunched: false
-						});
-					},
-					note
-				});
-				const placed = {
-					...record,
-					supervisor: void 0,
-					arguments: run.arguments,
-					host: run.placement,
-					hostLaunched: run.launched
-				};
-				writeWorkspaceState(root, { macos: placed });
-				launched();
-				return placed;
-			} catch (error) {
-				write({
-					supervisor: void 0,
-					...placement ? {
-						host: placement,
-						hostLaunched: false
-					} : {}
-				});
-				throw error;
-			} finally {
-				connection.connection.close();
-			}
-		}, {
-			external: true,
-			declareSpawns: true,
-			ownerPurpose: "build and launch macOS app"
-		}).finally(() => progress.clear());
-	}, { write: note });
-}
-async function buildBundle(root, recipe, record, hosted, note, progress = NO_BUILD_PROGRESS) {
-	const started = Date.parse(record.build.startedAt);
-	const scratch = join(macosDir(root), "build");
-	writeWorkspaceState(root, { macos: record });
-	const writer = tapBuildLog(createNdjsonWriter(macosLogFile(root), { maxBytes: LOG_ROTATE_BYTES }), progress);
-	try {
-		const base = recipe.bundleId;
-		const bundleId = hosted ? base : `${base}.stim.${createHash("sha256").update(root).digest("hex").slice(0, 12)}`;
-		const displayName = workspaceAppName(root, record.product);
-		const built = await buildMacosBundle({
-			root,
-			recipe,
-			bundle: record.bundle,
-			bundleId,
-			displayName,
-			scratch,
-			writer,
-			note,
-			progress,
-			record: record.build,
-			buildMachine: record.build.buildMachine
-		});
-		record.bundleId = built.bundleId;
-		record.displayName = displayName;
-		record.bundle = realpathSync(record.bundle);
-		record.executable = realpathSync(join(record.bundle, "Contents", "MacOS", record.product));
-		record.build = {
-			...record.build,
-			state: "ok",
-			finishedAt: (/* @__PURE__ */ new Date()).toISOString(),
-			durationMs: Date.now() - started
-		};
-		writeWorkspaceState(root, { macos: record });
-		recordMacosBuild(root, record.build, progress.steps());
-		return built.handoff;
-	} catch (error) {
-		const message = error instanceof Error ? error.message : String(error);
-		writer.write({
-			src: "build",
-			platform: "macos",
-			level: "error",
-			msg: message
-		});
-		const build = {
-			...record.build,
-			state: "failed",
-			finishedAt: (/* @__PURE__ */ new Date()).toISOString(),
-			durationMs: Date.now() - started,
-			error: message,
-			..."code" in Object(error) && typeof error.code === "string" ? { errorCode: error.code } : {}
-		};
-		writeWorkspaceState(root, { macos: {
-			...record,
-			supervisor: void 0,
-			build
-		} });
-		recordMacosBuild(root, build, progress.steps());
-		throw error;
-	} finally {
-		writer.close();
-	}
-}
-function recordMacosBuild(root, build, compileSteps) {
-	recordFinishedBuild(root, {
-		platform: "macos",
-		status: build.state === "ok" ? "ok" : "failed",
-		configuration: "Debug",
-		fingerprint: null,
-		cacheKey: null,
-		cacheHit: false,
-		cacheSkipped: false,
-		durationMs: build.durationMs,
-		startedAt: build.startedAt,
-		errorCode: build.errorCode,
-		buildMachine: build.buildMachine,
-		builtOn: build.builtOn,
-		offloadedTo: build.offloadedTo,
-		offloadFallback: build.offloadFallback,
-		...compileSteps === null ? {} : { compileSteps }
-	});
-}
-const LAUNCH_SERVICES_CALL_MS = 2e3;
-async function waitForLaunchServices(record, deadline) {
-	if (record.host || !record.app) return "skipped";
-	const args = [
-		"find",
-		`bundleid=${record.bundleId}`,
-		`pid=${record.app.pid}`
-	];
-	while (Date.now() < deadline) {
-		if ((await getExecutor().runFileAsync("lsappinfo", args, { timeoutMs: LAUNCH_SERVICES_CALL_MS }).catch(() => "")).includes("ASN:")) return "listed";
-		await new Promise((done) => setTimeout(done, 100));
-	}
-	return "timeout";
-}
-async function launchHere(root, record, note) {
-	await stopBundleInstances(root);
-	const fd = openSync(join(workspaceLogsDir$1(root), "macos-supervisor.log"), "a");
-	let child;
-	try {
-		child = spawnDeclared(() => getExecutor().spawn(process.execPath, [
-			spawnEntry("macos-run"),
-			root,
-			record.launchId
-		], {
-			cwd: root,
-			detached: true,
-			stdio: [
-				"ignore",
-				fd,
-				fd
-			],
-			env: {
-				...process.env,
-				STIM_BACKGROUND_LAUNCH: "1"
-			}
-		}));
-		child.unref();
-	} finally {
-		closeSync(fd);
-	}
-	const deadline = Date.now() + 2e4;
-	while (Date.now() < deadline) {
-		const current = readMacosRecord(root);
-		if (current?.launchId === record.launchId && current.app && current.supervisor && (0, process_identity_exports.inspectProcessIdentity)(current.app) === "same" && (0, process_identity_exports.inspectProcessIdentity)(current.supervisor) === "same") {
-			if (await waitForLaunchServices(current, deadline) === "timeout") note("macOS LaunchServices does not list the app yet. agent-device open may start a second copy; wait and check lsappinfo.");
-			return current;
-		}
-		if (child.exitCode !== null || child.signalCode !== null) break;
-		await new Promise((done) => setTimeout(done, 100));
-	}
-	throw new Error("The macOS app did not register. See macos-supervisor.log in the workspace logs.");
-}
-function launchPayload(root, record) {
-	const agentDevice = { stateDir: workspaceAgentDeviceDir(root) };
-	if (!record.host) return {
-		agentDevice,
-		platform: "macos",
-		...record
-	};
-	const { product, displayName, launchId, build, host } = record;
-	return {
-		agentDevice,
-		platform: "macos",
-		product,
-		displayName,
-		launchId,
-		build,
-		host
-	};
-}
-function macosCommand(program) {
-	program.command("macos").description("Build and launch an owned Swift Package macOS Debug app.").option("--remote-build <value>", "Build on auto, local, or one named machine; a name refuses without fallback", parseBuildMachineOption).option("--json", "print one launch or plan payload; build output goes to stderr").option("--plan", "validate the next SwiftPM Debug build without building or launching").option("--remote <machine>", "run it on this approved remote Mac from remote.machines").action(async (options) => {
-		const root = findProjectRoot(process.cwd());
-		if (options.plan) {
-			try {
-				if (!root) throw new Error("Run stim macos from the Swift Package directory.");
-				if (options.remote !== void 0) throw Object.assign(/* @__PURE__ */ new Error("--remote selects a launch host and does not apply to --plan."), { code: "STIM_BAD_ARG" });
-				const plan = planMacos(root, options.remoteBuild);
-				if (options.json) console.log(JSON.stringify(plan));
-				else {
-					console.log(phaseLine("plan", `macos ${plan.product}: SwiftPM Debug build, then stage and launch`));
-					console.log(phaseLine("build", `selection: ${plan.buildMachine}; worker availability is not checked`));
-					console.log(phaseLine("expect", "unknown: SwiftPM determines incremental work when the build runs"));
-				}
-			} catch (error) {
-				const failure = {
-					code: error.code ?? "STIM_BAD_ARG",
-					message: error instanceof Error ? error.message : String(error),
-					remedy: error.remedy ?? "Check the macOS project settings in stim guide macos."
-				};
-				console.error(failure.message);
-				if (options.json) console.log(JSON.stringify(failure));
-				process.exitCode = 1;
-			}
-			return;
-		}
-		if (!root) throw new Error("Run stim macos from the Swift Package directory.");
-		const record = await runMacos(root, console.error, options.remote, options.remoteBuild).catch((error) => {
-			const remedy = error.remedy;
-			if (typeof remedy === "string") console.error(`remedy: ${remedy}`);
-			throw error;
-		});
-		if (options.json) console.log(JSON.stringify(launchPayload(root, record)));
-		else if (record.host) console.log(`Started ${record.product} on ${record.host.machine} as ${record.host.bundleId}${record.hostLaunched === true ? "" : " (launch not confirmed)"}.`);
-		else console.log(`Started ${record.product} (pid ${record.app?.pid}).`);
-		if (!options.json) console.log(phaseLine("agent-device", `AGENT_DEVICE_STATE_DIR=${workspaceAgentDeviceDir(root)}`));
-	});
-}
-//#endregion
-export { buildMacosBundle as i, runMacos as n, waitForLaunchServices as r, macosCommand as t };

package/dist/metro-gateway-CX9Xlkq2.mjs

@@ -1,103 +0,0 @@
-import { k as process_identity_exports } from "./config-BYDxlMY3.mjs";
-import { a as updateWorkspaceState, r as readWorkspaceState$1 } from "./workspace-state-DJt_MMvf.mjs";
-import { l as realIo } from "./tailnet-Dh-qiYzG.mjs";
-import { HOSTED_METRO_REQUESTS_KEY, findPeer, hostedMetroGateways, hostedMetroRequests, isJsonObject, parseMachine } from "@stim-cli/core/state";
-import { randomBytes, randomUUID } from "node:crypto";
-import { isIP } from "node:net";
-//#region src/device-host/metro-gateway.ts
-function gatewayAddresses(credential, status) {
-	const machine = parseMachine(credential.machine);
-	const peer = machine ? findPeer(status, machine.name) : "missing";
-	if (typeof peer === "string" || peer.nodeId !== credential.nodeId) throw new Error(`${credential.machine} no longer resolves to its pinned tailnet node. Run stim doctor.`);
-	const self = isJsonObject(status) && isJsonObject(status.Self) ? status.Self : null;
-	const address = (Array.isArray(self?.TailscaleIPs) ? self.TailscaleIPs : []).find((ip) => typeof ip === "string" && isIP(ip) === isIP(peer.address) && isIP(ip) !== 0);
-	if (!address) throw new Error("This Mac has no Tailscale address compatible with the hosting Mac.");
-	return {
-		address,
-		peer: peer.address
-	};
-}
-function requireHostedMetro(root) {
-	const supervisor = readWorkspaceState$1(root)?.supervisor;
-	if (supervisor?.hostedMetro === true && (0, process_identity_exports.inspectProcessIdentity)(supervisor) === "same") return;
-	throw Object.assign(/* @__PURE__ */ new Error("Hosted Debug runs require a running Metro supervisor with private gateway support. Run stim stop; stim start, then retry."), {
-		code: "STIM_HOSTING_REFUSED",
-		remedy: "Run stim stop; stim start, then retry."
-	});
-}
-async function requestHostedMetro(root, session, credential) {
-	requireHostedMetro(root);
-	const addresses = gatewayAddresses(credential, realIo.status());
-	const previous = hostedMetroRequests(readWorkspaceState$1(root))[session];
-	const request = previous && previous.address === addresses.address && previous.peer === addresses.peer ? previous : {
-		id: randomUUID(),
-		machine: credential.machine,
-		...addresses,
-		secret: randomBytes(32).toString("hex")
-	};
-	updateWorkspaceState(root, (state) => ({
-		...state,
-		[HOSTED_METRO_REQUESTS_KEY]: {
-			...hostedMetroRequests(state),
-			[session]: request
-		}
-	}));
-	const deadline = Date.now() + 15e3;
-	while (Date.now() < deadline) {
-		const state = readWorkspaceState$1(root);
-		const gateway = hostedMetroGateways(state)[session];
-		if (gateway?.id === request.id && gateway.processToken === state?.supervisor?.processToken) {
-			if (gateway.error) throw new Error(gateway.error);
-			if (gateway.port) return {
-				gatewayPort: gateway.port,
-				secret: request.secret
-			};
-		}
-		await new Promise((done) => setTimeout(done, 100));
-	}
-	throw new Error(`The Metro supervisor did not open a private gateway for ${credential.machine}. Run stim stop; stim start, then retry.`);
-}
-function clearHostedMetro(root, session) {
-	updateWorkspaceState(root, (state) => {
-		const requests = { ...hostedMetroRequests(state) };
-		delete requests[session];
-		return {
-			...state,
-			[HOSTED_METRO_REQUESTS_KEY]: requests
-		};
-	});
-}
-async function closeHostedMetro(root, session) {
-	clearHostedMetro(root, session);
-	const deadline = Date.now() + 5e3;
-	while (true) {
-		const state = readWorkspaceState$1(root);
-		const gateway = hostedMetroGateways(state)[session];
-		const supervisor = state?.supervisor;
-		if (!gateway?.port || !supervisor || gateway.processToken !== supervisor.processToken) return;
-		if ((0, process_identity_exports.inspectProcessIdentity)(supervisor) === "gone") return;
-		if (Date.now() >= deadline) throw new Error("The Metro supervisor did not close its private gateway. Restart Metro, then retry stim stop.");
-		await new Promise((done) => setTimeout(done, 100));
-	}
-}
-function hostedMetroSettings(settings, hosted) {
-	return hosted ? {
-		...settings,
-		ios: {
-			...isJsonObject(settings.ios) ? settings.ios : {},
-			remote: void 0
-		},
-		android: {
-			...isJsonObject(settings.android) ? settings.android : {},
-			remote: void 0
-		},
-		metro: {
-			...isJsonObject(settings.metro) ? settings.metro : {},
-			tunnel: void 0,
-			publicUrl: void 0,
-			ngrokUrl: void 0
-		}
-	} : settings;
-}
-//#endregion
-export { requireHostedMetro as a, requestHostedMetro as i, closeHostedMetro as n, hostedMetroSettings as r, clearHostedMetro as t };