stim 1.5.0 → 1.7.0

package/dist/build-lock-CgtsB6TV.mjs

@@ -0,0 +1,604 @@
+import { t as getExecutor } from "./exec-B29XNuhP.mjs";
+import { E as ownership_claim_exports, u as getConfigDir } from "./config-B7iyKWkL.mjs";
+import { r as register } from "./cache-manifest-CYJi8-Hx.mjs";
+import { l as sharedBuildCache } from "./workspace-state-BT5E3SA2.mjs";
+import { a as formatElapsed } from "./command-output-B3ycpsYv.mjs";
+import { existsSync, readFileSync, readdirSync, statSync } from "node:fs";
+import { createHash } from "node:crypto";
+import { join } from "node:path";
+import { existsSync as existsSync$1, mkdirSync as mkdirSync$1, readFileSync as readFileSync$1, rmSync as rmSync$1, writeFileSync as writeFileSync$1 } from "fs";
+import { join as join$1 } from "path";
+import { buildCacheKey, resolveArtifact, storeArtifact } from "@stim-cli/core";
+import * as expoFingerprint from "@expo/fingerprint";
+import { buildUploadTimeoutMs } from "@stim-cli/cache";
+const ASSET_MANIFEST_FILE = "assets-manifest.json";
+const MAX_DEPTH = 4;
+function hashFile(file) {
+	try {
+		return createHash("sha256").update(readFileSync(file)).digest("hex");
+	} catch {
+		return null;
+	}
+}
+function readAssetManifest(root) {
+	if (!existsSync(root)) return null;
+	const assets = [];
+	let broken = false;
+	const walk = (abs, rel, depth) => {
+		if (depth > MAX_DEPTH || broken) return;
+		let names;
+		try {
+			names = readdirSync(abs);
+		} catch {
+			broken = true;
+			return;
+		}
+		for (const name of names) {
+			const child = join(abs, name);
+			let stat;
+			try {
+				stat = statSync(child);
+			} catch {
+				broken = true;
+				return;
+			}
+			const path = rel === "" ? name : `${rel}/${name}`;
+			if (stat.isDirectory()) {
+				walk(child, path, depth + 1);
+				continue;
+			}
+			if (!stat.isFile()) continue;
+			const sha256 = hashFile(child);
+			if (sha256 === null) {
+				broken = true;
+				return;
+			}
+			assets.push({
+				path,
+				sha256
+			});
+		}
+	};
+	walk(root, "", 0);
+	if (broken) return null;
+	assets.sort((a, b) => a.path.localeCompare(b.path));
+	return {
+		version: 1,
+		assets
+	};
+}
+function parseAssetManifest(text) {
+	let parsed;
+	try {
+		parsed = JSON.parse(String(text));
+	} catch {
+		return null;
+	}
+	const obj = parsed;
+	if (!obj || obj.version !== 1 || !Array.isArray(obj.assets)) return null;
+	const assets = [];
+	for (const raw of obj.assets) {
+		const entry = raw;
+		if (typeof entry?.path !== "string" || typeof entry?.sha256 !== "string") return null;
+		assets.push({
+			path: entry.path,
+			sha256: entry.sha256
+		});
+	}
+	return {
+		version: 1,
+		assets
+	};
+}
+function pickGeneratedResDir(names, variant, reactChildren = []) {
+	const wanted = (variant ?? "").trim().toLowerCase();
+	const modern = names.filter((n) => /^createBundle.+JsAndAssets$/.test(n)).toSorted();
+	if (wanted) {
+		const match = modern.find((n) => n.toLowerCase() === `createbundle${wanted}jsandassets`);
+		if (match) return match;
+	} else if (modern.length === 1) return modern[0];
+	if (!names.includes("react")) return null;
+	const children = reactChildren.toSorted();
+	if (wanted) {
+		const match = children.find((n) => n.toLowerCase() === wanted);
+		if (match) return `react/${match}`;
+	} else if (children.length === 1) return `react/${children[0]}`;
+	return null;
+}
+function androidModuleDirs(root, { list = safeList } = {}) {
+	const android = join(root, "android");
+	return ["app", ...list(android).filter((name) => name !== "app" && existsSync(join(android, name, "build", "generated", "res"))).toSorted()];
+}
+function findGeneratedResDir(root, variant, { list = safeList } = {}) {
+	for (const module of androidModuleDirs(root, { list })) {
+		const base = join(root, "android", module, "build", "generated", "res");
+		const names = list(base);
+		if (names.length === 0) continue;
+		const picked = pickGeneratedResDir(names, variant, names.includes("react") ? list(join(base, "react")) : []);
+		if (picked) return join(base, ...picked.split("/"));
+	}
+	return null;
+}
+function captureAssetManifest(root, { variant = null, findDir = findGeneratedResDir, read = readAssetManifest } = {}) {
+	const dir = findDir(root, variant);
+	return dir ? read(dir) : null;
+}
+function compareAssetManifests(fresh, stored) {
+	const left = new Map(fresh.assets.map((a) => [a.path, a.sha256]));
+	const right = new Map(stored.assets.map((a) => [a.path, a.sha256]));
+	const added = [];
+	const changed = [];
+	const removed = [];
+	for (const [path, sha256] of left) if (!right.has(path)) added.push(path);
+	else if (right.get(path) !== sha256) changed.push(path);
+	for (const path of right.keys()) if (!left.has(path)) removed.push(path);
+	added.sort();
+	changed.sort();
+	removed.sort();
+	return {
+		same: added.length === 0 && changed.length === 0 && removed.length === 0,
+		added,
+		removed,
+		changed,
+		example: added[0] ?? changed[0] ?? removed[0] ?? null
+	};
+}
+function assetDiffReason(diff) {
+	const which = diff.added.length ? "added" : diff.changed.length ? "changed" : "removed";
+	return `this workspace emits a different asset set than the cached build did (${diff.added.length} added, ${diff.changed.length} changed, ${diff.removed.length} removed; e.g. ${which} ${diff.example})`;
+}
+function safeList(dir) {
+	try {
+		return readdirSync(dir);
+	} catch {
+		return [];
+	}
+}
+//#endregion
+//#region src/cache/build-cache.ts
+function entryDir(platform, key, root = sharedBuildCache()) {
+	return join$1(root, platform, key);
+}
+const FINGERPRINT_PLATFORMS = /* @__PURE__ */ new Set(["ios", "android"]);
+/**
+* Paths that exist in a working checkout and not in a fresh one, which
+* @expo/fingerprint does not ignore on its own. A fingerprint that counts them
+* cannot match across checkouts, which is the parity failure `doctor` reports.
+*
+* The list stays narrow on purpose: a path belongs here only when no native
+* build on any project can read it. Anything a single project can judge --
+* a lockfile with machine paths, a generated report -- belongs in that
+* project's `.fingerprintignore`, which still applies on top of this.
+*/
+const DEFAULT_FINGERPRINT_IGNORES = ["**/android/local.properties", "**/android/.idea/**"];
+async function fingerprintProject(projectRoot, { platform, createFingerprint = expoFingerprint.createFingerprintAsync, debug = false } = {}) {
+	const result = await createFingerprint(projectRoot, {
+		...platform && FINGERPRINT_PLATFORMS.has(platform) ? { platforms: [platform] } : void 0,
+		...debug ? { debug } : {},
+		ignorePaths: DEFAULT_FINGERPRINT_IGNORES,
+		silent: true
+	});
+	const hash = result?.hash ?? null;
+	if (!hash) return null;
+	return {
+		hash,
+		sources: Array.isArray(result?.sources) ? result.sources : []
+	};
+}
+function registerOnce(root) {
+	try {
+		register({
+			dir: root,
+			name: "Build cache",
+			prune: "entries",
+			entriesDepth: 2,
+			note: "built .app/.apk keyed on the native fingerprint"
+		});
+	} catch {}
+}
+function resolveBuild(platform, key, root = sharedBuildCache()) {
+	return resolveArtifact(entryDir(platform, key, root));
+}
+function storeBuild(platform, key, buildPath, rootOrOptions = {}) {
+	const options = typeof rootOrOptions === "string" ? { root: rootOrOptions } : rootOrOptions || {};
+	const root = options.root || sharedBuildCache();
+	if (!buildPath || !existsSync$1(buildPath)) throw new Error(`No build to store at ${buildPath}`);
+	registerOnce(root);
+	return storeArtifact(entryDir(platform, key, root), buildPath, {
+		runFile: getExecutor().runFile,
+		overwrite: Boolean(options.overwrite),
+		writeMetadata: (staging) => {
+			if (Array.isArray(options.sources)) try {
+				writeFileSync$1(join$1(staging, SOURCES_FILE), JSON.stringify(options.sources));
+			} catch {}
+			if (options.assetManifest) try {
+				writeFileSync$1(join$1(staging, ASSET_MANIFEST_FILE), JSON.stringify(options.assetManifest));
+			} catch {}
+		}
+	});
+}
+const PROVIDER_DOWNLOAD_DIR = "cache-provider";
+function providerDownloadPath(workspacePath) {
+	return join$1(workspacePath, PROVIDER_DOWNLOAD_DIR);
+}
+/**
+* Empties and registers the scratch directory a provider downloads into. It is
+* created only when a provider is about to be asked, and registered so `gc`
+* reports what an interrupted run left behind.
+*/
+function prepareProviderDownloadDir(dir) {
+	rmSync$1(dir, {
+		recursive: true,
+		force: true
+	});
+	mkdirSync$1(dir, { recursive: true });
+	try {
+		register({
+			dir,
+			name: "Cache provider downloads",
+			prune: "entries",
+			entriesDepth: 1,
+			note: "artifacts fetched from the project cache provider; anything left here is from an interrupted run"
+		});
+	} catch {}
+}
+function filesystemBuildCapability({ root, sources, assetManifest, resolve = resolveBuild, store = storeBuild } = {}) {
+	const stored = {
+		...root === void 0 ? {} : { root },
+		...sources === void 0 ? {} : { sources },
+		...assetManifest === void 0 ? {} : { assetManifest }
+	};
+	return {
+		resolve: ({ platform, key }) => root === void 0 ? resolve(platform, key) : resolve(platform, key, root),
+		store: ({ platform, key, sourcePath, overwrite }) => store(platform, key, sourcePath, {
+			...stored,
+			overwrite
+		})
+	};
+}
+function providerUploadOutcome(result, name) {
+	if (!result) return null;
+	const label = name || "the cache provider";
+	if (result.timedOut) return {
+		line: `${label} upload was cancelled after ${buildUploadTimeoutMs()}ms`,
+		warn: true
+	};
+	if (result.failed) return {
+		line: `${label} upload failed: ${result.failed}`,
+		warn: true
+	};
+	return {
+		line: `uploaded (${label})`,
+		warn: false
+	};
+}
+const SOURCES_FILE = "fingerprint-sources.json";
+function storedSources(platform, key, root = sharedBuildCache()) {
+	try {
+		const parsed = JSON.parse(readFileSync$1(join$1(entryDir(platform, key, root), SOURCES_FILE), "utf-8"));
+		return Array.isArray(parsed) ? parsed : null;
+	} catch {
+		return null;
+	}
+}
+function storedAssetManifest(platform, key, root = sharedBuildCache()) {
+	try {
+		return parseAssetManifest(readFileSync$1(join$1(entryDir(platform, key, root), ASSET_MANIFEST_FILE), "utf-8"));
+	} catch {
+		return null;
+	}
+}
+function sourceName(source) {
+	const s = source;
+	if (typeof s?.filePath === "string" && s.filePath !== "") return s.filePath;
+	if (typeof s?.id === "string" && s.id !== "") return s.id;
+	return null;
+}
+function diffItemName(item) {
+	const o = item;
+	for (const candidate of [
+		o,
+		o?.addedSource,
+		o?.removedSource,
+		o?.afterSource,
+		o?.beforeSource
+	]) {
+		const name = sourceName(candidate);
+		if (name) return name;
+	}
+	return null;
+}
+function compareSourceLists(previous, current) {
+	const previousByName = /* @__PURE__ */ new Map();
+	for (const source of previous) {
+		const name = sourceName(source);
+		if (name !== null) previousByName.set(name, source.hash ?? null);
+	}
+	const changed = [];
+	const seen = /* @__PURE__ */ new Set();
+	for (const source of current) {
+		const name = sourceName(source);
+		if (name === null || seen.has(name)) continue;
+		seen.add(name);
+		const hash = source.hash;
+		if (!previousByName.has(name) || previousByName.get(name) !== (hash ?? null)) changed.push(name);
+	}
+	for (const [name] of previousByName) if (!seen.has(name)) changed.push(name);
+	return changed;
+}
+function diffFingerprintSources({ previous, previousHash = null, current, differ = null }) {
+	if (typeof differ === "function") try {
+		const items = differ({
+			sources: previous,
+			hash: previousHash ?? ""
+		}, {
+			sources: current.sources,
+			hash: current.hash
+		});
+		if (Array.isArray(items)) {
+			const names = [];
+			const seen = /* @__PURE__ */ new Set();
+			for (const item of items) {
+				const name = diffItemName(item);
+				if (name !== null && !seen.has(name)) {
+					seen.add(name);
+					names.push(name);
+				}
+			}
+			return names;
+		}
+	} catch {}
+	return compareSourceLists(previous, current.sources);
+}
+function fingerprintDiffSuffix(changed) {
+	if (!changed.length) return "";
+	const shown = changed.slice(0, 3).join(", ");
+	return ` -- ${changed.length} source${changed.length === 1 ? "" : "s"} changed: ${shown}`;
+}
+function describeFingerprintMiss({ platform, current, lastBuild, root = sharedBuildCache(), differ = expoFingerprint.diffFingerprints }) {
+	if (!lastBuild || lastBuild.platform !== platform) return null;
+	const previousHash = typeof lastBuild.fingerprint === "string" ? lastBuild.fingerprint : null;
+	const previousKey = typeof lastBuild.cacheKey === "string" ? lastBuild.cacheKey : null;
+	if (!previousHash || !previousKey || previousHash === current.hash) return null;
+	const previous = storedSources(platform, previousKey, root);
+	if (!previous) return null;
+	const changed = diffFingerprintSources({
+		previous,
+		previousHash,
+		current,
+		differ
+	});
+	return changed.length ? {
+		changed,
+		previousHash
+	} : null;
+}
+async function refingerprintAfterMutation({ projectRoot, platform, previousHash, fingerprint = fingerprintProject }) {
+	let computed = null;
+	try {
+		computed = await fingerprint(projectRoot, { platform });
+	} catch {
+		return null;
+	}
+	if (!computed?.hash) return null;
+	return {
+		hash: computed.hash,
+		sources: computed.sources,
+		moved: computed.hash !== previousHash
+	};
+}
+function untrackedNativeFiles({ projectRoot, exec = getExecutor() }) {
+	let out;
+	try {
+		out = exec.runFile("git", [
+			"-C",
+			projectRoot,
+			"ls-files",
+			"--others",
+			"--exclude-standard",
+			"--",
+			"ios",
+			"android"
+		]);
+	} catch {
+		return [];
+	}
+	return String(out || "").split("\n").map((line) => line.trim()).filter((line) => line !== "");
+}
+function untrackedMissLine(files, cap = 3) {
+	if (!Array.isArray(files) || files.length === 0) return null;
+	const shown = files.slice(0, cap);
+	const more = files.length > shown.length ? `, and ${files.length - shown.length} more` : "";
+	return `no previous entry to diff against; ${files.length} untracked file${files.length === 1 ? "" : "s"} under ios/ or android/ are hashed like any other source: ${shown.join(", ")}${more} -- list the build-irrelevant ones in .fingerprintignore`;
+}
+function fingerprintDiffRecord({ changed, previousHash, hash }) {
+	const shown = changed.slice(0, 20);
+	return {
+		src: "build",
+		level: "info",
+		event: "fingerprint_diff",
+		msg: `fingerprint ${previousHash} -> ${hash}: ${changed.length} source${changed.length === 1 ? "" : "s"} changed: ` + shown.join(", ") + (changed.length > shown.length ? `, and ${changed.length - shown.length} more` : ""),
+		changed: changed.length,
+		sources: shown
+	};
+}
+//#endregion
+//#region src/engine/build-lock.ts
+const LOCK_SUFFIX = ".lock";
+const WAIT_POLL_MS = 1e3;
+const WAIT_PROGRESS_MS = 3e4;
+const WAIT_CEILING_MS = 54e5;
+function sleepAsync(ms) {
+	return new Promise((resolve) => setTimeout(resolve, ms));
+}
+function segment(value) {
+	return String(value).replace(/[^A-Za-z0-9._-]+/g, "-").replace(/^\.+/, "") || "unknown";
+}
+function buildLocksDir() {
+	return join(getConfigDir(), "build-locks");
+}
+function buildLockPath(platform, key) {
+	return join(buildLocksDir(), `${segment(platform)}-${segment(key)}${LOCK_SUFFIX}`);
+}
+function label(platform) {
+	return `${platform} build`;
+}
+function toRecord(holder) {
+	const details = holder.details;
+	return {
+		pid: holder.owner.pid,
+		projectRoot: typeof details.projectRoot === "string" ? details.projectRoot : null,
+		startedAt: holder.startedAt || null,
+		logFile: typeof details.logFile === "string" ? details.logFile : null
+	};
+}
+function readBuildLock(pathOrSpec) {
+	const path = typeof pathOrSpec === "string" ? pathOrSpec : buildLockPath(pathOrSpec.platform, pathOrSpec.key);
+	const survey = (0, ownership_claim_exports.readClaimSet)(path);
+	const holder = survey.live[0] ?? survey.dead[0];
+	return holder ? toRecord(holder) : null;
+}
+function acquireBuildLock({ platform, key, root = null, logFile = null }) {
+	const path = buildLockPath(platform, key);
+	const attempt = (0, ownership_claim_exports.tryAcquireClaim)({
+		root: path,
+		mode: "exclusive",
+		label: label(platform),
+		details: {
+			projectRoot: root,
+			logFile
+		}
+	});
+	const reaped = attempt.reaped[0];
+	if (attempt.acquired) {
+		const handle = {
+			acquired: true,
+			path,
+			lock: {
+				pid: attempt.acquired.owner.pid,
+				projectRoot: root,
+				startedAt: attempt.acquired.startedAt,
+				logFile
+			},
+			claim: attempt.acquired
+		};
+		return reaped ? {
+			...handle,
+			tookOver: toRecord(reaped)
+		} : handle;
+	}
+	if (attempt.pending) (0, ownership_claim_exports.releaseClaim)(attempt.pending);
+	const holder = attempt.held ?? attempt.waitingFor?.[0];
+	return holder ? {
+		held: toRecord(holder),
+		path
+	} : { path };
+}
+function releaseBuildLock(handle) {
+	return (0, ownership_claim_exports.releaseClaim)(handle?.claim);
+}
+function listBuildLocks() {
+	const dir = buildLocksDir();
+	let names;
+	try {
+		names = readdirSync(dir);
+	} catch {
+		return [];
+	}
+	const locks = [];
+	for (const name of names) {
+		if (!name.endsWith(LOCK_SUFFIX)) continue;
+		const path = join(dir, name);
+		try {
+			if (!statSync(path).isDirectory()) continue;
+		} catch {
+			continue;
+		}
+		const stem = name.slice(0, -5);
+		const cut = stem.indexOf("-");
+		const survey = (0, ownership_claim_exports.readClaimSet)(path);
+		const holder = survey.live[0] ?? survey.dead[0];
+		const info = holder ? toRecord(holder) : null;
+		locks.push({
+			path,
+			name,
+			platform: cut > 0 ? stem.slice(0, cut) : stem,
+			key: cut > 0 ? stem.slice(cut + 1) : null,
+			pid: info?.pid ?? null,
+			projectRoot: info?.projectRoot ?? null,
+			startedAt: info?.startedAt ?? null,
+			logFile: info?.logFile ?? null,
+			alive: survey.live.length > 0,
+			unresolved: survey.unresolved.length > 0
+		});
+	}
+	return locks;
+}
+function waitingLine({ projectRoot, pid, elapsedMs, logFile }) {
+	const where = projectRoot || "another workspace";
+	const tail = logFile ? ` -- tail ${logFile}` : "";
+	return `${"build".padEnd(11)} waiting on ${where} (pid ${pid ?? "?"}, ${formatElapsed(elapsedMs)} elapsed)${tail} -- stim guide lifecycle concurrency`;
+}
+function takeoverLine({ projectRoot, pid, logFile, startedAt = null, now = Date.now }) {
+	const where = projectRoot || "another workspace";
+	const started = startedAt ? Date.parse(startedAt) : NaN;
+	const ago = Number.isFinite(started) ? ` (it started ${formatElapsed(now() - started)} ago)` : "";
+	const tail = logFile ? ` -- read ${logFile} before this one finishes` : "";
+	return `RETRY: ${where}'s build of this fingerprint (pid ${pid ?? "?"}) FAILED without an artifact${ago}, and this run rebuilds the SAME inputs, so expect the same failure unless something changed${tail}`;
+}
+async function waitForBuild({ platform, key, resolve = resolveBuild, intervalMs = WAIT_POLL_MS, progressMs = WAIT_PROGRESS_MS, ceilingMs = WAIT_CEILING_MS, out = () => {}, now = Date.now, sleep = sleepAsync }) {
+	const path = buildLockPath(platform, key);
+	const started = now();
+	let lastProgress = started;
+	let holder = readBuildLock(path);
+	for (;;) {
+		const hit = resolve(platform, key);
+		if (hit) return {
+			hit,
+			waitedMs: now() - started
+		};
+		const survey = (0, ownership_claim_exports.readClaimSet)(path);
+		const unresolved = survey.unresolved[0];
+		if (unresolved) throw new ownership_claim_exports.ClaimRefusedError({
+			claimPath: unresolved.path,
+			root: path,
+			label: label(platform),
+			reason: unresolved.reason
+		});
+		const live = survey.live[0];
+		if (live) holder = toRecord(live);
+		else {
+			const dead = survey.dead[0];
+			if (dead) return {
+				builderFailed: `the builder (pid ${dead.owner.pid}) is gone`,
+				holder: toRecord(dead),
+				waitedMs: now() - started
+			};
+			return {
+				lockReleased: true,
+				holder,
+				waitedMs: now() - started
+			};
+		}
+		const elapsed = now() - started;
+		if (elapsed >= ceilingMs) {
+			const err = /* @__PURE__ */ new Error(`Waited ${formatElapsed(elapsed)} for ${holder?.projectRoot || "another workspace"}'s ${platform} build of ${key} without an artifact, and pid ${holder?.pid} is still the live holder. The lock is ${path}; remove it if that process is not really building:\n  ${(0, ownership_claim_exports.claimRemoveCommand)(path)}`);
+			err.code = "STIM_BUILD_WAIT_TIMEOUT";
+			err.lockPath = path;
+			err.holder = holder ?? void 0;
+			throw err;
+		}
+		if (now() - lastProgress >= progressMs) {
+			lastProgress = now();
+			out(waitingLine({
+				projectRoot: holder.projectRoot,
+				pid: holder.pid,
+				elapsedMs: elapsed,
+				logFile: holder.logFile
+			}));
+		}
+		await sleep(intervalMs);
+	}
+}
+//#endregion
+export { untrackedNativeFiles as C, readAssetManifest as D, compareAssetManifests as E, untrackedMissLine as S, captureAssetManifest as T, providerUploadOutcome as _, segment as a, storeBuild as b, buildCacheKey as c, filesystemBuildCapability as d, fingerprintDiffRecord as f, providerDownloadPath as g, prepareProviderDownloadDir as h, releaseBuildLock as i, describeFingerprintMiss as l, fingerprintProject as m, acquireBuildLock as n, takeoverLine as o, fingerprintDiffSuffix as p, listBuildLocks as r, waitForBuild as s, WAIT_CEILING_MS as t, diffFingerprintSources as u, refingerprintAfterMutation as v, assetDiffReason as w, storedAssetManifest as x, resolveBuild as y };

