rea-agents 2.5.0 → 3.1.0

package/bridge/hopper_bridge.py

@@ -1046,29 +1046,65 @@ def _serve_connection(connection):
         if not line or len(line) > MAX_LINE_BYTES:
             break
         request_id = None
+        authenticated = False
         should_stop = False
         try:
             request = json.loads(line.decode("utf-8"))
             if set(request) != {"id", "token", "method", "params"}:
                 raise ValueError("Invalid bridge request shape")
             request_id = request["id"]
+            if isinstance(request_id, bool) or not isinstance(request_id, int) or request_id < 0:
+                raise ValueError("Invalid bridge request id")
             if not isinstance(request["token"], str) or not hmac.compare_digest(request["token"], REA_TOKEN):
                 raise PermissionError("Invalid bridge capability")
+            authenticated = True
+            _write_message(file, {"id": request_id, "event": {
+                "type": "progress",
+                "phase": "hopper_bridge",
+                "completed": 0,
+                "total": 1,
+                "message": "Hopper bridge started request",
+            }})
             result = _dispatch(request["method"], request["params"])
             should_stop = request["method"] == "shutdown_document" or (
                 request["method"] == "shutdown" and not result.get("cleanup_required", False)
             )
-            response = {"id": request_id, "result": _json_safe(result)}
+            safe_result = _json_safe(result)
+            _write_message(file, {"id": request_id, "event": {
+                "type": "progress",
+                "phase": "hopper_bridge",
+                "completed": 1,
+                "total": 1,
+                "message": "Hopper bridge completed request",
+                "terminal": True,
+            }})
+            response = {"id": request_id, "result": safe_result}
         except Exception as error:
-            response = {"id": request_id if isinstance(request_id, int) else 0, "error": {"code": -32000, "message": str(error)[:512], "type": _diagnostic_type(error)}}
-        file.write((json.dumps(response, separators=(",", ":")) + "\n").encode("utf-8"))
-        file.flush()
+            diagnostic = _safe_diagnostic(error)
+            if authenticated:
+                _write_message(file, {"id": request_id, "event": {
+                    "type": "diagnostic",
+                    "error": diagnostic,
+                }})
+            response_id = request_id if (
+                isinstance(request_id, int)
+                and not isinstance(request_id, bool)
+                and request_id >= 0
+            ) else 0
+            response = {"id": response_id, "error": diagnostic}
+        _write_message(file, response)
         if should_stop:
             break
     file.close()
     connection.close()
 
 
+def _write_message(file, message):
+    """Write and flush one compact bridge message."""
+    file.write((json.dumps(message, separators=(",", ":")) + "\n").encode("utf-8"))
+    file.flush()
+
+
 def _diagnostic_type(error):
     if isinstance(error, CapabilityUnavailableError):
         return "capability_unavailable"
@@ -1079,6 +1115,20 @@ def _diagnostic_type(error):
     return "bridge_exception"
 
 
+def _safe_diagnostic(error):
+    """Project one exception without retaining provider or credential text."""
+    diagnostic_type = _diagnostic_type(error)
+    if diagnostic_type == "capability_unavailable":
+        message = str(error)[:512]
+    elif diagnostic_type == "authorization":
+        message = "Invalid bridge capability"
+    elif diagnostic_type == "invalid_request":
+        message = "Invalid Hopper bridge request"
+    else:
+        message = "%s: Hopper bridge operation failed" % type(error).__name__[:128]
+    return {"code": -32000, "message": message, "type": diagnostic_type}
+
+
 def _run():
     """Own a permission-restricted, single-client Unix socket for this bridge."""
     if os.path.exists(REA_SOCKET):

package/dist/application/AnalysisContextQueries.js

