rea-agents 6.4.0 → 6.7.0

package/dist/mcp/ArtifactProviderMetadata-UCJr2oZW.js

@@ -0,0 +1,167 @@
+import { t as __esmMin } from "./rolldown-runtime-BjeaiXFo.js";
+import { i as init_ArtifactReader, t as ArtifactReaderFailure } from "./ArtifactReader-BrnwNaKY.js";
+import { P as init_InvestigationProviders, v as ARTIFACT_GRAPH_PROVIDER } from "./callerPath-CpPnMZyN.js";
+import { o as init_artifactToolContracts, t as ARTIFACT_ANALYSIS_OPERATIONS } from "./artifactToolContracts-C9dRDo-D.js";
+import { Readable } from "node:stream";
+
+//#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/filesystem/readFileHandleChunks.js
+var FileReadCancelled, readFileHandleChunks, fileOffset;
+function init_readFileHandleChunks() {
+	return (init_readFileHandleChunks = __esmMin((() => {
+		FileReadCancelled = class extends Error {
+			reason;
+			constructor(reason) {
+				super("File read cancelled", { cause: reason });
+				this.reason = reason;
+				this.name = "FileReadCancelled";
+			}
+		};
+		readFileHandleChunks = (handle, options = {}) => {
+			const start = fileOffset(options.start ?? 0);
+			const unlimited = options.end === undefined || options.end === Infinity;
+			const end = unlimited ? undefined : fileOffset(options.end);
+			if (start === undefined || !unlimited && end === undefined || end !== undefined && end < start) throw new RangeError("Invalid file read range");
+			let readPending = false;
+			let totalBytes = 0n;
+			let coverage;
+			const cancellationFailure = () => options.cancellationFailure?.(options.signal?.reason) ?? new FileReadCancelled(options.signal?.reason);
+			const assertActive = () => {
+				if (options.signal?.aborted) throw cancellationFailure();
+			};
+			const source = Readable.from((async function* () {
+				let position = start;
+				while (end === undefined || position <= end) {
+					assertActive();
+					const remaining = end === undefined ? undefined : end - position + 1n;
+					const chunk = Buffer.allocUnsafe(remaining === undefined || remaining > 64n * 1024n ? 64 * 1024 : Number(remaining));
+					readPending = true;
+					let bytesRead;
+					try {
+						({bytesRead} = await handle.read(chunk, 0, chunk.length, position));
+					} finally {
+						readPending = false;
+					}
+					totalBytes += BigInt(bytesRead);
+					if (bytesRead === 0) coverage = Object.freeze({
+						kind: "complete",
+						bytes: totalBytes,
+						boundary: "eof"
+					});
+					else if (end !== undefined && position + BigInt(bytesRead) > end) coverage = Object.freeze({
+						kind: "complete",
+						bytes: totalBytes,
+						boundary: "range"
+					});
+					assertActive();
+					if (bytesRead === 0) return;
+					position += BigInt(bytesRead);
+					yield chunk.subarray(0, bytesRead);
+				}
+			})(), { objectMode: false });
+			const onAbort = () => {
+				if (!readPending && !source.destroyed) source.destroy(cancellationFailure());
+			};
+			options.signal?.addEventListener("abort", onAbort, { once: true });
+			source.once("close", () => options.signal?.removeEventListener("abort", onAbort));
+			if (options.signal?.aborted) onAbort();
+			return Object.assign(source, { readCoverage: () => coverage ?? Object.freeze({
+				kind: "incomplete",
+				bytes: totalBytes
+			}) });
+		};
+		fileOffset = (value) => {
+			if (typeof value === "bigint") return value >= 0n ? value : undefined;
+			return Number.isSafeInteger(value) && value >= 0 ? BigInt(value) : undefined;
+		};
+	})))();
+}
+
+//#endregion
+//#region dist/artifacts/readArtifactFileChunks.js
+var readArtifactFileChunks;
+function init_readArtifactFileChunks() {
+	return (init_readArtifactFileChunks = __esmMin((() => {
+		init_readFileHandleChunks();
+		init_ArtifactReader();
+		readArtifactFileChunks = (handle, options = {}) => readFileHandleChunks(handle, {
+			...options,
+			cancellationFailure: (reason) => new ArtifactReaderFailure("cancelled", "Artifact file read cancelled", { cause: reason })
+		});
+	})))();
+}
+
+//#endregion
+//#region dist/artifacts/ArtifactProviderMetadata.js
+var artifactCapabilities;
+function init_ArtifactProviderMetadata() {
+	return (init_ArtifactProviderMetadata = __esmMin((() => {
+		init_InvestigationProviders();
+		init_artifactToolContracts();
+		artifactCapabilities = (platform = process.platform) => Object.freeze(ARTIFACT_ANALYSIS_OPERATIONS.map((operation) => {
+			const common = {
+				provider: ARTIFACT_GRAPH_PROVIDER,
+				operation,
+				effects: Object.freeze({
+					mutatesArtifact: false,
+					launchesProcess: operation !== "decode_interface_builder" && operation !== "inspect_keyed_archive" && operation !== "trace_dylib_resolution",
+					mayShowUi: false,
+					mayAccessNetwork: false,
+					mayWriteFilesystem: operation === "extract_artifact" || operation === "inspect_artifact" || operation === "inventory_artifact",
+					changesPermissions: false,
+					requiresRoot: false
+				}),
+				limitations: Object.freeze(["DMG child inventory automatically uses a read-only native macOS mount; PKG remains root-hash-only.", "ASAR files discovered in filesystem-backed inventories are expanded without bulk extraction; other nested containers remain recorded only."])
+			};
+			return Object.freeze(operation === "inspect_asset_catalog" && platform !== "darwin" ? {
+				...common,
+				available: false,
+				availabilityCode: "unsupported_host",
+				reason: "Apple asset catalogs require macOS assetutil."
+			} : {
+				...common,
+				available: true,
+				reason: null
+			});
+		}));
+	})))();
+}
+
+//#endregion
+export { OwnedDirectoryHandle as a, readArtifactFileChunks as i, init_ArtifactProviderMetadata as n, init_OwnedDirectoryHandle as o, init_readArtifactFileChunks as r, artifactCapabilities as t };

