stim 1.34.0 → 1.35.0

package/dist/{ccache-ChBMXlBq.mjs → device-capacity-C0PiTyRb.mjs}

@@ -1,24 +1,24 @@
 import { C as operationState, D as ownership_claim_exports, E as debugLog, S as isTermination, T as process_identity_exports, d as throwIfCancelled, f as WorkspaceProcessCleanupError, l as cancellableSleep, m as workspaceProcessLockError, n as isTimeoutError, p as withWorkspaceProcessLock, t as getExecutor, u as cancelledError } from "./exec-CGuDzt40.mjs";
-import { D as workspaceId$1, E as workspaceDir, M as withDirLock$1, b as sharedCcache$1, d as writeWorkspaceState, j as workspaceStateFile$1, k as workspaceLogsDir$1, l as withWorkspaceStateLockAsync, r as readWorkspaceState$1, t as clearWorkspaceStateKey, y as sharedBuildCache } from "./workspace-state-BdZ-QgmB.mjs";
+import { D as workspaceId$1, E as workspaceDir, M as withDirLock$1, b as sharedCcache$1, d as writeWorkspaceState, j as workspaceStateFile$1, k as workspaceLogsDir$1, l as withWorkspaceStateLockAsync, r as readWorkspaceState$1, s as updateWorkspaceStateAsync, t as clearWorkspaceStateKey, y as sharedBuildCache } from "./workspace-state-BdZ-QgmB.mjs";
 import { n as stripAnsi } from "./process-output-Fpl8PYi8.mjs";
-import { a as formatElapsed, l as phaseLine, o as formatLongDuration, s as isAppLaunchError, u as plural } from "./command-output-DjExb_tZ.mjs";
-import { a as clearDevice, at as isOnMountedVolume, ct as volumeRootFor, d as getConfigDir, ft as deviceSlotPlatforms, ht as projectDeviceSlots, k as withConfigLockAsync$1, m as getProject, nt as directorySizeAsync, o as clearSupervisor, rt as formatBytes, st as measuredDirectorySizeAsync, tt as directorySize, v as loadConfig$1 } from "./config-BW0fAtoK.mjs";
+import { a as formatElapsed, l as phaseLine, o as formatLongDuration, s as isAppLaunchError, u as plural } from "./command-output-CGxrQ3Bd.mjs";
+import { a as clearDevice, at as isOnMountedVolume, ct as volumeRootFor, d as getConfigDir, dt as deviceSlotKey, ft as deviceSlotPlatforms, ht as projectDeviceSlots, k as withConfigLockAsync$1, m as getProject, nt as directorySizeAsync, o as clearSupervisor, p as getPlatformDeviceLimits, rt as formatBytes, st as measuredDirectorySizeAsync, tt as directorySize, u as getConcurrencyLimits, v as loadConfig$1 } from "./config-BW0fAtoK.mjs";
 import { a as killOnAbort, n as runOperationFileQuiet, r as childEnvironment, t as runOperationFile } from "./operation-exec-DKlBcKAL.mjs";
-import { Z as resolveProjectSettingsAsync, d as androidLayoutSetting, ft as planMetroReach, m as defaultAndroidLayout } from "./settings-B5IBDfTx.mjs";
-import { C as resolvePackageJson, M as readMetroTunnel, N as readPidFile, P as readRemoteSession, i as findProjectRoot$1, j as clearWorkspaceSupervisor, k as clearRemoteSession, s as ownedDeviceLabel, v as detectIsExpo } from "./project-DU3jjnBE.mjs";
-import { R as listAvdsAsync, U as ownedAvdDirectory, X as parseAvdSystemImage, Y as parseAvdDeviceProfile, d as androidToolPath, ft as isStimOwnedAvd, gt as dropParked, m as avdIniPaths, o as androidHome, pt as isStimOwnedSim, q as ownedAvdSerialResolverAsync, xt as readParked, y as avdStorageRoots, z as listInstalledSystemImages } from "./android-Iq0M2t2d.mjs";
+import { Z as resolveProjectSettingsAsync, d as androidLayoutSetting, ft as planMetroReach, g as deviceReclaimIdleMinutesSetting, m as defaultAndroidLayout } from "./settings-B5IBDfTx.mjs";
+import { C as resolvePackageJson, M as readMetroTunnel, N as readPidFile, P as readRemoteSession, i as findProjectRoot$1, j as clearWorkspaceSupervisor, k as clearRemoteSession, s as ownedDeviceLabel, v as detectIsExpo } from "./project-Dqqj3IkW.mjs";
+import { N as listAdbDevices, P as listAdbDevicesAsync, R as listAvdsAsync, U as ownedAvdDirectory, X as parseAvdSystemImage, Y as parseAvdDeviceProfile, d as androidToolPath, ft as isStimOwnedAvd, gt as dropParked, m as avdIniPaths, o as androidHome, pt as isStimOwnedSim, q as ownedAvdSerialResolverAsync, xt as readParked, y as avdStorageRoots, z as listInstalledSystemImages } from "./android-Iq0M2t2d.mjs";
 import { a as listeningPidsAsync, c as pidExists, d as resolveProjectMetro, h as isMetroRunning, r as killMetroTreeAsync, u as processCwds } from "./metro-B5PVz0Wv.mjs";
 import { c as readNdjsonGenerations$1, i as createNdjsonWriter, r as createNdjsonTail } from "./ndjson-CrjIsGzw.mjs";