@@ -0,0 +1,142 @@
+import { AnalysisOutputError } from "../domain/errors.js";
+import { err, ok } from "../domain/result.js";
+const parameters = (document, address) => ({
+    ...(document === undefined ? {} : { document }),
+    ...(address === undefined ? {} : { address }),
+});
+const executionOptions = (signal) => signal === undefined ? {} : { signal };
+/** Compose the provider's volatile selection state into one coherent query. */
+export const getNavigationContext = async (analysis, input, signal) => {
+    const document = input.document ??
+        (await analysis.execute("current_document", {}, executionOptions(signal)));
+    if (typeof document !== "string" && !document.ok)
+        return document;
+    const documentName = typeof document === "string" ? document : document.value.result;
+    const documentArgs = typeof documentName === "string" ? parameters(documentName) : {};
+    const address = await analysis.execute("current_address", documentArgs, executionOptions(signal));
+    if (!address.ok)
+        return address;
+    if (typeof address.value.result !== "string")
+        return ok({
+            document: documentName,
+            address: address.value.result,
+            procedure: null,
+        });
+    const procedure = await analysis.execute("resolve_containing_procedure", parameters(typeof documentName === "string" ? documentName : undefined, address.value.result), executionOptions(signal));
+    if (!procedure.ok) {
+        if (!isMissingCurrentProcedure(procedure.error))
+            return procedure;
+        return ok({
+            document: documentName,
+            address: address.value.result,
+            procedure: null,
+        });
+    }
+    return ok({
+        document: documentName,
+        address: address.value.result,
+        procedure: containingProcedureName(procedure.value.result),
+    });
+};
+/** Inspect bounded provider-neutral facets at one explicit reproducible address. */
+export const inspectAddressContext = async (analysis, input, signal) => {
+    const document = await resolveDocument(analysis, input.document, signal);
+    if (!document.ok)
+        return document;
+    const args = parameters(document.value, input.address);
+    const operations = [
+        "address_name",
+        "resolve_containing_procedure",
+        "comment",
+        "inline_comment",
+        "list_bookmarks",
+    ];
+    const results = await Promise.all(operations.map((operation) => analysis.execute(operation, operation === "list_bookmarks" ? parameters(document.value) : args, executionOptions(signal))));
+    for (const result of results) {
+        if (!result.ok && isRequestLevelFailure(result.error))
+            return result;
+    }
+    const name = facet(results[0], operations[0]);
+    const procedure = facet(results[1], operations[1]);
+    const comment = facet(results[2], operations[2]);
+    const inlineComment = facet(results[3], operations[3]);
+    const bookmarks = facet(results[4], operations[4]);
+    return ok({
+        address: input.address,
+        document: document.value,
+        name,
+        procedure,
+        comment,
+        inline_comment: inlineComment,
+        bookmarks: bookmarks.state === "available"
+            ? matchingBookmarks(bookmarks.value, resolvedAddress(results[1], input.address))
+            : bookmarks,
+    });
+};
+const resolveDocument = async (analysis, document, signal) => {
+    if (document !== undefined)
+        return ok(document);
+    const current = await analysis.execute("current_document", {}, executionOptions(signal));
+    if (!current.ok)
+        return current;
+    return typeof current.value.result === "string"
+        ? ok(current.value.result)
+        : err(new AnalysisOutputError("current_document", "expected a document identity string"));
+};
+const facet = (result, operation) => result?.ok === true
+    ? { state: "available", value: result.value.result }
+    : {
+        state: "unavailable",
+        reason: result?.error.message ?? `${operation} returned no result`,
+        remediation: `Call ${operation} directly to inspect provider availability and diagnostics.`,
+    };
+const isMissingCurrentProcedure = (error) => /(?:no procedure exists|not in a procedure)/iu.test(error.message);
+const isRequestLevelFailure = (error) => error._tag === "AnalysisCancelledError" ||
+    error._tag === "AnalysisTimeoutError" ||
+    error._tag === "NoBinaryOpenError" ||
+    error._tag === "PermissionRequiredError";
+const containingProcedureName = (value) => {
+    if (typeof value !== "object" || value === null || Array.isArray(value))
+        return null;
+    if (value.found !== true)
+        return null;
+    const procedure = value.procedure;
+    if (typeof procedure !== "object" ||
+        procedure === null ||
+        Array.isArray(procedure))
+        return null;
+    return typeof procedure.name === "string" ? procedure.name : null;
+};
+const resolvedAddress = (result, fallback) => {
+    if (result?.ok !== true)
+        return fallback;
+    const value = result.value.result;
+    if (typeof value !== "object" || value === null || Array.isArray(value))
+        return fallback;
+    return typeof value.query_address === "string"
+        ? value.query_address
+        : fallback;
+};
+const matchingBookmarks = (value, address) => {
+    if (!Array.isArray(value))
+        return {
+            state: "unavailable",
+            reason: "list_bookmarks returned malformed output; expected an array.",
+            remediation: "Retry list_bookmarks directly and report the provider output shape if it remains malformed.",
+        };
+    if (!value.every(isBookmark))
+        return {
+            state: "unavailable",
+            reason: "list_bookmarks returned malformed entries; expected address and name strings.",
+            remediation: "Retry list_bookmarks directly and report the provider output shape if it remains malformed.",
+        };
+    return {
+        state: "available",
+        value: value.filter((bookmark) => bookmark.address === address),
+    };
+};
+const isBookmark = (value) => typeof value === "object" &&
+    value !== null &&
+    !Array.isArray(value) &&
+    typeof value.address === "string" &&
+    typeof value.name === "string";

