@tangle-network/agent-runtime 0.105.0 → 0.106.1

package/dist/workspace-archive-BosQiotA.js

@@ -0,0 +1,575 @@
+import { A as verifyMaterializedWorkspace, C as assertNoGitIndirection, D as captureMaterializedWorkspace, E as candidateWorkspaceManifest, T as runCandidateGit, a as persistCandidateOutputArtifact, at as deepFreezeCandidate, ct as omitTopLevelDigest, k as verifyBytes, lt as sha256Bytes, nt as canonicalCandidateBytes, ot as embeddedCandidateArtifact, rt as canonicalCandidateDigest$1, st as immutableCandidateValue, w as readCandidateGitTreeFiles } from "./prepare-B53sPV7M.js";
+import { agentCandidateBundleSchema } from "@tangle-network/agent-interface";
+import { randomUUID } from "node:crypto";
+import { lstat, mkdir, mkdtemp, open, readFile, readdir, realpath, rename, rm, writeFile } from "node:fs/promises";
+import { constants } from "node:fs";
+import { dirname, isAbsolute, join, resolve, sep, win32 } from "node:path";
+import { tmpdir } from "node:os";
+import { isAnyArrayBuffer, isSharedArrayBuffer } from "node:util/types";
+import { extract, pack } from "tar-stream";
+//#region src/candidate-execution/bundle.ts
+/** Validate and content-address a candidate bundle before it crosses an approval boundary. */
+function sealAgentCandidateBundle(input) {
+	const digest = canonicalCandidateDigest$1(input);
+	const parsed = agentCandidateBundleSchema.parse({
+		...input,
+		digest
+	});
+	if (canonicalCandidateDigest$1(omitTopLevelDigest(parsed)) !== digest) throw new Error("candidate bundle changed while validating its canonical wire shape");
+	return immutableCandidateValue(parsed);
+}
+//#endregion
+//#region src/candidate-execution/workspace-archive.ts
+const archiveKind = "agent-candidate-workspace-archive";
+const workspaceEntryPrefix = "workspace/";
+const repositoryMetadataEntry = "metadata/repository.json";
+const repositoryBundleEntry = "metadata/repository.bundle";
+const fixedTarTime = /* @__PURE__ */ new Date(0);
+const defaultLimits = Object.freeze({
+	maxArchiveBytes: 512 * 1024 * 1024,
+	maxEmbeddedArtifactBytes: 1024 * 1024,
+	maxFiles: 5e4,
+	maxFileBytes: 128 * 1024 * 1024,
+	maxTotalFileBytes: 256 * 1024 * 1024,
+	maxPathBytes: 4096,
+	maxRepositoryBundleBytes: 128 * 1024 * 1024
+});
+/** Capture one exact regular-file workspace for immutable candidate execution. */
+async function captureAgentCandidateWorkspace(rootInput, options = {}) {
+	const root = resolve(rootInput);
+	const limits = workspaceLimits(options.limits);
+	const captured = options.includeRepository ? await captureRepository(root, limits) : await captureMaterializedWorkspace(root, { limits: {
+		maxFiles: limits.maxFiles,
+		maxFileBytes: limits.maxFileBytes,
+		maxTotalFileBytes: limits.maxTotalFileBytes
+	} });
+	assertWorkspaceFilesWithinLimits(captured.files, limits);
+	const repository = "repository" in captured ? captured.repository : void 0;
+	return captureWorkspaceFiles(captured.files, repository, limits, options.artifactPersistence);
+}
+/** Capture detached files returned by a remote executor into the standard archive. */
+async function captureAgentCandidateWorkspaceFiles(input, options = {}) {
+	const limits = workspaceLimits(options.limits);
+	return captureWorkspaceFiles(normalizeWorkspaceFiles(input, limits), void 0, limits, options.artifactPersistence);
+}
+async function captureWorkspaceFiles(files, repository, limits, artifactPersistence) {
+	const material = candidateWorkspaceManifest(files);
+	const manifest = canonicalCandidateBytes(material);
+	const archive = await encodeWorkspaceArchive(files, repository, limits.maxArchiveBytes);
+	if (!artifactPersistence && (manifest.byteLength > limits.maxEmbeddedArtifactBytes || archive.byteLength > limits.maxEmbeddedArtifactBytes)) throw new Error("candidate workspace artifacts exceed maxEmbeddedArtifactBytes; artifactPersistence is required");
+	const manifestArtifact = await captureWorkspaceArtifact("manifest", manifest, artifactPersistence);
+	const archiveArtifact = await captureWorkspaceArtifact("archive", archive, artifactPersistence);
+	const snapshot = deepFreezeCandidate({
+		kind: "agent-candidate-workspace-snapshot",
+		digest: canonicalCandidateDigest$1(material),
+		material,
+		manifest: manifestArtifact,
+		archive: archiveArtifact
+	});
+	return Object.freeze({
+		snapshot,
+		archive
+	});
+}
+async function captureWorkspaceArtifact(kind, bytes, persistence) {
+	if (!persistence) return embeddedCandidateArtifact(bytes);
+	if (!persistence.executionId.trim()) throw new Error("candidate workspace artifact persistence requires an executionId");
+	return persistCandidateOutputArtifact(persistence.outputArtifacts, {
+		executionId: persistence.executionId,
+		purpose: kind === "manifest" ? "candidate-workspace-manifest" : "candidate-workspace-archive",
+		bytes,
+		...persistence.signal ? { signal: persistence.signal } : {}
+	});
+}
+/** Create the standard bounded materializer for candidate execution ports. */
+function createAgentCandidateWorkspacePort(options = {}) {
+	const limits = workspaceLimits(options.limits);
+	return Object.freeze({ materialize: async ({ role, snapshot, archive, destination }) => {
+		await materializeAgentCandidateWorkspace({
+			role,
+			snapshot,
+			archive,
+			destination,
+			limits
+		});
+	} });
+}
+async function materializeAgentCandidateWorkspace(input) {
+	verifyBytes(input.archive, input.snapshot.archive.sha256, input.snapshot.archive.byteLength, "candidate workspace archive");
+	const decoded = await parseWorkspaceArchive(input.archive, input.limits);
+	if (decoded.repository && input.role !== "task") throw new Error("only task workspaces may carry a Git repository");
+	assertArchiveMatchesSnapshot(decoded.files, input.snapshot);
+	const destination = resolve(input.destination);
+	await prepareEmptyDestination(destination);
+	const staging = await mkdtemp(`${destination}.materializing-`);
+	try {
+		await writeWorkspaceFiles(staging, decoded.files);
+		if (decoded.repository) await materializeRepository(decoded.repository, staging);
+		await verifyMaterializedWorkspace(staging, input.snapshot.material, { ignoredProtectedRootEntries: decoded.repository ? [".git"] : [] });
+		await rename(staging, destination);
+	} catch (error) {
+		await rm(staging, {
+			recursive: true,
+			force: true
+		});
+		await rm(destination, {
+			recursive: true,
+			force: true
+		});
+		throw error;
+	}
+}
+async function captureRepository(root, limits) {
+	const stats = await lstat(root);
+	if (!stats.isDirectory() || stats.isSymbolicLink() || await realpath(root) !== root) throw new Error("candidate repository root must be a real directory");
+	if (resolve((await runCandidateGit(root, ["rev-parse", "--show-toplevel"])).stdout.toString("utf8").trim()) !== root) throw new Error("candidate repository capture must start at the Git worktree root");
+	const gitDir = resolve((await runCandidateGit(root, ["rev-parse", "--absolute-git-dir"])).stdout.toString("utf8").trim());
+	if (await realpath(gitDir) !== gitDir || gitDir.includes(":")) throw new Error("candidate repository Git object store has an unsupported path");
+	await assertNoGitIndirection(root, gitDir, "candidate repository");
+	const headCommit = (await runCandidateGit(root, ["rev-parse", "HEAD"])).stdout.toString("utf8").trim();
+	const headTree = (await runCandidateGit(root, ["rev-parse", "HEAD^{tree}"])).stdout.toString("utf8").trim();
+	assertGitObjectId(headCommit, "HEAD");
+	assertGitObjectId(headTree, "HEAD tree");
+	if (headCommit.length !== headTree.length) throw new Error("candidate repository HEAD and tree use different object formats");
+	const files = await readCandidateGitTreeFiles(root, headTree, {}, limits);
+	assertWorkspaceFilesWithinLimits(files, limits);
+	const reachableBytesText = (await runCandidateGit(root, [
+		"rev-list",
+		"--disk-usage",
+		"--objects",
+		"HEAD"
+	])).stdout.toString("utf8").trim();
+	const reachableBytes = Number(reachableBytesText);
+	if (!Number.isSafeInteger(reachableBytes) || reachableBytes < 0) throw new Error("candidate repository reachable size is invalid");
+	if (reachableBytes > limits.maxRepositoryBundleBytes) throw new Error("candidate repository exceeds maxRepositoryBundleBytes");
+	const temporary = await mkdtemp(join(tmpdir(), "agent-candidate-workspace-bundle-"));
+	const bundlePath = join(temporary, `${randomUUID()}.bundle`);
+	try {
+		await runCandidateGit(root, [
+			"bundle",
+			"create",
+			bundlePath,
+			"HEAD"
+		]);
+		const bundle = Uint8Array.from(await readFile(bundlePath));
+		if (bundle.byteLength > limits.maxRepositoryBundleBytes) throw new Error("candidate repository bundle exceeds maxRepositoryBundleBytes");
+		return {
+			files,
+			repository: {
+				headCommit,
+				headTree,
+				bundle: {
+					sha256: sha256Bytes(bundle),
+					byteLength: bundle.byteLength,
+					bytes: bundle
+				}
+			}
+		};
+	} finally {
+		await rm(temporary, {
+			recursive: true,
+			force: true
+		});
+	}
+}
+async function encodeWorkspaceArchive(files, repository, maxArchiveBytes) {
+	const archive = pack();
+	const output = collectStream(archive, maxArchiveBytes, "candidate workspace archive");
+	try {
+		await writeWorkspaceArchiveEntries(archive, files, repository);
+		archive.finalize();
+		return await output;
+	} catch (error) {
+		archive.destroy(error instanceof Error ? error : new Error(String(error)));
+		await output.catch(() => void 0);
+		throw error;
+	}
+}
+async function verifyCanonicalWorkspaceArchive(files, repository, expected, maxArchiveBytes) {
+	const archive = pack();
+	const comparison = streamEqualsBytes(archive, expected, maxArchiveBytes, "candidate workspace archive");
+	try {
+		await writeWorkspaceArchiveEntries(archive, files, repository);
+		archive.finalize();
+		if (!await comparison) throw new Error("candidate workspace tar is not canonical");
+	} catch (error) {
+		archive.destroy(error instanceof Error ? error : new Error(String(error)));
+		await comparison.catch(() => void 0);
+		throw error;
+	}
+}
+async function writeWorkspaceArchiveEntries(archive, files, repository) {
+	for (const file of files) await writeTarEntry(archive, `${workspaceEntryPrefix}${file.path}`, file.mode, file.bytes);
+	if (!repository) return;
+	const metadata = canonicalCandidateBytes({
+		kind: archiveKind,
+		headCommit: repository.headCommit,
+		headTree: repository.headTree,
+		bundle: {
+			sha256: repository.bundle.sha256,
+			byteLength: repository.bundle.byteLength
+		}
+	});
+	await writeTarEntry(archive, repositoryMetadataEntry, 384, metadata);
+	await writeTarEntry(archive, repositoryBundleEntry, 384, repository.bundle.bytes);
+}
+async function parseWorkspaceArchive(bytes, limits) {
+	if (bytes.byteLength > limits.maxArchiveBytes) throw new Error("candidate workspace archive exceeds maxArchiveBytes");
+	const parser = extract();
+	const files = [];
+	const observedEntryNames = /* @__PURE__ */ new Set();
+	const observedPaths = /* @__PURE__ */ new Set();
+	let totalBytes = 0;
+	let retainedEntryBytes = 0;
+	let previousPath;
+	let repositoryMetadata;
+	let repositoryBundle;
+	const decoded = (async () => {
+		for await (const entry of parser) {
+			const name = entry.header.name;
+			if (entry.header.type !== "file" || typeof name !== "string" || observedEntryNames.has(name)) throw new Error("candidate workspace tar contains an invalid entry");
+			observedEntryNames.add(name);
+			if (name.startsWith(workspaceEntryPrefix)) {
+				if (files.length >= limits.maxFiles) throw new Error("candidate workspace archive has an invalid file count");
+				const path = safeArchivePath(name.slice(10), limits.maxPathBytes);
+				if (!isWorkspaceFileMode(entry.header.mode)) throw new Error(`candidate workspace archive has an unsupported mode: ${path}`);
+				assertRetainedArchiveSize(bytes.byteLength, retainedEntryBytes, entry.header.size, limits);
+				const fileBytes = await readTarEntry(entry, limits.maxFileBytes, `workspace file ${path}`);
+				retainedEntryBytes += fileBytes.byteLength;
+				assertWorkspacePathOrder(path, previousPath, observedPaths, "candidate workspace archive paths must be unique and sorted");
+				previousPath = path;
+				if (fileBytes.byteLength > limits.maxTotalFileBytes - totalBytes) throw new Error("candidate workspace archive exceeds maxTotalFileBytes");
+				totalBytes += fileBytes.byteLength;
+				files.push({
+					path,
+					mode: entry.header.mode,
+					bytes: fileBytes
+				});
+			} else if (name === repositoryMetadataEntry) {
+				if (entry.header.mode !== 384 || repositoryMetadata) throw new Error("candidate workspace archive repository metadata is invalid");
+				assertRetainedArchiveSize(bytes.byteLength, retainedEntryBytes, entry.header.size, limits);
+				const metadataBytes = await readTarEntry(entry, limits.maxPathBytes, "candidate repository metadata");
+				retainedEntryBytes += metadataBytes.byteLength;
+				repositoryMetadata = parseRepositoryMetadata(metadataBytes, limits.maxRepositoryBundleBytes);
+			} else if (name === repositoryBundleEntry) {
+				if (entry.header.mode !== 384 || repositoryBundle) throw new Error("candidate workspace archive repository bundle is invalid");
+				assertRetainedArchiveSize(bytes.byteLength, retainedEntryBytes, entry.header.size, limits);
+				repositoryBundle = await readTarEntry(entry, limits.maxRepositoryBundleBytes, "candidate Git bundle");
+				retainedEntryBytes += repositoryBundle.byteLength;
+			} else throw new Error(`candidate workspace tar contains an unsupported entry: ${name}`);
+		}
+		if (Boolean(repositoryMetadata) !== Boolean(repositoryBundle)) throw new Error("candidate workspace archive repository evidence is incomplete");
+		const repository = repositoryMetadata && repositoryBundle ? repositoryFromTar(repositoryMetadata, repositoryBundle) : void 0;
+		return {
+			files,
+			...repository ? { repository } : {}
+		};
+	})();
+	parser.end(Buffer.from(bytes.buffer, bytes.byteOffset, bytes.byteLength));
+	const result = await decoded;
+	await verifyCanonicalWorkspaceArchive(result.files, result.repository, bytes, limits.maxArchiveBytes);
+	return result;
+}
+function assertRetainedArchiveSize(archiveBytes, retainedEntryBytes, entryBytes, limits) {
+	if (!Number.isSafeInteger(entryBytes) || entryBytes === void 0 || entryBytes < 0 || entryBytes > limits.maxArchiveBytes - archiveBytes - retainedEntryBytes) throw new Error("candidate workspace archive exceeds maxArchiveBytes while decoding");
+}
+function parseRepositoryMetadata(bytes, maxBundleBytes) {
+	let value;
+	try {
+		value = JSON.parse(new TextDecoder("utf-8", { fatal: true }).decode(bytes));
+	} catch (error) {
+		throw new Error("candidate workspace archive repository metadata is invalid", { cause: error });
+	}
+	if (!isRecord(value) || Object.keys(value).sort().join(",") !== "bundle,headCommit,headTree,kind" || value.kind !== archiveKind || typeof value.headCommit !== "string" || typeof value.headTree !== "string" || !isRecord(value.bundle) || Object.keys(value.bundle).sort().join(",") !== "byteLength,sha256" || typeof value.bundle.sha256 !== "string" || !/^sha256:[a-f0-9]{64}$/.test(value.bundle.sha256) || !Number.isSafeInteger(value.bundle.byteLength) || value.bundle.byteLength <= 0 || value.bundle.byteLength > maxBundleBytes) throw new Error("candidate workspace archive repository is invalid");
+	if (!Buffer.from(canonicalCandidateBytes(value)).equals(Buffer.from(bytes))) throw new Error("candidate workspace archive repository metadata is not canonical");
+	assertGitObjectId(value.headCommit, "repository HEAD");
+	assertGitObjectId(value.headTree, "repository HEAD tree");
+	if (value.headCommit.length !== value.headTree.length) throw new Error("candidate repository HEAD and tree use different object formats");
+	return {
+		kind: archiveKind,
+		headCommit: value.headCommit,
+		headTree: value.headTree,
+		bundle: {
+			sha256: value.bundle.sha256,
+			byteLength: value.bundle.byteLength
+		}
+	};
+}
+function repositoryFromTar(metadata, bundle) {
+	verifyBytes(bundle, metadata.bundle.sha256, metadata.bundle.byteLength, "candidate Git bundle");
+	return {
+		headCommit: metadata.headCommit,
+		headTree: metadata.headTree,
+		bundle: {
+			...metadata.bundle,
+			bytes: bundle
+		}
+	};
+}
+async function writeTarEntry(archive, name, mode, bytes) {
+	await new Promise((resolveEntry, rejectEntry) => {
+		archive.entry({
+			name,
+			mode,
+			uid: 0,
+			gid: 0,
+			size: bytes.byteLength,
+			mtime: fixedTarTime,
+			type: "file",
+			uname: "",
+			gname: ""
+		}, Buffer.from(bytes.buffer, bytes.byteOffset, bytes.byteLength), (error) => error ? rejectEntry(error) : resolveEntry());
+	});
+}
+async function readTarEntry(entry, maxBytes, label) {
+	const size = entry.header.size;
+	if (!Number.isSafeInteger(size) || size === void 0 || size < 0 || size > maxBytes) throw new Error(`${label} has an invalid tar size`);
+	const bytes = await collectStream(entry, maxBytes, label);
+	if (bytes.byteLength !== size) throw new Error(`${label} differs from its tar size`);
+	return bytes;
+}
+async function collectStream(stream, maxBytes, label) {
+	const chunks = [];
+	let totalBytes = 0;
+	for await (const chunk of stream) {
+		if (chunk.byteLength > maxBytes - totalBytes) {
+			const error = /* @__PURE__ */ new Error(`${label} exceeds its size limit`);
+			if ("destroy" in stream && typeof stream.destroy === "function") stream.destroy(error);
+			throw error;
+		}
+		const bytes = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk);
+		chunks.push(bytes);
+		totalBytes += bytes.byteLength;
+	}
+	return Buffer.concat(chunks, totalBytes);
+}
+async function streamEqualsBytes(stream, expected, maxBytes, label) {
+	const expectedBuffer = Buffer.from(expected.buffer, expected.byteOffset, expected.byteLength);
+	let equal = true;
+	let offset = 0;
+	for await (const chunk of stream) {
+		if (chunk.byteLength > maxBytes - offset) {
+			const error = /* @__PURE__ */ new Error(`${label} exceeds its size limit`);
+			if ("destroy" in stream && typeof stream.destroy === "function") stream.destroy(error);
+			throw error;
+		}
+		const observed = Buffer.from(chunk.buffer, chunk.byteOffset, chunk.byteLength);
+		if (offset + observed.byteLength > expectedBuffer.byteLength || !observed.equals(expectedBuffer.subarray(offset, offset + observed.byteLength))) equal = false;
+		offset += observed.byteLength;
+	}
+	return equal && offset === expectedBuffer.byteLength;
+}
+async function prepareEmptyDestination(destination) {
+	await mkdir(destination, {
+		recursive: true,
+		mode: 448
+	});
+	const stats = await lstat(destination);
+	if (!stats.isDirectory() || stats.isSymbolicLink() || await realpath(destination) !== destination) throw new Error("candidate workspace destination must be a real directory");
+	if ((await readdir(destination)).length > 0) throw new Error("candidate workspace destination must be empty");
+}
+async function writeWorkspaceFiles(destination, files) {
+	for (const file of files) {
+		const path = workspacePath(destination, file.path);
+		await mkdir(dirname(path), {
+			recursive: true,
+			mode: 448
+		});
+		const descriptor = await open(path, constants.O_WRONLY | constants.O_CREAT | constants.O_EXCL | (typeof constants.O_NOFOLLOW === "number" ? constants.O_NOFOLLOW : 0), 384);
+		try {
+			await descriptor.writeFile(file.bytes);
+			const stats = await descriptor.stat();
+			if (!stats.isFile() || stats.nlink !== 1) throw new Error(`candidate workspace file identity changed while writing: ${file.path}`);
+			await descriptor.chmod(file.mode);
+		} finally {
+			await descriptor.close();
+		}
+	}
+}
+async function materializeRepository(repository, destination) {
+	const temporary = await mkdtemp(join(tmpdir(), "agent-candidate-workspace-bundle-"));
+	const bundlePath = join(temporary, `${randomUUID()}.bundle`);
+	try {
+		await writeFile(bundlePath, repository.bundle.bytes, {
+			flag: "wx",
+			mode: 384
+		});
+		await runCandidateGit(destination, [
+			"init",
+			"--quiet",
+			"--initial-branch=candidate",
+			`--object-format=${repository.headCommit.length === 64 ? "sha256" : "sha1"}`
+		]);
+		await runCandidateGit(destination, [
+			"bundle",
+			"verify",
+			bundlePath
+		]);
+		await runCandidateGit(destination, [
+			"bundle",
+			"unbundle",
+			bundlePath
+		]);
+		if ((await runCandidateGit(destination, [
+			"cat-file",
+			"-t",
+			repository.headCommit
+		])).stdout.toString("utf8").trim() !== "commit") throw new Error("candidate repository HEAD is not a commit");
+		if ((await runCandidateGit(destination, ["rev-parse", `${repository.headCommit}^{tree}`])).stdout.toString("utf8").trim() !== repository.headTree) throw new Error("candidate repository bundle HEAD tree changed");
+		await runCandidateGit(destination, [
+			"update-ref",
+			"--no-deref",
+			"HEAD",
+			repository.headCommit
+		]);
+		await runCandidateGit(destination, ["read-tree", repository.headTree]);
+		if ((await runCandidateGit(destination, [
+			"status",
+			"--porcelain=v1",
+			"--untracked-files=all"
+		])).stdout.toString("utf8").trim()) throw new Error("candidate repository files do not exactly match HEAD");
+	} finally {
+		await rm(temporary, {
+			recursive: true,
+			force: true
+		});
+	}
+}
+function assertArchiveMatchesSnapshot(files, snapshot) {
+	const material = candidateWorkspaceManifest(files);
+	const materialBytes = canonicalCandidateBytes(material);
+	verifyBytes(materialBytes, snapshot.manifest.sha256, snapshot.manifest.byteLength, "candidate workspace manifest");
+	if (canonicalCandidateDigest$1(material) !== snapshot.digest || !Buffer.from(materialBytes).equals(Buffer.from(canonicalCandidateBytes(snapshot.material)))) throw new Error("candidate workspace archive does not match its snapshot manifest");
+}
+function assertWorkspaceFilesWithinLimits(files, limits) {
+	if (files.length > limits.maxFiles) throw new Error("candidate workspace exceeds maxFiles");
+	let totalBytes = 0;
+	let previousPath;
+	const observedPaths = /* @__PURE__ */ new Set();
+	for (const file of files) {
+		const path = safeArchivePath(file.path, limits.maxPathBytes);
+		assertWorkspacePathOrder(path, previousPath, observedPaths, "candidate workspace paths must be unique and sorted");
+		previousPath = path;
+		if (!isWorkspaceFileMode(file.mode)) throw new Error(`candidate workspace file has unsupported mode: ${path}`);
+		if (file.bytes.byteLength > limits.maxFileBytes) throw new Error(`candidate workspace file exceeds maxFileBytes: ${path}`);
+		totalBytes += file.bytes.byteLength;
+		if (totalBytes > limits.maxTotalFileBytes) throw new Error("candidate workspace exceeds maxTotalFileBytes");
+	}
+}
+function normalizeWorkspaceFiles(input, limits) {
+	if (!Array.isArray(input)) throw new Error("candidate workspace files must be an array");
+	const fileCount = input.length;
+	if (fileCount > limits.maxFiles) throw new Error("candidate workspace exceeds maxFiles");
+	let totalBytes = 0;
+	const files = [];
+	for (let index = 0; index < fileCount; index++) {
+		const inputFile = input[index];
+		if (!isRecord(inputFile) || Object.keys(inputFile).sort().join(",") !== "bytes,mode,path") throw new Error(`candidate workspace file ${index} is invalid`);
+		const descriptors = Object.getOwnPropertyDescriptors(inputFile);
+		if (!("value" in (descriptors.path ?? {})) || !("value" in (descriptors.mode ?? {})) || !("value" in (descriptors.bytes ?? {}))) throw new Error(`candidate workspace file ${index} must use fixed values`);
+		const path = safeArchivePath(descriptors.path?.value, limits.maxPathBytes);
+		const mode = descriptors.mode?.value;
+		const inputBytes = descriptors.bytes?.value;
+		if (!isWorkspaceFileMode(mode)) throw new Error(`candidate workspace file has unsupported mode: ${path}`);
+		const view = inspectWorkspaceBytes(inputBytes, path);
+		if (view.byteLength > limits.maxFileBytes) throw new Error(`candidate workspace file exceeds maxFileBytes: ${path}`);
+		if (view.byteLength > limits.maxTotalFileBytes - totalBytes) throw new Error("candidate workspace exceeds maxTotalFileBytes");
+		if (view.byteLength > Math.max(0, limits.maxArchiveBytes - 1024)) throw new Error("candidate workspace archive exceeds maxArchiveBytes");
+		totalBytes += view.byteLength;
+		files.push({
+			path,
+			mode,
+			bytes: detachWorkspaceBytes(view)
+		});
+	}
+	files.sort((left, right) => left.path < right.path ? -1 : left.path > right.path ? 1 : 0);
+	assertWorkspaceFilesWithinLimits(files, limits);
+	return files;
+}
+function isWorkspaceFileMode(value) {
+	return Number.isSafeInteger(value) && value >= 0 && value <= 511;
+}
+function workspaceLimits(overrides) {
+	const limits = {
+		...defaultLimits,
+		...overrides
+	};
+	for (const [name, value] of Object.entries(limits)) if (!Number.isSafeInteger(value) || value <= 0) throw new Error(`candidate workspace ${name} must be a positive safe integer`);
+	return Object.freeze(limits);
+}
+function safeArchivePath(value, maxPathBytes) {
+	if (typeof value !== "string" || !value || !isWellFormedUnicode(value) || Buffer.byteLength(value, "utf8") > maxPathBytes || isAbsolute(value) || win32.isAbsolute(value) || value.includes("\\") || value.includes("\0") || hasControlCharacter(value) || value.split("/").some((part) => !part || part === "." || part === "..") || [".git", ".sidecar"].includes(value.split("/")[0]?.toLowerCase() ?? "")) throw new Error(`candidate workspace archive contains an unsafe path: ${String(value)}`);
+	return value;
+}
+function assertWorkspacePathOrder(path, previousPath, observedPaths, errorMessage) {
+	if (previousPath !== void 0 && previousPath >= path) throw new Error(errorMessage);
+	for (let slash = path.indexOf("/"); slash !== -1; slash = path.indexOf("/", slash + 1)) if (observedPaths.has(path.slice(0, slash))) throw new Error(errorMessage);
+	observedPaths.add(path);
+}
+function inspectWorkspaceBytes(input, path) {
+	let buffer;
+	let byteOffset;
+	let byteLength;
+	try {
+		buffer = typedArrayBufferGetter.call(input);
+		byteOffset = typedArrayByteOffsetGetter.call(input);
+		byteLength = typedArrayByteLengthGetter.call(input);
+	} catch {
+		throw new Error(`candidate workspace file bytes are invalid: ${path}`);
+	}
+	if (isSharedArrayBuffer(buffer)) throw new Error(`candidate workspace file uses shared bytes: ${path}`);
+	if (!isAnyArrayBuffer(buffer)) throw new Error(`candidate workspace file bytes are invalid: ${path}`);
+	return {
+		buffer,
+		byteOffset,
+		byteLength
+	};
+}
+function detachWorkspaceBytes(input) {
+	const { buffer, byteOffset, byteLength } = input;
+	const copy = new Uint8Array(byteLength);
+	Uint8Array.prototype.set.call(copy, new Uint8Array(buffer, byteOffset, byteLength));
+	return copy;
+}
+function isWellFormedUnicode(value) {
+	for (let index = 0; index < value.length; index++) {
+		const code = value.charCodeAt(index);
+		if (code >= 55296 && code <= 56319) {
+			const next = value.charCodeAt(index + 1);
+			if (!(next >= 56320 && next <= 57343)) return false;
+			index++;
+		} else if (code >= 56320 && code <= 57343) return false;
+	}
+	return true;
+}
+function workspacePath(root, relativePath) {
+	const path = resolve(root, relativePath);
+	if (!path.startsWith(`${root}${sep}`)) throw new Error(`candidate workspace archive path escapes its destination: ${relativePath}`);
+	return path;
+}
+function assertGitObjectId(value, label) {
+	if (!/^(?:[a-f0-9]{40}|[a-f0-9]{64})$/.test(value)) throw new Error(`candidate repository ${label} is not a Git object id`);
+}
+function hasControlCharacter(value) {
+	for (let index = 0; index < value.length; index++) {
+		const code = value.charCodeAt(index);
+		if (code < 32 || code === 127) return true;
+	}
+	return false;
+}
+function isRecord(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function requireTypedArrayGetter(name) {
+	const typedArrayPrototype = Object.getPrototypeOf(Uint8Array.prototype);
+	const getter = Object.getOwnPropertyDescriptor(typedArrayPrototype, name)?.get;
+	if (!getter) throw new Error(`typed array intrinsic ${name} accessor is unavailable`);
+	return getter;
+}
+const typedArrayBufferGetter = requireTypedArrayGetter("buffer");
+const typedArrayByteOffsetGetter = requireTypedArrayGetter("byteOffset");
+const typedArrayByteLengthGetter = requireTypedArrayGetter("byteLength");
+//#endregion
+export { sealAgentCandidateBundle as i, captureAgentCandidateWorkspaceFiles as n, createAgentCandidateWorkspacePort as r, captureAgentCandidateWorkspace as t };
+
+//# sourceMappingURL=workspace-archive-BosQiotA.js.map