rea-agents 6.5.0 → 6.7.0

package/dist/cli-runtime/ArtifactFileOperation-Dg4BcoEM.js

@@ -0,0 +1,122 @@
+import { __esmMin } from "./rolldown-runtime-DXoylpqc.js";
+import { OwnedFileHandle, RegularFileCancelled, RegularFileCleanupFailure, RegularFileOperationCancelled, init_OwnedFileHandle, init_OwnedRegularFile, init_RegularFile, withOwnedFileHandle, withOwnedRegularFile } from "./OwnedRegularFile-D1f5nUCx.js";
+import { ArtifactReaderFailure, artifactPrimaryCleanupLeases, init_ArtifactReader } from "./ArtifactReader-DMwm42bk.js";
+import { AnalysisCleanupLease, AnalysisCleanupLeaseGroup, init_AnalysisCleanupLease } from "./AnalysisCleanupLease-CWfTGYKd.js";
+
+//#region dist/artifacts/ArtifactFileOperation.js
+var ArtifactFileCleanupFailure, mapArtifactFileFailure, artifactFilePrimaryFailure, ArtifactFileCancelled, bindArtifactFileCleanup, artifactFileCancellationCause, assertArtifactReadActive, withArtifactRegularFile, withArtifactFileHandle, artifactOperationCause;
+function init_ArtifactFileOperation() {
+	return (init_ArtifactFileOperation = __esmMin((() => {
+		init_RegularFile();
+		init_OwnedFileHandle();
+		init_OwnedRegularFile();
+		init_ArtifactReader();
+		init_AnalysisCleanupLease();
+		ArtifactFileCleanupFailure = class extends ArtifactReaderFailure {
+			cleanupLease;
+			cleanupLeases;
+			fileCleanupFailure;
+			constructor(fileCleanupFailure, cleanupLease) {
+				const outcome = fileCleanupFailure.outcome;
+				if (outcome.kind === "failed" && outcome.cause instanceof RegularFileOperationCancelled) fileCleanupFailure = new RegularFileCleanupFailure(fileCleanupFailure.path, fileCleanupFailure.owner, {
+					kind: "failed",
+					cause: artifactOperationCause(outcome.cause)
+				}, fileCleanupFailure.cleanupCause, fileCleanupFailure.retention, fileCleanupFailure.completionCancellation);
+				const completionCancellation = fileCleanupFailure.completionCancellation;
+				const primary = fileCleanupFailure.outcome.kind === "failed" ? fileCleanupFailure.outcome.cause : completionCancellation === undefined ? fileCleanupFailure.cleanupCause : new ArtifactReaderFailure("cancelled", "Artifact read cancelled during close", { cause: completionCancellation.reason });
+				const projected = ArtifactReaderFailure.withCleanup(primary, ArtifactReaderFailure.cleanupObservation(fileCleanupFailure.cleanupCause, fileCleanupFailure.path));
+				super(projected.reason, projected.message, {
+					cause: fileCleanupFailure,
+					cleanup: projected.cleanup,
+					partialObservation: projected.partialObservation,
+					cancellation: projected.cancellation,
+					...projected.boundary === undefined ? {} : { boundary: projected.boundary }
+				}, projected.details);
+				this.cleanupLease = cleanupLease;
+				this.fileCleanupFailure = fileCleanupFailure;
+				const inherited = fileCleanupFailure.outcome.kind === "failed" ? artifactPrimaryCleanupLeases(fileCleanupFailure.outcome.cause) : [];
+				this.cleanupLeases = inherited === undefined ? undefined : [...new Set([cleanupLease, ...inherited])];
+			}
+		};
+		mapArtifactFileFailure = (cause, classify) => {
+			if (!(cause instanceof ArtifactFileCleanupFailure)) return classify(cause);
+			const physical = cause.fileCleanupFailure;
+			if (physical.outcome.kind !== "failed") return cause;
+			const primary = physical.outcome.cause instanceof ArtifactFileCleanupFailure ? mapArtifactFileFailure(physical.outcome.cause, classify) : classify(physical.outcome.cause);
+			if (primary === physical.outcome.cause) return cause;
+			return new ArtifactFileCleanupFailure(new RegularFileCleanupFailure(physical.path, physical.owner, {
+				kind: "failed",
+				cause: primary
+			}, physical.cleanupCause, physical.retention, physical.completionCancellation), cause.cleanupLease);
+		};
+		artifactFilePrimaryFailure = (cause) => {
+			while (cause instanceof ArtifactFileCleanupFailure && cause.fileCleanupFailure.outcome.kind === "failed") cause = cause.fileCleanupFailure.outcome.cause;
+			return cause;
+		};
+		ArtifactFileCancelled = class extends ArtifactReaderFailure {
+			fileCancellation;
+			constructor(fileCancellation) {
+				super("cancelled", "Artifact read cancelled", { cause: fileCancellation.reason });
+				this.fileCancellation = fileCancellation;
+			}
+		};
+		bindArtifactFileCleanup = (cause, error) => {
+			const leases = cause instanceof ArtifactReaderFailure ? cause.cleanupLeases : undefined;
+			if (leases !== undefined) new AnalysisCleanupLeaseGroup(error, leases);
+		};
+		artifactFileCancellationCause = (cause) => {
+			return cause.cancellation === undefined ? cause.cause : cause.cancellation.reason;
+		};
+		assertArtifactReadActive = (signal) => {
+			if (signal?.aborted) throw new ArtifactReaderFailure("cancelled", "Artifact read cancelled", { cause: signal.reason });
+		};
+		withArtifactRegularFile = async (path, resources, signal, operation, symlinks = "reject") => {
+			let cleanupLease;
+			assertArtifactReadActive(signal);
+			try {
+				const value = await withOwnedRegularFile(path, {
+					symlinks,
+					...signal === undefined ? {} : { signal },
+					retainFailedClose: (owner) => {
+						cleanupLease = new AnalysisCleanupLease(() => owner.close(), [path]);
+						resources.retain({
+							kind: "lease",
+							resource: path,
+							lease: cleanupLease
+						});
+					}
+				}, async (file) => {
+					assertArtifactReadActive(signal);
+					return await operation(file);
+				});
+				return value;
+			} catch (cause) {
+				if (cause instanceof RegularFileCleanupFailure && cleanupLease !== undefined) throw new ArtifactFileCleanupFailure(cause, cleanupLease);
+				if (cause instanceof RegularFileCancelled) throw new ArtifactFileCancelled(cause);
+				throw artifactOperationCause(cause);
+			}
+		};
+		withArtifactFileHandle = async (path, file, resources, signal, operation) => {
+			const owner = new OwnedFileHandle(file);
+			const cleanupLease = new AnalysisCleanupLease(() => owner.close(), [path]);
+			try {
+				return await withOwnedFileHandle(path, owner, {
+					...signal === undefined ? {} : { signal },
+					retainFailedClose: () => resources?.retain({
+						kind: "lease",
+						resource: path,
+						lease: cleanupLease
+					})
+				}, operation);
+			} catch (cause) {
+				if (cause instanceof RegularFileCleanupFailure) throw new ArtifactFileCleanupFailure(cause, cleanupLease);
+				if (cause instanceof RegularFileCancelled) throw new ArtifactFileCancelled(cause);
+				throw artifactOperationCause(cause);
+			}
+		};
+		artifactOperationCause = (cause) => cause instanceof RegularFileOperationCancelled ? new ArtifactReaderFailure("cancelled", "Artifact file operation cancelled", { cause: cause.reason }) : cause;
+	})))();
+}
+
+//#endregion
+export { ArtifactFileCancelled, ArtifactFileCleanupFailure, artifactFileCancellationCause, artifactFilePrimaryFailure, assertArtifactReadActive, bindArtifactFileCleanup, init_ArtifactFileOperation, mapArtifactFileFailure, withArtifactFileHandle, withArtifactRegularFile };