package/dist/application/AnalysisSnapshotCache.js

@@ -1,7 +1,7 @@
 import { EvidenceIntegrityError, NoBinaryOpenError, } from "../domain/errors.js";
 import { err, ok } from "../domain/result.js";
 import { analysisQueryId, createAnalysisSnapshotEntry, snapshotBinding, snapshotMatchesProfile, snapshotMatchesTarget, snapshotTarget, } from "../domain/analysisSnapshot.js";
-import { OFFICIAL_TOOL_CONTRACTS } from "../contracts/toolContracts.js";
+import { GENERATED_MCP_TOOL_CATALOG } from "../generatedMcpToolCatalog.js";
 const STATEFUL_OPERATIONS = new Set([
     "health",
     "current_address",
@@ -19,7 +19,9 @@ const CURSOR_DEFAULT_OPERATIONS = new Set([
     "prev_address",
     "xrefs",
 ]);
-const DOCUMENT_SCOPED_OPERATIONS = new Set(OFFICIAL_TOOL_CONTRACTS.map(({ name }) => name).filter((name) => name !== "current_document" &&
+const DOCUMENT_SCOPED_OPERATIONS = new Set(GENERATED_MCP_TOOL_CATALOG.filter(({ kind }) => kind === "official-proxy")
+    .map(({ name }) => name)
+    .filter((name) => name !== "current_document" &&
     name !== "list_documents" &&
     name !== "set_current_document"));
 /** Whether an operation is immutable and independent of provider UI state. */

package/dist/application/ApplicationWorkflowEvidenceResolver.js

@@ -36,7 +36,7 @@ export const resolveTraceApplicationFeatureRequest = (input, lookup) => {
 };
 /** Resolve a trace request already parsed by the caller-facing contract. */
 export const resolveTraceApplicationFeatureRequestValidated = (input, lookup) => {
-    const application = graphEvidence(input.application, input.application_evidence_id, lookup);
+    const application = graphEvidence(input, lookup);
     if (!application.ok)
         return application;
     const native = resolveEvidenceReferences(lookup, input.native_observation_evidence_ids);
@@ -63,7 +63,7 @@ export const resolveTraceJavaScriptSemanticsRequest = (input, lookup) => {
 };
 /** Resolve a semantic trace request already parsed by its public contract. */
 export const resolveTraceJavaScriptSemanticsRequestValidated = (input, lookup) => {
-    const application = graphEvidence(input.application, input.application_evidence_id, lookup);
+    const application = graphEvidence(input, lookup);
     if (!application.ok)
         return application;
     const raw = { application: application.value, query: input.query };
@@ -81,10 +81,14 @@ export const resolveCompareApplicationVersionsRequest = (input, lookup) => {
 };
 /** Resolve a comparison request parsed by the caller-facing contract. */
 export const resolveCompareApplicationVersionsRequestValidated = (input, lookup) => {
-    const left = graphEvidence(input.left, input.left_evidence_id, lookup);
+    const left = graphEvidence("left" in input
+        ? { application: input.left }
+        : { application_evidence_id: input.left_evidence_id }, lookup);
     if (!left.ok)
         return left;
-    const right = graphEvidence(input.right, input.right_evidence_id, lookup);
+    const right = graphEvidence("right" in input
+        ? { application: input.right }
+        : { application_evidence_id: input.right_evidence_id }, lookup);
     if (!right.ok)
         return right;
     const leftNative = resolveEvidenceReferences(lookup, input.left_native_observation_evidence_ids);
@@ -123,7 +127,7 @@ export const resolveCompareSourceToBundleRequest = (input, lookup) => {
 };
 /** Resolve a historical-source comparison request parsed by its public contract. */
 export const resolveCompareSourceToBundleRequestValidated = (input, lookup) => {
-    const application = graphEvidence(input.application, input.application_evidence_id, lookup);
+    const application = graphEvidence(input, lookup);
     if (!application.ok)
         return application;
     const raw = {
@@ -148,10 +152,14 @@ export const resolveCompareJavaScriptExportShapesRequest = (input, lookup) => {
 };
 /** Resolve an export-shape request already parsed by the adapter contract. */
 export const resolveCompareJavaScriptExportShapesRequestValidated = (input, lookup) => {
-    const left = graphEvidence(input.left, input.left_evidence_id, lookup);
+    const left = graphEvidence("left" in input
+        ? { application: input.left }
+        : { application_evidence_id: input.left_evidence_id }, lookup);
     if (!left.ok)
         return left;
-    const right = graphEvidence(input.right, input.right_evidence_id, lookup);
+    const right = graphEvidence("right" in input
+        ? { application: input.right }
+        : { application_evidence_id: input.right_evidence_id }, lookup);
     if (!right.ok)
         return right;
     const raw = {
@@ -171,10 +179,10 @@ export const resolveCompareJavaScriptExportShapesRequestValidated = (input, look
         ? ok(parsed.data)
         : invalid("compare_javascript_export_shapes", parsed.error, raw);
 };
-const graphEvidence = (evidence, evidenceId, lookup) => {
-    if (evidence !== undefined)
-        return ok(evidence);
-    const resolved = resolveEvidenceReferences(lookup, evidenceId === undefined ? [] : [evidenceId], APPLICATION_GRAPH_IDENTITIES);
+const graphEvidence = (source, lookup) => {
+    if ("application" in source)
+        return ok(source.application);
+    const resolved = resolveEvidenceReferences(lookup, [source.application_evidence_id], APPLICATION_GRAPH_IDENTITIES);
     return resolved.ok ? ok(resolved.value[0]) : resolved;
 };
 const invalid = (operation, cause, input) => err(new AnalysisInputError(operation, undefined, projectInputIssues(cause.issues, input)));

package/dist/application/ArtifactInventory/policy.js

@@ -0,0 +1,17 @@
+import { ArtifactReaderFailure } from "../../artifacts/ArtifactReader.js";
+/** Resolve caller approval and operator policy before native reader selection. */
+export const resolveNativeMountPolicy = (approved, enabled) => {
+    if (!approved)
+        return { status: "disabled" };
+    if (!enabled)
+        throw new ArtifactReaderFailure("unavailable", "Native DMG mounting is disabled by operator policy");
+    return { status: "approved" };
+};
+/** Resolve parsed caller intent and operator policy before artifact scanning. */
+export const resolveArtifactIntegrityPolicy = (intent, enabled) => {
+    if (intent.mode === "fail")
+        return intent;
+    if (!enabled)
+        throw new ArtifactReaderFailure("policy", "Integrity continuation requires explicit approval and operator policy");
+    return intent;
+};

package/dist/application/ArtifactInventory/reader.js

@@ -1,5 +1,4 @@
 import { AsarArtifactReader } from "../../artifacts/AsarArtifactReader.js";
-import { ArtifactReaderFailure, } from "../../artifacts/ArtifactReader.js";
 import { DirectoryArtifactReader } from "../../artifacts/DirectoryArtifactReader.js";
 import { MachOSliceArtifactReader } from "../../artifacts/MachOSliceArtifactReader.js";
 import { NativeDmgArtifactReader } from "../../artifacts/NativeDmgArtifactReader.js";
@@ -21,10 +20,8 @@ export const createReader = async (path, format, nativeMount, signal) => {
                 ? new MachOSliceArtifactReader(path)
                 : undefined;
         case "dmg":
-            if (!nativeMount.nativeMountApproved)
+            if (nativeMount.status === "disabled")
                 return undefined;
-            if (!nativeMount.nativeMountEnabled)
-                throw new ArtifactReaderFailure("unavailable", "Native DMG mounting is disabled by operator policy");
             return NativeDmgArtifactReader.create(path, signal);
         default:
             return undefined;

package/dist/application/ArtifactInventory/scanCanonical.js

@@ -10,9 +10,6 @@ import { scanReader, } from "./scanReader.js";
 import { NATIVE_MOUNT_DISABLED, STRICT_INTEGRITY_POLICY, } from "./types.js";
 export const scanCanonicalArtifactInventory = async (path, limits, options = {}) => {
     const integrity = options.integrity ?? STRICT_INTEGRITY_POLICY;
-    if (integrity.mode === "record-and-continue" &&
-        (!integrity.approved || !integrity.enabled))
-        throw new ArtifactReaderFailure("unavailable", "Integrity continuation requires explicit approval and operator policy");
     const metadata = await lstat(path);
     const rootFormat = await classifyRoot(path, metadata.isDirectory());
     const rootDigest = metadata.isDirectory()

package/dist/application/ArtifactInventory/scanReader.js

@@ -69,14 +69,14 @@ const digestArtifactEntry = async (context, currentReader, entry, logicalPath) =
     const digest = await hashReadable(await currentReader.open(entry, context.signal), Math.min(context.limits.maxEntryBytes, remainingBytes), context.signal);
     context.totalBytes += digest.bytes;
     const mismatched = entry.declaredSha256 !== null && entry.declaredSha256 !== digest.sha256;
-    if (mismatched && context.integrity.mode === "fail")
-        throw new ArtifactReaderFailure("integrity", `Artifact integrity metadata disagrees with content: ${logicalPath}`, undefined, {
-            logicalPath,
-            declaredSha256: entry.declaredSha256,
-            calculatedSha256: digest.sha256,
-            unpacked: entry.unpacked,
-        });
     if (mismatched && entry.declaredSha256 !== null) {
+        if (context.integrity.mode === "fail")
+            throw new ArtifactReaderFailure("integrity", `Artifact integrity metadata disagrees with content: ${logicalPath}`, undefined, {
+                logicalPath,
+                declaredSha256: entry.declaredSha256,
+                calculatedSha256: digest.sha256,
+                unpacked: entry.unpacked,
+            });
         if (context.pendingContradictions.length >= context.integrity.maxMismatches)
             throw new ArtifactReaderFailure("limit", "Artifact integrity mismatch limit exceeded");
         context.pendingContradictions.push({

package/dist/application/ArtifactInventory/types.js

@@ -1,10 +1,6 @@
 export const NATIVE_MOUNT_DISABLED = {
-    nativeMountApproved: false,
-    nativeMountEnabled: false,
+    status: "disabled",
 };
 export const STRICT_INTEGRITY_POLICY = {
     mode: "fail",
-    approved: false,
-    enabled: false,
-    maxMismatches: 1,
 };

package/dist/application/BinarySession.js

@@ -2,15 +2,15 @@ import { randomUUID } from "node:crypto";
 import { analysisProfilesEqual, } from "../domain/analysisProfile.js";
 import { AnalysisCancelledError, ProviderAdapterError, } from "../domain/errors.js";
 import { err, ok } from "../domain/result.js";
-import { enhancedToolNameSchema } from "../contracts/enhancedInputs.js";
-import { OFFICIAL_TOOL_CONTRACTS } from "../contracts/toolContracts.js";
+import { GENERATED_MCP_TOOL_CATALOG } from "../generatedMcpToolCatalog.js";
 import { SessionProviderRouter, } from "./SessionProviderRouter.js";
 import { BinarySessionRecords } from "./BinarySessionRecords.js";
 import { binarySessionStatus } from "./BinarySessionStatus.js";
 import { resolveSessionOpen, } from "./BinarySessionOpen.js";
 import { prepareSessionExecution } from "./BinarySessionExecution.js";
 import { closeAnalysisClient } from "./AnalysisClientCleanup.js";
-const OFFICIAL_OPERATIONS = new Set(OFFICIAL_TOOL_CONTRACTS.map(({ name }) => name));
+const OFFICIAL_OPERATIONS = new Set(GENERATED_MCP_TOOL_CATALOG.filter(({ kind }) => kind === "official-proxy").map(({ name }) => name));
+const ENHANCED_OPERATIONS = new Set(GENERATED_MCP_TOOL_CATALOG.filter(({ kind }) => kind === "enhanced").map(({ name }) => name));
 /**
  * Owns the single active target shared by CLI and MCP adapters.
  *
@@ -24,7 +24,7 @@ export class BinarySession extends BinarySessionRecords {
     #transition = Promise.resolve();
     #calls = new Set();
     #providerRouter;
-    #runtimeAvailability = new Map();
+    #runtimeUnavailability = new Map();
     #availabilityListeners = new Set();
     constructor(provider, options = {}) {
         super();
@@ -42,7 +42,7 @@ export class BinarySession extends BinarySessionRecords {
             const exact = route.capabilities?.get(operation)?.provider;
             if (exact !== undefined)
                 selected = exact;
-            else if (enhancedToolNameSchema.safeParse(operation).success) {
+            else if (ENHANCED_OPERATIONS.has(operation)) {
                 const providers = new Map();
                 for (const descriptor of route.capabilities?.values() ?? [])
                     if (descriptor.available &&
@@ -112,6 +112,7 @@ export class BinarySession extends BinarySessionRecords {
                     if (!imported.ok)
                         return imported;
                 }
+                this.resetSnapshotInvalidation();
                 return ok(target);
             }
             await this.#drainCalls();
@@ -184,7 +185,7 @@ export class BinarySession extends BinarySessionRecords {
             target: this.#active?.target,
             route: this.#currentRoute(),
             router: this.#providerRouter,
-            runtimeAvailability: this.#runtimeAvailability,
+            runtimeUnavailability: this.#runtimeUnavailability,
             runId: this.#active?.runId,
             runtimeLineageSnapshots: this.#active?.client.runtimeLineageSnapshots?.() ?? [],
             requestActivitySnapshots: this.#active?.client.requestActivitySnapshots?.() ?? [],
@@ -245,12 +246,12 @@ export class BinarySession extends BinarySessionRecords {
     }
     #observeRuntimeAvailability(operation, result) {
         if (result.ok) {
-            if (this.#setRuntimeAvailability(operation, true, null))
+            if (this.#markRuntimeAvailable(operation))
                 this.#emitAvailabilityChanged();
             return;
         }
         if (result.error._tag === "AnalysisCapabilityUnavailableError") {
-            if (this.#setRuntimeAvailability(operation, false, result.error.message))
+            if (this.#markRuntimeUnavailable(operation, result.error.message))
                 this.#emitAvailabilityChanged();
             return;
         }
@@ -266,27 +267,25 @@ export class BinarySession extends BinarySessionRecords {
             for (const descriptor of capabilities?.values() ?? [])
                 if (providerId !== undefined && descriptor.provider.id === providerId)
                     changed =
-                        this.#setRuntimeAvailability(descriptor.operation, false, "Provider became unavailable during this session.") || changed;
+                        this.#markRuntimeUnavailable(descriptor.operation, "Provider became unavailable during this session.") || changed;
             if (changed)
                 this.#emitAvailabilityChanged();
         }
     }
-    #setRuntimeAvailability(operation, available, reason) {
-        const current = this.#runtimeAvailability.get(operation);
-        if (current?.available === available && current.reason === reason)
-            return false;
-        if (available && current === undefined)
+    #markRuntimeAvailable(operation) {
+        return this.#runtimeUnavailability.delete(operation);
+    }
+    #markRuntimeUnavailable(operation, reason) {
+        const current = this.#runtimeUnavailability.get(operation);
+        if (current?.reason === reason)
             return false;
-        if (available)
-            this.#runtimeAvailability.delete(operation);
-        else
-            this.#runtimeAvailability.set(operation, { available, reason });
+        this.#runtimeUnavailability.set(operation, { reason });
         return true;
     }
     #clearRuntimeAvailability() {
-        if (this.#runtimeAvailability.size === 0)
+        if (this.#runtimeUnavailability.size === 0)
             return;
-        this.#runtimeAvailability.clear();
+        this.#runtimeUnavailability.clear();
         this.#emitAvailabilityChanged();
     }
     #emitAvailabilityChanged() {

package/dist/application/BinarySessionComposition.js

@@ -0,0 +1,21 @@
+import { AnalysisProviderRegistry } from "./AnalysisProviderRegistry.js";
+import { BinarySession } from "./BinarySession.js";
+import { SessionProviderRouter } from "./SessionProviderRouter.js";
+const normalizeBinarySessionOptions = (optionsOrResolver) => typeof optionsOrResolver === "function"
+    ? { resolveAnalysisProfile: optionsOrResolver }
+    : (optionsOrResolver ?? {});
+/**
+ * Compose one provider-neutral session from deep-provider selection and
+ * disjoint auxiliary operation families.
+ */
+export const composeBinarySession = (registry, auxiliaryProviders = []) => new BinarySession(registry instanceof SessionProviderRouter
+    ? registry
+    : SessionProviderRouter.selectable(registry, auxiliaryProviders));
+/**
+ * Compose a session through the same internal seam for focused adapter tests.
+ * The constructor remains private to this composition module, so callers test
+ * provider behavior without coupling to BinarySession construction.
+ */
+export const composeBinarySessionFromFactory = (provider, optionsOrResolver) => new BinarySession(provider, normalizeBinarySessionOptions(optionsOrResolver));
+/** Compose a focused session from any provider-shaped test seam. */
+export const composeBinarySessionFromProvider = (provider, optionsOrResolver) => new BinarySession(provider, normalizeBinarySessionOptions(optionsOrResolver));