-import { T as formatSpace, a as removeEasSessionClaim, d as parseWatchRoots, f as parseWatchmanClients, i as recordEasSessionClaim, l as parseSubscriberNames, n as easMachineStateRoot$1, o as removeEasSessionClaimAsync, p as parseWatchmanPid, r as readEasSessionLedger$1, s as compareStimVersions, t as assertEasMachineRootWritable, u as parseTriggerCount, w as environmentState, y as capacity } from "./eas-session-ledger-CXwagcQ7.mjs";
+import { T as formatSpace, a as removeEasSessionClaim, d as parseWatchRoots, f as parseWatchmanClients, i as recordEasSessionClaim, l as parseSubscriberNames, n as easMachineStateRoot$1, o as removeEasSessionClaimAsync, p as parseWatchmanPid, r as readEasSessionLedger$1, s as compareStimVersions, t as assertEasMachineRootWritable, u as parseTriggerCount, w as environmentState, y as capacity } from "./eas-session-ledger-DCUfh6m7.mjs";
 import { i as registeredCaches, r as register } from "./cache-manifest-8JX9S1QJ.mjs";
-import { At as mapLimited, B as workspaceBuildInProgress, Dt as createGcResults, Et as GC_OUTPUT, F as collectOwnedDeviceActivityAsync, L as idleShutdownCandidates, Mt as sizeConcurrency, N as collectIdleDevicesAsync, _t as teardownParkedIosSim, bt as measureDu, dt as eraseParkedIosSim, gt as teardownParkedAvd, ht as teardownOwnedIosSim, i as clearWorkspaceOutputs, l as keptByLock, o as collectWorkspaceOutputs, pt as teardownOwnedAvd, ut as eraseParkedAvd, v as withIdleWorkspace, vt as probePublicHttp, wt as listBuildSlots, x as resolveSupervisorTarget, xt as writeUsageCache, yt as canonical$1, z as shutDownIdleDevices } from "./workspaces-B9v5V7Es.mjs";
+import { At as mapLimited, B as workspaceBuildInProgress, Dt as createGcResults, Et as GC_OUTPUT, F as collectOwnedDeviceActivityAsync, L as idleShutdownCandidates, Mt as sizeConcurrency, N as collectIdleDevicesAsync, P as collectOwnedDeviceActivity, _t as teardownParkedIosSim, bt as measureDu, dt as eraseParkedIosSim, gt as teardownParkedAvd, ht as teardownOwnedIosSim, i as clearWorkspaceOutputs, l as keptByLock, o as collectWorkspaceOutputs, ot as recordCapacityRefusal, pt as teardownOwnedAvd, st as recordCapacityWait, ut as eraseParkedAvd, v as withIdleWorkspace, vt as probePublicHttp, wt as listBuildSlots, x as resolveSupervisorTarget, xt as writeUsageCache, yt as canonical$1, z as shutDownIdleDevices$1 } from "./workspaces-CY3KSdC0.mjs";
 import { t as canonicalPath } from "./paths-BsJMoPP2.mjs";
