stim 1.16.0 → 1.17.1

package/dist/{dependency-state-B6cMXZab.mjs → dependency-state-CLcBHH2M.mjs}

@@ -1,5 +1,5 @@
 import { t as getExecutor } from "./exec-CaErVv7t.mjs";
-import { gt as repoRoot } from "./settings-oTSkkNrM.mjs";
+import { gt as repoRoot } from "./settings-Cfd-0r2d.mjs";
 import { existsSync } from "node:fs";
 import { dirname, join, relative } from "node:path";
 //#region src/dependency-state.ts

package/dist/{deps-urbmfXig.mjs → deps-CVxlsRFn.mjs}

@@ -1,7 +1,7 @@
 import { t as getExecutor } from "./exec-CaErVv7t.mjs";
 import { n as stripAnsi, r as waitForChild, t as createLineReader } from "./process-output-Fpl8PYi8.mjs";
 import { a as spawnDeclared } from "./spawn-claims-D0XfSe8u.mjs";
-import { S as bundlerPin, u as HEARTBEAT_INTERVAL_MS, y as startBuildHeartbeat } from "./toolchain-DkUflduf.mjs";
+import { S as bundlerPin, u as HEARTBEAT_INTERVAL_MS, y as startBuildHeartbeat } from "./toolchain-CdrxgUeA.mjs";
 import { existsSync, readFileSync } from "node:fs";
 import { delimiter, dirname, join, relative, resolve, sep } from "node:path";
 import { homedir } from "node:os";

package/dist/{dev-client-CroAIjjj.mjs → dev-client-B-XC4uRH.mjs}

@@ -1,5 +1,5 @@
-import { c as isPackageResolvable, p as resolvePackageJson } from "./project-Du91Ilvc.mjs";
-import { C as pickDevClientScheme, w as readBundleSchemes } from "./app-install-CKWdbXIX.mjs";
+import { l as isPackageResolvable, m as resolvePackageJson } from "./project-D47Rh0ly.mjs";
+import { E as readBundleSchemes, T as pickDevClientScheme } from "./app-install-VPkI5WEg.mjs";
 import { dirname, join } from "node:path";
 import { isJsonObject, readJsonObject } from "@stim-cli/core/state";
 //#region src/commands/dev-client.ts

package/dist/{device-DZQjF7H5.mjs → device-C8IOoJPv.mjs}

@@ -1,11 +1,11 @@
 import { H as projectDeviceSlots, R as deviceSlotKey, V as parseDeviceSlotOption, p as getProject } from "./config-D0DbpZtM.mjs";
-import { r as clockTime } from "./command-output-DnJMdEY-.mjs";
-import { o as findProjectRoot, t as NO_PROJECT_REFUSAL } from "./project-Du91Ilvc.mjs";
-import { n as fileLeaseIo, o as parseLeaseDuration, p as takeLease, u as releaseWorkspaceLeases } from "./device-lease-D-hLqx1b.mjs";
-import { E as getAvdNameForSerial, G as probeEmulatorSerial, N as memoizeEmulatorProbe, O as listAdbDevices, U as physicalDeviceModel, Y as resolvePhysicalDevice, c as androidPoolNoCandidatesRefusal, s as androidPoolCandidates } from "./android-B_NumVyQ.mjs";
-import { l as parseDeviceWait, p as waitForDevice } from "./device-lease-run-CqjShqWW.mjs";
-import { t as selectFromPool } from "./device-pool-CUaEWMMm.mjs";
-import { a as iosPoolCandidates, c as isWirelessIosDevice, f as resolveIosPhysicalDevice, l as listIosDevices, o as iosPoolNoCandidatesRefusal } from "./ios-device-FfCN_C8p.mjs";
+import { r as clockTime } from "./command-output-CDAIFD-8.mjs";
+import { s as findProjectRoot, t as NO_PROJECT_REFUSAL } from "./project-D47Rh0ly.mjs";
+import { n as fileLeaseIo, o as parseLeaseDuration, p as takeLease, u as releaseWorkspaceLeases } from "./device-lease-DpoS36_u.mjs";
+import { E as getAvdNameForSerial, G as probeEmulatorSerial, N as memoizeEmulatorProbe, O as listAdbDevices, U as physicalDeviceModel, Y as resolvePhysicalDevice, c as androidPoolNoCandidatesRefusal, s as androidPoolCandidates } from "./android-B_YNZy61.mjs";
+import { l as parseDeviceWait, p as waitForDevice } from "./device-lease-run-B8YltIH_.mjs";
+import { t as selectFromPool } from "./device-pool-3o7s5lo4.mjs";
+import { a as iosPoolCandidates, c as isWirelessIosDevice, f as resolveIosPhysicalDevice, l as listIosDevices, o as iosPoolNoCandidatesRefusal } from "./ios-device-pAN4t54-.mjs";
 import chalk from "chalk";
 //#region src/commands/device.ts
 const DEFAULT_FOR = "5m";