package/dist/{build-slots-CuPszJDu.mjs → build-slots-C-oAHRT1.mjs}

@@ -1,5 +1,5 @@
-import { E as ownership_claim_exports, u as getConfigDir } from "./config-DMP7L7H6.mjs";
-import { a as formatElapsed } from "./command-output-BuIb_ZOI.mjs";
+import { E as ownership_claim_exports, u as getConfigDir } from "./config-B7iyKWkL.mjs";
+import { a as formatElapsed } from "./command-output-B3ycpsYv.mjs";
 import { readdirSync, statSync } from "node:fs";
 import { join } from "node:path";
 //#region src/engine/build-slots.ts

package/dist/{cache-manifest-uoOKhgUD.mjs → cache-manifest-CYJi8-Hx.mjs}

@@ -1,9 +1,9 @@
-import { u as getConfigDir } from "./config-DMP7L7H6.mjs";
+import { u as getConfigDir } from "./config-B7iyKWkL.mjs";
 import { existsSync } from "fs";
 import { homedir } from "os";
 import { join, resolve } from "path";
 import { readCacheManifest, updateCacheManifest } from "@stim-cli/core";
-//#region src/cache-manifest.ts
+//#region src/cache/cache-manifest.ts
 function manifestPath() {
 	return join(getConfigDir(), "caches.json");
 }

