stim 1.20.2 → 1.22.0

package/dist/{reload-C8JhxjSh.mjs → reload-BzkYabB-.mjs}

@@ -1,20 +1,22 @@
-import { H as parseDeviceSlotKey, V as deviceSlotPlatforms, p as getProject } from "./config-BYDxlMY3.mjs";
-import { i as recordWorkspaceUse, r as readWorkspaceState$1 } from "./workspace-state-DJt_MMvf.mjs";
-import { f as refuseNoProject, l as phaseLine } from "./command-output-BTy8hZ0F.mjs";
-import { F as readWorkspaceLaunches, n as findCommandWorkspace } from "./project-_phNIJfs.mjs";
-import { J as resolveOwnedAvdSerial } from "./android-Mz_Inn3w.mjs";
-import { u as resolveProjectMetro } from "./metro-DnCEjCxs.mjs";
-import { o as readWebRecord, r as cdpEndpoint, u as webFacts } from "./state-D1Icyjlu.mjs";
-import { E as resolveOwnedIosSim } from "./ios-RkW4pnQf.mjs";
-import { m as ensureMetroReverse, s as androidAppProcess, y as iosAppProcess } from "./app-install-BIKtMfPq.mjs";
-import { d as probeHostedSession } from "./hosted-client-ZEKpS9vw.mjs";
-import { r as readHostedNative } from "./ios-state-CBLe1xYw.mjs";
-import { r as reopenHostedAndroidMetro } from "./hosted-android-C3MHGld1.mjs";
-import { n as nativeRunCommand } from "./slot-launch-DPt0m9Nd.mjs";
-import { n as sendToOwnedPage, t as liveWebRecord } from "./page-DRHy329N.mjs";
+import { H as deviceSlotPlatforms, U as parseDeviceSlotKey, p as getProject } from "./config-DlrsduwG.mjs";
+import { f as refuseNoProject, l as phaseLine } from "./command-output-gwpm28fu.mjs";
+import { d as cancelledError, f as throwIfCancelled, u as cancellableSleep } from "./operation-exec-BW0em61G.mjs";
+import { a as recordWorkspaceUseAsync, r as readWorkspaceState$1 } from "./workspace-state-U08dEzhG.mjs";
+import { Nt as repoRootAsync } from "./settings-C7O8A6ZI.mjs";
+import { I as readWorkspaceLaunches, r as findCommandWorkspaceAsync } from "./project-wM_XFTvE.mjs";
+import { a as listeningPidsAsync, d as resolveProjectMetro, h as isMetroRunning, u as processCwds } from "./metro-DiXtA3Ty.mjs";
+import { d as webFactsAsync, o as readWebRecord, r as cdpEndpoint } from "./state--smjFSTL.mjs";
+import { Sn as iosAppProcess, _n as ensureMetroReverse, dn as androidAppProcess } from "./budget-Cvwn54qV.mjs";
+import { et as resolveOwnedAvdSerialAsync } from "./android-C7sVmyI9.mjs";
+import { E as resolveOwnedIosSim, f as listAllIosSimsAsync } from "./ios-hcBpnEGk.mjs";
+import { f as probeHostedSession } from "./hosted-client-DZAPrcro.mjs";
+import { r as readHostedNative } from "./ios-state-Dtw5K2aI.mjs";
+import { r as reopenHostedAndroidMetro } from "./hosted-android-B-9f-jkd.mjs";
+import { n as nativeRunCommand } from "./slot-launch-CbfmNgM6.mjs";
+import { n as sendToOwnedPage, t as liveWebRecord } from "./page-DBL2PiUU.mjs";
 import { hostedAndroidDeviceName, hostedNativeRecords } from "@stim-cli/core/state";
-import chalk from "chalk";
 import { WebSocket } from "ws";
