stim 1.20.2 → 1.22.0

package/dist/build-cache-Dv7RN200.mjs

@@ -0,0 +1,602 @@
+import { h as withDrainingCancellation, t as getExecutor } from "./exec-DEoAhcze.mjs";
+import { i as sharedBuildCache } from "./paths-DQtTgsBf.mjs";
+import { a as killOnAbort, c as gitQuiet, f as throwIfCancelled, o as git, r as childEnvironment } from "./operation-exec-BW0em61G.mjs";
+import { m as defaultAndroidLayout } from "./settings-C7O8A6ZI.mjs";
+import { r as register } from "./cache-manifest-DSeQjt-Q.mjs";
+import { createHash } from "node:crypto";
+import { existsSync, readFileSync, readdirSync, statSync } from "node:fs";
+import { join } from "node:path";
+import { artifactIn, buildCacheKey, resolveArtifact, storeArtifactAsync } from "@stim-cli/core";
+import { join as join$1, posix as posix$1, relative as relative$1, sep as sep$1 } from "path";
+import { existsSync as existsSync$1, mkdirSync as mkdirSync$1, readFileSync as readFileSync$1, readdirSync as readdirSync$1, realpathSync as realpathSync$1, rmSync as rmSync$1, statSync as statSync$1 } from "fs";
+import { writeFile } from "node:fs/promises";
+import { isDeepStrictEqual } from "util";
+import * as expoFingerprint from "@expo/fingerprint";
+import { loadConfigAsync } from "@expo/fingerprint/build/Config.js";
+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, layout = defaultAndroidLayout(root) } = {}) {
+	const modules = layout.custom ? [layout.moduleDir] : androidModuleDirs(root, { list }).map((m) => join(root, "android", m));
+	for (const moduleDir of modules) {
+		const base = join(moduleDir, "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, layout = defaultAndroidLayout(root), findDir = findGeneratedResDir, read = readAssetManifest } = {}) {
+	const dir = findDir(root, variant, { layout });
+	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/**"];
+const APP_ROOT_IOS_SKIPPED = /* @__PURE__ */ new Set([
+	"node_modules",
+	"Pods",
+	"build",
+	"android",
+	".git",
+	".DS_Store",
+	".stim.json"
+]);
+function gitIgnoredNames(projectRoot, names) {
+	if (names.length === 0) return /* @__PURE__ */ new Set();
+	const out = gitQuiet(projectRoot, [
+		"check-ignore",
+		"--",
+		...names
+	]);
+	return new Set(String(out ?? "").split("\n").map((line) => line.trim()).filter(Boolean));
+}
+/**
+* Sources and ignores that make an `ios.projectPath` outside `ios/` count the way
+* @expo/fingerprint's bare sourcer counts `ios/`. A project directory that is the
+* app itself cannot be told apart from the app's JavaScript, so every top-level
+* entry git tracks, except dependencies and build output, is hashed: a JS change
+* misses the cache instead of risking a stale native build.
+*/
+function iosProjectFingerprintOptions(projectRoot, iosProjectPath, { list = (dir) => readdirSync$1(dir), isDirectory = (path) => statSync$1(path).isDirectory(), ignored = gitIgnoredNames } = {}) {
+	if (iosProjectPath === "ios") return {};
+	const appRoot = iosProjectPath === ".";
+	const prefix = appRoot ? "" : `${iosProjectPath}/`;
+	const reasons = ["ios.projectPath"];
+	let extraSources = [{
+		type: "dir",
+		filePath: iosProjectPath,
+		reasons
+	}];
+	if (appRoot) {
+		const names = list(projectRoot).filter((name) => !APP_ROOT_IOS_SKIPPED.has(name) && !name.startsWith(".watchman-cookie-"));
+		const skip = ignored(projectRoot, names);
+		extraSources = names.filter((name) => !skip.has(name)).toSorted((a, b) => a.localeCompare(b)).map((filePath) => ({
+			type: isDirectory(join$1(projectRoot, filePath)) ? "dir" : "file",
+			filePath,
+			reasons
+		}));
+	}
+	return {
+		extraSources,
+		ignorePaths: [
+			`${prefix}Pods/**/*`,
+			`${prefix}build/**/*`,
+			`${prefix}.xcode.env.local`,
+			`${prefix}**/project.xcworkspace`,
+			`${prefix}*.xcworkspace/xcuserdata/**/*`
+		]
+	};
+}
+const ANDROID_ROOT_SOURCES = [
+	"settings.gradle",
+	"settings.gradle.kts",
+	"build.gradle",
+	"build.gradle.kts",
+	"gradle.properties",
+	"gradle"
+];
+function androidProjectFingerprintOptions(projectRoot, layout, exists = existsSync$1) {
+	if (!layout.custom) return {};
+	const reasons = ["android.gradleRoot"];
+	const extraSources = ANDROID_ROOT_SOURCES.filter((name) => exists(join$1(layout.gradleRoot, name))).map((name) => ({
+		type: name === "gradle" ? "dir" : "file",
+		filePath: posix$1.join(layout.gradleRootRelative, name),
+		reasons
+	}));
+	let appRoot = projectRoot;
+	try {
+		appRoot = realpathSync$1(projectRoot);
+	} catch {}
+	const fromApp = relative$1(appRoot, layout.moduleDir).split(sep$1).join("/");
+	if (fromApp === "android" || fromApp.startsWith("android/")) return fromApp === "android/app" ? { extraSources } : {
+		extraSources,
+		ignorePaths: [
+			"build",
+			".cxx",
+			".gradle"
+		].map((dir) => `${fromApp}/${dir}/**/*`)
+	};
+	const moduleRel = posix$1.join(layout.gradleRootRelative, ...layout.module.split(":").filter(Boolean));
+	extraSources.push({
+		type: "dir",
+		filePath: moduleRel,
+		reasons: ["android.module"]
+	});
+	return {
+		extraSources,
+		ignorePaths: [
+			"build",
+			".cxx",
+			".gradle"
+		].map((dir) => `${moduleRel}/${dir}/**/*`)
+	};
+}
+async function fingerprintProject(projectRoot, { platform, iosProjectPath = "ios", androidLayout = null, createFingerprint = expoFingerprint.createFingerprintAsync, debug = false } = {}) {
+	const platforms = platform && FINGERPRINT_PLATFORMS.has(platform) ? { platforms: [platform] } : void 0;
+	const ios = platform === "ios" ? iosProjectFingerprintOptions(projectRoot, iosProjectPath) : androidLayout?.custom ? androidProjectFingerprintOptions(projectRoot, androidLayout) : {};
+	if (ios.extraSources) ios.extraSources = [...(await loadConfigAsync(projectRoot, true))?.extraSources ?? [], ...ios.extraSources];
+	const result = await createFingerprint(projectRoot, {
+		...platforms,
+		...debug ? { debug } : {},
+		...ios.extraSources ? { extraSources: ios.extraSources } : {},
+		ignorePaths: [...DEFAULT_FINGERPRINT_IGNORES, ...ios.ignorePaths ?? []],
+		silent: true
+	});
+	const hash = result?.hash ?? null;
+	if (!hash) return null;
+	return {
+		hash,
+		sources: Array.isArray(result?.sources) ? result.sources : []
+	};
+}
+function registerOnce(root, registeredBy) {
+	try {
+		register({
+			dir: root,
+			registeredBy,
+			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));
+}
+async function storeBuild(platform, key, buildPath, rootOrOptions = {}) {
+	const options = typeof rootOrOptions === "string" ? { root: rootOrOptions } : rootOrOptions || {};
+	const root = options.root || sharedBuildCache();
+	const signal = options.signal ?? options.context?.signal;
+	const env = options.context?.env;
+	throwIfCancelled(signal, "build cache copy");
+	if (!buildPath || !existsSync$1(buildPath)) throw new Error(`No build to store at ${buildPath}`);
+	registerOnce(root, options.context?.cwd);
+	try {
+		return await withDrainingCancellation(options.context, signal, () => storeArtifactAsync(entryDir(platform, key, root), buildPath, {
+			signal,
+			runFile: (file, args) => getExecutor().runFileAsync(file, args, {
+				timeoutMs: "unbounded",
+				...env ? childEnvironment(env) : {},
+				onSpawn: killOnAbort(signal),
+				declareFor: options.context
+			}),
+			overwrite: Boolean(options.overwrite),
+			writeMetadata: async (staging) => {
+				if (Array.isArray(options.sources)) try {
+					await writeFile(join$1(staging, SOURCES_FILE), JSON.stringify(options.sources.map(withoutContents)));
+				} catch {}
+				if (options.assetManifest) try {
+					await writeFile(join$1(staging, ASSET_MANIFEST_FILE), JSON.stringify(options.assetManifest));
+				} catch {}
+			}
+		}));
+	} catch (error) {
+		throwIfCancelled(signal, "build cache copy");
+		throw error;
+	}
+}
+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, registeredBy) {
+	rmSync$1(dir, {
+		recursive: true,
+		force: true
+	});
+	mkdirSync$1(dir, { recursive: true });
+	try {
+		register({
+			dir,
+			registeredBy,
+			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, context, sources, assetManifest, resolve = resolveBuild, store = storeBuild } = {}) {
+	const stored = {
+		...context === void 0 ? {} : { context },
+		...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, signal }) => store(platform, key, sourcePath, {
+			...stored,
+			overwrite,
+			signal
+		})
+	};
+}
+function providerUploadOutcome(result, name, env) {
+	if (!result) return null;
+	const label = name || "the cache provider";
+	if (result.timedOut) return {
+		line: `${label} upload was cancelled after ${buildUploadTimeoutMs(env)}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 withoutContents(source) {
+	return source.type === "contents" ? {
+		...source,
+		contents: ""
+	} : source;
+}
+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 sourceReasons(source) {
+	const reasons = source?.reasons;
+	return Array.isArray(reasons) ? reasons.filter((reason) => typeof reason === "string") : [];
+}
+function diffItemChange(item) {
+	const o = item;
+	const [change, source] = o?.op === "added" ? ["added", o.addedSource] : o?.op === "removed" ? ["removed", o.removedSource] : ["changed", o?.afterSource ?? o?.beforeSource];
+	const name = sourceName(source);
+	return name === null ? null : {
+		name,
+		change,
+		reasons: sourceReasons(source)
+	};
+}
+function compareSourceLists(previous, current) {
+	const previousByName = /* @__PURE__ */ new Map();
+	for (const source of previous) {
+		const name = sourceName(source);
+		if (name !== null) previousByName.set(name, {
+			hash: source.hash ?? null,
+			reasons: sourceReasons(source)
+		});
+	}
+	const changes = [];
+	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 ?? null;
+		const before = previousByName.get(name);
+		if (!before) changes.push({
+			name,
+			change: "added",
+			reasons: sourceReasons(source)
+		});
+		else if (before.hash !== hash) changes.push({
+			name,
+			change: "changed",
+			reasons: sourceReasons(source)
+		});
+	}
+	for (const [name, before] of previousByName) if (!seen.has(name)) changes.push({
+		name,
+		change: "removed",
+		reasons: before.reasons
+	});
+	return changes;
+}
+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 changes = [];
+			const seen = /* @__PURE__ */ new Set();
+			for (const item of items) {
+				const change = diffItemChange(item);
+				if (change !== null && !seen.has(change.name)) {
+					seen.add(change.name);
+					changes.push(change);
+				}
+			}
+			return changes;
+		}
+	} catch {}
+	return compareSourceLists(previous, current.sources);
+}
+async function refingerprintAfterMutation({ projectRoot, platform, previousHash, iosProjectPath, androidLayout, fingerprint = fingerprintProject }) {
+	let computed = null;
+	try {
+		computed = await fingerprint(projectRoot, {
+			platform,
+			...iosProjectPath ? { iosProjectPath } : {},
+			...androidLayout ? { androidLayout } : {}
+		});
+	} catch {
+		return null;
+	}
+	if (!computed?.hash) return null;
+	return {
+		hash: computed.hash,
+		sources: computed.sources,
+		moved: computed.hash !== previousHash
+	};
+}
+const CONFIG_INPUT_REASONS = /* @__PURE__ */ new Set([
+	"expoConfig",
+	"expoConfigPlugins",
+	"expoConfigExternalFile"
+]);
+function writtenByBuild(name, platform) {
+	return name === platform || name.startsWith(`${platform}/`) || name.startsWith("node_modules/") || name.includes("/node_modules/");
+}
+const PREBUILD_WRITTEN_IDS = [["ios", "bundleIdentifier"], ["android", "package"]];
+function expoConfigContents(sources) {
+	const source = sources.find((s) => s.type === "contents" && s.id === "expoConfig");
+	if (source?.type !== "contents") return null;
+	try {
+		const parsed = JSON.parse(String(source.contents));
+		return parsed && typeof parsed === "object" ? parsed : null;
+	} catch {
+		return null;
+	}
+}
+function onlyPrebuildIdsAdded(before, after) {
+	const previous = expoConfigContents(before);
+	const current = expoConfigContents(after);
+	if (!previous || !current) return false;
+	const stripped = { ...current };
+	for (const [section, key] of PREBUILD_WRITTEN_IDS) {
+		const was = previous[section];
+		const now = stripped[section];
+		if (now?.[key] === void 0 || was?.[key] !== void 0) continue;
+		const rest = { ...now };
+		delete rest[key];
+		if (was === void 0 && Object.keys(rest).length === 0) delete stripped[section];
+		else stripped[section] = rest;
+	}
+	return isDeepStrictEqual(previous, stripped);
+}
+function configInputsChanged(before, after, { prebuildRan }) {
+	return compareSourceLists(before, after).filter((change) => change.reasons.some((reason) => CONFIG_INPUT_REASONS.has(reason))).filter((change) => !(prebuildRan && change.name === "expoConfig" && onlyPrebuildIdsAdded(before, after))).map((change) => change.name);
+}
+function inputsChangedDuringBuild({ platform, lookup, prebuildRan, compiled, current }) {
+	const names = new Set(configInputsChanged(lookup, current, { prebuildRan }));
+	for (const change of compareSourceLists(compiled, current)) if (!writtenByBuild(change.name, platform)) names.add(change.name);
+	return [...names];
+}
+function changedDuringBuildLine(changed) {
+	const shown = changed.slice(0, 3);
+	const more = changed.length > shown.length ? `, and ${changed.length - shown.length} more` : "";
+	return `${shown.join(", ")}${more} changed while the build ran, so the artifact may not match its key; the build will be installed but not cached`;
+}
+function untrackedNativeFiles({ projectRoot, iosProjectPath = "ios" }) {
+	let out;
+	try {
+		out = git(projectRoot, [
+			"ls-files",
+			"--others",
+			"--exclude-standard",
+			"--",
+			"ios",
+			"android",
+			...iosProjectPath !== "ios" ? [iosProjectPath] : []
+		]);
+	} 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
+export { compareAssetManifests as C, captureAssetManifest as S, storedAssetManifest as _, diffFingerprintSources as a, untrackedNativeFiles as b, fingerprintDiffRecord as c, prepareProviderDownloadDir as d, providerDownloadPath as f, storeBuild as g, resolveBuild as h, configInputsChanged as i, fingerprintProject as l, refingerprintAfterMutation as m, buildCacheKey as n, entryDir as o, providerUploadOutcome as p, changedDuringBuildLine as r, filesystemBuildCapability as s, artifactIn as t, inputsChangedDuringBuild as u, storedSources as v, readAssetManifest as w, assetDiffReason as x, untrackedMissLine as y };