stim 0.0.0 → 1.1.0

package/dist/command-output-8wHMEde0.mjs

@@ -0,0 +1,289 @@
+import { n as stripAnsi } from "./process-output-C7IlIzd7.mjs";
+//#region src/launch-error-preview.ts
+function framePriority(frame, root) {
+	const normalized = frame.replaceAll("\\", "/");
+	if (/^\s*at (?:android\.|java\.|com\.android\.|dalvik\.)/.test(normalized)) return 2;
+	if (/(?:^|[/(\s])node_modules\//.test(normalized) || /\bnode:internal\//.test(normalized)) return 2;
+	const paths = [...normalized.matchAll(/(?:\(|@|\bat )([^()]+?\.(?:[cm]?[jt]sx?|swift|kt|java|mm?|cpp|cc|c|h))(?::\d+(?::\d+)?)?(?:\)|$)/g)];
+	for (const [, file] of paths) {
+		if (!file || /^https?:/.test(file)) continue;
+		if (!(file.startsWith("/") || /^[A-Za-z]:\//.test(file)) && !file.startsWith("../")) return 0;
+		if (root && file.startsWith(`${root.replaceAll("\\", "/").replace(/\/$/, "")}/`)) return 0;
+	}
+	if (/\(<anonymous>\)\s*$/.test(frame)) return 2;
+	return 1;
+}
+function decodeStack(value) {
+	return value.replace(/\\([nrt\\'"])/g, (_escape, char) => {
+		return {
+			n: "\n",
+			r: "\r",
+			t: "	"
+		}[char] ?? char;
+	});
+}
+function expandStackFields(message) {
+	return message.replace(/(?<!\w)(['"]?)(componentStack|stack)\1:\s*(['"])((?:\\.|(?!\3)[^\\])*)\3,?/g, (_match, _keyQuote, field, _quote, value) => {
+		return `\n${field === "componentStack" ? "Component" : "Error"} stack:\n${decodeStack(value)}\n`;
+	}).replace(/(^|\n|[,{])[ \t]*(['"]?)(componentStack|stack)\2:[ \t]*(['"])((?:\\.|[^\\\n])*)$/gm, (match, prefix, _keyQuote, field, _quote, value) => {
+		if (!/\\n\s+at\s/.test(value)) return match;
+		return `${prefix}\n${field === "componentStack" ? "Component" : "Error"} stack:\n${decodeStack(value)}`;
+	});
+}
+function jsonStringField(blob, field) {
+	const match = new RegExp(`"${field}":"((?:[^"\\\\]|\\\\.)*)"`).exec(blob);
+	if (!match) return null;
+	try {
+		return JSON.parse(`"${match[1]}"`);
+	} catch {
+		return null;
+	}
+}
+function jsonObjectComplete(blob) {
+	let depth = 0;
+	let inString = false;
+	for (let i = 0; i < blob.length; i++) {
+		const char = blob[i];
+		if (inString) {
+			if (char === "\\") i++;
+			else if (char === "\"") inString = false;
+		} else if (char === "\"") inString = true;
+		else if (char === "{") depth++;
+		else if (char === "}" && --depth === 0) return true;
+	}
+	return false;
+}
+/**
+* React Native's DebugServerException embeds Metro's serialized bundling error
+* after a `Body:` line, and logcat splits that JSON across lines past 4 KiB.
+*/
+function compactMetroErrorBody(text, root, printed) {
+	if (!text.includes("DebugServerException")) return null;
+	const lines = text.split(/\r?\n/);
+	const start = lines.findIndex((line) => line.includes("{\"type\":\""));
+	if (start < 0) return null;
+	const prefix = lines[start].slice(0, lines[start].indexOf("{\"type\":\""));
+	let blob = lines[start].slice(prefix.length);
+	let end = start + 1;
+	while (end < lines.length && !jsonObjectComplete(blob) && lines[end].trim() && !/^(?:\tat\s|\s*Caused by:)/.test(lines[end])) blob += lines[end++];
+	const type = /^\{"type":"([^"]*)"/.exec(blob)?.[1];
+	const message = jsonStringField(blob, "message");
+	if (!type || !message) return null;
+	const stripRoot = (value) => root ? value.replaceAll(`${root}/`, "") : value;
+	const [firstLine = "", ...rest] = stripRoot(stripAnsi(message)).trim().split(/\r?\n/);
+	const first = firstLine.trim();
+	const importStack = stripRoot(stripAnsi(jsonStringField(blob, "_expoImportStack") ?? "")).trim();
+	const diagnosis = [
+		first,
+		...rest,
+		...importStack ? importStack.split(/\r?\n/) : []
+	];
+	const printedLines = new Set(printed.flatMap((line) => stripRoot(stripAnsi(line)).split(/\r?\n/).map((part) => part.trim())));
+	const replacement = first && diagnosis.every((line) => !line.trim() || printedLines.has(line.trim())) ? [`${type}: ${first} (diagnosis above)`] : [`${type}: ${first}`, ...diagnosis.slice(1)];
+	return {
+		head: [...lines.slice(0, start), ...prefix.trim() ? [prefix] : []].join("\n"),
+		lines: [...replacement, "[Metro error body compacted; full text in stim logs]"],
+		tail: lines.slice(end).join("\n")
+	};
+}
+function shortFrame(frame, root) {
+	return (root ? frame.replaceAll(`${root}/`, "") : frame).trim().replace(/ \(BuildId: [0-9a-f]+\)/gi, "").replace(" [captured native frame]", "").replace(/ \(in ([^()]+)\) \(\/?<compiler-generated>:0\) \(\1\)$/, " ($1; compiler-generated)").replace(/https?:\/\/[^\s)]+/g, (location) => {
+		const match = /^(.*\.bundle)(?:[^\s]*?)(:\d+:\d+)$/.exec(location);
+		if (!match) {
+			const bundle = /\/([^/]+\.bundle)/.exec(location)?.[1];
+			return bundle ? `${bundle} [unsymbolicated]` : location;
+		}
+		return `${match[1].split("/").at(-1)}${match[2]} [unsymbolicated]`;
+	}).replace(/\((\/(?:apex|system)\/[^()]+)\)/g, (_match, path) => `(${path.split("/").at(-1)})`);
+}
+function structuredFrames(value) {
+	if (!Array.isArray(value)) return [];
+	return value.flatMap((frame) => {
+		if (frame === null || typeof frame !== "object") return [];
+		const { file, line, column, fn } = frame;
+		const location = [
+			typeof file === "string" ? file : null,
+			line,
+			column
+		].filter((part) => typeof part === "string" || typeof part === "number" && Number.isFinite(part)).join(":");
+		const name = typeof fn === "string" ? fn : "";
+		return name && location ? [`at ${name} (${location})`] : name || location ? [`at ${name || location}`] : [];
+	});
+}
+/** Formats captured stacks for humans; full mode removes preview limits and preserves frame text. */
+function launchErrorPreview(records, root, { full = false } = {}) {
+	const lines = [];
+	let kind = "Error";
+	let frames = [];
+	let hadStack = false;
+	let source = "";
+	const flush = () => {
+		if (frames.length) {
+			hadStack = true;
+			const ranked = frames.map((frame, index) => ({
+				frame,
+				index,
+				rank: framePriority(frame, root)
+			}));
+			const selected = ranked.toSorted((a, b) => a.rank - b.rank || a.index - b.index).slice(0, full ? void 0 : 10).toSorted((a, b) => a.index - b.index);
+			const prioritized = !full && selected.some(({ index, rank }) => index >= 10 && rank === 0);
+			lines.push(`${kind} stack${prioritized ? " (app frames prioritized)" : ""}:`, ...selected.map(({ frame }) => `  ${full ? frame.trim() : shortFrame(frame, root)}`));
+			if (frames.length > selected.length) {
+				const frameworkCount = ranked.filter((entry) => entry.rank === 2 && !selected.includes(entry)).length;
+				lines.push(`  ... ${frames.length - selected.length} more frames${frameworkCount ? ` (${frameworkCount} dependency/native)` : ""}`);
+			}
+		}
+		frames = [];
+		kind = "Error";
+	};
+	const consume = (line) => {
+		if ((hadStack || frames.length > 0) && /^\s*isComponentError:\s*(?:true|false)\s*}?,?\s*$/.test(line)) return;
+		const header = /^\s*(Component stack|Error stack|Call Stack):?\s*$/i.exec(line);
+		if (header) {
+			flush();
+			kind = /^component/i.test(header[1]) ? "Component" : "Error";
+		} else if (/^\s*at\s+\S/.test(line) || /^\s*\S[^\n]*@\S+:\d+:\d+\s*$/.test(line) || /^\s+\S[^\n]*\([^()]+:\d+:\d+\)\s*$/.test(line)) {
+			if (!full && /\(https?:\/\/[^\s)]*$/.test(line)) return;
+			frames.push(line);
+		} else if (line.trim()) {
+			flush();
+			if (/^\s*Caused by:/.test(line)) kind = "Caused-by";
+			lines.push(!full && line.length > 1e3 ? `${line.slice(0, 1e3)} ... [preview shortened; full text in stim logs]` : line);
+		}
+	};
+	for (const record of records) {
+		const nextSource = JSON.stringify([
+			record.src,
+			record.platform,
+			record.proc
+		]);
+		if (source !== nextSource) flush();
+		source = nextSource;
+		if (record.msg != null) {
+			const msg = String(record.msg);
+			const compacted = full ? null : compactMetroErrorBody(msg, root, lines);
+			const chunks = compacted ? [
+				expandStackFields(compacted.head),
+				...compacted.lines,
+				expandStackFields(compacted.tail)
+			] : [expandStackFields(msg)];
+			for (const chunk of chunks) for (const line of chunk.split(/\r?\n/)) consume(line);
+		}
+		const stack = typeof record.stack === "string" ? record.stack.split(/\r?\n/) : structuredFrames(record.stack);
+		if (stack.length) {
+			flush();
+			if (record.event === "native_crash") kind = "Native";
+			for (const line of stack) consume(line);
+		}
+		const components = typeof record.componentStack === "string" ? record.componentStack.split(/\r?\n/) : structuredFrames(record.componentStack);
+		if (components.length) {
+			flush();
+			kind = "Component";
+			for (const line of components) consume(line);
+		}
+		if (typeof record.codeFrame === "string") {
+			flush();
+			lines.push(record.codeFrame);
+		}
+		if (typeof record.symbolicationNote === "string") {
+			flush();
+			lines.push(...record.symbolicationNote.split("\n").filter((line) => full || !line.startsWith("Same error captured by ")));
+		}
+	}
+	flush();
+	if (hadStack && !full) lines.push("Full captured logs: stim logs --source all");
+	return lines;
+}
+//#endregion
+//#region src/command-output.ts
+const LABEL_WIDTH = 11;
+function formatDuration(ms) {
+	const value = Number(ms);
+	if (!Number.isFinite(value) || value < 0) return "unknown";
+	if (value < 1e3) return `${Math.round(value)}ms`;
+	const totalSeconds = Math.round(value / 1e3);
+	if (totalSeconds >= 60) {
+		const minutes = Math.floor(totalSeconds / 60);
+		const seconds = totalSeconds - minutes * 60;
+		return `${minutes}m${String(seconds).padStart(2, "0")}s`;
+	}
+	return `${Math.round(value / 100) / 10}s`;
+}
+function formatLongDuration(ms) {
+	const value = Number(ms);
+	if (!Number.isFinite(value) || value < 0) return "unknown";
+	const totalSeconds = Math.round(value / 1e3);
+	const hours = Math.floor(totalSeconds / 3600);
+	const minutes = Math.floor((totalSeconds - hours * 3600) / 60);
+	const seconds = totalSeconds - hours * 3600 - minutes * 60;
+	if (hours > 0) return minutes > 0 ? `${hours}h${String(minutes).padStart(2, "0")}m` : `${hours}h`;
+	if (minutes > 0) return seconds > 0 ? `${minutes}m${String(seconds).padStart(2, "0")}s` : `${minutes}m`;
+	return `${seconds}s`;
+}
+function formatElapsed(ms) {
+	const totalSeconds = Math.max(0, Math.round((Number(ms) || 0) / 1e3));
+	const minutes = Math.floor(totalSeconds / 60);
+	const seconds = totalSeconds % 60;
+	return minutes > 0 ? `${minutes}m${String(seconds).padStart(2, "0")}s` : `${seconds}s`;
+}
+function plural(count, singular, many = `${singular}s`) {
+	return `${count} ${count === 1 ? singular : many}`;
+}
+function clockTime(iso) {
+	const at = new Date(iso);
+	if (Number.isNaN(at.getTime())) return iso;
+	return [
+		at.getHours(),
+		at.getMinutes(),
+		at.getSeconds()
+	].map((n) => String(n).padStart(2, "0")).join(":");
+}
+function releasedLeaseFact(lease) {
+	return `released the ${lease.platform} lease on ${lease.id} (it ran until ${clockTime(lease.expiresAt)})`;
+}
+function phaseLine(label, text) {
+	return `  ${String(label).padEnd(LABEL_WIDTH)} ${text}`;
+}
+/** Quote a path for a shell command Stim prints for a human to copy and run. */
+function quotedPath(path) {
+	return `'${path.replaceAll("'", "'\\''")}'`;
+}
+function shortUdid(udid) {
+	const text = String(udid ?? "");
+	return text.length > 4 ? `${text.slice(0, 4)}..` : text;
+}
+function shortHash(hash) {
+	const text = String(hash ?? "");
+	return text.length > 8 ? `${text.slice(0, 6)}..` : text;
+}
+function isAppLaunchError(record) {
+	return record.src !== "device" || record.level === "fatal" || record.platform === "android" && typeof record.proc === "string" && /^ReactNativeJS\(\d+\)$/.test(record.proc) || record.platform === "ios" && record.subsystem === "com.facebook.react.log" && record.category === "javascript";
+}
+/**
+* Splits the error-level records a verified launch collected into the device
+* log the run counts and the records it still prints one by one.
+*/
+function launchErrorReport(records, root) {
+	const fromDevice = records.filter((record) => record.src === "device" && !isAppLaunchError(record));
+	const lines = launchErrorPreview(records.filter(isAppLaunchError), root);
+	return {
+		summary: fromDevice.length === 0 ? null : `${plural(fromDevice.length, "general device error-level record")} (not confirmed app errors); inspect with stim logs --errors --source device`,
+		lines
+	};
+}
+function appReadinessMessage(status, waitedMs) {
+	if (status === "ready") return `app reported ready (${formatDuration(waitedMs)} verification total)`;
+	if (status === "error") return "not confirmed: an app error or process exit interrupted the readiness wait";
+	return "not confirmed: no ready log within 30s of bundle load; inspect the UI and logs";
+}
+const SLOW_STEP_MS = 2e3;
+function stepClock(now = Date.now) {
+	const t0 = now();
+	return () => now() - t0;
+}
+function stepTimer(now = Date.now) {
+	const elapsed = stepClock(now);
+	return () => `(${formatDuration(elapsed())})`;
+}
+//#endregion
+export { launchErrorPreview as _, formatElapsed as a, launchErrorReport as c, quotedPath as d, releasedLeaseFact as f, stepTimer as g, stepClock as h, formatDuration as i, phaseLine as l, shortUdid as m, appReadinessMessage as n, formatLongDuration as o, shortHash as p, clockTime as r, isAppLaunchError as s, SLOW_STEP_MS as t, plural as u };

package/dist/config-D7uu8Gbq.mjs

@@ -0,0 +1,381 @@
+import { t as getExecutor } from "./exec-bsN9MJXb.mjs";
+import { existsSync, lstatSync, mkdirSync, readFileSync, readdirSync, readlinkSync, renameSync, statSync, unlinkSync, writeFileSync } from "fs";
+import { homedir } from "os";
+import { dirname, isAbsolute, join, normalize } from "path";
+import { withDirLock } from "@stim-cli/core";
+import { capture, check, decode } from "unique-pid";
+//#region src/fs-util.ts
+function volumeRootFor(path) {
+	const m = normalize(String(path)).match(/^\/volumes\/([^/]+)/i);
+	return m ? `/Volumes/${m[1]}` : "/";
+}
+function resolveWorkspaceRealish(workspacePath) {
+	const raw = String(workspacePath);
+	if (!raw.startsWith("/")) return null;
+	let current = raw;
+	const MAX_HOPS = 40;
+	for (let hops = 0; hops < MAX_HOPS; hops++) {
+		const normalized = normalize(current);
+		const segments = normalized.split("/").filter(Boolean);
+		let prefix = "";
+		let followedSymlink = false;
+		for (const segment of segments) {
+			prefix += `/${segment}`;
+			let st;
+			try {
+				st = lstatSync(prefix);
+			} catch (err) {
+				if (err && err.code === "ENOENT") return normalized;
+				return null;
+			}
+			if (st.isSymbolicLink()) {
+				let target;
+				try {
+					target = readlinkSync(prefix);
+				} catch {
+					return null;
+				}
+				current = `${target.startsWith("/") ? target : normalize(join(dirname(prefix), target))}${normalized.slice(prefix.length)}`;
+				followedSymlink = true;
+				break;
+			}
+		}
+		if (!followedSymlink) return normalized;
+	}
+	return null;
+}
+function isRealMount(entryDev, rootDev) {
+	return entryDev != null && rootDev != null && entryDev !== rootDev;
+}
+function listMountedVolumes({ statFn = statSync } = {}) {
+	const roots = ["/"];
+	let rootDev;
+	try {
+		rootDev = statFn("/").dev;
+	} catch {
+		return roots;
+	}
+	try {
+		for (const name of readdirSync("/Volumes")) {
+			const path = join("/Volumes", name);
+			let entryDev;
+			try {
+				entryDev = statFn(path).dev;
+			} catch {
+				continue;
+			}
+			if (isRealMount(entryDev, rootDev)) roots.push(path);
+		}
+	} catch {}
+	return roots;
+}
+function resolveVolumeRoot(path) {
+	const realish = resolveWorkspaceRealish(path);
+	return realish === null ? null : volumeRootFor(realish);
+}
+function isOnMountedVolume(path, mountedVolumes) {
+	const mounted = new Set(mountedVolumes || listMountedVolumes());
+	const volume = resolveVolumeRoot(path);
+	if (volume === null) return false;
+	return mounted.has(volume);
+}
+function directorySize(dir, { timeoutMs } = {}) {
+	let out;
+	try {
+		out = getExecutor().runFile("du", ["-sk", dir], { timeoutMs });
+	} catch {
+		return 0;
+	}
+	if (!out) return 0;
+	const kb = parseInt(out.split(/\s+/)[0] ?? "", 10);
+	return isNaN(kb) ? 0 : kb * 1024;
+}
+function formatBytes(bytes) {
+	if (bytes >= 1024 ** 3) return `${(bytes / 1024 ** 3).toFixed(1)}G`;
+	if (bytes >= 1024 ** 2) return `${Math.round(bytes / 1024 ** 2)}M`;
+	return `${Math.round(bytes / 1024)}K`;
+}
+//#endregion
+//#region src/process-identity.ts
+function sameProcessRecord(a, b) {
+	if (!a || !b) return !a && !b;
+	return a.pid === b.pid && a.processToken === b.processToken;
+}
+function captureProcessIdentity(pid) {
+	const result = capture(pid);
+	if (result.ok) return {
+		ok: true,
+		token: result.value
+	};
+	return {
+		ok: false,
+		reason: `${result.error.code} (${result.error.message})`
+	};
+}
+function captureProcessToken(pid) {
+	const captured = captureProcessIdentity(pid);
+	return captured.ok ? captured.token : null;
+}
+function inspectProcessIdentity(record) {
+	if (!record || typeof record.processToken !== "string") return "unknown";
+	const decoded = decode(record.processToken);
+	if (!decoded.ok || decoded.value.pid !== record.pid) return "unknown";
+	const result = check(record.processToken);
+	return result.ok ? result.value : "unknown";
+}
+async function waitForProcessExit(record, timeoutMs) {
+	const deadline = Date.now() + timeoutMs;
+	while (Date.now() <= deadline) {
+		const identity = inspectProcessIdentity(record);
+		if (identity === "different" || identity === "gone") return true;
+		if (Date.now() >= deadline) return false;
+		await new Promise((resolve) => setTimeout(resolve, 100));
+	}
+	return false;
+}
+//#endregion
+//#region src/config.ts
+function getConfigDir() {
+	return process.env.STIM_HOME || join(homedir(), ".stim");
+}
+function getConfigPath() {
+	return join(getConfigDir(), "config.json");
+}
+function ensureDir() {
+	const dir = getConfigDir();
+	if (!existsSync(dir)) mkdirSync(dir, { recursive: true });
+}
+const LOCK_DIR_NAME = "config.lock";
+function lockPath() {
+	return join(getConfigDir(), LOCK_DIR_NAME);
+}
+function withConfigLock(fn) {
+	return withDirLock(lockPath(), fn, { ensureParent: ensureDir });
+}
+function configCorruptRepair(path = getConfigPath()) {
+	return `Repair the file, or move it aside to start over: mv "${path}" "${path}.broken"`;
+}
+function configCorrupt(reason, path = getConfigPath()) {
+	const corrupt = /* @__PURE__ */ new Error(`Stim config at ${path} ${reason}\nIt holds the records of the simulators and emulators Stim owns, so it is never reset automatically.
+` + configCorruptRepair(path));
+	corrupt.code = "STIM_CONFIG_CORRUPT";
+	return corrupt;
+}
+function loadConfig() {
+	const p = getConfigPath();
+	if (!existsSync(p)) return null;
+	const raw = readFileSync(p, "utf-8");
+	try {
+		return JSON.parse(raw);
+	} catch (err) {
+		throw configCorrupt(`is not valid JSON: ${err.message}`, p);
+	}
+}
+function isRecord(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+/**
+* An array or scalar container swallows every write silently: `JSON.stringify` drops a string key set on
+* an array, so the record is gone by the time the file is written. Absent is created; unusable is refused.
+*/
+function adoptContainer(cfg, key) {
+	const value = cfg[key];
+	if (value === void 0 || value === null) {
+		cfg[key] = {};
+		return true;
+	}
+	if (!isRecord(value)) throw configCorrupt(`has a ${key} that is not an object: ${JSON.stringify(value)}`);
+	return false;
+}
+function saveConfig(config) {
+	ensureDir();
+	const target = getConfigPath();
+	const tmp = `${target}.${process.pid}.${Math.random().toString(36).slice(2)}.tmp`;
+	writeFileSync(tmp, JSON.stringify(config, null, 2) + "\n");
+	try {
+		renameSync(tmp, target);
+	} catch (err) {
+		try {
+			unlinkSync(tmp);
+		} catch {}
+		throw err;
+	}
+}
+const CONFIG_VERSION = 2;
+function ensureConfig() {
+	return withConfigLock(() => {
+		const existing = loadConfig();
+		if (existing) {
+			let changed = false;
+			if (adoptContainer(existing, "projects")) changed = true;
+			if (adoptContainer(existing, "repos")) changed = true;
+			if (existing.version !== CONFIG_VERSION) {
+				existing.version = CONFIG_VERSION;
+				changed = true;
+			}
+			if (changed) saveConfig(existing);
+			return existing;
+		}
+		const fresh = {
+			version: CONFIG_VERSION,
+			projects: {},
+			repos: {}
+		};
+		saveConfig(fresh);
+		return fresh;
+	});
+}
+function getProject(projectPath) {
+	return loadConfig()?.projects?.[projectPath] || null;
+}
+function requireAbsoluteProjectPath(projectPath) {
+	if (isAbsolute(projectPath)) return;
+	throw new Error(`Project key "${projectPath}" is not an absolute path. The registry is keyed by the realpath of a workspace root, so a relative key can never resolve.`);
+}
+function upsertProject(projectPath, fields) {
+	requireAbsoluteProjectPath(projectPath);
+	return withConfigLock(() => {
+		const cfg = ensureConfig();
+		const existing = cfg.projects[projectPath] || {
+			metroPort: null,
+			platforms: {}
+		};
+		cfg.projects[projectPath] = {
+			...existing,
+			...fields
+		};
+		saveConfig(cfg);
+		return cfg.projects[projectPath];
+	});
+}
+function removeProject(projectPath) {
+	withConfigLock(() => {
+		const cfg = loadConfig();
+		if (!cfg?.projects?.[projectPath]) return;
+		delete cfg.projects[projectPath];
+		saveConfig(cfg);
+	});
+}
+function claimMetroPort(projectPath, port) {
+	return withConfigLock(() => {
+		const cfg = ensureConfig();
+		if (!cfg.projects[projectPath]) throw new Error(`Project not registered: ${projectPath}`);
+		for (const [path, proj] of Object.entries(cfg.projects)) if (path !== projectPath && proj?.metroPort === port) return null;
+		cfg.projects[projectPath].metroPort = port;
+		saveConfig(cfg);
+		return port;
+	});
+}
+function setDevice(projectPath, platform, deviceFields) {
+	requireAbsoluteProjectPath(projectPath);
+	withConfigLock(() => {
+		const cfg = ensureConfig();
+		if (!cfg.projects[projectPath]) throw new Error(`Project not registered: ${projectPath}`);
+		cfg.projects[projectPath].platforms = cfg.projects[projectPath].platforms || {};
+		cfg.projects[projectPath].platforms[platform] = deviceFields;
+		saveConfig(cfg);
+	});
+}
+function releaseAndroidConsolePort(projectPath, consolePort) {
+	return withConfigLock(() => {
+		const cfg = loadConfig();
+		const android = cfg?.projects?.[projectPath]?.platforms?.android;
+		if (!cfg || !android || android.consolePort !== consolePort) return false;
+		delete android.consolePort;
+		saveConfig(cfg);
+		return true;
+	});
+}
+function clearDevice(projectPath, platform) {
+	withConfigLock(() => {
+		const cfg = loadConfig();
+		if (!cfg?.projects?.[projectPath]?.platforms) return;
+		delete cfg.projects[projectPath].platforms[platform];
+		saveConfig(cfg);
+	});
+}
+function setSupervisor(projectPath, { pid, port, startedAt, processToken }) {
+	requireAbsoluteProjectPath(projectPath);
+	return withConfigLock(() => {
+		const cfg = ensureConfig();
+		if (!cfg.projects[projectPath]) cfg.projects[projectPath] = {
+			metroPort: null,
+			platforms: {}
+		};
+		cfg.projects[projectPath].supervisor = {
+			pid,
+			port,
+			startedAt,
+			processToken
+		};
+		saveConfig(cfg);
+		return cfg.projects[projectPath].supervisor;
+	});
+}
+function clearSupervisor(projectPath, expected) {
+	return withConfigLock(() => {
+		const cfg = loadConfig();
+		const current = cfg?.projects?.[projectPath]?.supervisor;
+		if (!current) return true;
+		if (expected !== void 0 && !sameProcessRecord(current, expected)) return false;
+		delete cfg.projects[projectPath].supervisor;
+		saveConfig(cfg);
+		return true;
+	});
+}
+function getConcurrencyLimits({ env = process.env } = {}) {
+	const c = loadConfig()?.concurrency || {};
+	return {
+		maxBuilds: resolveLimit(env.STIM_MAX_BUILDS, c.maxBuilds),
+		maxDevices: resolveLimit(env.STIM_MAX_DEVICES, c.maxDevices)
+	};
+}
+function resolveLimit(envVal, cfgVal) {
+	const raw = envVal !== void 0 && envVal !== null && envVal !== "" ? Number(envVal) : typeof cfgVal === "number" ? cfgVal : NaN;
+	if (!Number.isFinite(raw) || raw <= 0) return 0;
+	return Math.floor(raw);
+}
+function getProjectSettings(projectPath) {
+	return getProject(projectPath)?.settings || {};
+}
+function getRepoSettings(gitCommonDir) {
+	return loadConfig()?.repos?.[gitCommonDir]?.settings || {};
+}
+function isPathPrefix(prefix, path) {
+	if (prefix === path) return true;
+	const withSlash = prefix.endsWith("/") ? prefix : `${prefix}/`;
+	return path.startsWith(withSlash);
+}
+function findEnclosingWorktreeRoot(projectPath) {
+	const cfg = loadConfig();
+	if (!cfg?.projects) return null;
+	let best = null;
+	for (const [path, proj] of Object.entries(cfg.projects)) {
+		if (!proj?.worktreeRoot) continue;
+		if (!isPathPrefix(path, projectPath)) continue;
+		if (!best || path.length > best.length) best = path;
+	}
+	return best;
+}
+function allMetroPorts() {
+	const cfg = loadConfig();
+	if (!cfg?.projects) return [];
+	return Object.values(cfg.projects).map((p) => p.metroPort).filter((p) => typeof p === "number");
+}
+function allConsolePortsAndSerials({ isMounted = isOnMountedVolume } = {}) {
+	const cfg = loadConfig();
+	const result = {
+		androidConsolePorts: [],
+		androidPhysicalSerials: []
+	};
+	if (!cfg) return result;
+	for (const [path, proj] of Object.entries(cfg.projects || {})) {
+		if (!existsSync(path) && isMounted(path)) continue;
+		const android = proj.platforms?.android;
+		if (typeof android?.consolePort === "number") result.androidConsolePorts.push(android.consolePort);
+		if (android?.serial && !android.avdName) result.androidPhysicalSerials.push(android.serial);
+	}
+	return result;
+}
+//#endregion
+export { directorySize as A, withConfigLock as C, sameProcessRecord as D, inspectProcessIdentity as E, isOnMountedVolume as M, listMountedVolumes as N, waitForProcessExit as O, volumeRootFor as P, upsertProject as S, captureProcessToken as T, releaseAndroidConsolePort as _, clearSupervisor as a, setDevice as b, findEnclosingWorktreeRoot as c, getConfigPath as d, getProject as f, loadConfig as g, isPathPrefix as h, clearDevice as i, formatBytes as j, withDirLock as k, getConcurrencyLimits as l, getRepoSettings as m, allMetroPorts as n, configCorruptRepair as o, getProjectSettings as p, claimMetroPort as r, ensureConfig as s, allConsolePortsAndSerials as t, getConfigDir as u, removeProject as v, captureProcessIdentity as w, setSupervisor as x, saveConfig as y };