reverseport 0.0.0-stage → 1.2.0

package/dist/cli-runtime/UninstallFailure-1blyKXHE.js

@@ -0,0 +1,22 @@
+import { __esmMin } from "./rolldown-runtime-DXoylpqc.js";
+
+//#region dist/application/UninstallFailure.js
+var isUninstallFailure;
+function init_UninstallFailure() {
+	return (init_UninstallFailure = __esmMin((() => {
+		isUninstallFailure = (result) => {
+			const status = result.status;
+			switch (status) {
+				case "complete": return false;
+				case "failed": return true;
+				default: {
+					const exhaustive = status;
+					throw new TypeError(`Unhandled uninstall result status: ${String(exhaustive)}`);
+				}
+			}
+		};
+	})))();
+}
+
+//#endregion
+export { init_UninstallFailure, isUninstallFailure };

package/dist/cli-runtime/Update-DF55X_N2.js

@@ -0,0 +1,143 @@
+import { __esmMin, __exportAll } from "./rolldown-runtime-DXoylpqc.js";
+import { PRODUCT_IDENTITY, init_identity } from "./reconstructionObligationLedgerSchemas-dvp6PEnZ.js";
+import { init_UpdateFailure, isUpdateFailure } from "./UpdateFailure-BcFNxEZZ.js";
+import { gt, valid } from "semver";
+
+//#region dist/application/Update.js
+var Update_exports = /* @__PURE__ */ __exportAll({
+	isUpdateFailure: () => isUpdateFailure,
+	runUpdate: () => runUpdate,
+	updateInstallCommand: () => updateInstallCommand
+});
+var updateInstallCommand, versionCheckRemediation, runUpdate, runUpdateWorkflow;
+function init_Update() {
+	return (init_Update = __esmMin((() => {
+		init_identity();
+		init_UpdateFailure();
+		updateInstallCommand = (installation, version) => {
+			const release = `${PRODUCT_IDENTITY.packageName}@${version}`;
+			const manager = installation.manager;
+			switch (manager) {
+				case "npm": return [
+					"npm",
+					"install",
+					"--global",
+					"--ignore-scripts",
+					"--prefix",
+					installation.prefix,
+					release
+				];
+				case "bun": return [
+					"bun",
+					"add",
+					"--global",
+					"--ignore-scripts",
+					release
+				];
+				default: {
+					const exhaustive = manager;
+					throw new TypeError(`Unhandled installation manager: ${String(exhaustive)}`);
+				}
+			}
+		};
+		versionCheckRemediation = (release) => {
+			if (release.ok) {
+				return "REA received invalid version metadata. Check the installed version and npm registry, then rerun reverseport update.";
+			}
+			const failure = release.error;
+			const kind = failure.kind;
+			switch (kind) {
+				case "unsupported-package-manager": return failure.detail;
+				case "unavailable": return `REA could not resolve the latest release: ${failure.detail}. Retry reverseport update when registry access is available.`;
+				case "invalid-metadata": return `REA could not resolve the latest release: ${failure.detail}. Check the npm release metadata, then rerun reverseport update.`;
+				default: {
+					const exhaustive = kind;
+					throw new TypeError(`Unhandled release lookup failure: ${String(exhaustive)}`);
+				}
+			}
+		};
+		runUpdate = async (currentVersion, host, output = "human") => {
+			let result;
+			let primaryFailure;
+			let failed = false;
+			try {
+				result = await runUpdateWorkflow(currentVersion, host, output);
+			} catch (cause) {
+				failed = true;
+				primaryFailure = cause;
+			}
+			let cleanupFailure;
+			try {
+				cleanupFailure = await host.close?.();
+			} catch (cause) {
+				cleanupFailure = `Update resource cleanup failed: ${cause instanceof Error ? cause.message : String(cause)}`;
+			}
+			if (failed) {
+				if (cleanupFailure !== undefined) throw new AggregateError([primaryFailure, new Error(cleanupFailure)], "Update failed and its resource cleanup remains incomplete.", { cause: primaryFailure });
+				throw primaryFailure;
+			}
+			if (result === undefined) throw new Error("Update result was not produced.");
+			return cleanupFailure === undefined ? result : {
+				...result,
+				cleanupFailure
+			};
+		};
+		runUpdateWorkflow = async (currentVersion, host, output) => {
+			const installation = await host.installation();
+			const release = await host.latestVersion(installation);
+			const latestVersion = release.ok ? release.value : null;
+			const targetVersion = release.ok ? valid(release.value) : null;
+			if (!release.ok || valid(currentVersion) === null || targetVersion === null) return {
+				status: "failed",
+				currentVersion,
+				latestVersion,
+				reason: "version-check",
+				remediation: versionCheckRemediation(release)
+			};
+			if (!gt(targetVersion, currentVersion)) return {
+				status: "current",
+				currentVersion,
+				latestVersion: targetVersion,
+				installMethod: installation?.manager ?? "unknown"
+			};
+			if (installation === undefined) return {
+				status: "failed",
+				currentVersion,
+				latestVersion: targetVersion,
+				reason: "unknown-install-method",
+				remediation: "Update this installation with the package manager or source checkout that owns it. For a one-off latest invocation, use npx reverseport@latest."
+			};
+			const installed = await host.installVersion(installation, targetVersion, output);
+			if (!installed.ok) return {
+				status: "failed",
+				currentVersion,
+				latestVersion: targetVersion,
+				reason: "install",
+				remediation: `REA could not install ${targetVersion} in ${installation.manager === "npm" ? installation.prefix : installation.globalDirectory}: ${installed.error}. Repair this ${installation.manager} installation, then rerun reverseport update.`
+			};
+			const verified = await host.installedVersion(installation);
+			if (!verified.ok || verified.value !== targetVersion) return {
+				status: "failed",
+				currentVersion,
+				latestVersion: targetVersion,
+				reason: "verification",
+				...verified.ok ? { installedVersion: verified.value } : {},
+				remediation: `${installation.manager} completed, but REA could not verify ${targetVersion} in ${installation.packageRoot}: ${verified.ok ? `the executable reported ${verified.value}` : verified.error}. The installation may have changed; repair it before retrying.`
+			};
+			const maintenance = await host.planMaintenance(installation);
+			return {
+				status: "updated",
+				previousVersion: currentVersion,
+				latestVersion: targetVersion,
+				installedVersion: verified.value,
+				installMethod: installation.manager,
+				command: updateInstallCommand(installation, targetVersion),
+				maintenance,
+				remediation: maintenance.status === "planned" ? "REA is updated. Run the maintenance command to review and approve changes to existing REA integrations, then restart affected agents." : maintenance.status === "unavailable" ? "REA is updated. Integration maintenance could not be planned; inspect the maintenance diagnostic before changing configuration." : "REA is updated. Restart agents running this installation to load the new version."
+			};
+		};
+	})))();
+}
+
+//#endregion
+export { Update_exports, init_Update, updateInstallCommand };