package/dist/cache-manifest.d.mts

@@ -1,4 +1,4 @@
-//#region src/cache-manifest.d.ts
+//#region src/cache/cache-manifest.d.ts
 interface CacheEntry {
   dir: string;
   name?: string;

package/dist/cache-manifest.mjs

@@ -1,2 +1,2 @@
-import { a as unregister, i as registeredCaches, n as readManifest, r as register, t as manifestPath } from "./cache-manifest-uoOKhgUD.mjs";
+import { a as unregister, i as registeredCaches, n as readManifest, r as register, t as manifestPath } from "./cache-manifest-CYJi8-Hx.mjs";
 export { manifestPath, readManifest, register, registeredCaches, unregister };

package/dist/cli.mjs

@@ -3,20 +3,20 @@ import { readFileSync } from "node:fs";
 import { Command } from "commander";
 //#region bin/cli.ts
 const commands = /* @__PURE__ */ new Map([
-	["doctor", () => import("./doctor-Di_B26uh.mjs")],
-	["worktree", () => import("./worktree-CeUKDAQw.mjs")],
-	["start", () => import("./start-DiEfqEWk.mjs")],
-	["ports", () => import("./ports-A6uTJSPj.mjs")],
-	["stop", () => import("./stop-CM1fejKW.mjs")],
-	["ios", () => import("./ios-BdpkncL6.mjs")],
-	["android", () => import("./android-sobvO9ia.mjs")],
-	["reload", () => import("./reload-CYBJbJfI.mjs")],
-	["device", () => import("./device-BUw4JBuH.mjs")],
-	["logs", () => import("./logs-BfQdIhiF.mjs")],
-	["status", () => import("./status-J5LAXpag.mjs")],
-	["stats", () => import("./stats-DHrO0frH.mjs")],
-	["gc", () => import("./gc-C20dWw_8.mjs")],
-	["guide", () => import("./guide-sAnoty2y.mjs")]
+	["doctor", () => import("./doctor-CTAx9gMu.mjs")],
+	["worktree", () => import("./worktree-BfE4lzHK.mjs")],
+	["start", () => import("./start-TTVILlUi.mjs")],
+	["ports", () => import("./ports-BIbJaKNW.mjs")],
+	["stop", () => import("./stop-CnUpnFT5.mjs")],
+	["ios", () => import("./ios-BRXYSxSc.mjs")],
+	["android", () => import("./android-Da-G_o3n.mjs")],
+	["reload", () => import("./reload-ChW46VDb.mjs")],
+	["device", () => import("./device-CBSaC6BU.mjs")],
+	["logs", () => import("./logs-CakdBTtm.mjs")],
+	["status", () => import("./status-DUNy_HZs.mjs")],
+	["stats", () => import("./stats-CLg5RuDS.mjs")],
+	["gc", () => import("./gc-CX0KRfLG.mjs")],
+	["guide", () => import("./guide-CPmAG9me.mjs")]
 ]);
 const pkg = JSON.parse(readFileSync(new URL("../package.json", import.meta.url), "utf-8"));
 const program = new Command();

package/dist/collector-run.d.mts

@@ -15,6 +15,8 @@ interface Executor {
   runQuiet(cmd: string, opts?: ExecOptions): string | null;
   runFileQuiet(file: string, args?: string[], opts?: ExecOptions): string | null;
   spawn(cmd: string, args?: readonly string[], opts?: SpawnOptions): ChildProcess;
+  /** Absolute path of `name` on PATH, or null. Windows resolves PATH through PATHEXT. */
+  findExecutable(name: string): string | null;
 }
 //#endregion
 //#region src/collector/android.d.ts