stim 1.26.0 → 1.28.0

package/dist/settings-payload-DwQiEMCn.mjs

@@ -0,0 +1,257 @@
+import { _ as loadConfig$1, f as getConfigPath$1, h as getRepoSettings, m as getProjectSettings } from "./config-Cn94Jc0g.mjs";
+import { a as killOnAbort, i as gitPath } from "./operation-exec-Dp4FuIGR.mjs";
+import { K as removedMachineSettings, V as readCommittedSettings, st as unknownSettingKeys } from "./settings-CY5JZlNN.mjs";
+import { r as findCommandWorkspaceAsync } from "./project-Sui52ywT.mjs";
+import { i as stimDesktopInstalledAsync, n as settingDefault, r as stimDesktopInstalled } from "./stim-desktop-CbWo21kb.mjs";
+import { join } from "node:path";
+import { SETTINGS, SETTING_SCOPES, coerceSettingText, isJsonObject, replacementAdvice, settingDefinition, settingValueError } from "@stim-cli/core/state";
+//#region src/workspace/settings-payload.ts
+const MASK = "********";
+const PRECEDENCE = [
+	"workspace",
+	"repo",
+	"committed",
+	"machine"
+];
+var SettingsRefusal = class extends Error {
+	code;
+	remedy;
+	constructor(code, message, remedy) {
+		super(message);
+		this.code = code;
+		this.remedy = remedy;
+	}
+};
+/** Reads layers using exactly `env`; `signal` kills Git children. `resolvedProject` pins a mutation's readback target. */
+async function readSettingsContext(cwd, env, note = () => {}, signal, resolvedProject) {
+	const repoRootOf = (dir) => gitPath(dir, ["--show-toplevel"], env, signal);
+	const projectPath = resolvedProject === void 0 ? await findCommandWorkspaceAsync(cwd, repoRootOf, note) : resolvedProject;
+	const start = projectPath ?? cwd;
+	const [common, root] = await Promise.all([gitPath(start, ["--path-format=absolute", "--git-common-dir"], env, signal), repoRootOf(start)]);
+	signal?.throwIfAborted();
+	const repoRoot = common ? root ?? projectPath : null;
+	const app = projectPath ?? repoRoot;
+	const repository = repoRoot ?? projectPath;
+	const committed = readCommittedSettings(app);
+	let installed;
+	return {
+		projectPath,
+		gitCommonDir: common,
+		repoRoot,
+		machine: loadConfig$1(),
+		workspace: projectPath ? getProjectSettings(projectPath) : {},
+		repo: common ? getRepoSettings(common) : {},
+		committed: {
+			app: committed,
+			repository: repository === app ? committed : readCommittedSettings(repository)
+		},
+		env,
+		desktopInstalled: () => installed ??= stimDesktopInstalled(process.platform, env)
+	};
+}
+function valueAt(settings, key) {
+	let node = settings;
+	for (const segment of key.split(".")) {
+		if (!isJsonObject(node)) return void 0;
+		node = node[segment];
+	}
+	return node;
+}
+function committedDirectory(context, setting) {
+	return setting?.committedAt === "repository" ? repositoryDirectory(context) : appDirectory(context);
+}
+function repositoryDirectory(context) {
+	return context.repoRoot ?? context.projectPath;
+}
+function appDirectory(context) {
+	return context.projectPath ?? context.repoRoot;
+}
+function layerFile(context, scope, setting) {
+	const machineFile = getConfigPath$1();
+	if (scope === "machine") return machineFile;
+	if (scope === "workspace") return context.projectPath ? `${machineFile} (projects["${context.projectPath}"].settings)` : null;
+	if (scope === "repo") return context.gitCommonDir ? `${machineFile} (repos["${context.gitCommonDir}"].settings)` : null;
+	const directory = committedDirectory(context, setting);
+	return directory ? join(directory, ".stim.json") : null;
+}
+function layerSettings(context, scope, setting) {
+	if (scope === "machine") return context.machine ?? {};
+	if (scope === "workspace") return context.workspace;
+	if (scope === "repo") return context.repo;
+	return setting?.committedAt === "repository" ? context.committed.repository : context.committed.app;
+}
+function masked(setting, value) {
+	return setting.sensitive && value !== void 0 && value !== null ? MASK : value;
+}
+function settingExample(setting) {
+	switch (setting.type.kind) {
+		case "boolean": return "false";
+		case "number": return String(setting.default ?? setting.type.minimum ?? 1);
+		case "strings": return `'["node_modules"]'`;
+		case "object": return `'{"key": "value"}'`;
+		case "choice": return setting.type.choices[0];
+		default: return "<value>";
+	}
+}
+function envSettingValue(setting, raw) {
+	const value = coerceSettingText(setting, raw);
+	const error = settingValueError(setting, value);
+	if (error) throw new SettingsRefusal("STIM_BAD_ARG", `Invalid ${setting.env} value ${JSON.stringify(raw)}. Expected ${error}.`, `Fix the environment variable, or unset it and run \`stim settings set ${setting.key} ${settingExample(setting)}\`.`);
+	return value;
+}
+/** The refusal `stim settings get` gives for an invalid environment override of `key`, or null when it is unset, blank or valid. */
+function envSettingRefusal(key, env) {
+	const setting = settingDefinition(key);
+	const raw = setting?.env ? env[setting.env]?.trim() : void 0;
+	if (!setting || !raw) return null;
+	try {
+		envSettingValue(setting, raw);
+		return null;
+	} catch (error) {
+		if (error instanceof SettingsRefusal) return error;
+		throw error;
+	}
+}
+/** The refusal for an invalid configured value of a machine setting, or null when it is unset or valid. */
+function configSettingRefusal(key, value) {
+	const setting = settingDefinition(key);
+	const checked = typeof value === "string" ? value.trim() : value;
+	const error = setting && checked !== void 0 && checked !== null ? settingValueError(setting, checked) : null;
+	if (!error) return null;
+	return new SettingsRefusal("STIM_BAD_ARG", `Invalid ${key} setting ${JSON.stringify(value)}. Expected ${error}.`, `Replace it with \`stim settings set ${key} <value>\`; \`stim guide settings\` lists the values it takes.`);
+}
+/** The refusal for an invalid `remote.build` that placement would read: the environment override first, else the configured value. */
+function buildPreferenceRefusal(env, configured) {
+	const fromEnvironment = envSettingRefusal("remote.build", env);
+	if (fromEnvironment) return fromEnvironment;
+	return env.STIM_REMOTE_BUILD?.trim() ? null : configSettingRefusal("remote.build", configured);
+}
+function settingEntry(context, setting) {
+	const layers = {};
+	for (const scope of PRECEDENCE) {
+		if (!setting.scopes.includes(scope) || layerFile(context, scope, setting) === null) continue;
+		const value = valueAt(layerSettings(context, scope, setting), setting.key);
+		if (value !== void 0) layers[scope] = masked(setting, value);
+	}
+	const envValue = setting.env ? context.env[setting.env] : void 0;
+	const env = setting.env && envValue ? {
+		name: setting.env,
+		value: String(masked(setting, envValue))
+	} : void 0;
+	const scopedHome = !env && setting.scopedHomeValue !== void 0 && context.env.STIM_HOME;
+	const ci = !env && setting.ciValue !== void 0 && context.env.CI;
+	const winner = PRECEDENCE.find((scope) => scope in layers);
+	let value = null;
+	let origin = null;
+	let defaultReason = null;
+	if (env) {
+		value = masked(setting, envSettingValue(setting, envValue));
+		origin = "env";
+	} else if (scopedHome) {
+		value = setting.scopedHomeValue;
+		origin = "env";
+	} else if (ci) {
+		value = setting.ciValue;
+		origin = "env";
+	} else if (winner) {
+		value = layers[winner];
+		origin = winner;
+	} else if (setting.default !== void 0) {
+		const fallback = settingDefault(setting, context.desktopInstalled);
+		value = fallback.value;
+		origin = "default";
+		defaultReason = fallback.reason;
+	}
+	return {
+		key: setting.key,
+		value,
+		origin,
+		layers,
+		...env ? { env } : scopedHome ? { env: {
+			name: "STIM_HOME",
+			value: context.env.STIM_HOME
+		} } : ci ? { env: {
+			name: "CI",
+			value: context.env.CI
+		} } : {},
+		...setting.sensitive ? { sensitive: true } : {},
+		...defaultReason ? { defaultReason } : {}
+	};
+}
+function unknownEntries(context) {
+	const sources = [
+		{
+			scope: "machine",
+			file: layerFile(context, "machine", null),
+			settings: {
+				optimizations: context.machine?.optimizations,
+				...removedMachineSettings(context.machine)
+			}
+		},
+		{
+			scope: "workspace",
+			file: layerFile(context, "workspace", null),
+			settings: layerSettings(context, "workspace", null)
+		},
+		{
+			scope: "repo",
+			file: layerFile(context, "repo", null),
+			settings: layerSettings(context, "repo", null)
+		},
+		{
+			scope: "committed",
+			file: layerFile(context, "committed", null),
+			settings: layerSettings(context, "committed", null)
+		}
+	];
+	const repository = repositoryDirectory(context);
+	if (repository && repository !== appDirectory(context)) sources.push({
+		scope: "committed",
+		file: join(repository, ".stim.json"),
+		settings: context.committed.repository
+	});
+	return sources.flatMap(({ scope, file, settings }) => file === null ? [] : unknownSettingKeys(settings).map((key) => {
+		const value = valueAt(settings, key);
+		const command = replacementAdvice(key, value)?.command;
+		const entry = {
+			key,
+			scope,
+			file,
+			value
+		};
+		return command ? Object.assign(entry, { replacement: command }) : entry;
+	}));
+}
+function settingsPayload(context) {
+	const files = {};
+	for (const scope of SETTING_SCOPES) {
+		const file = layerFile(context, scope, null);
+		if (file) files[scope] = file;
+	}
+	return {
+		project: context.projectPath,
+		files,
+		settings: SETTINGS.map((setting) => settingEntry(context, setting)),
+		unknown: unknownEntries(context)
+	};
+}
+/** Every setting with its effective value and layers; looks Stim Desktop up asynchronously, and only when a default depends on it. */
+async function readSettingsPayload(context, signal) {
+	let asked = false;
+	const payload = settingsPayload({
+		...context,
+		desktopInstalled: () => {
+			asked = true;
+			return false;
+		}
+	});
+	if (!asked) return payload;
+	const installed = await stimDesktopInstalledAsync(process.platform, context.env, killOnAbort(signal));
+	signal?.throwIfAborted();
+	return settingsPayload({
+		...context,
+		desktopInstalled: () => installed
+	});
+}
+//#endregion
+export { envSettingRefusal as a, readSettingsPayload as c, unknownEntries as d, configSettingRefusal as i, settingEntry as l, buildPreferenceRefusal as n, layerFile as o, committedDirectory as r, readSettingsContext as s, SettingsRefusal as t, settingExample as u };

