stim 1.8.0 → 1.9.0

package/dist/{named-ports-DzMOlmaX.mjs → named-ports-CmLQSIRj.mjs}

@@ -1,7 +1,7 @@
-import { t as getExecutor } from "./exec-B29XNuhP.mjs";
-import { C as withConfigLock, f as getProject, g as loadConfig, s as ensureConfig, u as getConfigDir, w as process_identity_exports, y as saveConfig } from "./config-B7iyKWkL.mjs";
-import { c as isPortFree, o as signalProcessTree, r as listeningPids } from "./metro-C7bcJ0uo.mjs";
-import { t as withWorkspaceProcessLock } from "./workspace-process-lock-BYfZz_S-.mjs";
+import { D as process_identity_exports, T as withConfigLock, f as getProject, g as loadConfig, s as ensureConfig, u as getConfigDir, x as saveConfig } from "./config-Cp9lM3wX.mjs";
+import { t as getExecutor } from "./exec-jIAlgilk.mjs";
+import { d as isPortFree, l as signalProcessTree, r as listeningPids } from "./metro-DrLHaMn2.mjs";
+import { t as withWorkspaceProcessLock } from "./workspace-process-lock-DWaiRD0e.mjs";
 import { realpathSync } from "node:fs";
 //#region src/named-ports.ts
 const FIRST_PORT = 8900;

package/dist/{ndjson-BZwI1NBv.mjs → ndjson-9uFNRwfe.mjs}

@@ -1,6 +1,8 @@
-import { closeSync, mkdirSync, openSync, writeSync } from "fs";
+import { closeSync, mkdirSync, openSync, readFileSync, writeSync } from "fs";
 import { dirname } from "path";
+import { rotateLog, rotatedLogPath } from "@stim-cli/core";
 //#region src/ndjson.ts
+const ROTATE_CHECK_MS = 1e3;
 const LEVELS = [
 	"debug",
 	"info",
@@ -42,6 +44,19 @@ function parseNdjsonText(text) {
 	}
 	return out;
 }
