stim 1.25.0 → 1.27.0

package/dist/prebuild-BDpToDgR.mjs

@@ -0,0 +1,1246 @@
+import { E as debugLog, _ as spawnDeclared, t as getExecutor } from "./exec-aULwtNly.mjs";
+import { M as withDirLock$1, l as withWorkspaceStateLockAsync, o as updateWorkspaceState, r as readWorkspaceState$1, y as sharedBuildCache } from "./workspace-state-BjqdjnJR.mjs";
+import { n as stripAnsi, r as waitForChild, t as createLineReader } from "./process-output-Fpl8PYi8.mjs";
+import { m as shortHash } from "./command-output-Dj-WT4BP.mjs";
+import { o as git, s as gitAsync } from "./operation-exec-Dp4FuIGR.mjs";
+import { St as gitCommonDirOnDisk } from "./settings-BDVI8Ivc.mjs";
+import { v as detectIsExpo } from "./project-DYj-HVx6.mjs";
+import { Vn as remoteCliInvocation } from "./ccache-BWTze1Ls.mjs";
+import { r as register } from "./cache-manifest-DEjqGGat.mjs";
+import { $ as STIM_VERSION } from "./workspaces-DFbj07jp.mjs";
+import { D as storedSources, m as fingerprintProject, o as diffFingerprintSources, p as fingerprintOptions, u as expoEnvFiles, v as packageIn } from "./build-cache-gBJ-WKzA.mjs";
+import { i as expoBinRefusal, o as expoSdkMajor, r as expoBinPath, s as expoTelemetryEnv } from "./server-expo-ABQs2XFA.mjs";
+import { t as readDoctorFingerprint } from "./doctor-fingerprint-o7ZI9YLn.mjs";
+import { createRequire } from "node:module";
+import { createHash } from "node:crypto";
+import { existsSync, lstatSync, mkdirSync, readFileSync, readdirSync, readlinkSync, realpathSync, renameSync, rmSync, statSync, writeFileSync } from "node:fs";
+import { dirname, isAbsolute, join, posix, relative, resolve, sep } from "node:path";
+import { ambientContext } from "@stim-cli/core";
+import { FINGERPRINT_MEMO_SCHEMA, LAST_BUILD_KEYS, fingerprintMemoDir, fingerprintMemoFile, fingerprintMemoLock, loadConfig, readFingerprintMemo, readWorkspaceState, trace } from "@stim-cli/core/state";
+import { readFile } from "node:fs/promises";
+import * as expoFingerprint from "@expo/fingerprint";
+import { normalizeOptionsAsync } from "@expo/fingerprint/build/Options.js";
+import { isIgnoredPathWithMatchObjects } from "@expo/fingerprint/build/utils/Path.js";
+//#region src/cache/static-fingerprint.ts
+const STATIC_SCHEMA = 1;
+/** More files than this outside git, or ignored by git, means the static check reads too much to be worth it. */
+const UNTRACKED_FILE_CAP = 2e3;
+const CONFIG_FILES = [
+	"app.json",
+	"app.config.ts",
+	"app.config.js",
+	"app.config.mjs",
+	"app.config.cjs",
+	"app.config.json"
+];
+const FINGERPRINT_CONFIGS = ["fingerprint.config.js", "fingerprint.config.cjs"];
+const RN_CONFIGS = [
+	"react-native.config.js",
+	"react-native.config.ts",
+	"react-native.config.cjs",
+	"react-native.config.mjs"
+];
+const ROOT_FILES = [
+	"package.json",
+	...CONFIG_FILES,
+	...FINGERPRINT_CONFIGS,
+	...RN_CONFIGS,
+	".fingerprintignore",
+	".gitignore",
+	"eas.json",
+	".easignore",
+	"expo-module.config.json"
+];
+const ROOT_DIRS = ["patches", "cng-patches"];
+const LOCKFILES = [
+	"pnpm-lock.yaml",
+	"yarn.lock",
+	"package-lock.json",
+	"bun.lock",
+	"bun.lockb"
+];
+const NATIVE_MARKERS = ["expo-module.config.json", ...RN_CONFIGS];
+const RISKY_IMPORTS = /* @__PURE__ */ new Set([
+	"fs",
+	"fs/promises",
+	"child_process",
+	"http",
+	"https",
+	"http2",
+	"net",
+	"dgram",
+	"worker_threads",
+	"process",
+	"dotenv",
+	"dotenv/config",
+	"@dotenvx/dotenvx",
+	"fs-extra",
+	"graceful-fs",
+	"execa",
+	"shelljs",
+	"cross-spawn",
+	"node-fetch",
+	"undici",
+	"axios",
+	"got"
+]);
+const FILE_IMPORTS = /* @__PURE__ */ new Set([
+	"fs",
+	"fs/promises",
+	"fs-extra",
+	"graceful-fs"
+]);
+const BUILTINS = /* @__PURE__ */ new Set([
+	"path",
+	"os",
+	"url",
+	"util",
+	"crypto",
+	"module",
+	"assert",
+	"events"
+]);
+const ASSET = /['"`]([^'"`\n]+\.(?:png|jpe?g|webp|gif|svg|ttf|otf|json|plist|xml|mp3|wav|caf|lottie|p8|mobileprovision))['"`]/g;
+/** An Expo module that declares its platforms is linked only on those; any other native package counts on both. */
+function linkedOn(info, platform) {
+	if (!info.native) return false;
+	if (!Array.isArray(info.platforms)) return true;
+	const wanted = platform === "ios" ? ["ios", "apple"] : ["android"];
+	return info.platforms.some((each) => wanted.includes(String(each))) || (platform === "ios" ? info.native.includes("*.podspec") : info.native.includes("android/build.gradle"));
+}
+const field = (value, key) => value && typeof value === "object" && key in value ? Reflect.get(value, key) : void 0;
+const sha256 = (value) => createHash("sha256").update(value).digest("hex");
+function blobId(content) {
+	return createHash("sha1").update(`blob ${content.length}\0`).update(content).digest("hex");
+}
+function readJson(path) {
+	return JSON.parse(readFileSync(path, "utf8"));
+}
+function stringList(value) {
+	return value && typeof value === "object" ? Object.keys(value) : [];
+}
+var Uncertain = class extends Error {};
+const local = (dir) => !dir.split(sep).includes("node_modules");
+function resolvePackage(from, name) {
+	for (let dir = from;; dir = dirname(dir)) {
+		const candidate = join(dir, "node_modules", name);
+		if (existsSync(join(candidate, "package.json"))) try {
+			return realpathSync(candidate);
+		} catch {
+			return null;
+		}
+		if (dirname(dir) === dir) return null;
+	}
+}
+/**
+* The installed packages, keyed by real path: every package reachable from the app's manifest, and every entry of a
+* node_modules directory above the app, which older autolinking scans.
+*/
+function packageGraph(root, manifest) {
+	const packages = /* @__PURE__ */ new Map();
+	const read = (dir) => {
+		const known = packages.get(dir);
+		if (known) return known;
+		let json;
+		let entries;
+		try {
+			json = readJson(join(dir, "package.json"));
+			entries = readdirSync(dir);
+		} catch {
+			return null;
+		}
+		const markers = NATIVE_MARKERS.filter((name) => entries.includes(name));
+		if (entries.some((name) => name.endsWith(".podspec"))) markers.push("*.podspec");
+		if (entries.includes("android") && ["build.gradle", "build.gradle.kts"].some((f) => existsSync(join(dir, "android", f)))) markers.push("android/build.gradle");
+		if (field(json, "codegenConfig")) markers.push("codegenConfig");
+		let platforms = null;
+		if (markers.includes("expo-module.config.json")) try {
+			platforms = field(readJson(join(dir, "expo-module.config.json")), "platforms") ?? null;
+		} catch {
+			platforms = "unreadable";
+		}
+		const info = {
+			name: String(field(json, "name") ?? ""),
+			version: String(field(json, "version") ?? ""),
+			deps: [
+				"dependencies",
+				"optionalDependencies",
+				"peerDependencies"
+			].flatMap((key) => stringList(field(json, key))),
+			native: markers.length ? markers : null,
+			platforms
+		};
+		packages.set(dir, info);
+		return info;
+	};
+	const queue = [];
+	const visit = (from, names, required, follow = true) => {
+		for (const name of names) {
+			const real = resolvePackage(from, name);
+			if (!real) {
+				if (required) throw new Uncertain(`${name} is not installed`);
+				continue;
+			}
+			if (!packages.has(real) && read(real) && follow) queue.push(real);
+		}
+	};
+	visit(root, [...stringList(field(manifest, "dependencies")), ...stringList(field(manifest, "devDependencies"))], true);
+	visit(root, stringList(field(manifest, "optionalDependencies")), false);
+	const hoisted = [];
+	for (let dir = root;; dir = dirname(dir)) {
+		const modules = join(dir, "node_modules");
+		let names = [];
+		try {
+			names = readdirSync(modules).flatMap((name) => {
+				if (name.startsWith(".")) return [];
+				if (!name.startsWith("@")) return [name];
+				try {
+					return readdirSync(join(modules, name)).map((scoped) => `${name}/${scoped}`);
+				} catch {
+					return [];
+				}
+			});
+		} catch {}
+		hoisted.push([dir, names]);
+		if (dirname(dir) === dir) break;
+	}
+	while (queue.length) {
+		const dir = queue.shift();
+		const info = dir === void 0 ? void 0 : packages.get(dir);
+		if (dir !== void 0 && info) visit(dir, info.deps, false);
+	}
+	for (const [dir, names] of hoisted) visit(dir, names, false, false);
+	return packages;
+}
+function resolveRelative(from, spec) {
+	const base = resolve(dirname(from), spec);
+	for (const path of [base, ...[
+		".ts",
+		".js",
+		".mjs",
+		".cjs",
+		".json",
+		"/index.ts",
+		"/index.js"
+	].map((e) => base + e)]) if (statSync(path, { throwIfNoEntry: false })?.isFile()) return path;
+	return null;
+}
+const isDirectory = (path) => statSync(path, { throwIfNoEntry: false })?.isDirectory() ?? false;
+const isFile = (path) => statSync(path, { throwIfNoEntry: false })?.isFile() ?? false;
+/** A string a config names relative to itself: a module it loads, a file it reads at prebuild, or a directory. */
+function addNamedPath(file, spec, scan, root) {
+	const found = resolveRelative(file, spec);
+	if (found && /\.[cm]?[jt]sx?$/.test(found)) scanConfigSource(found, scan, "plugin", root);
+	else if (found) scan.files.add(found);
+	else if (isDirectory(resolve(dirname(file), spec))) scan.dirs.add(resolve(dirname(file), spec));
+}
+/** Every `process.env` that is not followed by a literal name: the config passes the environment on as a value. */
+const ENV_VALUE = /process\.env\b(?!\s*(?:\??\.\s*[A-Za-z_$]|\[\s*(['"])[^'"]+\1\s*\]))/;
+/** Whether a plugin applies mods: it calls a `with...` helper it takes from the config-plugins package. */
+function appliesMods(source) {
+	const pkg = String.raw`['"](?:@expo\/config-plugins|expo\/config-plugins)['"]`;
+	const named = [...source.matchAll(new RegExp(String.raw`\{([^}]*)\}\s*=\s*require\s*\(\s*${pkg}\s*\)`, "g")), ...source.matchAll(new RegExp(String.raw`import\s*\{([^}]*)\}\s*from\s*${pkg}`, "g"))].flatMap((match) => String(match[1]).split(",").flatMap((part) => {
+		const [imported = "", alias = imported] = part.split(/\s+as\s+|:/).map((name) => name.trim());
+		return /^with[A-Z]\w*$/.test(imported) && /^\w+$/.test(alias) ? [alias] : [];
+	}));
+	const spaces = [...source.matchAll(new RegExp(String.raw`(?:const|let|var)\s+(\w+)\s*=\s*require\s*\(\s*${pkg}\s*\)`, "g")), ...source.matchAll(new RegExp(String.raw`import\s+(?:\*\s+as\s+)?(\w+)\s+from\s*${pkg}`, "g"))].map((match) => String(match[1]));
+	return named.some((name) => new RegExp(String.raw`(?<![\w.])${name}\s*\(`).test(source.replace(new RegExp(String.raw`function\s+${name}\b`, "g"), ""))) || spaces.some((name) => new RegExp(String.raw`\b${name}\.with[A-Z]\w*\s*\(`).test(source));
+}
+/**
+* What a config module evaluates, found by reading its source: the local modules, assets and directories it names,
+* the packages it imports and the environment variables it reads. Anything the scan cannot follow throws `Uncertain`.
+* A local plugin named by a path string also runs while the config is evaluated, but its file access normally sits in
+* mods that run at prebuild: its file access counts only when it calls no `with...` mod helper, and its process and
+* network access always counts.
+*/
+function scanConfigSource(file, scan, mode, root) {
+	if (scan.files.has(file)) return;
+	scan.files.add(file);
+	if (file.endsWith(".json")) {
+		scanJsonConfig(file, scan, root);
+		return;
+	}
+	const source = readFileSync(file, "utf8");
+	const where = relative(root, file);
+	const uncertain = (reason) => {
+		throw new Uncertain(`${reason} in ${where}`);
+	};
+	const fileAccess = mode === "evaluated" || !appliesMods(source);
+	if (/\brequire\s*\(\s*[^'"\s)]/.test(source) || /\bimport\s*\(\s*[^'"\s)]/.test(source)) uncertain("a dynamic require or import");
+	if (ENV_VALUE.test(source) || /=\s*process\b(?!\s*\??\.)/.test(source) || /\(\s*process\s*[,)]/.test(source)) uncertain("process.env read without a literal name");
+	if (/\b(execSync|execFileSync|spawnSync|fetch)\s*\(/.test(source) || /(?<!\.)\b(exec|execFile|spawn)\s*\(/.test(source)) uncertain("process or network access");
+	if (fileAccess && /\b(readFileSync|readFile|readdirSync|readdir|existsSync|statSync|createReadStream)\s*\(/.test(source)) uncertain("file access");
+	if (/[`]\s*\.{1,2}\/[^`]*\$\{/.test(source) || /\$\{[^}]*\}[^`]*\.(?:png|jpe?g|webp|json|plist)`/.test(source)) uncertain("an asset path built at evaluation");
+	for (const match of source.matchAll(/process\.env\s*\??\.\s*([A-Za-z_$][\w$]*)/g)) scan.env.add(String(match[1]));
+	for (const match of source.matchAll(/process\.env\s*\[\s*['"]([^'"]+)['"]\s*\]/g)) scan.env.add(String(match[1]));
+	const imports = /* @__PURE__ */ new Set();
+	for (const pattern of [
+		/\bfrom\s*['"]([^'"]+)['"]/g,
+		/\brequire\s*\(\s*['"]([^'"]+)['"]\s*\)/g,
+		/\bimport\s*\(\s*['"]([^'"]+)['"]\s*\)/g,
+		/\bimport\s+['"]([^'"]+)['"]/g
+	]) for (const match of source.matchAll(pattern)) imports.add(String(match[1]));
+	for (const spec of imports) {
+		const bare = spec.replace(/^node:/, "");
+		if (RISKY_IMPORTS.has(bare) || bare.startsWith("dotenv")) {
+			if (!FILE_IMPORTS.has(bare) || fileAccess) uncertain(`an import of ${spec}`);
+		} else if (spec.startsWith(".")) {
+			const found = resolveRelative(file, spec);
+			if (!found) throw new Uncertain(`an import of ${spec} that does not resolve in ${where}`);
+			scanConfigSource(found, scan, mode, root);
+		} else if (!spec.startsWith("node:") && !BUILTINS.has(bare)) scan.packages.add(spec.startsWith("@") ? spec.split("/").slice(0, 2).join("/") : spec.split("/")[0] ?? spec);
+	}
+	for (const match of source.matchAll(/['"](\.{1,2}\/[^'"\n]+)['"]/g)) {
+		const spec = String(match[1]);
+		if (!imports.has(spec)) addNamedPath(file, spec, scan, root);
+	}
+	for (const match of source.matchAll(/['"]((?:@[a-z0-9][\w.-]*\/)?[a-z0-9][\w.-]*(?:\/[\w.-]+)*)['"]/g)) {
+		const spec = String(match[1]);
+		scan.packages.add(spec.startsWith("@") ? spec.split("/").slice(0, 2).join("/") : spec.split("/")[0] ?? spec);
+	}
+	for (const match of source.matchAll(ASSET)) {
+		const path = resolve(dirname(file), String(match[1]));
+		if (isFile(path)) scan.files.add(path);
+	}
+}
+/**
+* The local files a static config names: every string value that is a path to a file or, written relative, to a
+* directory, such as an icon, a splash image, a google services file, a fonts directory or a local plugin, and the
+* packages its plugins name.
+*/
+function scanJsonConfig(file, scan, root) {
+	let json;
+	try {
+		json = readJson(file);
+	} catch {
+		throw new Uncertain(`${relative(root, file)} cannot be parsed`);
+	}
+	const visit = (value) => {
+		if (Array.isArray(value)) value.forEach(visit);
+		else if (value && typeof value === "object") Object.values(value).forEach(visit);
+		else if (typeof value === "string" && value && value.length < 512 && !value.includes("\n")) {
+			const plain = resolve(dirname(file), value);
+			if (value.startsWith(".")) addNamedPath(file, value, scan, root);
+			else if (isFile(plain)) scan.files.add(plain);
+			else if (/^(@[a-z0-9][\w.-]*\/)?[a-z0-9][\w.-]*(\/[\w.-]+)*$/.test(value)) scan.packages.add(value.startsWith("@") ? value.split("/").slice(0, 2).join("/") : value.split("/")[0] ?? value);
+		}
+	};
+	visit(json);
+}
+function lockfileDigest(root, top) {
+	for (let dir = root;; dir = dirname(dir)) {
+		const name = LOCKFILES.find((file) => existsSync(join(dir, file)));
+		if (name) {
+			const bytes = readFileSync(join(dir, name));
+			if (name.endsWith("b")) return [name, sha256(bytes)];
+			const lines = bytes.toString("utf8").split("\n").map((line) => line.trim()).filter((line) => line && !line.startsWith("#")).toSorted();
+			return [relative(root, join(dir, name)), sha256(lines.join("\n"))];
+		}
+		if (dir === top || dirname(dir) === dir) return null;
+	}
+}
+const toPosix = (path) => path.split(sep).join("/");
+/** A variable's value, and the file it names when it names one: a config can take a file path from the environment. */
+function envValueDigest(root, value) {
+	if (value === void 0) return null;
+	const named = value && value.length < 1024 ? resolve(root, value) : null;
+	const file = named && statSync(named, { throwIfNoEntry: false })?.isFile() ? contentId(named) : null;
+	return sha256(file ? `${value}\0${file}` : value);
+}
+function contentId(path) {
+	const stat = lstatSync(path, { throwIfNoEntry: false });
+	if (!stat) return "-";
+	if (stat.isSymbolicLink()) return blobId(Buffer.from(readlinkSync(path)));
+	return stat.isFile() ? blobId(readFileSync(path)) : "-";
+}
+/**
+* A digest of the inputs @expo/fingerprint hashes for one platform, read without evaluating the app config or running
+* autolinking: git blob ids of the tracked native inputs, content hashes of the untracked, modified and ignored ones,
+* each installed package's version and native markers, the lockfile, and the config's sources and the environment
+* variables they read. Equal digests mean equal fingerprints only as far as this model of the inputs reaches; it
+* reports `uncertain` for whatever it cannot follow, which then takes the full fingerprint.
+*/
+async function staticFingerprint(projectRoot, target, { env, signal }) {
+	try {
+		return {
+			...await computeDigest(realpathSync.native(projectRoot), target, env, signal),
+			uncertain: null
+		};
+	} catch (error) {
+		if (error instanceof Uncertain) return {
+			digest: null,
+			uncertain: error.message
+		};
+		throw error;
+	}
+}
+async function computeDigest(root, target, env, signal) {
+	if (existsSync(join(root, ".pnp.cjs"))) throw new Uncertain("Yarn Plug-n-Play installs have no node_modules to read");
+	const normalized = await normalizeOptionsAsync(root, await fingerprintOptions(root, target));
+	if (typeof normalized.fileHookTransform === "function") throw new Uncertain("fingerprint.config.js sets fileHookTransform");
+	if (normalized.nativeModuleSourceType !== "package" || normalized.configPluginSourceType !== "package") throw new Uncertain("the fingerprint preset hashes package files");
+	let top;
+	try {
+		top = realpathSync.native(await gitAsync(root, ["rev-parse", "--show-toplevel"], { signal }));
+	} catch {
+		throw new Uncertain("the project is not in a git work tree");
+	}
+	let manifest;
+	try {
+		manifest = readJson(join(root, "package.json"));
+	} catch {
+		throw new Uncertain("package.json cannot be read");
+	}
+	const packages = packageGraph(root, manifest);
+	const scan = {
+		files: /* @__PURE__ */ new Set(),
+		dirs: /* @__PURE__ */ new Set(),
+		packages: /* @__PURE__ */ new Set(),
+		env: /* @__PURE__ */ new Set(["EXPO_NO_DOTENV"])
+	};
+	for (const name of [
+		...CONFIG_FILES,
+		...FINGERPRINT_CONFIGS,
+		...RN_CONFIGS
+	]) {
+		const path = join(root, name);
+		if (existsSync(path)) scanConfigSource(path, scan, "evaluated", root);
+	}
+	const specs = /* @__PURE__ */ new Set([...ROOT_FILES, ...ROOT_DIRS]);
+	const useCNG = normalized.useCNGForPlatforms ?? {};
+	if (!field(useCNG, target.platform)) specs.add(target.platform);
+	const autolinking = field(field(manifest, "expo"), "autolinking");
+	specs.add("modules");
+	for (const options of [
+		autolinking,
+		field(autolinking, "ios"),
+		field(autolinking, "android")
+	]) {
+		const nativeModulesDir = field(options, "nativeModulesDir");
+		if (typeof nativeModulesDir === "string") specs.add(nativeModulesDir);
+		const searchPaths = field(options, "searchPaths");
+		if (Array.isArray(searchPaths)) {
+			for (const path of searchPaths) if (typeof path === "string") specs.add(path);
+		}
+	}
+	const extraContents = [];
+	for (const source of normalized.extraSources ?? []) if (source.type === "contents") extraContents.push([source.id, source.contents]);
+	else specs.add(source.filePath);
+	for (const [dir, info] of packages) if (local(dir) && info.native) specs.add(relative(root, dir));
+	for (const name of scan.packages) for (const [dir, info] of packages) if (info.name === name && local(dir)) specs.add(relative(root, dir));
+	const insideRepo = (spec) => {
+		const fromTop = relative(top, resolve(root, spec));
+		return !isAbsolute(fromTop) && fromTop !== ".." && !fromTop.startsWith(`..${sep}`);
+	};
+	const gitSpecs = [...specs].filter(insideRepo).map(toPosix).toSorted();
+	const outsideRepo = [...specs].filter((spec) => !insideRepo(spec)).toSorted();
+	const files = /* @__PURE__ */ new Map();
+	const list = async (args) => gitSpecs.length ? (await gitAsync(root, [
+		"--literal-pathspecs",
+		"ls-files",
+		"-z",
+		...args,
+		"--",
+		...gitSpecs
+	], {
+		untrimmed: true,
+		timeoutMs: 6e4,
+		signal
+	})).split("\0").filter(Boolean) : [];
+	const [staged, changed, untracked, ignored] = await Promise.all([
+		list(["-s"]),
+		list(["-m"]),
+		list(["-o", "--exclude-standard"]),
+		list([
+			"-o",
+			"-i",
+			"--exclude-standard",
+			"--directory"
+		])
+	]);
+	for (const line of staged) {
+		const [meta, path] = line.split("	");
+		const [mode, id] = (meta ?? "").split(" ");
+		if (mode === "160000") throw new Uncertain(`${path} is a git submodule`);
+		if (path && id) files.set(path, id);
+	}
+	const hashed = [...changed, ...untracked];
+	const isIgnored = (path, dir) => path.split("/").includes("node_modules") || isIgnoredPathWithMatchObjects(path, dir ? normalized.ignoreDirMatchObjects : normalized.ignorePathMatchObjects);
+	const walk = (path) => {
+		if (isIgnored(path, true)) return;
+		for (const entry of readdirSync(join(root, path), { withFileTypes: true })) {
+			const child = posix.join(path, entry.name);
+			if (entry.isDirectory()) walk(child);
+			else if (!isIgnored(child, false)) hashed.push(child);
+			if (hashed.length > UNTRACKED_FILE_CAP) throw new Uncertain("too many inputs outside git");
+		}
+	};
+	for (const entry of ignored) if (entry.endsWith("/")) walk(entry.slice(0, -1));
+	else if (!isIgnored(entry, false)) hashed.push(entry);
+	for (const dir of scan.dirs) walk(toPosix(relative(root, dir)));
+	for (const spec of outsideRepo) {
+		const stat = statSync(join(root, spec), { throwIfNoEntry: false });
+		if (stat?.isDirectory()) walk(toPosix(spec));
+		else if (stat) hashed.push(toPosix(spec));
+	}
+	if (hashed.length > UNTRACKED_FILE_CAP) throw new Uncertain("too many inputs outside git");
+	for (const name of expoEnvFiles(env)) {
+		hashed.push(name);
+		let text = "";
+		try {
+			text = readFileSync(join(root, name), "utf8");
+		} catch {}
+		for (const match of text.matchAll(/\$\{?([A-Za-z_][A-Za-z0-9_]*)/g)) scan.env.add(String(match[1]));
+	}
+	for (const file of scan.files) hashed.push(toPosix(relative(root, file)));
+	await Promise.all(hashed.map(async (path) => {
+		signal?.throwIfAborted();
+		const full = join(root, path);
+		const stat = lstatSync(full, { throwIfNoEntry: false });
+		files.set(path, stat?.isFile() ? blobId(await readFile(full)) : contentId(full));
+	}));
+	const packageRows = [...packages].map(([dir, info]) => [
+		toPosix(relative(root, dir)),
+		info.name,
+		info.version,
+		info.native,
+		info.platforms
+	]).toSorted((a, b) => JSON.stringify(a) < JSON.stringify(b) ? -1 : 1);
+	const { ignorePathMatchObjects, ignoreDirMatchObjects: _dirs, fileHookTransform: _hook, ...options } = normalized;
+	const require = createRequire(import.meta.url);
+	const identity = {
+		schema: STATIC_SCHEMA,
+		stim: STIM_VERSION,
+		fingerprint: String(field(require("@expo/fingerprint/package.json"), "version")),
+		platform: target.platform,
+		root: toPosix(relative(top, root)),
+		options: {
+			...options,
+			concurrentIoLimit: null,
+			silent: null,
+			debug: null,
+			ignorePaths: ignorePathMatchObjects.map((match) => match.pattern),
+			extraSources: (options.extraSources ?? []).map(({ reasons: _reasons, ...source }) => source)
+		}
+	};
+	const nativePackages = [...new Set([...packages.values()].filter((info) => linkedOn(info, target.platform)).map((info) => info.name))].toSorted();
+	return {
+		digest: sha256(JSON.stringify({
+			identity,
+			files: [...files].toSorted(([a], [b]) => a < b ? -1 : a > b ? 1 : 0),
+			extraContents,
+			packages: packageRows,
+			lockfile: lockfileDigest(root, top),
+			env: [...scan.env].toSorted().map((name) => [name, envValueDigest(root, env[name])])
+		})),
+		nativePackages
+	};
+}
+//#endregion
+//#region src/cache/fingerprint-memo.ts
+/** Records kept per platform; writing one more removes the least recently written. */
+const FINGERPRINT_MEMO_CAP = 256;
+/** How long the end of a run waits for a background check that is still running before it gives the check up. */
+const FINGERPRINT_CHECK_GRACE_MS = 3e3;
+const AUTOLINKED = /^(expo|rncore)Autolinking(Ios|Android)$/;
+const errorMessage = (error) => error instanceof Error ? error.message : String(error);
+const SOURCE_TYPES = /* @__PURE__ */ new Set([
+	"file",
+	"dir",
+	"contents",
+	"package"
+]);
+function isSourceList(sources) {
+	return sources.every((source) => source !== null && typeof source === "object" && "type" in source && SOURCE_TYPES.has(String(source.type)));
+}
+function writeRecord(record, { onlyIfAbsent = false } = {}) {
+	const dir = fingerprintMemoDir(record.platform);
+	const file = fingerprintMemoFile(record.platform, record.digest);
+	withDirLock$1(fingerprintMemoLock(), () => {
+		if (onlyIfAbsent && existsSync(file)) return;
+		mkdirSync(dir, {
+			recursive: true,
+			mode: 448
+		});
+		const tmp = `${file}.tmp-${process.pid}`;
+		writeFileSync(tmp, JSON.stringify(record), { mode: 384 });
+		renameSync(tmp, file);
+		const records = readdirSync(dir).filter((name) => name.endsWith(".json"));
+		if (records.length <= FINGERPRINT_MEMO_CAP) return;
+		const byAge = records.map((name) => ({
+			name,
+			mtimeMs: statSync(join(dir, name), { throwIfNoEntry: false })?.mtimeMs ?? 0
+		})).toSorted((a, b) => a.mtimeMs - b.mtimeMs);
+		for (const { name } of byAge.slice(0, records.length - FINGERPRINT_MEMO_CAP)) rmSync(join(dir, name), { force: true });
+	});
+	try {
+		register({
+			dir: fingerprintMemoDir(),
+			name: "Fingerprint memo",
+			prune: "entries",
+			entriesDepth: 2,
+			note: "full native fingerprints keyed by a static digest of their inputs"
+		});
+	} catch {}
+}
+function dropRecord(platform, digest) {
+	const file = fingerprintMemoFile(platform, digest);
+	if (!existsSync(file)) return;
+	withDirLock$1(fingerprintMemoLock(), () => rmSync(file, { force: true }));
+}
+const runBackgroundFingerprint = (operation, projectRoot, target, signal) => readDoctorFingerprint({
+	...operation,
+	signal
+}, {
+	root: projectRoot,
+	...target.platform ? { platform: target.platform } : {},
+	...target.iosProjectPath ? { iosProjectPath: target.iosProjectPath } : {},
+	...target.androidLayout ? { androidLayout: target.androidLayout } : {}
+}, { lowPriority: true });
+function startCheck(operation, projectRoot, target, stored, background) {
+	const controller = new AbortController();
+	const signal = AbortSignal.any([operation.signal, controller.signal]);
+	let done = false;
+	let abandoned = false;
+	const result = background(operation, projectRoot, target, signal).then((computed) => ({
+		hash: computed?.hash ?? null,
+		sources: computed?.sources ?? [],
+		failure: computed?.hash ? null : "no hash"
+	}), (error) => ({
+		hash: null,
+		sources: [],
+		failure: errorMessage(error)
+	})).then(({ hash, sources, failure }) => {
+		done = true;
+		const status = hash === stored.hash ? "confirmed" : hash === null ? "failed" : "stale";
+		if (status === "confirmed") try {
+			writeRecord(stored, { onlyIfAbsent: true });
+		} catch {}
+		if (!abandoned) debugLog.log("fingerprint_memo_check", {
+			platform: target.platform,
+			status,
+			...failure && !controller.signal.aborted ? { failure } : {}
+		});
+		const modeled = new Set(stored.nativePackages);
+		const unmodeled = sources.flatMap((source) => source.type === "package" && source.reasons.some((reason) => AUTOLINKED.test(reason)) && !modeled.has(source.name) ? [source.name] : []);
+		return {
+			status,
+			recorded: stored.hash,
+			current: hash,
+			...status === "stale" ? { unmodeled } : {}
+		};
+	});
+	return {
+		settle: async (graceMs = FINGERPRINT_CHECK_GRACE_MS) => {
+			if (done) return result;
+			let timer;
+			const late = new Promise((resolve) => {
+				timer = setTimeout(() => resolve(null), graceMs);
+			});
+			const settled = await Promise.race([result, late]);
+			clearTimeout(timer);
+			if (settled) return settled;
+			abandoned = true;
+			controller.abort();
+			debugLog.log("fingerprint_memo_check", {
+				platform: target.platform,
+				status: "abandoned"
+			});
+			return {
+				status: "abandoned",
+				recorded: stored.hash,
+				current: null
+			};
+		},
+		cancel: () => controller.abort()
+	};
+}
+/**
+* The fingerprint for a pre-mutation cache lookup. With `consult`, a record of this machine's Stim home whose static
+* digest matches the tree stands in for the full fingerprint, and with `record` a full fingerprint then runs in the
+* background as `check`; the record is removed until that check agrees. With `record`, a full fingerprint is
+* recorded under the tree's static digest, only when the digest did not change while it was computed. Any memo
+* failure falls back to the full fingerprint; errors from the fingerprint itself propagate.
+*/
+async function memoizedFingerprint(projectRoot, target, { consult, record, operation, fingerprint = fingerprintProject, background = runBackgroundFingerprint, staticDigest = staticFingerprint, now = Date.now }) {
+	const full = () => fingerprint(projectRoot, target);
+	const skip = (reason) => debugLog.log("fingerprint_memo_skip", {
+		platform: target.platform,
+		reason
+	});
+	if (!operation || !(consult || record)) return {
+		fingerprint: await full(),
+		memoHit: false,
+		check: null
+	};
+	const digestNow = async () => {
+		try {
+			const result = await staticDigest(projectRoot, target, {
+				env: operation.env,
+				signal: operation.signal
+			});
+			if (result.uncertain !== null) {
+				skip(result.uncertain);
+				return null;
+			}
+			return result;
+		} catch (error) {
+			operation.signal.throwIfAborted();
+			skip(errorMessage(error));
+			return null;
+		}
+	};
+	const before = await digestNow();
+	if (!before) return {
+		fingerprint: await full(),
+		memoHit: false,
+		check: null
+	};
+	if (consult) try {
+		const stored = readFingerprintMemo(target.platform, before.digest);
+		if (!stored) skip("no record");
+		else if (!isSourceList(stored.sources)) skip("the record has unknown sources");
+		else {
+			if (record) dropRecord(target.platform, before.digest);
+			debugLog.log("fingerprint_memo_hit", { platform: target.platform });
+			trace.mark("fingerprint memo hit", { platform: target.platform });
+			return {
+				fingerprint: {
+					hash: stored.hash,
+					sources: stored.sources
+				},
+				memoHit: true,
+				check: record ? startCheck(operation, projectRoot, target, stored, background) : null
+			};
+		}
+	} catch (error) {
+		skip(errorMessage(error));
+	}
+	const startedAt = now();
+	const computed = await full();
+	if (!record || !computed?.hash) return {
+		fingerprint: computed,
+		memoHit: false,
+		check: null
+	};
+	if ((await digestNow())?.digest !== before.digest) skip("an input changed while it was fingerprinted");
+	else try {
+		writeRecord({
+			schema: FINGERPRINT_MEMO_SCHEMA,
+			platform: target.platform,
+			digest: before.digest,
+			recordedAt: startedAt,
+			hash: computed.hash,
+			sources: computed.sources,
+			nativePackages: before.nativePackages
+		});
+	} catch (error) {
+		skip(errorMessage(error));
+	}
+	return {
+		fingerprint: computed,
+		memoHit: false,
+		check: null
+	};
+}
+/** Waits briefly for a memo hit's background check and reports a disagreement, which has already dropped the record. */
+async function settleFingerprintCheck(check, platform, warn, log) {
+	if (!check) return;
+	const { status, recorded, current, unmodeled } = await check.settle();
+	if (status !== "stale" || !current) return;
+	const line = `the recorded fingerprint ${shortHash(recorded)} no longer matches the tree (${shortHash(current)}), so this run looked up the build cache with a stale key; run stim ${platform} again to use the current tree`;
+	warn(line);
+	log?.({
+		src: "build",
+		level: "warn",
+		event: "fingerprint_memo_stale",
+		msg: line,
+		recorded,
+		current,
+		...unmodeled?.length ? { unmodeled } : {}
+	});
+}
+//#endregion
+//#region src/cache/miss-reason.ts
+const MISS_CHANGE_CAP = 20;
+function recordedBuilds(state, platform) {
+	const builds = [];
+	for (const value of [state?.[LAST_BUILD_KEYS[platform]], state?.lastBuild]) {
+		const record = value;
+		if (record?.platform !== platform) continue;
+		const startedAt = typeof record.startedAt === "string" ? record.startedAt : "";
+		if (typeof record.fingerprint === "string" && typeof record.cacheKey === "string") builds.push({
+			fingerprint: record.fingerprint,
+			cacheKey: record.cacheKey,
+			startedAt
+		});
+		const carried = record.missReason?.baseline;
+		if (typeof carried?.fingerprint === "string" && typeof carried.cacheKey === "string") builds.push({
+			fingerprint: carried.fingerprint,
+			cacheKey: carried.cacheKey,
+			startedAt
+		});
+	}
+	return builds;
+}
+function projectIdentity(root) {
+	let real;
+	try {
+		real = realpathSync.native(root);
+	} catch {
+		return null;
+	}
+	for (let dir = real;; dir = dirname(dir)) {
+		if (existsSync(join(dir, ".git"))) {
+			const common = gitCommonDirOnDisk(dir);
+			return common ? `${common}\n${relative(dir, real)}` : null;
+		}
+		if (dirname(dir) === dir) return null;
+	}
+}
+function findMissBaseline(root, platform, { readState = readWorkspaceState, projectRoots = () => Object.keys(loadConfig()?.projects ?? {}), identity = projectIdentity, sourcesOf = (p, key) => storedSources(p, key, sharedBuildCache()) } = {}) {
+	for (const build of recordedBuilds(readState(root), platform)) {
+		const sources = sourcesOf(platform, build.cacheKey);
+		if (sources) return {
+			fingerprint: build.fingerprint,
+			cacheKey: build.cacheKey,
+			sources,
+			from: "workspace"
+		};
+	}
+	const project = identity(root);
+	if (!project) return null;
+	const others = [];
+	for (const other of projectRoots()) {
+		if (other === root || identity(other) !== project) continue;
+		others.push(...recordedBuilds(readState(other), platform));
+	}
+	for (const build of others.toSorted((a, b) => (Date.parse(b.startedAt) || 0) - (Date.parse(a.startedAt) || 0))) {
+		const sources = sourcesOf(platform, build.cacheKey);
+		if (sources) return {
+			fingerprint: build.fingerprint,
+			cacheKey: build.cacheKey,
+			sources,
+			from: "project"
+		};
+	}
+	return null;
+}
+const CATEGORY_RANK = {
+	"native-dependency": 0,
+	"app-config": 1,
+	"config-plugin": 2,
+	package: 3,
+	"native-dir": 4,
+	file: 5,
+	"app-asset": 6,
+	other: 7,
+	"package-scripts": 8,
+	autolinking: 9
+};
+function describeChange({ name, change, reasons }) {
+	const pkg = packageIn(name);
+	if (name === "expoConfig" || reasons.includes("expoConfig")) return {
+		category: "app-config",
+		label: "app config changed"
+	};
+	if (pkg && reasons.some((reason) => /^(expo|rncore)Autolinking(Ios|Android)?$/.test(reason))) return {
+		category: "native-dependency",
+		label: `native dependency ${change}: ${pkg}`
+	};
+	if (pkg && reasons.includes("expoConfigPlugins")) return {
+		category: "config-plugin",
+		label: `config plugin ${change}: ${pkg}`
+	};
+	if (/^(expoAutolinkingConfig|rncoreAutolinkingConfig)(:|$)/.test(name)) return {
+		category: "autolinking",
+		label: "autolinking config changed"
+	};
+	if (name.startsWith("package:")) return {
+		category: "package",
+		label: `${name.slice(8)} ${change}`
+	};
+	if (name === "packageJson:scripts") return {
+		category: "package-scripts",
+		label: "package.json scripts changed"
+	};
+	if (reasons.includes("expoConfigExternalFile")) return {
+		category: "app-asset",
+		label: `app asset ${change}: ${name}`
+	};
+	if (reasons.includes("bareNativeDir")) return {
+		category: "native-dir",
+		label: `${name}/ ${change}`
+	};
+	if (reasons.length || name.includes("/") || name.includes(".")) return {
+		category: "file",
+		label: `${name} ${change}`
+	};
+	return {
+		category: "other",
+		label: `${name} ${change}`
+	};
+}
+function rekeyPrefix(rekeyedBy) {
+	return rekeyedBy.length ? `${rekeyedBy.join(" and ")} changed native inputs; ` : "";
+}
+function missReasonFromChanges({ changes, baseline, rekeyedBy = [] }) {
+	const prefix = rekeyPrefix(rekeyedBy);
+	if (!baseline) return {
+		kind: "no-baseline",
+		summary: `${prefix}no earlier build of this project in the cache to compare with`,
+		changes: [],
+		changeCount: 0,
+		baseline: null,
+		rekeyedBy
+	};
+	if (!changes.length) return {
+		kind: "same-sources",
+		summary: `${prefix}native inputs match the last build; no cached app for this configuration or target`,
+		changes: [],
+		changeCount: 0,
+		baseline,
+		rekeyedBy
+	};
+	const described = changes.map((change, index) => ({
+		change,
+		index,
+		...describeChange(change)
+	})).toSorted((a, b) => CATEGORY_RANK[a.category] - CATEGORY_RANK[b.category] || a.index - b.index);
+	const dependencyMoved = described.some((entry) => entry.category === "native-dependency");
+	const labels = [...new Set(described.filter((entry) => !(dependencyMoved && entry.category === "autolinking")).map((entry) => entry.label))];
+	const more = labels.length > 1 ? ` (+${labels.length - 1} more)` : "";
+	return {
+		kind: "changed",
+		summary: `${prefix}${labels[0]}${more}`,
+		changes: described.slice(0, MISS_CHANGE_CAP).map(({ change, category }) => ({
+			source: change.name,
+			change: change.change,
+			category
+		})),
+		changeCount: changes.length,
+		baseline,
+		rekeyedBy
+	};
+}
+function explainBuildMiss({ root, platform, current, rekeyedBy = [], baselineDeps, differ = expoFingerprint.diffFingerprints }) {
+	const baseline = findMissBaseline(root, platform, baselineDeps);
+	const changes = baseline ? diffFingerprintSources({
+		previous: baseline.sources,
+		previousHash: baseline.fingerprint,
+		current,
+		differ
+	}) : [];
+	return {
+		reason: missReasonFromChanges({
+			changes,
+			baseline: baseline ? {
+				fingerprint: baseline.fingerprint,
+				cacheKey: baseline.cacheKey,
+				from: baseline.from
+			} : null,
+			rekeyedBy
+		}),
+		changedNames: changes.map((change) => change.name),
+		previousHash: baseline?.fingerprint ?? null
+	};
+}
+function predictBuildMiss({ root, platform, current, prebuild }) {
+	const { reason } = explainBuildMiss({
+		root,
+		platform,
+		current
+	});
+	const baseline = reason.baseline && {
+		fingerprint: reason.baseline.fingerprint,
+		from: reason.baseline.from
+	};
+	if (!prebuild || !baseline) return {
+		...reason,
+		baseline
+	};
+	const dir = platform === "ios" ? "ios/" : "android/";
+	return {
+		...reason,
+		kind: "prebuild-pending",
+		summary: `${reason.summary} (before prebuild ${prebuild}s ${dir})`,
+		baseline
+	};
+}
+function skippedMissReason(summary) {
+	return {
+		kind: "cache-skipped",
+		summary,
+		changes: [],
+		changeCount: 0,
+		baseline: null,
+		rekeyedBy: []
+	};
+}
+function fingerprintErrorMissReason(message) {
+	return {
+		kind: "fingerprint-error",
+		summary: `fingerprinting failed: ${message}`,
+		changes: [],
+		changeCount: 0,
+		baseline: null,
+		rekeyedBy: []
+	};
+}
+//#endregion
+//#region src/engine/prebuild.ts
+const PREBUILD_ERROR = "STIM_PREBUILD_FAILED";
+const LAST_LINES = 20;
+function nativeDirName(platform) {
+	return platform === "android" ? "android" : "ios";
+}
+function nativeDir(root, platform) {
+	return join(root, nativeDirName(platform));
+}
+function nativeDirInFingerprint(sources, platform) {
+	const dir = nativeDirName(platform);
+	return sources.some((source) => source.type === "dir" && source.filePath === dir && source.hash != null);
+}
+/**
+* @expo/fingerprint leaves a native directory out of the hash when git ignores it (CNG), so the cache
+* key only covers that directory when this workspace's recorded prebuild ran on the same fingerprint.
+*/
+function prebuildAction({ isExpo, nativeDirExists, nativeDirFingerprinted, nativeDirTracked, generatedFrom, fingerprint }) {
+	if (!isExpo) return "none";
+	if (!nativeDirExists) return "generate";
+	if (nativeDirFingerprinted || generatedFrom === fingerprint) return "none";
+	return nativeDirTracked ? "refuse" : "regenerate";
+}
+function prebuildRecord(state) {
+	const record = state?.prebuild;
+	return record && typeof record === "object" ? record : {};
+}
+function unreadableGitTracksNativeDir(error) {
+	if (error instanceof Error && "code" in error && error.code === "ENOENT") return false;
+	return !/not a git repository \(or any (of the parent directories|parent up to mount point)/.test(error instanceof Error ? error.message : String(error));
+}
+function gitTracksNativeDir(root, platform) {
+	try {
+		return git(root, [
+			"ls-files",
+			"--",
+			nativeDirName(platform)
+		], { env: {
+			LC_ALL: "C",
+			LANGUAGE: "C"
+		} }).trim() !== "";
+	} catch (error) {
+		return unreadableGitTracksNativeDir(error);
+	}
+}
+function prebuildInputs(root, platform, { isExpo, fingerprint, sources }) {
+	const nativeDirExists = existsSync(nativeDir(root, platform));
+	const fingerprinted = nativeDirInFingerprint(sources, platform);
+	const generatedFrom = prebuildRecord(readWorkspaceState$1(root))[platform];
+	return {
+		isExpo,
+		nativeDirExists,
+		nativeDirFingerprinted: fingerprinted,
+		generatedFrom: typeof generatedFrom === "string" ? generatedFrom : null,
+		fingerprint
+	};
+}
+function planPrebuild(root, platform, options) {
+	const inputs = prebuildInputs(root, platform, options);
+	return prebuildAction({
+		...inputs,
+		nativeDirTracked: inputs.nativeDirExists && !inputs.nativeDirFingerprinted && gitTracksNativeDir(root, platform)
+	});
+}
+async function planPrebuildAsync(root, platform, options, signal) {
+	signal?.throwIfAborted();
+	const untracked = prebuildAction({
+		...prebuildInputs(root, platform, options),
+		nativeDirTracked: false
+	});
+	if (untracked !== "regenerate") return untracked;
+	let tracked;
+	try {
+		tracked = (await gitAsync(root, [
+			"ls-files",
+			"--",
+			nativeDirName(platform)
+		], {
+			env: {
+				LC_ALL: "C",
+				LANGUAGE: "C"
+			},
+			signal
+		})).trim() !== "";
+	} catch (error) {
+		signal?.throwIfAborted();
+		tracked = unreadableGitTracksNativeDir(error);
+	}
+	return tracked ? "refuse" : "regenerate";
+}
+function recordPrebuild(root, platform, fingerprint) {
+	updateWorkspaceState(root, (state) => ({
+		...state,
+		prebuild: {
+			...prebuildRecord(state),
+			[platform]: fingerprint
+		}
+	}));
+}
+/** Records the prebuild fingerprint after waiting for the workspace state lock without blocking the event loop. */
+function recordPrebuildAsync(root, platform, fingerprint) {
+	return withWorkspaceStateLockAsync(root, () => recordPrebuild(root, platform, fingerprint));
+}
+/**
+* @expo/cli 57 made `expo prebuild` delete existing native folders by default and added `--no-clean`
+* to keep them (expo/expo#47209); earlier CLIs keep them by default and reject `--no-clean`.
+*/
+function keepNativeDirArgs(root) {
+	return (expoSdkMajor(root) ?? 0) >= 57 ? ["--no-clean"] : [];
+}
+function staleNativeDirRemedy(platform) {
+	const dir = nativeDirName(platform);
+	return `Fix what the output above reports. Stim ran \`expo prebuild\` over the existing ${dir}/ without deleting it, which keeps what earlier config plugins wrote there. If ${dir}/ predates a removed config plugin or an Expo SDK upgrade, delete ${dir}/ and run again so Stim generates it fresh.`;
+}
+function staleNativeDirRefusal(platform) {
+	const dir = nativeDirName(platform);
+	return {
+		code: PREBUILD_ERROR,
+		message: `The fingerprint leaves ${dir}/ out of the cache key, and Stim cannot show that ${dir}/ was generated from the current app config. Git tracks files in it, or could not say whether it does, so Stim will not run \`expo prebuild\` over it.`,
+		remedy: `Stop excluding ${dir}/ from the fingerprint (check .fingerprintignore) so the cache key covers its files, or add ${dir}/ to .gitignore and untrack it so Stim regenerates it from the app config.`
+	};
+}
+function prebuildRefusal({ isExpo, platform, nativeDirExists }) {
+	if (nativeDirExists || isExpo) return null;
+	const dir = nativeDirName(platform);
+	return {
+		code: PREBUILD_ERROR,
+		message: `This project has no ${dir}/ directory and is not an Expo (CNG) project, so Stim cannot generate one.`,
+		remedy: `Check out or generate the native project (\`npx @react-native-community/cli init\` produced one originally), or add \`expo\` to the project so \`expo prebuild\` can create ${dir}/.`
+	};
+}
+function prebuildFailure(logWriter, result) {
+	logWriter?.write?.({
+		src: "build",
+		level: "error",
+		msg: result.reason || "Expo prebuild failed.",
+		event: "prebuild_failed"
+	});
+	return result;
+}
+async function runPrebuild(root, platform, logWriter, { spawnFn = null, now = Date.now, isExpo = null, clean = false } = {}) {
+	const dirExists = existsSync(nativeDir(root, platform));
+	const refusal = prebuildRefusal({
+		isExpo: isExpo === null ? detectIsExpo(root) : isExpo,
+		platform,
+		nativeDirExists: dirExists
+	});
+	if (refusal) return prebuildFailure(logWriter, {
+		failed: true,
+		code: refusal.code,
+		reason: refusal.message,
+		remedy: refusal.remedy,
+		error: refusal,
+		lastLines: []
+	});
+	const bin = expoBinPath(root);
+	if (!bin) {
+		const binRefusal = expoBinRefusal(root, "prebuild");
+		return prebuildFailure(logWriter, {
+			failed: true,
+			code: PREBUILD_ERROR,
+			reason: binRefusal.message,
+			remedy: binRefusal.remedy,
+			lastLines: []
+		});
+	}
+	const spawn = spawnFn || ((cmd, args, opts) => getExecutor().spawn(cmd, args, opts));
+	const startedAt = now();
+	const tail = [];
+	const push = (line) => {
+		const msg = stripAnsi(String(line)).trimEnd();
+		if (!msg.trim()) return;
+		tail.push(msg);
+		if (tail.length > LAST_LINES) tail.shift();
+		logWriter?.write?.({
+			src: "build",
+			level: "debug",
+			msg,
+			raw: true,
+			event: "prebuild"
+		});
+	};
+	let child;
+	try {
+		const invocation = remoteCliInvocation(bin, [
+			"prebuild",
+			"-p",
+			platform,
+			"--no-install",
+			...clean ? ["--clean"] : dirExists ? keepNativeDirArgs(root) : []
+		], "expo");
+		child = spawnDeclared(ambientContext(), () => spawn(invocation.file, invocation.args, {
+			cwd: root,
+			stdio: [
+				"ignore",
+				"pipe",
+				"pipe"
+			],
+			env: {
+				...ambientContext()?.env ?? process.env,
+				...expoTelemetryEnv(ambientContext()?.env ?? process.env),
+				FORCE_COLOR: "0",
+				CI: "1"
+			}
+		}));
+	} catch (err) {
+		return prebuildFailure(logWriter, {
+			failed: true,
+			code: PREBUILD_ERROR,
+			reason: `Could not run \`expo prebuild\`: ${err?.message || err}`,
+			lastLines: []
+		});
+	}
+	const outReader = createLineReader(push);
+	const errReader = createLineReader(push);
+	child.stdout?.setEncoding?.("utf-8");
+	child.stderr?.setEncoding?.("utf-8");
+	child.stdout?.on("data", (chunk) => outReader.push(chunk));
+	child.stderr?.on("data", (chunk) => errReader.push(chunk));
+	const result = await waitForChild(child);
+	outReader.flush();
+	errReader.flush();
+	const durationMs = now() - startedAt;
+	if (result.error) return prebuildFailure(logWriter, {
+		failed: true,
+		code: PREBUILD_ERROR,
+		reason: `Could not run \`expo prebuild\`: ${result.error?.message || result.error}`,
+		lastLines: tail.slice(),
+		durationMs
+	});
+	if (result.code !== 0) {
+		const how = result.signal ? `signal ${result.signal}` : `exit code ${result.code}`;
+		return prebuildFailure(logWriter, {
+			failed: true,
+			code: PREBUILD_ERROR,
+			reason: `\`expo prebuild -p ${platform}\` failed (${how}).`,
+			...dirExists && !clean ? { remedy: staleNativeDirRemedy(platform) } : {},
+			lastLines: tail.slice(),
+			durationMs
+		});
+	}
+	if (!existsSync(nativeDir(root, platform))) return prebuildFailure(logWriter, {
+		failed: true,
+		code: PREBUILD_ERROR,
+		reason: `\`expo prebuild -p ${platform}\` succeeded but did not create ${nativeDirName(platform)}/.`,
+		lastLines: tail.slice(),
+		durationMs
+	});
+	return {
+		ok: true,
+		durationMs,
+		nativeDir: nativeDir(root, platform)
+	};
+}
+//#endregion
+export { runPrebuild as a, fingerprintErrorMissReason as c, memoizedFingerprint as d, settleFingerprintCheck as f, recordPrebuildAsync as i, predictBuildMiss as l, planPrebuildAsync as n, staleNativeDirRefusal as o, recordPrebuild as r, explainBuildMiss as s, planPrebuild as t, skippedMissReason as u };