stim 1.8.0 → 1.10.0

package/dist/{device-RdujjHLB.mjs → device-DhTZe7L4.mjs}

@@ -1,10 +1,10 @@
-import { B as validateDeviceSlot } from "./config-B7iyKWkL.mjs";
-import { a as findProjectRoot } from "./project-DDZWf_16.mjs";
-import { E as memoizeEmulatorProbe, L as resolvePhysicalDevice, M as physicalDeviceModel, P as probeEmulatorSerial, S as listAdbDevices, a as androidPoolNoCandidatesRefusal, i as androidPoolCandidates } from "./android-DWssqHQ8.mjs";
-import { r as clockTime } from "./command-output-B3ycpsYv.mjs";
-import { f as takeLease, l as releaseWorkspaceLeases, n as fileLeaseIo, o as parseLeaseDuration } from "./device-lease-Ffz_M5t0.mjs";
-import { d as waitForDevice, s as parseDeviceWait, t as selectFromPool } from "./device-pool-BxRwdufO.mjs";
-import { c as listIosDevices, o as iosPoolCandidates, s as iosPoolNoCandidatesRefusal, u as resolveIosPhysicalDevice } from "./ios-device-CauFJiYx.mjs";
+import { V as parseDeviceSlotOption } from "./config-BEq0Qw_a.mjs";
+import { o as findProjectRoot, t as NO_PROJECT_REFUSAL } from "./project-BXZzOABt.mjs";
+import { r as clockTime } from "./command-output-D5z2_bcF.mjs";
+import { n as fileLeaseIo, o as parseLeaseDuration, p as takeLease, u as releaseWorkspaceLeases } from "./device-lease-CbEaIk7b.mjs";
+import { B as resolvePhysicalDevice, F as physicalDeviceModel, L as probeEmulatorSerial, O as memoizeEmulatorProbe, a as androidPoolNoCandidatesRefusal, i as androidPoolCandidates, w as listAdbDevices } from "./android-787HhP5w.mjs";
+import { d as waitForDevice, s as parseDeviceWait, t as selectFromPool } from "./device-pool-Di8Q-9Ro.mjs";
+import { a as iosPoolCandidates, c as listIosDevices, o as iosPoolNoCandidatesRefusal, s as isWirelessIosDevice, u as resolveIosPhysicalDevice } from "./ios-device-CtRdEVjx.mjs";
 import chalk from "chalk";
 //#region src/commands/device.ts
 const DEFAULT_FOR = "5m";