+import chalk from "chalk";
 //#region src/engine/reload.ts
 const METRO_TIMEOUT_MS = 2e3;
 function describe$1(error) {
@@ -39,9 +41,10 @@ function peerMatches(query, role, appId) {
 * Asks Metro for its peers and reloads the ones matching `role` and `appId`. With `peersOnly`, it sends nothing and
 * only reports the outcome a reload would have, so a caller can wait for the app to connect.
 */
-function reloadThroughMetro(port, { role, appId, timeoutMs = METRO_TIMEOUT_MS, peersOnly = false }) {
+function reloadThroughMetro(port, { role, appId, timeoutMs = METRO_TIMEOUT_MS, peersOnly = false, signal }) {
+	if (signal?.aborted) return Promise.reject(cancelledError("reload"));
 	const roleName = ROLE_NAMES[role];
-	return new Promise((resolve) => {
+	return new Promise((resolve, reject) => {
 		const requestId = `stim-reload-${process.pid}-${Date.now()}`;
 		const socket = new WebSocket(`ws://127.0.0.1:${port}/message`);
 		let settled = false;
@@ -49,6 +52,7 @@ function reloadThroughMetro(port, { role, appId, timeoutMs = METRO_TIMEOUT_MS, p
 			if (settled) return;
 			settled = true;
 			clearTimeout(timer);
+			signal?.removeEventListener("abort", abort);
 			socket.close();
 			resolve(result);
 		};
@@ -57,7 +61,18 @@ function reloadThroughMetro(port, { role, appId, timeoutMs = METRO_TIMEOUT_MS, p
 			unreachable: true,
 			reason: `Metro did not answer on port ${port}.`
 		}), timeoutMs);
+		const abort = () => {
+			if (settled) return;
+			settled = true;
+			clearTimeout(timer);
+			signal?.removeEventListener("abort", abort);
+			socket.once("close", () => reject(cancelledError("reload")));
+			socket.terminate();
+		};
+		signal?.addEventListener("abort", abort, { once: true });
+		if (signal?.aborted) abort();
 		socket.once("open", () => {
+			if (settled || signal?.aborted) return;
 			socket.send(JSON.stringify({
 				version: 2,
 				method: "getpeers",
@@ -66,6 +81,7 @@ function reloadThroughMetro(port, { role, appId, timeoutMs = METRO_TIMEOUT_MS, p
 			}));
 		});
 		socket.on("message", (data) => {
+			if (settled || signal?.aborted) return;
 			let message;
 			try {
 				message = JSON.parse(data.toString());
@@ -129,22 +145,31 @@ function reloadThroughMetro(port, { role, appId, timeoutMs = METRO_TIMEOUT_MS, p
 			unreachable: true,
 			reason: `Metro reload failed: ${describe$1(error)}`
 		}));
+		socket.once("close", () => finish({
+			failed: true,
+			unreachable: true,
+			reason: `Metro closed before answering on port ${port}.`
+		}));
 	});
 }
 //#endregion
 //#region src/commands/reload.ts
 const DEFAULT_DEPS = {
-	findWorkspace: findCommandWorkspace,
+	findWorkspace: (cwd) => findCommandWorkspaceAsync(cwd, repoRootAsync, (line) => console.error(line)),
 	getProject,
 	readLaunches: readWorkspaceLaunches,
-	resolveIos: resolveOwnedIosSim,
-	resolveAndroid: resolveOwnedAvdSerial,
+	resolveIos: async (udid) => resolveOwnedIosSim(udid, await listAllIosSimsAsync({})),
+	resolveAndroid: resolveOwnedAvdSerialAsync,
 	iosProcess: iosAppProcess,
 	androidProcess: androidAppProcess,
-	resolveMetro: resolveProjectMetro,
+	resolveMetro: (port, root, signal) => resolveProjectMetro(port, root, {
+		probe: (candidate) => isMetroRunning(candidate, signal),
+		pidsOf: listeningPidsAsync,
+		cwdOf: async (pid) => (await processCwds([pid])).get(pid) ?? null
+	}),
 	reloadMetro: reloadThroughMetro,
-	readBrowser: (root) => {
-		const facts = webFacts(readWebRecord(root));
+	readBrowser: async (root) => {
+		const facts = await webFactsAsync(readWebRecord(root));
 		return facts?.status === "unverified" ? "unverified" : liveWebRecord(facts?.record ?? null);
 	},
 	reloadPage: (record) => sendToOwnedPage(record, "Page.reload"),
@@ -168,11 +193,12 @@ function failure(code, message, remedy) {
 function describe(error) {
 	return error instanceof Error ? error.message : String(error);
 }
-async function reloadBrowser(browser, metroPort, d) {
+async function reloadBrowser(browser, metroPort, d, signal) {
 	let pageUrl;
 	try {
 		pageUrl = await d.reloadPage(browser);
 	} catch (error) {
+		throwIfCancelled(signal, "reload");
 		return {
 			ok: false,
 			error: failure("STIM_RELOAD_FAILED", `The owned Chrome did not accept the reload: ${describe(error)}`, "Run `stim web` to reopen the page.")
@@ -192,8 +218,8 @@ async function reloadBrowser(browser, metroPort, d) {
 		}
 	};
 }
-function processFailure(platform, record, d, slot = "default") {
-	const { state } = platform === "ios" ? d.iosProcess(record.deviceId, record.appId) : d.androidProcess(record.deviceId, record.appId);
+async function processFailure(platform, record, d, slot = "default") {
+	const { state } = platform === "ios" ? await d.iosProcess(record.deviceId, record.appId) : await d.androidProcess(record.deviceId, record.appId);
 	if (state === "unknown") {
 		const probe = platform === "ios" ? `xcrun simctl spawn ${record.deviceId} launchctl list` : `adb -s ${record.deviceId} shell pidof ${record.appId}`;
 		return failure("STIM_RELOAD_PROBE_FAILED", `Stim could not determine whether ${record.appId} is running on ${record.deviceId}.`, `Run \`${probe}\` and retry when the device tool responds.`);
@@ -201,7 +227,7 @@ function processFailure(platform, record, d, slot = "default") {
 	if (state === "stopped") return failure("STIM_RELOAD_STOPPED", `${record.appId} is not running on ${record.deviceId}.`, `Run \`${nativeRunCommand(platform, slot)}\` to launch it.`);
 	return null;
 }
-function inspectTarget(platform, record, project, d, slot = "default") {
+async function inspectTarget(platform, record, project, d, slot = "default") {
 	const runCommand = nativeRunCommand(platform, slot);
 	if (platform === "ios") {
 		const configured = project.platforms?.ios;
@@ -211,7 +237,7 @@ function inspectTarget(platform, record, project, d, slot = "default") {
 		};
 		let resolved;
 		try {
-			resolved = d.resolveIos(record.deviceId);
+			resolved = await d.resolveIos(record.deviceId);
 		} catch (error) {
 			return {
 				platform,
@@ -222,7 +248,7 @@ function inspectTarget(platform, record, project, d, slot = "default") {
 			platform,
 			error: failure("STIM_RELOAD_STOPPED", `The recorded iOS app is not running on a booted owned simulator.`, `Run \`${runCommand}\` to boot, install, and launch it.`)
 		};
-		const stopped = processFailure(platform, record, d, slot);
+		const stopped = await processFailure(platform, record, d, slot);
 		if (stopped) return {
 			platform,
 			error: stopped
@@ -241,7 +267,7 @@ function inspectTarget(platform, record, project, d, slot = "default") {
 	};
 	let resolved;
 	try {
-		resolved = d.resolveAndroid(configured.avdName);
+		resolved = await d.resolveAndroid(configured.avdName);
 	} catch (error) {
 		return {
 			platform,
@@ -252,7 +278,7 @@ function inspectTarget(platform, record, project, d, slot = "default") {
 		platform,
 		error: failure("STIM_RELOAD_STOPPED", `The recorded Android app is not running on this workspace's owned emulator.`, `Run \`${runCommand}\` to boot, install, and launch it.`)
 	};
-	const stopped = processFailure(platform, record, d, slot);
+	const stopped = await processFailure(platform, record, d, slot);
 	if (stopped) return {
 		platform,
 		error: stopped
@@ -267,9 +293,16 @@ function inspectTarget(platform, record, project, d, slot = "default") {
 function isTargetFailure(value) {
 	return "error" in value;
 }
-async function runReload({ root, platform = null, deps = {} }) {
+async function runReload({ root, platform = null, deps = {}, signal }) {
+	throwIfCancelled(signal, "reload");
 	const d = {
 		...DEFAULT_DEPS,
+		reloadPage: (record) => sendToOwnedPage(record, "Page.reload", {}, signal),
+		reopenHostedMetro: (projectRoot, placement, port) => reopenHostedAndroidMetro(projectRoot, placement, port, signal),
+		sleep: (ms) => cancellableSleep(ms, {
+			signal,
+			what: "reload"
+		}),
 		...deps
 	};
 	const project = d.getProject(root);
@@ -277,13 +310,14 @@ async function runReload({ root, platform = null, deps = {} }) {
 		ok: false,
 		error: failure("STIM_NO_PROJECT", `No Stim environment is registered for ${root}.`, "Run `stim start` first.")
 	};
-	const read = platform === null || platform === "web" ? d.readBrowser(root) : null;
+	const read = platform === null || platform === "web" ? await d.readBrowser(root) : null;
+	throwIfCancelled(signal, "reload");
 	if (platform === "web" && read === "unverified") return {
 		ok: false,
 		error: failure("STIM_RELOAD_PROBE_FAILED", "Stim could not verify the owned Chrome's supervisor or Chrome process.", "Run `stim status`, then follow `stim guide errors teardown`.")
 	};
 	const browser = read === "unverified" ? null : read;
-	if (platform === "web") return browser ? reloadBrowser(browser, project.metroPort ?? null, d) : {
+	if (platform === "web") return browser ? reloadBrowser(browser, project.metroPort ?? null, d, signal) : {
 		ok: false,
 		error: failure("STIM_RELOAD_STOPPED", "No owned Chrome is running for this workspace.", "Run `stim web` first.")
 	};
@@ -309,9 +343,10 @@ async function runReload({ root, platform = null, deps = {} }) {
 	const hostedProbes = Object.fromEntries(await Promise.all(["ios", "android"].flatMap((native) => Object.entries(hosted[native]).map(async ([slot, placement]) => [`${native}:${slot}`, await probeHostedSession({
 		...placement,
 		platform: native
-	})]))));
+	}, signal ? { ttlMs: 0 } : void 0)]))));
+	throwIfCancelled(signal, "reload");
 	const launches = d.readLaunches(root);
-	const inspected = Object.entries(launches).flatMap(([key, record]) => {
+	const inspected = (await Promise.all(Object.entries(launches).map(async ([key, record]) => {
 		const parsed = parseDeviceSlotKey(key);
 		if (!parsed || platform && parsed.platform !== platform) return [];
 		if (hostedFailures[`${parsed.platform}:${parsed.slot}`]) return [];
@@ -330,11 +365,12 @@ async function runReload({ root, platform = null, deps = {} }) {
 				error: failure("STIM_RELOAD_PROBE_FAILED", `The ${parsed.platform} session on ${placement.machine} is ${probe.state}.`, `Run stim ${parsed.platform} --remote ${placement.machine} or stim stop to reconcile it.`)
 			}];
 		}
-		return [inspectTarget(parsed.platform, record, {
+		return [await inspectTarget(parsed.platform, record, {
 			...project,
 			platforms: deviceSlotPlatforms(project, parsed.slot)
 		}, d, parsed.slot)];
-	});
+	}))).flat();
+	throwIfCancelled(signal, "reload");
 	inspected.push(...Object.values(hostedFailures));
 	const live = inspected.filter((target) => !isTargetFailure(target));
 	const livePlatforms = new Set(live.map((target) => target.platform));
@@ -346,7 +382,7 @@ async function runReload({ root, platform = null, deps = {} }) {
 			error: failure("STIM_RELOAD_AMBIGUOUS", `More than one platform is live: ${names.join(", ")}.`, `Choose one with ${names.map((name) => `\`stim reload ${name}\``).join(" or ")}.`)
 		};
 	}
-	if (browser && inspected.length === 0) return reloadBrowser(browser, project.metroPort ?? null, d);
+	if (browser && inspected.length === 0) return reloadBrowser(browser, project.metroPort ?? null, d, signal);
 	if (read === "unverified" && inspected.length === 0) return {
 		ok: false,
 		error: failure("STIM_RELOAD_PROBE_FAILED", "Stim could not verify the owned Chrome's supervisor or Chrome process.", "Run `stim status`, then follow `stim guide errors teardown`.")
@@ -375,11 +411,14 @@ async function runReload({ root, platform = null, deps = {} }) {
 		ok: false,
 		error: failure("STIM_NO_METRO", `The launch does not point at this workspace's current Metro reservation.`, "Run `stim start`, then launch the app again.")
 	};
-	if (!(await d.resolveMetro(port, root)).metro) return {
+	const metro = await d.resolveMetro(port, root, signal);
+	throwIfCancelled(signal, "reload");
+	if (!metro.metro) return {
 		ok: false,
 		error: failure("STIM_NO_METRO", `Port ${port} is not serving this workspace's Metro.`, "Run `stim start`, then retry.")
 	};
-	const stopped = target.hosted ? null : processFailure(target.platform, target.record, d, target.slot);
+	const stopped = target.hosted ? null : await processFailure(target.platform, target.record, d, target.slot);
+	throwIfCancelled(signal, "reload");
 	if (stopped) return {
 		ok: false,
 		error: stopped
@@ -388,11 +427,14 @@ async function runReload({ root, platform = null, deps = {} }) {
 	let hostedReopened = false;
 	const reverseChecked = target.platform === "android" ? live.filter((c) => c.platform === "android" && !c.record.release && c.record.metroPort === port) : [];
 	for (const candidate of reverseChecked) {
+		throwIfCancelled(signal, "reload");
 		if (candidate.hostedAndroid) {
 			try {
 				await d.reopenHostedMetro(root, candidate.hostedAndroid, port);
+				throwIfCancelled(signal, "reload");
 				hostedReopened = true;
 			} catch (error) {
+				throwIfCancelled(signal, "reload");
 				return {
 					ok: false,
 					error: failure("STIM_HOSTING_REFUSED", describe(error), `Retry stim reload android when ${candidate.hostedAndroid.machine} answers, or run stim stop to reconcile the session.`)
@@ -401,7 +443,8 @@ async function runReload({ root, platform = null, deps = {} }) {
 			continue;
 		}
 		const serial = candidate.record.deviceId;
-		const ensured = d.ensureReverse(serial, port);
+		const ensured = await d.ensureReverse(serial, port);
+		throwIfCancelled(signal, "reload");
 		if (ensured.failed) return {
 			ok: false,
 			error: failure("STIM_RELOAD_FAILED", `Stim could not check or restore the adb reverse for Metro port ${port} on ${serial}: ${ensured.reason}`, `Run \`adb -s ${serial} reverse tcp:${port} tcp:${port}\`, then \`stim reload android\` again.`)
@@ -410,23 +453,27 @@ async function runReload({ root, platform = null, deps = {} }) {
 	}
 	const request = {
 		role: target.platform,
-		appId: target.record.appId
+		appId: target.record.appId,
+		...signal ? { signal } : {}
 	};
 	const expectedPeers = reverseChecked.filter((c) => c.record.appId === target.record.appId).length;
 	const awaitReconnect = reverseRestored.length > 0 || hostedReopened;
 	for (let poll = 0; poll < RECONNECT_POLLS; poll++) {
+		throwIfCancelled(signal, "reload");
 		if (!awaitReconnect) break;
 		const peers = await d.reloadMetro(port, {
 			...request,
 			peersOnly: true
 		});
+		throwIfCancelled(signal, "reload");
 		if (peers.broadcast) await d.sleep(RECONNECT_UNOBSERVED_MS);
 		if (peers.unreachable || peers.broadcast || peers.ok && peers.targets >= expectedPeers) break;
 		await d.sleep(RECONNECT_POLL_MS);
 	}
+	throwIfCancelled(signal, "reload");
 	const reloaded = await d.reloadMetro(port, request);
 	if (!reloaded.ok) {
-		const stoppedAfterMetro = target.hosted ? null : processFailure(target.platform, target.record, d, target.slot);
+		const stoppedAfterMetro = target.hosted ? null : await processFailure(target.platform, target.record, d, target.slot);
 		if (stoppedAfterMetro) return {
 			ok: false,
 			error: stoppedAfterMetro
@@ -472,12 +519,12 @@ function registerReload(program, deps = {}) {
 			process.exitCode = 1;
 			return;
 		}
-		const root = (deps.findWorkspace ?? DEFAULT_DEPS.findWorkspace)(process.cwd());
+		const root = await (deps.findWorkspace ?? DEFAULT_DEPS.findWorkspace)(process.cwd());
 		if (!root) {
 			refuseNoProject({ json: Boolean(opts.json) });
 			return;
 		}
-		recordWorkspaceUse(root);
+		await recordWorkspaceUseAsync(root);
 		const result = await runReload({
 			root,
 			platform: value ?? null,
@@ -509,4 +556,4 @@ function reloadCommand(program) {
 	registerReload(program);
 }
 //#endregion
-export { reloadCommand as default, registerReload, runReload };
+export { reloadCommand as n, runReload as r, registerReload as t };

package/dist/reload-D7AVlb8N.mjs

@@ -0,0 +1,2 @@
+import { n as reloadCommand, r as runReload, t as registerReload } from "./reload-BzkYabB-.mjs";
+export { reloadCommand as default, registerReload, runReload };

package/dist/{remote-BiR6aYjy.mjs → remote-DjGDmlTZ.mjs}

@@ -1,19 +1,22 @@
-import { V as deviceSlotPlatforms } from "./config-BYDxlMY3.mjs";
-import { F as parseIosRemote, H as remoteIosSetting, L as publicUrlSetting, V as remoteEasFallbackSetting, tt as tunnelModeSetting } from "./settings-B717odTD.mjs";
-import { l as phaseLine } from "./command-output-BTy8hZ0F.mjs";
-import { n as devicePlacementRecord } from "./placement-log-MOfPVgaM.mjs";
-import { c as devicePlacementLine } from "./build-plan-B7SZsc2N.mjs";
-import "./device-remote-xRT0Vmo9.mjs";
-import { b as resolveSimulatorAppFlag } from "./support-CwjbFs9H.mjs";
+import { H as deviceSlotPlatforms } from "./config-DlrsduwG.mjs";
+import { l as phaseLine } from "./command-output-gwpm28fu.mjs";
+import { F as parseIosRemote, H as remoteEasFallbackSetting, R as publicUrlSetting, U as remoteIosSetting, rt as tunnelModeSetting } from "./settings-C7O8A6ZI.mjs";
+import "./budget-Cvwn54qV.mjs";
+import { b as resolveSimulatorAppFlag } from "./support-CNioewsd.mjs";
+import { n as devicePlacementRecord } from "./placement-log-BnGgJRRZ.mjs";
+import { r as devicePlacementLine } from "./eas-fallback-CSgAulr5.mjs";
 import chalk from "chalk";
 //#region src/commands/ios/remote.ts
-function resolveIosRemote({ opts, settings, physical, recorded }) {
-	const target = opts.remote !== void 0 ? parseIosRemote(opts.remote) : remoteIosSetting(settings);
-	if (physical && target?.kind === "machine") return { failure: {
+function deviceRemoteConflict(remote, physical) {
+	if (!physical || remote === void 0 || !parseIosRemote(remote)) return null;
+	return {
 		code: "STIM_BAD_ARG",
-		message: "--device builds for a phone connected to this machine, and --remote installs on a remote one.",
-		remedy: "Pass only one of --device and --remote; unset ios.remote for a local phone."
-	} };
+		message: `--device runs on a phone connected to this machine, and --remote ${remote} chooses where a simulator runs.`,
+		remedy: "Pass only one of --device and --remote, or --remote local with --device."
+	};
+}
+function resolveIosRemote({ opts, settings, physical, recorded }) {
+	const target = opts.remote !== void 0 ? parseIosRemote(opts.remote) : physical ? null : remoteIosSetting(settings);
 	const machine = target?.kind === "machine" ? target.machine : null;
 	if (recorded && recorded.machine !== machine && machine !== "auto") return { failure: {
 		code: "STIM_BAD_ARG",
@@ -67,7 +70,7 @@ async function selectIosPlacement(args) {
 	const { root, slot, d, opts, deviceType, runtime, noWait, phase, log, release, appMode, metroCheck } = args;
 	const viewer = resolveSimulatorAppFlag(opts.simulatorApp, args.physical, null);
 	if ("refusal" in viewer) return { failure: viewer.refusal };
-	const refusal = args.validateSelectors();
+	const refusal = await args.validateSelectors();
 	if (refusal) return { failure: refusal };
 	const easFallback = args.supportsRemote && remoteEasFallbackSetting(args.settings);
 	try {
@@ -82,6 +85,8 @@ async function selectIosPlacement(args) {
 			...easFallback ? { eas: () => d.checkEasFallback({
 				root,
 				platform: "ios",
+				env: args.env,
+				operation: args.operation,
 				slot,
 				release,
 				isExpo: d.detectIsExpo(root),
@@ -149,7 +154,7 @@ async function connectIosTarget(selection, selectors, d, appMode) {
 		} };
 	}
 }
-async function iosPlacementBudget(d, root, note, hosted, automatic, simSnapshot) {
+async function iosPlacementBudget(d, root, note, hosted, automatic, simSnapshot, env) {
 	if (automatic) return {
 		...automatic,
 		refusal: hosted ? null : automatic.refusal
@@ -160,14 +165,15 @@ async function iosPlacementBudget(d, root, note, hosted, automatic, simSnapshot)
 	} : d.budgetGate({
 		root,
 		note,
-		simSnapshot
+		simSnapshot,
+		env
 	});
 }
 function hostedIosMetroNote(hosted, settings, note, simulatorApp) {
 	if (hosted && (settings.iosSimulatorApp !== void 0 || simulatorApp !== void 0)) note(chalk.dim(phaseLine("device", "iosSimulatorApp is ignored on a hosting Mac; the simulator boots headless.")));
 	if (hosted && (publicUrlSetting(settings) || tunnelModeSetting(settings))) note(chalk.dim(phaseLine("metro", "metro.publicUrl and metro.tunnel are ignored on a hosting Mac; Metro uses the private tailnet bridge.")));
 }
-async function connectIosBackend(root, backend, deviceType, d) {
+async function connectIosBackend(root, backend, deviceType, d, env, operation) {
 	if (!backend) return {
 		remote: null,
 		arch: null
@@ -175,6 +181,8 @@ async function connectIosBackend(root, backend, deviceType, d) {
 	const resolved = await d.resolveRemoteContext({
 		root,
 		backend,
+		env,
+		operation,
 		easBin: d.resolveEasCliBin(root)?.file ?? null,
 		deviceType: deviceType?.trim() || null
 	});
@@ -189,4 +197,4 @@ async function connectIosBackend(root, backend, deviceType, d) {
 	};
 }
 //#endregion
-export { iosPlacementBudget as a, hostedIosSelectors as i, connectIosTarget as n, selectIosPlacement as o, hostedIosMetroNote as r, connectIosBackend as t };
+export { hostedIosSelectors as a, hostedIosMetroNote as i, connectIosTarget as n, iosPlacementBudget as o, deviceRemoteConflict as r, selectIosPlacement as s, connectIosBackend as t };