-import { $ as readBundleSchemes, Z as approvableSchemes, _t as runCancellationSignal, bt as claimForEmptying, mt as nativeRunWaitNotice } from "./toolchain-CYonNjd_.mjs";
-import { N as listBuildLocks, b as leaseIsExpired, g as workspaceActivity, o as envDir, p as readHostProcessTableAsync, x as listLeaseFiles } from "./activity-DkS-Ir6V.mjs";
-import { u as expoConfigContents } from "./build-cache-Cqj4FGnX.mjs";
-import { G as deviceHoldsBundle, O as sanitizeDeviceLabel, W as deviceHoldsApk, b as parseSimctlList, f as listAllIosSimsAsync, g as listUserApps, j as uninstallIosApp, p as listIosDeviceTypesAsync, u as iosSimulatorFailureAdvice, y as parseRuntimeVersion } from "./ios-BdZdNsAj.mjs";
+import { $ as readBundleSchemes, Z as approvableSchemes, _t as runCancellationSignal, bt as claimForEmptying, mt as nativeRunWaitNotice } from "./toolchain-DRQyCvlp.mjs";
+import { N as listBuildLocks, _ as workspaceDeviceLastUseAt, b as leaseIsExpired, g as workspaceActivity, o as envDir, p as readHostProcessTableAsync, x as listLeaseFiles } from "./activity-BQpJpAjA.mjs";
+import { u as expoConfigContents } from "./build-cache-_fkewiwH.mjs";
+import { G as deviceHoldsBundle, O as sanitizeDeviceLabel, W as deviceHoldsApk, b as parseSimctlList, d as listAllIosSims, f as listAllIosSimsAsync, g as listUserApps, j as uninstallIosApp, l as iosRuntimeMatches, p as listIosDeviceTypesAsync, u as iosSimulatorFailureAdvice, y as parseRuntimeVersion } from "./ios-BdZdNsAj.mjs";
 import { n as supervisorError } from "./errors-DHm_U5gv.mjs";
-import { c as findBinUpward, n as expoBinFromPackage, r as expoBinPath, s as expoTelemetryEnv } from "./server-expo-CUJ2fuv1.mjs";
+import { c as findBinUpward, n as expoBinFromPackage, r as expoBinPath, s as expoTelemetryEnv } from "./server-expo-CjQwxvIi.mjs";
 import { t as DEV_MENU_LAUNCH_ARGS } from "./ios-device-DLdEDWJj.mjs";
 import { t as resolveMaintenanceSettings } from "./settings-D9LtQaUw.mjs";
 import { createRequire } from "node:module";
@@ -26,12 +26,13 @@ import { createHash, randomUUID } from "node:crypto";
 import { closeSync, existsSync, lstatSync, mkdirSync, openSync, readFileSync, readSync, readdirSync, realpathSync, renameSync, rmSync, statSync, statfsSync, unlinkSync, writeFileSync } from "node:fs";
 import { homedir, platform, totalmem } from "node:os";
 import { basename, dirname, isAbsolute, join, relative, resolve, sep } from "node:path";
-import { LOG_ROTATE_BYTES, METRO_NAMED_CACHE_LAYOUT, ambientContext, cacheDirRefusal, compiledHelper, configDir, ensurePrivateDir, rotatedLogPath, withAmbientContext, withDirLock } from "@stim-cli/core";
-import { DEV_SERVER_STOP_REQUEST_KEY, MACHINE_OWNER_KINDS, MAINTENANCE_LOG_NAME, budgetSweepFile, budgetSweepLock, buildWorkerRoot, gcLogFile, isJsonObject, loadConfig, machineCacheUsageFile, maintenanceNdjsonFile, readCreatedDevices, readDevServerStop, readDevServerStopRequest, readJsonObject, readMachineCacheUsage, runId, settingDefinition, settingValueError, workspaceLogsDir } from "@stim-cli/core/state";
+import { LOG_ROTATE_BYTES, METRO_NAMED_CACHE_LAYOUT, ambientContext, cacheDirRefusal, compiledHelper, configDir, ensurePrivateDir, rotatedLogPath, withAmbientContext, withDirLock, workspaceId } from "@stim-cli/core";
+import { DEVICE_IDLE_SHUTDOWN_KEY, DEVICE_RECLAIM_REASON, DEV_SERVER_STOP_REQUEST_KEY, MACHINE_OWNER_KINDS, MAINTENANCE_LOG_NAME, automaticMachineEnabled, budgetSweepFile, budgetSweepLock, buildWorkerRoot, gcLogFile, isJsonObject, loadConfig, machineCacheUsageFile, maintenanceNdjsonFile, readCreatedDevices, readDevServerStop, readDevServerStopRequest, readDeviceIdleShutdowns, readJsonObject, readMachineCacheUsage, runId, settingDefinition, settingValueError, workspaceLogsDir } from "@stim-cli/core/state";
 import { basename as basename$1, dirname as dirname$1, isAbsolute as isAbsolute$1, join as join$1, relative as relative$1, resolve as resolve$1 } from "path";
 import chalk from "chalk";
 import { existsSync as existsSync$1, readFileSync as readFileSync$1, readdirSync as readdirSync$1, realpathSync as realpathSync$1, rmSync as rmSync$1, statSync as statSync$1 } from "fs";
 import { fileURLToPath } from "node:url";
