stim 1.8.0 → 1.9.0

package/dist/{settings-BXXorVM2.mjs → settings-D030k0t4.mjs}

@@ -1,28 +1,21 @@
-import { d as getConfigPath, g as loadConfig, m as getRepoSettings, p as getProjectSettings } from "./config-B7iyKWkL.mjs";
-import { g as repoRoot, s as gitCommonDir } from "./worktree-FG_ZKKdb.mjs";
-import { createHash } from "node:crypto";
-import { isAbsolute } from "node:path";
+import { d as getConfigPath, g as loadConfig, m as getRepoSettings, p as getProjectSettings } from "./config-Cp9lM3wX.mjs";
+import { _ as repoRoot, s as gitCommonDir } from "./worktree-R_cUlE7s.mjs";
 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";
+import { isAbsolute, join, relative, resolve, sep } from "path";
+import { isAbsolute as isAbsolute$1 } from "node:path";
+import { createHash } from "node:crypto";
 //#region src/optimizations.ts
-const OPTIMIZATION_SHAPES = {
-	optimizations: "object",
-	"optimizations.buildCache": "boolean",
-	"optimizations.remoteBuildCache": "boolean",
-	"optimizations.releaseBundleSwap": "boolean",
-	"optimizations.metroSharedCache": "boolean",
-	"optimizations.metroWarmup": "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"
-};
+const ANDROID_COMPILER_CACHE_CHOICES = [
+	"auto",
+	"ccache",
+	"cas",
+	"none"
+];
+const ANDROID_PCH_CHOICES = [
+	"auto",
+	"on",
+	"off"
+];
 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.";
