stim 1.19.0 → 1.20.0

package/dist/native-android-lHzaew7r.mjs

@@ -0,0 +1,226 @@
+import { t as getExecutor } from "./exec-B81Qodjn.mjs";
+import { $ as settingValueAt } from "./settings-Bbztm4oV.mjs";
+import { x as workspaceDir } from "./workspace-state-CSIFuuDa.mjs";
+import { T as findBuildTool, o as androidHome } from "./android-BsYNR81W.mjs";
+import { i as skippedMissReason } from "./miss-reason-BPAzZS0r.mjs";
+import { o as resolveCcache } from "./ccache-CjHQ5F8g.mjs";
+import { a as buildGradle, r as androidSdkRefusal } from "./gradle-C2OEKCCI.mjs";
+import { n as androidToolchain } from "./toolchain-DqyDXs30.mjs";
+import { i as nativeGradleTransfer, t as gradleOffloadInputs } from "./native-gradle-inputs-BQnIdAlL.mjs";
+import { n as androidProcessRuntime } from "./launch-DxH0THLP.mjs";
+import { existsSync, readFileSync, statSync } from "node:fs";
+import { isAbsolute, join } from "node:path";
+import { fileURLToPath } from "node:url";
+//#region src/integrations/native-android.ts
+const CACHE_LIMIT = "Native Gradle inputs can include arbitrary external files and plugins; Stim artifact caching is unavailable. Offload requires a complete android.offloadInputs declaration. Gradle still owns incremental and task-cache reuse.";
+const MODEL_LIMIT = "Native Android requires AGP with androidComponents, one application module and configuration-on-demand disabled. Gradle resolves the exact variant and APK outputs during the build.";
+function refusal(reason) {
+	return {
+		code: "STIM_BUILD_FAILED",
+		reason,
+		remedy: "Select one signed standalone APK for the requested variant and target ABI in the Android application module, then retry. Stim does not sign APKs or install split APK sets."
+	};
+}
+function selectNativeApk(value, variant, abi) {
+	const model = value;
+	if (!model || model.schema !== 1 || typeof model.module !== "string" || !model.module.startsWith(":") || model.variant !== variant || typeof model.applicationId !== "string" || !/^[A-Za-z_][\w]*(?:\.[A-Za-z_][\w]*)+$/.test(model.applicationId) || typeof model.sdkDirectory !== "string" || !isAbsolute(model.sdkDirectory) || !Array.isArray(model.elements) || !model.elements.every((element) => element && typeof element.path === "string" && isAbsolute(element.path) && element.path.endsWith(".apk") && Array.isArray(element.filters) && element.filters.every((filter) => filter && typeof filter.type === "string" && typeof filter.value === "string"))) return refusal("Gradle did not export a valid model for the requested native Android variant.");
+	const universal = model.elements.filter((element) => element.filters.length === 0);
+	const candidates = universal.length ? universal : model.elements.filter((element) => abi !== null && element.filters.length === 1 && element.filters[0].type === "ABI" && element.filters[0].value === abi);
+	if (candidates.length !== 1) return refusal(`Native variant "${variant}" has ${candidates.length} installable APK candidates for ${abi ?? "an unspecified ABI"}. Density splits and ambiguous output sets are unsupported.`);
+	return {
+		apkPath: candidates[0].path,
+		androidPackage: model.applicationId
+	};
+}
+async function locateNativeApk(modelFile, variant, abi) {
+	let value;
+	try {
+		value = JSON.parse(readFileSync(modelFile, "utf8"));
+	} catch {
+		return refusal("Gradle succeeded without exporting the native Android APK model.");
+	}
+	const located = selectNativeApk(value, variant, abi);
+	if ("code" in located) return located;
+	try {
+		if (!statSync(located.apkPath).isFile()) return refusal("The APK selected by Gradle is not a file.");
+	} catch {
+		return refusal("The APK selected by Gradle does not exist.");
+	}
+	const signer = findBuildTool(["apksigner"], { home: value.sdkDirectory });
+	if (!signer) return refusal("No Android SDK apksigner is available to verify the native APK signature.");
+	try {
+		await getExecutor().runFileAsync(signer.path, ["verify", located.apkPath], { timeoutMs: 3e4 });
+	} catch (error) {
+		return refusal(`The native APK signature could not be verified: ${error.message}`);
+	}
+	return located;
+}
+function nativeAndroidProject(root) {
+	return {
+		isExpo: false,
+		packageRemedy: "Check the applicationId reported by AGP for the selected application variant.",
+		appIds: () => ({
+			bundleId: null,
+			androidPackage: null
+		}),
+		variantProblem: () => null,
+		targets: [
+			"emulator",
+			"physical",
+			"hosted"
+		],
+		eas: false,
+		runtimeKind: () => "process",
+		plan: async () => ({ refusal: {
+			code: "STIM_BAD_ARG",
+			message: `${MODEL_LIMIT} --plan does not execute Gradle. ${CACHE_LIMIT}`,
+			remedy: "Run `stim android` with an exact --variant to resolve and build the native app."
+		} }),
+		runtime: ({ phase }) => androidProcessRuntime(async () => {
+			phase("metro", "skipped (native process)");
+			return {
+				ok: true,
+				prepared: { metroPort: null }
+			};
+		}),
+		artifact: ({ writer, buildPlan, target, out, estimates, settings }) => {
+			const variant = buildPlan.variant ?? "debug";
+			const inputs = settingValueAt(settings, "android.offloadInputs");
+			let transfer = null;
+			const modelFile = join(workspaceDir(root), "gradle-build", `native-apk-${encodeURIComponent(variant)}.json`);
+			return {
+				identity: async () => ({ cacheIneligible: CACHE_LIMIT }),
+				cache: () => {
+					throw new Error(CACHE_LIMIT);
+				},
+				prepare: async () => {},
+				reconcile: async () => ({
+					identity: null,
+					rekeyedBy: [],
+					cacheRefusal: null
+				}),
+				validate: async () => null,
+				materialize: async () => null,
+				explain: () => ({
+					reason: skippedMissReason(CACHE_LIMIT),
+					diff: null
+				}),
+				untrackedLine: () => null,
+				legacyCache: null,
+				offload: {
+					supportsUncachedArtifacts: true,
+					get unsupported() {
+						if (buildPlan.cas) return "Apple Clang CAS builds build here";
+						try {
+							gradleOffloadInputs(inputs);
+							return null;
+						} catch (error) {
+							return error.message;
+						}
+					},
+					target: () => {
+						transfer = nativeGradleTransfer(root, inputs);
+						return {
+							platform: "android",
+							native: "gradle",
+							local: androidToolchain(),
+							requires: {
+								ndk: null,
+								buildTools: null,
+								compileSdk: null
+							}
+						};
+					},
+					get request() {
+						if (!transfer) throw new Error("Native Gradle offload needs a declared source inventory.");
+						return {
+							platform: "android",
+							isExpo: false,
+							native: {
+								provider: "gradle",
+								transfer
+							},
+							android: {
+								variant,
+								abi: target.abi,
+								gradleBuildCache: buildPlan.gradleBuildCache,
+								pch: buildPlan.pch,
+								compilerCache: buildPlan.compilerCache === "none" ? "none" : "ccache"
+							}
+						};
+					},
+					unchanged: async () => transfer !== null && nativeGradleTransfer(root, inputs).digest === transfer.digest
+				},
+				compile: async () => {
+					const script = ["../shim/native-android.gradle", "../../shim/native-android.gradle"].map((path) => fileURLToPath(new URL(path, import.meta.url))).find(existsSync);
+					if (!script) throw new Error("Stim installation is missing shim/native-android.gradle.");
+					return buildGradle({
+						root,
+						logWriter: writer,
+						variant,
+						project: {
+							directory: root,
+							gradlew: join(root, process.platform === "win32" ? "gradlew.bat" : "gradlew"),
+							module: ":",
+							outputsDir: root
+						},
+						task: ":stimExportAndroidApk",
+						projectArgs: [
+							"--init-script",
+							script,
+							`-Pstim.native.variant=${variant}`,
+							`-Pstim.native.model=${modelFile}`
+						],
+						locate: () => locateNativeApk(modelFile, variant, target.abi)
+					}, {
+						estimateMs: estimates().coldBuildMs,
+						ccache: buildPlan.compilerCache === "ccache" ? resolveCcache({
+							root,
+							onNote: out
+						}) : null,
+						cas: buildPlan.cas,
+						buildCache: buildPlan.gradleBuildCache,
+						pch: buildPlan.pch,
+						compilerCacheDisabled: buildPlan.compilerCache === "none"
+					});
+				}
+			};
+		}
+	};
+}
+function nativeAndroidDoctor(root) {
+	return { inspect: () => {
+		const sdkPath = androidHome();
+		const sdk = androidSdkRefusal({
+			sdkPath,
+			sdkExists: existsSync(sdkPath),
+			hasLocalProperties: existsSync(join(root, "local.properties")),
+			localPropertiesPath: "local.properties"
+		});
+		const wrapper = join(root, process.platform === "win32" ? "gradlew.bat" : "gradlew");
+		return [
+			{
+				level: "note",
+				title: "Native Android Gradle project",
+				detail: `${MODEL_LIMIT} ${CACHE_LIMIT} Metro and EAS are unsupported; local, physical and hosted targets use native process readiness.`,
+				fix: null
+			},
+			...sdk ? [{
+				level: "cost",
+				code: "android-sdk-missing",
+				title: "No Android SDK was found",
+				detail: sdk.reason,
+				fix: sdk.remedy
+			}] : [],
+			...!existsSync(wrapper) ? [{
+				level: "cost",
+				code: "android-wrapper-missing",
+				title: "The Gradle wrapper for this host is missing",
+				detail: wrapper,
+				fix: "Restore the project Gradle wrapper."
+			}] : []
+		];
+	} };
+}
+//#endregion
+export { nativeAndroidDoctor, nativeAndroidProject };

