rea-agents 6.1.0 → 6.2.0

package/dist/application/binary/AnalysisSnapshotCache.js

@@ -31,7 +31,8 @@ export const isSnapshotCacheable = (operation, descriptor, parameters) => !STATE
         typeof parameters.address === "string") &&
     descriptor?.effects.mutatesArtifact === false &&
     descriptor.cachePolicy !== "live" &&
-    descriptor.effects.mayWriteFilesystem === false &&
+    (descriptor.cachePolicy === "snapshot" ||
+        descriptor.effects.mayWriteFilesystem === false) &&
     descriptor.effects.changesPermissions === false;
 /** Bounded in-memory cache for one immutable binary identity. */
 export class AnalysisSnapshotCache {
@@ -72,7 +73,7 @@ export class AnalysisSnapshotCache {
                 imported += 1;
             this.#entries.set(entry.query_id, structuredClone(entry));
         }
-        for (const entry of snapshot.workflow_entries ?? []) {
+        for (const entry of snapshot.workflow_entries) {
             if (!this.#workflowEntries.has(entry.query_id) && !this.#hasCapacity())
                 continue;
             this.#workflowEntries.set(entry.query_id, structuredClone(entry));
@@ -86,15 +87,16 @@ export class AnalysisSnapshotCache {
         try {
             const snapshotTargetIdentity = snapshotTarget(target);
             const binding = snapshotBinding(profile);
-            const retainedEvidence = structuredClone(evidenceBundle);
+            const entries = [...this.#entries.values()].sort((left, right) => left.query_id.localeCompare(right.query_id));
+            const workflows = [...this.#workflowEntries.values()].sort((left, right) => left.query_id.localeCompare(right.query_id));
+            // Parsing owns the returned JSON and metadata; pre-cloning the same
+            // payloads here only adds another full materialization.
             return ok(parseAnalysisSnapshot({
                 target: snapshotTargetIdentity,
                 binding,
-                entries: this.entries(),
-                ...(this.workflowEntries().length === 0
-                    ? {}
-                    : { workflow_entries: this.workflowEntries() }),
-                evidence_bundle: retainedEvidence,
+                entries,
+                workflow_entries: workflows,
+                evidence_bundle: evidenceBundle,
             }));
         }
         catch (cause) {

package/dist/application/binary/BinarySession.js

@@ -13,7 +13,7 @@ import { BinarySessionRecords } from "./BinarySessionRecords.js";
 import { binarySessionStatus } from "./BinarySessionStatus.js";
 import { resolveSessionOpen, resolveSessionTarget, validateResolvedSessionTarget, } from "./BinarySessionOpen.js";
 import { bindExecutionTarget, commitExecutionProfile, prepareSessionExecution, } from "./BinarySessionExecution.js";
-import { closeAnalysisClient } from "./AnalysisClientCleanup.js";
+import { analysisErrorWithCleanupFailure, closeAnalysisClient, } from "./AnalysisClientCleanup.js";
 const OFFICIAL_OPERATIONS = new Set(OFFICIAL_TOOL_CONTRACTS.map(({ name }) => name));
 const ENHANCED_OPERATIONS = new Set(ENHANCED_TOOL_CONTRACTS.map(({ name }) => name));
 /**
@@ -25,6 +25,7 @@ const ENHANCED_OPERATIONS = new Set(ENHANCED_TOOL_CONTRACTS.map(({ name }) => na
  */
 export class BinarySession extends BinarySessionRecords {
     #active;
+    #pendingCleanup;
     #transition = Promise.resolve();
     #transitionGeneration = 0;
     #calls = new Map();
@@ -38,14 +39,14 @@ export class BinarySession extends BinarySessionRecords {
     /** Identify the provider producing evidence for this session. */
     providerIdentity(operation) {
         const route = this.#currentRoute();
-        let selected = route.identity;
+        let selected = route.binding?.identity ?? route.identity;
         if (operation !== undefined) {
-            const exact = route.capabilities?.get(operation)?.provider;
+            const exact = route.capabilities.get(operation)?.provider;
             if (exact !== undefined)
                 selected = exact;
             else if (ENHANCED_OPERATIONS.has(operation)) {
                 const providers = new Map();
-                for (const descriptor of route.capabilities?.values() ?? [])
+                for (const descriptor of route.capabilities.values())
                     if (descriptor.available &&
                         OFFICIAL_OPERATIONS.has(descriptor.operation))
                         providers.set(descriptor.provider.id, descriptor.provider);
@@ -81,10 +82,6 @@ export class BinarySession extends BinarySessionRecords {
             return undefined;
         return structuredClone(profile);
     }
-    /** Return opaque adapter metadata retained for legacy open_binary output. */
-    openCompatibility() {
-        return structuredClone(this.#active?.compatibility ?? {});
-    }
     /** Observe runtime provider-health changes that affect discovery metadata. */
     onAvailabilityChanged(listener) {
         this.#availabilityListeners.add(listener);
@@ -134,7 +131,7 @@ export class BinarySession extends BinarySessionRecords {
             if (!resolved.ok)
                 return resolved;
             const { target, route, sameTarget } = resolved.value;
-            const { profile, compatibility } = route;
+            const { profile } = route;
             if (isAborted(options.signal))
                 return err(new AnalysisCancelledError("open_binary"));
             const activeProfile = this.#active?.profile;
@@ -142,6 +139,11 @@ export class BinarySession extends BinarySessionRecords {
                 ? profile === null
                 : profile !== null && analysisProfilesEqual(activeProfile, profile);
             await this.#drainCalls(admittedThrough);
+            if (isAborted(options.signal))
+                return err(new AnalysisCancelledError("open_binary"));
+            const pendingClosed = await this.#retryPendingCleanup();
+            if (!pendingClosed.ok)
+                return pendingClosed;
             if (isAborted(options.signal))
                 return err(new AnalysisCancelledError("open_binary"));
             if (sameTarget && sameProfile) {
@@ -155,31 +157,28 @@ export class BinarySession extends BinarySessionRecords {
             const previous = this.#active;
             this.#active = undefined;
             if (previous !== undefined) {
-                const closed = await closeAnalysisClient(previous.client, previous.route.identity.id);
+                const closed = await this.#retireClient(previous.client, previous.route.identity.id);
                 if (!closed.ok) {
                     this.clearSessionRecords();
                     this.#clearRuntimeAvailability();
                     return closed;
                 }
             }
+            if (isAborted(options.signal))
+                return err(await this.#restoreAfterFailedOpen(previous, new AnalysisCancelledError("open_binary")));
             const runId = randomUUID();
             const client = route.createClient(target, { runId });
             const started = await client.execute("health", {}, options);
             if (!started.ok) {
-                await client.close();
-                await this.#restore(previous);
-                return started;
+                return err(await this.#failedOpen(client, route.identity.id, previous, started.error));
             }
             if (isAborted(options.signal)) {
-                await client.close();
-                await this.#restore(previous);
-                return err(new AnalysisCancelledError("open_binary"));
+                return err(await this.#failedOpen(client, route.identity.id, previous, new AnalysisCancelledError("open_binary")));
             }
             this.#active = {
                 target,
                 client,
                 profile,
-                compatibility: structuredClone(compatibility),
                 route,
                 runId,
             };
@@ -195,9 +194,7 @@ export class BinarySession extends BinarySessionRecords {
                 const imported = this.importAnalysisSnapshot(options.snapshot);
                 if (!imported.ok) {
                     this.#active = undefined;
-                    await client.close();
-                    await this.#restore(previous);
-                    return imported;
+                    return err(await this.#failedOpen(client, route.identity.id, previous, imported.error));
                 }
             }
             return ok(target);
@@ -222,7 +219,12 @@ export class BinarySession extends BinarySessionRecords {
                 return written;
             const closed = await this.#closeActive(options);
             return closed.ok
-                ? ok({ ...written.value, entries: snapshot.value.entries.length })
+                ? ok({
+                    ...written.value,
+                    primitive_entries: snapshot.value.entries.length,
+                    workflow_entries: snapshot.value.workflow_entries.length,
+                    evidence_records: snapshot.value.evidence_bundle.records.length,
+                })
                 : closed;
         });
     }
@@ -230,8 +232,8 @@ export class BinarySession extends BinarySessionRecords {
         const previous = this.#active;
         this.#active = undefined;
         const closed = previous === undefined
-            ? ok(null)
-            : await closeAnalysisClient(previous.client, previous.route.identity.id, {
+            ? await this.#retryPendingCleanup(options.progress, options.retainProviderDocuments)
+            : await this.#retireClient(previous.client, previous.route.identity.id, {
                 ...(options.progress === undefined
                     ? {}
                     : { progress: options.progress }),
@@ -243,6 +245,42 @@ export class BinarySession extends BinarySessionRecords {
         this.#clearRuntimeAvailability();
         return closed;
     }
+    async #retireClient(client, providerId, options = {}) {
+        this.#pendingCleanup = {
+            client,
+            providerId,
+            retainDocument: options.retainDocument === true,
+        };
+        return this.#retryPendingCleanup(options.progress);
+    }
+    async #retryPendingCleanup(progress, retainDocument) {
+        let pending = this.#pendingCleanup;
+        if (pending === undefined)
+            return ok(null);
+        if (retainDocument !== undefined) {
+            pending = { ...pending, retainDocument };
+            this.#pendingCleanup = pending;
+        }
+        const closed = await closeAnalysisClient(pending.client, pending.providerId, {
+            ...(progress === undefined ? {} : { progress }),
+            ...(pending.retainDocument ? { retainDocument: true } : {}),
+        });
+        if (closed.ok)
+            this.#pendingCleanup = undefined;
+        return closed;
+    }
+    async #failedOpen(client, providerId, previous, primary) {
+        const closed = await this.#retireClient(client, providerId);
+        if (!closed.ok)
+            return analysisErrorWithCleanupFailure(primary, closed.error, "open_binary");
+        return this.#restoreAfterFailedOpen(previous, primary);
+    }
+    async #restoreAfterFailedOpen(previous, primary) {
+        const restored = await this.#restore(previous);
+        return restored.ok
+            ? primary
+            : analysisErrorWithCleanupFailure(primary, restored.error, "open_binary");
+    }
     /** Describe the active binary session. */
     status() {
         return binarySessionStatus({
@@ -328,7 +366,7 @@ export class BinarySession extends BinarySessionRecords {
                 execution: profiled.value,
             });
         }
-        else if (profiled.ok && capability?.effects.mutatesArtifact === true) {
+        else if (profiled.ok && capability.effects.mutatesArtifact) {
             this.invalidateSnapshot();
         }
         return profiled;
@@ -410,21 +448,24 @@ export class BinarySession extends BinarySessionRecords {
     }
     async #restore(previous) {
         if (previous === undefined)
-            return;
+            return ok(null);
         const runId = randomUUID();
         const client = previous.route.createClient(previous.target, { runId });
         const started = await client.execute("health", {});
-        if (started.ok)
+        if (started.ok) {
             this.#active = {
                 target: previous.target,
                 client,
                 profile: previous.profile,
-                compatibility: previous.compatibility,
                 route: previous.route,
                 runId,
             };
-        else
-            await client.close();
+            return ok(null);
+        }
+        const closed = await this.#retireClient(client, previous.route.identity.id);
+        return closed.ok
+            ? ok(null)
+            : err(analysisErrorWithCleanupFailure(started.error, closed.error, "open_binary"));
     }
     async #waitForTransition(operation, signal, transition) {
         if (signal?.aborted === true)

package/dist/application/binary/BinarySessionComposition.js

@@ -6,6 +6,4 @@ import { SessionProviderRouter } from "./SessionProviderRouter.js";
  * 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), new InvestigationRecords());
+export const composeBinarySession = (registry, auxiliaryProviders = []) => new BinarySession(SessionProviderRouter.selectable(registry, auxiliaryProviders), new InvestigationRecords());

package/dist/application/binary/BinarySessionExecution.js

@@ -9,17 +9,15 @@ export const prepareSessionExecution = (input) => {
     const { active, operation, parameters, unboundOperationError, lookupSnapshot, } = input;
     if (active === undefined)
         return err(new NoBinaryOpenError());
-    const capability = active.route.capabilities?.get(operation);
-    if (active.route.capabilities !== undefined &&
-        capability?.available !== true) {
+    const capability = active.route.capabilities.get(operation);
+    if (capability?.available !== true) {
         const selectionError = unboundOperationError(operation, active.route);
         if (selectionError !== undefined)
             return err(selectionError);
         return err(new AnalysisCapabilityUnavailableError(active.route.binding?.identity.id ?? active.route.identity.id, operation, capability?.reason ?? "operation is not declared by this provider"));
     }
     const profile = active.profile !== null &&
-        (capability === undefined ||
-            capability.provider.id === active.profile.provider.id)
+        capability.provider.id === active.profile.provider.id
         ? active.profile
         : undefined;
     const cacheable = profile !== undefined &&

package/dist/application/binary/BinarySessionOpen.js

@@ -1,6 +1,6 @@
 import { snapshotMatchesBinding, snapshotMatchesTarget, snapshotTarget, } from "../../domain/analysisSnapshot.js";
 import { parseBinaryTarget } from "../BinaryTargetResolver.js";
-import {} from "../../domain/binaryTarget.js";
+import {} from "../../domain/binaryTargetTypes.js";
 import { EvidenceIntegrityError, AnalysisSnapshotMismatchError, } from "../../domain/evidenceErrors.js";
 import {} from "../../domain/analysisErrorBase.js";
 import { err } from "../../domain/result.js";

package/dist/application/binary/BinarySessionRecords.js

@@ -6,7 +6,7 @@ import { err, ok } from "../../domain/result.js";
 import { AnalysisSnapshotCache } from "./AnalysisSnapshotCache.js";
 import { InvestigationRecords } from "../investigation/InvestigationRecords.js";
 const SNAPSHOT_MUTATION_RECOVERY = "Export session observations through export_evidence_bundle if needed. Close the active target without saving a snapshot, then reopen it before importing or saving a snapshot.";
-/** Binary snapshot owner and compatibility facade for composed investigation records. */
+/** Own binary snapshots and coordinate the composed investigation records. */
 export class BinarySessionRecords {
     #records;
     #snapshot = new AnalysisSnapshotCache();

package/dist/application/binary/BinarySessionStatus.js

@@ -1,9 +1,6 @@
 /** Project internal provider routing state into the caller-visible session status. */
 export const binarySessionStatus = ({ target, route, router, runtimeUnavailability, runId, runtimeLineageSnapshots, requestActivitySnapshots, providerOperationHealth, }) => {
-    const configuredProvider = router.configuredIdentity();
-    const provider = providerSummary(configuredProvider);
-    const providers = router.providerIdentities(route).map(providerSummary);
-    const capabilities = [...(route.capabilities?.values() ?? [])]
+    const capabilities = [...route.capabilities.values()]
         .filter(({ operation }) => operation !== "inventory_artifact")
         .sort((left, right) => left.operation.localeCompare(right.operation))
         .map((descriptor) => {
@@ -38,8 +35,6 @@ export const binarySessionStatus = ({ target, route, router, runtimeUnavailabili
             .map(capabilityStatus),
     }));
     const common = {
-        provider,
-        providers,
         capabilities,
         analysis_provider_binding: analysisProviderBinding,
         analysis_provider_candidates: analysisProviderCandidates,

package/dist/application/binary/CompositeProvider.js

@@ -1,8 +1,8 @@
 import { AnalysisCapabilityUnavailableError } from "../../domain/analysisErrorCore.js";
 import { err, ok } from "../../domain/result.js";
 import { closeAnalysisClient } from "./AnalysisClientCleanup.js";
-/** Synthetic compatibility identity for a deterministic provider set. */
-export const compositeProviderIdentity = (identities) => ({
+/** Synthetic identity for a deterministic provider set. */
+const compositeProviderIdentity = (identities) => ({
     id: `composite:${identities
         .map(({ id }) => id)
         .sort()
@@ -16,15 +16,10 @@ export class CompositeProvider {
     #identity;
     #capabilities;
     #providerByOperation;
-    #profileProvider;
     constructor(providers) {
         this.providers = providers;
         if (providers.length === 0)
             throw new RangeError("CompositeProvider requires at least one provider");
-        const profileProviders = providers.filter(({ resolveAnalysisProfile }) => resolveAnalysisProfile !== undefined);
-        if (profileProviders.length > 1)
-            throw new TypeError("CompositeProvider supports at most one target-bound analysis profile");
-        this.#profileProvider = profileProviders[0];
         this.#identity = Object.freeze(compositeProviderIdentity(providers.map((provider) => provider.identity())));
         const routes = new Map();
         const capabilities = [];
@@ -46,12 +41,6 @@ export class CompositeProvider {
     capabilities() {
         return this.#capabilities;
     }
-    resolveAnalysisProfile(target, options) {
-        const resolve = this.#profileProvider?.resolveAnalysisProfile;
-        return resolve === undefined
-            ? Promise.resolve(ok({ profile: null, compatibility: {} }))
-            : resolve.call(this.#profileProvider, target, options);
-    }
     createClient(target, profile, context) {
         const clients = new Map();
         const clientFor = (provider) => {
@@ -62,7 +51,7 @@ export class CompositeProvider {
             clients.set(provider, created);
             return created;
         };
-        const closeWithOutcome = async (options) => {
+        const close = async (options) => {
             const outcomes = await Promise.all([...clients.entries()].map(([provider, client]) => closeAnalysisClient(client, provider.identity().id, options)));
             return outcomes.find((outcome) => !outcome.ok) ?? ok(null);
         };
@@ -101,10 +90,7 @@ export class CompositeProvider {
                 }
                 return undefined;
             },
-            closeWithOutcome,
-            close: async () => {
-                await closeWithOutcome();
-            },
+            close,
         };
     }
 }

package/dist/application/binary/LazyAnalysisProvider.js

@@ -1,7 +1,7 @@
 import { AnalysisCancelledError } from "../../domain/analysisErrorCore.js";
 import { AnalysisError } from "../../domain/analysisErrorBase.js";
 import { ProviderAdapterError } from "../../domain/providerAdapterError.js";
-import { err } from "../../domain/result.js";
+import { err, ok } from "../../domain/result.js";
 import { ABORTED, waitForAbortable } from "./AbortablePromise.js";
 const isAborted = (signal) => signal?.aborted === true;
 /**
@@ -77,13 +77,13 @@ class LazyAnalysisClient {
     operationHealthSnapshot() {
         return this.#client?.operationHealthSnapshot?.();
     }
-    async close() {
+    close = async (options) => {
         this.#closed = true;
         if (this.#loading === undefined)
-            return;
+            return ok(null);
         const client = await this.#loading;
-        await client.close();
-    }
+        return client.close(options);
+    };
     async #load(operation) {
         if (this.#closed)
             throw new ProviderAdapterError(this.#providerId, operation, {

package/dist/application/binary/SessionProviderRouter.js

@@ -1,40 +1,18 @@
-import { analysisProfileSchema, } from "../../domain/analysisProfile.js";
-import { AnalysisCancelledError, AnalysisCapabilityUnavailableError, } from "../../domain/analysisErrorCore.js";
-import { ProviderAdapterError } from "../../domain/providerAdapterError.js";
+import { AnalysisCapabilityUnavailableError } from "../../domain/analysisErrorCore.js";
 import { ProviderSelectionError } from "../../domain/providerSelectionError.js";
 import {} from "../../domain/analysisErrorBase.js";
-import { jsonObjectSchema } from "../../domain/jsonValue.js";
 import { err, ok } from "../../domain/result.js";
 import { AnalysisProviderRegistry, } from "./AnalysisProviderRegistry.js";
-import { ABORTED, waitForAbortable } from "./AbortablePromise.js";
-import { CompositeProvider, compositeProviderIdentity, } from "./CompositeProvider.js";
-/** Resolve either the compatibility single-provider seam or a selectable set. */
+import { CompositeProvider } from "./CompositeProvider.js";
+/** Resolve one registry-selected deep provider and disjoint auxiliary families. */
 export class SessionProviderRouter {
-    runtime;
-    constructor(runtime) {
-        this.runtime = runtime;
-    }
-    /** Create routing for an embedding backed by one fixed provider or factory. */
-    static single(provider, options = {}) {
-        const identity = typeof provider === "function"
-            ? { id: "unidentified", name: "Unidentified provider", version: null }
-            : provider.identity();
-        const capabilities = typeof provider === "function"
-            ? undefined
-            : capabilityMap(provider.capabilities());
-        const resolveProfile = options.resolveAnalysisProfile ??
-            (typeof provider === "function" ||
-                provider.resolveAnalysisProfile === undefined
-                ? () => Promise.resolve(ok({ profile: null, compatibility: {} }))
-                : (target, resolutionOptions) => provider.resolveAnalysisProfile?.(target, resolutionOptions) ??
-                    Promise.resolve(ok({ profile: null, compatibility: {} })));
-        return new SessionProviderRouter({
-            kind: "single",
-            provider,
-            identity,
-            capabilities,
-            resolveProfile,
-        });
+    registry;
+    auxiliaryProviders;
+    route;
+    constructor(registry, auxiliaryProviders, route) {
+        this.registry = registry;
+        this.auxiliaryProviders = auxiliaryProviders;
+        this.route = route;
     }
     /** Create selection-aware routing while keeping auxiliary families disjoint. */
     static selectable(registry, auxiliaryProviders) {
@@ -48,99 +26,31 @@ export class SessionProviderRouter {
             if (auxiliaryOperations.has(operation))
                 throw new TypeError(`Deep and auxiliary providers both declare operation ${operation}`);
         const initialRoute = selectableRoute(auxiliaryProviders, undefined);
-        return new SessionProviderRouter({
-            kind: "selectable",
-            registry,
-            auxiliaryProviders: [...auxiliaryProviders],
-            identity: identities.length === 0
-                ? emptyProviderIdentity()
-                : compositeProviderIdentity(identities),
-            initialRoute,
-        });
-    }
-    /** Compatibility identity covering every configured provider. */
-    configuredIdentity() {
-        return structuredClone(this.runtime.identity);
-    }
-    /** Provider identities exposed through the flat 1.x compatibility field. */
-    providerIdentities(route) {
-        if (this.runtime.kind === "single") {
-            if (route.capabilities === undefined)
-                return [route.identity];
-            return uniqueProviderIdentities([...route.capabilities.values()].map(({ provider }) => provider));
-        }
-        const selected = route.binding?.identity;
-        return uniqueProviderIdentities([
-            ...this.runtime.auxiliaryProviders.map((provider) => provider.identity()),
-            ...this.runtime.registry
-                .identities()
-                .map((identity) => identity.id === selected?.id ? selected : identity),
-        ]);
+        return new SessionProviderRouter(registry, [...auxiliaryProviders], initialRoute);
     }
     /** Target-free routes and discovery metadata. */
     initialRoute() {
-        if (this.runtime.kind === "selectable")
-            return this.runtime.initialRoute;
-        const runtime = this.runtime;
-        return {
-            identity: structuredClone(runtime.identity),
-            capabilities: runtime.capabilities,
-            profile: null,
-            compatibility: {},
-            binding: null,
-            selection: undefined,
-            createClient: (target, context) => createSingleProviderClient(runtime, target, undefined, context),
-        };
+        return this.route;
     }
     /** Resolve target routes before any provider client is created. */
     async resolve(target, providerId, signal) {
         const resolutionOptions = signal === undefined ? undefined : { signal };
-        if (this.runtime.kind === "selectable") {
-            const selected = await this.runtime.registry.select(target, providerId, resolutionOptions);
-            return selected.ok
-                ? ok(selectableRoute(this.runtime.auxiliaryProviders, selected.value))
-                : selected;
-        }
-        const runtime = this.runtime;
-        if (providerId !== undefined &&
-            providerId !== "auto" &&
-            providerId !== runtime.identity.id)
-            return err(new ProviderSelectionError({
-                reason: "unknown_provider",
-                requestedProviderId: providerId,
-                candidateIds: [runtime.identity.id],
-            }));
-        const resolved = await waitForAbortable(runtime.resolveProfile(target, resolutionOptions), signal);
-        if (resolved === ABORTED)
-            return err(new AnalysisCancelledError("open_binary"));
-        if (!resolved.ok)
-            return resolved;
-        const normalized = normalizeProfileResolution(resolved.value, runtime.identity.id);
-        if (!normalized.ok)
-            return normalized;
-        return ok({
-            identity: structuredClone(runtime.identity),
-            capabilities: runtime.capabilities,
-            profile: normalized.value.profile,
-            compatibility: normalized.value.compatibility,
-            binding: null,
-            selection: undefined,
-            createClient: (openedTarget, context) => createSingleProviderClient(runtime, openedTarget, normalized.value.profile ?? undefined, context),
-        });
+        const selected = await this.registry.select(target, providerId, resolutionOptions);
+        return selected.ok
+            ? ok(selectableRoute(this.auxiliaryProviders, selected.value))
+            : selected;
     }
     /** Candidate status authoritative for the active or target-free route. */
     candidateStatuses(route) {
-        if (this.runtime.kind === "single")
-            return [];
-        return route.selection?.candidates ?? this.runtime.registry.candidates();
+        return route.selection?.candidates ?? this.registry.candidates();
     }
     /** Produce exact candidate rejections for an intentionally unbound route. */
     unboundOperationError(operation, route) {
-        if (this.runtime.kind !== "selectable" ||
-            route.binding !== null ||
-            route.selection === undefined)
+        if (route.binding !== null ||
+            route.selection === undefined ||
+            !this.registry.declaredOperations().includes(operation))
             return undefined;
-        return this.runtime.registry.unboundOperationError(operation, route.selection);
+        return this.registry.unboundOperationError(operation, route.selection);
     }
 }
 const selectableRoute = (auxiliaryProviders, selection) => {
@@ -149,23 +59,23 @@ const selectableRoute = (auxiliaryProviders, selection) => {
         ...auxiliaryProviders,
         ...(binding === null ? [] : [binding.provider]),
     ];
-    const provider = providers.length === 0 ? undefined : new CompositeProvider(providers);
+    const provider = binding === null && providers.length === 1
+        ? providers[0]
+        : providers.length === 0
+            ? undefined
+            : new CompositeProvider(providers);
     const identity = provider?.identity() ?? emptyProviderIdentity();
     const capabilities = capabilityMap(provider?.capabilities() ?? []);
     return {
         identity,
         capabilities,
         profile: binding?.profile ?? null,
-        compatibility: structuredClone(binding?.compatibility ?? {}),
         binding,
         selection,
         createClient: (target, context) => provider?.createClient(target, binding?.profile, context) ??
             emptyClient(identity),
     };
 };
-const createSingleProviderClient = (runtime, target, profile, context) => typeof runtime.provider === "function"
-    ? runtime.provider(target, profile, context)
-    : runtime.provider.createClient(target, profile, context);
 const emptyClient = (identity) => ({
     execute: (operation) => operation === "health"
         ? Promise.resolve(ok({
@@ -177,7 +87,7 @@ const emptyClient = (identity) => ({
             subject: null,
         }))
         : Promise.resolve(err(new AnalysisCapabilityUnavailableError(identity.id, operation, "operation is not declared by this provider set"))),
-    close: () => Promise.resolve(),
+    close: () => Promise.resolve(ok(null)),
 });
 const emptyProviderIdentity = () => ({
     id: "composite:none",
@@ -185,9 +95,6 @@ const emptyProviderIdentity = () => ({
     version: null,
 });
 const capabilityMap = (capabilities) => new Map(capabilities.map((descriptor) => [descriptor.operation, descriptor]));
-const uniqueProviderIdentities = (identities) => [...new Map(identities.map((identity) => [identity.id, identity])).values()]
-    .sort((left, right) => left.id.localeCompare(right.id))
-    .map((identity) => structuredClone(identity));
 const assertDisjoint = (providers) => {
     const routes = new Set();
     for (const provider of providers)
@@ -206,18 +113,3 @@ const assertUniqueProviderIds = (identities) => {
         ids.add(identity.id);
     }
 };
-const normalizeProfileResolution = (resolution, providerId) => {
-    try {
-        return ok({
-            profile: resolution.profile === null
-                ? null
-                : analysisProfileSchema.parse(resolution.profile),
-            compatibility: jsonObjectSchema.parse(resolution.compatibility),
-        });
-    }
-    catch (cause) {
-        return err(new ProviderAdapterError(providerId, "resolve_analysis_profile", {
-            cause,
-        }));
-    }
-};