+import { setTimeout as setTimeout$1 } from "node:timers/promises";
 import { access, lstat, readFile, readdir, rm, stat, statfs } from "node:fs/promises";
 import { homedir as homedir$1, tmpdir as tmpdir$1 } from "os";
 //#region src/budget-sweep.ts
@@ -7775,7 +7776,7 @@ function estimateMemoryUse({ config, sims, androidSerial, supervisorRunning }) {
 		liveWorkspaces: liveCount
 	};
 }
-async function listSims(signal, operation) {
+async function listSims$1(signal, operation) {
 	try {
 		return await listAllIosSimsAsync({
 			timeoutMs: DEVICE_LIST_TIMEOUT_MS,
@@ -7811,7 +7812,7 @@ async function readMemoryUse(simSnapshot, signal, operation) {
 		operation
 	});
 	const config = loadConfig$1();
-	const sims = simSnapshot && !signal ? await snapshotSims(simSnapshot) : await listSims(signal, operation);
+	const sims = simSnapshot && !signal ? await snapshotSims(simSnapshot) : await listSims$1(signal, operation);
 	signal?.throwIfAborted();
 	const serials = /* @__PURE__ */ new Map();
 	for (const record of Object.values(config?.projects ?? {})) for (const { platforms } of projectDeviceSlots(record)) {
@@ -7869,7 +7870,7 @@ async function reclaimIdleDevices({ root, dryRun, note, record, now, env, signal
 	const other = isOtherWorkspace(root);
 	const collect = async (at) => {
 		signal?.throwIfAborted();
-		const devices = await collectIdleDevicesAsync(loadConfig$1(), await listSims(signal, operation) ?? [], [], at, env, signal, operation);
+		const devices = await collectIdleDevicesAsync(loadConfig$1(), await listSims$1(signal, operation) ?? [], [], at, env, signal, operation);
 		signal?.throwIfAborted();
 		return idleShutdownCandidates(devices.filter((device) => other(device.project)), 0);
 	};
@@ -7878,7 +7879,7 @@ async function reclaimIdleDevices({ root, dryRun, note, record, now, env, signal
 		targets: idle.map(deviceLabel),
 		failures: 0
 	};
-	const { failures, shutDown } = await shutDownIdleDevices(idle, 0, () => collect(Date.now()), stepOutput(note, record), signal, operation);
+	const { failures, shutDown } = await shutDownIdleDevices$1(idle, 0, () => collect(Date.now()), stepOutput(note, record), signal, operation);
 	return {
 		targets: shutDown.map(deviceLabel),
 		failures
@@ -7903,7 +7904,7 @@ async function reclaimIdleDevServers({ root, dryRun, note, record, now, env, sig
 		targets: [],
 		failures: 0
 	};
-	const sims = await listSims(signal, operation);
+	const sims = await listSims$1(signal, operation);
 	signal?.throwIfAborted();
 	if (sims === null) {
 		note(chalk.dim(phaseLine("budget", "dev servers left alone: simulators could not be listed to prove them idle")));
@@ -8473,4 +8474,986 @@ function resolveCcache({ root, layout = defaultAndroidLayout(root), dir = shared
 	};
 }
 //#endregion
-export { gradleVersionLines as $, memorySweepIsScoped as $n, INSTALL_ERROR as $t, diskPressureLevel as A, loadProjectProvider as An, ensureRemoteBootOwned as At, includesArchives as B, MIN_EAS_CLI_DEVICE_VERSION as Bn, RELEASE_VERIFY_WAIT_MS as Bt, devServerStopLevel as C, runProcessOperation as Cn, describeError as Ct, requestDevServerStop as D, checkEasAuth as Dn, bundleEntryPoint as Dt, metroLastStop as E, cacheLevel as En, binOnPath as Et, gcOptionsOf as F, resolveRemote as Fn, withEasProjectLock as Ft, planCacheEmptying as G, parseArchiveSelector as Gn, unattributedLaunchLines as Gt, includesRecordings as H, easCliSupport as Hn, isBundleProof as Ht, maintenanceItem as I, uploadRemote as In, LAUNCH_BUNDLING as It, selectsBeyondCaches as J, collectMemoryReport as Jn, verifyLaunch as Jt, previewScopedEmptying as K, GRADLE_DAEMONS_KIND as Kn, unverifiedLaunchLines as Kt, openGcLog as L, bundleInvocation as Ln, LAUNCH_FATAL as Lt, levelStillShort as M, providerFromConfig as Mn, remoteAndroidDeps as Mt, lowestFree as N, readProjectConfig as Nn, remoteIosDeps as Nt, vanishedSupervisorMessage as O, easAuthNote as On, endRecordedSession as Ot, protectWindowMs as P, resolveEasCliBin as Pn, resolveRemoteContext as Pt, deleteGradleVersions as Q, memoryScope as Qn, DEFAULT_METRO_PORT as Qt, maintenanceLogger as R, remoteCliInvocation as Rn, LAUNCH_UNVERIFIED as Rt, describeMetroLastStop as S, processContext as Sn, deleteEasSessions as St, logVanishedSupervisor as T, UPLOAD_TIMEOUT_MS as Tn, REMOTE_SESSION_ERROR as Tt, includesWorkspaceOutputs as U, easCliUpgradeRemedy as Un, readCollectorRecords as Ut, includesParkedDevices as V, MIN_EAS_CLI_SIMULATOR_VERSION as Vn, VERIFY_TIMEOUT_MS as Vt, isWorkspacesScope as W, ownedSessionName as Wn, readMetroRecords as Wt, collectGradleVersions as X, memoryCacheKind as Xn, APP_READINESS_TIMEOUT_MS as Xt, trimCaches as Y, inspectWatchmanMemory as Yn, verifyReleaseLaunch as Yt, deleteGradleVersion as Z, memoryLines as Zn, ADB_INSTALL_TIMEOUT_MS as Zt, resolveBudget as _, reverseMetroPorts as _n, findStaleDeviceRecords as _t, projectCmakeLauncher as a, devClientUrl as an, attributeMachineUsage as ar, DEVICE_LIST_TIMEOUT_MS$1 as at, stopOwnedMetroForReset as b, gateMetroOrigin as bn, withAndroidAvdSizes as bt, budgetGate as c, hasMetroReverse as cn, pruneCache as cr, collectParkedSims as ct, enforceBudget as d, installIosApp as dn, deleteProjectDevices as dt, IOS_DEV_MENU_OFF_DEFAULTS_PLIST as en, memoryWorkPending as er, gradleVersionsPending as et, inspectBudget as f, iosAppProcess as fn, describeParkedSims as ft, readVolumeSpaceAsync as g, restartedAppNote as gn, findOrphanedDevices as gt, readVolumeSpace as h, launchIosApp as hn, eraseParkedDevices as ht, ccacheInstallCommand as i, clearOtherUserApps as in, phase as ir, collectInventory as it, levelFloors as j, ownerFromConfig as jn, readInstalledEasCliVersionAsync as jt, withdrawDevServerStopRequest as k, isEasAuthFailureText as kn, ensureMetroReachable as kt, budgetLine as l, installAndroidApp as ln, sizeCaches as lr, deleteParkedAvds as lt, peekBudget as m, launchAndroidReleaseApp as mn, deviceSweepIsScoped as mt, CCACHE_UNAVAILABLE as n, androidDevClientUrl as nn, scopedMemoryReport as nr, waitForGradleExit as nt, readCcacheActivity as o, deviceShellArg as on, readFootprints as or, collectDeviceLeases as ot, machineNumber as p, launchAndroidApp as pn, describeUnverifiableDevices as pt, selectCaches as q, WATCHMAN_KIND as qn, verifyAndroidReleaseLaunch as qt, ccacheActivityLine as r, appProcessFromPid as rn, stopIdleGradleDaemons as rr, getMachineCacheReport as rt, resolveCcache as s, ensureMetroReverse as sn, discoverCaches as sr, collectParkedAvds as st, CCACHE_NOT_RUN as t, androidAppProcess as tn, reclaimMemory as tr, includesGradleVersions as tt, cacheLabel as u, installConflictKind as un, deleteParkedSims as ut, trimmableCaches as v, writeDebugHttpHost as vn, findStaleProjectDevices as vt, devServerStopRecord as w, RESOLVE_TIMEOUT_MS as wn, withRemoteSessionGcLocks as wt, describeDevServerStop as x, exitAfterFlush as xn, collectEasSessionSweep as xt, stopOwnedMetro as y, readRemoteSimulatorArch as yn, unverifiedDeviceCommand as yt, emptyCaches as z, remoteCommand as zn, MANIFEST_VERIFY_TIMEOUT_MS as zt };
+//#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/idle-shutdown.ts
+const SIM_LIST_TIMEOUT_MS = 1e4;
+const MINUTE_MS = 6e4;
+/**
+* How long a booted owned device has been idle, when that is at least `idleMs` and nothing keeps it in use: no
+* driver, Stim or agent-device lock, or unreadable activity evidence, no build in the workspace, and no activity
+* (including an open stim-server viewer) for `idleMs`. Null keeps the device running.
+*/
+function idleShutdownDueMs(activity, { idleMs, now, buildInProgress, platform = process.platform }) {
+	if (buildInProgress || activity.state === "driven") return null;
+	const unknown = platform === "win32" ? activity.basis.filter((basis) => basis !== "driver-process") : activity.basis;
+	if (activity.state === "unknown" && unknown.length > 0) return null;
+	const last = Date.parse(activity.lastActivityAt ?? "");
+	if (!Number.isFinite(last)) return null;
+	const idle = now - last;
+	return idle >= idleMs ? idle : null;
+}
+function listSims() {
+	try {
+		return listAllIosSims({ timeoutMs: SIM_LIST_TIMEOUT_MS });
+	} catch {
+		return [];
+	}
+}
+/** Booted owned devices idle for `idleMs`, in one workspace or all registered workspaces when root is absent. */
+function dueIdleDevices(root, idleMs, now = Date.now()) {
+	const config = loadConfig$1();
+	if (!config) return [];
+	const self = root === void 0 ? void 0 : canonicalPath(root);
+	const projects = Object.fromEntries(Object.entries(config.projects).filter(([path]) => {
+		if (self !== void 0 && canonicalPath(path) !== self) return false;
+		const usedAt = workspaceDeviceLastUseAt(path);
+		return !Number.isFinite(usedAt) || now - usedAt >= idleMs;
+	}));
+	if (!Object.keys(projects).length) return [];
+	const builds = new Map(Object.keys(projects).map((path) => [path, workspaceBuildInProgress(path)]));
+	return collectOwnedDeviceActivity({
+		...config,
+		projects
+	}, listSims(), now).flatMap((device) => {
+		const idleForMs = idleShutdownDueMs(device.activity, {
+			idleMs,
+			now,
+			buildInProgress: builds.get(device.project) ?? true
+		});
+		return idleForMs === null ? [] : [{
+			device,
+			idleForMs
+		}];
+	});
+}
+/** Appends an idle shutdown record to the workspace's metro.ndjson, where the supervisor writes its own. */
+function writeIdleShutdownEvent(root, event) {
+	const writer = createNdjsonWriter(join(workspaceLogsDir$1(root), "metro.ndjson"), { maxBytes: LOG_ROTATE_BYTES });
+	writer.write({
+		src: "metro",
+		...event
+	});
+	writer.close();
+}
+/**
+* Shuts down, through centralized teardown, each of the workspace's owned devices that is still idle for `idleMs`,
+* and records why. The caller holds the workspace's native-run lock, so no `ios` or `android` run is booting or
+* installing on them.
+*/
+async function shutDownIdleDevices(root, idleMs, log, now = Date.now(), { only, reason } = {}) {
+	let shutDown = 0;
+	for (const { device, idleForMs } of dueIdleDevices(root, idleMs, now)) {
+		if (only && (device.kind !== only.kind || device.id !== only.id || device.project !== only.project || device.slot !== only.slot)) continue;
+		const what = `${device.kind === "ios" ? "simulator" : "emulator"} ${device.name}`;
+		const outcome = device.kind === "ios" ? await teardownOwnedIosSim(device.id, {
+			label: device.name,
+			workspace: root
+		}) : await teardownOwnedAvd(device.id, {
+			owner: {
+				projectPath: device.project,
+				slot: device.slot
+			},
+			workspace: root
+		});
+		if (outcome.status === "torn-down") {
+			shutDown++;
+			const idleMinutes = Math.floor(idleForMs / MINUTE_MS);
+			try {
+				await updateWorkspaceStateAsync(root, (state) => ({
+					...state,
+					[DEVICE_IDLE_SHUTDOWN_KEY]: {
+						...readDeviceIdleShutdowns(state),
+						[deviceSlotKey(device.kind, device.slot)]: {
+							at: new Date(now).toISOString(),
+							idleMinutes,
+							...reason ? { reason } : {}
+						}
+					}
+				}));
+			} catch (error) {
+				log({
+					level: "warn",
+					event: "device_idle_shutdown_failed",
+					msg: `shut down idle ${what} but could not record it: ${error?.message || error}`
+				});
+			}
+			log({
+				level: "info",
+				event: "device_idle_shutdown",
+				msg: `shut down ${what}, idle ${formatLongDuration(idleForMs)}${reason === DEVICE_RECLAIM_REASON ? ", reclaimed for a waiting run" : ""}`
+			});
+		} else if (outcome.status !== "missing") log({
+			level: "warn",
+			event: "device_idle_shutdown_failed",
+			msg: `could not shut down idle ${what}: ${outcome.reason}`,
+			...outcome.status === "skipped" ? { skipped: true } : {}
+		});
+	}
+	return shutDown;
+}
+/** Forgets the slot's idle shutdown once a run boots its device again. */
+async function clearDeviceIdleShutdown(root, platform, slot = "default") {
+	const key = deviceSlotKey(platform, slot);
+	if (!(key in readDeviceIdleShutdowns(readWorkspaceState$1(root)))) return;
+	await updateWorkspaceStateAsync(root, (state) => {
+		const { [key]: _cleared, ...rest } = readDeviceIdleShutdowns(state);
+		const { [DEVICE_IDLE_SHUTDOWN_KEY]: _all, ...others } = state;
+		return Object.keys(rest).length ? {
+			...others,
+			[DEVICE_IDLE_SHUTDOWN_KEY]: rest
+		} : others;
+	});
+}
+//#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$1(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 { levelStillShort as $, providerFromConfig as $n, remoteAndroidDeps as $t, budgetLine as A, installAndroidApp as An, sizeCaches as Ar, deleteParkedAvds as At, stopOwnedMetro as B, readRemoteSimulatorArch as Bn, unverifiedDeviceCommand as Bt, CCACHE_UNAVAILABLE as C, androidDevClientUrl as Cn, scopedMemoryReport as Cr, waitForGradleExit as Ct, readCcacheActivity as D, deviceShellArg as Dn, readFootprints as Dr, collectDeviceLeases as Dt, projectCmakeLauncher as E, devClientUrl as En, attributeMachineUsage as Er, DEVICE_LIST_TIMEOUT_MS$1 as Et, peekBudget as F, launchAndroidReleaseApp as Fn, deviceSweepIsScoped as Ft, devServerStopRecord as G, RESOLVE_TIMEOUT_MS as Gn, withRemoteSessionGcLocks as Gt, describeDevServerStop as H, exitAfterFlush as Hn, collectEasSessionSweep as Ht, readVolumeSpace as I, launchIosApp as In, eraseParkedDevices as It, requestDevServerStop as J, checkEasAuth as Jn, bundleEntryPoint as Jt, logVanishedSupervisor as K, UPLOAD_TIMEOUT_MS as Kn, REMOTE_SESSION_ERROR as Kt, readVolumeSpaceAsync as L, restartedAppNote as Ln, findOrphanedDevices as Lt, enforceBudget as M, installIosApp as Mn, deleteProjectDevices as Mt, inspectBudget as N, iosAppProcess as Nn, describeParkedSims as Nt, resolveCcache as O, ensureMetroReverse as On, discoverCaches as Or, collectParkedAvds as Ot, machineNumber as P, launchAndroidApp as Pn, describeUnverifiableDevices as Pt, levelFloors as Q, ownerFromConfig as Qn, readInstalledEasCliVersionAsync as Qt, resolveBudget as R, reverseMetroPorts as Rn, findStaleDeviceRecords as Rt, CCACHE_NOT_RUN as S, androidAppProcess as Sn, reclaimMemory as Sr, includesGradleVersions as St, ccacheInstallCommand as T, clearOtherUserApps as Tn, phase as Tr, collectInventory as Tt, describeMetroLastStop as U, processContext as Un, deleteEasSessions as Ut, stopOwnedMetroForReset as V, gateMetroOrigin as Vn, withAndroidAvdSizes as Vt, devServerStopLevel as W, runProcessOperation as Wn, describeError as Wt, withdrawDevServerStopRequest as X, isEasAuthFailureText as Xn, ensureMetroReachable as Xt, vanishedSupervisorMessage as Y, easAuthNote as Yn, endRecordedSession as Yt, diskPressureLevel as Z, loadProjectProvider as Zn, ensureRemoteBootOwned as Zt, withDeviceBootAdmission as _, APP_READINESS_TIMEOUT_MS as _n, memoryCacheKind as _r, collectGradleVersions as _t, countLiveOwnedDevicesAsync as a, LAUNCH_UNVERIFIED as an, remoteCliInvocation as ar, maintenanceLogger as at, shutDownIdleDevices as b, INSTALL_ERROR as bn, memorySweepIsScoped as br, gradleVersionLines as bt, deviceSlotUsages as c, VERIFY_TIMEOUT_MS as cn, MIN_EAS_CLI_SIMULATOR_VERSION as cr, includesParkedDevices as ct, peekDeviceSlots as d, readMetroRecords as dn, ownedSessionName as dr, isWorkspacesScope as dt, remoteIosDeps as en, readProjectConfig as er, lowestFree as et, runtimeMismatch as f, unattributedLaunchLines as fn, parseArchiveSelector as fr, planCacheEmptying as ft, unknownIosRuntimeRefusal as g, verifyReleaseLaunch as gn, inspectWatchmanMemory as gr, trimCaches as gt, unknownIosDeviceTypeRefusal as h, verifyLaunch as hn, collectMemoryReport as hr, selectsBeyondCaches as ht, countLiveOwnedDevices as i, LAUNCH_FATAL as in, bundleInvocation as ir, openGcLog as it, cacheLabel as j, installConflictKind as jn, deleteParkedSims as jt, budgetGate as k, hasMetroReverse as kn, pruneCache as kr, collectParkedSims as kt, deviceTypeMismatch as l, isBundleProof as ln, easCliSupport as lr, includesRecordings as lt, unknownAndroidSystemImageRefusal as m, verifyAndroidReleaseLaunch as mn, WATCHMAN_KIND as mr, selectCaches as mt, DeviceAdmissionRefusal as n, withEasProjectLock as nn, resolveRemote as nr, gcOptionsOf as nt, countLiveOwnedDevicesByPlatform as o, MANIFEST_VERIFY_TIMEOUT_MS as on, remoteCommand as or, emptyCaches as ot, unknownAndroidDeviceProfileRefusal as p, unverifiedLaunchLines as pn, GRADLE_DAEMONS_KIND as pr, previewScopedEmptying as pt, metroLastStop as q, cacheLevel as qn, binOnPath as qt, checkDeviceCapacity as r, LAUNCH_BUNDLING as rn, uploadRemote as rr, maintenanceItem as rt, countLiveOwnedDevicesFrom as s, RELEASE_VERIFY_WAIT_MS as sn, MIN_EAS_CLI_DEVICE_VERSION as sr, includesArchives as st, DEFAULT_DEVICE_SLOT_WAIT_MS as t, resolveRemoteContext as tn, resolveEasCliBin as tr, protectWindowMs as tt, layerNote as u, readCollectorRecords as un, easCliUpgradeRemedy as ur, includesWorkspaceOutputs as ut, clearDeviceIdleShutdown as v, ADB_INSTALL_TIMEOUT_MS as vn, memoryLines as vr, deleteGradleVersion as vt, ccacheActivityLine as w, appProcessFromPid as wn, stopIdleGradleDaemons as wr, getMachineCacheReport as wt, writeIdleShutdownEvent as x, IOS_DEV_MENU_OFF_DEFAULTS_PLIST as xn, memoryWorkPending as xr, gradleVersionsPending as xt, dueIdleDevices as y, DEFAULT_METRO_PORT as yn, memoryScope as yr, deleteGradleVersions as yt, trimmableCaches as z, writeDebugHttpHost as zn, findStaleProjectDevices as zt };