stim 1.0.0 → 1.1.0

package/dist/settings-BSwrY4FZ.mjs

@@ -0,0 +1,687 @@
+import { d as getConfigPath, g as loadConfig, m as getRepoSettings, p as getProjectSettings } from "./config-D7uu8Gbq.mjs";
+import { g as repoRoot, s as gitCommonDir } from "./worktree-Dx3ZC5lS.mjs";
+import { createHash } from "node:crypto";
+import { isAbsolute } from "node:path";
+import { existsSync, readFileSync, realpathSync, statSync } from "fs";
+import { isAbsolute as isAbsolute$1, join as join$1, relative as relative$1, resolve as resolve$1, sep as sep$1 } from "path";
+//#region src/optimizations.ts
+const OPTIMIZATION_SHAPES = {
+	optimizations: "object",
+	"optimizations.buildCache": "boolean",
+	"optimizations.remoteBuildCache": "boolean",
+	"optimizations.releaseBundleSwap": "boolean",
+	"optimizations.metroSharedCache": "boolean",
+	"optimizations.ios": "object",
+	"optimizations.ios.compilationCache": "boolean",
+	"optimizations.ios.swiftCompilationCache": "boolean",
+	"optimizations.ios.prefixMapping": "boolean",
+	"optimizations.android": "object",
+	"optimizations.android.compilerCache": "string",
+	"optimizations.android.casToolchain": "path",
+	"optimizations.android.pch": "string",
+	"optimizations.android.gradleBuildCache": "boolean",
+	"optimizations.android.targetAbiOnly": "boolean"
+};
+function compilerCacheFallbackMessage({ fallback, compilerCache, file = null }) {
+	const origin = fallback.fromEnvironment ? "the environment" : file;
+	const backend = compilerCache === "none" ? "Android builds use no compiler cache, because optimizations.android.compilerCache is \"none\"." : "Android builds fall back to ccache when it is available.";
+	return `${fallback.key}${origin ? ` in ${origin}` : ""} ${fallback.reason}. ${backend}`;
+}
+function optimizationBuildProfile(platform, options) {
+	const selected = platform === "ios" ? options.ios : { pch: options.android.pch };
+	const defaults = platform === "ios" ? {
+		compilationCache: true,
+		swiftCompilationCache: false,
+		prefixMapping: true
+	} : { pch: "auto" };
+	if (JSON.stringify(selected) === JSON.stringify(defaults)) return void 0;
+	return `opt-${createHash("sha256").update(JSON.stringify(selected)).digest("hex").slice(0, 16)}`;
+}
+function resolveOptimizations(settings = {}, env = process.env) {
+	function choice(path, choices, fallback) {
+		const raw = optimizationValue(settings, path);
+		if (raw === void 0) return fallback;
+		if (typeof raw !== "string" || !choices.includes(raw)) throw new Error(`Invalid optimizations.${path}. Expected ${choices.join(", ")}.`);
+		return raw;
+	}
+	const compiler = choice("android.compilerCache", [
+		"auto",
+		"ccache",
+		"cas",
+		"none"
+	], "auto");
+	const fromEnvironment = Boolean(env.STIM_ANDROID_CAS_TOOLCHAIN);
+	const manifest = env.STIM_ANDROID_CAS_TOOLCHAIN || optimizationValue(settings, "android.casToolchain");
+	let fallback = null;
+	let toolchain = null;
+	if (manifest !== void 0) {
+		if (typeof manifest === "string" && isAbsolute(manifest) && !/[\r\n\0]/.test(manifest)) toolchain = manifest;
+		else fallback = {
+			key: fromEnvironment ? "STIM_ANDROID_CAS_TOOLCHAIN" : "optimizations.android.casToolchain",
+			reason: `is ${JSON.stringify(manifest)}, which is not an absolute path to a toolchain JSON manifest`,
+			fromEnvironment,
+			manifest: null
+		};
+	}
+	let compilerCache = compiler === "auto" ? toolchain ? "cas" : "ccache" : compiler;
+	if (compilerCache === "cas" && !toolchain) {
+		fallback ??= {
+			key: "optimizations.android.compilerCache",
+			reason: "is \"cas\", but no optimizations.android.casToolchain or STIM_ANDROID_CAS_TOOLCHAIN names the toolchain manifest",
+			fromEnvironment: false,
+			manifest: null
+		};
+		compilerCache = "ccache";
+	}
+	return {
+		buildCache: optimizationBoolean(settings, "buildCache"),
+		remoteBuildCache: optimizationBoolean(settings, "remoteBuildCache"),
+		releaseBundleSwap: optimizationBoolean(settings, "releaseBundleSwap"),
+		metroSharedCache: optimizationBoolean(settings, "metroSharedCache"),
+		ios: {
+			compilationCache: optimizationBoolean(settings, "ios.compilationCache"),
+			swiftCompilationCache: optimizationBoolean(settings, "ios.swiftCompilationCache", false),
+			prefixMapping: optimizationBoolean(settings, "ios.prefixMapping")
+		},
+		android: {
+			compilerCache,
+			casToolchain: toolchain,
+			compilerCacheFallback: fallback,
+			pch: choice("android.pch", [
+				"auto",
+				"on",
+				"off"
+			], "auto"),
+			gradleBuildCache: optimizationBoolean(settings, "android.gradleBuildCache"),
+			targetAbiOnly: optimizationBoolean(settings, "android.targetAbiOnly")
+		}
+	};
+}
+function artifactCachePolicy(options, reuse, release) {
+	return {
+		read: reuse && options.buildCache && (!release || options.releaseBundleSwap),
+		write: options.buildCache,
+		remote: options.buildCache && options.remoteBuildCache
+	};
+}
+function optimizationValue(settings, path) {
+	let node = settings;
+	for (const key of ["optimizations", ...path.split(".")]) {
+		if (node === void 0) return void 0;
+		if (!node || typeof node !== "object" || Array.isArray(node)) throw new Error("Invalid optimizations setting. Expected nested objects.");
+		node = node[key];
+	}
+	return node;
+}
+function optimizationBoolean(settings, path, fallback = true) {
+	const raw = optimizationValue(settings, path);
+	if (raw === void 0) return fallback;
+	if (typeof raw !== "boolean") throw new Error(`Invalid optimizations.${path}. Expected true or false.`);
+	return raw;
+}
+function resolveMetroSharedCache(settings) {
+	return optimizationBoolean(settings, "metroSharedCache");
+}
+//#endregion
+//#region src/engine/metro-reach.ts
+const TUNNEL_MODES = [
+	"auto",
+	"off",
+	"expo",
+	"cloudflared",
+	"ngrok"
+];
+const PUBLIC_METRO_ENV = "STIM_METRO_PUBLIC_URL";
+const MANAGED_PROVIDERS = ["ngrok", "cloudflared"];
+const NAMED = {
+	cloudflared: "`cloudflared` (brew install cloudflared)",
+	ngrok: "`ngrok` (brew install ngrok, then `ngrok config add-authtoken <token>`)"
+};
+function planMetroReach({ mode, metroPort, publicUrl = null, isExpo, available = [] }) {
+	const named = publicUrl?.trim().replace(/\/+$/, "") || null;
+	if (mode === "off") return {
+		origin: `http://localhost:${metroPort}`,
+		gate: false
+	};
+	if (named) return {
+		origin: named,
+		gate: true
+	};
+	if (mode === "expo") {
+		if (!isExpo) return {
+			failed: "metro.tunnel is \"expo\", but this workspace does not run an Expo dev server.",
+			remedy: "Use \"auto\" to let stim start a tunnel, or \"off\" if the device shares this machine."
+		};
+		return { expoTunnel: true };
+	}
+	if (mode === "cloudflared" || mode === "ngrok") {
+		if (!available.includes(mode)) return {
+			failed: `metro.tunnel is "${mode}", but ${mode} is not on PATH.`,
+			remedy: `Install ${NAMED[mode] ?? mode}, or set metro.tunnel to "auto".`
+		};
+		return { start: mode };
+	}
+	const provider = available[0];
+	if (provider) return { start: provider };
+	return {
+		failed: `A remote device cannot reach this workspace's Metro on port ${metroPort}, and no tunnel is available to give it one.`,
+		remedy: `Install ${NAMED.ngrok} or ${NAMED.cloudflared} and Stim will manage the tunnel for you. If you already have one, set metro.publicUrl to its URL. If the device shares this machine (a local \`agent-device proxy\`), set metro.tunnel to "off".`
+	};
+}
+function detectProviders(onPath) {
+	return MANAGED_PROVIDERS.filter((p) => onPath(p));
+}
+//#endregion
+//#region src/settings.ts
+function isPlainObject(v) {
+	return v !== null && typeof v === "object" && !Array.isArray(v);
+}
+function mergeSettingsLayers(layers) {
+	const out = {};
+	for (const layer of layers) {
+		if (!isPlainObject(layer)) continue;
+		for (const [key, value] of Object.entries(layer)) if (isPlainObject(value) && isPlainObject(out[key])) out[key] = mergeSettingsLayers([out[key], value]);
+		else if (!(key in out)) out[key] = value;
+	}
+	return out;
+}
+const SETTING_SHAPE_RULES = {
+	boolean: {
+		expected: "true or false",
+		accepts: (value) => typeof value === "boolean"
+	},
+	string: {
+		expected: "a string",
+		accepts: (value) => typeof value === "string"
+	},
+	path: {
+		expected: "a string path",
+		accepts: (value) => typeof value === "string"
+	},
+	strings: {
+		expected: "an array of strings",
+		accepts: (value) => Array.isArray(value) && value.every((entry) => typeof entry === "string")
+	},
+	number: {
+		expected: "a number",
+		accepts: (value) => typeof value === "number"
+	},
+	object: {
+		expected: "an object",
+		accepts: isPlainObject
+	}
+};
+const SETTING_SHAPES = {
+	...OPTIMIZATION_SHAPES,
+	"ios.deviceType": "string",
+	"ios.runtime": "string",
+	"ios.configuration": "string",
+	"ios.remote": "string",
+	"ios.simslimProfile": "path",
+	"ios.signingIdentity": "string",
+	"ios.signingIdentitySha1": "string",
+	"ios.lanHost": "string",
+	"android.systemImage": "string",
+	"android.dataPartitionSizeGb": "number",
+	"android.avdConfigFile": "path",
+	"android.avdConfig": "object",
+	"android.variant": "string",
+	"android.keystore": "path",
+	"android.keystorePassword": "string",
+	"android.remote": "string",
+	"metro.tunnel": "string",
+	"metro.ngrokUrl": "string",
+	"metro.publicUrl": "string",
+	"worktree.exclude": "strings",
+	"worktree.defaultBranch": "string",
+	"cache.provider": "string",
+	"cache.options": "object",
+	caches: "strings"
+};
+const KNOWN_SETTINGS = new Set(Object.keys(SETTING_SHAPES));
+const SETTINGS_WITH_RESOLVE_TIME_FALLBACK = /* @__PURE__ */ new Set(["optimizations.android.casToolchain"]);
+const PATH_SETTINGS = Object.freeze(Object.entries(SETTING_SHAPES).filter(([, shape]) => shape === "path").map(([path]) => path));
+function settingValueAt(settings, path) {
+	let node = settings;
+	for (const segment of path.split(".")) {
+		if (!isPlainObject(node)) return void 0;
+		node = node[segment];
+	}
+	return node;
+}
+function settingShapeErrors(settings) {
+	const errors = [];
+	for (const [path, shape] of Object.entries(SETTING_SHAPES)) {
+		if (SETTINGS_WITH_RESOLVE_TIME_FALLBACK.has(path)) continue;
+		const value = settingValueAt(settings, path);
+		if (value === void 0) continue;
+		const rule = SETTING_SHAPE_RULES[shape];
+		if (rule.accepts(value)) continue;
+		errors.push(`Invalid ${path} setting ${JSON.stringify(value)}. Expected ${rule.expected}.`);
+	}
+	return errors;
+}
+const SETTING_SHAPE_REMEDY = "Run `stim guide settings` for the shape each setting takes.";
+const MAX_ANDROID_DATA_PARTITION_SIZE_GB = 16384;
+function validateAndroidDataPartitionSizeGb(raw) {
+	if (typeof raw !== "number" || !Number.isSafeInteger(raw) || raw < 6 || raw > 16384) throw new Error(`Invalid android.dataPartitionSizeGb setting ${JSON.stringify(raw)}. Expected an integer from 6 through ${MAX_ANDROID_DATA_PARTITION_SIZE_GB} GiB.`);
+	return raw;
+}
+function androidDataPartitionSizeBytes(sizeGb) {
+	return validateAndroidDataPartitionSizeGb(sizeGb) * 1024 ** 3;
+}
+function androidDataPartitionSizeGbRaw(settings) {
+	if (!isPlainObject(settings) || !isPlainObject(settings.android)) return void 0;
+	return settings.android.dataPartitionSizeGb;
+}
+function androidDataPartitionSizeGbSetting(settings) {
+	const raw = androidDataPartitionSizeGbRaw(settings);
+	if (raw === void 0) return 8;
+	return validateAndroidDataPartitionSizeGb(raw);
+}
+function androidDataPartitionSizeGbSettingError(settings) {
+	try {
+		androidDataPartitionSizeGbSetting(settings);
+		return null;
+	} catch (error) {
+		return String(error?.message || error);
+	}
+}
+function yesNoAvdValue(value) {
+	if (value === true || value === "true" || value === "yes") return "yes";
+	if (value === false || value === "false" || value === "no") return "no";
+	throw new Error("expected true, false, \"yes\", or \"no\"");
+}
+function boundedIntegerAvdRule(min, max, unit) {
+	return {
+		help: `integer ${min}-${max}${unit ? ` ${unit}` : ""}`,
+		parse: (value) => {
+			const parsed = typeof value === "number" ? value : typeof value === "string" && /^(0|[1-9]\d*)$/.test(value) ? Number(value) : NaN;
+			if (!Number.isSafeInteger(parsed) || parsed < min || parsed > max) throw new Error(`expected an integer from ${min} through ${max}${unit ? ` ${unit}` : ""}`);
+			return String(parsed);
+		}
+	};
+}
+function enumAvdRule(values) {
+	return {
+		help: values.join("|"),
+		parse: (value) => {
+			if (typeof value !== "string" || !values.includes(value)) throw new Error(`expected one of: ${values.join(", ")}`);
+			return value;
+		}
+	};
+}
+const ANDROID_AVD_CONFIG_RULES = {
+	"hw.cpu.ncore": boundedIntegerAvdRule(1, 64),
+	"hw.gpu.mode": enumAvdRule([
+		"auto",
+		"host",
+		"software",
+		"lavapipe",
+		"swiftshader",
+		"swangle"
+	]),
+	"hw.initialOrientation": enumAvdRule(["portrait", "landscape"]),
+	"hw.lcd.density": boundedIntegerAvdRule(72, 1e3, "dpi"),
+	"hw.lcd.vsync": boundedIntegerAvdRule(1, 1e3, "Hz"),
+	"hw.ramSize": boundedIntegerAvdRule(1536, 8192, "MB"),
+	"hw.screen": enumAvdRule([
+		"no-touch",
+		"touch",
+		"multi-touch"
+	]),
+	"runtime.network.latency": enumAvdRule([
+		"none",
+		"gsm",
+		"hscsd",
+		"gprs",
+		"edge",
+		"umts",
+		"hsdpa",
+		"lte",
+		"evdo",
+		"5g"
+	]),
+	"runtime.network.speed": enumAvdRule([
+		"gsm",
+		"hscsd",
+		"gprs",
+		"edge",
+		"umts",
+		"hsdpa",
+		"lte",
+		"evdo",
+		"5g",
+		"full"
+	]),
+	"vm.heapSize": boundedIntegerAvdRule(16, 4096, "MB")
+};
+const YES_NO_AVD_RULE = {
+	help: "true|false|yes|no",
+	parse: yesNoAvdValue
+};
+for (const key of [
+	"hw.accelerometer",
+	"hw.accelerometer_uncalibrated",
+	"hw.audioInput",
+	"hw.audioOutput",
+	"hw.battery",
+	"hw.dPad",
+	"hw.gps",
+	"hw.gpu.enabled",
+	"hw.gyroscope",
+	"hw.keyboard",
+	"hw.mainKeys",
+	"hw.rotaryInput",
+	"hw.trackBall",
+	"showDeviceFrame"
+]) ANDROID_AVD_CONFIG_RULES[key] = YES_NO_AVD_RULE;
+const ANDROID_AVD_CONFIG_KEYS = Object.freeze(Object.keys(ANDROID_AVD_CONFIG_RULES).toSorted());
+const ANDROID_AVD_CONFIG_HELP = Object.freeze(ANDROID_AVD_CONFIG_KEYS.map((key) => `${key}: ${ANDROID_AVD_CONFIG_RULES[key].help}`));
+function isSafeAndroidAvdConfigKey(key) {
+	return Object.hasOwn(ANDROID_AVD_CONFIG_RULES, key);
+}
+function normalizedAndroidAvdConfigEntry(key, value) {
+	if (typeof key !== "string" || key !== key.trim() || !isSafeAndroidAvdConfigKey(key)) throw new Error(`Unsupported android.avdConfig key ${JSON.stringify(key)}. Use a documented safe hardware override; identity, path, storage, image, snapshot, and boot-lifecycle keys are protected.`);
+	if (typeof value === "string" && /[\r\n\0]/.test(value)) throw new Error(`Invalid android.avdConfig value for ${key}: expected one line.`);
+	try {
+		return [key, ANDROID_AVD_CONFIG_RULES[key].parse(value)];
+	} catch (error) {
+		throw new Error(`Invalid android.avdConfig value for ${key}: ${String(error?.message || error)}.`, { cause: error });
+	}
+}
+function parseAndroidAvdConfigIni(contents) {
+	const entries = {};
+	const lines = contents.replace(/^\uFEFF/, "").split(/\r?\n/);
+	for (let index = 0; index < lines.length; index++) {
+		const line = String(lines[index] ?? "").trim();
+		if (!line || line.startsWith("#") || line.startsWith(";")) continue;
+		const separator = line.indexOf("=");
+		if (separator <= 0) throw new Error(`Invalid android.avdConfigFile line ${index + 1}: expected key=value.`);
+		const [key, value] = normalizedAndroidAvdConfigEntry(line.slice(0, separator), line.slice(separator + 1).trim());
+		if (Object.hasOwn(entries, key)) throw new Error(`Invalid android.avdConfigFile line ${index + 1}: duplicate key ${key}.`);
+		entries[key] = value;
+	}
+	return entries;
+}
+function pathEscapesRoot(root, path) {
+	const child = relative$1(root, path);
+	return child === ".." || child.startsWith(`..${sep$1}`) || isAbsolute$1(child);
+}
+function androidAvdConfigSetting(settings, settingsRoot) {
+	if (!isPlainObject(settings) || !isPlainObject(settings.android)) return {};
+	const android = settings.android;
+	let entries = {};
+	if ("avdConfigFile" in android) {
+		if (typeof android.avdConfigFile !== "string" || !android.avdConfigFile.trim() || android.avdConfigFile !== android.avdConfigFile.trim() || /[\r\n\0]/.test(android.avdConfigFile) || isAbsolute$1(android.avdConfigFile)) throw new Error("Invalid android.avdConfigFile setting. Expected a relative file path inside the app directory.");
+		try {
+			const root = realpathSync(settingsRoot);
+			const candidate = resolve$1(root, android.avdConfigFile);
+			if (pathEscapesRoot(root, candidate)) throw new Error("path escapes the settings root");
+			const path = realpathSync(candidate);
+			if (pathEscapesRoot(root, path)) throw new Error("symlink target escapes the settings root");
+			const stat = statSync(path);
+			if (!stat.isFile()) throw new Error("path is not a regular file");
+			if (stat.size > 65536) throw new Error("file exceeds 64 KiB");
+			const contents = readFileSync(path, "utf8");
+			if (Buffer.byteLength(contents) > 65536) throw new Error("file exceeds 64 KiB");
+			entries = parseAndroidAvdConfigIni(contents);
+		} catch (error) {
+			throw new Error(`Could not read valid android.avdConfigFile ${android.avdConfigFile}: ${String(error?.message || error)}`, { cause: error });
+		}
+	}
+	if ("avdConfig" in android) {
+		if (!isPlainObject(android.avdConfig)) throw new Error("Invalid android.avdConfig setting. Expected an object of native AVD key/value pairs.");
+		for (const [key, value] of Object.entries(android.avdConfig)) {
+			const [normalizedKey, normalizedValue] = normalizedAndroidAvdConfigEntry(key, value);
+			entries[normalizedKey] = normalizedValue;
+		}
+	}
+	return entries;
+}
+function androidAvdConfigSettingError(settings, projectPath) {
+	try {
+		androidAvdConfigSetting(settings, projectPath);
+		return null;
+	} catch (error) {
+		return String(error?.message || error);
+	}
+}
+function iosSimSlimProfileSetting(settings, settingsRoot) {
+	if (!isPlainObject(settings) || !isPlainObject(settings.ios) || !("simslimProfile" in settings.ios)) return null;
+	const value = settings.ios.simslimProfile;
+	if (typeof value !== "string" || !value.trim() || value !== value.trim() || /[\r\n\0]/.test(value) || isAbsolute$1(value)) throw new Error("Invalid ios.simslimProfile setting. Expected a relative JSON file path inside the app directory.");
+	try {
+		const root = realpathSync(settingsRoot);
+		const candidate = resolve$1(root, value);
+		if (pathEscapesRoot(root, candidate)) throw new Error("path escapes the settings root");
+		const path = realpathSync(candidate);
+		if (pathEscapesRoot(root, path)) throw new Error("symlink target escapes the settings root");
+		const stat = statSync(path);
+		if (!stat.isFile()) throw new Error("path is not a regular file");
+		if (stat.size > 65536) throw new Error("file exceeds 64 KiB");
+		return path;
+	} catch (error) {
+		throw new Error(`Could not read ios.simslimProfile ${value}: ${String(error?.message || error)}`, { cause: error });
+	}
+}
+function iosString(settings, key) {
+	if (!isPlainObject(settings) || !isPlainObject(settings.ios)) return void 0;
+	return settings.ios[key];
+}
+function iosSigningIdentitySetting(settings) {
+	const raw = iosString(settings, "signingIdentity");
+	return typeof raw === "string" && raw.trim() !== "" ? raw.trim() : null;
+}
+function iosSigningIdentitySettingError(settings) {
+	const raw = iosString(settings, "signingIdentity");
+	if (raw === void 0) return null;
+	if (typeof raw !== "string" || raw.trim() === "" || /[\r\n\0]/.test(raw)) return `Invalid ios.signingIdentity setting ${JSON.stringify(raw)}. Expected the identity name \`security find-identity -v -p codesigning\` prints, such as "Apple Development: Jane (TEAMID5678)".`;
+	return null;
+}
+const SIGNING_IDENTITY_SHA1 = /^[0-9A-Fa-f]{40}$/;
+function iosSigningIdentitySha1Setting(settings) {
+	const raw = iosString(settings, "signingIdentitySha1");
+	return typeof raw === "string" && SIGNING_IDENTITY_SHA1.test(raw.trim()) ? raw.trim().toUpperCase() : null;
+}
+function iosSigningIdentitySha1SettingError(settings) {
+	const raw = iosString(settings, "signingIdentitySha1");
+	if (raw === void 0) return null;
+	if (typeof raw !== "string" || !SIGNING_IDENTITY_SHA1.test(raw.trim())) return `Invalid ios.signingIdentitySha1 setting ${JSON.stringify(raw)}. Expected the 40-character hex SHA-1 hash \`security find-identity -v -p codesigning\` prints beside the identity name.`;
+	return null;
+}
+const LAN_HOST = /^(?!-)[A-Za-z0-9-]+(?:\.(?!-)[A-Za-z0-9-]+)*$/;
+function iosLanHostSetting(settings) {
+	const raw = iosString(settings, "lanHost");
+	return typeof raw === "string" && LAN_HOST.test(raw.trim()) ? raw.trim() : null;
+}
+function iosLanHostSettingError(settings) {
+	const raw = iosString(settings, "lanHost");
+	if (raw === void 0) return null;
+	if (typeof raw !== "string" || !LAN_HOST.test(raw.trim())) return `Invalid ios.lanHost setting ${JSON.stringify(raw)}. Expected a bare address or hostname the phone can reach, such as "192.168.1.42" -- never a URL, a scheme, or a port.`;
+	return null;
+}
+function unknownSettingKeys(settings, prefix = "") {
+	if (!isPlainObject(settings)) return [];
+	const unknown = [];
+	for (const [key, value] of Object.entries(settings)) {
+		const path = prefix ? `${prefix}.${key}` : key;
+		if (KNOWN_SETTINGS.has(path) && ![...KNOWN_SETTINGS].some((k) => k.startsWith(`${path}.`))) continue;
+		if (isPlainObject(value) && [...KNOWN_SETTINGS].some((k) => k.startsWith(`${path}.`))) {
+			unknown.push(...unknownSettingKeys(value, path));
+			continue;
+		}
+		unknown.push(path);
+	}
+	return unknown;
+}
+function readCommittedSettings(directory) {
+	if (!directory) return {};
+	const p = join$1(directory, ".stim.json");
+	if (!existsSync(p)) return {};
+	try {
+		const parsed = JSON.parse(readFileSync(p, "utf-8"));
+		return isPlainObject(parsed) ? parsed : {};
+	} catch {
+		return {};
+	}
+}
+function settingsLayers({ projectPath, gitCommonDir, repoRoot }) {
+	const machine = loadConfig();
+	const machineFile = getConfigPath();
+	const committedDir = projectPath ?? repoRoot;
+	return [
+		projectPath ? {
+			file: `${machineFile} (projects["${projectPath}"].settings)`,
+			settings: getProjectSettings(projectPath)
+		} : null,
+		gitCommonDir ? {
+			file: `${machineFile} (repos["${gitCommonDir}"].settings)`,
+			settings: getRepoSettings(gitCommonDir)
+		} : null,
+		committedDir ? {
+			file: join$1(committedDir, ".stim.json"),
+			settings: readCommittedSettings(committedDir)
+		} : null,
+		machine?.optimizations === void 0 ? null : {
+			file: machineFile,
+			settings: { optimizations: machine.optimizations }
+		}
+	].filter((layer) => layer !== null);
+}
+function settingOrigin(layers, dottedKey) {
+	for (const layer of layers) {
+		const value = settingValueAt(layer.settings, dottedKey);
+		if (value !== void 0) return {
+			file: layer.file,
+			value
+		};
+	}
+	return null;
+}
+function settingFile(context, dottedKey) {
+	return settingOrigin(settingsLayers(context), dottedKey)?.file ?? null;
+}
+function resolveSettings(context) {
+	return mergeSettingsLayers(settingsLayers(context).map((layer) => layer.settings));
+}
+function settingsForProject(root) {
+	return resolveSettings({
+		projectPath: root,
+		gitCommonDir: gitCommonDir(root),
+		repoRoot: repoRoot(root) ?? root
+	});
+}
+function projectOptimizations(root) {
+	return resolveOptimizations(settingsForProject(root));
+}
+function projectMetroSharedCache(root) {
+	return resolveMetroSharedCache(settingsForProject(root));
+}
+function cacheBlock(layer) {
+	if (!isPlainObject(layer) || !isPlainObject(layer.cache)) return null;
+	return layer.cache;
+}
+function resolveCacheProviderConfig({ projectPath, gitCommonDir, repoRoot }) {
+	const layers = [
+		{
+			settings: projectPath ? getProjectSettings(projectPath) : {},
+			baseDir: projectPath ?? null
+		},
+		{
+			settings: gitCommonDir ? getRepoSettings(gitCommonDir) : {},
+			baseDir: repoRoot ?? projectPath ?? null
+		},
+		{
+			settings: readCommittedSettings(projectPath),
+			baseDir: projectPath ?? null
+		}
+	];
+	let provider = null;
+	let baseDir = null;
+	for (const layer of layers) {
+		const reference = cacheBlock(layer.settings)?.provider;
+		if (typeof reference !== "string" || reference.trim() === "" || layer.baseDir === null) continue;
+		provider = reference.trim();
+		baseDir = layer.baseDir;
+		break;
+	}
+	if (provider === null || baseDir === null) return null;
+	const options = mergeSettingsLayers(layers.map((layer) => {
+		const block = cacheBlock(layer.settings)?.options;
+		return isPlainObject(block) ? block : null;
+	}));
+	return {
+		provider,
+		options,
+		baseDir
+	};
+}
+function cacheProviderSettingError(settings) {
+	const block = settings.cache;
+	if (!isPlainObject(block)) return block === void 0 ? null : `Invalid cache setting ${JSON.stringify(block)}. Expected an object with provider and options.`;
+	if ("provider" in block && (typeof block.provider !== "string" || block.provider.trim() === "")) return `Invalid cache.provider setting ${JSON.stringify(block.provider)}. Expected a module path or package name.`;
+	if ("options" in block && !isPlainObject(block.options)) return `Invalid cache.options setting ${JSON.stringify(block.options)}. Expected an object.`;
+	return null;
+}
+const REMOTE_DEVICE_BACKENDS = ["proxy", "eas"];
+function remoteIosSetting(settings) {
+	return remoteSetting(settings, "ios");
+}
+function remoteAndroidSetting(settings) {
+	return remoteSetting(settings, "android");
+}
+function remoteSetting(settings, platform) {
+	const block = settings[platform];
+	if (!isPlainObject(block)) return null;
+	const remote = block.remote;
+	return typeof remote === "string" && REMOTE_DEVICE_BACKENDS.includes(remote) ? remote : null;
+}
+function remoteDeviceSettingError(settings) {
+	for (const platform of ["ios", "android"]) {
+		const block = settings[platform];
+		if (!isPlainObject(block) || !("remote" in block)) continue;
+		if (remoteSetting(settings, platform) === null) return `Invalid ${platform}.remote setting ${JSON.stringify(block.remote)}. Expected one of: ${REMOTE_DEVICE_BACKENDS.join(", ")}.`;
+	}
+	return null;
+}
+function tunnelModeSetting(settings) {
+	const block = settings.metro;
+	if (typeof block !== "object" || block === null) return null;
+	const mode = block.tunnel;
+	return typeof mode === "string" && TUNNEL_MODES.includes(mode) ? mode : null;
+}
+function metroTunnelSettingError(settings) {
+	const block = settings.metro;
+	if (!isPlainObject(block)) return null;
+	if ("tunnel" in block) {
+		const mode = block.tunnel;
+		if (typeof mode !== "string" || !TUNNEL_MODES.includes(mode)) return `Invalid metro.tunnel setting ${JSON.stringify(mode)}. Expected one of: ${TUNNEL_MODES.join(", ")}.`;
+	}
+	if (!("ngrokUrl" in block)) return null;
+	if (block.tunnel !== "ngrok") return "metro.ngrokUrl requires metro.tunnel to be \"ngrok\".";
+	if (normalizedHttpsUrl(block.ngrokUrl) === null) return "metro.ngrokUrl must be a valid HTTPS URL.";
+	return null;
+}
+function publicUrlSetting(settings) {
+	const block = settings.metro;
+	if (typeof block !== "object" || block === null) return null;
+	const url = block.publicUrl;
+	return typeof url === "string" && url.trim() ? url : null;
+}
+function ngrokUrlSetting(settings) {
+	const block = settings.metro;
+	if (typeof block !== "object" || block === null) return null;
+	if (block.tunnel !== "ngrok") return null;
+	return normalizedHttpsUrl(block.ngrokUrl);
+}
+function normalizedHttpsUrl(raw) {
+	if (typeof raw !== "string" || !raw.trim()) return null;
+	try {
+		return new URL(raw.trim()).protocol === "https:" ? raw.trim().replace(/\/+$/, "") : null;
+	} catch {
+		return null;
+	}
+}
+//#endregion
+export { settingFile as A, compilerCacheFallbackMessage as B, projectOptimizations as C, remoteIosSetting as D, remoteDeviceSettingError as E, unknownSettingKeys as F, resolveOptimizations as H, PUBLIC_METRO_ENV as I, detectProviders as L, settingShapeErrors as M, settingsLayers as N, resolveCacheProviderConfig as O, tunnelModeSetting as P, planMetroReach as R, projectMetroSharedCache as S, remoteAndroidSetting as T, optimizationBuildProfile as V, iosSigningIdentitySha1SettingError as _, SETTING_SHAPE_REMEDY as a, metroTunnelSettingError as b, androidDataPartitionSizeBytes as c, cacheProviderSettingError as d, iosLanHostSetting as f, iosSigningIdentitySha1Setting as g, iosSigningIdentitySettingError as h, SETTINGS_WITH_RESOLVE_TIME_FALLBACK as i, settingOrigin as j, resolveSettings as k, androidDataPartitionSizeGbSetting as l, iosSigningIdentitySetting as m, PATH_SETTINGS as n, androidAvdConfigSetting as o, iosLanHostSettingError as p, REMOTE_DEVICE_BACKENDS as r, androidAvdConfigSettingError as s, ANDROID_AVD_CONFIG_HELP as t, androidDataPartitionSizeGbSettingError as u, iosSimSlimProfileSetting as v, publicUrlSetting as w, ngrokUrlSetting as x, mergeSettingsLayers as y, artifactCachePolicy as z };