package/dist/mcp/ArtifactReader-BrnwNaKY.js

@@ -0,0 +1,78 @@
+import { t as __esmMin } from "./rolldown-runtime-BjeaiXFo.js";
+import { D as AnalysisError, O as init_analysisErrorBase } from "./analysisErrorCore-BIEP7tvF.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 { sameArtifactEntry as a, init_ArtifactReader as i, artifactPrimaryCleanupLeases as n, sameArtifactSourceIdentity as o, copyArtifactEntry as r, ArtifactReaderFailure as t };

package/dist/mcp/ArtifactResourceScope-zi3Dkqzy.js

@@ -0,0 +1,175 @@
+import { t as __esmMin } from "./rolldown-runtime-BjeaiXFo.js";
+import { i as init_ArtifactReader, n as artifactPrimaryCleanupLeases, t as ArtifactReaderFailure } from "./ArtifactReader-BrnwNaKY.js";
+import { a as init_AnalysisCleanupLease, r as AnalysisCleanupLease } from "./providerCleanupError-DIRHxzWo.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 { ArtifactResourceScope as n, init_ArtifactResourceScope as r, ArtifactResourceRetryFailure as t };

package/dist/mcp/AsarHeader-B_IbppTz.js

@@ -0,0 +1,31 @@
+import { t as __esmMin } from "./rolldown-runtime-BjeaiXFo.js";
+import { i as init_ArtifactReader, t as ArtifactReaderFailure } from "./ArtifactReader-BrnwNaKY.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 { admitAsarHeader as n, init_AsarHeader as r, MAX_ASAR_HEADER_BYTES as t };

package/dist/mcp/BinarySessionStatus-CZ9nnXMt.js

@@ -0,0 +1,213 @@
+import { t as __esmMin } from "./rolldown-runtime-BjeaiXFo.js";
+import { D as PROVIDER_EFFECT_NAMES, R as init_toolOutputSchemaPrimitives } from "./nativeValueTrace-BEZbDieM.js";
+import { l as init_unicodeCodePointOrder, s as compareUnicodeCodePoints } from "./providerOperationHealth-9DRSGM8N.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 { init_BinaryTargetSummary as a, binaryTargetSummary as i, init_BinarySessionStatus as n, providerCapabilitySets as r, binarySessionStatus as t };