package/dist/device-capacity-ZC4XSZ4R.mjs

@@ -0,0 +1,580 @@
+import { H as projectDeviceSlots, _ as loadConfig$1, d as getConfigDir, u as getConcurrencyLimits, z as deviceSlotPlatforms } from "./config-D0DbpZtM.mjs";
+import { n as ownership_claim_exports } from "./process-identity-BmRm1qV0.mjs";
+import { a as formatElapsed, l as phaseLine } from "./command-output-CDAIFD-8.mjs";
+import { E as projectDeviceReclaimIdleMinutes } from "./settings-Cfd-0r2d.mjs";
+import { x as workspaceLogsDir$1 } from "./workspace-state-DqcCbpE7.mjs";
+import { n as withIdleWorkspace, o as canonicalPath } from "./in-use-CvGOUn-x.mjs";
+import { O as listAdbDevices } from "./android-B_YNZy61.mjs";
+import { _ as parseRuntimeVersion, c as iosRuntimeMatches, u as listAllIosSims } from "./ios-DSfnPfse.mjs";
+import { n as workspaceProcessLockError, t as withWorkspaceProcessLock } from "./workspace-process-lock-2mNzOlaB.mjs";
+import { h as recordCapacityWait, m as recordCapacityRefusal } from "./build-progress-D0WkjCPd.mjs";
+import { r as createNdjsonWriter } from "./ndjson-PclOIwVY.mjs";
+import { n as dueIdleDevices, r as shutDownIdleDevices } from "./idle-shutdown-IGyNV8Cr.mjs";
+import { realpathSync } from "node:fs";
+import { basename, join } from "node:path";
+import { LOG_ROTATE_BYTES, workspaceId } from "@stim-cli/core";
+import { DEVICE_RECLAIM_REASON } from "@stim-cli/core/state";
+import { setTimeout } from "node:timers/promises";
+//#region src/devices/queue-reclaim.ts
+async function reclaimIdleDevice(root, idleMs, out, now, skipped) {
+	try {
+		const self = canonicalPath(root);
+		const candidate = dueIdleDevices(void 0, idleMs, now()).filter(({ device }) => {
+			try {
+				return realpathSync(device.project) !== self;
+			} catch {
+				return false;
+			}
+		}).toSorted((a, b) => b.idleForMs - a.idleForMs).find(({ device }) => !skipped.has(`${device.kind}:${device.id}`));
+		if (!candidate) return 0;
+		const { device, idleForMs } = candidate;
+		const label = loadConfig$1()?.projects[device.project]?.label || basename(device.project);
+		const log = (event) => {
+			const writer = createNdjsonWriter(join(workspaceLogsDir$1(device.project), "metro.ndjson"), { maxBytes: LOG_ROTATE_BYTES });
+			writer.write({
+				src: "metro",
+				...event
+			});
+			writer.close();
+			if (event.level === "warn") out(`${"device".padEnd(11)} ${event.msg}`);
+		};
+		skipped.add(`${device.kind}:${device.id}`);
+		const run = await withIdleWorkspace(device.project, () => shutDownIdleDevices(device.project, idleMs, log, now(), {
+			only: device,
+			reason: DEVICE_RECLAIM_REASON
+		}), {
+			purpose: "device queue reclaim",
+			supervisor: false,
+			managedLocks: false
+		});
+		if (!run.ran) {
+			log({
+				level: "warn",
+				event: "device_idle_shutdown_failed",
+				msg: `could not reclaim ${device.name}: ${run.reasons.join("; ")}`
+			});
+			return 0;
+		}
+		if (!run.value) return 0;
+		skipped.delete(`${device.kind}:${device.id}`);
+		out(`${"device".padEnd(11)} reclaimed ${device.kind === "ios" ? "iOS simulator" : "Android emulator"} ${device.name} (workspace ${label}, idle ${Math.floor(idleForMs / 6e4)}m) for this waiting run`);
+		return run.value;
+	} catch (error) {
+		out(`${"device".padEnd(11)} could not reclaim an idle device: ${error?.message || error}`);
+		return 0;
+	}
+}
+//#endregion
+//#region src/engine/device-capacity.ts
+const LIVE_SIM_STATES = /* @__PURE__ */ new Set(["Booted", "Booting"]);
+const ADMISSION_LOCK = "device-admission";
+const ADMISSION_LOCK_WAIT_MS = 3e5;
+const LOCK_QUIET_MS = 5e3;
+const LOCK_PROGRESS_MS = 3e4;
+const INVENTORY_REFRESH_MS = 1e4;
+const LISTING_TIMEOUT_MS = 3e4;
+const NO_ADB = {
+	emulators: [],
+	physical: [],
+	unhealthy: []
+};
+var DeviceAdmissionRefusal = class extends Error {
+	code;
+	remedy;
+	constructor(refusal) {
+		super(refusal.message);
+		this.code = refusal.code;
+		this.remedy = refusal.remedy;
+	}
+};
+var DeviceCountUnavailable = class extends Error {};
+function deviceKey(platform, key) {
+	return `${platform}:${key}`;
+}
+function bootingDevicesRoot() {
+	return join(getConfigDir(), "device-boots");
+}
+function liveEmulatorPorts(adb) {
+	return [...adb.emulators, ...adb.unhealthy.filter((entry) => entry.kind === "emulator")];
+}
+function readBootingDevices() {
+	const survey = (0, ownership_claim_exports.readClaimSet)(bootingDevicesRoot());
+	const unresolved = survey.unresolved[0];
+	if (unresolved) throw new ownership_claim_exports.ClaimRefusedError({
+		claimPath: unresolved.path,
+		root: bootingDevicesRoot(),
+		reason: unresolved.reason,
+		label: "device boot"
+	});
+	const booting = [];
+	for (const holder of survey.live) {
+		const { platform, key } = holder.details;
+		if (typeof platform === "string" && typeof key === "string") booting.push({
+			platform,
+			key,
+			displayName: typeof holder.details.displayName === "string" ? holder.details.displayName : void 0
+		});
+	}
+	return booting;
+}
+function listSimsForCount() {
+	return process.platform === "darwin" ? listAllIosSims({ timeoutMs: LISTING_TIMEOUT_MS }) : [];
+}
+function listAdbForCount() {
+	return listAdbDevices({ timeoutMs: LISTING_TIMEOUT_MS });
+}
+function toolAbsent(error) {
+	const { code, status, stderr } = error ?? {};
+	return code === "ENOENT" || status === 127 || /unable to find utility|invalid active developer path|Xcode license/.test(String(stderr ?? ""));
+}
+function recordsOwnedEmulator(config) {
+	return Object.values(config?.projects || {}).some((project) => projectDeviceSlots(project).some(({ platforms }) => platforms.android?.owned && typeof platforms.android.consolePort === "number"));
+}
+function liveOwnedDeviceKeys({ sims = [], adbEmulators = [], config = null, booting = [], exclude = [] }) {
+	const keys = /* @__PURE__ */ new Set();
+	for (const sim of sims) {
+		if (!sim?.name?.startsWith("stim-")) continue;
+		if (exclude.some((device) => device.platform === "ios" && device.key === sim.udid)) continue;
+		if (LIVE_SIM_STATES.has(sim.state)) keys.add(deviceKey("ios", sim.udid));
+	}
+	const livePorts = new Set(adbEmulators.map((e) => e.consolePort));
+	for (const proj of Object.values(config?.projects || {})) for (const { platforms } of projectDeviceSlots(proj)) {
+		const android = platforms.android;
+		if (android?.owned && android.avdName && typeof android.consolePort === "number" && livePorts.has(android.consolePort)) keys.add(deviceKey("android", android.avdName));
+	}
+	for (const device of booting) if (!exclude.some((excluded) => excluded.platform === device.platform && excluded.key === device.key)) keys.add(deviceKey(device.platform, device.key));
+	return keys;
+}
+function inventoryKeys(inventory, exclude = []) {
+	return liveOwnedDeviceKeys({
+		...inventory,
+		adbEmulators: liveEmulatorPorts(inventory.adb),
+		exclude
+	});
+}
+function atCapacityRefusal(count, max) {
+	return {
+		code: "STIM_AT_CAPACITY",
+		message: count < max ? `${count}/${max} Stim devices are in use, but another run is ahead in the device slot queue.` : `${count} Stim device(s) are already booted and concurrency.maxDevices is ${max}, so booting another would exceed the cap.`,
+		remedy: "stop an environment (stim stop) or raise concurrency.maxDevices"
+	};
+}
+function uncountedRefusal(error) {
+	return {
+		code: "STIM_NO_DEVICE",
+		message: `concurrency.maxDevices is set, and Stim could not count the booted devices: ${error?.message || error}`,
+		remedy: `Listing devices times out when the machine is overloaded: retry once the load falls. Otherwise run \`stim doctor\` to check the simulator and adb toolchains, and check that ${join(getConfigDir(), "config.json")} and ${bootingDevicesRoot()} are readable.`
+	};
+}
+function listed(source, empty, absent = () => false) {
+	try {
+		return (typeof source === "function" ? source() : source) ?? empty;
+	} catch (error) {
+		if (absent(error)) return empty;
+		throw new DeviceCountUnavailable("", { cause: error });
+	}
+}
+function readInventory({ sims = listSimsForCount, adb = listAdbForCount, config = loadConfig$1, booting = readBootingDevices }) {
+	try {
+		const recorded = listed(config, null);
+		return {
+			booting: listed(booting, []),
+			sims: listed(sims, [], toolAbsent),
+			adb: recordsOwnedEmulator(recorded) ? listed(adb, NO_ADB, toolAbsent) : NO_ADB,
+			config: recorded
+		};
+	} catch (error) {
+		if (error instanceof DeviceCountUnavailable) {
+			if ((0, ownership_claim_exports.isClaimRefusal)(error.cause)) throw error.cause;
+			return uncountedRefusal(error.cause);
+		}
+		throw error;
+	}
+}
+/**
+* Owned simulators that are booted or booting, owned emulators adb lists in any state, and devices another
+* run is booting under `concurrency.maxDevices`, each counted once unless excluded; when a listing fails, why the count is unknown.
+*/
+function countLiveOwnedDevices(sources = {}, { exclude = [] } = {}) {
+	try {
+		const inventory = readInventory(sources);
+		return "code" in inventory ? { unknown: inventory.message } : inventoryKeys(inventory, exclude).size;
+	} catch (error) {
+		if ((0, ownership_claim_exports.isClaimRefusal)(error)) return { unknown: error.message };
+		throw error;
+	}
+}
+function workspaceHasLiveDevice({ platform, project, slot = "default", sims = [], adbEmulators = [] } = {}) {
+	if (!platform) return false;
+	const record = deviceSlotPlatforms(project, slot)?.[platform];
+	if (!record) return false;
+	if (platform === "ios") return sims.some((s) => s.udid === record.deviceUdid && LIVE_SIM_STATES.has(s.state));
+	return typeof record.consolePort === "number" && adbEmulators.some((e) => e.consolePort === record.consolePort);
+}
+function deviceCapacityRefusal({ platform, project, slot = "default", max, sims = [], adb = null, config = null, booting = [] } = {}) {
+	if (!max || max <= 0) return null;
+	const adbEmulators = liveEmulatorPorts(adb ?? NO_ADB);
+	if (workspaceHasLiveDevice({
+		platform,
+		project,
+		slot,
+		sims,
+		adbEmulators
+	})) return null;
+	const count = liveOwnedDeviceKeys({
+		sims,
+		adbEmulators,
+		config,
+		booting
+	}).size;
+	return count < max ? null : atCapacityRefusal(count, max);
+}
+/**
+* The early `concurrency.maxDevices` check, before Metro starts or a device is created. It is advisory, so an
+* unknown count passes: `withDeviceBootAdmission` makes the binding decision when the boot starts.
+*/
+function checkDeviceCapacity({ platform, project, slot = "default", max, ...sources } = {}) {
+	if (!max || max <= 0) return null;
+	let inventory;
+	try {
+		inventory = readInventory(sources);
+	} catch (error) {
+		if ((0, ownership_claim_exports.isClaimRefusal)(error)) return null;
+		throw error;
+	}
+	if ("code" in inventory) return null;
+	return deviceCapacityRefusal({
+		platform,
+		project,
+		slot,
+		max,
+		...inventory
+	});
+}
+function peekDeviceSlots({ platform, project, slot = "default", max = getConcurrencyLimits().maxDevices, sources = {} }) {
+	try {
+		const inventory = readInventory(sources);
+		if ("code" in inventory) return {
+			count: null,
+			max,
+			queued: 0,
+			localLive: false
+		};
+		const owned = deviceSlotPlatforms(project, slot)?.[platform]?.owned === true;
+		return {
+			count: inventoryKeys(inventory).size,
+			max,
+			queued: liveWaiters().length,
+			localLive: owned && workspaceHasLiveDevice({
+				platform,
+				project,
+				slot,
+				sims: inventory.sims,
+				adbEmulators: liveEmulatorPorts(inventory.adb)
+			})
+		};
+	} catch (error) {
+		if (!(0, ownership_claim_exports.isClaimRefusal)(error)) throw error;
+		return {
+			count: null,
+			max,
+			queued: 0,
+			localLive: false
+		};
+	}
+}
+const DEFAULT_DEVICE_SLOT_WAIT_MS = 6e5;
+function deviceSlotWaitingLine({ count, max, holders, elapsedMs, queue }) {
+	return `${"device".padEnd(11)} waiting for a device slot (${count}/${max} in use${holders.length ? `: ${holders.join(", ")}` : ""}), ${formatElapsed(elapsedMs)} elapsed -- stim guide lifecycle concurrency${queue ? `; ${queue}` : ""}`;
+}
+function deviceHolders(inventory, keys) {
+	const names = /* @__PURE__ */ new Map();
+	for (const [root, project] of Object.entries(inventory.config?.projects ?? {})) for (const { platforms } of projectDeviceSlots(project)) {
+		if (platforms.ios?.deviceUdid) names.set(deviceKey("ios", platforms.ios.deviceUdid), project.label || basename(root));
+		if (platforms.android?.avdName) names.set(deviceKey("android", platforms.android.avdName), project.label || basename(root));
+	}
+	for (const sim of inventory.sims) {
+		const key = deviceKey("ios", sim.udid);
+		if (!names.has(key)) names.set(key, sim.name);
+	}
+	for (const device of inventory.booting) {
+		const key = deviceKey(device.platform, device.key);
+		if (!names.has(key)) names.set(key, device.displayName ?? device.key);
+	}
+	return [...new Set([...keys].map((key) => names.get(key) ?? key.slice(key.indexOf(":") + 1)))].toSorted();
+}
+function liveWaiters() {
+	const root = join(getConfigDir(), "device-waits");
+	const survey = (0, ownership_claim_exports.inspectClaimSet)(root, { label: "device wait" });
+	if (survey.exclusive) throw new ownership_claim_exports.ClaimRefusedError({
+		root,
+		claimPath: survey.exclusive.path,
+		reason: "the wait queue is held exclusively",
+		label: "device wait"
+	});
+	return survey.shared.toSorted((a, b) => (Number(a.details.sequence) || 0) - (Number(b.details.sequence) || 0) || a.startedAt.localeCompare(b.startedAt) || a.claimId.localeCompare(b.claimId));
+}
+function takeWaitTicket(device, waiters) {
+	const root = join(getConfigDir(), "device-waits");
+	const attempt = (0, ownership_claim_exports.tryAcquireClaim)({
+		root,
+		mode: "shared",
+		label: "device wait",
+		details: {
+			...device,
+			sequence: Math.max(0, ...waiters.map((holder) => Number(holder.details.sequence) || 0)) + 1
+		}
+	});
+	if (attempt.acquired) return attempt.acquired;
+	throw new ownership_claim_exports.ClaimRefusedError({
+		root,
+		claimPath: attempt.held?.path ?? root,
+		reason: "the wait queue is held exclusively",
+		label: "device wait"
+	});
+}
+function takeBootMarker(device) {
+	const attempt = (0, ownership_claim_exports.tryAcquireClaim)({
+		root: bootingDevicesRoot(),
+		mode: "shared",
+		label: "device boot",
+		details: { ...device }
+	});
+	if (attempt.acquired) return attempt.acquired;
+	throw new DeviceAdmissionRefusal({
+		code: "STIM_NO_DEVICE",
+		message: `Another process holds ${bootingDevicesRoot()} exclusively, so this boot cannot be counted toward concurrency.maxDevices.`,
+		remedy: "Retry once that process finishes."
+	});
+}
+async function admissionTransaction(action, lockWaitMs, out, signal) {
+	const started = Date.now();
+	let lastLine = null;
+	const onHeld = () => {
+		const elapsed = Date.now() - started;
+		if (elapsed < LOCK_QUIET_MS || lastLine !== null && Date.now() - lastLine < LOCK_PROGRESS_MS) return;
+		lastLine = Date.now();
+		out(phaseLine("device", `waiting for other runs to finish counting booted devices (${formatElapsed(elapsed)})`));
+	};
+	try {
+		return await withWorkspaceProcessLock(getConfigDir(), ADMISSION_LOCK, action, {
+			external: true,
+			waitMs: lockWaitMs,
+			onHeld,
+			signal
+		});
+	} catch (error) {
+		if (workspaceProcessLockError(error) !== "timeout") throw error;
+		throw new DeviceAdmissionRefusal({
+			code: "STIM_NO_DEVICE",
+			message: `Waited ${formatElapsed(lockWaitMs)} for other runs to finish counting booted devices for concurrency.maxDevices.`,
+			remedy: "Listing devices is slow, which usually means the machine is overloaded. Retry once the load falls."
+		});
+	}
+}
+/** Boots an owned device under the Stim home's cap, reserving capacity before releasing admission. */
+async function withDeviceBootAdmission(device, boot, { root, max = getConcurrencyLimits().maxDevices, sources = {}, lockWaitMs = ADMISSION_LOCK_WAIT_MS, out = () => {}, waitMs = DEFAULT_DEVICE_SLOT_WAIT_MS, noWait = false, displayName = basename(root), now = Date.now, signal, sleep = (ms) => setTimeout(ms, void 0, { signal }), waitingFor = () => {}, onWait = () => {} }) {
+	signal?.throwIfAborted();
+	if (!max || max <= 0) return boot();
+	const workspace = workspaceId(root);
+	device = {
+		...device,
+		workspace,
+		displayName
+	};
+	let ticket;
+	let marker;
+	let started;
+	let lastLine = -Infinity;
+	let visibleWait = false;
+	let lastInventory = {
+		count: 0,
+		holders: []
+	};
+	let lastListed = -Infinity;
+	let reclaimed = 0;
+	let lastReclaim = -Infinity;
+	const skippedReclaims = /* @__PURE__ */ new Set();
+	try {
+		try {
+			for (;;) {
+				const result = await admissionTransaction(async () => {
+					signal?.throwIfAborted();
+					const waiters = liveWaiters();
+					const first = waiters[0];
+					const turn = !first || first.claimId === ticket?.claimId;
+					const admit = () => {
+						const admitted = takeBootMarker(device);
+						if ((0, ownership_claim_exports.releaseClaim)(ticket)) ticket = void 0;
+						return { marker: admitted };
+					};
+					const wait = ({ count, holders }) => {
+						const ticketId = ticket?.claimId;
+						const position = ticketId ? waiters.findIndex((holder) => holder.claimId === ticketId) + 1 : waiters.length + 1;
+						const headName = first?.details.displayName ?? displayName;
+						const queue = `queue position ${position}${position > 1 ? " behind" : ", head"} ${headName}; queue: ${join(getConfigDir(), "device-waits")}`;
+						if (noWait || waitMs === 0) throw new DeviceAdmissionRefusal(atCapacityRefusal(count, max));
+						if (started !== void 0 && now() - started >= waitMs) throw new DeviceAdmissionRefusal({
+							code: "STIM_AT_CAPACITY",
+							message: `Waited ${formatElapsed(now() - started)} for a device slot; ${count}/${max} Stim devices are in use; ${queue}.`,
+							remedy: "Stop an environment (stim stop), retry with a longer --wait <seconds>, or raise concurrency.maxDevices."
+						});
+						if (!ticket) {
+							ticket = takeWaitTicket(device, waiters);
+							started = now();
+						}
+						return {
+							count,
+							holders,
+							queue,
+							reclaim: turn && count >= max
+						};
+					};
+					if (ticket && !turn && now() - lastListed < INVENTORY_REFRESH_MS) {
+						const booting = sources.booting ?? readBootingDevices;
+						const own = deviceKey(device.platform, device.key);
+						if ((typeof booting === "function" ? booting() : booting).some((entry) => deviceKey(entry.platform, entry.key) === own)) return admit();
+						return wait(lastInventory);
+					}
+					const inventory = readInventory(sources);
+					if ("code" in inventory) throw new DeviceAdmissionRefusal(inventory);
+					const keys = inventoryKeys(inventory);
+					const own = deviceKey(device.platform, device.key);
+					const ownBooting = inventory.booting.some((entry) => deviceKey(entry.platform, entry.key) === own);
+					if (device.platform === "ios" && keys.has(own) || ownBooting) return admit();
+					keys.delete(own);
+					if (keys.size < max && turn) return admit();
+					lastListed = now();
+					lastInventory = {
+						count: keys.size,
+						holders: deviceHolders(inventory, keys)
+					};
+					return wait(lastInventory);
+				}, lockWaitMs, out, signal);
+				if ("marker" in result) {
+					marker = result.marker;
+					signal?.throwIfAborted();
+					break;
+				}
+				signal?.throwIfAborted();
+				const elapsedMs = now() - started;
+				visibleWait = true;
+				waitingFor({
+					kind: "device-slot",
+					inUse: result.count,
+					max,
+					since: new Date(started).toISOString()
+				});
+				if (now() - lastLine >= 1e4) {
+					lastLine = now();
+					out(deviceSlotWaitingLine({
+						count: result.count,
+						max,
+						holders: result.holders,
+						elapsedMs,
+						queue: result.queue
+					}));
+				}
+				if (result.reclaim && now() - lastReclaim >= 15e3) {
+					lastReclaim = now();
+					try {
+						const minutes = projectDeviceReclaimIdleMinutes(canonicalPath(root));
+						if (minutes > 0) reclaimed += await reclaimIdleDevice(root, minutes * 6e4, out, now, skippedReclaims);
+					} catch (error) {
+						out(phaseLine("device", `could not reclaim an idle device: ${error?.message || error}`));
+					}
+				}
+				await sleep(Math.min(2e3, Math.max(0, waitMs - elapsedMs)));
+			}
+		} catch (error) {
+			if (error instanceof DeviceAdmissionRefusal && error.code === "STIM_AT_CAPACITY") recordCapacityRefusal({
+				platform: device.platform,
+				max,
+				workspace
+			}, now());
+			throw error;
+		} finally {
+			(0, ownership_claim_exports.releaseClaim)(ticket);
+			if (visibleWait) waitingFor(null);
+			if (started !== void 0) {
+				const ms = Math.max(0, Math.round(now() - started));
+				recordCapacityWait({
+					platform: device.platform,
+					ms,
+					max,
+					workspace,
+					...reclaimed ? { reclaimed } : {}
+				}, now());
+				onWait(ms);
+			}
+		}
+		return await boot();
+	} finally {
+		(0, ownership_claim_exports.releaseClaim)(marker);
+	}
+}
+function deviceTypeMismatch(recordedTypeId, requestedName, deviceTypes) {
+	if (!requestedName || !recordedTypeId) return null;
+	const wanted = (deviceTypes || []).find((d) => d.name === requestedName);
+	if (!wanted) return null;
+	if (wanted.identifier === recordedTypeId) return null;
+	const recorded = (deviceTypes || []).find((d) => d.identifier === recordedTypeId);
+	return `this project's sim is ${recorded ? recorded.name : recordedTypeId}, but --device-type asked for ${requestedName}`;
+}
+function runtimeMismatch(recordedRuntimeId, requested, runtimes) {
+	if (!requested || !recordedRuntimeId) return null;
+	const wanted = runtimes.find((r) => iosRuntimeMatches(r, requested));
+	if (!wanted || wanted.identifier === recordedRuntimeId) return null;
+	return `this project's sim runs iOS ${parseRuntimeVersion(recordedRuntimeId)}, but --runtime asked for ${requested}`;
+}
+function installedNames(names) {
+	const unique = [...new Set(names.filter((n) => typeof n === "string" && n !== ""))];
+	return unique.length > 0 ? unique.join(", ") : "none";
+}
+/** Appends which settings layer supplied an unresolved device selector, so the user knows where to fix it. */
+function layerNote(refusal, key, flag, origin) {
+	if (flag !== void 0 && flag !== null) return refusal;
+	if (!origin) return refusal;
+	return {
+		message: `${refusal.message} ${key} is set at the ${origin} layer.`,
+		remedy: `${refusal.remedy} Fix it with \`stim settings set ${key} <value> --scope ${origin}\` or \`stim settings unset ${key} --scope ${origin}\`.`
+	};
+}
+function unknownIosRuntimeRefusal(requested, runtimes) {
+	if (!requested) return null;
+	if ((runtimes || []).some((r) => iosRuntimeMatches(r, requested))) return null;
+	return {
+		message: `No installed simulator runtime matches "${requested}". Installed runtimes: ${installedNames((runtimes || []).map((r) => r.version))}.`,
+		remedy: "Pass `--runtime` (or set ios.runtime) a version printed above (\"26.5\") or a runtime's full name (\"iOS 26.5\"); nothing else matches. Install more runtimes through Xcode."
+	};
+}
+function creatableIosDeviceTypeNames(runtimes, runtime) {
+	return (runtime ? (runtimes || []).filter((r) => iosRuntimeMatches(r, runtime)) : runtimes || []).flatMap((r) => (r.supportedDeviceTypes || []).map((d) => d.name));
+}
+function unknownIosDeviceTypeRefusal(requested, runtimes, runtime) {
+	if (!requested) return null;
+	const creatable = creatableIosDeviceTypeNames(runtimes, runtime);
+	if (creatable.includes(requested)) return null;
+	return {
+		message: `No device type named "${requested}" can be created on ${runtime ? `runtime ${runtime}` : "any installed simulator runtime"}. ${runtime ? `Device types runtime ${runtime} supports` : "Device types the installed runtimes support"}: ${installedNames(creatable)}.`,
+		remedy: "Pass `--device-type` (or set ios.deviceType) one of the names printed above, exactly as `xcrun simctl list devicetypes` spells it. `xcrun simctl list devicetypes` also lists watchOS, tvOS and visionOS models, which no iOS runtime can create. Install more models through Xcode."
+	};
+}
+function unknownAndroidSystemImageRefusal(requested, images) {
+	if (!requested) return null;
+	if ((images || []).some((i) => i.pkg === requested)) return null;
+	return {
+		message: `No installed Android system image is named "${requested}". Installed system images: ${installedNames((images || []).map((i) => i.pkg))}.`,
+		remedy: "Pass `--system-image` (or set android.systemImage) to one of the package ids printed above. Install more with `sdkmanager \"system-images;android-36;google_apis;arm64-v8a\"`."
+	};
+}
+function unknownAndroidDeviceProfileRefusal(requested, profiles) {
+	if (!requested) return null;
+	if (profiles.includes(requested)) return null;
+	return {
+		message: `No Android hardware profile is named "${requested}". Profiles avdmanager offers: ${installedNames(profiles)}.`,
+		remedy: "Pass `--device-profile` (or set android.deviceProfile) to one of the ids printed above, exactly as `avdmanager list device -c` spells it, e.g. \"pixel_fold\" or \"pixel_tablet\"."
+	};
+}
+//#endregion
+export { deviceTypeMismatch as a, runtimeMismatch as c, unknownIosDeviceTypeRefusal as d, unknownIosRuntimeRefusal as f, countLiveOwnedDevices as i, unknownAndroidDeviceProfileRefusal as l, DeviceAdmissionRefusal as n, layerNote as o, withDeviceBootAdmission as p, checkDeviceCapacity as r, peekDeviceSlots as s, DEFAULT_DEVICE_SLOT_WAIT_MS as t, unknownAndroidSystemImageRefusal as u };