package/dist/native-gradle-inputs-BQnIdAlL.mjs

@@ -0,0 +1,356 @@
+import { t as getExecutor } from "./exec-B81Qodjn.mjs";
+import { existsSync, lstatSync, readFileSync, readdirSync, readlinkSync, realpathSync } from "node:fs";
+import { basename, dirname, isAbsolute, join, relative, resolve, sep } from "node:path";
+import { createHash } from "node:crypto";
+//#region src/offload/manifest.ts
+function manifestDigest(entries) {
+	const hash = createHash("sha256");
+	for (const entry of entries.toSorted((a, b) => a.path < b.path ? -1 : a.path > b.path ? 1 : 0)) hash.update(`${entry.path}\0${entry.kind}\0${entry.sha256}\n`);
+	return hash.digest("hex");
+}
+//#endregion
+//#region src/integrations/native-inputs.ts
+var NativeInputError = class extends Error {};
+function fingerprintNativeInputs(inputs, { excluded = [], ignoredDirectoryMarkers = [], parameters }) {
+	const exclusions = excluded.map((path) => resolve(path));
+	const directoryMarkers = new Set(ignoredDirectoryMarkers.map((path) => resolve(path)));
+	const entries = [];
+	const names = /* @__PURE__ */ new Set();
+	const isExcluded = (path) => exclusions.some((output) => path === output || path.startsWith(`${output}${sep}`));
+	let admit;
+	const record = (path, kind, content = "") => {
+		entries.push({
+			path,
+			kind,
+			sha256: createHash("sha256").update(content).digest("hex")
+		});
+	};
+	const walk = (absolute, logical, ancestors, optional = false, relative = null) => {
+		let stat;
+		try {
+			stat = lstatSync(absolute);
+		} catch (error) {
+			if (optional && error.code === "ENOENT") {
+				record(logical, "absent");
+				return;
+			}
+			throw error;
+		}
+		if (stat.isSymbolicLink()) {
+			const target = readlinkSync(absolute);
+			const resolved = resolve(dirname(absolute), target);
+			if (isExcluded(resolved)) throw new NativeInputError(`Native input ${logical} links into an excluded output.`);
+			if (ancestors.has(absolute)) throw new NativeInputError(`Native input ${logical} contains a link cycle.`);
+			record(logical, "link", target);
+			walk(resolved, `${logical}/@target`, /* @__PURE__ */ new Set([...ancestors, absolute]));
+		} else if (stat.isDirectory()) {
+			const canonical = realpathSync(absolute);
+			if (ancestors.has(canonical)) throw new NativeInputError(`Native input ${logical} contains a directory cycle.`);
+			if (!directoryMarkers.has(absolute)) record(logical, "directory");
+			const next = /* @__PURE__ */ new Set([...ancestors, canonical]);
+			for (const name of readdirSync(absolute).toSorted()) {
+				const child = join(absolute, name);
+				const childRelative = relative === null ? null : relative ? `${relative}/${name}` : name;
+				if (isExcluded(child) || childRelative !== null && admit && !admit(childRelative)) continue;
+				walk(child, `${logical}/${name}`, next, false, childRelative);
+			}
+		} else if (stat.isFile()) record(logical, `file:${stat.mode & 73}`, readFileSync(absolute));
+		else throw new NativeInputError(`Native input ${logical} is not a file, directory or symbolic link.`);
+	};
+	try {
+		for (const input of inputs) {
+			if (!input.name || names.has(input.name)) throw new NativeInputError("Native input names must be unique.");
+			names.add(input.name);
+			const path = resolve(input.path);
+			if (isExcluded(path)) throw new NativeInputError(`Native input ${input.name} is also an excluded output.`);
+			admit = input.admit;
+			walk(path, input.name, /* @__PURE__ */ new Set(), input.optional, "");
+		}
+	} catch (error) {
+		if (error instanceof NativeInputError) throw error;
+		throw new NativeInputError(`Could not read native build inputs: ${error.message}`, { cause: error });
+	}
+	const sorted = entries.toSorted((a, b) => a.path < b.path ? -1 : a.path > b.path ? 1 : 0);
+	return {
+		hash: createHash("sha256").update("stim-native-inputs-v1\0").update(JSON.stringify(parameters)).update("\0").update(manifestDigest(sorted)).digest("hex"),
+		entries: sorted,
+		parameters
+	};
+}
+//#endregion
+//#region src/offload/native-source.ts
+function* repositoryInputs(snapshot) {
+	const links = snapshot.entries.filter((entry) => entry.kind === "link").map((entry) => `${entry.path}/@target`);
+	for (const entry of snapshot.entries) {
+		if (entry.path === "repository") continue;
+		if (!entry.path.startsWith("repository/")) throw new Error("Native offload requires every input to be inside the repository.");
+		if (links.some((link) => entry.path === link || entry.path.startsWith(`${link}/`))) continue;
+		yield {
+			entry,
+			path: entry.path.slice(11)
+		};
+	}
+}
+const absentInput = (path) => /* @__PURE__ */ new Error(`Native input ${path} is ignored or absent from the source transfer; it was not uploaded.`);
+/** Throws the same membership refusal as nativeTransferManifest, from the git-visible paths alone. */
+function checkNativeTransferMembership(snapshot, visible) {
+	for (const { entry, path } of repositoryInputs(snapshot)) {
+		if (entry.kind === "directory" || visible.has(path)) continue;
+		for (let index = path.indexOf("/"); index !== -1; index = path.indexOf("/", index + 1)) if (visible.has(path.slice(0, index))) throw new Error(`Native input ${path} is inside the git submodule ${path.slice(0, index)}; submodules are not transferred.`);
+		throw absentInput(path);
+	}
+}
+function nativeTransferManifest(root, snapshot, visible) {
+	const files = new Map(visible.map((file) => [file.path, file]));
+	root = realpathSync(root);
+	const selected = [];
+	const empty = createHash("sha256").update("").digest("hex");
+	for (const { entry, path } of repositoryInputs(snapshot)) {
+		if (entry.kind === "directory") {
+			selected.push({
+				path,
+				kind: "directory",
+				size: 0,
+				sha256: empty
+			});
+			continue;
+		}
+		const file = files.get(path);
+		if (!file) throw absentInput(path);
+		const kind = entry.kind === "file:0" ? "file" : entry.kind === "file:73" ? "exec" : entry.kind;
+		if (kind !== file.kind || entry.sha256 !== file.sha256) throw new Error(`Native input ${path} changed or has an unsupported executable mode.`);
+		selected.push(file);
+		if (kind === "link") {
+			const link = join(root, path);
+			const target = readlinkSync(link);
+			const destination = relative(root, realpathSync(resolve(dirname(link), target)));
+			if (isAbsolute(target) || isAbsolute(destination) || destination === ".." || destination.startsWith(`..${sep}`)) throw new Error(`Native input ${path} has a link that cannot be relocated inside the repository.`);
+		}
+	}
+	return selected.toSorted((a, b) => a.path.localeCompare(b.path));
+}
+function verifyNativeTransfer(root, files, digest, ignoredDirectoryMarkers = []) {
+	return manifestDigest(nativeTransferManifest(root, fingerprintNativeInputs([{
+		name: "repository",
+		path: root
+	}], {
+		excluded: [join(root, ".git")],
+		ignoredDirectoryMarkers,
+		parameters: null
+	}), files)) === digest;
+}
+/** The exact source a build needs: tracked and untracked, not ignored, as `git ls-files -co --exclude-standard`. */
+function sourceManifest(repoRoot, strict = false) {
+	const files = [];
+	for (const path of gitVisiblePaths(repoRoot)) {
+		const absolute = join(repoRoot, path);
+		let stat;
+		try {
+			stat = lstatSync(absolute);
+		} catch (error) {
+			if (strict && error.code !== "ENOENT") throw error;
+			continue;
+		}
+		if (stat.isSymbolicLink()) {
+			const target = Buffer.from(readlinkSync(absolute));
+			files.push({
+				path,
+				kind: "link",
+				size: target.length,
+				sha256: createHash("sha256").update(target).digest("hex")
+			});
+		} else if (stat.isFile()) {
+			const content = readFileSync(absolute);
+			files.push({
+				path,
+				kind: stat.mode & 73 ? "exec" : "file",
+				size: content.length,
+				sha256: createHash("sha256").update(content).digest("hex")
+			});
+		} else if (strict) throw new Error(`Native source ${path} is not a file or link; transfer submodule contents explicitly.`);
+	}
+	return files;
+}
+function gitVisiblePaths(repoRoot) {
+	const listed = getExecutor().runFile("git", [
+		"-C",
+		repoRoot,
+		"ls-files",
+		"-z",
+		"-co",
+		"--exclude-standard"
+	], {
+		untrimmed: true,
+		timeoutMs: 12e4
+	});
+	return new Set(listed.split("\0").filter(Boolean));
+}
+//#endregion
+//#region src/integrations/native-gradle-inputs.ts
+function containedPath(path) {
+	return typeof path === "string" && path.length > 0 && !path.includes("\\") && !path.includes(":") && !path.includes("\0") && !path.split("/").some((part) => !part || part === "." || part === ".." || part.toLowerCase() === ".git");
+}
+function gradleOffloadInputs(value) {
+	const input = value;
+	if (!input || typeof input !== "object" || input.complete !== true || Object.keys(input).some((key) => ![
+		"complete",
+		"ignored",
+		"outputs"
+	].includes(key)) || !Array.isArray(input.ignored) || !input.ignored.every(containedPath) || !Array.isArray(input.outputs) || !input.outputs.every(containedPath)) throw new Error("Native Gradle offload requires android.offloadInputs with complete: true, ignored: [exact repository-relative files], and outputs: [generated repository-relative directories].");
+	const ignored = [...new Set(input.ignored)].toSorted();
+	const outputs = [...new Set(input.outputs)].toSorted();
+	if (ignored.some((path) => path.split("/").at(-1) === "local.properties")) throw new Error("local.properties is machine-local; remove it from android.offloadInputs.ignored.");
+	if (outputs.some((path) => path.split("/").some((part) => part === ".gradle" || part === ".kotlin"))) throw new Error("Gradle project state is worker-owned and cannot be declared as a generated output.");
+	for (const output of outputs) if (outputs.some((other) => other !== output && output.startsWith(`${other}/`))) throw new Error(`Generated output ${output} is nested inside another output declaration.`);
+	return {
+		complete: true,
+		ignored,
+		outputs
+	};
+}
+const below = (path, directory) => path === directory || path.startsWith(`${directory}/`);
+function gradleStateDirectories(project) {
+	return [".gradle", ".kotlin"].map((name) => project ? `${project}/${name}` : name);
+}
+function requireRealParents(repository, path) {
+	const parts = path.split("/");
+	for (let index = 1; index < parts.length; index++) {
+		const parent = join(repository, ...parts.slice(0, index));
+		const stat = lstatSync(parent, { throwIfNoEntry: false });
+		if (stat && !stat.isDirectory()) throw new Error(`Native input ${path} has a non-directory parent.`);
+	}
+}
+function nativeGradleTransfer(root, value) {
+	const declaration = gradleOffloadInputs(value);
+	const repository = realpathSync(getExecutor().runFile("git", [
+		"-C",
+		root,
+		"rev-parse",
+		"--show-toplevel"
+	]));
+	const project = relative(repository, realpathSync(root)).split(sep).join("/");
+	if (project && !containedPath(project)) throw new Error("The native Gradle project leaves its repository.");
+	if (lstatSync(join(repository, project, "buildSrc"), { throwIfNoEntry: false })?.isDirectory()) throw new Error("Native Gradle offload does not support buildSrc: AGP does not report its build directories, so the worker cannot keep them.");
+	const state = gradleStateDirectories(project);
+	const files = new Map(sourceManifest(repository, true).map((file) => [file.path, file]));
+	for (const path of declaration.ignored) {
+		requireRealParents(repository, path);
+		const absolute = join(repository, path);
+		const stat = lstatSync(absolute);
+		if (!stat.isFile() && !stat.isSymbolicLink()) throw new Error(`Ignored native input ${path} must be an exact file or link, not a directory.`);
+		const content = stat.isSymbolicLink() ? Buffer.from(readlinkSync(absolute)) : readFileSync(absolute);
+		files.set(path, {
+			path,
+			kind: stat.isSymbolicLink() ? "link" : stat.mode & 73 ? "exec" : "file",
+			size: content.length,
+			sha256: createHash("sha256").update(content).digest("hex")
+		});
+	}
+	for (const file of files.values()) {
+		if (!containedPath(file.path)) throw new Error(`Native input ${file.path} is not a contained relative path.`);
+		requireRealParents(repository, file.path);
+		if (state.some((path) => below(file.path, path))) throw new Error("Gradle project state cannot be transferred as source.");
+		if (declaration.outputs.some((output) => below(file.path, output) || below(output, file.path))) throw new Error(`Native input ${file.path} overlaps a declared generated output.`);
+		if (file.path.split("/").at(-1) === "local.properties") {
+			if (file.kind === "link") throw new Error(`Native input ${file.path} is a machine-local properties link.`);
+			if (readFileSync(join(repository, file.path), "utf8").split(/\r?\n/).some((line) => line.trim() && !/^\s*[#!]/.test(line) && !/^\s*sdk\.dir\s*[:=].*[^\\]$/.test(line))) throw new Error(`Native input ${file.path} contains unsupported machine-local properties.`);
+			files.delete(file.path);
+			continue;
+		}
+	}
+	for (const file of files.values()) if (file.kind === "link") {
+		const absolute = join(repository, file.path);
+		const target = readlinkSync(absolute);
+		const resolved = realpathSync(resolve(dirname(absolute), target));
+		const destination = relative(repository, resolved).split(sep).join("/");
+		if (isAbsolute(target) || !containedPath(destination) || !files.has(destination)) throw new Error(`Native input ${file.path} links to a target outside the declared source inventory.`);
+	}
+	for (const output of declaration.outputs) {
+		requireRealParents(repository, output);
+		const stat = lstatSync(join(repository, output), { throwIfNoEntry: false });
+		if (stat && !stat.isDirectory()) throw new Error(`Generated output ${output} is not a real directory.`);
+		if (state.some((path) => below(output, path) || below(path, output))) throw new Error(`Generated output ${output} overlaps Gradle project state.`);
+	}
+	const empty = createHash("sha256").update("").digest("hex");
+	for (const path of files.keys()) {
+		const parts = path.split("/");
+		for (let index = 1; index < parts.length; index++) {
+			const directory = parts.slice(0, index).join("/");
+			files.set(directory, {
+				path: directory,
+				kind: "directory",
+				size: 0,
+				sha256: empty
+			});
+		}
+	}
+	const selected = [...files.values()].toSorted((a, b) => a.path.localeCompare(b.path));
+	return {
+		repository,
+		project,
+		declaration,
+		files: selected,
+		digest: manifestDigest(selected)
+	};
+}
+function canonicalParent(path) {
+	const missing = [];
+	while (!existsSync(path) && dirname(path) !== path) {
+		missing.unshift(basename(path));
+		path = dirname(path);
+	}
+	return join(realpathSync(path), ...missing);
+}
+function nativeGradleOutputs(repository, declaration, reported) {
+	if (!Array.isArray(reported) || !reported.every((path) => typeof path === "string" && isAbsolute(path))) throw new Error("AGP did not report the configured native Gradle build directories.");
+	const real = realpathSync(repository);
+	const reportedPaths = /* @__PURE__ */ new Set();
+	for (const absolute of reported) {
+		const resolved = resolve(absolute);
+		const canonical = join(canonicalParent(dirname(resolved)), basename(resolved));
+		const path = relative(real, canonical).split(sep).join("/");
+		if (!containedPath(path)) throw new Error("A Gradle build directory leaves the transferred repository.");
+		requireRealParents(repository, path);
+		const stat = lstatSync(join(repository, path), { throwIfNoEntry: false });
+		if (stat && !stat.isDirectory()) throw new Error(`Gradle build directory ${path} is not a real directory.`);
+		reportedPaths.add(path);
+	}
+	for (const output of declaration.outputs) if (!reportedPaths.has(output)) throw new Error(`Declared output ${output} was not reported by AGP.`);
+	for (const path of reportedPaths) if (lstatSync(join(repository, path), { throwIfNoEntry: false })?.isDirectory() && !declaration.outputs.some((output) => below(path, output))) throw new Error(`Gradle build directory ${path} is not declared; add it to android.offloadInputs.outputs.`);
+	return declaration.outputs.filter((path) => lstatSync(join(repository, path), { throwIfNoEntry: false })?.isDirectory());
+}
+function validateGradleManifest(project, declaration, files) {
+	gradleOffloadInputs(declaration);
+	if (project && !containedPath(project)) throw new Error("The native Gradle project leaves its repository.");
+	const excluded = [...declaration.outputs, ...gradleStateDirectories(project)];
+	for (const file of files) if (!containedPath(file.path) || excluded.some((path) => below(file.path, path) || file.kind !== "directory" && below(path, file.path))) throw new Error(`Native source ${file.path} overlaps worker outputs or leaves the repository.`);
+	for (const path of declaration.ignored) if (!files.some((file) => file.path === path && file.kind !== "directory")) throw new Error(`Declared ignored input ${path} is missing from the transfer.`);
+}
+function verifyGradleTransfer(repository, project, declaration, files, digest) {
+	validateGradleManifest(project, declaration, files);
+	const excluded = [...declaration.outputs, ...gradleStateDirectories(project)];
+	for (const path of excluded) {
+		requireRealParents(repository, path);
+		const stat = lstatSync(join(repository, path), { throwIfNoEntry: false });
+		if (stat && !stat.isDirectory()) throw new Error(`Worker output ${path} is not a real directory.`);
+	}
+	const markers = excluded.flatMap((path) => path.split("/").slice(0, -1).map((_, index) => join(repository, ...path.split("/").slice(0, index + 1))));
+	const snapshot = fingerprintNativeInputs([{
+		name: "repository",
+		path: repository
+	}], {
+		excluded: [join(repository, ".git"), ...excluded.map((path) => join(repository, path))],
+		ignoredDirectoryMarkers: markers.filter((path) => !files.some((file) => join(repository, file.path) === path)),
+		parameters: null
+	});
+	const known = new Set(files.map((file) => file.path));
+	for (const entry of snapshot.entries) {
+		if (!entry.path.startsWith("repository/") || entry.path.includes("/@target")) continue;
+		const parts = entry.path.slice(11).split("/");
+		const index = parts.findIndex((_, depth) => !known.has(parts.slice(0, depth + 1).join("/")));
+		if (index >= 0 && (index < parts.length - 1 || entry.kind === "directory")) throw new Error(`Native Gradle directory ${parts.slice(0, index + 1).join("/")} is outside the source transfer and not a declared output reported by AGP; such directories, for example, included builds or externalNativeBuild staging, are not supported for remote builds.`);
+	}
+	return manifestDigest(nativeTransferManifest(repository, snapshot, files)) === digest;
+}
+//#endregion
+export { validateGradleManifest as a, gitVisiblePaths as c, verifyNativeTransfer as d, NativeInputError as f, nativeGradleTransfer as i, nativeTransferManifest as l, manifestDigest as m, gradleStateDirectories as n, verifyGradleTransfer as o, fingerprintNativeInputs as p, nativeGradleOutputs as r, checkNativeTransferMembership as s, gradleOffloadInputs as t, sourceManifest as u };

package/dist/{native-runtime-BGxsbfny.mjs → native-runtime-BRmWL7ru.mjs}

@@ -1,15 +1,15 @@
-import { l as phaseLine } from "./command-output-Bt8ygHE7.mjs";
-import { r as readWorkspaceState$1, u as ensureWorkspaceStorage } from "./workspace-state-CR9X86xJ.mjs";
-import { x as metroPortSetting } from "./settings-CxgngUZk.mjs";
-import { u as resolveProjectMetro } from "./metro-DI2AjPF_.mjs";
-import { r as LAUNCH_UNVERIFIED, t as LAUNCH_BUNDLING } from "./launch-verify-DCveSE6d.mjs";
-import { c as startDevServer } from "./start-DtxthMfI.mjs";
+import { j as metroPortSetting } from "./settings-Bbztm4oV.mjs";
+import { p as ensureWorkspaceStorage, r as readWorkspaceState$1 } from "./workspace-state-CSIFuuDa.mjs";
+import { l as phaseLine } from "./command-output-BjPN99ZB.mjs";
+import { u as resolveProjectMetro } from "./metro-D_j9sN-B.mjs";
+import { c as startDevServer } from "./start-CdvcTaXr.mjs";
+import { r as LAUNCH_UNVERIFIED, t as LAUNCH_BUNDLING } from "./launch-verify-BzRdbuO1.mjs";
 import { readIdleStop } from "@stim-cli/core/state";
 import chalk from "chalk";
 //#region src/commands/native-runtime.ts
 const sleep = (ms) => new Promise((r) => setTimeout(r, ms));
-async function ensureDevServer({ root, port, settings, remote, note, resolve = resolveProjectMetro, start = startDevServer, readState = readWorkspaceState$1 }) {
-	const pin = metroPortSetting(root);
+async function ensureDevServer({ root, port, settings, settingsContext, remote, note, resolve = resolveProjectMetro, start = startDevServer, readState = readWorkspaceState$1 }) {
+	const pin = metroPortSetting(settings);
 	const canReuse = !pin.error && (pin.port === null || pin.port === port);
 	const held = port === null || !canReuse ? null : (await resolve(port, root)).metro;
 	if (port !== null && held) return {
@@ -24,6 +24,7 @@ async function ensureDevServer({ root, port, settings, remote, note, resolve = r
 	const result = await start({
 		root,
 		settings,
+		settingsContext,
 		remote,
 		out: note,
 		note