+function readNdjsonGenerations(file) {
+	const out = [];
+	for (const path of [rotatedLogPath(file), file]) {
+		let text;
+		try {
+			text = readFileSync(path, "utf-8");
+		} catch {
+			continue;
+		}
+		for (const record of parseNdjsonText(text)) out.push(record);
+	}
+	return out;
+}
 function formatNdjsonLine(record) {
 	try {
 		return `${JSON.stringify(record)}\n`;
@@ -49,9 +64,11 @@ function formatNdjsonLine(record) {
 		return null;
 	}
 }
-function createNdjsonWriter(file, { truncate = false, fields = {} } = {}) {
+function createNdjsonWriter(file, { truncate = false, fields = {}, maxBytes, now = Date.now } = {}) {
 	let fd = null;
 	let freshFile = truncate;
+	let uncheckedBytes = 0;
+	let checkedAt = 0;
 	let written = 0;
 	let dropped = 0;
 	let lastError = null;
@@ -61,6 +78,20 @@ function createNdjsonWriter(file, { truncate = false, fields = {} } = {}) {
 		fd = openSync(file, freshFile ? "w" : "a");
 		freshFile = false;
 	}
+	function rotateIfDue(limit) {
+		if (fd !== null && uncheckedBytes < limit / 8 && now() - checkedAt < ROTATE_CHECK_MS) return;
+		if (fd !== null) {
+			try {
+				closeSync(fd);
+			} catch {}
+			fd = null;
+		}
+		uncheckedBytes = 0;
+		checkedAt = now();
+		try {
+			rotateLog(file, limit);
+		} catch {}
+	}
 	function write(record) {
 		if (closed) {
 			dropped += 1;
@@ -76,8 +107,10 @@ function createNdjsonWriter(file, { truncate = false, fields = {} } = {}) {
 			return false;
 		}
 		try {
+			if (maxBytes !== void 0) rotateIfDue(maxBytes);
 			if (fd === null) open();
 			writeSync(fd, line);
+			uncheckedBytes += Buffer.byteLength(line);
 			written += 1;
 			return true;
 		} catch (err) {
@@ -131,4 +164,4 @@ function stamp(record) {
 	};
 }
 //#endregion
-export { parseNdjsonLine as a, levelRank as i, SOURCES as n, parseNdjsonText as o, createNdjsonWriter as r, LEVELS as t };
+export { parseNdjsonLine as a, levelRank as i, SOURCES as n, readNdjsonGenerations as o, createNdjsonWriter as r, LEVELS as t };

package/dist/{ownership-Cp52QAK1.mjs → ownership-D15Op8vN.mjs}

@@ -1,6 +1,6 @@
-import { w as process_identity_exports } from "./config-B7iyKWkL.mjs";
-import { a as withWorkspaceStateLock, o as writeWorkspaceState, r as readWorkspaceState } from "./workspace-state-BT5E3SA2.mjs";
-import { i as pidExists } from "./metro-C7bcJ0uo.mjs";
+import { D as process_identity_exports } from "./config-Cp9lM3wX.mjs";
+import { c as writeWorkspaceState, o as withWorkspaceStateLock, r as readWorkspaceState } from "./workspace-state-DF2gCFhx.mjs";
+import { a as pidExists } from "./metro-DrLHaMn2.mjs";
 import { realpathSync } from "node:fs";
 //#region src/collector/state.ts
 function collectorRoot(root) {

package/dist/{ownership-wolE-0Do.mjs → ownership-DCQPuWEc.mjs}

@@ -1,12 +1,12 @@
-import { t as getExecutor } from "./exec-B29XNuhP.mjs";
-import { u as getConfigDir, w as process_identity_exports } from "./config-B7iyKWkL.mjs";
-import { t as createLineReader } from "./process-output-Dl5uKE03.mjs";
-import { i as pidExists, o as signalProcessTree } from "./metro-C7bcJ0uo.mjs";
-import { t as withWorkspaceProcessLock } from "./workspace-process-lock-BYfZz_S-.mjs";
+import { D as process_identity_exports, k as ownership_claim_exports, u as getConfigDir } from "./config-Cp9lM3wX.mjs";
+import { t as getExecutor } from "./exec-jIAlgilk.mjs";
+import { t as createLineReader } from "./process-output-Fpl8PYi8.mjs";
+import { a as pidExists, l as signalProcessTree } from "./metro-DrLHaMn2.mjs";
+import { r as workspaceProcessLockPath, t as withWorkspaceProcessLock } from "./workspace-process-lock-DWaiRD0e.mjs";
 import { t as probePublicHttp } from "./public-http-probe-CyMDrQ3c.mjs";
 import { closeSync, mkdirSync, openSync, readFileSync, unlinkSync } from "node:fs";
-import { createHash, randomUUID } from "node:crypto";
 import { basename, join, resolve, sep } from "node:path";
+import { createHash, randomUUID } from "node:crypto";
 //#region src/engine/tunnel.ts
 function tunnelArgv(provider, port, ngrokUrl, logFile) {
 	if (provider === "cloudflared") return {
@@ -78,6 +78,25 @@ async function withManagedRemoteWorktreeRemovalLock(worktreeRoot, fn, options =
 		ownerPurpose: "worktree removal"
 	});
 }
+function managedLockHolders(root) {
+	const locks = [{
+		label: "managed tunnel",
+		path: workspaceProcessLockPath(managedTunnelLockRoot(root), "metro-tunnel", false)
+	}, {
+		label: "managed remote",
+		path: workspaceProcessLockPath(managedRemoteWorktreeLockRoot(root), "managed-remote", true)
+	}];
+	const reasons = [];
+	for (const { label, path } of locks) {
+		const claims = (0, ownership_claim_exports.readClaimSet)(path);
+		const holder = claims.live[0];
+		if (holder) {
+			const purpose = typeof holder.details.purpose === "string" ? ` for ${holder.details.purpose}` : "";
+			reasons.push(`the ${label} lock is held${purpose}`);
+		} else if (claims.unresolved[0]) reasons.push(`the ${label} lock cannot be resolved: ${claims.unresolved[0].reason}`);
+	}
+	return reasons;
+}
 function managedTunnelLockRoot(root) {
 	const key = createHash("sha256").update(resolve(root)).digest("hex");
 	return join(getConfigDir(), "process-locks", key);
@@ -467,4 +486,4 @@ function numberOrNull(v) {
 	return typeof v === "number" && Number.isSafeInteger(v) && v > 0 ? v : null;
 }
 //#endregion
-export { withManagedRemoteWorktreeLock as a, withManagedTunnelRemovalLock as c, terminateChild as i, startTunnelSequence as n, withManagedRemoteWorktreeRemovalLock as o, stopTunnel as r, withManagedTunnelLock as s, resolveSupervisorTarget as t };
+export { terminateChild as a, withManagedTunnelLock as c, stopTunnel as i, withManagedTunnelRemovalLock as l, managedLockHolders as n, withManagedRemoteWorktreeLock as o, startTunnelSequence as r, withManagedRemoteWorktreeRemovalLock as s, resolveSupervisorTarget as t };

package/dist/{ports-BIbJaKNW.mjs → ports-BNKoWVWZ.mjs}

@@ -1,6 +1,6 @@
-import { f as getProject } from "./config-B7iyKWkL.mjs";
-import { a as findProjectRoot } from "./project-DDZWf_16.mjs";
-import { n as getNamedPort, t as clearNamedPorts } from "./named-ports-DzMOlmaX.mjs";
+import { f as getProject } from "./config-Cp9lM3wX.mjs";
+import { o as findProjectRoot } from "./project-DS112DYB.mjs";
+import { n as getNamedPort, t as clearNamedPorts } from "./named-ports-CmLQSIRj.mjs";
 //#region src/commands/ports.ts
 async function inProject(action) {
 	try {

package/dist/{process-output-Dl5uKE03.mjs → process-output-Fpl8PYi8.mjs}

@@ -16,7 +16,7 @@ function createLineReader(onLine) {
 			if (!buffered) return;
 			const rest = buffered;
 			buffered = "";
-			onLine(rest);
+			onLine(rest.endsWith("\r") ? rest.slice(0, -1) : rest);
 		}
 	};
 }

package/dist/{project-DDZWf_16.mjs → project-DS112DYB.mjs}

@@ -1,5 +1,5 @@
-import { c as findEnclosingWorktreeRoot, f as getProject } from "./config-B7iyKWkL.mjs";
-import { g as repoRoot } from "./worktree-FG_ZKKdb.mjs";
+import { c as findEnclosingWorktreeRoot, f as getProject } from "./config-Cp9lM3wX.mjs";
+import { _ as repoRoot } from "./worktree-R_cUlE7s.mjs";
 import { existsSync, readFileSync, readdirSync, realpathSync } from "fs";
 import { basename, dirname, join, resolve } from "path";
 import { createRequire } from "module";
@@ -38,6 +38,11 @@ function ownedDeviceLabel(projectPath) {
 	const worktreeLabel = basename(realpathSync(root));
 	return worktreeLabel === appLabel ? appLabel : `${worktreeLabel}-${appLabel}`;
 }
+const NO_PROJECT_REFUSAL = {
+	code: "STIM_NO_PROJECT",
+	message: "Not in a React Native project (no package.json found).",
+	remedy: "Run this from the app directory -- the one holding package.json."
+};
 function findProjectRoot(startDir) {
 	let dir;
 	try {
@@ -240,4 +245,4 @@ function detectAndroidPackageFromGradle(projectRoot) {
 	return null;
 }
 //#endregion
-export { findProjectRoot as a, projectShortcut as c, detectIsExpo as i, resolvePackageJson as l, detectAndroidPackage as n, isPackageResolvable as o, detectBundleId as r, ownedDeviceLabel as s, appProjectProblem as t };
+export { detectIsExpo as a, ownedDeviceLabel as c, detectBundleId as i, projectShortcut as l, appProjectProblem as n, findProjectRoot as o, detectAndroidPackage as r, isPackageResolvable as s, NO_PROJECT_REFUSAL as t, resolvePackageJson as u };

package/dist/{reload-BdypPbjM.mjs → reload-ZNJUo1pl.mjs}

@@ -1,12 +1,13 @@
-import { I as deviceSlotPlatforms, L as parseDeviceSlotKey, f as getProject } from "./config-B7iyKWkL.mjs";
-import { a as findProjectRoot } from "./project-DDZWf_16.mjs";
-import { d as readWorkspaceLaunches } from "./state-DZobzxLW.mjs";
-import { a as resolveProjectMetro } from "./metro-C7bcJ0uo.mjs";
-import { I as resolveOwnedAvdSerial } from "./android-DWssqHQ8.mjs";
-import { l as phaseLine } from "./command-output-B3ycpsYv.mjs";
-import { u as androidAppProcess, y as iosAppProcess } from "./app-install-BDbsSgCl.mjs";
-import { x as resolveOwnedIosSim } from "./ios-BcCiI4TS.mjs";
-import { n as nativeRunCommand } from "./slot-launch-ZUUe0TQP.mjs";
+import { U as deviceSlotPlatforms, W as parseDeviceSlotKey, f as getProject } from "./config-Cp9lM3wX.mjs";
+import { i as recordWorkspaceUse } from "./workspace-state-DF2gCFhx.mjs";
+import { o as findProjectRoot } from "./project-DS112DYB.mjs";
+import { d as readWorkspaceLaunches } from "./state-NcJzMEBF.mjs";
+import { c as resolveProjectMetro } from "./metro-DrLHaMn2.mjs";
+import { R as resolveOwnedAvdSerial } from "./android-_y4Ohi5z.mjs";
+import { f as refuseNoProject, l as phaseLine } from "./command-output-gByVmIjy.mjs";
+import { h as iosAppProcess, o as androidAppProcess } from "./app-install-Uf3a83Tv.mjs";
+import { C as resolveOwnedIosSim } from "./ios-BL2NFckr.mjs";
+import { n as nativeRunCommand } from "./slot-launch-DU9A-gYw.mjs";
 import chalk from "chalk";
 import { WebSocket } from "ws";
 //#region src/engine/reload.ts
@@ -305,12 +306,10 @@ function registerReload(program, deps = {}) {
 		}
 		const root = (deps.findProjectRoot ?? DEFAULT_DEPS.findProjectRoot)(process.cwd());
 		if (!root) {
-			const error = failure("STIM_NO_PROJECT", "Not inside a project (no package.json found above the current directory).", null);
-			if (opts.json) console.log(JSON.stringify(error));
-			else console.error(chalk.red(phaseLine("error", `${error.code}: ${error.message}`)));
-			process.exitCode = 1;
+			refuseNoProject({ json: Boolean(opts.json) });
 			return;
 		}
+		recordWorkspaceUse(root);
 		const result = await runReload({
 			root,
 			platform: value ?? null,

package/dist/{server-bare-BQkyxa_b.mjs → server-bare-DWkkcIxV.mjs}

@@ -1,7 +1,7 @@
 import { i as __require, t as __commonJSMin } from "./rolldown-runtime-BsOwBuO_.mjs";
 import { n as supervisorError } from "./errors-B6W7FkxQ.mjs";
-import { C as projectMetroSharedCache } from "./settings-BXXorVM2.mjs";
-import { a as metroStoreRoot, o as registerMetroStore, t as appendCacheStore } from "./metro-store-CDDZHtPl.mjs";
+import { S as projectMetroSharedCache } from "./settings-D030k0t4.mjs";
+import { a as metroStoreRoot, o as registerMetroStore, t as appendCacheStore } from "./metro-store-DzeWkfqW.mjs";
 import { createRequire } from "node:module";
 import { isAbsolute, join, relative, sep } from "node:path";
 //#endregion

package/dist/{server-expo-BVAA1OqJ.mjs → server-expo-B_lctBR3.mjs}

@@ -1,11 +1,12 @@
-import { t as getExecutor } from "./exec-B29XNuhP.mjs";
-import { r as createNdjsonWriter } from "./ndjson-BZwI1NBv.mjs";
-import { l as resolvePackageJson } from "./project-DDZWf_16.mjs";
+import { t as getExecutor } from "./exec-jIAlgilk.mjs";
+import { r as createNdjsonWriter } from "./ndjson-9uFNRwfe.mjs";
+import { u as resolvePackageJson } from "./project-DS112DYB.mjs";
 import { n as supervisorError } from "./errors-B6W7FkxQ.mjs";
-import { n as stripAnsi, t as createLineReader } from "./process-output-Dl5uKE03.mjs";
-import { C as projectMetroSharedCache } from "./settings-BXXorVM2.mjs";
-import { a as metroStoreRoot, i as metroStoreConfirmedRoot, n as expoMetroConfigPath, o as registerMetroStore, r as expoMetroStoreEnv } from "./metro-store-CDDZHtPl.mjs";
+import { n as stripAnsi, t as createLineReader } from "./process-output-Fpl8PYi8.mjs";
+import { S as projectMetroSharedCache } from "./settings-D030k0t4.mjs";
+import { a as metroStoreRoot, i as metroStoreConfirmedRoot, n as expoMetroConfigPath, o as registerMetroStore, r as expoMetroStoreEnv } from "./metro-store-DzeWkfqW.mjs";
 import { accessSync, constants, existsSync, readFileSync } from "node:fs";
+import { LOG_ROTATE_BYTES } from "@stim-cli/core";
 import { dirname, join, parse } from "node:path";
 //#region src/supervisor/server-expo.ts
 function delay(ms) {
@@ -209,7 +210,7 @@ async function startExpoServer({ root, port, logsDir, writer = null, spawnFn = n
 		throw supervisorError("STIM_EXPO_BIN", refusal.message, refusal.remedy);
 	}
 	const bin = resolved.path;
-	const log = writer || createNdjsonWriter(join(logsDir, "metro.ndjson"));
+	const log = writer || createNdjsonWriter(join(logsDir, "metro.ndjson"), { maxBytes: LOG_ROTATE_BYTES });
 	const spawn = spawnFn || ((cmd, args, opts) => getExecutor().spawn(cmd, args, opts));
 	const args = [
 		"start",

package/dist/server-expo-CeILEu86.mjs

@@ -0,0 +1,2 @@
+import { p as startExpoServer } from "./server-expo-B_lctBR3.mjs";
+export { startExpoServer };

package/dist/settings-BKNh5rl4.mjs

@@ -0,0 +1,376 @@
+import { E as writeConfigSetting, T as withConfigLock, d as getConfigPath, g as loadConfig, j as isJsonObject, m as getRepoSettings, p as getProjectSettings } from "./config-Cp9lM3wX.mjs";
+import { _ as repoRoot, s as gitCommonDir } from "./worktree-R_cUlE7s.mjs";
+import { o as findProjectRoot, t as NO_PROJECT_REFUSAL } from "./project-DS112DYB.mjs";
+import { B as isSensitiveReference, F as unknownSettingKeys, H as settingValueError, R as SETTINGS, T as readCommittedSettings, V as settingDefinition, z as SETTING_SCOPES } from "./settings-D030k0t4.mjs";
+import { existsSync, readFileSync, renameSync, unlinkSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import chalk from "chalk";
+//#region src/commands/settings.ts
+const MASK = "********";
+const PRECEDENCE = [
+	"workspace",
+	"repo",
+	"committed",
+	"machine"
+];
+var Refusal = class extends Error {
+	code;
+	remedy;
+	constructor(code, message, remedy) {
+		super(message);
+		this.code = code;
+		this.remedy = remedy;
+	}
+};
+function readContext(env) {
+	const projectPath = findProjectRoot(process.cwd());
+	const start = projectPath ?? process.cwd();
+	const common = gitCommonDir(start);
+	return {
+		projectPath,
+		gitCommonDir: common,
+		repoRoot: common ? repoRoot(start) ?? projectPath : null,
+		machine: loadConfig(),
+		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();
+	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.projectPath ? getProjectSettings(context.projectPath) : {};
+	if (scope === "repo") return context.gitCommonDir ? getRepoSettings(context.gitCommonDir) : {};
+	return readCommittedSettings(committedDirectory(context, setting));
+}
+function masked(setting, value) {
+	return setting.sensitive && value !== void 0 && value !== null ? MASK : value;
+}
+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 winner = PRECEDENCE.find((scope) => scope in layers);
+	let value = null;
+	let origin = null;
+	if (env) {
+		value = env.value;
+		origin = "env";
+	} else if (scopedHome) {
+		value = setting.scopedHomeValue;
+		origin = "env";
+	} else if (winner) {
+		value = layers[winner];
+		origin = winner;
+	} else if (setting.default !== void 0) {
+		value = setting.default;
+		origin = "default";
+	}
+	return {
+		key: setting.key,
+		value,
+		origin,
+		layers,
+		...env ? { env } : scopedHome ? { env: {
+			name: "STIM_HOME",
+			value: context.env.STIM_HOME
+		} } : {},
+		...setting.sensitive ? { sensitive: true } : {}
+	};
+}
+function unknownEntries(context) {
+	const sources = [
+		{
+			scope: "machine",
+			file: layerFile(context, "machine", null),
+			settings: { optimizations: context.machine?.optimizations }
+		},
+		{
+			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: readCommittedSettings(repository)
+	});
+	return sources.flatMap(({ scope, file, settings }) => file === null ? [] : unknownSettingKeys(settings).map((key) => ({
+		key,
+		scope,
+		file,
+		value: valueAt(settings, key)
+	})));
+}
+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)
+	};
+}
+function requireSetting(key) {
+	const setting = settingDefinition(key);
+	if (setting) return setting;
+	throw new Refusal("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 readScope(raw, setting) {
+	if (raw === void 0) {
+		if (setting.scopes.length === 1) return setting.scopes[0];
+		throw new Refusal("STIM_BAD_ARG", `${setting.key} can live in more than one layer, so the command needs --scope.`, `Pass --scope ${setting.scopes.join("|")}.`);
+	}
+	if (!SETTING_SCOPES.includes(raw)) throw new Refusal("STIM_BAD_ARG", `--scope takes ${SETTING_SCOPES.join(", ")}, not ${JSON.stringify(raw)}.`, null);
+	const scope = raw;
+	if (!setting.scopes.includes(scope)) throw new Refusal("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 Refusal("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 Refusal(NO_PROJECT_REFUSAL.code, NO_PROJECT_REFUSAL.message, NO_PROJECT_REFUSAL.remedy);
+}
+function example(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 parseSettingValue(setting, raw) {
+	const invalid = (expected) => new Refusal("STIM_BAD_ARG", `Invalid ${setting.key} value ${JSON.stringify(raw)}. Expected ${expected}.`, `For example: stim settings set ${setting.key} ${example(setting)}${setting.scopes.length > 1 ? ` --scope ${setting.scopes[0]}` : ""}`);
+	let value = raw;
+	const kind = setting.type.kind;
+	if (kind === "boolean" || kind === "number" || kind === "strings" || kind === "object") try {
+		value = JSON.parse(raw);
+	} catch {
+		value = 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 Refusal(NO_PROJECT_REFUSAL.code, NO_PROJECT_REFUSAL.message, NO_PROJECT_REFUSAL.remedy);
+	return join(directory, ".stim.json");
+}
+function writeCommitted(file, key, value) {
+	return withConfigLock(() => {
+		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 Refusal("STIM_BAD_ARG", `${file} is not valid JSON: ${error.message}`, `Repair ${file}, then run the command again.`);
+		}
+		if (!isJsonObject(parsed)) throw new Refusal("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;
+	});
+}
+function writeSetting(context, setting, scope, value) {
+	if (scope === "committed") return writeCommitted(committedTarget(context, setting), setting.key, value);
+	if (scope === "machine") return writeConfigSetting({ scope }, setting.key, value);
+	if (scope === "workspace") return writeConfigSetting({
+		scope,
+		projectPath: context.projectPath
+	}, setting.key, value);
+	return writeConfigSetting({
+		scope,
+		gitCommonDir: context.gitCommonDir
+	}, setting.key, value);
+}
+function formatValue(value) {
+	return typeof value === "string" ? value : JSON.stringify(value);
+}
+const CONSOLE = {
+	out: (line) => console.log(line),
+	note: (line) => console.error(line)
+};
+function run(json, io, action) {
+	try {
+		action();
+	} catch (error) {
+		const code = error.code;
+		if (!(error instanceof Refusal) && !(typeof code === "string" && code.startsWith("STIM_"))) throw error;
+		const failure = {
+			code,
+			message: error.message,
+			remedy: error instanceof Refusal ? error.remedy : null
+		};
+		io.note(chalk.red(`${failure.code}: ${failure.message}`));
+		if (failure.remedy) io.note(chalk.dim(failure.remedy));
+		if (json) io.out(JSON.stringify(failure));
+		process.exitCode = 1;
+	}
+}
+function wantsJson(opts, command) {
+	return Boolean(opts.json ?? command.parent?.opts().json);
+}
+function registerSettings(program, io = CONSOLE, env = process.env) {
+	const settings = program.command("settings").description("Show every Stim setting with its effective value and layer, or change one").option("--json", "print every setting, its origin, and each layer value as JSON").action((opts) => run(Boolean(opts.json), io, () => {
+		const payload = settingsPayload(readContext(env));
+		if (opts.json) {
+			io.out(JSON.stringify(payload));
+			return;
+		}
+		const width = Math.max(...payload.settings.map((entry) => entry.key.length));
+		for (const entry of payload.settings) {
+			const origin = entry.origin ?? "unset";
+			const shown = entry.origin === null ? "" : formatValue(entry.value);
+			io.out(`${entry.key.padEnd(width)}  ${shown}${shown ? "  " : ""}${chalk.dim(`(${origin})`)}`);
+		}
+		for (const entry of payload.unknown) io.note(chalk.yellow(`Warning: ${entry.key} in ${entry.file} is not read by Stim.`));
+	}));
+	settings.command("get <key>").description("Print the effective value of a setting, or its value in one layer").option("--scope <scope>", `read one layer: ${SETTING_SCOPES.join(", ")}`).option("--json", "print the setting entry as JSON").action((key, opts, command) => run(wantsJson(opts, command), io, () => {
+		const setting = requireSetting(key);
+		const scope = opts.scope === void 0 ? null : readScope(opts.scope, setting);
+		const context = readContext(env);
+		const entry = settingEntry(context, setting);
+		const value = scope ? entry.layers[scope] ?? null : entry.value;
+		if (wantsJson(opts, command)) {
+			io.out(JSON.stringify(scope ? {
+				key,
+				scope,
+				file: layerFile(context, scope, setting),
+				value
+			} : entry));
+			return;
+		}
+		if (value !== null) io.out(formatValue(value));
+	}));
+	settings.command("set <key> <value>").description("Write a setting to one layer").option("--scope <scope>", `the layer to write: ${SETTING_SCOPES.join(", ")}`).option("--json", "print the written setting as JSON").action((key, raw, opts, command) => run(wantsJson(opts, command), io, () => {
+		const setting = requireSetting(key);
+		const scope = readScope(opts.scope, setting);
+		const value = parseSettingValue(setting, raw);
+		if (setting.sensitive && scope === "committed" && !isSensitiveReference(value)) throw new Refusal("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, or commit a reference such as env:MY_KEYSTORE_PASSWORD.`);
+		const context = readContext(env);
+		const file = requireLayer(context, scope, setting);
+		const changed = writeSetting(context, setting, scope, value);
+		report(io, wantsJson(opts, command), {
+			key,
+			scope,
+			file,
+			changed
+		}, setting, readContext(env), "set");
+	}));
+	settings.command("unset <key>").description("Remove a setting from one layer").option("--scope <scope>", `the layer to clear: ${SETTING_SCOPES.join(", ")}`).option("--json", "print the setting after removal as JSON").action((key, opts, command) => run(wantsJson(opts, command), io, () => {
+		const setting = requireSetting(key);
+		const scope = readScope(opts.scope, setting);
+		const context = readContext(env);
+		const file = requireLayer(context, scope, setting);
+		const changed = writeSetting(context, setting, scope, void 0);
+		report(io, wantsJson(opts, command), {
+			key,
+			scope,
+			file,
+			changed
+		}, setting, readContext(env), "unset");
+	}));
+}
+function report(io, json, write, setting, context, verb) {
+	const entry = settingEntry(context, setting);
+	if (json) {
+		io.out(JSON.stringify({
+			...write,
+			setting: entry
+		}));
+		return;
+	}
+	const effective = entry.origin === null ? "unset" : `${formatValue(entry.value)} (${entry.origin})`;
+	if (!write.changed) {
+		io.out(`${write.key} was not set in ${write.file}; effective value: ${effective}`);
+		return;
+	}
+	const shown = verb === "set" ? ` = ${formatValue(entry.layers[write.scope])}` : "";
+	io.out(`${verb} ${write.key}${shown} in ${write.file}; effective value: ${effective}`);
+}
+function settingsCommand(program) {
+	registerSettings(program);
+}
+//#endregion
+export { settingsCommand as default, registerSettings };