stim 1.34.0 → 1.36.0

package/dist/device-capacity-CHC3dKWg.mjs

@@ -1,867 +0,0 @@
-import { D as ownership_claim_exports, m as workspaceProcessLockError, p as withWorkspaceProcessLock } from "./exec-CGuDzt40.mjs";
-import { a as formatElapsed, l as phaseLine } from "./command-output-DjExb_tZ.mjs";
-import { d as getConfigDir, ft as deviceSlotPlatforms, ht as projectDeviceSlots, k as withConfigLockAsync$1, p as getPlatformDeviceLimits, u as getConcurrencyLimits, v as loadConfig$1 } from "./config-BW0fAtoK.mjs";
-import { g as deviceReclaimIdleMinutesSetting } from "./settings-B5IBDfTx.mjs";
-import { N as listAdbDevices, P as listAdbDevicesAsync } from "./android-Iq0M2t2d.mjs";
-import { ot as recordCapacityRefusal, st as recordCapacityWait, v as withIdleWorkspace } from "./workspaces-B9v5V7Es.mjs";
-import { t as canonicalPath } from "./paths-BsJMoPP2.mjs";
-import { d as listAllIosSims, f as listAllIosSimsAsync, l as iosRuntimeMatches, y as parseRuntimeVersion } from "./ios-BdZdNsAj.mjs";
-import { i as writeIdleShutdownEvent, n as dueIdleDevices, r as shutDownIdleDevices } from "./idle-shutdown-DPD8oV36.mjs";
-import { realpathSync } from "node:fs";
-import { basename, join } from "node:path";
-import { workspaceId } from "@stim-cli/core";
-import { DEVICE_RECLAIM_REASON, automaticMachineEnabled } from "@stim-cli/core/state";
-import { setTimeout } from "node:timers/promises";
-//#region src/workspace/display-label.ts
-function baseLabel({ root, label }) {
-	return label || basename(root);
-}
-function pathSegments(root) {
-	return root.split(/[\\/]+/).filter(Boolean).toReversed();
-}
-function workspaceLabels(workspaces) {
-	const labels = /* @__PURE__ */ new Map();
-	const groups = /* @__PURE__ */ new Map();
-	for (const workspace of workspaces) {
-		const base = baseLabel(workspace);
-		const group = groups.get(base) ?? [];
-		if (!group.some(({ root }) => root === workspace.root)) group.push(workspace);
-		groups.set(base, group);
-	}
-	for (const [base, group] of groups) {
-		const [only] = group;
-		if (group.length === 1 && only) {
-			labels.set(only.root, base);
-			continue;
-		}
-		const segments = group.map(({ root }) => pathSegments(root));
-		const longest = Math.max(...segments.map((parts) => parts.length));
-		let depth = 0;
-		while (depth < longest && segments.every((parts) => parts[depth] === segments[0]?.[depth])) depth++;
-		const suffixes = segments.map((parts) => parts[depth]);
-		const distinct = new Set(suffixes).size === group.length;
-		group.forEach(({ root }, index) => {
-			const suffix = distinct ? suffixes[index] : root;
-			labels.set(root, suffix ? `${base} (${suffix})` : base);
-		});
-	}
-	return labels;
-}
-function workspaceDisplayLabel(root, config) {
-	const registered = Object.entries(config?.projects ?? {}).map(([path, project]) => ({
-		root: path,
-		label: project.label
-	}));
-	const own = registered.find((entry) => entry.root === root);
-	return workspaceLabels([...registered, own ?? { root }]).get(root) ?? basename(root);
-}
-//#endregion
-//#region src/devices/queue-reclaim.ts
-async function reclaimIdleDevice(root, idleMs, out, now, skipped, platform) {
-	try {
-		const self = canonicalPath(root);
-		const candidate = dueIdleDevices(void 0, idleMs, now()).filter(({ device }) => {
-			try {
-				return realpathSync(device.project) !== self;
-			} catch {
-				return false;
-			}
-		}).filter(({ device }) => !platform || device.kind === platform).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 = workspaceDisplayLabel(device.project, loadConfig$1());
-		const log = (event) => {
-			writeIdleShutdownEvent(device.project, event);
-			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
-	});
-}
-const PLATFORM_CAPS = {
-	ios: {
-		setting: "concurrency.maxIosDevices",
-		noun: "iOS simulator"
-	},
-	android: {
-		setting: "concurrency.maxAndroidDevices",
-		noun: "Android emulator"
-	}
-};
-function isCappedPlatform(platform) {
-	return platform === "ios" || platform === "android";
-}
-function platformCount(keys, platform) {
-	return [...keys].filter((key) => key.startsWith(`${platform}:`)).length;
-}
-/** The caps that apply to a boot on `platform` given the booted `keys`, the platform's own cap first. */
-function deviceLimits(keys, platform, max, platformMax) {
-	const limits = [];
-	if (platformMax > 0 && isCappedPlatform(platform)) limits.push({
-		...PLATFORM_CAPS[platform],
-		count: platformCount(keys, platform),
-		max: platformMax,
-		platform
-	});
-	if (max > 0) limits.push({
-		setting: "concurrency.maxDevices",
-		noun: "device",
-		count: keys.size,
-		max
-	});
-	return limits;
-}
-/** Whether a queued waiter is held back by its own platform cap, so it does not hold up the runs behind it. */
-function platformWalled(keys, waiter, platformMax) {
-	const platform = String(waiter.details.platform);
-	if (!isCappedPlatform(platform)) return false;
-	const cap = platformMax[platform] ?? 0;
-	return cap > 0 && platformCount(keys, platform) >= cap;
-}
-/** The first cap with no room left, or the first cap when all have room (for a run waiting behind another). */
-function bindingLimit(limits) {
-	return limits.find((limit) => limit.count >= limit.max) ?? limits[0];
-}
-function atCapacityRefusal({ count, max, setting, noun }) {
-	return {
-		code: "STIM_AT_CAPACITY",
-		message: count < max ? `${count}/${max} Stim ${noun}s are in use, but another run is ahead in the device slot queue.` : `${count} Stim ${noun}(s) are already booted and ${setting} is ${max}, so booting another would exceed the cap.`,
-		remedy: `stop an environment (stim stop) or raise ${setting}`
-	};
-}
-function uncountedRefusal(error) {
-	return {
-		code: "STIM_NO_DEVICE",
-		message: `A device cap (concurrency.maxDevices, concurrency.maxIosDevices or concurrency.maxAndroidDevices) 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 });
-	}
-}
-async function listedAwait(read, empty, absent = () => false) {
-	try {
-		return await read() ?? empty;
-	} catch (error) {
-		if (absent(error)) return empty;
-		throw new DeviceCountUnavailable("", { cause: error });
-	}
-}
-async function readInventoryAsync({ sims = () => process.platform === "darwin" ? listAllIosSimsAsync({ timeoutMs: LISTING_TIMEOUT_MS }) : [], adb = () => listAdbDevicesAsync({ timeoutMs: LISTING_TIMEOUT_MS }), config = loadConfig$1, booting = readBootingDevices }) {
-	try {
-		const recorded = await listedAwait(() => typeof config === "function" ? config() : config, null);
-		return {
-			booting: await listedAwait(() => typeof booting === "function" ? booting() : booting, []),
-			sims: await listedAwait(() => typeof sims === "function" ? sims() : sims, [], toolAbsent),
-			adb: recordsOwnedEmulator(recorded) ? await listedAwait(() => typeof adb === "function" ? adb() : 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;
-	}
-}
-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 = [] } = {}) {
-	const counts = countLiveOwnedDevicesByPlatform(sources, { exclude });
-	return "unknown" in counts ? counts : counts.ios + counts.android;
-}
-/** The counts of {@link countLiveOwnedDevices} split by platform. */
-function countLiveOwnedDevicesByPlatform(sources = {}, { exclude = [] } = {}) {
-	try {
-		const inventory = readInventory(sources);
-		if ("code" in inventory) return { unknown: inventory.message };
-		const keys = inventoryKeys(inventory, exclude);
-		return {
-			ios: platformCount(keys, "ios"),
-			android: platformCount(keys, "android")
-		};
-	} catch (error) {
-		if ((0, ownership_claim_exports.isClaimRefusal)(error)) return { unknown: error.message };
-		throw error;
-	}
-}
-async function listedAsync(source, empty) {
-	try {
-		return await source();
-	} catch (error) {
-		if (toolAbsent(error)) return empty;
-		throw new DeviceCountUnavailable("", { cause: error });
-	}
-}
-async function countLiveOwnedDevicesFrom(sources, { exclude = [] } = {}) {
-	try {
-		const inventory = await readInventoryAsync(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;
-	}
-}
-async function countLiveOwnedDevicesAsync(operation) {
-	try {
-		operation.signal.throwIfAborted();
-		const config = loadConfig$1();
-		const booting = readBootingDevices();
-		const [sims, adb] = await Promise.all([process.platform === "darwin" ? listedAsync(() => listAllIosSimsAsync({ timeoutMs: LISTING_TIMEOUT_MS }), []) : [], recordsOwnedEmulator(config) ? listedAsync(() => listAdbDevicesAsync({ timeoutMs: LISTING_TIMEOUT_MS }), NO_ADB) : NO_ADB]);
-		operation.signal.throwIfAborted();
-		return countLiveOwnedDevices({
-			config,
-			booting,
-			sims,
-			adb
-		});
-	} catch (error) {
-		operation.signal.throwIfAborted();
-		if ((0, ownership_claim_exports.isClaimRefusal)(error)) return { unknown: error.message };
-		if (error instanceof DeviceCountUnavailable) return { unknown: uncountedRefusal(error.cause).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, platformMax, sims = [], adb = null, config = null, booting = [] } = {}) {
-	if (!(max && max > 0) && !(platformMax && platformMax > 0)) return null;
-	const adbEmulators = liveEmulatorPorts(adb ?? NO_ADB);
-	if (workspaceHasLiveDevice({
-		platform,
-		project,
-		slot,
-		sims,
-		adbEmulators
-	})) return null;
-	const full = deviceLimits(liveOwnedDeviceKeys({
-		sims,
-		adbEmulators,
-		config,
-		booting
-	}), platform ?? "", max ?? 0, platformMax ?? 0).find((limit) => limit.count >= limit.max);
-	return full ? {
-		...atCapacityRefusal(full),
-		max: full.max
-	} : null;
-}
-/**
-* 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.
-*/
-async function checkDeviceCapacity({ platform, project, slot = "default", max, platformMax = platform && isCappedPlatform(platform) ? getPlatformDeviceLimits()[platform] : 0, ...sources } = {}) {
-	if (!(max && max > 0) && !(platformMax && platformMax > 0)) return null;
-	let inventory;
-	try {
-		inventory = await readInventoryAsync(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,
-		platformMax,
-		...inventory
-	});
-}
-async function peekDeviceSlots({ platform, project, slot = "default", max = getConcurrencyLimits().maxDevices, platformMax = getPlatformDeviceLimits()[platform], sources = {} }) {
-	try {
-		const inventory = await readInventoryAsync(sources);
-		if ("code" in inventory) return {
-			count: null,
-			max,
-			queued: 0,
-			localLive: false
-		};
-		const owned = deviceSlotPlatforms(project, slot)?.[platform]?.owned === true;
-		const keys = inventoryKeys(inventory);
-		const limits = deviceLimits(keys, platform, max, platformMax);
-		const tightest = limits.length ? limits.reduce((a, b) => b.max - b.count < a.max - a.count ? b : a) : void 0;
-		return {
-			count: tightest?.count ?? keys.size,
-			max: tightest?.max ?? max,
-			queued: liveWaiters().filter((waiter) => !platformWalled(keys, waiter, {
-				...getPlatformDeviceLimits(),
-				[platform]: platformMax
-			})).length,
-			localLive: owned && workspaceHasLiveDevice({
-				platform,
-				project,
-				slot,
-				sims: inventory.sims,
-				adbEmulators: liveEmulatorPorts(inventory.adb)
-			}),
-			...tightest?.platform ? { limit: tightest.setting } : {}
-		};
-	} 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, setting }) {
-	return `${"device".padEnd(11)} waiting for a device slot (${count}/${max} in use${setting ? ` by ${setting}` : ""}${holders.length ? `: ${holders.join(", ")}` : ""}), ${formatElapsed(elapsedMs)} elapsed -- stim guide lifecycle concurrency${queue ? `; ${queue}` : ""}`;
-}
-function unrecordedHolder(label) {
-	return {
-		label,
-		workspace: null,
-		slot: null
-	};
-}
-function slotHolders(inventory, keys) {
-	const owners = /* @__PURE__ */ new Map();
-	const projects = Object.entries(inventory.config?.projects ?? {});
-	const labels = workspaceLabels(projects.map(([root, project]) => ({
-		root,
-		label: project.label
-	})));
-	for (const [root, project] of projects) {
-		const label = labels.get(root) ?? basename(root);
-		for (const { slot, platforms } of projectDeviceSlots(project)) {
-			if (platforms.ios?.deviceUdid) owners.set(deviceKey("ios", platforms.ios.deviceUdid), {
-				label,
-				workspace: root,
-				slot
-			});
-			if (platforms.android?.avdName) owners.set(deviceKey("android", platforms.android.avdName), {
-				label,
-				workspace: root,
-				slot
-			});
-		}
-	}
-	for (const sim of inventory.sims) {
-		const key = deviceKey("ios", sim.udid);
-		if (!owners.has(key)) owners.set(key, unrecordedHolder(sim.name));
-	}
-	const booting = /* @__PURE__ */ new Set();
-	for (const device of inventory.booting) {
-		const key = deviceKey(device.platform, device.key);
-		booting.add(key);
-		if (!owners.has(key)) owners.set(key, unrecordedHolder(device.displayName ?? device.key));
-	}
-	return [...keys].map((key) => {
-		const { label, workspace, slot } = owners.get(key) ?? unrecordedHolder(key.slice(key.indexOf(":") + 1));
-		const platform = key.startsWith("android:") ? "android" : "ios";
-		return booting.has(key) ? {
-			platform,
-			label,
-			workspace,
-			slot,
-			booting: true
-		} : {
-			platform,
-			label,
-			workspace,
-			slot
-		};
-	}).toSorted((a, b) => a.label.localeCompare(b.label) || a.platform.localeCompare(b.platform));
-}
-function deviceHolders(inventory, keys) {
-	return [...new Set(slotHolders(inventory, keys).map((holder) => holder.label))].toSorted();
-}
-/**
-* `concurrency.maxDevices` usage for status (the owned devices the cap counts and who holds each) and the usage of each
-* per-platform cap that is set, from one inventory read. `sims` is the listing status already read; an unknown count
-* reports why instead of failing.
-*/
-async function deviceSlotUsages(max, platformMax, sources = {}) {
-	const capped = [];
-	for (const platform of ["ios", "android"]) {
-		const cap = platformMax[platform] ?? 0;
-		if (cap > 0) capped.push([platform, cap]);
-	}
-	const platformDevices = (count) => capped.length ? { platformDevices: Object.fromEntries(capped.map(([platform, cap]) => [platform, {
-		max: cap,
-		...count(platform)
-	}])) } : {};
-	try {
-		const inventory = await readInventoryAsync(sources);
-		if ("code" in inventory) return {
-			...max > 0 ? { devices: {
-				max,
-				inUse: null,
-				unknown: inventory.message,
-				holders: []
-			} } : {},
-			...platformDevices(() => ({
-				inUse: null,
-				unknown: inventory.message
-			}))
-		};
-		const keys = inventoryKeys(inventory);
-		return {
-			...max > 0 ? { devices: {
-				max,
-				inUse: keys.size,
-				holders: slotHolders(inventory, keys)
-			} } : {},
-			...platformDevices((platform) => ({ inUse: platformCount(keys, platform) }))
-		};
-	} catch (error) {
-		if (!(0, ownership_claim_exports.isClaimRefusal)(error)) throw error;
-		return {
-			...max > 0 ? { devices: {
-				max,
-				inUse: null,
-				unknown: error.message,
-				holders: []
-			} } : {},
-			...platformDevices(() => ({
-				inUse: null,
-				unknown: error.message
-			}))
-		};
-	}
-}
-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 the device caps.`,
-		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 the device caps.`,
-			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, platformMax = getPlatformDeviceLimits(), sources = {}, lockWaitMs = ADMISSION_LOCK_WAIT_MS, out = () => {}, waitMs = DEFAULT_DEVICE_SLOT_WAIT_MS, noWait = false, automatic = false, displayName = workspaceDisplayLabel(root, loadConfig$1()), reclaimIdleMinutes = deviceReclaimIdleMinutesSetting({}), now = Date.now, signal, sleep = (ms) => setTimeout(ms, void 0, { signal }), waitingFor = () => {}, onWait = () => {}, onBootStart = () => {} }) {
-	const requireMembership = () => {
-		if (automatic && !automaticMachineEnabled("device", "local")) throw new DeviceAdmissionRefusal({
-			code: "STIM_HOSTING_REFUSED",
-			message: "local is disabled in this requester's automatic device pool.",
-			remedy: "Enable local in remote.devicePoolDisabled or select a machine explicitly."
-		});
-	};
-	signal?.throwIfAborted();
-	requireMembership();
-	const ownCap = isCappedPlatform(device.platform) ? platformMax[device.platform] ?? 0 : 0;
-	if (!(max > 0) && !(ownCap > 0)) {
-		onBootStart();
-		return boot();
-	}
-	const workspace = workspaceId(root);
-	device = {
-		...device,
-		workspace,
-		displayName
-	};
-	let ticket;
-	let marker;
-	let started;
-	let lastLine = -Infinity;
-	let visibleWait = false;
-	let lastInventory;
-	let lastTurn = false;
-	let binding;
-	let lastListed = -Infinity;
-	let reclaimed = 0;
-	let lastReclaim = -Infinity;
-	const skippedReclaims = /* @__PURE__ */ new Set();
-	try {
-		try {
-			for (;;) {
-				const result = await admissionTransaction(async () => {
-					signal?.throwIfAborted();
-					requireMembership();
-					const waiters = liveWaiters();
-					const first = waiters[0];
-					const mine = waiters.findIndex((holder) => holder.claimId === ticket?.claimId);
-					const ahead = mine < 0 ? waiters : waiters.slice(0, mine);
-					const admit = () => {
-						const admitted = takeBootMarker(device);
-						if ((0, ownership_claim_exports.releaseClaim)(ticket)) ticket = void 0;
-						return { marker: admitted };
-					};
-					const wait = ({ limit, holders }, turn) => {
-						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(limit));
-						if (started !== void 0 && now() - started >= waitMs) throw new DeviceAdmissionRefusal({
-							code: "STIM_AT_CAPACITY",
-							message: `Waited ${formatElapsed(now() - started)} for a device slot; ${limit.count}/${limit.max} Stim ${limit.noun}s are in use (${limit.setting}); ${queue}.`,
-							remedy: `Stop an environment (stim stop), retry with a longer --wait <seconds>, or raise ${limit.setting}.`
-						});
-						if (!ticket) {
-							ticket = takeWaitTicket(device, waiters);
-							started = now();
-						}
-						const firstOfPlatform = ahead.every((holder) => holder.details.platform !== device.platform);
-						return {
-							limit,
-							holders,
-							queue,
-							reclaim: turn && firstOfPlatform && limit.count >= limit.max
-						};
-					};
-					if (ticket && lastInventory && ahead.length > 0 && !lastTurn && 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, false);
-					}
-					const inventory = await readInventoryAsync(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);
-					const limits = deviceLimits(keys, device.platform, max, ownCap);
-					const turn = ahead.every((waiter) => platformWalled(keys, waiter, platformMax));
-					if (turn && limits.every((limit) => limit.count < limit.max)) return admit();
-					lastListed = now();
-					lastTurn = turn;
-					const limit = bindingLimit(limits);
-					if (!limit) return admit();
-					binding = limit;
-					lastInventory = {
-						limit,
-						holders: deviceHolders(inventory, limit.platform ? new Set([...keys].filter((key) => key.startsWith(`${limit.platform}:`))) : keys)
-					};
-					return wait(lastInventory, turn);
-				}, 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.limit.count,
-					max: result.limit.max,
-					since: new Date(started).toISOString()
-				});
-				if (now() - lastLine >= 1e4) {
-					lastLine = now();
-					out(deviceSlotWaitingLine({
-						count: result.limit.count,
-						max: result.limit.max,
-						holders: result.holders,
-						elapsedMs,
-						queue: result.queue,
-						...result.limit.platform ? { setting: result.limit.setting } : {}
-					}));
-				}
-				signal?.throwIfAborted();
-				if (result.reclaim && now() - lastReclaim >= 15e3) {
-					lastReclaim = now();
-					try {
-						if (reclaimIdleMinutes > 0) reclaimed += await reclaimIdleDevice(root, reclaimIdleMinutes * 6e4, out, now, skippedReclaims, result.limit.platform);
-					} 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") {
-				const at = now();
-				await withConfigLockAsync$1(() => recordCapacityRefusal({
-					platform: device.platform,
-					max: binding?.max ?? max,
-					workspace
-				}, at)).catch(() => {});
-			}
-			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));
-				const at = now();
-				await withConfigLockAsync$1(() => recordCapacityWait({
-					platform: device.platform,
-					ms,
-					max: binding?.max ?? max,
-					workspace,
-					...reclaimed ? { reclaimed } : {}
-				}, at)).catch(() => {});
-				onWait(ms);
-			}
-		}
-		requireMembership();
-		onBootStart();
-		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."
-	};
-}
-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 { withDeviceBootAdmission as _, countLiveOwnedDevicesAsync as a, deviceSlotUsages as c, peekDeviceSlots as d, runtimeMismatch as f, unknownIosRuntimeRefusal as g, unknownIosDeviceTypeRefusal as h, countLiveOwnedDevices as i, deviceTypeMismatch as l, unknownAndroidSystemImageRefusal as m, DeviceAdmissionRefusal as n, countLiveOwnedDevicesByPlatform as o, unknownAndroidDeviceProfileRefusal as p, checkDeviceCapacity as r, countLiveOwnedDevicesFrom as s, DEFAULT_DEVICE_SLOT_WAIT_MS as t, layerNote as u };