stim 1.26.0 → 1.28.0

package/dist/{settings-CosW5X-S.mjs → settings-CY5JZlNN.mjs}

@@ -1,15 +1,16 @@
-import { c as throwIfCancelled, l as WorkspaceProcessCleanupError, n as isTimeoutError, t as getExecutor } from "./exec-VFRpu1iA.mjs";
-import { _ as loadConfig$1, d as getConfigDir, f as getConfigPath$1, h as getRepoSettings, m as getProjectSettings } from "./config-BktkY_zC.mjs";
-import { c as gitQuiet, l as gitQuietAsync, n as runOperationFileQuiet, o as git, r as childEnvironment, s as gitAsync, t as runOperationFile } from "./operation-exec-CUZifp6Z.mjs";
-import { accessSync, chmodSync, constants, lstatSync, mkdirSync, mkdtempSync, readdirSync, realpathSync, rmSync, statSync } from "node:fs";
+import { D as ownership_claim_exports, c as throwIfCancelled, l as WorkspaceProcessCleanupError, n as isTimeoutError, t as getExecutor } from "./exec-aULwtNly.mjs";
+import { _ as loadConfig$1, d as getConfigDir, f as getConfigPath$1, h as getRepoSettings, m as getProjectSettings } from "./config-Cn94Jc0g.mjs";
+import { c as gitQuiet, l as gitQuietAsync, n as runOperationFileQuiet, o as git, r as childEnvironment, s as gitAsync, t as runOperationFile } from "./operation-exec-Dp4FuIGR.mjs";
+import { accessSync, chmodSync, constants, existsSync, lstatSync, mkdirSync, mkdtempSync, readdirSync, realpathSync, rmSync, statSync } from "node:fs";
 import { tmpdir } from "node:os";
 import { basename, dirname, isAbsolute, join, relative, resolve, sep } from "node:path";
 import { ambientEnv, buildCacheRoot, compiledHelper, configDir } from "@stim-cli/core";
-import { REMOTE_DEVICE_BACKENDS, SETTINGS, SETTING_GROUPS, TUNNEL_MODES, WEB_VIEWPORTS, acceptsShape, coerceSettingText, expectedShape, isLayeredSetting, settingDefinition, settingValueError } from "@stim-cli/core/state";
+import { REMOTE_DEVICE_BACKENDS, REPLACED_SETTINGS, SETTINGS, SETTING_GROUPS, TUNNEL_MODES, WEB_VIEWPORTS, acceptsShape, coerceSettingText, expectedShape, isLayeredSetting, isPathPrefix, placementWord, replacementAdvice, settingDefinition, settingValueError, trashRoot } from "@stim-cli/core/state";
 import { basename as basename$1, dirname as dirname$1, isAbsolute as isAbsolute$1, join as join$1, normalize, relative as relative$1, resolve as resolve$1, sep as sep$1 } from "path";
 import { fileURLToPath } from "node:url";
+import { captureProcessIdentity } from "@stim-cli/core/process-identity";
 import { existsSync as existsSync$1, lstatSync as lstatSync$1, readFileSync as readFileSync$1, readdirSync as readdirSync$1, realpathSync as realpathSync$1, statSync as statSync$1 } from "fs";
