stim 1.20.2 → 1.21.0

package/dist/{native-gradle-inputs-BsLRrl7u.mjs → native-gradle-inputs-Bep9JcSF.mjs}

@@ -1,83 +1,9 @@
-import { t as git } from "./git-DDfFzkMm.mjs";
-import { existsSync, lstatSync, readFileSync, readdirSync, readlinkSync, realpathSync } from "node:fs";
-import { basename, dirname, isAbsolute, join, relative, resolve, sep } from "node:path";
+import { n as gitAsync } from "./git-C3iTsJaZ.mjs";
+import { n as fingerprintNativeInputs, r as manifestDigest } from "./native-inputs-TRTTTRxt.mjs";
 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
+import { createReadStream } from "node:fs";
+import { basename, dirname, isAbsolute, join, relative, resolve, sep } from "node:path";
+import { access, lstat, readFile, readlink, realpath } from "node:fs/promises";
 //#region src/offload/native-source.ts
 function* repositoryInputs(snapshot) {
 	const links = snapshot.entries.filter((entry) => entry.kind === "link").map((entry) => `${entry.path}/@target`);
@@ -100,12 +26,14 @@ function checkNativeTransferMembership(snapshot, visible) {
 		throw absentInput(path);
 	}
 }
-function nativeTransferManifest(root, snapshot, visible) {
+async function nativeTransferManifest(root, snapshot, visible, signal) {
 	const files = new Map(visible.map((file) => [file.path, file]));
-	root = realpathSync(root);
+	signal?.throwIfAborted();
+	root = await realpath(root);
 	const selected = [];
 	const empty = createHash("sha256").update("").digest("hex");
 	for (const { entry, path } of repositoryInputs(snapshot)) {
+		signal?.throwIfAborted();
 		if (entry.kind === "directory") {
 			selected.push({
 				path,
@@ -122,64 +50,82 @@ function nativeTransferManifest(root, snapshot, visible) {
 		selected.push(file);
 		if (kind === "link") {
 			const link = join(root, path);
-			const target = readlinkSync(link);
-			const destination = relative(root, realpathSync(resolve(dirname(link), target)));
+			const target = await readlink(link);
+			const destination = relative(root, await realpath(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([{
+async function verifyNativeTransfer(root, files, digest, ignoredDirectoryMarkers = []) {
+	const snapshot = await fingerprintNativeInputs([{
 		name: "repository",
 		path: root
 	}], {
 		excluded: [join(root, ".git")],
 		ignoredDirectoryMarkers,
 		parameters: null
-	}), files)) === digest;
+	});
+	return manifestDigest(await nativeTransferManifest(root, snapshot, files)) === digest;
+}
+/** SHA-256 and byte count of one regular file, streamed without blocking the caller. */
+async function nativeFileDigest(path, signal) {
+	const hash = createHash("sha256");
+	let size = 0;
+	try {
+		for await (const chunk of createReadStream(path, { signal })) {
+			hash.update(chunk);
+			size += chunk.length;
+		}
+	} finally {
+		signal?.throwIfAborted();
+	}
+	return {
+		size,
+		sha256: hash.digest("hex")
+	};
 }
 /** The exact source a build needs: tracked and untracked, not ignored, as `git ls-files -co --exclude-standard`. */
-function sourceManifest(repoRoot, strict = false) {
+async function sourceManifest(repoRoot, strict = false, signal) {
 	const files = [];
-	for (const path of gitVisiblePaths(repoRoot)) {
+	for (const path of await gitVisiblePaths(repoRoot, signal)) {
+		signal?.throwIfAborted();
 		const absolute = join(repoRoot, path);
 		let stat;
 		try {
-			stat = lstatSync(absolute);
+			stat = await lstat(absolute);
 		} catch (error) {
 			if (strict && error.code !== "ENOENT") throw error;
 			continue;
 		}
 		if (stat.isSymbolicLink()) {
-			const target = Buffer.from(readlinkSync(absolute));
+			const target = Buffer.from(await readlink(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.`);
+		} else if (stat.isFile()) files.push({
+			path,
+			kind: stat.mode & 73 ? "exec" : "file",
+			...await nativeFileDigest(absolute, signal)
+		});
+		else if (strict) throw new Error(`Native source ${path} is not a file or link; transfer submodule contents explicitly.`);
 	}
+	signal?.throwIfAborted();
 	return files;
 }
-function gitVisiblePaths(repoRoot) {
-	const listed = git(repoRoot, [
+async function gitVisiblePaths(repoRoot, signal) {
+	const listed = await gitAsync(repoRoot, [
 		"ls-files",
 		"-z",
 		"-co",
 		"--exclude-standard"
 	], {
 		untrimmed: true,
-		timeoutMs: 12e4
+		timeoutMs: 12e4,
+		signal
 	});
 	return new Set(listed.split("\0").filter(Boolean));
 }
@@ -210,57 +156,91 @@ const below = (path, directory) => path === directory || path.startsWith(`${dire
 function gradleStateDirectories(project) {
 	return [".gradle", ".kotlin"].map((name) => project ? `${project}/${name}` : name);
 }
-function requireRealParents(repository, path) {
+async function statIfPresent(path) {
+	try {
+		return await lstat(path);
+	} catch (error) {
+		if (error instanceof Error && "code" in error && error.code === "ENOENT") return null;
+		throw error;
+	}
+}
+async function requireRealParents(repository, path, signal) {
 	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 });
+		signal?.throwIfAborted();
+		const stat = await statIfPresent(join(repository, ...parts.slice(0, index)));
 		if (stat && !stat.isDirectory()) throw new Error(`Native input ${path} has a non-directory parent.`);
 	}
 }
-function nativeGradleTransfer(root, value) {
+async function nativeGradleTransfer(root, value, signal) {
+	return nativeGradleInventory(root, value, [], signal, true);
+}
+async function nativeGradleLocalSourceDigest(root, value, localFiles, signal) {
+	const { project, digest } = await nativeGradleInventory(root, value, localFiles, signal, false);
+	return createHash("sha256").update(JSON.stringify({
+		project,
+		digest
+	})).digest("hex");
+}
+async function nativeGradleInventory(root, value, localFiles, signal, transfer) {
+	signal?.throwIfAborted();
 	const declaration = gradleOffloadInputs(value);
-	const repository = realpathSync(git(root, ["rev-parse", "--show-toplevel"]));
-	const project = relative(repository, realpathSync(root)).split(sep).join("/");
+	const repository = await realpath(await gitAsync(root, ["rev-parse", "--show-toplevel"], { signal }));
+	const realRoot = await realpath(root);
+	const project = relative(repository, realRoot).split(sep).join("/");
+	const local = localFiles.map((path) => resolve(realRoot, relative(root, path)));
 	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.");
+	if (transfer && (await statIfPresent(join(repository, project, "buildSrc")))?.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]));
+	const files = new Map((await sourceManifest(repository, true, signal)).map((file) => [file.path, file]));
 	for (const path of declaration.ignored) {
-		requireRealParents(repository, path);
+		await requireRealParents(repository, path, signal);
 		const absolute = join(repository, path);
-		const stat = lstatSync(absolute);
+		const stat = await lstat(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, {
+		if (stat.isSymbolicLink()) {
+			const content = Buffer.from(await readlink(absolute));
+			files.set(path, {
+				path,
+				kind: "link",
+				size: content.length,
+				sha256: createHash("sha256").update(content).digest("hex")
+			});
+		} else files.set(path, {
 			path,
-			kind: stat.isSymbolicLink() ? "link" : stat.mode & 73 ? "exec" : "file",
-			size: content.length,
-			sha256: createHash("sha256").update(content).digest("hex")
+			kind: stat.mode & 73 ? "exec" : "file",
+			...await nativeFileDigest(absolute, signal)
 		});
 	}
 	for (const file of files.values()) {
+		if (local.includes(resolve(repository, file.path))) {
+			files.delete(file.path);
+			continue;
+		}
 		if (!containedPath(file.path)) throw new Error(`Native input ${file.path} is not a contained relative path.`);
-		requireRealParents(repository, file.path);
+		await requireRealParents(repository, file.path, signal);
 		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.`);
+			if ((await readFile(join(repository, file.path), {
+				encoding: "utf8",
+				signal
+			})).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 target = await readlink(absolute);
+		const resolved = await realpath(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 });
+		await requireRealParents(repository, output, signal);
+		const stat = await statIfPresent(join(repository, output));
 		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.`);
 	}
@@ -286,31 +266,37 @@ function nativeGradleTransfer(root, value) {
 		digest: manifestDigest(selected)
 	};
 }
-function canonicalParent(path) {
+async function canonicalParent(path) {
 	const missing = [];
-	while (!existsSync(path) && dirname(path) !== path) {
+	while (!await access(path).then(() => true, () => false) && dirname(path) !== path) {
 		missing.unshift(basename(path));
 		path = dirname(path);
 	}
-	return join(realpathSync(path), ...missing);
+	return join(await realpath(path), ...missing);
 }
-function nativeGradleOutputs(repository, declaration, reported) {
+async function nativeGradleOutputs(repository, declaration, reported, signal) {
+	signal?.throwIfAborted();
 	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 real = await realpath(repository);
 	const reportedPaths = /* @__PURE__ */ new Set();
 	for (const absolute of reported) {
 		const resolved = resolve(absolute);
-		const canonical = join(canonicalParent(dirname(resolved)), basename(resolved));
+		const canonical = join(await 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 });
+		await requireRealParents(repository, path, signal);
+		const stat = await statIfPresent(join(repository, path));
 		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());
+	for (const path of reportedPaths) if ((await statIfPresent(join(repository, path)))?.isDirectory() && !declaration.outputs.some((output) => below(path, output))) throw new Error(`Gradle build directory ${path} is not declared; add it to android.offloadInputs.outputs.`);
+	const outputs = [];
+	for (const path of declaration.outputs) {
+		signal?.throwIfAborted();
+		if ((await statIfPresent(join(repository, path)))?.isDirectory()) outputs.push(path);
+	}
+	return outputs;
 }
 function validateGradleManifest(project, declaration, files) {
 	gradleOffloadInputs(declaration);
@@ -319,22 +305,24 @@ function validateGradleManifest(project, declaration, files) {
 	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) {
+async function verifyGradleTransfer(repository, project, declaration, files, digest, signal) {
+	signal?.throwIfAborted();
 	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 });
+		await requireRealParents(repository, path, signal);
+		const stat = await statIfPresent(join(repository, path));
 		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([{
+	const snapshot = await 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
+		parameters: null,
+		signal
 	});
 	const known = new Set(files.map((file) => file.path));
 	for (const entry of snapshot.entries) {
@@ -343,7 +331,7 @@ function verifyGradleTransfer(repository, project, declaration, files, digest) {
 		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;
+	return manifestDigest(await nativeTransferManifest(repository, snapshot, files, signal)) === 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 };
+export { nativeGradleTransfer as a, checkNativeTransferMembership as c, sourceManifest as d, verifyNativeTransfer as f, nativeGradleOutputs as i, gitVisiblePaths as l, gradleStateDirectories as n, validateGradleManifest as o, nativeGradleLocalSourceDigest as r, verifyGradleTransfer as s, gradleOffloadInputs as t, nativeTransferManifest as u };

package/dist/native-inputs-TRTTTRxt.mjs

@@ -0,0 +1,91 @@
+import { createHash } from "node:crypto";
+import { createReadStream } from "node:fs";
+import { dirname, join, resolve, sep } from "node:path";
+import { lstat, readdir, readlink, realpath } from "node:fs/promises";
+//#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 {};
+async function fingerprintNativeInputs(inputs, { excluded = [], ignoredDirectoryMarkers = [], parameters, signal }) {
+	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 = async (absolute, logical, ancestors, optional = false, relative = null) => {
+		signal?.throwIfAborted();
+		let stat;
+		try {
+			stat = await lstat(absolute);
+		} catch (error) {
+			if (optional && error.code === "ENOENT") {
+				record(logical, "absent");
+				return;
+			}
+			throw error;
+		}
+		if (stat.isSymbolicLink()) {
+			const target = await readlink(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);
+			await walk(resolved, `${logical}/@target`, /* @__PURE__ */ new Set([...ancestors, absolute]));
+		} else if (stat.isDirectory()) {
+			const canonical = await realpath(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 (await readdir(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;
+				await walk(child, `${logical}/${name}`, next, false, childRelative);
+			}
+		} else if (stat.isFile()) {
+			const digest = createHash("sha256");
+			for await (const chunk of createReadStream(absolute, { signal })) digest.update(chunk);
+			entries.push({
+				path: logical,
+				kind: `file:${stat.mode & 73}`,
+				sha256: digest.digest("hex")
+			});
+		} 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;
+			await walk(path, input.name, /* @__PURE__ */ new Set(), input.optional, "");
+		}
+	} catch (error) {
+		signal?.throwIfAborted();
+		if (error instanceof NativeInputError) throw error;
+		throw new NativeInputError(`Could not read native build inputs: ${error.message}`, { cause: error });
+	}
+	signal?.throwIfAborted();
+	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
+export { fingerprintNativeInputs as n, manifestDigest as r, NativeInputError as t };