package/dist/cli-runtime/UpdateFailure-BcFNxEZZ.js

@@ -0,0 +1,24 @@
+import { __esmMin } from "./rolldown-runtime-DXoylpqc.js";
+
+//#region dist/application/UpdateFailure.js
+var isUpdateFailure;
+function init_UpdateFailure() {
+	return (init_UpdateFailure = __esmMin((() => {
+		isUpdateFailure = (result) => {
+			if (result.cleanupFailure !== undefined) return true;
+			const status = result.status;
+			switch (status) {
+				case "current":
+				case "updated": return false;
+				case "failed": return true;
+				default: {
+					const exhaustive = status;
+					throw new TypeError(`Unhandled update result status: ${String(exhaustive)}`);
+				}
+			}
+		};
+	})))();
+}
+
+//#endregion
+export { init_UpdateFailure, isUpdateFailure };

package/dist/cli-runtime/WindowsBatchCommand-5gT-d7O4.js

@@ -0,0 +1,45 @@
+import { __esmMin } from "./rolldown-runtime-DXoylpqc.js";
+import { init_snapshotEnvironment, snapshotEnvironment } from "./snapshotEnvironment-B5Ai0mha.js";
+import { win32 } from "node:path";
+
+//#region dist/process/WindowsBatchCommand.js
+var WindowsBatchCommandError, isWindowsBatchFile, quoteWindowsBatchToken, windowsBatchCommand;
+function init_WindowsBatchCommand() {
+	return (init_WindowsBatchCommand = __esmMin((() => {
+		init_snapshotEnvironment();
+		WindowsBatchCommandError = class extends Error {
+			reason;
+			constructor(reason, message) {
+				super(message);
+				this.reason = reason;
+				this.name = "WindowsBatchCommandError";
+			}
+		};
+		isWindowsBatchFile = (command) => /\.(?:bat|cmd)$/iu.test(command);
+		quoteWindowsBatchToken = (value) => {
+			if (value.length === 0 || value.includes("\0") || value.includes("\r") || value.includes("\n") || /["%^!&|<>]/u.test(value)) throw new WindowsBatchCommandError("metacharacter", "Windows batch arguments cannot contain command-interpreter metacharacters");
+			return `"${value}"`;
+		};
+		windowsBatchCommand = (options) => {
+			const environment = snapshotEnvironment(options.environment, "win32");
+			const systemRoot = environment.SYSTEMROOT;
+			const comSpec = options.comSpec ?? environment.COMSPEC ?? (systemRoot === undefined ? "C:\\Windows\\System32\\cmd.exe" : win32.join(systemRoot, "System32", "cmd.exe"));
+			if (!win32.isAbsolute(comSpec) || win32.basename(comSpec).toLowerCase() !== "cmd.exe") throw new WindowsBatchCommandError("invalid_comspec", "Windows ComSpec must be an absolute cmd.exe path");
+			const tokens = [options.batchPath, ...options.arguments].map(quoteWindowsBatchToken);
+			return {
+				command: comSpec,
+				arguments: [
+					"/d",
+					"/e:on",
+					"/v:off",
+					"/s",
+					"/c",
+					`"${tokens.join(" ")}"`
+				]
+			};
+		};
+	})))();
+}
+
+//#endregion
+export { WindowsBatchCommandError, init_WindowsBatchCommand, isWindowsBatchFile, quoteWindowsBatchToken, windowsBatchCommand };

package/dist/cli-runtime/ZipArtifactReader-Db65WuM_.js

@@ -0,0 +1,380 @@
+import { __esmMin } from "./rolldown-runtime-DXoylpqc.js";
+import { compareUnicodeCodePoints, init_artifactIdentity, init_unicodeCodePointOrder, logicalPathNfc } from "./reconstructionObligationLedgerSchemas-dvp6PEnZ.js";
+import { ArtifactReaderFailure, copyArtifactEntry, init_ArtifactReader, sameArtifactEntry } from "./ArtifactReader-BXkffc1D.js";
+import { NonRegularFileReadError, OwnedFileHandle, RegularFileAdmissionFailure, init_OwnedFileHandle, init_RegularFile, openRegularFile, sameRegularFileState } from "./RegularFile-CL6meBxi.js";
+import { posix } from "node:path";
+import { once } from "node:events";
+import { PassThrough } from "node:stream";
+import { Reader, ZipReader } from "@zip.js/zip.js";
+
+//#region dist/filesystem/OwnedDirectoryHandle.js
+var OwnedDirectoryHandle;
+function init_OwnedDirectoryHandle() {
+	return (init_OwnedDirectoryHandle = __esmMin((() => {
+		OwnedDirectoryHandle = class {
+			handle;
+			#state = { kind: "open" };
+			constructor(handle) {
+				this.handle = handle;
+			}
+			close() {
+				if (this.#state.kind === "closed") return Promise.resolve();
+				if (this.#state.kind === "closing") return this.#state.attempt;
+				if (this.#state.kind === "failed") return Promise.reject(this.#state.cause);
+				const attempt = Promise.resolve().then(async () => {
+					try {
+						await this.handle.close();
+						this.#state = { kind: "closed" };
+					} catch (cause) {
+						this.#state = {
+							kind: "failed",
+							cause
+						};
+						throw cause;
+					}
+				});
+				this.#state = {
+					kind: "closing",
+					attempt
+				};
+				return attempt;
+			}
+		};
+	})))();
+}
+
+//#endregion
+//#region dist/artifacts/StreamBytes.js
+var streamChunkToBuffer;
+function init_StreamBytes() {
+	return (init_StreamBytes = __esmMin((() => {
+		streamChunkToBuffer = (value) => {
+			if (Buffer.isBuffer(value)) return value;
+			if (value instanceof Uint8Array) return Buffer.from(value);
+			if (typeof value === "string") return Buffer.from(value);
+			throw new TypeError("Readable stream emitted a non-byte chunk");
+		};
+	})))();
+}
+
+//#endregion
+//#region dist/artifacts/ArtifactPaths.js
+var DRIVE_OR_UNC, ENGLISH_UNICODE_CASE_NOTE, ENGLISH_UNICODE_CASE_INVENTORY_LIMITATION, DESTINATION_CASE_COLLISION_PREFIX, normalizeArtifactPath, ArtifactPathRegistry, emptyCaseNode, englishCaseFold, annotateEnglishUnicodeCaseCollisions, caseCollisionLimitation, destinationCaseCollisionMessage, englishUnicodeCaseCollisions, collisionsAlong;
+function init_ArtifactPaths() {
+	return (init_ArtifactPaths = __esmMin((() => {
+		init_artifactIdentity();
+		init_unicodeCodePointOrder();
+		init_ArtifactReader();
+		DRIVE_OR_UNC = /^(?:[A-Za-z]:|\\|\/\/)/u;
+		ENGLISH_UNICODE_CASE_NOTE = "This comparison is not a filesystem observation.";
+		ENGLISH_UNICODE_CASE_INVENTORY_LIMITATION = `Logical archive names collide under English (en-US) Unicode case folding; a case-insensitive destination cannot store both spellings. ${ENGLISH_UNICODE_CASE_NOTE}`;
+		DESTINATION_CASE_COLLISION_PREFIX = "Destination filesystem cannot store both ";
+		normalizeArtifactPath = (input) => {
+			if (input.includes("\0") || input.includes("\\") || input.startsWith("/") || DRIVE_OR_UNC.test(input)) throw new ArtifactReaderFailure("path", `Artifact path is absolute or unsafe: ${JSON.stringify(input)}`);
+			const normalized = logicalPathNfc(input).replace(/\/+$/u, "");
+			const parts = normalized.split("/");
+			if (normalized.length === 0 || parts.some((part) => part === "" || part === "." || part === "..") || posix.normalize(normalized) !== normalized) throw new ArtifactReaderFailure("path", `Artifact path is not normalized: ${JSON.stringify(input)}`);
+			return normalized;
+		};
+		ArtifactPathRegistry = class {
+			#root = {
+				kind: undefined,
+				children: new Map()
+			};
+			add(path, kind) {
+				const parts = path.split("/");
+				let node = this.#root;
+				for (const [index, part] of parts.entries()) {
+					if (node.kind !== undefined && node.kind !== "directory") throw new ArtifactReaderFailure("path", `Artifact prefix conflict: ${path}`);
+					let child = node.children.get(part);
+					if (child === undefined) {
+						child = {
+							kind: undefined,
+							children: new Map()
+						};
+						node.children.set(part, child);
+					}
+					node = child;
+					if (index === parts.length - 1) {
+						if (node.kind !== undefined) throw new ArtifactReaderFailure("path", `Artifact path collision: ${path}`);
+						if (kind !== "directory" && node.children.size > 0) throw new ArtifactReaderFailure("path", `Artifact prefix conflict: ${path}`);
+					}
+				}
+				node.kind = kind;
+			}
+		};
+		emptyCaseNode = () => ({
+			bySpelling: new Map(),
+			spellingsByFold: new Map(),
+			terminals: []
+		});
+		englishCaseFold = (part) => part.toLocaleLowerCase("en-US");
+		annotateEnglishUnicodeCaseCollisions = (occurrences) => {
+			const collisions = englishUnicodeCaseCollisions(occurrences.map(({ logical_path }) => logical_path));
+			if (collisions.size === 0) return undefined;
+			for (const occurrence of occurrences) for (const collision of collisions.get(occurrence.logical_path) ?? []) occurrence.limitations.push(caseCollisionLimitation(occurrence.logical_path, collision));
+			return ENGLISH_UNICODE_CASE_INVENTORY_LIMITATION;
+		};
+		caseCollisionLimitation = (path, { prefix, other, additional }) => {
+			const others = additional === 0 ? other : `${other} and ${String(additional)} other spelling${additional === 1 ? "" : "s"}`;
+			const subject = prefix === path ? `Logical path ${path} collides` : `Logical path ${path} is under ${prefix}, which collides`;
+			return `${subject} under English (en-US) Unicode case folding with ${others}; a case-insensitive destination cannot store both. ${ENGLISH_UNICODE_CASE_NOTE}`;
+		};
+		destinationCaseCollisionMessage = (requestedPath, existingNames) => {
+			const slash = requestedPath.lastIndexOf("/");
+			const segment = slash < 0 ? requestedPath : requestedPath.slice(slash + 1);
+			if (existingNames.includes(segment)) return undefined;
+			const folded = englishCaseFold(segment);
+			const existing = existingNames.filter((name) => englishCaseFold(name) === folded).sort(compareUnicodeCodePoints)[0];
+			if (existing === undefined) return undefined;
+			const parent = slash < 0 ? "" : requestedPath.slice(0, slash + 1);
+			return `${DESTINATION_CASE_COLLISION_PREFIX}${requestedPath} and ${parent}${existing}; inventory retains both logical names.`;
+		};
+		englishUnicodeCaseCollisions = (paths) => {
+			const root = emptyCaseNode();
+			for (const path of paths) {
+				if (path.length === 0 || path === ".") continue;
+				let node = root;
+				for (const part of path.split("/")) {
+					let child = node.bySpelling.get(part);
+					if (child === undefined) {
+						const folded = englishCaseFold(part);
+						const spellings = node.spellingsByFold.get(folded);
+						if (spellings === undefined) node.spellingsByFold.set(folded, [part]);
+						else spellings.push(part);
+						child = emptyCaseNode();
+						node.bySpelling.set(part, child);
+					}
+					node = child;
+				}
+				node.terminals.push(path);
+			}
+			const collisions = new Map();
+			const pending = [{
+				node: root,
+				prefix: undefined,
+				chain: undefined
+			}];
+			for (let item = pending.pop(); item !== undefined; item = pending.pop()) {
+				const { node, prefix, chain } = item;
+				if (chain !== undefined) for (const path of node.terminals) collisions.set(path, collisionsAlong(chain));
+				for (const spellings of node.spellingsByFold.values()) spellings.sort(compareUnicodeCodePoints);
+				for (const [spelling, child] of node.bySpelling) {
+					const childPrefix = prefix === undefined ? spelling : `${prefix}/${spelling}`;
+					const spellings = node.spellingsByFold.get(englishCaseFold(spelling)) ?? [];
+					const other = spellings[0] === spelling ? spellings[1] : spellings[0];
+					pending.push({
+						node: child,
+						prefix: childPrefix,
+						chain: other === undefined ? chain : {
+							collision: {
+								prefix: childPrefix,
+								other: prefix === undefined ? other : `${prefix}/${other}`,
+								additional: spellings.length - 2
+							},
+							parent: chain
+						}
+					});
+				}
+			}
+			return collisions;
+		};
+		collisionsAlong = (chain) => {
+			const collisions = [];
+			let link = chain;
+			while (link !== undefined) {
+				collisions.push(link.collision);
+				link = link.parent;
+			}
+			return collisions.reverse();
+		};
+	})))();
+}
+
+//#endregion
+//#region dist/artifacts/ZipArtifactReader.js
+var ZIP_UTF8_DECODER, NodeFileReader, ZipArtifactReader, projectZipEntry, decodeZipEntryText, zipEntryPath, decodeStrictZipUtf8, extractStream, isSymlink, abortIfNeeded, toError;
+function init_ZipArtifactReader() {
+	return (init_ZipArtifactReader = __esmMin((() => {
+		init_ArtifactReader();
+		init_OwnedFileHandle();
+		init_RegularFile();
+		ZIP_UTF8_DECODER = new TextDecoder("utf-8", {
+			fatal: true,
+			ignoreBOM: true
+		});
+		NodeFileReader = class extends Reader {
+			path;
+			maximumReadBytes;
+			admitted;
+			#handle;
+			#owner;
+			#initPromise;
+			#ownsHandle;
+			constructor(path, maximumReadBytes, admitted) {
+				super(path);
+				this.path = path;
+				this.maximumReadBytes = maximumReadBytes;
+				this.admitted = admitted;
+				this.#ownsHandle = admitted === undefined;
+			}
+			init() {
+				this.#initPromise ??= this.#initialize();
+				return this.#initPromise;
+			}
+			async #initialize() {
+				try {
+					const handle = this.admitted?.handle ?? await openRegularFile(this.path, { symlinks: "reject" });
+					this.#handle = handle;
+					if (this.#ownsHandle) this.#owner = new OwnedFileHandle(handle);
+				} catch (cause) {
+					if (cause instanceof RegularFileAdmissionFailure) {
+						this.#owner = cause.owner;
+						const primary = cause.cause instanceof NonRegularFileReadError ? new ArtifactReaderFailure("format", `ZIP source is not a regular file: ${this.path}`, { cause: cause.cause }) : cause.cause;
+						throw ArtifactReaderFailure.withCleanup(primary, ArtifactReaderFailure.cleanupObservation(cause.cleanupCause, this.path));
+					}
+					if (cause instanceof NonRegularFileReadError) throw new ArtifactReaderFailure("format", `ZIP source is not a regular file: ${this.path}`, { cause });
+					throw cause;
+				}
+				const metadata = await this.#handle.stat();
+				if (!metadata.isFile() || this.admitted !== undefined && !sameRegularFileState(this.admitted.initial, metadata)) throw new ArtifactReaderFailure("integrity", `ZIP source identity changed before reading: ${this.path}`);
+				this.size = metadata.size;
+			}
+			async readUint8Array(index, length) {
+				const handle = this.#handle;
+				if (handle === undefined) throw new Error("ZIP reader is not initialized");
+				const readBytes = Math.min(length, this.size - index);
+				if (this.maximumReadBytes !== undefined && readBytes > this.maximumReadBytes) throw new ArtifactReaderFailure("limit", `ZIP metadata read requires ${readBytes} bytes, exceeding the ${this.maximumReadBytes}-byte read budget`);
+				const bytes = Buffer.alloc(readBytes);
+				const read = await handle.read(bytes, 0, bytes.length, index);
+				return bytes.subarray(0, read.bytesRead);
+			}
+			async closeHandle() {
+				if (!this.#ownsHandle) return;
+				await this.#initPromise?.catch(() => undefined);
+				if (this.#owner === undefined) return;
+				await this.#owner.close();
+				this.#owner = undefined;
+				this.#handle = undefined;
+			}
+		};
+		ZipArtifactReader = class {
+			format;
+			#source;
+			#reader;
+			#entries = new Map();
+			/** Optionally bound each metadata read before allocating its backing buffer. */
+			constructor(path, format, maximumMetadataReadBytes, admitted) {
+				this.format = format;
+				this.#source = new NodeFileReader(path, maximumMetadataReadBytes, admitted);
+				this.#reader = new ZipReader(this.#source, {
+					checkSignature: true,
+					checkOverlappingEntry: true,
+					filenameValidation: "tolerant"
+				});
+			}
+			async *entries(signal) {
+				let index = 0;
+				for await (const entry of this.#reader.getEntriesGenerator({ decodeText: decodeZipEntryText })) {
+					abortIfNeeded(signal);
+					const metadata = projectZipEntry(entry, index++);
+					const stored = this.#entries.get(metadata.adapterKey);
+					if (stored !== undefined && !sameArtifactEntry(metadata, stored.metadata)) throw new ArtifactReaderFailure("integrity", `ZIP member identity changed during enumeration: ${entry.filename}`);
+					if (stored === undefined) this.#entries.set(metadata.adapterKey, {
+						source: entry,
+						metadata: copyArtifactEntry(metadata)
+					});
+					yield metadata;
+				}
+			}
+			open(entry, signal) {
+				abortIfNeeded(signal);
+				const stored = this.#entries.get(entry.adapterKey);
+				if (stored === undefined || !sameArtifactEntry(entry, stored.metadata)) return Promise.reject(new ArtifactReaderFailure("integrity", "ZIP entry metadata does not match this reader's inventory"));
+				const source = stored.source;
+				if (source.directory || isSymlink(source)) return Promise.reject(new ArtifactReaderFailure("format", "ZIP entry is not a regular file"));
+				if (source.encrypted) return Promise.reject(new ArtifactReaderFailure("unavailable", "Encrypted ZIP entry is unsupported"));
+				return Promise.resolve(extractStream(source, signal));
+			}
+			async close() {
+				await this.#reader.close().catch(() => undefined);
+				await this.#source.closeHandle();
+			}
+			provenance() {
+				return [];
+			}
+		};
+		projectZipEntry = (entry, index) => {
+			const symlink = isSymlink(entry);
+			return {
+				path: zipEntryPath(entry),
+				kind: entry.directory ? "directory" : symlink ? "symlink" : "file",
+				declaredSize: entry.directory ? null : entry.uncompressedSize,
+				compressedSize: entry.directory ? null : entry.compressedSize,
+				executable: entry.executable,
+				encrypted: entry.encrypted,
+				byteOffset: null,
+				declaredSha256: null,
+				unpacked: false,
+				limitations: symlink ? ["Archive symlink target was not read."] : [],
+				adapterKey: `zip-entry:${index}`
+			};
+		};
+		decodeZipEntryText = (bytes, encoding, type) => {
+			if (type !== "filename" || encoding !== "utf-8") return undefined;
+			return decodeStrictZipUtf8(bytes, "ZIP filename is not valid UTF-8");
+		};
+		zipEntryPath = (entry) => {
+			const field = entry.extraFieldUnicodePath;
+			if (field?.valid !== true) return entry.filename;
+			return decodeStrictZipUtf8(field.data.subarray(5), "ZIP Unicode Path extra field is not valid UTF-8");
+		};
+		decodeStrictZipUtf8 = (bytes, message) => {
+			try {
+				return ZIP_UTF8_DECODER.decode(bytes);
+			} catch (cause) {
+				throw new ArtifactReaderFailure("format", message, { cause });
+			}
+		};
+		extractStream = (entry, signal) => {
+			const output = new PassThrough();
+			const controller = new AbortController();
+			const onAbort = () => {
+				controller.abort(signal?.reason);
+				output.destroy(new ArtifactReaderFailure("cancelled", "ZIP operation cancelled"));
+			};
+			signal?.addEventListener("abort", onAbort, { once: true });
+			output.once("close", () => {
+				signal?.removeEventListener("abort", onAbort);
+				controller.abort();
+			});
+			const writable = new WritableStream({
+				write: async (chunk) => {
+					abortIfNeeded(signal);
+					if (!output.write(Buffer.from(chunk))) await once(output, "drain", { signal: controller.signal });
+				},
+				close: () => {
+					output.end();
+				},
+				abort: (reason) => {
+					output.destroy(toError(reason));
+				}
+			});
+			void entry.getData(writable, {
+				signal: controller.signal,
+				checkSignature: true,
+				checkOverlappingEntry: true,
+				onprogress: () => abortIfNeeded(signal)
+			}).catch((cause) => output.destroy(toError(cause)));
+			return output;
+		};
+		isSymlink = (entry) => entry.unixMode !== undefined && (entry.unixMode & 61440) === 40960;
+		abortIfNeeded = (signal) => {
+			if (signal?.aborted === true) throw new ArtifactReaderFailure("cancelled", "ZIP operation cancelled");
+		};
+		toError = (cause) => cause instanceof Error ? cause : new Error("ZIP extraction failed");
+	})))();
+}
+
+//#endregion
+export { ArtifactPathRegistry, DESTINATION_CASE_COLLISION_PREFIX, OwnedDirectoryHandle, ZipArtifactReader, annotateEnglishUnicodeCaseCollisions, destinationCaseCollisionMessage, init_ArtifactPaths, init_OwnedDirectoryHandle, init_StreamBytes, init_ZipArtifactReader, normalizeArtifactPath, streamChunkToBuffer };

