stim 1.17.2 → 1.18.0

package/dist/{toolchain-DNyR3NPq.mjs → toolchain-Bnyd_K3A.mjs}

@@ -1,20 +1,23 @@
-import { t as getExecutor } from "./exec-CaErVv7t.mjs";
-import { r as register } from "./cache-manifest-DnUHBJaU.mjs";
-import { t as createLineReader } from "./process-output-Fpl8PYi8.mjs";
-import { a as formatElapsed, l as phaseLine } from "./command-output-CDAIFD-8.mjs";
-import { Z as resolveOptimizations } from "./settings-Cfd-0r2d.mjs";
-import { m as resolvePackageJson } from "./project-D47Rh0ly.mjs";
-import { _ as workspaceDerivedData, f as sharedCcache$1, p as sharedCompilationCache$1, x as workspaceLogsDir$1 } from "./workspace-state-DqcCbpE7.mjs";
-import { a as spawnDeclared } from "./spawn-claims-D0XfSe8u.mjs";
-import { o as androidHome } from "./android-B_YNZy61.mjs";
-import { t as cleanLine } from "./server-expo-CHTyXD0G.mjs";
+import { t as getExecutor } from "./exec-DWhCZDGm.mjs";
+import { n as stripAnsi, r as waitForChild, t as createLineReader } from "./process-output-Fpl8PYi8.mjs";
+import { a as formatElapsed, l as phaseLine } from "./command-output-CBtzyIgF.mjs";
+import { _ as loadConfig$1 } from "./config-CgYMahz7.mjs";
+import { h as resolvePackageJson } from "./project-C3ChRLZy.mjs";
+import { _ as workspaceDerivedData, f as sharedCcache$1, p as sharedCompilationCache$1, x as workspaceLogsDir$1 } from "./workspace-state-C59dqG-Z.mjs";
+import { r as register } from "./cache-manifest-BI7ozfmH.mjs";
+import { o as machineNumber } from "./budget-DIhL2BKx.mjs";
+import { a as spawnDeclared } from "./spawn-claims-Kqiifsk2.mjs";
+import { o as androidHome } from "./android-DC3ZLuw0.mjs";
+import { Q as resolveOptimizations } from "./settings-CQyMElEP.mjs";
+import { t as cleanLine } from "./server-expo-DoBHhuzK.mjs";
 import { createRequire } from "node:module";
-import { createHash } from "node:crypto";
 import { existsSync, readFileSync, readdirSync, realpathSync, statSync } from "node:fs";
-import { basename, dirname, isAbsolute, join, relative, resolve, sep } from "node:path";
+import { basename, delimiter, dirname, isAbsolute, join, relative, resolve, sep } from "node:path";
 import { stimBuildDigest } from "@stim-cli/core/state";
 import { fileURLToPath } from "node:url";
+import { homedir } from "node:os";
 import chalk from "chalk";
