stim 1.26.0 → 1.28.0

package/dist/native-run-BfIDFKLH.mjs

@@ -1,275 +0,0 @@
-import { D as ownership_claim_exports, b as operationState, g as signalDeclaredSpawns, h as refuseDeclaredSpawns, p as allowDeclaredSpawns, u as withWorkspaceProcessLock, y as isTermination } from "./exec-VFRpu1iA.mjs";
-import { E as workspaceDir, l as withWorkspaceStateLockAsync, o as updateWorkspaceState, r as readWorkspaceState, t as clearWorkspaceStateKey } from "./workspace-state-pUg3_RRA.mjs";
-import { a as formatElapsed, l as phaseLine } from "./command-output-BF5AR2dL.mjs";
-import { t as canonicalPath } from "./paths-BsJMoPP2.mjs";
-import { existsSync, mkdirSync } from "node:fs";
-import { basename, dirname, join } from "node:path";
-import { setTimeout } from "node:timers/promises";
-//#region src/cache/cache-claim.ts
-const LABEL = "cache";
-const POLL_MS = 500;
-const EMPTYING_WAIT_MS = 6e5;
-/**
-* The claim set guarding a cache Stim can only empty whole. It sits beside the cache's resolved directory, so emptying
-* the cache never removes it and every path that reaches the same cache names the same set; before the cache exists,
-* its resolved parent stands in for it.
-*/
-function cacheClaimRoot(dir) {
-	return `${existsSync(dir) ? canonicalPath(dir) : join(canonicalPath(dirname(dir)), basename(dir))}.claims`;
-}
-function describe(holder) {
-	const { platform, projectRoot } = holder.details;
-	const where = typeof projectRoot === "string" ? ` in ${projectRoot}` : "";
-	return holder.mode === "shared" ? `the ${typeof platform === "string" ? platform : "iOS"} build (pid ${holder.owner.pid}${where}) may be using it` : `pid ${holder.owner.pid} is emptying it`;
-}
-/** Why the cache at `dir` may be in use, from its claim set, without taking or removing any claim. */
-function cacheUser(dir) {
-	const root = cacheClaimRoot(dir);
-	const survey = (0, ownership_claim_exports.readClaimSet)(root);
-	const problem = survey.unresolved[0];
-	if (problem) return `the cache claim ${problem.path} is unresolved, so a build may be using it`;
-	const holder = survey.live[0];
-	return holder ? describe(holder) : void 0;
-}
-/**
-* Takes the exclusive claim an emptier holds while it removes the cache's contents; a string is why it cannot.
-* It never waits for a build that holds the cache.
-*/
-function claimForEmptying(dir) {
-	try {
-		const attempt = (0, ownership_claim_exports.tryAcquireClaim)({
-			root: cacheClaimRoot(dir),
-			mode: "exclusive",
-			label: LABEL
-		});
-		if (attempt.acquired) return attempt.acquired;
-		if (attempt.pending) (0, ownership_claim_exports.releaseClaim)(attempt.pending);
-		const holder = attempt.held ?? attempt.waitingFor?.[0];
-		return holder ? describe(holder) : `its claim at ${cacheClaimRoot(dir)} could not be taken`;
-	} catch (error) {
-		if ((0, ownership_claim_exports.isClaimRefusal)(error) || (0, ownership_claim_exports.isClaimUnavailable)(error)) return error.message;
-		return `its claim at ${cacheClaimRoot(dir)} could not be taken: ${error instanceof Error ? error.message : String(error)}`;
-	}
-}
-/**
-* Takes the shared claim a build holds on the compilation cache it compiles with, waiting while an emptier holds it.
-* A claim set Stim cannot resolve, or no process identity, is a failure: the build never runs unguarded.
-*/
-async function shareCompilationCache({ dir, projectRoot, note, signal }) {
-	const started = Date.now();
-	let told = false;
-	for (;;) {
-		signal?.throwIfAborted();
-		let attempt;
-		let root = `${dir}.claims`;
-		try {
-			mkdirSync(dirname(dir), { recursive: true });
-			root = cacheClaimRoot(dir);
-			attempt = (0, ownership_claim_exports.tryAcquireClaim)({
-				root,
-				mode: "shared",
-				label: LABEL,
-				details: {
-					platform: "ios",
-					projectRoot
-				}
-			});
-		} catch (error) {
-			return { failure: (0, ownership_claim_exports.claimFailure)(error, null) ?? {
-				code: ownership_claim_exports.CLAIM_UNAVAILABLE,
-				message: `Stim could not take the compilation cache claim at ${root}: ${error instanceof Error ? error.message : String(error)}.`,
-				remedy: `Restore write access to ${dirname(root)}, then retry the same Stim command.`
-			} };
-		}
-		if (attempt.acquired) return { claim: attempt.acquired };
-		const emptier = attempt.held ? `pid ${attempt.held.owner.pid}` : "another process";
-		const waited = Date.now() - started;
-		if (waited >= EMPTYING_WAIT_MS) return { failure: {
-			code: "STIM_BUILD_FAILED",
-			message: `${emptier} has been emptying the compilation cache at ${dir} for ${formatElapsed(waited)}.`,
-			remedy: "Run the same command again once it has finished."
-		} };
-		if (!told) note(phaseLine("build", `waiting for ${emptier} to finish emptying the compilation cache at ${dir}`));
-		told = true;
-		await setTimeout(POLL_MS);
-	}
-}
-//#endregion
-//#region src/engine/native-run.ts
-const NATIVE_RUN_LOCK = "native-run";
-const NATIVE_RUN_WAIT_MS = 18e5;
-const WAIT_HEARTBEAT_MS = 3e4;
-const CANCEL_REQUEST_KEY = "nativeRunCancel";
-const REQUEST_POLL_MS = 250;
-function nativeRunHolder(holder) {
-	const { command, platform, slot, interrupt } = holder.details;
-	return {
-		command: typeof command === "string" ? command : null,
-		platform: typeof platform === "string" ? platform : null,
-		slot: typeof slot === "string" ? slot : "default",
-		takesSignals: interrupt === "signal"
-	};
-}
-function describeNativeRunHolder(holder, now) {
-	const { command, slot } = nativeRunHolder(holder);
-	const started = Date.parse(holder.startedAt);
-	const facts = [`pid ${holder.owner.pid}`];
-	if (Number.isFinite(started)) facts.push(`running for ${formatElapsed(now - started)}`);
-	if (command === null) return `another Stim run (${facts.join(", ")})`;
-	if (command === "build") return `an artifact build (${facts.join(", ")})`;
-	return `\`stim ${command}${slot === "default" ? "" : ` --slot ${slot}`}\` (${facts.join(", ")})`;
-}
-/**
-* Report a wait on the native-run lock: one line as soon as a holder is seen, a line for each new
-* holder, and a heartbeat every WAIT_HEARTBEAT_MS while the same holder keeps it.
-*/
-function nativeRunWaitNotice({ write, now = Date.now, describe = describeNativeRunHolder }) {
-	let claimId = null;
-	let lastAt = 0;
-	return (holder, firstLine) => {
-		const at = now();
-		if (holder.claimId !== claimId) {
-			claimId = holder.claimId;
-			lastAt = at;
-			write(firstLine ?? `waiting for ${describe(holder, at)} in this workspace to finish`);
-			return;
-		}
-		if (at - lastAt < WAIT_HEARTBEAT_MS) return;
-		lastAt = at;
-		write(`still waiting for ${describe(holder, at)}`);
-	};
-}
-/**
-* What `stop` does about the run holding the native-run lock. A build is interrupted only when the stop
-* leaves it nothing to deploy to: the whole workspace stops, the build targets the stopped slot, or the
-* stopped slot is the workspace's only device. A build for another slot that stays is left running and
-* the stop proceeds without the lock. Only an owner whose identity is proven live is signalled.
-*/
-function decideStopAction({ stopSlot, holder, ownerIdentity, deviceSlots }) {
-	if (holder.command === "macos" || holder.command === "build") {
-		if (stopSlot !== void 0) return { action: "proceed" };
-		return ownerIdentity === "same" ? { action: "interrupt" } : { action: "refuse" };
-	}
-	if (holder.command !== "ios" && holder.command !== "android") return { action: "wait" };
-	if (!(stopSlot === void 0 || holder.slot === stopSlot || deviceSlots.includes(stopSlot) && deviceSlots.every((slot) => slot === stopSlot))) return { action: "proceed" };
-	return ownerIdentity === "same" ? { action: "interrupt" } : { action: "refuse" };
-}
-const requestListeners = /* @__PURE__ */ new Map();
-/**
-* Ask the run holding `claimId` to cancel: the request is written to the workspace state, where the run's watch
-* finds it, and a run in this process is told at once.
-*/
-function requestNativeRunCancel(root, claimId, pid = process.pid) {
-	updateWorkspaceState(root, (state) => ({
-		...state,
-		[CANCEL_REQUEST_KEY]: {
-			claimId,
-			pid,
-			at: (/* @__PURE__ */ new Date()).toISOString()
-		}
-	}));
-	requestListeners.get(claimId)?.();
-}
-function cancelRequestFor(root, claimId) {
-	const request = readWorkspaceState(root)?.[CANCEL_REQUEST_KEY];
-	if (request?.claimId !== claimId || typeof request.pid !== "number") return null;
-	return { pid: request.pid };
-}
-function clearNativeRunCancel(root, claimId) {
-	try {
-		clearWorkspaceStateKey(root, CANCEL_REQUEST_KEY, (value) => value?.claimId === claimId);
-	} catch {}
-}
-/** The active native run of `context`'s operation aborts this signal when it is cancelled. */
-function runCancellationSignal(context) {
-	return operationState(context).runSignal;
-}
-/** Why `context`'s native run was cancelled, or null while it was not. */
-function runCancellation(context) {
-	return operationState(context).cancelled;
-}
-function cancelledFailure(context, platform, { code, message }) {
-	const cancelled = runCancellation(context);
-	if (cancelled === null || code === "STIM_CLAIM_UNAVAILABLE") return null;
-	return {
-		code: "STIM_CANCELLED",
-		message: `The ${platform} run was ${cancelled} before it finished.`,
-		remedy: `Run \`stim ${platform}\` again when you want the app on a device.`,
-		lines: [`it stopped at ${code ?? "an unfinished step"}${message ? `: ${message}` : ""}`]
-	};
-}
-function cancelOnAbort({ context, root, claim, write, controller }) {
-	const state = operationState(context);
-	const cancel = () => {
-		if (controller.signal.aborted) return;
-		const request = cancelRequestFor(root, claim.claimId);
-		const cancelled = request ? `cancelled by \`stim stop\` (pid ${request.pid})` : "cancelled by an interrupt";
-		state.cancelled = cancelled;
-		state.handled = true;
-		controller.abort();
-		refuseDeclaredSpawns(context, `the run was ${cancelled}`);
-		const signalled = signalDeclaredSpawns(context, "SIGINT");
-		if (signalled > 0 || request) state.draining = true;
-		write(signalled > 0 ? `${cancelled}; stopping the running build tool` : request ? `${cancelled}; stopping before the next build tool or install` : cancelled);
-	};
-	const onAbort = () => {
-		if (!isTermination(context.signal.reason)) cancel();
-	};
-	const onRequest = () => {
-		if (controller.signal.aborted || !cancelRequestFor(root, claim.claimId)) return;
-		cancel();
-		state.abortOperation?.("stop");
-	};
-	context.signal.addEventListener("abort", onAbort);
-	if (context.signal.aborted) onAbort();
-	requestListeners.set(claim.claimId, onRequest);
-	const watch = setInterval(onRequest, REQUEST_POLL_MS);
-	watch.unref();
-	return async () => {
-		clearInterval(watch);
-		requestListeners.delete(claim.claimId);
-		context.signal.removeEventListener("abort", onAbort);
-		allowDeclaredSpawns(context);
-		await withWorkspaceStateLockAsync(root, () => clearNativeRunCancel(root, claim.claimId)).catch(() => {});
-	};
-}
-/**
-* Run an `ios`, `android` or `macos` invocation under the workspace's native-run lock: the claim records the
-* command, platform and slot, and a wait for another holder is reported on `write`. An abort of `context.signal`
-* forwards an interrupt to the running declared build tool and refuses any later one; a run `stim stop` cancelled
-* stops before its next build tool or install. A `SIGTERM` abort reason is left to the caller.
-*/
-function withNativeBuildRun(context, root, details, fn, { write }) {
-	const notice = nativeRunWaitNotice({ write });
-	const state = operationState(context);
-	return withWorkspaceProcessLock(workspaceDir(root), NATIVE_RUN_LOCK, async (claim) => {
-		state.cancelled = null;
-		const controller = new AbortController();
-		state.runSignal = controller.signal;
-		const dispose = cancelOnAbort({
-			context,
-			root,
-			claim,
-			write,
-			controller
-		});
-		try {
-			return await fn(claim);
-		} finally {
-			await dispose();
-			state.runSignal = void 0;
-		}
-	}, {
-		external: true,
-		signal: context.signal,
-		waitMs: NATIVE_RUN_WAIT_MS,
-		declareSpawnsFor: context,
-		details: {
-			...details,
-			interrupt: state.takesSignals ? "signal" : "request"
-		},
-		onHeld: (holder) => notice(holder)
-	});
-}
-//#endregion
-export { decideStopAction as a, nativeRunWaitNotice as c, runCancellationSignal as d, withNativeBuildRun as f, shareCompilationCache as h, clearNativeRunCancel as i, requestNativeRunCancel as l, claimForEmptying as m, NATIVE_RUN_WAIT_MS as n, describeNativeRunHolder as o, cacheUser as p, cancelledFailure as r, nativeRunHolder as s, NATIVE_RUN_LOCK as t, runCancellation as u };