package/dist/cli-runtime/{ArtifactReader-BXkffc1D.js → ArtifactReader-DMwm42bk.js}

@@ -1,9 +1,11 @@
 import { __esmMin } from "./rolldown-runtime-DXoylpqc.js";
+import { AnalysisError, init_analysisErrorBase } from "./errorSchemas-Ixz_q7qt.js";
 
 //#region dist/artifacts/ArtifactReader.js
-var sameArtifactSourceIdentity, copyArtifactEntry, sameArtifactEntry, ArtifactReaderFailure, combineCleanup, errorMessage;
+var sameArtifactSourceIdentity, copyArtifactEntry, sameArtifactEntry, ArtifactReaderFailure, combineCleanup, errorMessage, artifactPrimaryCleanupLeases;
 function init_ArtifactReader() {
 	return (init_ArtifactReader = __esmMin((() => {
+		init_analysisErrorBase();
 		sameArtifactSourceIdentity = (expected, observed) => expected !== undefined && observed.dev === expected.device && observed.ino === expected.inode && observed.size === expected.size && observed.mode === expected.mode && observed.mtimeNs === expected.mtimeNs && observed.ctimeNs === expected.ctimeNs;
 		copyArtifactEntry = (entry) => ({
 			...entry,
@@ -14,32 +16,52 @@ function init_ArtifactReader() {
 		ArtifactReaderFailure = class ArtifactReaderFailure extends Error {
 			reason;
 			details;
+			cancellation;
 			cleanup;
+			cleanupLeases;
 			partialObservation;
+			/** The constrained bound for a `limit` reason, when the reader knows it. */
+			boundary;
 			constructor(reason, message, options, details) {
 				super(message, options);
 				this.reason = reason;
 				this.details = details;
 				this.name = "ArtifactReaderFailure";
+				this.cancellation = reason === "cancelled" ? options?.cancellation ?? { reason: options?.cause } : undefined;
 				this.cleanup = options?.cleanup;
+				this.cleanupLeases = options?.cleanupLeases ?? (this.cleanup === undefined ? [] : undefined);
 				this.partialObservation = options?.partialObservation;
+				this.boundary = options?.boundary;
 			}
-			/** Preserve the primary failure while attaching cleanup and any complete observation. */
-			static withCleanup(cause, cleanup, partialObservation) {
-				const primary = cause instanceof ArtifactReaderFailure ? cause : new ArtifactReaderFailure("io", errorMessage(cause), { cause });
+			/** Preserve the primary failure and observation. Supplied leases must cover all merged cleanup. */
+			static withCleanup(cause, cleanup, partialObservation, cleanupLeases) {
+				const primary = cause instanceof ArtifactReaderFailure ? cause : new ArtifactReaderFailure("io", errorMessage(cause), {
+					cause,
+					...cause instanceof AnalysisError ? {
+						partialObservation: cause.partialObservation,
+						...cause.cleanupIncomplete ? { cleanup: ArtifactReaderFailure.cleanupObservation(cause, []) } : {}
+					} : {}
+				});
 				const mergedObservation = partialObservation ?? primary.partialObservation;
 				return new ArtifactReaderFailure(primary.reason, primary.message, {
 					cause: primary,
+					cancellation: primary.cancellation,
 					cleanup: combineCleanup(primary.cleanup, cleanup),
+					cleanupLeases: cleanupLeases ?? (cleanup === primary.cleanup ? primary.cleanupLeases : undefined),
+					...primary.boundary === undefined ? {} : { boundary: primary.boundary },
 					...mergedObservation === undefined ? {} : { partialObservation: mergedObservation }
 				}, primary.details);
 			}
 			/** Give otherwise opaque cleanup failures a concrete owned resource. */
 			static cleanupObservation(cause, resource) {
 				if (cause instanceof ArtifactReaderFailure && cause.cleanup !== undefined) return cause.cleanup;
+				if (cause instanceof AnalysisError && cause.cleanupIncomplete) return {
+					reason: cause.cleanup?.reason ?? cause.message,
+					resources: [...cause.cleanupResources]
+				};
 				return {
 					reason: errorMessage(cause),
-					resources: [resource]
+					resources: typeof resource === "string" ? [resource] : [...resource]
 				};
 			}
 		};
@@ -48,8 +70,9 @@ function init_ArtifactReader() {
 			resources: [...new Set([...primary.resources, ...cleanup.resources])]
 		};
 		errorMessage = (cause) => cause instanceof Error ? cause.message : String(cause);
+		artifactPrimaryCleanupLeases = (cause) => cause instanceof ArtifactReaderFailure ? cause.cleanupLeases : cause instanceof AnalysisError && cause.cleanupIncomplete ? undefined : [];
 	})))();
 }
 
 //#endregion
-export { ArtifactReaderFailure, copyArtifactEntry, init_ArtifactReader, sameArtifactEntry, sameArtifactSourceIdentity };
+export { ArtifactReaderFailure, artifactPrimaryCleanupLeases, copyArtifactEntry, init_ArtifactReader, sameArtifactEntry, sameArtifactSourceIdentity };

package/dist/cli-runtime/ArtifactResourceScope-CokZGcII.js

@@ -0,0 +1,175 @@
+import { __esmMin } from "./rolldown-runtime-DXoylpqc.js";
+import { ArtifactReaderFailure, artifactPrimaryCleanupLeases, init_ArtifactReader } from "./ArtifactReader-DMwm42bk.js";
+import { AnalysisCleanupLease, init_AnalysisCleanupLease } from "./AnalysisCleanupLease-CWfTGYKd.js";
+
+//#region dist/artifacts/ArtifactResourceScope.js
+var ArtifactResourceRetryFailure, ArtifactResourceScope, cleanup;
+function init_ArtifactResourceScope() {
+	return (init_ArtifactResourceScope = __esmMin((() => {
+		init_ArtifactReader();
+		init_AnalysisCleanupLease();
+		ArtifactResourceRetryFailure = class extends ArtifactReaderFailure {
+			failedOwners;
+			cleanupLeases;
+			constructor(failures, message, options) {
+				super("unavailable", message, options);
+				this.failedOwners = failures.map(({ owner }) => owner);
+				this.cleanupLeases = [...new Set(failures.map(({ lease }) => lease))];
+			}
+		};
+		ArtifactResourceScope = class {
+			#pending = new Set();
+			#leases = new WeakMap();
+			#active = new Set();
+			#draining;
+			#closed = false;
+			get hasPending() {
+				return this.#pending.size > 0;
+			}
+			/** Labels come from the exact retained owners, never from diagnostic text. */
+			get cleanupResources() {
+				return [...new Set([...this.#pending].flatMap((owner) => {
+					const lease = this.#lease(owner);
+					return lease.released ? [] : lease.cleanupResources ?? [owner.resource];
+				}))];
+			}
+			/** Admit a resource operation while the scope remains open. */
+			async run(operation) {
+				while (true) {
+					if (this.#closed) throw new ArtifactReaderFailure("unavailable", "Artifact resource scope is closed");
+					if (this.#draining !== undefined) await this.#draining;
+					if (this.#closed) throw new ArtifactReaderFailure("unavailable", "Artifact resource scope is closed");
+					if (this.#pending.size > 0) {
+						await this.retryCleanup();
+						continue;
+					}
+					const running = Promise.resolve().then(operation);
+					this.#active.add(running);
+					try {
+						return await running;
+					} finally {
+						this.#active.delete(running);
+					}
+				}
+			}
+			/** Attempt cleanup now and retain the same owner if it fails. */
+			async release(owner) {
+				try {
+					await this.#lease(owner).release();
+					this.#pending.delete(owner);
+					return { kind: "released" };
+				} catch (cause) {
+					this.#pending.add(owner);
+					this.#observeCleanupFailure(owner, cause);
+					return {
+						kind: "failed",
+						cause,
+						owner,
+						lease: this.#lease(owner)
+					};
+				}
+			}
+			/** Compose initial cleanup authority without confusing it with an independent primary. */
+			cleanupFailure(outcome, failures, partialObservation) {
+				const observations = failures.map(({ cause, owner }) => ArtifactReaderFailure.cleanupObservation(cause, owner.resource));
+				const primary = outcome.kind === "failed" ? outcome.cause : failures[0].cause;
+				const inherited = outcome.kind === "failed" ? artifactPrimaryCleanupLeases(primary) : [];
+				return ArtifactReaderFailure.withCleanup(primary, {
+					reason: observations.map(({ reason }) => reason).join("; "),
+					resources: [...new Set(observations.flatMap(({ resources }) => resources))]
+				}, partialObservation, inherited === undefined ? undefined : [...new Set([...inherited, ...failures.map(({ lease }) => lease)])]);
+			}
+			/** Adopt an owner after another boundary's cleanup attempt failed. */
+			retain(owner) {
+				this.#pending.add(owner);
+			}
+			/** Retry retained owners without closing resource admission. */
+			retryCleanup() {
+				if (this.#draining !== undefined) return this.#draining;
+				this.#draining = this.#drainAndRetry().finally(() => {
+					this.#draining = undefined;
+				});
+				return this.#draining;
+			}
+			/** Stop admission, wait for active operations, and retry every retained owner. */
+			close() {
+				this.#closed = true;
+				return this.retryCleanup();
+			}
+			async #drainAndRetry() {
+				while (this.#active.size > 0) await Promise.allSettled(this.#active);
+				const failures = [];
+				for (const owner of this.#pending) {
+					try {
+						await this.#lease(owner).release();
+						this.#pending.delete(owner);
+					} catch (cause) {
+						this.#observeCleanupFailure(owner, cause);
+						failures.push({
+							owner,
+							cause
+						});
+					}
+				}
+				if (failures.length === 0) return;
+				const observations = failures.map(({ owner, cause }) => ArtifactReaderFailure.cleanupObservation(cause, owner.kind === "lease" && owner.lease instanceof AnalysisCleanupLease ? owner.lease.cleanupResources ?? owner.resource : owner.resource));
+				const resources = [...new Set(observations.flatMap(({ resources }) => resources))];
+				throw new ArtifactResourceRetryFailure(failures.map(({ owner }) => ({
+					owner,
+					lease: this.#lease(owner)
+				})), `Artifact cleanup remains incomplete: ${resources.join(", ")}`, {
+					cause: new AggregateError(failures.map(({ cause }) => cause), "One or more artifact resources remain owned"),
+					cleanup: {
+						reason: observations.map(({ reason }) => reason).join("; "),
+						resources
+					}
+				});
+			}
+			/** This boundary owns the latest parsed child cleanup facts for a composite owner. */
+			#observeCleanupFailure(owner, cause) {
+				const retained = this.#leases.get(owner);
+				if (retained !== undefined) retained.resources = [...ArtifactReaderFailure.cleanupObservation(cause, owner.resource).resources];
+			}
+			#lease(owner) {
+				if (owner.kind === "lease" && owner.lease instanceof AnalysisCleanupLease) return owner.lease;
+				const previous = this.#leases.get(owner);
+				if (previous !== undefined) return previous.lease;
+				const retained = {
+					resources: [owner.resource],
+					lease: new AnalysisCleanupLease(() => cleanup(owner), { get cleanupResources() {
+						return retained.resources;
+					} })
+				};
+				this.#leases.set(owner, retained);
+				return retained.lease;
+			}
+		};
+		cleanup = async (owner) => {
+			switch (owner.kind) {
+				case "lease":
+					await owner.lease.release();
+					return;
+				case "javascript-source-analysis":
+					await owner.analysis.close();
+					return;
+				case "reader":
+					await owner.reader.close();
+					return;
+				case "file-handle":
+				case "directory-handle":
+					await owner.handle.close();
+					return;
+				case "output-tree":
+					await owner.tree.rollback();
+					return;
+				case "staged-output":
+					await owner.output.close();
+					return;
+				case "private-runtime-root": await owner.root.close();
+			}
+		};
+	})))();
+}
+
+//#endregion
+export { ArtifactResourceRetryFailure, ArtifactResourceScope, init_ArtifactResourceScope };

package/dist/cli-runtime/{AsarHeader-CnzOzYEH.js → AsarHeader-BxwU17DJ.js}

@@ -1,5 +1,5 @@
 import { __esmMin } from "./rolldown-runtime-DXoylpqc.js";
-import { ArtifactReaderFailure, init_ArtifactReader } from "./ArtifactReader-BXkffc1D.js";
+import { ArtifactReaderFailure, init_ArtifactReader } from "./ArtifactReader-DMwm42bk.js";
 
 //#region dist/artifacts/AsarHeader.js
 var MAX_ASAR_HEADER_BYTES, admitAsarHeader;

package/dist/cli-runtime/{BinarySessionStatus-DnMxMk-r.js → BinarySessionStatus-DRhjr7Vb.js}

@@ -1,5 +1,5 @@
 import { __esmMin } from "./rolldown-runtime-DXoylpqc.js";
-import { PROVIDER_EFFECT_NAMES, compareUnicodeCodePoints, init_toolOutputSchemaPrimitives, init_unicodeCodePointOrder } from "./reconstructionObligationLedgerSchemas-Bao0xMr-.js";
+import { PROVIDER_EFFECT_NAMES, compareUnicodeCodePoints, init_toolOutputSchemaPrimitives, init_unicodeCodePointOrder } from "./reconstructionObligationLedgerSchemas-Bi6sect1.js";
 
 //#region dist/application/binary/BinaryTargetSummary.js
 var binaryTargetSummary;
@@ -24,7 +24,7 @@ function init_BinarySessionStatus() {
 		init_BinaryTargetSummary();
 		init_toolOutputSchemaPrimitives();
 		init_unicodeCodePointOrder();
-		binarySessionStatus = ({ target, route, router, runtimeUnavailability, runId, runtimeLineageSnapshots, requestActivitySnapshots, providerOperationHealth }) => {
+		binarySessionStatus = async ({ target, route, router, runtimeUnavailability, runId, runtimeLineageSnapshots, requestActivitySnapshots, providerOperationHealth, cleanupPending = false, signal }) => {
 			const routeCapabilities = [...route.capabilities.values()].filter(({ operation }) => operation !== "inventory_artifact").sort((left, right) => compareUnicodeCodePoints(left.operation, right.operation)).map((descriptor) => {
 				const unavailable = runtimeUnavailability.get(descriptor.operation);
 				return unavailable === undefined ? descriptor : {
@@ -39,7 +39,7 @@ function init_BinarySessionStatus() {
 				selection_source: route.binding.selectionSource,
 				analysis_profile: structuredClone(route.binding.profile)
 			};
-			const analysisProviderCandidates = router.candidateStatuses(route).map((candidate) => ({
+			const analysisProviderCandidates = (await router.candidateStatuses(route, signal)).map((candidate) => ({
 				provider: providerSummary(candidate.provider),
 				availability: structuredClone(candidate.availability),
 				target_support: structuredClone(candidate.targetSupport),
@@ -47,6 +47,7 @@ function init_BinarySessionStatus() {
 				capabilities: providerCapabilitySets(candidate.capabilities.slice().filter(({ operation }) => operation !== "inventory_artifact").sort((left, right) => compareUnicodeCodePoints(left.operation, right.operation)))
 			}));
 			const common = {
+				cleanup_pending: cleanupPending,
 				capabilities,
 				analysis_provider_binding: analysisProviderBinding,
 				analysis_provider_candidates: analysisProviderCandidates,

package/dist/cli-runtime/{BinaryTargetResolver-CVIJ_s1A.js → BinaryTargetResolver-tuCTjBlQ.js}

@@ -1,52 +1,21 @@
 import { __esmMin } from "./rolldown-runtime-DXoylpqc.js";
-import { err, hasZipSignature, init_localPath, init_result, init_zipPackageFormat, isPathWithinRoot, isZipPackageFormat, ok, zipPackageFormatForPath } from "./reconstructionObligationLedgerSchemas-Bao0xMr-.js";
-import { AnalysisCancelledError, BinaryTargetError, init_analysisErrorCore, init_configurationErrors } from "./errorSchemas-CTRmvMl3.js";
-import { init_RegularFile, openRegularFile, sameRegularFileState } from "./RegularFile-B_6KPCNQ.js";
-import { admitRawBinary, init_rawBinary, rawBinarySelectionError } from "./toolOutputSchemaGroups-DRiYs1je.js";
-import { classifyFatContainerIdentity, init_machoContainer, readFatContainerHeader } from "./machoContainer-C8BIkkq3.js";
-import { MAX_XML_PLIST_PROBE_BYTES, createXmlPlistSignatureProbe, hasBinaryPlistSignature, init_appleArchiveFormat, init_dosMz, observeMzWindowsHeader, parseDosMzHeader } from "./appleArchiveFormat-tVoI2ykA.js";
-import { init_dosCom, validateDosComLength } from "./managedToolContracts-D60QmIYj.js";
-import { decodeXmlPlistText, init_InterfaceBuilderDecodeBudget, init_propertyListXmlText, preflightPropertyListDecode } from "./InterfaceBuilderDecodeBudget-D4omRUe4.js";
-import { init_propertyListKeys, omitPrototypeKeys, parseXmlPropertyList } from "./propertyListKeys-G8e74YWb.js";
+import { err, hasZipSignature, init_localPath, init_result, init_zipPackageFormat, isPathWithinRoot, isZipPackageFormat, ok, zipPackageFormatForPath } from "./reconstructionObligationLedgerSchemas-Bi6sect1.js";
+import { AnalysisCancelledError, BinaryTargetError, init_analysisErrorCore, init_configurationErrors } from "./errorSchemas-Ixz_q7qt.js";
+import { init_OwnedRegularFile, init_RegularFile, openRegularFile, regularFileCancellation, sameRegularFileState } from "./OwnedRegularFile-D1f5nUCx.js";
+import { absoluteCallerPath, decodeXmlPlistText, init_InterfaceBuilderDecodeBudget, init_callerPath, init_propertyListXmlText, preflightPropertyListDecode } from "./InterfaceBuilderDecodeBudget-CW1IO3dG.js";
+import { admitRawBinary, init_rawBinary, rawBinarySelectionError } from "./toolOutputSchemaGroups-BqdSzySu.js";
+import { classifyFatContainerIdentity, init_machoContainer, readFatContainerHeader } from "./machoContainer-Cy98bkFm.js";
+import { decodePeMachine, init_elfFixedHeader, init_peMachine, peOptionalHeaderMagic, readElfFixedHeader } from "./peMachine-B9ggfSJJ.js";
+import { MAX_XML_PLIST_PROBE_BYTES, createXmlPlistSignatureProbe, hasBinaryPlistSignature, init_appleArchiveFormat, init_dosMz, observeMzWindowsHeader, parseDosMzHeader } from "./appleArchiveFormat-Bb3G5CCI.js";
+import { init_dosCom, validateDosComLength } from "./managedToolContracts-BuFkMBH5.js";
+import { init_propertyListKeys, omitPrototypeKeys, parseXmlPropertyList } from "./propertyListKeys-D5dSASEy.js";
 import { z } from "zod";
-import { extname, isAbsolute, join, resolve } from "node:path";
+import { extname, join } from "node:path";
 import { createHash } from "node:crypto";
-import { access, lstat, opendir, readFile, realpath, stat } from "node:fs/promises";
 import { constants } from "node:fs";
+import { access, lstat, opendir, readFile, realpath, stat } from "node:fs/promises";
 import { parseBinary } from "plist";
 
-//#region dist/domain/elfFixedHeader.js
-var readElfFixedHeader;
-function init_elfFixedHeader() {
-	return (init_elfFixedHeader = __esmMin((() => {
-		init_result();
-		readElfFixedHeader = (bytes, totalBytes = bytes.length) => {
-			if (bytes.length >= 4 && bytes.toString("hex", 0, 4) !== "7f454c46") return err("not an ELF image");
-			if (bytes.length < 16) return err("ELF identification is truncated");
-			const classByte = bytes[4];
-			if (classByte !== 1 && classByte !== 2) return err("unsupported ELF class");
-			const dataByte = bytes[5];
-			if (dataByte !== 1 && dataByte !== 2) return err("unsupported ELF endianness");
-			if (bytes[6] !== 1) return err("unsupported ELF identification version");
-			const elfClass = classByte === 1 ? 32 : 64;
-			const minimumSize = elfClass === 32 ? 52 : 64;
-			if (!Number.isSafeInteger(totalBytes) || totalBytes < bytes.length || totalBytes < minimumSize || bytes.length < minimumSize) return err(`truncated ELF header: an ELF${elfClass} header needs ${minimumSize} bytes; the file has ${totalBytes}`);
-			const littleEndian = dataByte === 1;
-			const readU16 = (offset) => littleEndian ? bytes.readUInt16LE(offset) : bytes.readUInt16BE(offset);
-			const readU32 = (offset) => littleEndian ? bytes.readUInt32LE(offset) : bytes.readUInt32BE(offset);
-			if (readU32(20) !== 1) return err("unsupported ELF header version");
-			const headerSize = readU16(elfClass === 32 ? 40 : 52);
-			if (headerSize < minimumSize || headerSize > totalBytes) return err("invalid ELF header size");
-			return ok({
-				elfClass,
-				byteOrder: littleEndian ? "little" : "big",
-				headerSize
-			});
-		};
-	})))();
-}
-
-//#endregion
 //#region dist/application/MipsElfSharedLoad.js
 var readMipsElfSharedLoad;
 function init_MipsElfSharedLoad() {
@@ -310,7 +279,7 @@ function init_MipsElfMetadata() {
 			const little = metadata.byteOrder === "little";
 			const u16 = (data, offset) => little ? data.readUInt16LE(offset) : data.readUInt16BE(offset);
 			const u32 = (data, offset) => little ? data.readUInt32LE(offset) : data.readUInt32BE(offset);
-			if (fixedHeader.value.elfClass !== 32 || fixedHeader.value.byteOrder !== metadata.byteOrder || u16(bytes, 18) !== 8 || u16(bytes, 16) !== metadata.type || u32(bytes, 36) !== metadata.flags) return err("MIPS ELF header no longer matches the resolved identity");
+			if (fixedHeader.value.elfClass !== 32 || fixedHeader.value.byteOrder !== metadata.byteOrder || fixedHeader.value.machine !== 8 || u16(bytes, 16) !== metadata.type || u32(bytes, 36) !== metadata.flags) return err("MIPS ELF header no longer matches the resolved identity");
 			if (fixedHeader.value.headerSize !== 52) return err("invalid MIPS ELF32 version or header size");
 			const tables = [{
 				label: "program header table",
@@ -537,8 +506,16 @@ function init_AppBundleExecutable() {
 			if (!isSafeExecutableName(name)) return err(new BinaryTargetError(bundle, "app has an unsafe CFBundleExecutable"));
 			const programs = join(bundle, ...layout.programs);
 			const executable = join(programs, name);
+			let canonicalBundle;
+			try {
+				canonicalBundle = await fileSystem.realpath(bundle);
+			} catch (cause) {
+				return err(new BinaryTargetError(bundle, errorReason(cause, bundle), { cause }));
+			}
 			try {
-				const [canonicalPrograms, canonicalExecutable] = await Promise.all([fileSystem.realpath(programs), fileSystem.realpath(executable)]);
+				const canonicalPrograms = await fileSystem.realpath(programs);
+				if (!isPathWithinRoot(canonicalBundle, canonicalPrograms)) return err(new BinaryTargetError(bundle, `app program directory leaves ${layout.programsLabel}`));
+				const canonicalExecutable = await fileSystem.realpath(executable);
 				if (!isPathWithinRoot(canonicalPrograms, canonicalExecutable)) return err(new BinaryTargetError(bundle, `app program file leaves ${layout.programsLabel}`));
 				return ok({
 					executable: canonicalExecutable,
@@ -566,51 +543,9 @@ function init_AppBundleExecutable() {
 	})))();
 }
 
-//#endregion
-//#region dist/domain/peMachine.js
-var architectureForMachine, NATIVE_OS_OVERRIDES, decodePeMachine;
-function init_peMachine() {
-	return (init_peMachine = __esmMin((() => {
-		architectureForMachine = (machine) => {
-			switch (machine) {
-				case 332: return "x86";
-				case 34404: return "x86_64";
-				case 448:
-				case 450:
-				case 452: return "arm";
-				case 43620: return "arm64";
-			}
-			return undefined;
-		};
-		NATIVE_OS_OVERRIDES = [
-			17988,
-			44484,
-			44485,
-			31609,
-			6547,
-			6546
-		];
-		decodePeMachine = (machine) => {
-			const direct = architectureForMachine(machine);
-			if (direct !== undefined) return {
-				architecture: direct,
-				nativeOsOverride: false
-			};
-			for (const override of NATIVE_OS_OVERRIDES) {
-				const architecture = architectureForMachine(machine ^ override);
-				if (architecture !== undefined) return {
-					architecture,
-					nativeOsOverride: true
-				};
-			}
-			return undefined;
-		};
-	})))();
-}
-
 //#endregion
 //#region dist/domain/binaryTarget.js
-var parseExecutableHeader, parseThinMachO, parseFatMachO, fatHostArchitecture, fatIdentityError, parseElf, parseMz, parsePeRecord, parseCodeViewData, peDebugDirectoryEntry, peRvaToFileOffset, parsePeCodeViewFromBuffer, peManagedStatus, machArchitecture, elfArchitecture;
+var parseExecutableHeader, parseThinMachO, parseFatMachO, fatHostArchitecture, fatIdentityError, parseElf, parseMz, parsePeRecord, parseCodeViewData, peDebugDirectoryEntry, peRvaToFileOffset, parsePeCodeViewFromBuffer, peManagedStatus, machArchitecture;
 function init_binaryTarget() {
 	return (init_binaryTarget = __esmMin((() => {
 		init_result();
@@ -708,11 +643,9 @@ function init_binaryTarget() {
 		parseElf = (bytes, fileSize) => {
 			const fixedHeader = readElfFixedHeader(bytes, fileSize);
 			if (!fixedHeader.ok) return fixedHeader;
-			const { elfClass, byteOrder } = fixedHeader.value;
+			const { elfClass, byteOrder, architecture } = fixedHeader.value;
 			const little = byteOrder === "little";
-			const machine = little ? bytes.readUInt16LE(18) : bytes.readUInt16BE(18);
-			const architecture = elfArchitecture(machine);
-			if (architecture === undefined) return err("unsupported ELF architecture");
+			if (architecture === null) return err("unsupported ELF architecture");
 			if (architecture === "mips" || architecture === "riscv" || architecture === "powerpc") {
 				const flagsOffset = elfClass === 32 ? 36 : 48;
 				const metadata = {
@@ -739,6 +672,11 @@ function init_binaryTarget() {
 					riscv: metadata
 				});
 			}
+			if (architecture === "hexagon") return ok({
+				format: "elf",
+				architecture,
+				availableArchitectures: [architecture]
+			});
 			return ok({
 				format: "elf",
 				architecture,
@@ -782,6 +720,7 @@ function init_binaryTarget() {
 			const characteristics = record.readUInt16LE(22);
 			return ok({
 				format: "pe",
+				peMachine: machineType,
 				architecture,
 				availableArchitectures: [architecture],
 				executableRole: (characteristics & 2) === 0 ? "non-executable" : (characteristics & 8192) === 0 ? "application" : "shared-library",
@@ -896,8 +835,7 @@ function init_binaryTarget() {
 		peManagedStatus = (optionalHeader, architecture) => {
 			if (optionalHeader.length < 2) return err("truncated PE optional header");
 			const magic = optionalHeader.readUInt16LE(0);
-			const expectedMagic = architecture === "x86_64" || architecture === "arm64" ? 523 : 267;
-			if (magic !== expectedMagic) return err("PE optional-header magic does not match its architecture");
+			if (magic !== peOptionalHeaderMagic(architecture)) return err("PE optional-header magic does not match its architecture");
 			const directoryOffset = magic === 523 ? 112 : 96;
 			const directoryCountOffset = directoryOffset - 4;
 			if (optionalHeader.length < directoryCountOffset + 4) return err("truncated PE optional header");
@@ -917,18 +855,6 @@ function init_binaryTarget() {
 			}
 			return undefined;
 		};
-		elfArchitecture = (machine) => {
-			switch (machine) {
-				case 3: return "x86";
-				case 62: return "x86_64";
-				case 8: return "mips";
-				case 20: return "powerpc";
-				case 40: return "arm";
-				case 183: return "arm64";
-				case 243: return "riscv";
-			}
-			return undefined;
-		};
 	})))();
 }
 
@@ -937,6 +863,7 @@ function init_binaryTarget() {
 var XML_PLIST_PROBE_CHUNK_BYTES, parseBinaryTarget, classifyBinaryTargetFilesystemFailure, filesystemErrorCode, targetFailureReason, throwIfTargetResolutionCancelled, detectArtifactFormat, namedArtifactFormat, isArchiveFormat, sha256Handle, resolveAppBundle, readExecutableMetadata, readPeMetadata, readPeCodeView;
 function init_BinaryTargetResolver() {
 	return (init_BinaryTargetResolver = __esmMin((() => {
+		init_OwnedRegularFile();
 		init_configurationErrors();
 		init_RegularFile();
 		init_analysisErrorCore();
@@ -949,12 +876,13 @@ function init_BinaryTargetResolver() {
 		init_appleArchiveFormat();
 		init_zipPackageFormat();
 		init_binaryTarget();
+		init_callerPath();
 		XML_PLIST_PROBE_CHUNK_BYTES = 64 * 1024;
 		parseBinaryTarget = async (input, options = {}) => {
 			const cwd = options.cwd ?? process.cwd();
 			const hostArchitecture = options.hostArchitecture ?? process.arch;
 			const { targetKind, formatHint, signal, architecture, entryPoint } = options;
-			const candidate = isAbsolute(input) ? input : resolve(cwd, input);
+			const candidate = absoluteCallerPath(input, { cwd });
 			try {
 				throwIfTargetResolutionCancelled(signal);
 				await access(candidate, constants.R_OK);
@@ -1054,6 +982,8 @@ function init_BinaryTargetResolver() {
 				}
 			} catch (cause) {
 				if (cause instanceof AnalysisCancelledError) return err(cause);
+				const cancellation = regularFileCancellation(cause);
+				if (cancellation !== undefined) return err(new AnalysisCancelledError("resolve_binary_target", { cause: cancellation.reason }));
 				if (signal?.aborted === true && cause === signal.reason) return err(new AnalysisCancelledError("resolve_binary_target", { cause }));
 				if (cause instanceof BinaryTargetError) return err(cause);
 				if (!(cause instanceof Error)) throw cause;
@@ -1305,4 +1235,4 @@ function init_BinaryTargetResolver() {
 }
 
 //#endregion
-export { classifyBinaryTargetFilesystemFailure, decodePeMachine, init_BinaryTargetResolver, init_binaryTarget, init_elfFixedHeader, init_peMachine, parseBinaryTarget, parseExecutableHeader, readElfFixedHeader };
+export { classifyBinaryTargetFilesystemFailure, init_BinaryTargetResolver, init_binaryTarget, parseBinaryTarget, parseExecutableHeader };