@@ -48,18 +41,13 @@ function resolveOptimizations(settings = {}, env = process.env) {
 		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 compiler = choice("android.compilerCache", ANDROID_COMPILER_CACHE_CHOICES, "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;
+		if (typeof manifest === "string" && isAbsolute$1(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`,
@@ -92,11 +80,7 @@ function resolveOptimizations(settings = {}, env = process.env) {
 			compilerCache,
 			casToolchain: toolchain,
 			compilerCacheFallback: fallback,
-			pch: choice("android.pch", [
-				"auto",
-				"on",
-				"off"
-			], "auto"),
+			pch: choice("android.pch", ANDROID_PCH_CHOICES, "auto"),
 			gradleBuildCache: optimizationBoolean(settings, "android.gradleBuildCache"),
 			targetAbiOnly: optimizationBoolean(settings, "android.targetAbiOnly")
 		}
@@ -177,6 +161,409 @@ function detectProviders(onPath) {
 	return MANAGED_PROVIDERS.filter((p) => onPath(p));
 }
 //#endregion
+//#region src/workspace/settings-registry.ts
+const SETTING_SCOPES = [
+	"machine",
+	"workspace",
+	"repo",
+	"committed"
+];
+const REMOTE_DEVICE_BACKENDS = ["proxy", "eas"];
+const IOS_SIMULATOR_APPS = [
+	"xcode",
+	"siniulator",
+	"stim-desktop"
+];
+const PROJECT = [
+	"workspace",
+	"repo",
+	"committed"
+];
+const EVERY = [
+	"machine",
+	"workspace",
+	"repo",
+	"committed"
+];
+const MACHINE = ["machine"];
+const STRING = { kind: "string" };
+const PATH = { kind: "path" };
+const ABSOLUTE_PATH = {
+	kind: "path",
+	absolute: true
+};
+const RELATIVE_PATH = {
+	kind: "path",
+	relative: true
+};
+const BOOLEAN = { kind: "boolean" };
+const OBJECT = { kind: "object" };
+const REMOTE = {
+	kind: "choice",
+	choices: REMOTE_DEVICE_BACKENDS
+};
+const PARKED_MAX = {
+	kind: "number",
+	integer: true,
+	minimum: 0
+};
+const CAPACITY = {
+	kind: "number",
+	integer: true,
+	minimum: 0
+};
+function optimization(key, description, type = BOOLEAN) {
+	return {
+		key: `optimizations.${key}`,
+		type,
+		scopes: EVERY,
+		description,
+		...type.kind === "boolean" ? { default: true } : {}
+	};
+}
+const SETTINGS = [
+	optimization("buildCache", "Read and write native build artifacts"),
+	optimization("remoteBuildCache", "Use remote artifact providers"),
+	optimization("releaseBundleSwap", "Swap current JS into cached release builds"),
+	optimization("metroSharedCache", "Append Stim's shared Metro cache store"),
+	optimization("metroWarmup", "Prefetch the development bundle during ios and android"),
+	optimization("ios.compilationCache", "Xcode compilation caching"),
+	{
+		key: "optimizations.ios.swiftCompilationCache",
+		type: BOOLEAN,
+		scopes: EVERY,
+		description: "Swift compilation caching; unset detects toolchain support"
+	},
+	optimization("ios.prefixMapping", "Clang source and DerivedData prefix mapping"),
+	{
+		...optimization("android.compilerCache", "Android compiler cache backend", {
+			kind: "choice",
+			choices: ANDROID_COMPILER_CACHE_CHOICES
+		}),
+		default: "auto"
+	},
+	{
+		...optimization("android.casToolchain", "Absolute path to the Android CAS toolchain manifest", ABSOLUTE_PATH),
+		env: "STIM_ANDROID_CAS_TOOLCHAIN"
+	},
+	{
+		...optimization("android.pch", "Android precompiled headers", {
+			kind: "choice",
+			choices: ANDROID_PCH_CHOICES
+		}),
+		default: "auto"
+	},
+	optimization("android.gradleBuildCache", "Gradle build cache"),
+	optimization("android.targetAbiOnly", "Narrow Debug builds to the device ABI"),
+	{
+		key: "ios.deviceType",
+		type: STRING,
+		scopes: PROJECT,
+		description: "Simulator model for owned simulators"
+	},
+	{
+		key: "ios.runtime",
+		type: STRING,
+		scopes: PROJECT,
+		description: "iOS runtime owned simulators are created on"
+	},
+	{
+		key: "ios.configuration",
+		type: STRING,
+		scopes: PROJECT,
+		default: "Debug",
+		description: "Xcode configuration to build, such as Debug or Release"
+	},
+	{
+		key: "ios.remote",
+		type: REMOTE,
+		scopes: PROJECT,
+		description: "Default remote backend for iOS"
+	},
+	{
+		key: "ios.simslimProfile",
+		type: RELATIVE_PATH,
+		scopes: PROJECT,
+		description: "SimSlim JSON profile under the app"
+	},
+	{
+		key: "ios.signingIdentity",
+		type: STRING,
+		scopes: PROJECT,
+		description: "Keychain identity used to re-seal a device build"
+	},
+	{
+		key: "ios.signingIdentitySha1",
+		type: {
+			kind: "string",
+			pattern: "^[0-9A-Fa-f]{40}$",
+			patternHelp: "a 40-character hex SHA-1 hash"
+		},
+		scopes: PROJECT,
+		description: "SHA-1 of the signing identity, when two share a name"
+	},
+	{
+		key: "ios.lanHost",
+		type: {
+			kind: "string",
+			pattern: "^(?!-)[A-Za-z0-9-]+(?:\\.(?!-)[A-Za-z0-9-]+)*$",
+			patternHelp: "a bare address or hostname, never a URL, scheme, or port"
+		},
+		scopes: PROJECT,
+		description: "Address a phone uses to reach this workspace's Metro"
+	},
+	{
+		key: "android.systemImage",
+		type: STRING,
+		scopes: PROJECT,
+		description: "SDK system image for owned AVDs"
+	},
+	{
+		key: "android.dataPartitionSizeGb",
+		type: {
+			kind: "number",
+			integer: true,
+			minimum: 6,
+			maximum: 16384
+		},
+		scopes: PROJECT,
+		default: 8,
+		description: "Data partition size of a new owned AVD, in GiB"
+	},
+	{
+		key: "android.avdConfigFile",
+		type: RELATIVE_PATH,
+		scopes: PROJECT,
+		description: "AVD config.ini fragment under the app"
+	},
+	{
+		key: "android.avdConfig",
+		type: OBJECT,
+		scopes: PROJECT,
+		description: "Validated AVD config values"
+	},
+	{
+		key: "android.variant",
+		type: STRING,
+		scopes: PROJECT,
+		description: "Gradle build variant"
+	},
+	{
+		key: "android.keystore",
+		type: PATH,
+		scopes: PROJECT,
+		description: "Keystore a re-packed release APK is signed with"
+	},
+	{
+		key: "android.keystorePassword",
+		type: STRING,
+		scopes: PROJECT,
+		sensitive: true,
+		description: "Keystore password, or an apksigner env: or file: reference"
+	},
+	{
+		key: "android.remote",
+		type: REMOTE,
+		scopes: PROJECT,
+		description: "Default remote backend for Android"
+	},
+	{
+		key: "metro.tunnel",
+		type: {
+			kind: "choice",
+			choices: TUNNEL_MODES
+		},
+		scopes: PROJECT,
+		default: "auto",
+		description: "How a remote device reaches Metro"
+	},
+	{
+		key: "metro.ngrokUrl",
+		type: STRING,
+		scopes: PROJECT,
+		description: "Stable ngrok URL for the managed tunnel"
+	},
+	{
+		key: "metro.publicUrl",
+		type: STRING,
+		scopes: PROJECT,
+		description: "Existing public Metro URL"
+	},
+	{
+		key: "metro.warmupUrl.ios",
+		type: { kind: "bundle-url" },
+		scopes: PROJECT,
+		description: "Bundle URL `stim ios` prefetches to warm Metro"
+	},
+	{
+		key: "metro.warmupUrl.android",
+		type: { kind: "bundle-url" },
+		scopes: PROJECT,
+		description: "Bundle URL `stim android` prefetches to warm Metro"
+	},
+	{
+		key: "worktree.exclude",
+		type: { kind: "strings" },
+		scopes: ["repo", "committed"],
+		committedAt: "repository",
+		description: "Ignored paths `worktree warm` skips"
+	},
+	{
+		key: "worktree.defaultBranch",
+		type: STRING,
+		scopes: ["repo", "committed"],
+		committedAt: "repository",
+		description: "Branch `worktree warm --refresh` expects the source checkout on"
+	},
+	{
+		key: "cache.provider",
+		type: STRING,
+		scopes: PROJECT,
+		description: "Second-tier cache provider module"
+	},
+	{
+		key: "cache.options",
+		type: OBJECT,
+		scopes: PROJECT,
+		description: "Options passed to the cache provider"
+	},
+	{
+		key: "iosSimulatorApp",
+		type: {
+			kind: "choice",
+			choices: IOS_SIMULATOR_APPS
+		},
+		scopes: MACHINE,
+		default: "xcode",
+		description: "App that displays an owned iOS simulator"
+	},
+	{
+		key: "concurrency.maxBuilds",
+		type: CAPACITY,
+		scopes: MACHINE,
+		default: 0,
+		env: "STIM_MAX_BUILDS",
+		description: "Concurrent native builds; 0 means no limit"
+	},
+	{
+		key: "concurrency.maxDevices",
+		type: CAPACITY,
+		scopes: MACHINE,
+		default: 0,
+		env: "STIM_MAX_DEVICES",
+		description: "Booted owned devices; 0 means no limit"
+	},
+	{
+		key: "pool.iosParkedMax",
+		type: PARKED_MAX,
+		scopes: MACHINE,
+		default: 3,
+		env: "STIM_POOL_IOS_PARKED_MAX",
+		scopedHomeValue: 0,
+		description: "Parked simulators kept for adoption; 0 turns parking off"
+	},
+	{
+		key: "pool.androidParkedMax",
+		type: PARKED_MAX,
+		scopes: MACHINE,
+		default: 3,
+		env: "STIM_POOL_ANDROID_PARKED_MAX",
+		scopedHomeValue: 0,
+		description: "Parked emulators kept for adoption; 0 turns parking off"
+	},
+	{
+		key: "caches.buildCache",
+		type: ABSOLUTE_PATH,
+		scopes: MACHINE,
+		env: "STIM_BUILD_CACHE",
+		description: "Absolute path of the shared build cache"
+	},
+	{
+		key: "caches.metroCache",
+		type: ABSOLUTE_PATH,
+		scopes: MACHINE,
+		env: "STIM_METRO_CACHE",
+		description: "Absolute parent path of the Metro transform caches"
+	},
+	{
+		key: "tempDir",
+		type: ABSOLUTE_PATH,
+		scopes: MACHINE,
+		env: "STIM_TMPDIR",
+		description: "Absolute directory for large temporary copies"
+	}
+];
+const BY_KEY = new Map(SETTINGS.map((setting) => [setting.key, setting]));
+function settingDefinition(key) {
+	return BY_KEY.get(key) ?? null;
+}
+function isLayeredSetting(setting) {
+	return setting.scopes.some((scope) => scope !== "machine");
+}
+const SETTING_GROUPS = [...new Set(SETTINGS.filter(isLayeredSetting).flatMap((setting) => setting.key.split(".").slice(0, -1).map((_, index, parts) => parts.slice(0, index + 1).join("."))))];
+function isPlainObject$1(value) {
+	return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+function bundleUrlAccepts(value, key) {
+	if (typeof value !== "string" || !/^(https?:\/\/|\/(?!\/))/.test(value) || /[\s\\#]/.test(value)) return false;
+	try {
+		const url = new URL(value, "http://localhost");
+		return /\.bundle\/*$/.test(url.pathname) && url.searchParams.get("platform") === key.split(".").at(-1);
+	} catch {
+		return false;
+	}
+}
+function expectedShape(type) {
+	switch (type.kind) {
+		case "boolean": return "true or false";
+		case "string": return "a string";
+		case "path": return "a string path";
+		case "strings": return "an array of strings";
+		case "number": return "a number";
+		case "choice": return `one of: ${type.choices.join(", ")}`;
+		case "object": return "an object";
+		case "bundle-url": return "an HTTP(S) URL or /path ending in .bundle with a matching platform query and no fragment";
+	}
+}
+function acceptsShape(setting, value) {
+	const { type } = setting;
+	switch (type.kind) {
+		case "boolean": return typeof value === "boolean";
+		case "string":
+		case "path": return typeof value === "string";
+		case "strings": return Array.isArray(value) && value.every((entry) => typeof entry === "string");
+		case "number": return typeof value === "number";
+		case "choice": return typeof value === "string" && type.choices.includes(value);
+		case "object": return isPlainObject$1(value);
+		case "bundle-url": return bundleUrlAccepts(value, setting.key);
+	}
+}
+function numberBounds(type) {
+	const noun = type.integer ? "a whole number" : "a number";
+	if (type.minimum !== void 0 && type.maximum !== void 0) return `${noun} from ${type.minimum} through ${type.maximum}`;
+	if (type.minimum !== void 0) return `${noun}, ${type.minimum} or more`;
+	return noun;
+}
+function settingValueError(setting, value) {
+	const { type } = setting;
+	if (!acceptsShape(setting, value)) return type.kind === "number" ? numberBounds(type) : expectedShape(type);
+	if (type.kind === "number") {
+		const number = value;
+		if (!Number.isFinite(number) || type.integer && !Number.isSafeInteger(number) || type.minimum !== void 0 && number < type.minimum || type.maximum !== void 0 && number > type.maximum) return numberBounds(type);
+	}
+	if (type.kind === "path") {
+		const path = value;
+		if (type.absolute && !isAbsolute$1(path)) return "an absolute path";
+		if (type.relative && (path.trim() === "" || isAbsolute$1(path))) return "a relative path inside the app directory";
+	}
+	if (type.kind === "string" && type.pattern && !new RegExp(type.pattern).test(value)) return type.patternHelp ?? `a string matching ${type.pattern}`;
+	return null;
+}
+const SENSITIVE_REFERENCE = /^(env|file):\S/;
+function isSensitiveReference(value) {
+	return typeof value === "string" && SENSITIVE_REFERENCE.test(value);
+}
+//#endregion
 //#region src/workspace/settings.ts
 function isPlainObject(v) {
 	return v !== null && typeof v === "object" && !Array.isArray(v);
@@ -190,77 +577,10 @@ function mergeSettingsLayers(layers) {
 	}
 	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
-	},
-	"bundle-url": {
-		expected: "an HTTP(S) URL or /path ending in .bundle with a matching platform query and no fragment",
-		accepts: (value, key) => {
-			if (typeof value !== "string" || !/^(https?:\/\/|\/(?!\/))/.test(value) || /[\s\\#]/.test(value)) return false;
-			try {
-				const url = new URL(value, "http://localhost");
-				return /\.bundle\/*$/.test(url.pathname) && url.searchParams.get("platform") === key.split(".").at(-1);
-			} catch {
-				return false;
-			}
-		}
-	}
-};
-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",
-	"metro.warmupUrl": "object",
-	"metro.warmupUrl.ios": "bundle-url",
-	"metro.warmupUrl.android": "bundle-url",
-	"worktree.exclude": "strings",
-	"worktree.defaultBranch": "string",
-	"cache.provider": "string",
-	"cache.options": "object",
-	caches: "strings"
-};
-const KNOWN_SETTINGS = new Set(Object.keys(SETTING_SHAPES));
+const LAYERED_SETTINGS = SETTINGS.filter(isLayeredSetting);
+const KNOWN_SETTINGS = /* @__PURE__ */ new Set([...LAYERED_SETTINGS.map((setting) => setting.key), ...SETTING_GROUPS]);
 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));
+const PATH_SETTINGS = Object.freeze(LAYERED_SETTINGS.filter((setting) => setting.type.kind === "path").map((setting) => setting.key));
 function settingValueAt(settings, path) {
 	let node = settings;
 	for (const segment of path.split(".")) {
@@ -271,20 +591,25 @@ function settingValueAt(settings, path) {
 }
 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, path)) continue;
-		errors.push(`Invalid ${path} setting ${JSON.stringify(value)}. Expected ${rule.expected}.`);
+	for (const group of SETTING_GROUPS) {
+		const value = settingValueAt(settings, group);
+		if (value === void 0 || isPlainObject(value)) continue;
+		errors.push(`Invalid ${group} setting ${JSON.stringify(value)}. Expected an object.`);
+	}
+	for (const setting of LAYERED_SETTINGS) {
+		if (SETTINGS_WITH_RESOLVE_TIME_FALLBACK.has(setting.key)) continue;
+		const value = settingValueAt(settings, setting.key);
+		if (value === void 0 || acceptsShape(setting, value)) continue;
+		errors.push(`Invalid ${setting.key} setting ${JSON.stringify(value)}. Expected ${expectedShape(setting.type)}.`);
 	}
 	return errors;
 }
 const SETTING_SHAPE_REMEDY = "Run `stim guide settings` for the shape each setting takes.";
+const MIN_ANDROID_DATA_PARTITION_SIZE_GB = 6;
+const DEFAULT_ANDROID_DATA_PARTITION_SIZE_GB = 8;
 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.`);
+	if (typeof raw !== "number" || !Number.isSafeInteger(raw) || raw < MIN_ANDROID_DATA_PARTITION_SIZE_GB || raw > MAX_ANDROID_DATA_PARTITION_SIZE_GB) throw new Error(`Invalid android.dataPartitionSizeGb setting ${JSON.stringify(raw)}. Expected an integer from ${MIN_ANDROID_DATA_PARTITION_SIZE_GB} through ${MAX_ANDROID_DATA_PARTITION_SIZE_GB} GiB.`);
 	return raw;
 }
 function androidDataPartitionSizeBytes(sizeGb) {
@@ -296,7 +621,7 @@ function androidDataPartitionSizeGbRaw(settings) {
 }
 function androidDataPartitionSizeGbSetting(settings) {
 	const raw = androidDataPartitionSizeGbRaw(settings);
-	if (raw === void 0) return 8;
+	if (raw === void 0) return DEFAULT_ANDROID_DATA_PARTITION_SIZE_GB;
 	return validateAndroidDataPartitionSizeGb(raw);
 }
 function androidDataPartitionSizeGbSettingError(settings) {
@@ -425,18 +750,18 @@ function parseAndroidAvdConfigIni(contents) {
 	return entries;
 }
 function pathEscapesRoot(root, path) {
-	const child = relative$1(root, path);
-	return child === ".." || child.startsWith(`..${sep$1}`) || isAbsolute$1(child);
+	const child = relative(root, path);
+	return child === ".." || child.startsWith(`..${sep}`) || isAbsolute(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.");
+		if (typeof android.avdConfigFile !== "string" || !android.avdConfigFile.trim() || android.avdConfigFile !== android.avdConfigFile.trim() || /[\r\n\0]/.test(android.avdConfigFile) || isAbsolute(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);
+			const candidate = resolve(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");
@@ -470,10 +795,10 @@ function androidAvdConfigSettingError(settings, projectPath) {
 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.");
+	if (typeof value !== "string" || !value.trim() || value !== value.trim() || /[\r\n\0]/.test(value) || isAbsolute(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);
+		const candidate = resolve(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");
@@ -526,6 +851,7 @@ function unknownSettingKeys(settings, prefix = "") {
 	const unknown = [];
 	for (const [key, value] of Object.entries(settings)) {
 		const path = prefix ? `${prefix}.${key}` : key;
+		if (path === "$schema") continue;
 		if (KNOWN_SETTINGS.has(path) && (!isPlainObject(value) || ![...KNOWN_SETTINGS].some((k) => k.startsWith(`${path}.`)))) continue;
 		if (isPlainObject(value) && [...KNOWN_SETTINGS].some((k) => k.startsWith(`${path}.`))) {
 			unknown.push(...unknownSettingKeys(value, path));
@@ -537,7 +863,7 @@ function unknownSettingKeys(settings, prefix = "") {
 }
 function readCommittedSettings(directory) {
 	if (!directory) return {};
-	const p = join$1(directory, ".stim.json");
+	const p = join(directory, ".stim.json");
 	if (!existsSync(p)) return {};
 	try {
 		const parsed = JSON.parse(readFileSync(p, "utf-8"));
@@ -560,7 +886,7 @@ function settingsLayers({ projectPath, gitCommonDir, repoRoot }) {
 			settings: getRepoSettings(gitCommonDir)
 		} : null,
 		committedDir ? {
-			file: join$1(committedDir, ".stim.json"),
+			file: join(committedDir, ".stim.json"),
 			settings: readCommittedSettings(committedDir)
 		} : null,
 		machine?.optimizations === void 0 ? null : {
@@ -617,23 +943,23 @@ function resolveCacheProviderConfig({ projectPath, gitCommonDir, repoRoot }) {
 			baseDir: projectPath ?? null
 		}
 	];
-	let provider = null;
-	let baseDir = null;
-	for (const layer of layers) {
+	const references = layers.map((layer) => {
 		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 typeof reference === "string" && reference.trim() !== "" ? reference.trim() : null;
+	});
+	const selected = layers.findIndex((layer, index) => references[index] !== null && layer.baseDir !== null);
+	if (selected === -1) return null;
+	const provider = references[selected];
+	const baseDir = layers[selected].baseDir;
 	return {
 		provider,
-		options,
+		options: mergeSettingsLayers(layers.map((layer, index) => {
+			const namesProvider = references[index] === provider && layer.baseDir === baseDir;
+			const overridesAbove = index < selected && references[index] === null;
+			if (!namesProvider && !overridesAbove) return null;
+			const block = cacheBlock(layer.settings)?.options;
+			return isPlainObject(block) ? block : null;
+		})),
 		baseDir
 	};
 }
@@ -644,7 +970,6 @@ function cacheProviderSettingError(settings) {
 	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");
 }
@@ -657,14 +982,6 @@ function remoteSetting(settings, platform) {
 	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;
@@ -673,12 +990,7 @@ function tunnelModeSetting(settings) {
 }
 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 (!isPlainObject(block) || !("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;
@@ -708,4 +1020,4 @@ function normalizedHttpsUrl(raw) {
 	}
 }
 //#endregion
-export { resolveSettings as A, artifactCachePolicy as B, projectMetroSharedCache as C, remoteDeviceSettingError as D, remoteAndroidSetting as E, tunnelModeSetting as F, optimizationBuildProfile as H, unknownSettingKeys as I, PUBLIC_METRO_ENV as L, settingOrigin as M, settingShapeErrors as N, remoteIosSetting as O, settingsLayers as P, detectProviders as R, ngrokUrlSetting as S, publicUrlSetting as T, resolveOptimizations as U, compilerCacheFallbackMessage 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, settingFile as j, resolveCacheProviderConfig 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, projectOptimizations as w, metroWarmupUrlSetting as x, mergeSettingsLayers as y, planMetroReach as z };
+export { settingFile as A, isSensitiveReference as B, projectOptimizations as C, remoteIosSetting as D, remoteAndroidSetting as E, unknownSettingKeys as F, planMetroReach as G, settingValueError as H, IOS_SIMULATOR_APPS as I, optimizationBuildProfile as J, artifactCachePolicy as K, REMOTE_DEVICE_BACKENDS as L, settingShapeErrors as M, settingsLayers as N, resolveCacheProviderConfig as O, tunnelModeSetting as P, SETTINGS as R, projectMetroSharedCache as S, readCommittedSettings as T, PUBLIC_METRO_ENV as U, settingDefinition as V, detectProviders as W, resolveOptimizations as Y, iosSimSlimProfileSetting as _, androidAvdConfigSetting as a, metroWarmupUrlSetting as b, androidDataPartitionSizeGbSetting as c, iosLanHostSetting as d, iosLanHostSettingError as f, iosSigningIdentitySha1SettingError as g, iosSigningIdentitySha1Setting as h, SETTING_SHAPE_REMEDY as i, settingOrigin as j, resolveSettings as k, androidDataPartitionSizeGbSettingError as l, iosSigningIdentitySettingError as m, PATH_SETTINGS as n, androidAvdConfigSettingError as o, iosSigningIdentitySetting as p, compilerCacheFallbackMessage as q, SETTINGS_WITH_RESOLVE_TIME_FALLBACK as r, androidDataPartitionSizeBytes as s, ANDROID_AVD_CONFIG_HELP as t, cacheProviderSettingError as u, mergeSettingsLayers as v, publicUrlSetting as w, ngrokUrlSetting as x, metroTunnelSettingError as y, SETTING_SCOPES as z };