package/dist/settings-write-CJpjkeAd.mjs

@@ -0,0 +1,185 @@
+import { u as withWorkspaceProcessLock } from "./exec-aULwtNly.mjs";
+import { A as writeConfigSettingAsync, O as withConfigLockAsync$1, f as getConfigPath$1 } from "./config-Cn94Jc0g.mjs";
+import { t as NO_PROJECT_REFUSAL } from "./project-Sui52ywT.mjs";
+import { i as stimDesktopInstalledAsync } from "./stim-desktop-CbWo21kb.mjs";
+import { n as recordingLayers, t as deleteTurnedOffRecordings } from "./recordings-iy0mkm7b.mjs";
+import { d as unknownEntries, l as settingEntry, o as layerFile, r as committedDirectory, s as readSettingsContext, t as SettingsRefusal, u as settingExample } from "./settings-payload-DwQiEMCn.mjs";
+import { existsSync, readFileSync, renameSync, unlinkSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { configDir } from "@stim-cli/core";
+import { REPLACED_SETTINGS, SETTING_SCOPES, coerceSettingText, isJsonObject, isSensitiveReference, replacementAdvice, settingDefinition, settingValueError } from "@stim-cli/core/state";
+//#region src/workspace/settings-write.ts
+function requireSetting(key, raw) {
+	const setting = settingDefinition(key);
+	if (setting) return setting;
+	const replaced = Object.hasOwn(REPLACED_SETTINGS, key) ? REPLACED_SETTINGS[key] : void 0;
+	if (replaced) {
+		const command = replacementAdvice(key, raw)?.command;
+		throw new SettingsRefusal("STIM_BAD_ARG", `${JSON.stringify(key)} was replaced by ${replaced.key} and is no longer read by Stim.`, `${command ? `Run \`${command}\`` : `Set ${replaced.key} (\`stim guide settings\` lists its values)`}, then run \`stim settings unset ${key}\` to remove the leftover key.`);
+	}
+	throw new SettingsRefusal("STIM_BAD_ARG", `${JSON.stringify(key)} is not a Stim setting.`, "Run `stim settings` to list every setting, or `stim guide settings` for what each one does.");
+}
+function parseScopeName(raw) {
+	if (!SETTING_SCOPES.includes(raw)) throw new SettingsRefusal("STIM_BAD_ARG", `--scope takes ${SETTING_SCOPES.join(", ")}, not ${JSON.stringify(raw)}.`, null);
+	return raw;
+}
+function readScope(raw, setting) {
+	if (raw === void 0) {
+		if (setting.scopes.length === 1) return setting.scopes[0];
+		throw new SettingsRefusal("STIM_BAD_ARG", `${setting.key} can live in more than one layer, so the command needs --scope.`, `Pass --scope ${setting.scopes.join("|")}.`);
+	}
+	const scope = parseScopeName(raw);
+	if (!setting.scopes.includes(scope)) throw new SettingsRefusal("STIM_BAD_ARG", `${setting.key} is not read from the ${scope} layer.`, `Pass --scope ${setting.scopes.join("|")}.`);
+	return scope;
+}
+function requireLayer(context, scope, setting) {
+	const file = layerFile(context, scope, setting);
+	if (file) return file;
+	if (scope === "repo") throw new SettingsRefusal("STIM_BAD_ARG", "The repo layer is keyed by a Git repository, and this directory is not inside one.", "Run this from inside the repository, or pick another --scope.");
+	throw new SettingsRefusal(NO_PROJECT_REFUSAL.code, NO_PROJECT_REFUSAL.message, NO_PROJECT_REFUSAL.remedy);
+}
+function parseSettingValue(setting, raw) {
+	const invalid = (expected) => new SettingsRefusal("STIM_BAD_ARG", `Invalid ${setting.key} value ${JSON.stringify(raw)}. Expected ${expected}.`, `For example: stim settings set ${setting.key} ${settingExample(setting)}${setting.scopes.length > 1 ? ` --scope ${setting.scopes[0]}` : ""}`);
+	const kind = setting.type.kind;
+	const value = coerceSettingText(setting, raw);
+	const error = settingValueError(setting, value);
+	if (error) throw invalid(kind === "strings" || kind === "object" ? `${error}, written as JSON` : error);
+	return value;
+}
+function committedTarget(context, setting) {
+	const directory = committedDirectory(context, setting);
+	if (!directory) throw new SettingsRefusal(NO_PROJECT_REFUSAL.code, NO_PROJECT_REFUSAL.message, NO_PROJECT_REFUSAL.remedy);
+	return join(directory, ".stim.json");
+}
+function writeCommitted(file, key, value, signal) {
+	return withConfigLockAsync$1(() => {
+		const exists = existsSync(file);
+		const text = exists ? readFileSync(file, "utf-8") : "";
+		let parsed = {};
+		if (exists && text.trim() !== "") try {
+			parsed = JSON.parse(text);
+		} catch (error) {
+			throw new SettingsRefusal("STIM_BAD_ARG", `${file} is not valid JSON: ${error.message}`, `Repair ${file}, then run the command again.`);
+		}
+		if (!isJsonObject(parsed)) throw new SettingsRefusal("STIM_BAD_ARG", `${file} is not a JSON object.`, `Repair ${file}, then run the command again.`);
+		const parts = key.split(".");
+		const chain = [parsed];
+		for (const part of parts.slice(0, -1)) {
+			const node = chain.at(-1);
+			if (!isJsonObject(node[part])) {
+				if (value === void 0) return false;
+				node[part] = {};
+			}
+			chain.push(node[part]);
+		}
+		const leaf = parts.at(-1);
+		const parent = chain.at(-1);
+		if (value === void 0) {
+			if (!(leaf in parent)) return false;
+			delete parent[leaf];
+			for (let index = chain.length - 1; index > 0; index--) {
+				if (Object.keys(chain[index]).length > 0) break;
+				delete chain[index - 1][parts[index - 1]];
+			}
+		} else parent[leaf] = value;
+		const indent = /\n([ \t]+)"/.exec(text)?.[1] ?? 2;
+		const tmp = `${file}.${process.pid}.${Math.random().toString(36).slice(2)}.tmp`;
+		writeFileSync(tmp, `${JSON.stringify(parsed, null, indent)}\n`);
+		try {
+			renameSync(tmp, file);
+		} catch (error) {
+			try {
+				unlinkSync(tmp);
+			} catch {}
+			throw error;
+		}
+		return true;
+	}, signal);
+}
+function writeSetting(context, setting, scope, value, signal) {
+	if (scope === "committed") return writeCommitted(committedTarget(context, setting), setting.key, value, signal);
+	if (scope === "machine") return writeConfigSettingAsync({ scope }, setting.key, value, signal);
+	if (scope === "workspace") return writeConfigSettingAsync({
+		scope,
+		projectPath: context.projectPath
+	}, setting.key, value, signal);
+	return writeConfigSettingAsync({
+		scope,
+		gitCommonDir: context.gitCommonDir
+	}, setting.key, value, signal);
+}
+/** Shares CLI set/unset validation and side effects; after commit, recording cleanup finishes despite cancellation. */
+async function mutateSetting(request, { cwd, env, note = () => {}, signal, beforeWrite }) {
+	signal?.throwIfAborted();
+	const { key } = request;
+	const setting = requireSetting(key, request.action === "set" ? request.value : void 0);
+	const scope = readScope(request.scope, setting);
+	const value = request.action === "set" ? parseSettingValue(setting, request.value) : void 0;
+	if (setting.sensitive && scope === "committed" && value !== void 0 && !isSensitiveReference(value)) throw new SettingsRefusal("STIM_BAD_ARG", `${key} is sensitive, so a committed .stim.json takes only an env: or file: reference, never the secret.`, `Set the secret with --scope workspace or --scope repo, which store it in ${getConfigPath$1()}, readable only by you, or commit a reference such as env:MY_KEYSTORE_PASSWORD.`);
+	const context = await readSettingsContext(cwd, env, note, signal);
+	const file = requireLayer(context, scope, setting);
+	beforeWrite?.(context.projectPath);
+	const apply = async () => {
+		const recording = setting.key === "recording.enabled" ? recordingLayers() : null;
+		const changed = await writeSetting(context, setting, scope, value, signal);
+		const updated = await readSettingsContext(cwd, env, void 0, void 0, context.projectPath);
+		const recordingsDeleted = recording ? await deleteTurnedOffRecordings(recording) : void 0;
+		let entry = settingEntry({
+			...updated,
+			desktopInstalled: () => false
+		}, setting);
+		if (entry.origin === "default" && setting.desktopDefault !== void 0) {
+			const installed = await stimDesktopInstalledAsync(process.platform, env);
+			entry = settingEntry({
+				...updated,
+				desktopInstalled: () => installed
+			}, setting);
+		}
+		return {
+			key,
+			scope,
+			file,
+			changed,
+			setting: entry,
+			...recordingsDeleted ? { recordingsDeleted } : {}
+		};
+	};
+	return key === "recording.enabled" ? withWorkspaceProcessLock(configDir(), "recording-settings", apply, {
+		external: true,
+		signal
+	}) : apply();
+}
+function configTarget(context, scope) {
+	if (scope === "workspace") return context.projectPath ? {
+		scope,
+		projectPath: context.projectPath
+	} : null;
+	if (scope === "repo") return context.gitCommonDir ? {
+		scope,
+		gitCommonDir: context.gitCommonDir
+	} : null;
+	return scope === "machine" ? { scope } : null;
+}
+/** Removes a key Stim no longer reads from every layer that has it, or from one with `scope`. */
+async function unsetReplacedSetting(request, { cwd, env, note = () => {}, signal }) {
+	signal?.throwIfAborted();
+	const { key } = request;
+	const only = request.scope === void 0 ? void 0 : parseScopeName(request.scope);
+	const context = await readSettingsContext(cwd, env, note, signal);
+	const removed = [];
+	for (const entry of unknownEntries(context)) {
+		if (entry.key !== key || only && entry.scope !== only) continue;
+		const target = configTarget(context, entry.scope);
+		if (entry.scope === "committed" ? await writeCommitted(entry.file, key, void 0, signal) : target && await writeConfigSettingAsync(target, key, void 0, signal)) removed.push({
+			scope: entry.scope,
+			file: entry.file
+		});
+	}
+	return {
+		key,
+		replacedBy: REPLACED_SETTINGS[key]?.key ?? key,
+		removed
+	};
+}
+//#endregion
+export { unsetReplacedSetting as i, readScope as n, requireSetting as r, mutateSetting as t };

