rea-agents 6.4.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-DMwm42bk.js

@@ -0,0 +1,78 @@
+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, 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,
+			limitations: [...entry.limitations],
+			...entry.sourceIdentity === undefined ? {} : { sourceIdentity: { ...entry.sourceIdentity } }
+		});
+		sameArtifactEntry = (entry, produced) => entry.path === produced.path && entry.kind === produced.kind && entry.declaredSize === produced.declaredSize && entry.compressedSize === produced.compressedSize && entry.executable === produced.executable && entry.encrypted === produced.encrypted && entry.byteOffset === produced.byteOffset && entry.declaredSha256 === produced.declaredSha256 && entry.unpacked === produced.unpacked && entry.adapterKey === produced.adapterKey && entry.limitations.length === produced.limitations.length && entry.limitations.every((limitation, index) => limitation === produced.limitations[index]) && entry.sourceIdentity?.device === produced.sourceIdentity?.device && entry.sourceIdentity?.inode === produced.sourceIdentity?.inode && entry.sourceIdentity?.size === produced.sourceIdentity?.size && entry.sourceIdentity?.mode === produced.sourceIdentity?.mode && entry.sourceIdentity?.mtimeNs === produced.sourceIdentity?.mtimeNs && entry.sourceIdentity?.ctimeNs === produced.sourceIdentity?.ctimeNs;
+		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 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: typeof resource === "string" ? [resource] : [...resource]
+				};
+			}
+		};
+		combineCleanup = (primary, cleanup) => primary === undefined || primary === cleanup ? cleanup : {
+			reason: `${primary.reason}; ${cleanup.reason}`,
+			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, 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-BxwU17DJ.js

@@ -0,0 +1,31 @@
+import { __esmMin } from "./rolldown-runtime-DXoylpqc.js";
+import { ArtifactReaderFailure, init_ArtifactReader } from "./ArtifactReader-DMwm42bk.js";
+
+//#region dist/artifacts/AsarHeader.js
+var MAX_ASAR_HEADER_BYTES, admitAsarHeader;
+function init_AsarHeader() {
+	return (init_AsarHeader = __esmMin((() => {
+		init_ArtifactReader();
+		MAX_ASAR_HEADER_BYTES = 16 * 1024 * 1024;
+		admitAsarHeader = async (handle) => {
+			const observed = await handle.stat();
+			if (!observed.isFile()) throw new ArtifactReaderFailure("format", "ASAR container is not a regular file");
+			const prefix = Buffer.alloc(16);
+			const read = await handle.read(prefix, 0, prefix.length, 0);
+			if (read.bytesRead !== prefix.length || prefix.readUInt32LE(0) !== 4) throw new ArtifactReaderFailure("format", "Truncated or invalid ASAR size pickle");
+			const headerBytes = prefix.readUInt32LE(4);
+			const payloadBytes = prefix.readUInt32LE(8);
+			const jsonBytes = prefix.readUInt32LE(12);
+			if (headerBytes < 8 || headerBytes > observed.size - 8 || payloadBytes !== headerBytes - 4 || jsonBytes > payloadBytes - 4) throw new ArtifactReaderFailure("format", "ASAR header leaves its container or has invalid pickle extents");
+			if (headerBytes > 16777216) throw new ArtifactReaderFailure("limit", `ASAR header exceeds the ${String(MAX_ASAR_HEADER_BYTES)} byte decode budget`);
+			return {
+				archiveBytes: observed.size,
+				headerBytes,
+				jsonBytes
+			};
+		};
+	})))();
+}
+
+//#endregion
+export { MAX_ASAR_HEADER_BYTES, admitAsarHeader, init_AsarHeader };

package/dist/cli-runtime/BinarySessionStatus-DRhjr7Vb.js

@@ -0,0 +1,212 @@
+import { __esmMin } from "./rolldown-runtime-DXoylpqc.js";
+import { PROVIDER_EFFECT_NAMES, compareUnicodeCodePoints, init_toolOutputSchemaPrimitives, init_unicodeCodePointOrder } from "./reconstructionObligationLedgerSchemas-Bi6sect1.js";
+
+//#region dist/application/binary/BinaryTargetSummary.js
+var binaryTargetSummary;
+function init_BinaryTargetSummary() {
+	return (init_BinaryTargetSummary = __esmMin((() => {
+		binaryTargetSummary = (target) => ({
+			path: target.path,
+			format: target.format,
+			kind: target.kind,
+			sha256: target.sha256,
+			architecture: target.architecture ?? null,
+			...target.format === "raw-binary" ? { entry_point: target.entryPoint } : {}
+		});
+	})))();
+}
+
+//#endregion
+//#region dist/application/binary/BinarySessionStatus.js
+var binarySessionStatus, requestActivityStatus, providerSummary, processLineageStatus, providerCapabilitySets, commonLimitationsPrefix, enabledCapabilityEffects, providerOperationHealthStatus;
+function init_BinarySessionStatus() {
+	return (init_BinarySessionStatus = __esmMin((() => {
+		init_BinaryTargetSummary();
+		init_toolOutputSchemaPrimitives();
+		init_unicodeCodePointOrder();
+		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 : {
+					...descriptor,
+					available: false,
+					reason: unavailable.reason
+				};
+			});
+			const capabilities = providerCapabilitySets(routeCapabilities);
+			const analysisProviderBinding = route.binding === null ? null : {
+				provider: providerSummary(route.binding.identity),
+				selection_source: route.binding.selectionSource,
+				analysis_profile: structuredClone(route.binding.profile)
+			};
+			const analysisProviderCandidates = (await router.candidateStatuses(route, signal)).map((candidate) => ({
+				provider: providerSummary(candidate.provider),
+				availability: structuredClone(candidate.availability),
+				target_support: structuredClone(candidate.targetSupport),
+				selected: candidate.selected,
+				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,
+				analysis_run: runId === undefined ? null : {
+					run_id: runId,
+					process_lineage: processLineageStatus(runtimeLineageSnapshots)
+				},
+				analysis_activity: requestActivityStatus(requestActivitySnapshots),
+				provider_operation_health: providerOperationHealthStatus(providerOperationHealth)
+			};
+			return target === undefined ? {
+				open: false,
+				...common
+			} : {
+				open: true,
+				...common,
+				...binaryTargetSummary(target)
+			};
+		};
+		requestActivityStatus = (snapshots) => {
+			const providers = snapshots.slice().sort((left, right) => compareUnicodeCodePoints(left.provider.id, right.provider.id)).map(({ provider, active, queuedRequests }) => ({
+				provider: providerSummary(provider),
+				active: active === null ? null : {
+					request_id: active.requestId,
+					operation: active.operation,
+					elapsed_ms: active.elapsedMs,
+					caller_state: active.callerState
+				},
+				queued_requests: queuedRequests
+			}));
+			const active = snapshots.flatMap((snapshot) => snapshot.active === null ? [] : [snapshot.active]);
+			return {
+				status: snapshots.length === 0 ? "not_observed" : active.length > 0 ? "busy" : "idle",
+				providers
+			};
+		};
+		providerSummary = ({ id, name, version }) => ({
+			id,
+			name,
+			version
+		});
+		processLineageStatus = (snapshots) => snapshots.length === 0 ? { status: "not_observed" } : {
+			status: "snapshots",
+			snapshots: snapshots.slice().sort((left, right) => compareUnicodeCodePoints(left.provider.id, right.provider.id)).map(({ provider, observation }) => ({
+				provider: providerSummary(provider),
+				observation: observation.status === "unavailable" ? {
+					status: observation.status,
+					observed_at: observation.observedAt,
+					launcher_pid: observation.launcherPid,
+					process_group_id: observation.processGroupId,
+					reason: observation.reason
+				} : {
+					status: observation.status,
+					observed_at: observation.observedAt,
+					launcher_pid: observation.lineage.launcherPid,
+					launcher_parent_pid: observation.lineage.launcherParentPid,
+					process_group_id: observation.lineage.processGroupId,
+					descendants: observation.lineage.descendants.map(({ pid, parentPid, processGroupId }) => ({
+						pid,
+						parent_pid: parentPid,
+						process_group_id: processGroupId
+					}))
+				}
+			}))
+		};
+		providerCapabilitySets = (descriptors) => {
+			const providers = new Map();
+			for (const descriptor of descriptors) {
+				const key = JSON.stringify([
+					descriptor.provider.id,
+					descriptor.provider.name,
+					descriptor.provider.version
+				]);
+				const provider = providers.get(key);
+				if (provider === undefined) providers.set(key, {
+					identity: descriptor.provider,
+					descriptors: [descriptor]
+				});
+				else provider.descriptors.push(descriptor);
+			}
+			return [...providers.values()].map(({ identity, descriptors: owned }) => {
+				const sharedLimitations = commonLimitationsPrefix(owned);
+				const groups = new Map();
+				for (const descriptor of owned) {
+					const effects = enabledCapabilityEffects(descriptor);
+					const limitations = descriptor.limitations.slice(sharedLimitations.length);
+					const availabilityCode = descriptor.availabilityCode ?? null;
+					const status = descriptor.available ? {
+						available: true,
+						reason: null,
+						availability_code: null
+					} : {
+						available: false,
+						reason: descriptor.reason,
+						availability_code: availabilityCode
+					};
+					const key = JSON.stringify([
+						effects,
+						limitations,
+						status.available,
+						status.reason,
+						status.availability_code
+					]);
+					const group = groups.get(key);
+					if (group === undefined) groups.set(key, {
+						operations: [descriptor.operation],
+						effects,
+						limitations,
+						...status
+					});
+					else group.operations.push(descriptor.operation);
+				}
+				return {
+					provider: providerSummary(identity),
+					shared_limitations: sharedLimitations,
+					groups: [...groups.values()]
+				};
+			});
+		};
+		commonLimitationsPrefix = (descriptors) => {
+			const first = descriptors[0]?.limitations;
+			if (first === undefined) return [];
+			let length = first.length;
+			for (const descriptor of descriptors.slice(1)) {
+				length = Math.min(length, descriptor.limitations.length);
+				let index = 0;
+				while (index < length && first[index] === descriptor.limitations[index]) index++;
+				length = index;
+			}
+			return first.slice(0, length);
+		};
+		enabledCapabilityEffects = (descriptor) => {
+			const effectValues = {
+				mutates_artifact: descriptor.effects.mutatesArtifact,
+				launches_process: descriptor.effects.launchesProcess,
+				may_show_ui: descriptor.effects.mayShowUi,
+				may_access_network: descriptor.effects.mayAccessNetwork,
+				may_write_filesystem: descriptor.effects.mayWriteFilesystem,
+				changes_permissions: descriptor.effects.changesPermissions,
+				requires_root: descriptor.effects.requiresRoot
+			};
+			return PROVIDER_EFFECT_NAMES.filter((name) => effectValues[name]);
+		};
+		providerOperationHealthStatus = (health) => {
+			if (health === undefined || health === null) return null;
+			return {
+				state: health.state,
+				stage: health.stage,
+				retry_action: health.retryAction,
+				exit_code: health.exitCode,
+				requests: health.requests.map((request) => ({
+					request_id: request.requestId,
+					operation: request.operation,
+					stage: request.stage
+				}))
+			};
+		};
+	})))();
+}
+
+//#endregion
+export { binarySessionStatus, init_BinarySessionStatus, providerCapabilitySets };