-import { chmod, lstat, mkdir, readdir, realpath, rm, utimes } from "node:fs/promises";
+import { chmod, lstat, mkdir, mkdtemp, readdir, realpath, rename, rm, rmdir, utimes, writeFile } from "node:fs/promises";
 //#region src/temporary.ts
 function existingPath(path) {
 	const missing = [];
@@ -108,6 +109,248 @@ async function removeTemporaryEntryAsync(path, signal) {
 	signal?.throwIfAborted();
 }
 //#endregion
+//#region src/workspace/worktree-trash.ts
+const TRASH_MANIFEST = "trash.json";
+const TRASH_ENTRY_PREFIX = "remove-";
+const TRASH_ENTRIES = "entries";
+const TRASH_CLAIMS = "claims";
+const LIST_TIMEOUT_MS = 3e4;
+const DELETE_NICENESS = "10";
+function rethrowCancellation(error, signal) {
+	if (error instanceof WorkspaceProcessCleanupError || error instanceof Error && "reportCleanup" in error) throw error;
+	signal?.throwIfAborted();
+}
+async function isPlainDirectory(path) {
+	const stat = await lstat(path).catch(() => null);
+	return Boolean(stat?.isDirectory());
+}
+async function ignoredDirectories(worktree, options) {
+	const out = await gitAsync(worktree, [
+		"ls-files",
+		"--others",
+		"--ignored",
+		"--exclude-standard",
+		"--directory",
+		"--no-empty-directory",
+		"-z"
+	], {
+		...options.env ? childEnvironment(options.env) : {},
+		signal: options.signal,
+		declareFor: options.declareFor,
+		timeoutMs: LIST_TIMEOUT_MS,
+		untrimmed: true
+	});
+	const found = [];
+	for (const entry of out.split("\0")) {
+		if (!entry.endsWith("/")) continue;
+		const rel = entry.slice(0, -1);
+		const parts = rel.split("/");
+		let plain = true;
+		for (let depth = 1; depth <= parts.length && plain; depth++) plain = await isPlainDirectory(join(worktree, ...parts.slice(0, depth)));
+		if (plain) found.push(rel);
+	}
+	return found;
+}
+async function openTrash(worktree, options, kind) {
+	if ((options.platform ?? process.platform) === "win32") return null;
+	const root = trashRoot();
+	let dir = null;
+	let claim = null;
+	try {
+		await mkdir(root, { recursive: true });
+		if (filesystemDevice(root) !== filesystemDevice(worktree)) return null;
+		dir = await mkdtemp(join(root, TRASH_ENTRY_PREFIX));
+		claim = (0, ownership_claim_exports.tryAcquireClaim)({
+			root: join(dir, "claims"),
+			mode: "exclusive",
+			label: "worktree trash"
+		}).acquired ?? null;
+		if (!claim) throw new Error("the trash entry claim was not acquired");
+		const manifest = {
+			worktree,
+			createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+			...kind ? { kind } : {}
+		};
+		await writeFile(join(dir, TRASH_MANIFEST), `${JSON.stringify(manifest)}\n`);
+		await mkdir(join(dir, TRASH_ENTRIES));
+	} catch (error) {
+		if (claim) (0, ownership_claim_exports.releaseClaim)(claim);
+		if (dir) await rm(dir, {
+			recursive: true,
+			force: true
+		}).catch(() => {});
+		rethrowCancellation(error, options.signal);
+		return null;
+	}
+	return {
+		dir,
+		worktree,
+		moved: [],
+		claim
+	};
+}
+/**
+* Moves the worktree's ignored directories, which `git worktree remove` would delete, into a new entry under
+* `$STIM_HOME/trash` held by an exclusive ownership claim. Null, with nothing moved, when the trash is on another
+* filesystem, the platform is Windows, git cannot list the entries, or the claim cannot be taken. A directory that
+* does not rename stays in the worktree for git to delete.
+*/
+async function moveIgnoredTreesToTrash(worktree, options = {}) {
+	if ((options.platform ?? process.platform) === "win32") return null;
+	let listed;
+	try {
+		listed = await ignoredDirectories(worktree, options);
+	} catch (error) {
+		rethrowCancellation(error, options.signal);
+		return null;
+	}
+	if (!listed.length) return null;
+	const trash = await openTrash(worktree, options);
+	if (!trash) return null;
+	for (const from of listed) {
+		const to = String(trash.moved.length);
+		try {
+			await rename(join(worktree, from), join(trash.dir, TRASH_ENTRIES, to));
+			trash.moved.push({
+				from,
+				to
+			});
+		} catch {}
+	}
+	if (trash.moved.length) return trash;
+	await discardTrash(trash);
+	return null;
+}
+/**
+* A trash entry that takes directories out of a live worktree while it warms, so the delete runs in the background.
+* `take` is false, with the directory untouched, when the entry cannot be opened or the rename fails; the caller
+* deletes it in place. gc deletes a crashed entry whatever the state of the worktree.
+*/
+function warmTrash(worktree, options = {}) {
+	let trash;
+	return {
+		async take(path) {
+			if (trash === void 0) trash = await openTrash(worktree, options, "warm");
+			if (!trash) return false;
+			const to = String(trash.moved.length);
+			try {
+				await rename(path, join(trash.dir, TRASH_ENTRIES, to));
+			} catch {
+				return false;
+			}
+			trash.moved.push({
+				from: path,
+				to
+			});
+			return true;
+		},
+		async dispose(operation) {
+			if (!trash) return;
+			if (trash.moved.length) await disposeTrash(trash, operation);
+			else await discardTrash(trash);
+		}
+	};
+}
+async function discardTrash(trash) {
+	await rmdir(join(trash.dir, TRASH_ENTRIES)).catch(() => {});
+	await rm(join(trash.dir, TRASH_MANIFEST), { force: true }).catch(() => {});
+	(0, ownership_claim_exports.releaseClaim)(trash.claim);
+	await rmdir(trash.dir).catch(() => {});
+}
+/** Moves every tree back into the worktree. Returns the relative paths that stay in the trash for gc. */
+async function restoreTrashedTrees(trash) {
+	const kept = [];
+	for (const entry of trash.moved.toReversed()) {
+		const target = join(trash.worktree, entry.from);
+		try {
+			if (await lstat(target).catch(() => null) || !await isPlainDirectory(dirname(target))) {
+				kept.push(entry.from);
+				continue;
+			}
+			await rename(join(trash.dir, TRASH_ENTRIES, entry.to), target);
+		} catch {
+			kept.push(entry.from);
+		}
+	}
+	if (kept.length) (0, ownership_claim_exports.releaseClaim)(trash.claim);
+	else await discardTrash(trash);
+	return kept;
+}
+/** Deletes one trash entry: `rm -rf` for the bulk, then a walk that also clears read-only directories. */
+async function deleteTrashEntry(dir, operation) {
+	if (process.platform !== "win32") try {
+		await runOperationFile(operation, getExecutor(), "rm", [
+			"-rf",
+			"--",
+			join(dir, TRASH_ENTRIES)
+		], {
+			timeoutMs: "unbounded",
+			signal: operation?.signal,
+			cwd: dirname(dir)
+		});
+	} catch (error) {
+		rethrowCancellation(error, operation?.signal);
+	}
+	await removeTemporaryEntryAsync(dir, operation?.signal);
+}
+function deleteInBackground(trash) {
+	try {
+		(0, ownership_claim_exports.markClaimChildPending)(trash.claim);
+		const child = getExecutor().spawn("nice", [
+			"-n",
+			DELETE_NICENESS,
+			"sh",
+			"-c",
+			"rm -rf -- \"$1\" && rm -rf -- \"$2\"",
+			"--",
+			join(trash.dir, TRASH_ENTRIES),
+			trash.dir
+		], {
+			cwd: dirname(trash.dir),
+			detached: true,
+			stdio: "ignore"
+		});
+		child.on?.("error", () => {});
+		child.unref?.();
+		const captured = child.pid === void 0 ? null : captureProcessIdentity(child.pid);
+		if (captured?.ok === false && captured.reason.startsWith("NOT_FOUND")) {
+			(0, ownership_claim_exports.clearClaimChild)(trash.claim);
+			(0, ownership_claim_exports.releaseClaim)(trash.claim);
+			return existsSync(trash.dir) ? "left" : "deleted";
+		}
+		if (!captured?.ok || child.pid === void 0) throw new Error("the trash deletion process was not recorded");
+		(0, ownership_claim_exports.setClaimChild)(trash.claim, {
+			pid: child.pid,
+			processToken: captured.token
+		});
+		return "background";
+	} catch {
+		try {
+			(0, ownership_claim_exports.clearClaimChild)(trash.claim);
+		} catch {}
+		(0, ownership_claim_exports.releaseClaim)(trash.claim);
+		return "left";
+	}
+}
+/**
+* Deletes the trash entry once its trees are out of the way. A CLI command starts a detached, low-priority `rm` recorded
+* as the claim's child, so gc reports the entry as in use until `rm` exits. Inside a bounded report, such as the
+* programmatic API, every child is stopped when the report settles, so the entry is deleted before returning.
+* `left` means the entry waits for gc with its claim released.
+*/
+async function disposeTrash(trash, operation) {
+	if (!getExecutor().reportSignal?.()) return deleteInBackground(trash);
+	try {
+		await deleteTrashEntry(trash.dir, operation);
+		return "deleted";
+	} catch (error) {
+		rethrowCancellation(error, operation?.signal);
+		return "left";
+	} finally {
+		(0, ownership_claim_exports.releaseClaim)(trash.claim);
+	}
+}
+//#endregion
 //#region src/clonefile.ts
 const SOURCE = "stim-clonefile.c";
 const COMPILE_TIMEOUT_MS = 12e4;
@@ -397,7 +640,7 @@ function knownCopiedPaths(rel) {
 function isMissingError(error) {
 	return error instanceof Error && "code" in error && (error.code === "ENOENT" || error.code === "ENOTDIR");
 }
-async function removeCopiedPath(root, rel, signal) {
+async function removeCopiedPath(root, rel, signal, trash) {
 	signal.throwIfAborted();
 	const path = join$1(root, rel);
 	let parent;
@@ -411,21 +654,22 @@ async function removeCopiedPath(root, rel, signal) {
 	if (inside === ".." || inside.startsWith(`..${sep$1}`) || isAbsolute$1(inside)) return;
 	const stat = await lstat(parent);
 	const target = join$1(parent, basename$1(path));
+	let targetStat;
 	try {
-		await lstat(target);
+		targetStat = await lstat(target);
 	} catch (error) {
 		if (isMissingError(error)) return;
 		throw error;
 	}
 	await chmod(parent, stat.mode | 448);
 	try {
-		await removeTemporaryEntryAsync(target, signal);
+		if (!(targetStat.isDirectory() && await trash.take(target))) await removeTemporaryEntryAsync(target, signal);
 	} finally {
 		await utimes(parent, stat.atime, stat.mtime);
 		await chmod(parent, stat.mode);
 	}
 }
-async function removeKnownCopiedPaths(path, rel, signal) {
+async function removeKnownCopiedPaths(path, rel, signal, trash) {
 	const paths = knownCopiedPaths(rel);
 	if (basename$1(rel) === "node_modules") {
 		const virtualStore = await readdir(join$1(path, ".pnpm")).catch((error) => {
@@ -435,7 +679,7 @@ async function removeKnownCopiedPaths(path, rel, signal) {
 		for (const name of virtualStore) if (name.startsWith("expo-modules-jsi@")) paths.push(`.pnpm/${name}/node_modules/expo-modules-jsi/apple/.DerivedData`);
 	}
 	const root = await realpath(path);
-	for (const known of paths) await removeCopiedPath(root, known, signal);
+	for (const known of paths) await removeCopiedPath(root, known, signal, trash);
 }
 async function cloneIgnoredEntries({ root, target, patterns, operation }) {
 	const options = {
@@ -460,58 +704,65 @@ async function cloneIgnoredEntries({ root, target, patterns, operation }) {
 	let cloned = true;
 	let helper;
 	const clonefile = () => helper ??= clonefileHelper(operation);
-	for (const rel of entries) {
-		operation.signal.throwIfAborted();
-		const from = join$1(root, rel);
-		const to = join$1(target, rel);
-		let copying = false;
-		try {
-			const reason = guard.covers(rel) ? "tracked" : overlapsNestedWorktree(rel, nested) ? "nested worktree" : missingDestinationReason(target, rel);
-			if (reason) {
-				skipped.push({
-					file: rel,
-					reason
-				});
-				continue;
-			}
-			await mkdir(dirname$1(to), { recursive: true });
-			copying = true;
-			const copiedWith = async (file, args) => {
-				try {
-					await getExecutor().runFileAsync(file, args, options);
-					return true;
-				} catch (cause) {
-					if (cause instanceof WorkspaceProcessCleanupError || cause instanceof Error && "reportCleanup" in cause) throw cause;
-					operation.signal.throwIfAborted();
-					await removeTemporaryEntryAsync(to);
-					return false;
+	const trash = warmTrash(target, { signal: operation.signal });
+	try {
+		for (const rel of entries) {
+			operation.signal.throwIfAborted();
+			const from = join$1(root, rel);
+			const to = join$1(target, rel);
+			let copying = false;
+			try {
+				const reason = guard.covers(rel) ? "tracked" : overlapsNestedWorktree(rel, nested) ? "nested worktree" : missingDestinationReason(target, rel);
+				if (reason) {
+					skipped.push({
+						file: rel,
+						reason
+					});
+					continue;
 				}
-			};
-			const directoryClone = (await lstat(from)).isDirectory() ? await clonefile() : null;
-			if (!(directoryClone && await copiedWith(directoryClone, [from, to])) && !await copiedWith("cp", [
-				"-Rc",
-				from,
-				to
-			])) {
-				await getExecutor().runFileAsync("cp", [
-					"-R",
+				await mkdir(dirname$1(to), { recursive: true });
+				copying = true;
+				const copiedWith = async (file, args) => {
+					try {
+						await getExecutor().runFileAsync(file, args, options);
+						return true;
+					} catch (cause) {
+						if (cause instanceof WorkspaceProcessCleanupError || cause instanceof Error && "reportCleanup" in cause) throw cause;
+						operation.signal.throwIfAborted();
+						await removeTemporaryEntryAsync(to);
+						return false;
+					}
+				};
+				const directoryClone = (await lstat(from)).isDirectory() ? await clonefile() : null;
+				if (!(directoryClone && await copiedWith(directoryClone, [from, to])) && !await copiedWith("cp", [
+					"-Rc",
 					from,
 					to
-				], options);
-				cloned = false;
+				])) {
+					await getExecutor().runFileAsync("cp", [
+						"-R",
+						from,
+						to
+					], options);
+					cloned = false;
+				}
+				if ((await lstat(to)).isDirectory()) await removeKnownCopiedPaths(to, rel, operation.signal, trash);
+				copied.push(rel);
+			} catch (cause) {
+				if (cause instanceof WorkspaceProcessCleanupError || cause instanceof Error && "reportCleanup" in cause) throw cause;
+				if (copying) await removeTemporaryEntryAsync(to);
+				operation.signal.throwIfAborted();
+				failed.push({
+					file: rel,
+					error: String(cause?.message || cause)
+				});
 			}
-			if ((await lstat(to)).isDirectory()) await removeKnownCopiedPaths(to, rel, operation.signal);
-			copied.push(rel);
-		} catch (cause) {
-			if (cause instanceof WorkspaceProcessCleanupError || cause instanceof Error && "reportCleanup" in cause) throw cause;
-			if (copying) await removeTemporaryEntryAsync(to);
-			operation.signal.throwIfAborted();
-			failed.push({
-				file: rel,
-				error: String(cause?.message || cause)
-			});
 		}
+	} catch (error) {
+		await trash.dispose(operation).catch(() => {});
+		throw error;
 	}
+	await trash.dispose(operation);
 	return {
 		copied,
 		skipped,
@@ -811,6 +1062,32 @@ async function deleteBranchAsync(cwd, branch, expectedSha, options = {}) {
 		write: true
 	});
 }
+function nativeCanonicalPath(path) {
+	const missing = [];
+	for (let existing = resolve$1(path);; existing = dirname$1(existing)) try {
+		return resolve$1(realpathSync$1.native(existing), ...missing);
+	} catch {
+		if (dirname$1(existing) === existing) return resolve$1(path);
+		missing.unshift(basename$1(existing));
+	}
+}
+function matchWorktreeEntry(entries, path) {
+	let best = null;
+	const target = nativeCanonicalPath(path);
+	(entries || []).forEach((entry, index) => {
+		if (!entry?.path || !isPathPrefix(nativeCanonicalPath(entry.path), target)) return;
+		if (!best || entry.path.length > best.path.length) best = {
+			...entry,
+			index
+		};
+	});
+	return best;
+}
+const LOCKED_REASON = "locked with git worktree lock";
+const LOCK_UNKNOWN_REASON = "git could not tell whether its worktree is locked";
+function lockReason(lock) {
+	return lock === "locked" ? LOCKED_REASON : LOCK_UNKNOWN_REASON;
+}
 function parseWorktrees(out) {
 	const entries = [];
 	let current = {};
@@ -856,6 +1133,24 @@ async function listWorktreesAsync(cwd, options = {}) {
 	], options);
 	return out ? parseWorktrees(out) : [];
 }
+function insideGitCheckout(root) {
+	for (let dir = resolve$1(root);; dir = dirname$1(dir)) {
+		if (existsSync$1(join$1(dir, ".git"))) return true;
+		if (dirname$1(dir) === dir) return false;
+	}
+}
+function lockOf(entries, root) {
+	const entry = matchWorktreeEntry(entries, root);
+	if (entry) return entry.locked ? "locked" : null;
+	return existsSync$1(root) && insideGitCheckout(root) ? "unknown" : null;
+}
+/** Null when `root` is not in a locked worktree; 'unknown' when git lists nothing for a path inside a git checkout. */
+function worktreeLock(root) {
+	return lockOf(listWorktrees(root), root);
+}
+async function worktreeLockAsync(root, options = {}) {
+	return lockOf(await listWorktreesAsync(root, options), root);
+}
 function branchOf(head) {
 	return head.startsWith("ref: refs/heads/") ? head.slice(16) : void 0;
 }
@@ -1043,7 +1338,7 @@ function settingShapeErrors(settings) {
 		if (SETTINGS_WITH_RESOLVE_TIME_FALLBACK.has(setting.key)) continue;
 		const value = settingValueAt(settings, setting.key);
 		if (value === void 0) continue;
-		const expected = setting.key === "ios.remote" || setting.key === "android.remote" || setting.key === "android.deviceProfile" || setting.type.kind === "number" && !BOUNDS_CHECKED_WHEN_USED.has(setting.key) ? settingValueError(setting, value) : acceptsShape(setting, value) ? null : expectedShape(setting.type);
+		const expected = setting.key === "ios.remote" || setting.key === "android.remote" || setting.key === "macos.remote" || setting.key === "android.deviceProfile" || setting.type.kind === "number" && !BOUNDS_CHECKED_WHEN_USED.has(setting.key) ? settingValueError(setting, value) : acceptsShape(setting, value) ? null : expectedShape(setting.type);
 		if (expected) errors.push(`Invalid ${setting.key} setting ${JSON.stringify(value)}. Expected ${expected}.`);
 	}
 	return errors;
@@ -1440,6 +1735,10 @@ function unknownSettingKeys(settings, prefix = "") {
 	}
 	return unknown;
 }
+function inertSettingWarning(settings, key) {
+	const advice = replacementAdvice(key, settingValueAt(settings, key));
+	return `Warning: setting "${key}" is not read by Stim and will be ignored.${advice ? advice.command ? ` Run \`${advice.command}\` instead.` : ` Use ${advice.key} instead.` : ""}`;
+}
 function readCommittedSettings(directory) {
 	if (!directory) return {};
 	const p = join$1(directory, ".stim.json");
@@ -1462,8 +1761,16 @@ function setSettingValueAt(settings, path, value) {
 	node[segments[segments.length - 1]] = value;
 }
 const MACHINE_READABLE_SETTINGS = SETTINGS.filter((setting) => isLayeredSetting(setting) && setting.scopes.includes("machine") && !setting.key.startsWith("optimizations."));
-function machineLayerSettings(machine) {
+function removedMachineSettings(machine) {
 	const settings = {};
+	for (const key of Object.keys(REPLACED_SETTINGS)) {
+		const value = settingValueAt(machine, key);
+		if (value !== void 0) setSettingValueAt(settings, key, value);
+	}
+	return settings;
+}
+function machineLayerSettings(machine) {
+	const settings = removedMachineSettings(machine);
 	const optimizations = settingValueAt(machine, "optimizations");
 	if (optimizations !== void 0) settings.optimizations = optimizations;
 	for (const setting of MACHINE_READABLE_SETTINGS) {
@@ -1635,13 +1942,19 @@ function cacheProviderSettingError(settings) {
 function parseIosRemote(remote) {
 	const selected = remote.trim();
 	const reserved = selected.toLowerCase();
-	if (reserved === "local") return null;
+	const word = placementWord(selected);
+	if (word === "local") return null;
+	if (word) return {
+		kind: "machine",
+		machine: "auto",
+		placement: word
+	};
 	return REMOTE_DEVICE_BACKENDS.includes(reserved) ? {
 		kind: "backend",
 		backend: reserved
 	} : {
 		kind: "machine",
-		machine: reserved === "auto" ? "auto" : selected
+		machine: selected
 	};
 }
 function remoteIosSetting(settings) {
@@ -1742,4 +2055,4 @@ function webSettings(settings) {
 	};
 }
 //#endregion
-export { settingOrigin as $, metroCommandSettingError as A, podsOutOfSync as At, readCommittedSettings as B, unpushedCommitsAsync as Bt, iosSigningIdentitySha1Setting as C, hasUncommittedWorkAsync as Ct, maintenanceKeepSetting as D, listWorktreesAsync as Dt, iosSimSlimProfileSetting as E, listWorktrees as Et, ngrokUrlSetting as F, resolveFullRef as Ft, resolveAndroidLayout as G, removeTemporaryEntryAsync as Gt, remoteAndroidSetting as H, filesystemDevice as Ht, parseIosRemote as I, resolveFullRefAsync as It, resolveProjectSettings as J, resolveCacheProviderConfig as K, temporaryRoot as Kt, projectSettingsContext as L, resolveSourceCheckoutAsync as Lt, metroPortSetting as M, removeWorktreeAsync as Mt, metroTunnelSettingError as N, repoRoot as Nt, mergeSettingsLayers as O, locallyKnownUpstream as Ot, metroWarmupUrlSetting as P, repoRootAsync as Pt, settingFile as Q, projectSettingsContextAsync as R, restoreFileAsync as Rt, iosSigningIdentitySettingError as S, hasRemoteAsync as St, iosSimSlimDefaultSetting as T, linkedWorktreesOnDisk as Tt, remoteEasFallbackSetting as U, makeTemporaryDirectory as Ut, realpathInside as V, warmWorktreePaths as Vt, remoteIosSetting as W, removeTemporaryEntry as Wt, resolveSettings as X, resolveProjectSettingsAsync as Y, runnableMetroCommand as Z, iosLanHostSetting as _, dirtyPathsAsync as _t, SETTING_SHAPE_REMEDY as a, unknownSettingKeys as at, iosProjectDirSettingError as b, gitCommonDirOnDisk as bt, androidDataPartitionSizeBytes as c, PUBLIC_METRO_ENV as ct, androidLayoutSetting as d, resolveTailscaleBinary as dt, settingOriginScope as et, androidLayoutSettingError as f, branchExistsAsync as ft, deviceReclaimIdleMinutesSetting as g, dirtyFingerprintFiles as gt, deviceIdleShutdownMinutesSetting as h, depsOutOfSync as ht, SETTINGS_WITH_RESOLVE_TIME_FALLBACK as i, tunnelModeSetting as it, metroIdleStopMinutesSetting as j, readWorktreeExclude as jt, metroCommandSetting as k, locallyKnownUpstreamAsync as kt, androidDataPartitionSizeGbSetting as l, detectProviders as lt, defaultAndroidLayout as m, deleteBranchAsync as mt, METRO_COMMAND_PORT as n, settingValueAt as nt, androidAvdConfigSetting as o, webSettings as ot, cacheProviderSettingError as p, cloneIgnoredEntries as pt, resolveIosProjectDir as q, PATH_SETTINGS as r, settingsLayers as rt, androidAvdConfigSettingError as s, workspaceHiddenSetting as st, ANDROID_AVD_CONFIG_HELP as t, settingShapeErrors as tt, androidDataPartitionSizeGbSettingError as u, planMetroReach as ut, iosLanHostSettingError as v, gitCommonDir as vt, iosSigningIdentitySha1SettingError as w, isPodInstallChurn as wt, iosSigningIdentitySetting as x, hasPopulatedSubmodulesAsync as xt, iosProjectDirSetting as y, gitCommonDirAsync as yt, publicUrlSetting as z, sourceCheckoutOf as zt };
+export { runnableMetroCommand as $, TRASH_MANIFEST as $t, metroCommandSetting as A, listWorktrees as At, publicUrlSetting as B, repoRoot as Bt, iosSigningIdentitySettingError as C, gitCommonDirOnDisk as Ct, iosSimSlimProfileSetting as D, isPodInstallChurn as Dt, iosSimSlimDefaultSetting as E, hasUncommittedWorkAsync as Et, metroWarmupUrlSetting as F, matchWorktreeEntry as Ft, remoteIosSetting as G, restoreFileAsync as Gt, realpathInside as H, resolveFullRef as Ht, ngrokUrlSetting as I, nativeCanonicalPath as It, resolveCacheProviderConfig as J, warmWorktreePaths as Jt, removedMachineSettings as K, sourceCheckoutOf as Kt, parseIosRemote as L, podsOutOfSync as Lt, metroIdleStopMinutesSetting as M, locallyKnownUpstream as Mt, metroPortSetting as N, locallyKnownUpstreamAsync as Nt, maintenanceKeepSetting as O, linkedWorktreesOnDisk as Ot, metroTunnelSettingError as P, lockReason as Pt, resolveSettings as Q, TRASH_ENTRY_PREFIX as Qt, projectSettingsContext as R, readWorktreeExclude as Rt, iosSigningIdentitySetting as S, gitCommonDirAsync as St, iosSigningIdentitySha1SettingError as T, hasRemoteAsync as Tt, remoteAndroidSetting as U, resolveFullRefAsync as Ut, readCommittedSettings as V, repoRootAsync as Vt, remoteEasFallbackSetting as W, resolveSourceCheckoutAsync as Wt, resolveProjectSettings as X, worktreeLockAsync as Xt, resolveIosProjectDir as Y, worktreeLock as Yt, resolveProjectSettingsAsync as Z, TRASH_CLAIMS as Zt, inertSettingWarning as _, deleteBranchAsync as _t, SETTING_SHAPE_REMEDY as a, makeTemporaryDirectory as an, settingsLayers as at, iosProjectDirSetting as b, dirtyPathsAsync as bt, androidDataPartitionSizeBytes as c, temporaryRoot as cn, webSettings as ct, androidLayoutSetting as d, detectProviders as dt, deleteTrashEntry as en, settingFile as et, androidLayoutSettingError as f, planMetroReach as ft, deviceReclaimIdleMinutesSetting as g, cloneIgnoredEntries as gt, deviceIdleShutdownMinutesSetting as h, branchExistsAsync as ht, SETTINGS_WITH_RESOLVE_TIME_FALLBACK as i, filesystemDevice as in, settingValueAt as it, metroCommandSettingError as j, listWorktreesAsync as jt, mergeSettingsLayers as k, listCarryableIgnoredEntries as kt, androidDataPartitionSizeGbSetting as l, workspaceHiddenSetting as lt, defaultAndroidLayout as m, LOCKED_REASON as mt, METRO_COMMAND_PORT as n, moveIgnoredTreesToTrash as nn, settingOriginScope as nt, androidAvdConfigSetting as o, removeTemporaryEntry as on, tunnelModeSetting as ot, cacheProviderSettingError as p, resolveTailscaleBinary as pt, resolveAndroidLayout as q, unpushedCommitsAsync as qt, PATH_SETTINGS as r, restoreTrashedTrees as rn, settingShapeErrors as rt, androidAvdConfigSettingError as s, removeTemporaryEntryAsync as sn, unknownSettingKeys as st, ANDROID_AVD_CONFIG_HELP as t, disposeTrash as tn, settingOrigin as tt, androidDataPartitionSizeGbSettingError as u, PUBLIC_METRO_ENV as ut, iosLanHostSetting as v, depsOutOfSync as vt, iosSigningIdentitySha1Setting as w, hasPopulatedSubmodulesAsync as wt, iosProjectDirSettingError as x, gitCommonDir as xt, iosLanHostSettingError as y, dirtyFingerprintFiles as yt, projectSettingsContextAsync as z, removeWorktreeAsync as zt };

package/dist/{settings-OaGQF-ri.mjs → settings-Cfd_Q6ys.mjs}

@@ -1,5 +1,6 @@
-import { a as layerFile, c as settingEntry, i as SettingsRefusal, n as readScope, o as readSettingsContext, r as requireSetting, s as readSettingsPayload, t as mutateSetting } from "./settings-write-QjYfSrjF.mjs";
-import { SETTING_SCOPES } from "@stim-cli/core/state";
+import { c as readSettingsPayload, l as settingEntry, o as layerFile, s as readSettingsContext, t as SettingsRefusal } from "./settings-payload-DwQiEMCn.mjs";
+import { i as unsetReplacedSetting, n as readScope, r as requireSetting, t as mutateSetting } from "./settings-write-CJpjkeAd.mjs";
+import { REPLACED_SETTINGS, SETTING_SCOPES } from "@stim-cli/core/state";
 import chalk from "chalk";
 //#region src/commands/settings.ts
 function formatValue(value) {
@@ -45,7 +46,7 @@ function registerSettings(program, io = CONSOLE, env = process.env) {
 			const shown = entry.origin === null ? "" : formatValue(entry.value);
 			io.out(`${entry.key.padEnd(width)}  ${shown}${shown ? "  " : ""}${chalk.dim(`(${formatOrigin(entry)})`)}`);
 		}
-		for (const entry of payload.unknown) io.note(chalk.yellow(`Warning: ${entry.key} in ${entry.file} is not read by Stim.`));
+		for (const entry of payload.unknown) io.note(chalk.yellow(`Warning: ${entry.key} in ${entry.file} is not read by Stim.${entry.replacement ? ` Run \`${entry.replacement}\` instead.` : ""}`));
 	}));
 	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, async () => {
 		const setting = requireSetting(key);
@@ -80,6 +81,18 @@ function registerSettings(program, io = CONSOLE, env = process.env) {
 		report(io, wantsJson(opts, command), result, "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, async () => {
+		if (Object.hasOwn(REPLACED_SETTINGS, key)) {
+			const removal = await unsetReplacedSetting({
+				key,
+				scope: opts.scope
+			}, {
+				cwd: process.cwd(),
+				env,
+				note: io.note
+			});
+			reportRemoval(io, wantsJson(opts, command), removal, opts.scope);
+			return;
+		}
 		const result = await mutateSetting({
 			action: "unset",
 			key,
@@ -92,6 +105,14 @@ function registerSettings(program, io = CONSOLE, env = process.env) {
 		report(io, wantsJson(opts, command), result, "unset");
 	}));
 }
+function reportRemoval(io, json, removal, scope) {
+	if (json) {
+		io.out(JSON.stringify(removal));
+		return;
+	}
+	for (const { file } of removal.removed) io.out(`unset ${removal.key} in ${file}`);
+	if (removal.removed.length === 0) io.out(`${removal.key} was not set in ${scope ? `the ${scope} layer` : "any layer"}.`);
+}
 function report(io, json, result, verb) {
 	const { setting: entry, recordingsDeleted, ...write } = result;
 	if (json) {