package/dist/settings.schema.json

@@ -287,7 +287,7 @@
           }
         },
         "remote": {
-          "description": "Default iOS remote target: eas, proxy, or an approved Mac in remote.machines; auto places on an approved Mac when this machine is full or busy; local runs here, overriding a lower layer",
+          "description": "Where the iOS simulator runs: local here (overriding a lower layer); auto here first, then a remote.machines entry when this machine is full or busy; remote on a remote.machines entry in order, here only when none takes it; remote-only the same but never here; a machine name exactly that machine; eas or proxy a remote device backend",
           "type": "string",
           "pattern": "^[A-Za-z0-9][A-Za-z0-9.-]*(?::(?!0+$)(?:[0-5]?[0-9]{1,4}|6[0-4][0-9]{3}|65[0-4][0-9]{2}|655[0-2][0-9]|6553[0-5]))?$",
           "x-stim": {
@@ -564,7 +564,7 @@
           }
         },
         "remote": {
-          "description": "Default Android remote target: eas, proxy, or an approved Mac in remote.machines; auto places on an approved Mac when this machine is full or busy; local runs here, overriding a lower layer",
+          "description": "Where the Android emulator runs: local here (overriding a lower layer); auto here first, then a remote.machines entry when this machine is full or busy; remote on a remote.machines entry in order, here only when none takes it; remote-only the same but never here; a machine name exactly that machine; eas or proxy a remote device backend",
           "type": "string",
           "pattern": "^[A-Za-z0-9][A-Za-z0-9.-]*(?::(?!0+$)(?:[0-5]?[0-9]{1,4}|6[0-4][0-9]{3}|65[0-4][0-9]{2}|655[0-2][0-9]|6553[0-5]))?$",
           "x-stim": {
@@ -811,6 +811,21 @@
             ]
           }
         },