@@ -69,7 +69,8 @@ async function poolDevice(platform, idLabel, waitSeconds, deadline, root, d, slo
 		idLabel,
 		list: () => platform === "ios" ? iosPoolCandidates(d.listIosDevices()).map((entry) => ({
 			id: entry.udid,
-			name: entry.name
+			name: entry.name,
+			fallback: isWirelessIosDevice(entry)
 		})) : androidPoolCandidates(d.listAdbDevices(), isEmulator).map((entry) => ({ id: entry.serial })),
 		noCandidates: () => {
 			const resolved = platform === "ios" ? iosPoolNoCandidatesRefusal(d.listIosDevices()) : androidPoolNoCandidatesRefusal(d.listAdbDevices(), isEmulator);
@@ -121,11 +122,7 @@ async function runLock(platformArg, idArg, opts = {}, overrides = {}) {
 		remedy: "Run `stim device lock ios` or `stim device lock android`."
 	});
 	const root = d.findProjectRoot(process.cwd());
-	if (!root) return report({
-		code: "STIM_NO_PROJECT",
-		message: "Not in a React Native project (no package.json found).",
-		remedy: "Run this from the app directory -- the one holding package.json."
-	});
+	if (!root) return report(NO_PROJECT_REFUSAL);
 	const durationText = String(opts.for ?? DEFAULT_FOR).trim();
 	const duration = parseLeaseDuration(durationText);
 	if ("error" in duration) return report({
@@ -224,11 +221,7 @@ async function runUnlock(platformArg, opts = {}, overrides = {}) {
 		remedy: "Run `stim device unlock` for every lease this workspace holds, or name one platform."
 	});
 	const root = d.findProjectRoot(process.cwd());
-	if (!root) return report({
-		code: "STIM_NO_PROJECT",
-		message: "Not in a React Native project (no package.json found).",
-		remedy: "Run this from the app directory -- the one holding package.json."
-	});
+	if (!root) return report(NO_PROJECT_REFUSAL);
 	const released = d.releaseLeases(root, {
 		platform,
 		...opts.slot ? { slot: opts.slot } : {}
@@ -243,10 +236,10 @@ async function runUnlock(platformArg, opts = {}, overrides = {}) {
 }
 function registerDevice(program, deps = {}) {
 	const device = program.command("device").description("Lease a connected physical device to this workspace, and give it back");
-	device.command("lock").argument("<platform>", "ios or android").argument("[id]", "the UDID or serial to lease; without one, the first free connected device is used").description("Lease a connected physical device to this workspace for a declared time, so another workspace's `--device` run waits instead of installing over it. Nothing but this command and a `--device` run moves the expiry.").option("--for <duration>", `How long to hold it: a whole number of seconds or minutes from 10s to 30m (default ${DEFAULT_FOR})`).option("--wait <seconds>", "How long to wait for a device another workspace holds, before refusing with STIM_DEVICE_BUSY (default 60, 0 refuses at once)").option("--slot <name>", "Use this workspace device slot", validateDeviceSlot).option("--json", "print the lease as JSON on stdout").action(async (platform, id, opts) => {
+	device.command("lock").argument("<platform>", "ios or android").argument("[id]", "the UDID or serial to lease; without one, the first free connected device is used").description("Lease a connected physical device to this workspace for a declared time, so another workspace's `--device` run waits instead of installing over it. Nothing but this command and a `--device` run moves the expiry.").option("--for <duration>", `How long to hold it: a whole number of seconds or minutes from 10s to 30m (default ${DEFAULT_FOR})`).option("--wait <seconds>", "How long to wait for a device another workspace holds, before refusing with STIM_DEVICE_BUSY (default 60, 0 refuses at once)").option("--slot <name>", "Use this workspace device slot", parseDeviceSlotOption).option("--json", "print the lease as JSON on stdout").action(async (platform, id, opts) => {
 		if ("code" in await runLock(platform, id, opts, deps)) process.exit(1);
 	});
-	device.command("unlock").argument("[platform]", "ios or android; without one, every lease this workspace holds is released").description("Release the device lease or leases this workspace holds. Releasing nothing is not an error.").option("--slot <name>", "Use this workspace device slot", validateDeviceSlot).option("--json", "print the released leases as JSON on stdout").action(async (platform, opts) => {
+	device.command("unlock").argument("[platform]", "ios or android; without one, every lease this workspace holds is released").description("Release the device lease or leases this workspace holds. Releasing nothing is not an error.").option("--slot <name>", "Use this workspace device slot", parseDeviceSlotOption).option("--json", "print the released leases as JSON on stdout").action(async (platform, opts) => {
 		const result = await runUnlock(platform, opts, deps);
 		if (!Array.isArray(result)) process.exit(1);
 	});

package/dist/{build-lock-CgtsB6TV.mjs → device-lease-CbEaIk7b.mjs}

@@ -1,14 +1,15 @@
-import { t as getExecutor } from "./exec-B29XNuhP.mjs";
-import { E as ownership_claim_exports, u as getConfigDir } from "./config-B7iyKWkL.mjs";
-import { r as register } from "./cache-manifest-CYJi8-Hx.mjs";
-import { l as sharedBuildCache } from "./workspace-state-BT5E3SA2.mjs";
-import { a as formatElapsed } from "./command-output-B3ycpsYv.mjs";
-import { existsSync, readFileSync, readdirSync, statSync } from "node:fs";
-import { createHash } from "node:crypto";
-import { join } from "node:path";
+import { B as parseDeviceSlotKey, R as deviceSlotKey, W as validateDeviceSlot, k as ownership_claim_exports, u as getConfigDir } from "./config-BEq0Qw_a.mjs";
+import { t as getExecutor } from "./exec-DK8KaVHK.mjs";
+import { r as register } from "./cache-manifest-Pubfp8wV.mjs";
+import { P as withDirLock, S as sharedBuildCache, _ as withWorkspaceStateLock, m as readWorkspaceState, p as clearWorkspaceStateKeys, y as writeWorkspaceState } from "./metro-BWLOJ_Wr.mjs";
+import { r as stopDeclaringSpawnsOn, t as declareSpawnsOn } from "./spawn-claims-CUleC2cM.mjs";
+import { a as formatElapsed, i as formatDuration, m as shortHash } from "./command-output-D5z2_bcF.mjs";
+import { existsSync, mkdirSync, readFileSync, readdirSync, renameSync, rmSync, statSync, writeFileSync } from "node:fs";
 import { existsSync as existsSync$1, mkdirSync as mkdirSync$1, readFileSync as readFileSync$1, rmSync as rmSync$1, writeFileSync as writeFileSync$1 } from "fs";
-import { join as join$1 } from "path";
+import { join } from "path";
 import { buildCacheKey, resolveArtifact, storeArtifact } from "@stim-cli/core";
+import { join as join$1 } from "node:path";
+import { createHash, randomBytes } from "node:crypto";
 import * as expoFingerprint from "@expo/fingerprint";
 import { buildUploadTimeoutMs } from "@stim-cli/cache";
 const ASSET_MANIFEST_FILE = "assets-manifest.json";
@@ -34,7 +35,7 @@ function readAssetManifest(root) {
 			return;
 		}
 		for (const name of names) {
-			const child = join(abs, name);
+			const child = join$1(abs, name);
 			let stat;
 			try {
 				stat = statSync(child);
@@ -106,16 +107,16 @@ function pickGeneratedResDir(names, variant, reactChildren = []) {
 	return null;
 }
 function androidModuleDirs(root, { list = safeList } = {}) {
-	const android = join(root, "android");
-	return ["app", ...list(android).filter((name) => name !== "app" && existsSync(join(android, name, "build", "generated", "res"))).toSorted()];
+	const android = join$1(root, "android");
+	return ["app", ...list(android).filter((name) => name !== "app" && existsSync(join$1(android, name, "build", "generated", "res"))).toSorted()];
 }
 function findGeneratedResDir(root, variant, { list = safeList } = {}) {
 	for (const module of androidModuleDirs(root, { list })) {
-		const base = join(root, "android", module, "build", "generated", "res");
+		const base = join$1(root, "android", module, "build", "generated", "res");
 		const names = list(base);
 		if (names.length === 0) continue;
-		const picked = pickGeneratedResDir(names, variant, names.includes("react") ? list(join(base, "react")) : []);
-		if (picked) return join(base, ...picked.split("/"));
+		const picked = pickGeneratedResDir(names, variant, names.includes("react") ? list(join$1(base, "react")) : []);
+		if (picked) return join$1(base, ...picked.split("/"));
 	}
 	return null;
 }
@@ -157,7 +158,7 @@ function safeList(dir) {
 //#endregion
 //#region src/cache/build-cache.ts
 function entryDir(platform, key, root = sharedBuildCache()) {
-	return join$1(root, platform, key);
+	return join(root, platform, key);
 }
 const FINGERPRINT_PLATFORMS = /* @__PURE__ */ new Set(["ios", "android"]);
 /**
@@ -209,17 +210,17 @@ function storeBuild(platform, key, buildPath, rootOrOptions = {}) {
 		overwrite: Boolean(options.overwrite),
 		writeMetadata: (staging) => {
 			if (Array.isArray(options.sources)) try {
-				writeFileSync$1(join$1(staging, SOURCES_FILE), JSON.stringify(options.sources));
+				writeFileSync$1(join(staging, SOURCES_FILE), JSON.stringify(options.sources));
 			} catch {}
 			if (options.assetManifest) try {
-				writeFileSync$1(join$1(staging, ASSET_MANIFEST_FILE), JSON.stringify(options.assetManifest));
+				writeFileSync$1(join(staging, ASSET_MANIFEST_FILE), JSON.stringify(options.assetManifest));
 			} catch {}
 		}
 	});
 }
 const PROVIDER_DOWNLOAD_DIR = "cache-provider";
 function providerDownloadPath(workspacePath) {
-	return join$1(workspacePath, PROVIDER_DOWNLOAD_DIR);
+	return join(workspacePath, PROVIDER_DOWNLOAD_DIR);
 }
 /**
 * Empties and registers the scratch directory a provider downloads into. It is
@@ -275,7 +276,7 @@ function providerUploadOutcome(result, name) {
 const SOURCES_FILE = "fingerprint-sources.json";
 function storedSources(platform, key, root = sharedBuildCache()) {
 	try {
-		const parsed = JSON.parse(readFileSync$1(join$1(entryDir(platform, key, root), SOURCES_FILE), "utf-8"));
+		const parsed = JSON.parse(readFileSync$1(join(entryDir(platform, key, root), SOURCES_FILE), "utf-8"));
 		return Array.isArray(parsed) ? parsed : null;
 	} catch {
 		return null;
@@ -283,7 +284,7 @@ function storedSources(platform, key, root = sharedBuildCache()) {
 }
 function storedAssetManifest(platform, key, root = sharedBuildCache()) {
 	try {
-		return parseAssetManifest(readFileSync$1(join$1(entryDir(platform, key, root), ASSET_MANIFEST_FILE), "utf-8"));
+		return parseAssetManifest(readFileSync$1(join(entryDir(platform, key, root), ASSET_MANIFEST_FILE), "utf-8"));
 	} catch {
 		return null;
 	}
@@ -424,7 +425,7 @@ function fingerprintDiffRecord({ changed, previousHash, hash }) {
 }
 //#endregion
 //#region src/engine/build-lock.ts
-const LOCK_SUFFIX = ".lock";
+const LOCK_SUFFIX$1 = ".lock";
 const WAIT_POLL_MS = 1e3;
 const WAIT_PROGRESS_MS = 3e4;
 const WAIT_CEILING_MS = 54e5;
@@ -435,10 +436,10 @@ function segment(value) {
 	return String(value).replace(/[^A-Za-z0-9._-]+/g, "-").replace(/^\.+/, "") || "unknown";
 }
 function buildLocksDir() {
-	return join(getConfigDir(), "build-locks");
+	return join$1(getConfigDir(), "build-locks");
 }
 function buildLockPath(platform, key) {
-	return join(buildLocksDir(), `${segment(platform)}-${segment(key)}${LOCK_SUFFIX}`);
+	return join$1(buildLocksDir(), `${segment(platform)}-${segment(key)}${LOCK_SUFFIX$1}`);
 }
 function label(platform) {
 	return `${platform} build`;
@@ -482,6 +483,7 @@ function acquireBuildLock({ platform, key, root = null, logFile = null }) {
 			},
 			claim: attempt.acquired
 		};
+		declareSpawnsOn(attempt.acquired);
 		return reaped ? {
 			...handle,
 			tookOver: toRecord(reaped)
@@ -495,6 +497,7 @@ function acquireBuildLock({ platform, key, root = null, logFile = null }) {
 	} : { path };
 }
 function releaseBuildLock(handle) {
+	stopDeclaringSpawnsOn(handle?.claim);
 	return (0, ownership_claim_exports.releaseClaim)(handle?.claim);
 }
 function listBuildLocks() {
@@ -507,8 +510,8 @@ function listBuildLocks() {
 	}
 	const locks = [];
 	for (const name of names) {
-		if (!name.endsWith(LOCK_SUFFIX)) continue;
-		const path = join(dir, name);
+		if (!name.endsWith(LOCK_SUFFIX$1)) continue;
+		const path = join$1(dir, name);
 		try {
 			if (!statSync(path).isDirectory()) continue;
 		} catch {
@@ -600,5 +603,456 @@ async function waitForBuild({ platform, key, resolve = resolveBuild, intervalMs
 		await sleep(intervalMs);
 	}
 }
+async function waitForSharedBuild({ platform, key, fingerprint, root, logFile, command, acquire, wait, now, phase, warn, out }) {
+	const waitStarted = now();
+	let failedHolder;
+	let released = null;
+	for (;;) {
+		let attempt = null;
+		try {
+			attempt = acquire({
+				platform,
+				key,
+				root,
+				logFile
+			});
+		} catch (err) {
+			const refusal = (0, ownership_claim_exports.claimFailure)(err, command);
+			if (refusal) return { refusal };
+			warn(`could not take the build lock: ${err?.message || err}; building anyway`);
+		}
+		if (attempt?.acquired) {
+			const previous = attempt.tookOver ?? failedHolder;
+			if (previous) warn(takeoverLine(previous));
+			return {
+				refusal: null,
+				lock: attempt,
+				hit: null,
+				released
+			};
+		}
+		if (!attempt?.held) return {
+			refusal: null,
+			lock: null,
+			hit: null,
+			released
+		};
+		released = null;
+		const holder = attempt.held;
+		const who = holder.projectRoot || "another workspace";
+		phase(`${who} is already building ${shortHash(fingerprint)} (pid ${holder.pid})${holder.logFile ? ` -- tail ${holder.logFile}` : ""} -- stim guide lifecycle concurrency`);
+		let waited;
+		try {
+			const ceilingMs = WAIT_CEILING_MS - (now() - waitStarted);
+			if (ceilingMs <= 0) throw Object.assign(/* @__PURE__ */ new Error(`Waited ${formatDuration(now() - waitStarted)} for shared builds without an artifact; ${who} (pid ${holder.pid}) holds ${attempt.path}.`), {
+				code: "STIM_BUILD_WAIT_TIMEOUT",
+				lockPath: attempt.path
+			});
+			waited = await wait({
+				platform,
+				key,
+				out,
+				ceilingMs
+			});
+		} catch (err) {
+			const refusal = (0, ownership_claim_exports.claimFailure)(err, command);
+			if (refusal) return { refusal };
+			const timeout = err;
+			if (timeout?.code !== "STIM_BUILD_WAIT_TIMEOUT") throw err;
+			return { refusal: {
+				code: "STIM_BUILD_WAIT_TIMEOUT",
+				message: timeout.message,
+				remedy: `Check pid ${holder.pid}; if it is not really building, remove ${timeout.lockPath} and run \`${command}\` again.`
+			} };
+		}
+		if (waited.hit) {
+			phase(`waited ${formatDuration(waited.waitedMs)} for ${who}'s build -> installed from cache -- stim guide lifecycle concurrency`);
+			return {
+				refusal: null,
+				lock: null,
+				hit: {
+					path: waited.hit,
+					waited: {
+						pid: holder.pid,
+						ms: waited.waitedMs
+					}
+				},
+				released
+			};
+		}
+		if (waited.lockReleased) {
+			failedHolder = void 0;
+			released = {
+				facts: {
+					pid: holder.pid,
+					ms: waited.waitedMs
+				},
+				who
+			};
+			phase(`${who}'s build lock was released; rechecking this workspace before building`);
+		} else {
+			warn(`${who}'s build ended without an artifact (${waited.builderFailed}); retrying the build lock`);
+			failedHolder = holder;
+		}
+	}
+}
+const DEFAULT_LEASE_MS = 3e5;
+const LEASE_SUFFIX = ".json";
+const LOCK_SUFFIX = ".lock";
+const DURATION = /^[1-9][0-9]*(s|m)$/;
+function deviceLocksDir() {
+	return join$1(getConfigDir(), "device-locks");
+}
+function leaseStem(platform, id) {
+	return `${segment(platform)}-${segment(id)}`;
+}
+function deviceLeasePath(platform, id) {
+	return join$1(deviceLocksDir(), `${leaseStem(platform, id)}${LEASE_SUFFIX}`);
+}
+function deviceLeaseLockPath(platform, id) {
+	return join$1(deviceLocksDir(), `${leaseStem(platform, id)}${LOCK_SUFFIX}`);
+}
+const fileLeaseIo = {
+	withHolderLock: withWorkspaceStateLock,
+	now: () => Date.now(),
+	readLease(path) {
+		try {
+			return readFileSync(path, "utf-8");
+		} catch {
+			return null;
+		}
+	},
+	writeLease(path, body) {
+		mkdirSync(deviceLocksDir(), { recursive: true });
+		const tmp = `${path}.tmp-${process.pid}-${randomBytes(4).toString("hex")}`;
+		writeFileSync(tmp, body);
+		try {
+			renameSync(tmp, path);
+		} catch (error) {
+			rmSync(tmp, { force: true });
+			throw error;
+		}
+	},
+	removeLease(path) {
+		rmSync(path, { force: true });
+	},
+	listLeaseNames() {
+		try {
+			return readdirSync(deviceLocksDir());
+		} catch {
+			return [];
+		}
+	},
+	withLeaseLock(lockPath, fn) {
+		return withDirLock(lockPath, fn, { ensureParent: () => mkdirSync(deviceLocksDir(), { recursive: true }) });
+	},
+	readHolder(root) {
+		return parseWorkspaceLeases(readWorkspaceState(root)?.deviceLeases);
+	},
+	writeHolder(root, leases) {
+		if (Object.keys(leases).length === 0) clearWorkspaceStateKeys(root, ["deviceLeases"]);
+		else writeWorkspaceState(root, { deviceLeases: leases });
+	}
+};
+function text(value) {
+	return typeof value === "string" && value.trim() !== "" ? value : null;
+}
+function isPlatform(value) {
+	return value === "ios" || value === "android";
+}
+function parseLease(raw) {
+	if (typeof raw !== "string") return null;
+	let parsed;
+	try {
+		parsed = JSON.parse(raw);
+	} catch {
+		return null;
+	}
+	if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) return null;
+	const entry = parsed;
+	if (entry.version !== 1 || !isPlatform(entry.platform)) return null;
+	const id = text(entry.id);
+	const holder = text(entry.holder);
+	const token = text(entry.token);
+	const expiresAt = text(entry.expiresAt);
+	if (!id || !holder || !token || !expiresAt || !Number.isFinite(Date.parse(expiresAt))) return null;
+	if (entry.slot !== void 0) {
+		if (typeof entry.slot !== "string") return null;
+		try {
+			validateDeviceSlot(entry.slot);
+		} catch {
+			return null;
+		}
+	}
+	return {
+		version: 1,
+		...typeof entry.slot === "string" ? { slot: entry.slot } : {},
+		platform: entry.platform,
+		id,
+		deviceName: text(entry.deviceName),
+		holder,
+		token,
+		grantedAt: text(entry.grantedAt),
+		expiresAt
+	};
+}
+function parseWorkspaceLeases(value) {
+	if (!value || typeof value !== "object" || Array.isArray(value)) return {};
+	const leases = {};
+	for (const [platform, entry] of Object.entries(value)) {
+		if (!parseDeviceSlotKey(platform) || !entry || typeof entry !== "object") continue;
+		const record = entry;
+		const id = text(record.id);
+		const token = text(record.token);
+		if (!id || !token) continue;
+		leases[platform] = {
+			id,
+			token,
+			kind: record.kind === "run" ? "run" : "declared"
+		};
+	}
+	return leases;
+}
+function leaseIsExpired(lease, now) {
+	return Date.parse(lease.expiresAt) <= now;
+}
+function parseLeaseDuration(value) {
+	const raw = String(value ?? "").trim();
+	const match = DURATION.exec(raw);
+	if (!match) return { error: `--for must be a whole number of seconds or minutes, such as 90s or 5m (got "${raw}").` };
+	const ms = Number(raw.slice(0, -1)) * (match[1] === "s" ? 1e3 : 6e4);
+	if (ms < 1e4 || ms > 18e5) return { error: `--for must be between 10s and 30m (got "${raw}").` };
+	return { ms };
+}
+function listLeaseFiles(io = fileLeaseIo) {
+	const dir = deviceLocksDir();
+	const entries = [];
+	for (const name of io.listLeaseNames().toSorted()) {
+		if (!name.endsWith(LEASE_SUFFIX)) continue;
+		const path = join$1(dir, name);
+		const lease = parseLease(io.readLease(path));
+		const stem = name.slice(0, -5);
+		const cut = stem.indexOf("-");
+		entries.push({
+			path,
+			name,
+			platform: lease?.platform ?? (cut > 0 ? stem.slice(0, cut) : stem),
+			id: lease?.id ?? (cut > 0 ? stem.slice(cut + 1) : null),
+			lease
+		});
+	}
+	return entries;
+}
+function writeLease(lease, io) {
+	io.writeLease(deviceLeasePath(lease.platform, lease.id), `${JSON.stringify(lease, null, 2)}\n`);
+	return lease;
+}
+function takeLease({ root, platform, slot = "default", id, deviceName = null, kind, durationMs = DEFAULT_LEASE_MS }, io = fileLeaseIo) {
+	return withHolderLock(io, root, () => {
+		const key = deviceSlotKey(platform, slot);
+		const previous = io.readHolder(root)[key];
+		if (previous && previous.id !== id) releaseHeld(root, platform, previous, io, slot);
+		for (const entry of listLeaseFiles(io)) {
+			const other = entry.lease;
+			if (!other || other.platform !== platform || other.holder !== root || (other.slot ?? "default") !== slot || other.id === id) continue;
+			releaseByRoot(root, platform, other.id, io);
+		}
+		const declared = previous?.kind === "declared" && previous.id === id;
+		const path = deviceLeasePath(platform, id);
+		const result = io.withLeaseLock(deviceLeaseLockPath(platform, id), () => {
+			const now = io.now();
+			const raw = io.readLease(path);
+			const current = parseLease(raw);
+			if (raw !== null && !current) return {
+				status: "unreadable",
+				path
+			};
+			const asked = now + durationMs;
+			if (current && !leaseIsExpired(current, now)) {
+				if (current.holder !== root || (current.slot ?? "default") !== slot) return {
+					status: "held",
+					lease: current
+				};
+				const floor = declared && kind === "run" ? Math.max(asked, Date.parse(current.expiresAt)) : asked;
+				return {
+					status: "set",
+					lease: writeLease({
+						...current,
+						deviceName: deviceName ?? current.deviceName,
+						expiresAt: new Date(floor).toISOString()
+					}, io)
+				};
+			}
+			const expiresAt = new Date(asked).toISOString();
+			return {
+				status: "taken",
+				lease: writeLease({
+					version: 1,
+					...slot === "default" ? {} : { slot },
+					platform,
+					id,
+					deviceName,
+					holder: root,
+					token: randomBytes(12).toString("hex"),
+					grantedAt: new Date(now).toISOString(),
+					expiresAt
+				}, io)
+			};
+		});
+		if (result.status === "taken" || result.status === "set") {
+			const recorded = result.status === "set" && declared ? "declared" : kind;
+			io.writeHolder(root, {
+				...io.readHolder(root),
+				[key]: {
+					id,
+					token: result.lease.token,
+					kind: recorded
+				}
+			});
+		}
+		return result;
+	});
+}
+function raiseLease({ root, platform, slot = "default", minMs }, io = fileLeaseIo) {
+	const record = io.readHolder(root)[deviceSlotKey(platform, slot)];
+	if (!record) return { status: "none" };
+	const path = deviceLeasePath(platform, record.id);
+	return io.withLeaseLock(deviceLeaseLockPath(platform, record.id), () => {
+		const current = parseLease(io.readLease(path));
+		if (!current || current.token !== record.token) return {
+			status: "lost",
+			lease: current
+		};
+		const floor = io.now() + minMs;
+		if (Date.parse(current.expiresAt) >= floor) return {
+			status: "raised",
+			lease: current
+		};
+		return {
+			status: "raised",
+			lease: writeLease({
+				...current,
+				expiresAt: new Date(floor).toISOString()
+			}, io)
+		};
+	});
+}
+function summarize(lease) {
+	return {
+		platform: lease.platform,
+		id: lease.id,
+		deviceName: lease.deviceName,
+		expiresAt: lease.expiresAt
+	};
+}
+function releaseHeld(root, platform, record, io, slot = "default") {
+	const key = deviceSlotKey(platform, slot);
+	const path = deviceLeasePath(platform, record.id);
+	const released = io.withLeaseLock(deviceLeaseLockPath(platform, record.id), () => {
+		const current = parseLease(io.readLease(path));
+		if (!current || current.token !== record.token) return null;
+		io.removeLease(path);
+		return current;
+	});
+	const held = io.readHolder(root);
+	if (held[key]?.token === record.token) {
+		delete held[key];
+		io.writeHolder(root, held);
+	}
+	return released;
+}
+function releaseByRoot(root, platform, id, io) {
+	const path = deviceLeasePath(platform, id);
+	return io.withLeaseLock(deviceLeaseLockPath(platform, id), () => {
+		const current = parseLease(io.readLease(path));
+		if (!current || current.holder !== root) return null;
+		io.removeLease(path);
+		return current;
+	});
+}
+function releaseRunLease({ root, platform, slot = "default" }, io = fileLeaseIo) {
+	return withHolderLock(io, root, () => {
+		const record = io.readHolder(root)[deviceSlotKey(platform, slot)];
+		if (!record || record.kind !== "run") return null;
+		const released = releaseHeld(root, platform, record, io, slot);
+		return released ? summarize(released) : null;
+	});
+}
+function releaseWorkspaceLeases(root, { platform = null, slot = null } = {}, io = fileLeaseIo) {
+	return withHolderLock(io, root, () => {
+		const released = [];
+		for (const [name, record] of Object.entries(io.readHolder(root))) {
+			const parsed = parseDeviceSlotKey(name);
+			if (!parsed || platform && parsed.platform !== platform || slot !== null && parsed.slot !== slot) continue;
+			const lease = releaseHeld(root, parsed.platform, record, io, parsed.slot);
+			if (lease) released.push(summarize(lease));
+		}
+		for (const entry of listLeaseFiles(io)) {
+			const lease = entry.lease;
+			if (!lease || lease.holder !== root) continue;
+			if (platform && lease.platform !== platform) continue;
+			if (slot !== null && (lease.slot ?? "default") !== slot) continue;
+			const byRoot = releaseByRoot(root, lease.platform, lease.id, io);
+			if (byRoot) released.push(summarize(byRoot));
+		}
+		return released;
+	});
+}
+function removeExpiredLease(entry, io = fileLeaseIo) {
+	const lease = entry.lease;
+	if (!lease) return false;
+	return io.withLeaseLock(deviceLeaseLockPath(lease.platform, lease.id), () => {
+		const current = parseLease(io.readLease(entry.path));
+		if (!current || !leaseIsExpired(current, io.now())) return false;
+		io.removeLease(entry.path);
+		return true;
+	});
+}
+function selectPoolDevice({ candidates, leases, held = null, now }) {
+	const ordered = candidates.toSorted((a, b) => {
+		const left = a.id.toLowerCase();
+		const right = b.id.toLowerCase();
+		return left < right ? -1 : left > right ? 1 : 0;
+	});
+	if (held) {
+		const mine = ordered.find((candidate) => candidate.id === held);
+		return mine ? {
+			status: "selected",
+			candidate: mine
+		} : {
+			status: "held-disconnected",
+			id: held
+		};
+	}
+	const preferred = ordered.filter((candidate) => !candidate.fallback);
+	const pool = preferred.length > 0 ? preferred : ordered;
+	if (pool.length === 0) return { status: "none" };
+	const byId = new Map(leases.map((lease) => [lease.id, lease]));
+	const free = (candidate) => {
+		const lease = byId.get(candidate.id);
+		return !lease || leaseIsExpired(lease, now);
+	};
+	const holders = [];
+	for (const candidate of pool) {
+		if (free(candidate)) return {
+			status: "selected",
+			candidate
+		};
+		const lease = byId.get(candidate.id);
+		holders.push({
+			id: lease.id,
+			holder: lease.holder,
+			expiresAt: lease.expiresAt
+		});
+	}
+	return {
+		status: "busy",
+		holders,
+		spare: ordered.filter((candidate) => candidate.fallback && free(candidate)).map((candidate) => candidate.id)
+	};
+}
+function withHolderLock(io, root, fn) {
+	return io.withHolderLock ? io.withHolderLock(root, fn) : fn();
+}
 //#endregion
-export { untrackedNativeFiles as C, readAssetManifest as D, compareAssetManifests as E, untrackedMissLine as S, captureAssetManifest as T, providerUploadOutcome as _, segment as a, storeBuild as b, buildCacheKey as c, filesystemBuildCapability as d, fingerprintDiffRecord as f, providerDownloadPath as g, prepareProviderDownloadDir as h, releaseBuildLock as i, describeFingerprintMiss as l, fingerprintProject as m, acquireBuildLock as n, takeoverLine as o, fingerprintDiffSuffix as p, listBuildLocks as r, waitForBuild as s, WAIT_CEILING_MS as t, diffFingerprintSources as u, refingerprintAfterMutation as v, assetDiffReason as w, storedAssetManifest as x, resolveBuild as y };
+export { resolveBuild as A, fingerprintDiffRecord as C, providerDownloadPath as D, prepareProviderDownloadDir as E, assetDiffReason as F, captureAssetManifest as I, compareAssetManifests as L, storedAssetManifest as M, untrackedMissLine as N, providerUploadOutcome as O, untrackedNativeFiles as P, readAssetManifest as R, filesystemBuildCapability as S, fingerprintProject as T, waitForBuild as _, parseLease as a, describeFingerprintMiss as b, raiseLease as c, removeExpiredLease as d, selectPoolDevice as f, releaseBuildLock as g, listBuildLocks as h, listLeaseFiles as i, storeBuild as j, refingerprintAfterMutation as k, releaseRunLease as l, acquireBuildLock as m, fileLeaseIo as n, parseLeaseDuration as o, takeLease as p, leaseIsExpired as r, parseWorkspaceLeases as s, deviceLeasePath as t, releaseWorkspaceLeases as u, waitForSharedBuild as v, fingerprintDiffSuffix as w, diffFingerprintSources as x, buildCacheKey as y };