stim 1.8.0 → 1.10.0

package/README.md

@@ -8,8 +8,8 @@ keep native and JavaScript builds warm across worktrees.
 
 ## Install
 
-If you previously installed `stim-cli` globally, follow the
-[migration instructions](#migrating-from-stim-cli) first.
+Node 22.12.0 or later is required. If you previously installed `stim-cli`
+globally, follow the [migration instructions](#migrating-from-stim-cli) first.
 
 ```bash
 npm install --global stim
@@ -22,18 +22,6 @@ Run without a global install when needed:
 npx stim <command>
 ```
 
-Node 22.12.0 or later is required.
-
-Machine defaults in `~/.stim/config.json` can enable or disable native artifact
-caching, remote caches, Metro sharing, iOS compiler caching and prefix mapping,
-and Android ccache/CAS, PCH, Gradle caching, and target ABI narrowing. The
-top-level `iosSimulatorApp` setting selects Xcode's viewer or an installed
-Siniulator.
-`.stim.json` runtime overrides apply per app, beside its `package.json`; monorepo
-apps do not inherit the repository-root file. Worktree-copy rules stay at the
-repository root. Run `stim guide settings` for the
-`optimizations` schema; existing defaults remain unchanged.
-
 ## Normal workflow
 
 ```bash
@@ -44,115 +32,29 @@ stim logs --errors
 stim stop
 ```
 
-For `stim logs --errors`, a clean check requires exit code 0 and no matching
-errors in the captured logs. Exit code 0 alone means the query succeeded, even
-when it prints errors. A workspace that has never produced a log timeline
-refuses with `STIM_NO_PROJECT`; in a monorepo, the error names the nearest
-registered descendant app with logs when one exists.
-
-Use `stim start --reset-cache` to recover from stale Metro transforms or file-map
-state. It restarts only this app's verified owned Metro, keeping its port and
-devices, with Metro's own reset: every store in the app's Metro config is cleared,
-including this app's shared transform store, so other worktrees of the same app
-rebuild their transforms too. Other apps and native build caches are unchanged.
-
-Use `stim doctor --platform ios` or `stim doctor --platform android` when only
-one native platform is in scope; shared project checks still run. Doctor also
-prints the running CLI version and the `stim` installation resolved from PATH,
-and flags a resolved installation that is older than another available one.
-
-For parallel iOS work, SimSlim is recommended as an optional way to reduce
-simulator background services and memory use. Run `stim guide lifecycle simslim`
-to review the service tradeoffs and configure a profile. Doctor recommends the
-setup without installing or enabling it. When a simulator cannot start
-processes, Stim bounds the wait and reports observed host memory pressure when
-available; free memory before retrying. A timeout alone does not prove OOM.
-
-For stale Android CMake launcher findings, stop native builds and run
-`stim doctor --fix --platform android` in the affected checkout. It clears
-affected ignored, untracked generated `.cxx` configurations in the app and
-installed native modules, then reports remaining findings. The next build
-recreates that output; source files, custom launcher settings, and shared
-ccache entries are preserved. Its cache-lock check cannot detect uncached,
-release-swap fallback, or direct Gradle builds; stop all native builds first.
-
 Stim builds or restores the app, installs it, launches it, and checks launch
 readiness. Plain output streams progress and reports the complete result. Use
 `--json` when a script needs structured data.
 
-To use an existing EAS development build, run `stim ios --eas-profile ios-simulator`
-or `stim android --eas-profile development` with your project's profile name.
-The profile must be an internal development build. Add `--device` for a connected
-phone; iOS requires `ios.simulator: true` for a simulator and false for a phone.
-Stim downloads a matching native build and connects it to the workspace's Metro.
-EAS CLI manages the downloaded artifact cache. An iOS provisioning failure
-points to EAS device registration and rebuild commands.
-On a miss it stops and prints the EAS build command, which may incur charges;
-it never triggers the build automatically. See `stim guide lifecycle eas` for
-setup, environment handling, and cache behavior.
-
-Use `stim ios --scheme "App Staging"` when a project has several shared Xcode
-app schemes. Combine it with `--configuration Release` if needed. Without the
-flag, Stim keeps its automatic scheme selection. Explicit schemes use separate
-artifact caches and Xcode build directories; run `stim guide lifecycle builds`
-for provider behavior. This selects an Xcode scheme, not a URL scheme.
-
-Launch evidence does not prove that the UI is interactive. Apps can optionally
-[declare readiness with two debug log messages](https://stim.appandflow.com/docs/dev-server-and-logs#optional-app-declared-readiness),
-without a package or SDK. A captured pending message extends the default
-three-second stability window after bundle delivery to a bounded wait for ready.
-Managed Metro response capture distinguishes a finished build from a finished
-response; servers without capture use the build-complete marker. Run
-`stim guide lifecycle readiness` for implementation instructions; verify the
-expected screen separately.
-
-`stim reload [ios|android]` requests a JavaScript reload in the live app on this
-workspace's owned local device. Use it when an error screen remains after a fix,
-and on Android after a failed first bundle load. An iOS app whose first bundle
-failed never connects to Metro, so reload cannot reach it. It reloads
-JavaScript and never restarts the app. It is not part of the normal workflow
-and does not build, install, boot, or launch an app. The platform is optional
-when only one app is live.
-Success confirms that the request was sent; Stim does not observe completion.
-Verify the expected UI on the reported device and inspect `stim logs --errors`
-before claiming recovery.
-
-For an isolated branch, create the worktree with Git, then warm it:
-
-```bash
-git worktree add -b feature/settings ../feature-settings HEAD
-cd ../feature-settings
-stim worktree warm
-```
-
-If a harness already created the linked worktree, run only `stim worktree warm`
-there. Warm copies missing ignored state from the source checkout, including
-eligible `.env` and local configuration files. Existing entries are preserved;
-existing ignored directories such as `node_modules` are skipped whole.
-
-`stim worktree warm --refresh` brings the source checkout up to date first: it
-checks the upstream, fetches changes when needed, fast-forwards whatever branch is checked out there, and installs what
-the new commits moved before copying. It refuses a source checkout it cannot
-move (uncommitted tracked changes, a rebase or merge in progress, a detached
-HEAD, a diverged branch) and never switches branches. One lock per repository
-keeps a copy from reading a `node_modules` a refresh is rewriting; plain warms
-still run side by side. A plain warm also refuses (`STIM_DEPS_INCOMPLETE`) when the last
-install of the lockfile on disk did not finish, instead of copying a partial
-`node_modules`; `stim worktree warm --refresh` reinstalls it.
-
-Wait for warm to finish before editing, installing dependencies, starting
-Metro/builds, or running another warm in that worktree. Concurrent writes are
-unsafe: entries created after the initial check can be overwritten or removed.
-
-After the work is preserved, `stim worktree remove` removes any linked
-worktree, warmed or not. Git-created branches stay. See the
-[worktree guide](https://stim.appandflow.com/docs/worktrees) for exclusions
-and cleanup rules.
-
-## Reference
-
-The [documentation website](https://stim.appandflow.com/) explains the
-human workflow and all commands.
+## Documentation
+
+The [documentation website](https://stim.appandflow.com/) is the full
+reference:
+
+- [Getting started](https://stim.appandflow.com/docs/getting-started): terms,
+  the first run, parallel worktrees, and what to do when a run fails.
+- [Worktrees](https://stim.appandflow.com/docs/worktrees): `worktree warm`,
+  `--refresh`, `worktree remove`, and `gc --worktrees` to remove finished
+  worktrees in bulk.
+- [Build caches](https://stim.appandflow.com/docs/build-caches): what `gc`
+  reports and trims, including the build outputs of idle workspaces.
+- [Devices](https://stim.appandflow.com/docs/owned-devices): owned simulators
+  and emulators, physical devices, slots, and remote devices.
+- [EAS development builds](https://stim.appandflow.com/docs/eas-builds).
+- [Commands](https://stim.appandflow.com/docs/commands) and
+  [settings](https://stim.appandflow.com/docs/settings).
+- [Troubleshooting](https://stim.appandflow.com/docs/troubleshooting): every
+  refusal code and its remedy.
 
 The installed CLI contains version-matched operational guidance:
 
@@ -163,10 +65,6 @@ stim <command> --help
 stim guide
 ```
 
-Runtime state defaults to `~/.stim`. Set `STIM_HOME` to move it. Stim manages
-owned simulators and emulators, leases connected physical devices, and supports
-configured remote devices.
-
 ## Migrating from stim-cli
 
 Remove the old global package before installing `stim`, since both provide the
@@ -180,36 +78,6 @@ npm install --global stim
 Update programmatic imports from `stim-cli/cache-manifest` to
 `stim/cache-manifest`. The `@stim-cli/*` packages keep their names.
 
-MIT License.
-
-### Multiple devices in one workspace
-
-Use a stable slot name for each simulator, emulator, or physical device. Slots
-can use identical models and all share the workspace's Metro server and build
-cache. Omit `--slot` to reuse your existing default device.
-
-```sh
-stim ios --slot phone
-stim ios --slot tablet --device-type "iPad Pro 13-inch (M4)"
-stim ios --slot hardware --device <udid>
-stim logs --slot tablet --source device
-stim stop --slot tablet
-```
+## License
 
-`stim status` shows every slot. Plain `stim stop` stops the whole workspace;
-`--slot` preserves the shared server and other devices. `stim reload ios` or
-`stim reload android` can reload multiple connected devices. Read
-`stim guide lifecycle options` for launch verification and recycling behavior.
-
-### Named server ports
-
-Use `stim ports get web` to reserve a workspace port for a server Stim does not
-manage, then pass that number to the server, for example
-`pnpm exec vite --port "$(stim ports get web)" --strictPort`.
-`stim ports` lists named allocations and managed Metro. `stim ports stop web`
-stops the TCP listener and releases its port; `--dry-run` previews the action.
-`stim ports release web` releases without stopping. Omitting the label selects
-all named ports. These commands leave Metro alone, and `stim stop` leaves
-named ports alone. Worktree removal and `gc --delete` stop and release named
-ports for removed workspaces. Read `stim guide ports` for the reserved band,
-listener ownership, and allocation limits.
+MIT

package/dist/{android-DWssqHQ8.mjs → android-787HhP5w.mjs}

@@ -1,9 +1,68 @@
-import { t as getExecutor } from "./exec-B29XNuhP.mjs";
-import { i as pidExists, o as signalProcessTree } from "./metro-C7bcJ0uo.mjs";
-import { c as androidDataPartitionSizeBytes } from "./settings-BXXorVM2.mjs";
-import { existsSync, lstatSync, mkdirSync, openSync, readFileSync, readdirSync, realpathSync, renameSync, rmSync, statSync, writeFileSync } from "fs";
-import { homedir, tmpdir } from "os";
+import { u as getConfigDir } from "./config-BEq0Qw_a.mjs";
+import { t as getExecutor } from "./exec-DK8KaVHK.mjs";
+import { P as withDirLock, c as signalProcessTree, i as pidExists } from "./metro-BWLOJ_Wr.mjs";
+import { c as androidDataPartitionSizeBytes } from "./settings-DOugPlPz.mjs";
+import { mkdirSync, renameSync, rmSync, writeFileSync } from "node:fs";
+import { existsSync as existsSync$1, lstatSync as lstatSync$1, mkdirSync as mkdirSync$1, openSync as openSync$1, readFileSync as readFileSync$1, readdirSync as readdirSync$1, realpathSync as realpathSync$1, renameSync as renameSync$1, rmSync as rmSync$1, statSync as statSync$1, writeFileSync as writeFileSync$1 } from "fs";
 import { dirname, isAbsolute, join, resolve } from "path";
+import { createdDevicesFile, createdDevicesLock, readCreatedDevices, readCreatedDevices as readCreatedDevices$1 } from "@stim-cli/core/state";
+import { homedir, tmpdir } from "os";
+//#region src/devices/created-devices.ts
+function update(platform, change) {
+	const dir = getConfigDir();
+	withDirLock(createdDevicesLock(), () => {
+		const current = readCreatedDevices();
+		const entries = new Set(current[platform]);
+		if (!change(entries)) return;
+		const next = {
+			version: 1,
+			ios: [...current.ios],
+			android: [...current.android],
+			[platform]: [...entries]
+		};
+		const file = createdDevicesFile();
+		const tmp = `${file}.${process.pid}.${Math.random().toString(36).slice(2)}.tmp`;
+		writeFileSync(tmp, `${JSON.stringify(next, null, 2)}\n`);
+		try {
+			renameSync(tmp, file);
+		} catch (error) {
+			rmSync(tmp, { force: true });
+			throw error;
+		}
+	}, { ensureParent: () => mkdirSync(dir, { recursive: true }) });
+}
+function recordCreatedDevice(platform, id) {
+	update(platform, (entries) => entries.size !== entries.add(id).size);
+}
+function forgetCreatedDevice(platform, id) {
+	update(platform, (entries) => entries.delete(id));
+}
+//#endregion
+//#region src/devices/device-ownership.ts
+const OWNED_SIM_NAME = /^stim-[A-Za-z0-9._-]+ \(.* \d+(?:\.\d+)*\)(?: [A-Za-z0-9-]+)?$/;
+const OWNED_AVD_NAME = /^stim-[A-Za-z0-9._-]+$/;
+const GIB = 1024 ** 3;
+function isOwnedSimName(name) {
+	return OWNED_SIM_NAME.test(name);
+}
+function isOwnedAvdName(name) {
+	return OWNED_AVD_NAME.test(name);
+}
+function avdConfigWrittenByStim(configIni) {
+	for (const line of String(configIni ?? "").split(/\r?\n/)) {
+		const match = /^disk\.dataPartition\.size=(\d+)$/.exec(line.trim());
+		if (match) return Number(match[1]) > 0 && Number(match[1]) % GIB === 0;
+	}
+	return false;
+}
+function isStimOwnedSim(sim, created = readCreatedDevices$1()) {
+	const name = sim.name ?? "";
+	return name.startsWith("stim-") && (created.ios.has(sim.udid) || isOwnedSimName(name));
+}
+function isStimOwnedAvd(name, readConfig, created = readCreatedDevices$1()) {
+	return isOwnedAvdName(name) && (created.android.has(name) || avdConfigWrittenByStim(readConfig()));
+}
+//#endregion
 //#region src/devices/android.ts
 const ANDROID_ABIS = /* @__PURE__ */ new Set([
 	"armeabi-v7a",
@@ -38,7 +97,7 @@ function androidToolPath(tool, platform = process.platform) {
 	const bare = location.at(-1);
 	const name = platform === "win32" ? `${bare}${WINDOWS_SDK_TOOL_EXTENSIONS[tool]}` : bare;
 	const abs = join(androidHome(), ...location.slice(0, -1), name);
-	return existsSync(abs) ? abs : bare;
+	return existsSync$1(abs) ? abs : bare;
 }
 const WINDOWS_BUILD_TOOL_EXTENSIONS = { apksigner: ".bat" };
 function androidBuildToolName(tool, platform = process.platform) {
@@ -60,7 +119,7 @@ function buildToolsMajor(version) {
 	const major = Number(String(version ?? "").split(/[.-]/)[0]);
 	return Number.isFinite(major) ? major : 0;
 }
-function findBuildTool(tools, { home = androidHome(), readDir = readdirSync, exists = existsSync, platform = process.platform } = {}) {
+function findBuildTool(tools, { home = androidHome(), readDir = readdirSync$1, exists = existsSync$1, platform = process.platform } = {}) {
 	const root = join(home, "build-tools");
 	let versions = [];
 	try {
@@ -91,7 +150,7 @@ function androidTool(tool) {
 function listInstalledSystemImages() {
 	const root = join(androidHome(), "system-images");
 	const images = [];
-	if (!existsSync(root)) return images;
+	if (!existsSync$1(root)) return images;
 	for (const apiDir of safeList(root)) {
 		const m = apiDir.match(/^android-(\d+)$/);
 		if (!m) continue;
@@ -107,7 +166,7 @@ function listInstalledSystemImages() {
 }
 function safeList(dir) {
 	try {
-		return readdirSync(dir);
+		return readdirSync$1(dir);
 	} catch {
 		return [];
 	}
@@ -132,6 +191,7 @@ async function createOwnedAvd(label, { systemImage, spawn = (...args) => getExec
 		throw new Error(`No ${arch} Android system image is installed. Install one, e.g.: sdkmanager "system-images;android-36;google_apis;${arch}"`);
 	}
 	const avdName = ownedAvdName(label);
+	recordCreatedDevice("android", avdName);
 	const tool = androidToolPath("avdmanager");
 	const args = [
 		"create",
@@ -183,7 +243,7 @@ function parseAvdSystemImage(configIni) {
 	}
 	return null;
 }
-function ownedAvdSystemImage(avdName, { avdDirectory = ownedAvdDirectory, readFile = (path) => readFileSync(path, "utf8") } = {}) {
+function ownedAvdSystemImage(avdName, { avdDirectory = ownedAvdDirectory, readFile = (path) => readFileSync$1(path, "utf8") } = {}) {
 	const directory = avdDirectory(avdName);
 	if (!directory) return null;
 	try {
@@ -195,13 +255,32 @@ function ownedAvdSystemImage(avdName, { avdDirectory = ownedAvdDirectory, readFi
 function sanitizeAvdLabel(label) {
 	return String(label).replace(/[^A-Za-z0-9._-]+/g, "-").replace(/^-+|-+$/g, "");
 }
+function avdConfigIni(avdName, directory = ownedAvdDirectory(avdName)) {
+	if (!directory) return null;
+	try {
+		return readFileSync$1(join(directory, "config.ini"), "utf8");
+	} catch {
+		return null;
+	}
+}
+function registeredOrOrphanedAvdDirectory(avdName) {
+	return ownedAvdDirectory(avdName) ?? listOrphanedAvdDirectories(avdName)[0]?.directory ?? null;
+}
+function isStimOwnedAvdName(avdName, directory) {
+	return isStimOwnedAvd(avdName, () => avdConfigIni(avdName, directory === void 0 ? registeredOrOrphanedAvdDirectory(avdName) : directory));
+}
 function ownedAvdName(label) {
 	const clean = sanitizeAvdLabel(label);
 	return `stim-${clean.startsWith("stim-") ? clean.slice(5) : clean}`;
 }
+const AVDMANAGER_DELETE_TIMEOUT_MS = 12e4;
 function deleteAvd(avdName) {
-	if (!avdName?.startsWith("stim-")) throw new Error(`Refusing to delete AVD "${avdName}": not a Stim-owned AVD (name must start with "stim-").`);
-	getExecutor().run(`${androidTool("avdmanager")} delete avd -n "${avdName}"`);
+	if (!isStimOwnedAvdName(avdName)) throw new Error(`Refusing to delete AVD "${avdName}": not a Stim-owned AVD; Stim has no record of creating it.`);
+	getExecutor().run(`${androidTool("avdmanager")} delete avd -n "${avdName}"`, {
+		timeoutMs: AVDMANAGER_DELETE_TIMEOUT_MS,
+		killSignal: "SIGKILL"
+	});
+	forgetCreatedDevice("android", avdName);
 }
 function parseAvdList(text) {
 	return text.split("\n").map((l) => l.trim()).filter((l) => l && !l.startsWith("INFO") && !l.startsWith("WARNING"));
@@ -416,7 +495,7 @@ function avdStorageRoots() {
 }
 function avdPathExists(path) {
 	try {
-		lstatSync(path);
+		lstatSync$1(path);
 		return true;
 	} catch (error) {
 		if (error.code === "ENOENT") return false;
@@ -427,17 +506,17 @@ function listOrphanedAvdDirectories(avdName) {
 	const roots = avdStorageRoots();
 	const stores = roots.filter(avdPathExists).map((root) => ({
 		root,
-		canonicalRoot: realpathSync(root),
-		names: readdirSync(root)
+		canonicalRoot: realpathSync$1(root),
+		names: readdirSync$1(root)
 	}));
 	const registered = /* @__PURE__ */ new Set();
 	for (const { root, canonicalRoot, names } of stores) for (const name of names.filter((entry) => entry.endsWith(".ini"))) {
 		const path = join(root, name);
-		const ini = readFileSync(path, "utf8");
+		const ini = readFileSync$1(path, "utf8");
 		const targets = /* @__PURE__ */ new Set([...avdIniPaths(root, ini), ...avdIniPaths(canonicalRoot, ini)]);
 		if (!targets.size) throw new Error(`Cannot verify AVD registration at ${path}; its data was kept.`);
 		for (const target of targets) try {
-			registered.add(realpathSync(target));
+			registered.add(realpathSync$1(target));
 		} catch (error) {
 			const code = error.code;
 			if (code !== "ENOENT" && code !== "ENOTDIR") throw error;
@@ -452,8 +531,8 @@ function listOrphanedAvdDirectories(avdName) {
 			if (roots.some((candidate) => avdPathExists(join(candidate, `${name}.ini`)))) continue;
 			const directory = join(canonicalRoot, entry);
 			if (registered.has(directory) || !avdPathExists(directory)) continue;
-			const stat = lstatSync(directory);
-			if (!stat.isDirectory() || stat.isSymbolicLink() || realpathSync(directory) !== directory) throw new Error(`Cannot verify AVD data at ${directory}; it was kept.`);
+			const stat = lstatSync$1(directory);
+			if (!stat.isDirectory() || stat.isSymbolicLink() || realpathSync$1(directory) !== directory) throw new Error(`Cannot verify AVD data at ${directory}; it was kept.`);
 			if (!orphaned.some((candidate) => candidate.directory === directory)) orphaned.push({
 				name,
 				directory,
@@ -464,7 +543,7 @@ function listOrphanedAvdDirectories(avdName) {
 	}
 	return orphaned;
 }
-function ownedAvdDirectory(avdName, { env = process.env, home = homedir(), readFile = (path) => readFileSync(path, "utf8"), realpath = realpathSync, isDirectory = (path) => statSync(path).isDirectory() } = {}) {
+function ownedAvdDirectory(avdName, { env = process.env, home = homedir(), readFile = (path) => readFileSync$1(path, "utf8"), realpath = realpathSync$1, isDirectory = (path) => statSync$1(path).isDirectory() } = {}) {
 	if (!/^stim-[A-Za-z0-9._-]+$/.test(avdName)) return null;
 	const roots = [
 		env.ANDROID_AVD_HOME,
@@ -488,6 +567,21 @@ function ownedAvdDirectory(avdName, { env = process.env, home = homedir(), readF
 	}
 	return null;
 }
+const AVD_USER_DATA = [
+	"userdata-qemu.img",
+	"userdata-qemu.img.qcow2",
+	"encryptionkey.img",
+	"encryptionkey.img.qcow2",
+	"cache.img",
+	"cache.img.qcow2",
+	"snapshots"
+];
+function wipeAvdUserData(directory) {
+	for (const name of AVD_USER_DATA) rmSync$1(join(directory, name), {
+		recursive: true,
+		force: true
+	});
+}
 function withAvdConfigOverrides(contents, overrides) {
 	const newline = contents.includes("\r\n") ? "\r\n" : "\n";
 	const trailingNewline = /\r?\n$/.test(contents);
@@ -509,10 +603,10 @@ function withAvdConfigOverrides(contents, overrides) {
 	return updated.join(newline) + (trailingNewline ? newline : "");
 }
 let avdConfigWriteSequence = 0;
-function configureNewOwnedAvd(avdName, { dataPartitionSizeGb, avdConfig = {} }, { avdDirectory = ownedAvdDirectory, readFile = (path) => readFileSync(path, "utf8"), writeFile = (path, contents) => writeFileSync(path, contents, {
+function configureNewOwnedAvd(avdName, { dataPartitionSizeGb, avdConfig = {} }, { avdDirectory = ownedAvdDirectory, readFile = (path) => readFileSync$1(path, "utf8"), writeFile = (path, contents) => writeFileSync$1(path, contents, {
 	encoding: "utf8",
 	flag: "wx"
-}), rename = renameSync, remove = (path) => rmSync(path, { force: true }) } = {}) {
+}), rename = renameSync$1, remove = (path) => rmSync$1(path, { force: true }) } = {}) {
 	const sizeBytes = androidDataPartitionSizeBytes(dataPartitionSizeGb);
 	const directory = avdDirectory(avdName);
 	if (!directory) throw new Error(`Could not resolve the content directory for newly created AVD ${avdName}.`);
@@ -547,7 +641,7 @@ function avdPoolConfiguration(dataPartitionSizeGb, avdConfig) {
 function ownedAvdMatchesConfiguration(avdName, configuration) {
 	const directory = ownedAvdDirectory(avdName);
 	if (!directory) return false;
-	const contents = readFileSync(join(directory, "config.ini"), "utf8");
+	const contents = readFileSync$1(join(directory, "config.ini"), "utf8");
 	const expected = JSON.parse(configuration);
 	return Array.isArray(expected) && expected.length > 0 && expected.every((entry) => Array.isArray(entry) && entry.length === 2 && entry.every((value) => typeof value === "string") && contents.split(/\r?\n/).some((line) => line.trim() === `${entry[0]}=${entry[1]}`));
 }
@@ -630,7 +724,7 @@ const CRASH_REPORT_MODE_EMULATOR_VERSION = 37;
 function emulatorCrashDatabases(env = process.env) {
 	const root = join(env.TMP || env.TEMP || tmpdir(), "AndroidEmulator");
 	try {
-		return readdirSync(root).filter((name) => /^emu-crash-.*\.db$/.test(name)).map((name) => join(root, name));
+		return readdirSync$1(root).filter((name) => /^emu-crash-.*\.db$/.test(name)).map((name) => join(root, name));
 	} catch {
 		return [];
 	}
@@ -644,7 +738,7 @@ function emulatorCrashDatabases(env = process.env) {
 * removed instead, which has the same effect unless a crash handler is still writing into it.
 * https://github.com/appandflow/stim/issues/918
 */
-function suppressEmulatorCrashConsent({ platform = process.platform, version = emulatorMajorVersion, databases = emulatorCrashDatabases, remove = (path) => rmSync(path, {
+function suppressEmulatorCrashConsent({ platform = process.platform, version = emulatorMajorVersion, databases = emulatorCrashDatabases, remove = (path) => rmSync$1(path, {
 	recursive: true,
 	force: true
 }) } = {}) {
@@ -662,6 +756,9 @@ function bootAndroidEmulator(avdName, consolePort, { logFile, platform = process
 		avdName,
 		"-port",
 		String(consolePort),
+		"-grpc",
+		String(consolePort + 3e3),
+		"-grpc-use-token",
 		...headlessEmulatorArgs(),
 		...suppressEmulatorCrashConsent({ platform })
 	], {
@@ -675,8 +772,8 @@ function bootAndroidEmulator(avdName, consolePort, { logFile, platform = process
 function emulatorStdio(logFile) {
 	if (!logFile) return "ignore";
 	try {
-		mkdirSync(dirname(logFile), { recursive: true });
-		const fd = openSync(logFile, "w");
+		mkdirSync$1(dirname(logFile), { recursive: true });
+		const fd = openSync$1(logFile, "w");
 		return [
 			"ignore",
 			fd,
@@ -781,7 +878,7 @@ function avdProcessLockPaths(avdDirectory, platform) {
 }
 function readAvdProcessId(path) {
 	try {
-		const pid = Number(readFileSync(path, "utf8").split("\0")[0]);
+		const pid = Number(readFileSync$1(path, "utf8").split("\0")[0]);
 		if (!Number.isSafeInteger(pid) || pid <= 0) throw new Error(`Could not read the emulator PID from process lock ${path}.`);
 		return pid;
 	} catch (error) {
@@ -824,7 +921,7 @@ function emulatorCrashHandlerPids(qemuPid) {
 	], { timeoutMs: 1e4 });
 	return String(out ?? "").split(/\r?\n/).map((line) => Number(line.trim())).filter((pid) => Number.isSafeInteger(pid) && pid > 0);
 }
-function waitForAndroidEmulatorShutdown(avdName, shutdown, { timeoutMs = ANDROID_EMULATOR_SHUTDOWN_TIMEOUT_MS, pollMs = ANDROID_EMULATOR_SHUTDOWN_POLL_MS, platform = process.platform, resolveDirectory = ownedAvdDirectory, readProcessId = readAvdProcessId, processAlive = pidExists, directoryExists = (path) => statSync(path).isDirectory(), crashHandlerPids = emulatorCrashHandlerPids, killCrashHandler = (pid) => signalProcessTree(pid, "SIGKILL", { platform }), now = Date.now, sleep = sleepSync } = {}) {
+function waitForAndroidEmulatorShutdown(avdName, shutdown, { timeoutMs = ANDROID_EMULATOR_SHUTDOWN_TIMEOUT_MS, pollMs = ANDROID_EMULATOR_SHUTDOWN_POLL_MS, platform = process.platform, resolveDirectory = ownedAvdDirectory, readProcessId = readAvdProcessId, processAlive = pidExists, directoryExists = (path) => statSync$1(path).isDirectory(), crashHandlerPids = emulatorCrashHandlerPids, killCrashHandler = (pid) => signalProcessTree(pid, "SIGKILL", { platform }), now = Date.now, sleep = sleepSync } = {}) {
 	const { directory, processId } = resolveAvdProcess(avdName, {
 		platform,
 		resolveDirectory,
@@ -852,20 +949,52 @@ function waitForAndroidEmulatorShutdown(avdName, shutdown, { timeoutMs = ANDROID
 	}
 	if (!directoryExists(directory)) throw new Error(`Could not verify the content directory for owned AVD ${avdName} after shutdown.`);
 }
-function getAvdNameForSerial(serial, { timeoutMs } = {}) {
-	const out = getExecutor().runQuiet(`${androidTool("adb")} -s ${serial} emu avd name`, { timeoutMs });
+const EMU_AVD_NAME_TIMEOUT_MS = 1e4;
+function getAvdNameForSerial(serial, { timeoutMs = EMU_AVD_NAME_TIMEOUT_MS } = {}) {
+	const out = getExecutor().runQuiet(`${androidTool("adb")} -s ${serial} emu avd name`, {
+		timeoutMs: Math.min(timeoutMs, EMU_AVD_NAME_TIMEOUT_MS),
+		killSignal: "SIGKILL"
+	});
 	if (!out) return null;
 	return out.split("\n")[0]?.trim() || null;
 }
-function resolveOwnedAvdSerial(avdName, { timeoutMs } = {}) {
+function resolveOwnedAvdSerial(avdName, opts = {}) {
+	return ownedAvdSerialResolver(opts)(avdName);
+}
+function once(read) {
+	let result;
+	return () => {
+		if (!result) try {
+			result = { value: read() };
+		} catch (error) {
+			result = { error };
+		}
+		if ("error" in result) throw result.error;
+		return result.value;
+	};
+}
+/**
+* `resolveOwnedAvdSerial` for several AVDs against one reading of the AVD list, `adb devices`, and
+* each emulator's AVD name. The timeout budget starts when the resolver is created.
+*/
+function ownedAvdSerialResolver({ timeoutMs } = {}) {
 	const started = Date.now();
 	const remaining = () => ({ timeoutMs: timeoutMs === void 0 ? void 0 : Math.max(1, timeoutMs - (Date.now() - started)) });
-	if (!listAvds(remaining()).includes(avdName)) return { missing: true };
-	if (!avdName?.startsWith("stim-")) return { notOwned: true };
-	const adb = listAdbDevices(remaining());
-	const match = [...adb.emulators, ...adb.unhealthy.filter((entry) => entry.kind === "emulator" && entry.consolePort !== void 0)].find((e) => getAvdNameForSerial(e.serial, remaining()) === avdName);
-	if (match) return { serial: match.serial };
-	return { notRunning: true };
+	const avds = once(() => listAvds(remaining()));
+	const adb = once(() => listAdbDevices(remaining()));
+	const names = /* @__PURE__ */ new Map();
+	const avdNameOf = (serial) => {
+		if (!names.has(serial)) names.set(serial, getAvdNameForSerial(serial, remaining()));
+		return names.get(serial);
+	};
+	return (avdName) => {
+		if (!avds().includes(avdName)) return { missing: true };
+		if (!isStimOwnedAvdName(avdName)) return { notOwned: true };
+		const devices = adb();
+		const match = [...devices.emulators, ...devices.unhealthy.filter((entry) => entry.kind === "emulator" && entry.consolePort !== void 0)].find((e) => avdNameOf(e.serial) === avdName);
+		if (match) return { serial: match.serial };
+		return { notRunning: true };
+	};
 }
 //#endregion
-export { ownedAvdName as A, waitForBoot as B, listAvds as C, nextConsolePort as D, memoizeEmulatorProbe as E, resetAdoptedAvd as F, resolveOwnedAvdSerial as I, resolvePhysicalDevice as L, physicalDeviceModel as M, pickDefaultSystemImage as N, ownedAvdDirectory as O, probeEmulatorSerial as P, shutdownAndroidEmulator as R, listAdbDevices as S, listOrphanedAvdDirectories as T, emulatorFailureRemedy as _, androidPoolNoCandidatesRefusal as a, getAvdNameForSerial as b, assertOwnedAvdStopped as c, avdStorageRoots as d, bootAndroidEmulator as f, emulatorDiskSpaceRemedy as g, deleteAvd as h, androidPoolCandidates as i, ownedAvdSystemImage as j, ownedAvdMatchesConfiguration as k, avdPathExists as l, createOwnedAvd as m, androidDeviceAbi as n, androidSystemImageAbi as o, configureNewOwnedAvd as p, androidHome as r, androidToolCwd as s, androidBuildToolName as t, avdPoolConfiguration as u, extractEmulatorFailure as v, listInstalledSystemImages as w, hostSystemImageArch as x, findBuildTool as y, waitForAndroidEmulatorShutdown as z };
+export { ownedAvdDirectory as A, resolvePhysicalDevice as B, isStimOwnedAvdName as C, listOrphanedAvdDirectories as D, listInstalledSystemImages as E, physicalDeviceModel as F, wipeAvdUserData as G, sleepSync as H, pickDefaultSystemImage as I, recordCreatedDevice as J, isStimOwnedSim as K, probeEmulatorSerial as L, ownedAvdName as M, ownedAvdSerialResolver as N, memoizeEmulatorProbe as O, ownedAvdSystemImage as P, resetAdoptedAvd as R, hostSystemImageArch as S, listAvds as T, waitForAndroidEmulatorShutdown as U, shutdownAndroidEmulator as V, waitForBoot as W, emulatorDiskSpaceRemedy as _, androidPoolNoCandidatesRefusal as a, findBuildTool as b, androidToolPath as c, avdPoolConfiguration as d, avdStorageRoots as f, deleteAvd as g, createOwnedAvd as h, androidPoolCandidates as i, ownedAvdMatchesConfiguration as j, nextConsolePort as k, assertOwnedAvdStopped as l, configureNewOwnedAvd as m, androidDeviceAbi as n, androidSystemImageAbi as o, bootAndroidEmulator as p, forgetCreatedDevice as q, androidHome as r, androidToolCwd as s, androidBuildToolName as t, avdPathExists as u, emulatorFailureRemedy as v, listAdbDevices as w, getAvdNameForSerial as x, extractEmulatorFailure as y, resolveOwnedAvdSerial as z };