+        "remote": {
+          "description": "Where stim macos launches the app: local here; auto here unless this machine is busy, then a remote.machines entry; remote on a remote.machines entry in order, here only when none takes it; remote-only the same but never here; a machine name exactly that machine. The --remote flag overrides it",
+          "type": "string",
+          "pattern": "^(?![Ee][Aa][Ss]$|[Pp][Rr][Oo][Xx][Yy]$)[A-Za-z0-9][A-Za-z0-9.-]*(?::(?!0+$)(?:[0-5]?[0-9]{1,4}|6[0-4][0-9]{3}|65[0-4][0-9]{2}|655[0-2][0-9]|6553[0-5]))?$",
+          "x-stim": {
+            "key": "macos.remote",
+            "kind": "string",
+            "scopes": [
+              "machine",
+              "workspace",
+              "repo",
+              "committed"
+            ]
+          }
+        },
         "assetCatalog": {
           "description": "Optional .xcassets directory relative to the Swift Package directory.",
           "type": "string",
@@ -897,7 +912,7 @@
       "type": "object",
       "properties": {
         "enabled": {
-          "description": "Keep workspace history on removal; false under STIM_HOME unless explicitly enabled",
+          "description": "Keep workspace history on removal, and archive a dirty finished worktree's changes before gc removes it; false keeps such worktrees, and is the default under STIM_HOME unless explicitly enabled",
           "type": "boolean",
           "default": true,
           "x-stim": {
@@ -1006,7 +1021,7 @@
       "type": "object",
       "properties": {
         "easFallback": {
-          "description": "When ios.remote or android.remote is auto, this machine is at its concurrency.maxDevices cap and no remote.machines entry takes the run, run the simulator or emulator on a billed EAS Simulator instead of waiting or refusing, when eas-cli can",
+          "description": "When ios.remote or android.remote is auto or remote, this machine is at its concurrency.maxDevices cap and no remote.machines entry takes the run, run the simulator or emulator on a billed EAS Simulator instead of waiting or refusing, when eas-cli can; remote-only never uses it",
           "type": "boolean",
           "default": false,
           "x-stim": {
@@ -1288,7 +1303,7 @@
               }
             },
             "remote": {
-              "description": "Default iOS remote target: eas, proxy, or an approved Mac in remote.machines; auto places on an approved Mac when this machine is full or busy; local runs here, overriding a lower layer",
+              "description": "Where the iOS simulator runs: local here (overriding a lower layer); auto here first, then a remote.machines entry when this machine is full or busy; remote on a remote.machines entry in order, here only when none takes it; remote-only the same but never here; a machine name exactly that machine; eas or proxy a remote device backend",
               "type": "string",
               "pattern": "^[A-Za-z0-9][A-Za-z0-9.-]*(?::(?!0+$)(?:[0-5]?[0-9]{1,4}|6[0-4][0-9]{3}|65[0-4][0-9]{2}|655[0-2][0-9]|6553[0-5]))?$",
               "x-stim": {
@@ -1398,7 +1413,7 @@
               }
             },
             "remote": {
-              "description": "Default Android remote target: eas, proxy, or an approved Mac in remote.machines; auto places on an approved Mac when this machine is full or busy; local runs here, overriding a lower layer",
+              "description": "Where the Android emulator runs: local here (overriding a lower layer); auto here first, then a remote.machines entry when this machine is full or busy; remote on a remote.machines entry in order, here only when none takes it; remote-only the same but never here; a machine name exactly that machine; eas or proxy a remote device backend",
               "type": "string",
               "pattern": "^[A-Za-z0-9][A-Za-z0-9.-]*(?::(?!0+$)(?:[0-5]?[0-9]{1,4}|6[0-4][0-9]{3}|65[0-4][0-9]{2}|655[0-2][0-9]|6553[0-5]))?$",
               "x-stim": {
@@ -1453,6 +1468,27 @@
           },
           "additionalProperties": false
         },
+        "macos": {
+          "type": "object",
+          "properties": {
+            "remote": {
+              "description": "Where stim macos launches the app: local here; auto here unless this machine is busy, then a remote.machines entry; remote on a remote.machines entry in order, here only when none takes it; remote-only the same but never here; a machine name exactly that machine. The --remote flag overrides it",
+              "type": "string",
+              "pattern": "^(?![Ee][Aa][Ss]$|[Pp][Rr][Oo][Xx][Yy]$)[A-Za-z0-9][A-Za-z0-9.-]*(?::(?!0+$)(?:[0-5]?[0-9]{1,4}|6[0-4][0-9]{3}|65[0-4][0-9]{2}|655[0-2][0-9]|6553[0-5]))?$",
+              "x-stim": {
+                "key": "macos.remote",
+                "kind": "string",
+                "scopes": [
+                  "machine",
+                  "workspace",
+                  "repo",
+                  "committed"
+                ]
+              }
+            }
+          },
+          "additionalProperties": false
+        },
         "recording": {
           "type": "object",
           "properties": {
@@ -1478,7 +1514,7 @@
           "type": "object",
           "properties": {
             "enabled": {
-              "description": "Keep workspace history on removal; false under STIM_HOME unless explicitly enabled",
+              "description": "Keep workspace history on removal, and archive a dirty finished worktree's changes before gc removes it; false keeps such worktrees, and is the default under STIM_HOME unless explicitly enabled",
               "type": "boolean",
               "default": true,
               "x-stim": {
@@ -1494,7 +1530,7 @@
               }
             },
             "maxAgeDays": {
-              "description": "Days to keep archived workspace records; 0 keeps nothing",
+              "description": "Days to keep archived workspace records and worktree change archives; 0 keeps nothing",
               "type": "integer",
               "minimum": 0,
               "default": 30,
@@ -1522,7 +1558,7 @@
               }
             },
             "maxTotalGb": {
-              "description": "Total archived bytes in binary GB; 0 keeps no artifacts",
+              "description": "Total archived bytes in binary GB, and separately the worktree change archives; 0 keeps no artifacts",
               "type": "number",
               "minimum": 0,
               "default": 5,
@@ -2030,7 +2066,7 @@
               }
             },
             "pressureProtectMinutes": {
-              "description": "Protection window, in minutes, that replaces maintenance.protectRecentHours at disk pressure levels 2 and 3",
+              "description": "Protection window, in minutes, that replaces maintenance.protectRecentHours at disk pressure levels 2 and 3, except for workspace build outputs and build directories, which level 2 keeps for 15 minutes after the last ios, android or macos run",
               "type": "integer",
               "minimum": 0,
               "default": 10,
@@ -2058,7 +2094,7 @@
               }
             },
             "removeFinishedWorktrees": {
-              "description": "Remove clean linked worktrees whose branch or pull request finished, under gc.worktreeGraceMinutes, and at disk pressure level 3 clean, pushed ones with no commits of their own",
+              "description": "Remove linked worktrees whose branch or pull request finished, under gc.worktreeGraceMinutes, archiving a dirty one's uncommitted files first, and clean, pushed ones with no commits of their own once idle",
               "type": "boolean",
               "default": true,
               "x-stim": {
@@ -2323,7 +2359,7 @@
               }
             },
             "maxLoadPerCore": {
-              "description": "Load per core (5-minute load average divided by the CPU count) at which this machine counts as saturated: it declines builds other machines send it, automatic build placement stops preferring it, and automatic iOS and Android device placement treats it as busy",
+              "description": "Load per core (5-minute load average divided by the CPU count) at which this machine counts as saturated: it declines builds other machines send it, reports the limit in its device offers so other machines skip it like a full one, stops preferring itself for automatic placement, and automatic iOS, Android and macOS placement treats it as busy",
               "type": "number",
               "minimum": 0.1,
               "default": 2,
@@ -2368,7 +2404,7 @@
           "type": "object",
           "properties": {
             "machines": {
-              "description": "Tailscale names of the remote machines this machine may build on and host owned simulators on, each optionally with :<port> of its tailscale serve route (default 7443); what each is used for follows the build and device-host approvals it grants, which doctor --fix asks for separately",
+              "description": "Tailscale names of the remote machines this machine may build on and host owned simulators, emulators and macOS apps on, each optionally with :<port> of its tailscale serve route (default 7443). The order is the placement priority: each workload goes to the first machine with room and a load under its own limit. What each is used for follows the build and device-host approvals it grants, which doctor --fix asks for separately",
               "type": "array",
               "items": {
                 "type": "string"
@@ -2412,7 +2448,7 @@
               }
             },
             "easFallback": {
-              "description": "When ios.remote or android.remote is auto, this machine is at its concurrency.maxDevices cap and no remote.machines entry takes the run, run the simulator or emulator on a billed EAS Simulator instead of waiting or refusing, when eas-cli can",
+              "description": "When ios.remote or android.remote is auto or remote, this machine is at its concurrency.maxDevices cap and no remote.machines entry takes the run, run the simulator or emulator on a billed EAS Simulator instead of waiting or refusing, when eas-cli can; remote-only never uses it",
               "type": "boolean",
               "default": false,
               "x-stim": {
@@ -2440,7 +2476,7 @@
               }
             },
             "build": {
-              "description": "Build placement: auto follows remote.buildMode within enabled automatic pool members; local always builds here; a name in remote.machines requires that remote machine without fallback. The ios, android and macos --remote-build flag overrides this setting and its environment override",
+              "description": "Where iOS simulator Debug, Android emulator debug and macOS SwiftPM Debug builds run: local here; auto here while it has a free concurrency.maxBuilds slot and load under server.maxLoadPerCore, otherwise on a remote.machines entry; remote on a remote.machines entry in order, here only when none takes the build; remote-only the same but never here; a machine name exactly that machine without fallback. The ios, android and macos --remote-build flag overrides this setting and its environment override",
               "type": "string",
               "pattern": "^[A-Za-z0-9][A-Za-z0-9.-]*(?::(?!0+$)(?:[0-5]?[0-9]{1,4}|6[0-4][0-9]{3}|65[0-4][0-9]{2}|655[0-2][0-9]|6553[0-5]))?$",
               "default": "auto",
@@ -2452,24 +2488,6 @@
                 ],
                 "env": "STIM_REMOTE_BUILD"
               }
-            },
-            "buildMode": {
-              "description": "When remote.build is auto, where iOS simulator Debug, Android emulator debug and macOS SwiftPM Debug builds run: auto builds here while this machine has a free concurrency.maxBuilds slot and its load is under server.maxLoadPerCore, and otherwise builds on a less loaded machine in remote.machines; force builds on an enabled remote machine whenever one can take the build; off builds here when local is enabled in remote.buildPoolDisabled",
-              "type": "string",
-              "enum": [
-                "auto",
-                "force",
-                "off"
-              ],
-              "default": "auto",
-              "x-stim": {
-                "key": "remote.buildMode",
-                "kind": "choice",
-                "scopes": [
-                  "machine"
-                ],
-                "env": "STIM_REMOTE_BUILD_MODE"
-              }
             }
           },
           "additionalProperties": false

package/dist/{simslim-Bax1qcxu.mjs → simslim-DCQwzoPy.mjs}

@@ -1,5 +1,5 @@
-import { D as ownership_claim_exports, S as process_identity_exports, b as operationState, t as getExecutor, y as isTermination } from "./exec-VFRpu1iA.mjs";
-import { d as getConfigDir } from "./config-BktkY_zC.mjs";
+import { D as ownership_claim_exports, S as process_identity_exports, b as operationState, t as getExecutor, y as isTermination } from "./exec-aULwtNly.mjs";
+import { d as getConfigDir } from "./config-Cn94Jc0g.mjs";
 import { n as stripAnsi, r as waitForChild, t as createLineReader } from "./process-output-Fpl8PYi8.mjs";
 import { join } from "node:path";
 //#region src/engine/simslim.ts