package/dist/cli-runtime/analysisErrorCleanup-DaUQNiQd.js

@@ -0,0 +1,32 @@
+import { __esmMin } from "./rolldown-runtime-DXoylpqc.js";
+import { ProviderAdapterError, init_providerAdapterError } from "./providerAdapterError-SRSE_gzN.js";
+import { init_analysisErrorProjection, projectAnalysisError } from "./streamedJsonOutput-VYlQZsM7.js";
+
+//#region dist/domain/analysisErrorCleanup.js
+var analysisErrorWithCleanupFailure;
+function init_analysisErrorCleanup() {
+	return (init_analysisErrorCleanup = __esmMin((() => {
+		init_providerAdapterError();
+		init_analysisErrorProjection();
+		analysisErrorWithCleanupFailure = (primary, cleanup, operation = "close_binary") => {
+			const projected = projectAnalysisError(cleanup);
+			return new ProviderAdapterError(cleanup instanceof ProviderAdapterError ? cleanup.providerId : "rea", operation, {
+				cause: new AggregateError([primary, cleanup], "Analysis failed and cleanup remains incomplete.", { cause: primary }),
+				userMessage: projectAnalysisError(primary).message,
+				...primary.capturedOutput === undefined ? {} : { capturedOutput: primary.capturedOutput },
+				...primary.partialObservation === undefined ? {} : { partialObservation: primary.partialObservation },
+				cleanup: {
+					reason: projected.message,
+					resources: [...new Set([...primary.cleanupResources, ...cleanup.cleanupResources])]
+				},
+				diagnostics: {
+					primary_error: projectAnalysisError(primary),
+					cleanup_error: projected
+				}
+			});
+		};
+	})))();
+}
+
+//#endregion
+export { analysisErrorWithCleanupFailure, init_analysisErrorCleanup };