+import { createHash } from "node:crypto";
 const CCACHE_SLOPPINESS = "pch_defines,time_macros";
 const STATS_LOG_FILE = "ccache-stats.log";
 const CCACHE_UNAVAILABLE = {
@@ -32,7 +35,11 @@ const CCACHE_NOT_RUN = {
 function ccacheStatsLog(root) {
 	return join(workspaceLogsDir$1(root), STATS_LOG_FILE);
 }
-function ccacheEnvironment({ binary, dir, workspaceRoot, statsLog }) {
+function ccacheMaxSize(config = loadConfig$1(), env = process.env) {
+	const { value, error } = machineNumber("caches.ccacheMaxGb", config, env);
+	return error || value === void 0 ? "5G" : `${value}G`;
+}
+function ccacheEnvironment({ binary, dir, workspaceRoot, statsLog, maxSize = "5G" }) {
 	return {
 		CMAKE_C_COMPILER_LAUNCHER: binary,
 		CMAKE_CXX_COMPILER_LAUNCHER: binary,
@@ -40,7 +47,7 @@ function ccacheEnvironment({ binary, dir, workspaceRoot, statsLog }) {
 		CCACHE_BASEDIR: workspaceRoot,
 		CCACHE_NOHASHDIR: "true",
 		CCACHE_SLOPPINESS,
-		CCACHE_MAXSIZE: "5G",
+		CCACHE_MAXSIZE: maxSize,
 		CCACHE_STATSLOG: statsLog
 	};
 }
@@ -95,7 +102,7 @@ function lookupCcache() {
 		return null;
 	}
 }
-function readOrNull(file) {
+function readOrNull$1(file) {
 	try {
 		return readFileSync(file, "utf-8");
 	} catch {
@@ -115,7 +122,7 @@ function resolveCcache({ root, dir = sharedCcache$1(), lookup = lookupCcache, on
 		onNote(chalk.dim(phaseLine("cache", "ccache off (not installed; brew install ccache)")));
 		return null;
 	}
-	const declared = projectCmakeLauncher(readOrNull(join(root, "android", "app", "build.gradle")));
+	const declared = projectCmakeLauncher(readOrNull$1(join(root, "android", "app", "build.gradle")));
 	if (declared) {
 		onNote(chalk.dim(phaseLine("cache", `ccache off (android/app/build.gradle sets ${declared} itself)`)));
 		return null;
@@ -135,7 +142,8 @@ function resolveCcache({ root, dir = sharedCcache$1(), lookup = lookupCcache, on
 			binary,
 			dir,
 			workspaceRoot: canonical(root),
-			statsLog
+			statsLog,
+			maxSize: ccacheMaxSize()
 		})
 	};
 }
@@ -1075,6 +1083,438 @@ async function buildIos({ root, udid = null, logWriter, project = null, scheme =
 	};
 }
 //#endregion
+//#region src/engine/deps.ts
+const DEPS_ERROR = "STIM_DEPS_FAILED";
+const TRANSCRIPT_LINES = 2e3;
+const MAX_POD_DIAGNOSTIC_LINES = 15;
+const POD_MARKER = /^\[!\]/;
+const POD_CONTINUATION = /^\s+\S/;
+const RUBY_HEAD = /^\S.*\.rb:\d+:in\s+(?:`[^']*'|'[^']*'):\s*\S/;
+const RUBY_FRAME = /^\s*from\s+\S/;
+const RUBY_CONTEXT_BEFORE = 4;
+const BUNDLER_FROZEN = /frozen mode|lockfile can't be updated|in deployment mode after changing/i;
+const BUNDLER_NO_COCOAPODS = /cocoapods is not currently included in the bundle|command not found: pod\b/i;
+function extractPodDiagnostics(transcript) {
+	if (typeof transcript !== "string" || transcript === "") return null;
+	const lines = transcript.split("\n").map((line) => line.replace(/\r$/, ""));
+	return extractPodBangBlocks(lines) || extractRubyHead(lines);
+}
+function extractPodBangBlocks(lines) {
+	const blocks = [];
+	for (let i = 0; i < lines.length; i += 1) {
+		const line = lines[i];
+		if (line === void 0 || !POD_MARKER.test(line)) continue;
+		const block = [line];
+		let j = i + 1;
+		for (; j < lines.length; j += 1) {
+			const next = lines[j];
+			if (next === void 0 || !POD_CONTINUATION.test(next)) break;
+			block.push(next);
+		}
+		blocks.push(block);
+		i = j - 1;
+	}
+	if (blocks.length === 0) return null;
+	const out = [];
+	let dropped = 0;
+	for (const block of blocks) {
+		const room = MAX_POD_DIAGNOSTIC_LINES - out.length;
+		if (room <= 0) {
+			dropped += block.length;
+			continue;
+		}
+		out.push(...block.slice(0, room));
+		dropped += Math.max(0, block.length - room);
+	}
+	if (dropped > 0) out.push(`(+${dropped} more [!] lines in the build log)`);
+	return {
+		source: "cocoapods",
+		lines: out
+	};
+}
+function extractRubyHead(lines) {
+	for (let i = 0; i < lines.length; i += 1) {
+		const line = lines[i];
+		if (line === void 0 || !RUBY_HEAD.test(line) || RUBY_FRAME.test(line)) continue;
+		let start = i;
+		while (start > 0 && i - start < RUBY_CONTEXT_BEFORE) {
+			const prev = lines[start - 1];
+			if (prev === void 0 || prev.trim() === "" || RUBY_FRAME.test(prev) || POD_MARKER.test(prev)) break;
+			start -= 1;
+		}
+		let end = i + 1;
+		while (end < lines.length) {
+			const next = lines[end];
+			if (next === void 0 || next.trim() === "" || RUBY_FRAME.test(next)) break;
+			end += 1;
+		}
+		return {
+			source: "ruby",
+			lines: lines.slice(start, end).filter((entry) => entry.trim() !== "").slice(0, MAX_POD_DIAGNOSTIC_LINES)
+		};
+	}
+	return null;
+}
+function podsAreStale(lockText, manifestText) {
+	const lock = normalize(lockText);
+	const manifest = normalize(manifestText);
+	if (lock === null && manifest === null) return {
+		noPods: true,
+		stale: false
+	};
+	if (lock === null) return {
+		stale: true,
+		reason: "ios/Podfile.lock is missing but ios/Pods exists"
+	};
+	if (manifest === null) return {
+		stale: true,
+		reason: "ios/Pods/Manifest.lock is missing (pods have never been installed here)"
+	};
+	if (lock !== manifest) return {
+		stale: true,
+		reason: "ios/Podfile.lock and ios/Pods/Manifest.lock differ"
+	};
+	return { stale: false };
+}
+function normalize(text) {
+	if (typeof text !== "string") return null;
+	return text.replace(/\r\n/g, "\n").trimEnd();
+}
+function podfilePath(root) {
+	return join(root, "ios", "Podfile");
+}
+function readPodState(root) {
+	return {
+		hasPodfile: existsSync(podfilePath(root)),
+		lockText: readOrNull(join(root, "ios", "Podfile.lock")),
+		manifestText: readOrNull(join(root, "ios", "Pods", "Manifest.lock"))
+	};
+}
+function readOrNull(file) {
+	try {
+		return readFileSync(file, "utf-8");
+	} catch {
+		return null;
+	}
+}
+function podEnv(root, options = {}) {
+	return podEnvForRuby(readRubyVersion(root), options);
+}
+function podEnvForRuby(version, { env = process.env, home = homedir(), exists = existsSync } = {}) {
+	const out = {
+		...env,
+		FORCE_COLOR: "0",
+		CLICOLOR: "0",
+		LANG: env.LANG ?? "en_US.UTF-8",
+		LC_ALL: env.LC_ALL ?? env.LANG ?? "en_US.UTF-8"
+	};
+	if (!version) return out;
+	const candidates = [
+		{ bin: join(home, ".rbenv", "versions", version, "bin") },
+		{
+			bin: join(home, ".rvm", "rubies", `ruby-${version}`, "bin"),
+			gems: join(home, ".rvm", "gems", `ruby-${version}`)
+		},
+		{ bin: join(home, ".asdf", "installs", "ruby", version, "bin") },
+		{ bin: join(home, ".local", "share", "mise", "installs", "ruby", version, "bin") }
+	];
+	for (const c of candidates) {
+		if (!exists(c.bin)) continue;
+		out.PATH = `${c.bin}${delimiter}${out.PATH ?? ""}`;
+		if (c.gems && exists(c.gems)) {
+			out.GEM_HOME = c.gems;
+			out.GEM_PATH = c.gems;
+		}
+		break;
+	}
+	return out;
+}
+function readRubyVersion(root, { read = readFileSync } = {}) {
+	try {
+		const first = String(read(join(root, ".ruby-version"), "utf-8")).split("\n").map((l) => l.trim()).find((l) => l && !l.startsWith("#"));
+		if (!first) return null;
+		return first.replace(/^ruby-/, "");
+	} catch {
+		return null;
+	}
+}
+function bundlerEnv(root, gemfile) {
+	return {
+		...podEnv(root),
+		BUNDLE_GEMFILE: gemfile,
+		BUNDLE_FROZEN: "true"
+	};
+}
+const BUNDLE_PATH_SETTING = /^BUNDLE_PATH:[ \t]*["']?([^"'\r\n]+?)["']?[ \t]*$/m;
+function bundlePathInsideProject(root, env) {
+	const fromEnv = env.BUNDLE_PATH;
+	const configured = fromEnv || BUNDLE_PATH_SETTING.exec(readOrNull(join(root, ".bundle", "config")) ?? "")?.[1];
+	if (!configured || configured.startsWith("~")) return null;
+	const resolved = resolve(root, configured);
+	if (resolved !== root && !resolved.startsWith(root + sep)) return null;
+	return {
+		path: relative(root, resolved) || ".",
+		where: fromEnv ? "where the BUNDLE_PATH environment variable points" : "where its own .bundle/config points BUNDLE_PATH"
+	};
+}
+async function runCaptured(ctx) {
+	const startedAt = ctx.now();
+	const transcript = [];
+	const push = (line) => {
+		const msg = stripAnsi(String(line)).trimEnd();
+		if (!msg.trim()) return;
+		transcript.push(msg);
+		if (transcript.length > TRANSCRIPT_LINES) transcript.splice(TRANSCRIPT_LINES / 2, 1);
+		ctx.logWriter?.write?.({
+			src: "build",
+			level: "debug",
+			msg,
+			raw: true,
+			event: ctx.event
+		});
+	};
+	let child;
+	try {
+		child = spawnDeclared(() => ctx.spawn(ctx.cmd, ctx.args, {
+			cwd: ctx.cwd,
+			stdio: [
+				"ignore",
+				"pipe",
+				"pipe"
+			],
+			env: ctx.env
+		}));
+	} catch (error) {
+		return {
+			transcript,
+			code: null,
+			signal: null,
+			error,
+			durationMs: ctx.now() - startedAt
+		};
+	}
+	const reader = {
+		out: createLineReader(push),
+		err: createLineReader(push)
+	};
+	child.stdout?.setEncoding?.("utf-8");
+	child.stderr?.setEncoding?.("utf-8");
+	child.stdout?.on("data", (chunk) => reader.out.push(chunk));
+	child.stderr?.on("data", (chunk) => reader.err.push(chunk));
+	const stopHeartbeat = ctx.label ? startBuildHeartbeat({
+		intervalMs: ctx.heartbeatMs,
+		elapsed: () => ctx.now() - startedAt,
+		emit: ctx.onHeartbeat,
+		label: ctx.label,
+		estimateMs: ctx.estimateMs ?? null
+	}) : () => {};
+	let result;
+	try {
+		result = await waitForChild(child);
+	} finally {
+		stopHeartbeat();
+	}
+	reader.out.flush();
+	reader.err.flush();
+	return {
+		transcript,
+		code: result.code ?? null,
+		signal: result.signal ?? null,
+		error: result.error ?? null,
+		durationMs: ctx.now() - startedAt
+	};
+}
+async function ensureBundledGems(root, pin, ctx) {
+	const env = bundlerEnv(root, pin.gemfile);
+	const cwd = dirname(pin.gemfile);
+	const check = await runCaptured({
+		...ctx,
+		cmd: "bundle",
+		args: ["check", "--dry-run"],
+		cwd,
+		env,
+		event: "bundle_check",
+		label: "gems"
+	});
+	if (check.error) return bundlerSpawnFailure("bundle check", check, pin);
+	if (check.code === 0) return { bundler: true };
+	const install = await runCaptured({
+		...ctx,
+		cmd: "bundle",
+		args: ["install"],
+		cwd,
+		env,
+		event: "bundle_install",
+		label: "gems"
+	});
+	if (install.error) return bundlerSpawnFailure("bundle install", install, pin);
+	const inProject = bundlePathInsideProject(cwd, env);
+	const note = inProject ? `\`bundle install\` put this project's gems in ${inProject.path}${sep}, ${inProject.where}; Gemfile.lock itself is never written.` : void 0;
+	if (install.code === 0) return {
+		bundler: true,
+		note
+	};
+	const how = install.signal ? `signal ${install.signal}` : `exit code ${install.code}`;
+	const transcript = install.transcript.join("\n");
+	const extracted = extractPodDiagnostics(transcript);
+	return {
+		bundler: false,
+		failure: {
+			failed: true,
+			code: DEPS_ERROR,
+			reason: `\`bundle install\` failed (${how}).`,
+			remedy: frozenRemedy(root, pin, transcript) || gemInstallRemedy(root, pin),
+			diagnosticSource: extracted ? extracted.source : "tail",
+			diagnosticLines: extracted ? extracted.lines : [],
+			lastLines: install.transcript.slice(-20),
+			durationMs: install.durationMs
+		}
+	};
+}
+function bundlerSpawnFailure(command, run, pin) {
+	if (isMissingBinary(run.error)) return {
+		bundler: false,
+		note: missingBundlerNote(pin)
+	};
+	return {
+		bundler: false,
+		failure: {
+			failed: true,
+			code: DEPS_ERROR,
+			reason: `Could not run \`${command}\`: ${run.error?.message || run.error}`,
+			remedy: `Bundler is how this project pins its CocoaPods (${pin.lockfile}). Check that \`bundle\` runs in ${dirname(pin.gemfile)}, then run again.`,
+			lastLines: run.transcript.slice(-20),
+			durationMs: run.durationMs
+		}
+	};
+}
+function missingBundlerNote(pin) {
+	return `${pin.lockfile} pins this project's CocoaPods, but \`bundle\` is not on PATH, so pods run as plain \`pod install\` with whatever CocoaPods PATH resolves to (\`gem install bundler\` to use the pin).`;
+}
+function frozenRemedy(root, pin, transcript) {
+	if (!BUNDLER_FROZEN.test(transcript)) return void 0;
+	return `Stim runs bundler with BUNDLE_FROZEN so it can never write into your checkout, and ${pin.gemfile} no longer matches ${pin.lockfile}. Run \`cd ${root} && bundle install\` yourself, keep the updated Gemfile.lock, then run again.`;
+}
+function gemInstallRemedy(root, pin) {
+	const version = readRubyVersion(root);
+	return `${version ? `This repo pins ruby ${version} (.ruby-version), so put that ruby on PATH (rbenv/rvm/asdf/mise) first. ` : ""}Bundler could not install the gems ${pin.lockfile} pins, so \`bundle exec pod install\` cannot run. Run \`cd ${root} && bundle install\` and fix what it reports, then run again.`;
+}
+async function runPodInstall(root, logWriter, { spawnFn = null, now = Date.now, heartbeatMs = HEARTBEAT_INTERVAL_MS, estimateMs = null, onHeartbeat = (line) => console.error(line) } = {}) {
+	const iosDir = join(root, "ios");
+	if (!existsSync(iosDir)) return {
+		failed: true,
+		code: DEPS_ERROR,
+		reason: `No ios/ directory in ${root}, so there is nothing to pod install.`,
+		remedy: "Run `stim ios` on a project with native iOS sources, or let prebuild generate them.",
+		lastLines: []
+	};
+	const ctx = {
+		logWriter,
+		spawn: spawnFn || ((cmd, args, opts) => getExecutor().spawn(cmd, args, opts)),
+		now,
+		heartbeatMs,
+		onHeartbeat
+	};
+	const notes = [];
+	const pin = bundlerPin(root);
+	let bundler = false;
+	if (pin) {
+		const gems = await ensureBundledGems(root, pin, ctx);
+		if (gems.failure) return {
+			...gems.failure,
+			notes
+		};
+		if (gems.note) notes.push(gems.note);
+		bundler = gems.bundler;
+	}
+	const args = bundler ? [
+		"bundle",
+		"exec",
+		"pod",
+		"install"
+	] : ["pod", "install"];
+	const command = args.join(" ");
+	const run = await runCaptured({
+		...ctx,
+		cmd: args[0],
+		args: args.slice(1),
+		cwd: iosDir,
+		env: bundler && pin ? bundlerEnv(root, pin.gemfile) : podEnv(root),
+		event: "pod_install",
+		label: "pods",
+		estimateMs
+	});
+	if (run.error) return {
+		...(bundler ? missingBundle(run.error, pin) : missingPod(run.error)) || {
+			failed: true,
+			code: "STIM_DEPS_FAILED",
+			reason: `Could not run \`${command}\`: ${run.error?.message || run.error}`,
+			lastLines: run.transcript.slice(-20),
+			durationMs: run.durationMs
+		},
+		command,
+		notes
+	};
+	if (run.code !== 0) {
+		const how = run.signal ? `signal ${run.signal}` : `exit code ${run.code}`;
+		const transcript = run.transcript.join("\n");
+		const extracted = extractPodDiagnostics(transcript);
+		return {
+			failed: true,
+			code: DEPS_ERROR,
+			reason: `\`${command}\` failed (${how}).`,
+			remedy: podFailureRemedy(root, pin, transcript),
+			command,
+			notes,
+			diagnosticSource: extracted ? extracted.source : "tail",
+			diagnosticLines: extracted ? extracted.lines : [],
+			lastLines: run.transcript.slice(-20),
+			durationMs: run.durationMs
+		};
+	}
+	return {
+		ok: true,
+		command,
+		notes,
+		durationMs: run.durationMs
+	};
+}
+function podFailureRemedy(root, pin, transcript) {
+	if (pin) {
+		const frozen = frozenRemedy(root, pin, transcript);
+		if (frozen) return frozen;
+		if (BUNDLER_NO_COCOAPODS.test(transcript)) return `${pin.lockfile} resolves cocoapods, but bundler found no \`pod\` executable in the bundle it loaded: the installed gems belong to a different Gemfile than ${pin.gemfile}, or that Gemfile's bundle was never installed. Run \`cd ${root} && bundle install && bundle exec pod --version\` and make that work, then run again.`;
+	}
+	const pinned = /Could not find proper version of cocoapods/.test(transcript) ? readRubyVersion(root) : null;
+	if (!pinned) return void 0;
+	return `This repo pins ruby ${pinned} (.ruby-version) and its Gemfile's cocoapods was installed under it; the shell's ruby is likely a different version, so bundler looks in the wrong gem home. Put ruby ${pinned} on PATH (rbenv/rvm/asdf/mise) -- \`bundle install\` will NOT fix this.`;
+}
+function isMissingBinary(err) {
+	const nodeErr = err;
+	const message = String(nodeErr?.message || err || "");
+	return nodeErr?.code === "ENOENT" || /ENOENT|not found/i.test(message);
+}
+function missingBundle(err, pin) {
+	if (!isMissingBinary(err)) return null;
+	return {
+		failed: true,
+		code: DEPS_ERROR,
+		reason: "Bundler is not installed: no `bundle` executable on PATH.",
+		remedy: `${pin?.lockfile ?? "Gemfile.lock"} pins this project's CocoaPods, so pods run through bundler. Install bundler (\`gem install bundler\`) and run again.`,
+		lastLines: []
+	};
+}
+function missingPod(err) {
+	if (!isMissingBinary(err)) return null;
+	return {
+		failed: true,
+		code: DEPS_ERROR,
+		reason: "CocoaPods is not installed: no `pod` executable on PATH.",
+		remedy: "Install CocoaPods (`brew install cocoapods`, or `gem install cocoapods`) and run again.",
+		lastLines: []
+	};
+}
+//#endregion
 //#region src/offload/manifest.ts
 function manifestDigest(entries) {
 	const hash = createHash("sha256");
@@ -1087,7 +1527,10 @@ const distDir = dirname(fileURLToPath(import.meta.url));
 function quiet(file, args) {
 	return getExecutor().runFileQuiet(file, args, { timeoutMs: 2e4 });
 }
-function iosToolchain() {
+function iosToolchain(root) {
+	return iosToolchainForRuby(readRubyVersion(root));
+}
+function iosToolchainForRuby(rubyVersion) {
 	const xcode = quiet("xcodebuild", ["-version"]);
 	return {
 		stimBuild: stimBuildDigest(distDir),
@@ -1098,9 +1541,15 @@ function iosToolchain() {
 			"iphonesimulator",
 			"--show-sdk-version"
 		])?.trim() ?? null,
-		cocoapods: quiet("pod", ["--version"])?.trim().split("\n").pop()?.trim() ?? null
+		cocoapods: cocoapodsVersion(rubyVersion)
 	};
 }
+function cocoapodsVersion(rubyVersion) {
+	return getExecutor().runFileQuiet("pod", ["--version"], {
+		timeoutMs: 2e4,
+		env: Object.fromEntries(Object.entries(podEnvForRuby(rubyVersion)).filter((entry) => entry[1] !== void 0))
+	})?.trim().split("\n").pop()?.trim() ?? null;
+}
 function macosToolchain() {
 	const xcode = quiet("xcodebuild", ["-version"]);
 	return {
@@ -1190,7 +1639,7 @@ function sdkPackages() {
 		platforms
 	};
 }
-function workerToolchain() {
+function workerToolchain(rubyVersion = null) {
 	let listed = null;
 	try {
 		listed = JSON.parse(quiet("xcrun", [
@@ -1202,7 +1651,7 @@ function workerToolchain() {
 		]) ?? "null");
 	} catch {}
 	return {
-		...iosToolchain(),
+		...iosToolchainForRuby(rubyVersion),
 		macosSdk: quiet("xcrun", [
 			"--sdk",
 			"macosx",
@@ -1295,4 +1744,4 @@ function toolchainMismatches(target, worker) {
 	return out;
 }
 //#endregion
-export { podInstallCommand as C, projectCmakeLauncher as D, ccacheActivityLine as E, readCcacheActivity as O, bundlerPin as S, CCACHE_UNAVAILABLE as T, readBundleId as _, toolchainMismatches as a, tailLines as b, COMPILATION_CACHE_NOT_RUN as c, buildIos as d, ccacheEnabled as f, readBundleExecutable as g, discoverXcodeProject as h, macosToolchain as i, resolveCcache as k, COMPILATION_CACHE_UNAVAILABLE as l, detectXcodeMajor as m, androidToolchain as n, workerToolchain as o, compilationCacheActivityLine as p, iosToolchain as r, manifestDigest as s, androidRequirements as t, HEARTBEAT_INTERVAL_MS as u, resolveScheme as v, CCACHE_NOT_RUN as w, describeDiagnostic as x, startBuildHeartbeat as y };
+export { CCACHE_NOT_RUN as A, readBundleId as C, describeDiagnostic as D, tailLines as E, resolveCcache as F, ccacheActivityLine as M, projectCmakeLauncher as N, bundlerPin as O, readCcacheActivity as P, readBundleExecutable as S, startBuildHeartbeat as T, buildIos as _, toolchainMismatches as a, detectXcodeMajor as b, DEPS_ERROR as c, readRubyVersion as d, runCaptured as f, HEARTBEAT_INTERVAL_MS as g, COMPILATION_CACHE_UNAVAILABLE as h, macosToolchain as i, CCACHE_UNAVAILABLE as j, podInstallCommand as k, podsAreStale as l, COMPILATION_CACHE_NOT_RUN as m, androidToolchain as n, workerToolchain as o, runPodInstall as p, iosToolchain as r, manifestDigest as s, androidRequirements as t, readPodState as u, ccacheEnabled as v, resolveScheme as w, discoverXcodeProject as x, compilationCacheActivityLine as y };

package/dist/{trigger-Bemu8ytw.mjs → trigger-CJMhwXe8.mjs}

@@ -1,8 +1,8 @@
-import { t as getExecutor } from "./exec-CaErVv7t.mjs";
-import { n as windowsLauncherArgs } from "./detached-entry-CiTEgMR1.mjs";
-import { t as resolveMaintenanceSettings } from "./settings-BBpMcDbD.mjs";
-import { n as stampAttempt, r as due, t as capChildLog } from "./attempt-Bk2ouQVL.mjs";
-import { t as spawnEntry } from "./spawn-entry-jw19m8Nl.mjs";
+import { t as getExecutor } from "./exec-DWhCZDGm.mjs";
+import { t as spawnEntry } from "./spawn-entry-Dcb7sDUz.mjs";
+import { n as windowsLauncherArgs } from "./detached-entry-BLfcgc4O.mjs";
+import { t as resolveMaintenanceSettings } from "./settings-Djl-mpjX.mjs";
+import { n as stampAttempt, r as due, t as capChildLog } from "./attempt-DW-mQqM7.mjs";
 import { closeSync, openSync } from "node:fs";
 import { maintenanceChildLogFile, maintenanceRunClaims, readMaintenanceAttempt, readMaintenanceState } from "@stim-cli/core/state";
 import { readClaimSet } from "@stim-cli/core/ownership-claim";

package/dist/trigger-DWAq9hkw.mjs

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

package/dist/{warm-progress-DF4JRvYI.mjs → warm-progress-CjB-MP6H.mjs}

@@ -1,14 +1,14 @@
-import { t as getExecutor } from "./exec-CaErVv7t.mjs";
-import { n as ownership_claim_exports } from "./process-identity-BmRm1qV0.mjs";
-import { o as pullRequestLookups } from "./pull-request-pxnDCQzn.mjs";
-import { at as gitCommonDirOnDisk } from "./settings-Cfd-0r2d.mjs";
-import { D as discoverAgentSessions, E as attributeAgentSessions, T as agentKey, a as updateWorkspaceState, u as ensureWorkspaceStorage, v as workspaceDir, w as withDirLock } from "./workspace-state-DqcCbpE7.mjs";
-import { I as ownedAvdDirectory } from "./android-B_YNZy61.mjs";
-import { randomUUID } from "node:crypto";
+import { n as ownership_claim_exports } from "./process-identity-Biv3arCO.mjs";
+import { t as getExecutor } from "./exec-DWhCZDGm.mjs";
+import { c as gitCommonDirOnDisk } from "./worktree-CsKYexJM.mjs";
+import { D as discoverAgentSessions, E as attributeAgentSessions, T as agentKey, a as updateWorkspaceState, u as ensureWorkspaceStorage, v as workspaceDir, w as withDirLock } from "./workspace-state-C59dqG-Z.mjs";
+import { I as ownedAvdDirectory } from "./android-DC3ZLuw0.mjs";
+import { o as pullRequestLookups } from "./pull-request-u4vp7zmK.mjs";
 import { existsSync, mkdirSync, realpathSync, renameSync, rmSync, statSync, writeFileSync } from "node:fs";
 import { basename, dirname, join } from "node:path";
 import { ENDED_AGENT_RETENTION_MS, READY_PHASE_MS, WARM_KEY, agentSessionsCacheFile, diskUsageCacheFile, pullRequestCacheFile, readAgentSessionsCache, readDiskUsage, readEndedAgentSessions, readPullRequestCache, readWarmRecord, readWorkspaceAgent, readWorkspaceState, workspaceEndedAgentsFile, workspaceEndedAgentsLock } from "@stim-cli/core/state";
 import { homedir } from "node:os";
+import { randomUUID } from "node:crypto";
 //#region src/workspace/merge-state.ts
 const FETCH_TIMEOUT_MS = 3e4;
 const FETCH_FRESH_MS = 6e5;

package/dist/web-B6_bFDn7.mjs

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