package/dist/server-expo-wvcj5tiZ.mjs

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

package/dist/settings-write-QjYfSrjF.mjs

@@ -1,360 +0,0 @@
-import { u as withWorkspaceProcessLock } from "./exec-VFRpu1iA.mjs";
-import { A as writeConfigSettingAsync, O as withConfigLockAsync$1, _ as loadConfig$1, f as getConfigPath$1, h as getRepoSettings, m as getProjectSettings } from "./config-BktkY_zC.mjs";
-import { a as killOnAbort, i as gitPath } from "./operation-exec-CUZifp6Z.mjs";
-import { B as readCommittedSettings, at as unknownSettingKeys } from "./settings-CosW5X-S.mjs";
-import { r as findCommandWorkspaceAsync, t as NO_PROJECT_REFUSAL } from "./project-BUu6Is4k.mjs";
-import { i as stimDesktopInstalledAsync, n as settingDefault, r as stimDesktopInstalled } from "./stim-desktop-6Dqp-gjX.mjs";
-import { n as recordingLayers, t as deleteTurnedOffRecordings } from "./recordings-BldzVKq0.mjs";
-import { existsSync, readFileSync, renameSync, unlinkSync, writeFileSync } from "node:fs";
-import { join } from "node:path";
-import { configDir } from "@stim-cli/core";
-import { SETTINGS, SETTING_SCOPES, coerceSettingText, isJsonObject, isSensitiveReference, 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;
-}
-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 }
-		},
-		{
-			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) => ({
-		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)
-	};
-}
-/** 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
-//#region src/workspace/settings-write.ts
-function requireSetting(key) {
-	const setting = settingDefinition(key);
-	if (setting) return setting;
-	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 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("|")}.`);
-	}
-	if (!SETTING_SCOPES.includes(raw)) throw new SettingsRefusal("STIM_BAD_ARG", `--scope takes ${SETTING_SCOPES.join(", ")}, not ${JSON.stringify(raw)}.`, null);
-	const scope = 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);
-	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();
-}
-//#endregion
-export { layerFile as a, settingEntry as c, SettingsRefusal as i, readScope as n, readSettingsContext as o, requireSetting as r, readSettingsPayload as s, mutateSetting as t };

package/dist/trigger-DzJu208Q.mjs

@@ -1,2 +0,0 @@
-import { t as triggerMaintenance } from "./trigger-KVaWWNyn.mjs";
-export { triggerMaintenance };

package/dist/web-BFLueSh-.mjs

@@ -1,2 +0,0 @@
-import { n as webCommand, t as runWeb } from "./web-Bihbf7-u.mjs";
-export { webCommand as default, runWeb };

package/dist/worktree-Bm4cb-nU.mjs

@@ -1,2 +0,0 @@
-import { _ as worktreeCommand, a as matchWorktreeEntry, c as reclaimKeys, d as removalBlockers, f as removalPath, g as warmedWorkspace, h as warmWorktreeTarget, i as excludeWatchmanCookies, l as registerRemove, m as removeWorktreeTarget, n as dependencyInstallCommand, o as nestedWorktrees, p as removalRemedy, r as excludePodChurn, s as porcelainPath, t as customIosDirs, u as registerWarm } from "./worktree-BKuklFh_.mjs";
-export { customIosDirs, worktreeCommand as default, dependencyInstallCommand, excludePodChurn, excludeWatchmanCookies, matchWorktreeEntry, nestedWorktrees, porcelainPath, reclaimKeys, registerRemove, registerWarm, removalBlockers, removalPath, removalRemedy, removeWorktreeTarget, warmWorktreeTarget, warmedWorkspace };