@astrale-os/kernel-client 0.5.1 → 0.6.0-beta.10

package/dist/session/discovery/publication.js

@@ -0,0 +1,123 @@
+import * as codecs from '@astrale-os/kernel-protocol/codecs';
+import * as publicationCodec from '@astrale-os/kernel-protocol/publication/publication';
+import { ClientError } from '../../errors/index.js';
+import { allowEndpoint } from '../context/index.js';
+import { runAcquisition } from './transport.js';
+export class PublicationDiscovery {
+    options;
+    publication;
+    revision = 0;
+    constructor(options) {
+        this.options = options;
+    }
+    current() {
+        return this.publication;
+    }
+    async revalidate(operation) {
+        const revision = this.revision;
+        const previous = this.publication;
+        const discovered = await this.fetch(operation, previous);
+        if (revision !== this.revision)
+            return this.revalidate(operation);
+        const retained = previous?.etag === discovered.etag ? previous : discovered;
+        this.publication = retained;
+        return retained;
+    }
+    invalidate() {
+        this.revision += 1;
+        this.publication = undefined;
+    }
+    async fetch(operation, previous) {
+        const url = publicationCodec.url(this.options.kernel);
+        allowEndpoint(url, this.options.policy);
+        const response = await runAcquisition(operation, 'publication', 'unknown', 'Kernel Publication could not be retrieved.', (signal) => this.options.fetch(url, {
+            headers: {
+                accept: 'application/json',
+                ...(previous === undefined ? {} : { 'if-none-match': `"${previous.etag}"` }),
+            },
+            redirect: 'manual',
+            signal,
+        }));
+        requireExactResponse(response, url, 'Publication discovery');
+        if (response.status === 304) {
+            if (previous === undefined) {
+                throw new ClientError('Publication discovery returned an unexpected not-modified response.');
+            }
+            const etag = response.headers.get('etag');
+            if (etag !== null && etag !== `"${previous.etag}"`) {
+                throw new ClientError('Publication not-modified ETag differs from the cached snapshot.');
+            }
+            return previous;
+        }
+        if (!response.ok) {
+            throw new ClientError(`Publication discovery returned HTTP ${response.status}.`);
+        }
+        const body = await runAcquisition(operation, 'publication', 'receive', 'Kernel Publication response could not be read.', (signal) => boundedResponse(response, this.options.maximumBytes, signal));
+        const admitted = publicationCodec.accept(codecs.json.decode(body));
+        if (admitted.identity.issuer !== this.options.kernel) {
+            throw new ClientError('Publication issuer differs from the requested Kernel issuer.');
+        }
+        const etag = response.headers.get('etag');
+        if (etag !== null && etag !== `"${admitted.etag}"`) {
+            throw new ClientError('Publication response ETag differs from its canonical content.');
+        }
+        return admitted;
+    }
+}
+export async function boundedResponse(response, maximum, signal) {
+    const declared = response.headers.get('content-length');
+    if (declared !== null) {
+        const length = Number(declared);
+        if (!Number.isSafeInteger(length) || length < 0) {
+            throw new ClientError('Response Content-Length is invalid.');
+        }
+        if (length > maximum)
+            throw new ClientError('Response exceeds its byte limit.');
+    }
+    if (response.body === null)
+        return new Uint8Array();
+    const reader = response.body.getReader();
+    const chunks = [];
+    let total = 0;
+    const abort = () => void reader.cancel(signal.reason).catch(() => undefined);
+    if (signal.aborted)
+        abort();
+    else
+        signal.addEventListener('abort', abort, { once: true });
+    try {
+        while (true) {
+            if (signal.aborted)
+                throw signal.reason;
+            const next = await reader.read();
+            if (next.done)
+                break;
+            total += next.value.byteLength;
+            if (total > maximum) {
+                await reader.cancel('response exceeds byte limit').catch(() => undefined);
+                throw new ClientError('Response exceeds its byte limit.');
+            }
+            chunks.push(next.value);
+        }
+    }
+    finally {
+        signal.removeEventListener('abort', abort);
+        reader.releaseLock();
+    }
+    return join(chunks, total);
+}
+export function requireExactResponse(response, expected, label) {
+    if (response.redirected || response.url !== expected) {
+        throw new ClientError(`${label} did not return the exact requested URL.`);
+    }
+}
+function join(parts, length) {
+    if (parts.length === 1)
+        return new Uint8Array(parts[0]);
+    const output = new Uint8Array(length);
+    let offset = 0;
+    for (const part of parts) {
+        output.set(part, offset);
+        offset += part.byteLength;
+    }
+    return output;
+}

package/dist/session/discovery/snapshot.d.ts

@@ -0,0 +1,12 @@
+import type { IssuerId } from '@astrale-os/kernel-core/auth/issuer';
+import type { bundle } from '@astrale-os/kernel-dsl/v1';
+import type { publication } from '@astrale-os/kernel-protocol';
+import type { ViewCatalog } from '../views/index.js';
+/** Coherent public observation acquired through one Client Session at one Publication ETag. */
+export interface SessionSnapshot {
+    readonly kernel: IssuerId;
+    readonly publication: publication.Publication;
+    readonly bundle: bundle.Bundle;
+    readonly views: ViewCatalog;
+}
+export declare function createSessionSnapshot(kernel: IssuerId, publication: publication.Publication, artifact: bundle.Bundle, views: ViewCatalog): SessionSnapshot;

package/dist/session/discovery/snapshot.js

@@ -0,0 +1,3 @@
+export function createSessionSnapshot(kernel, publication, artifact, views) {
+    return Object.freeze({ kernel, publication, bundle: artifact, views });
+}

package/dist/session/discovery/transport.d.ts

@@ -0,0 +1,6 @@
+import type { TransportPhase } from '../../errors/index.js';
+import type { SessionOperation } from '../context/index.js';
+type AcquisitionResource = 'publication' | 'bundle';
+/** Normalize only unknown failures from one injected acquisition capability. */
+export declare function runAcquisition<Result>(operation: SessionOperation, resource: AcquisitionResource, phase: Extract<TransportPhase, 'receive' | 'unknown'>, message: string, task: (signal: AbortSignal) => Result | PromiseLike<Result>): Promise<Result>;
+export {};

package/dist/session/discovery/transport.js

@@ -0,0 +1,13 @@
+import { ClientError, TransportError } from '../../errors/index.js';
+import { runSessionOperation } from '../context/index.js';
+/** Normalize only unknown failures from one injected acquisition capability. */
+export async function runAcquisition(operation, resource, phase, message, task) {
+    try {
+        return await runSessionOperation(operation, task);
+    }
+    catch (cause) {
+        if (cause instanceof ClientError)
+            throw cause;
+        throw TransportError.acquisition(message, { cause, phase, resource });
+    }
+}

package/dist/session/index.d.ts

@@ -1,16 +1,10 @@
-export { ClientSession } from './client-session.js';
-export { delegationMintVia } from './delegation-mint.js';
-export type { IdentityInput, ClientSessionCallOptions, ClientSessionConfig } from './config.js';
-export { DispatchRouteCache, MemoryDispatchRouteStore } from './dispatch-routes.js';
-export type { DispatchRoute, DispatchRouteStore } from './dispatch-routes.js';
-export type { BoundClientSessionView, SchemaTypedClientSession } from './types.js';
-export type { AfterCallCtx, AfterSignalCtx, BeforeCallCtx, DelegationMintCtx, DelegationRefusedCtx, RedirectFollowCtx, RedirectRefusedCtx, ClientSessionErrorCtx, ClientSessionHooks, ClientSessionHop, } from './hooks.js';
-export type { RedirectDecision, RedirectHop, RedirectPolicy } from './redirect/policy.js';
-export { allowAllPolicy, allowlistPolicy, promptPolicy, strictPolicy } from './redirect/policy.js';
-export type { DelegationContext, DelegationDecision, DelegationPolicy, } from './delegation/policy.js';
-export { allowAllDelegations, allowlistDelegations, promptDelegations, scopedSelf, } from './delegation/policy.js';
-export { DelegationCache } from './delegation/cache.js';
-export type { DelegationCacheConfig, DelegationMintFn, DelegationMintResult, } from './delegation/cache.js';
-export type { SchemaPersistence } from '../schema/persistence.js';
-export { ClientSessionError, DelegationMintError, DelegationPolicyError, DelegationRefusedError, HopLimitExceededError, IdentityPickerError, PersistenceLoadFailedError, PoolClosedError, RedirectPolicyError, RedirectRefusedError, RegistryWriteFailedError, SchemaOwnershipConflictError, UnresolvedIdentityError, } from './errors/index.js';
-//# sourceMappingURL=index.d.ts.map
+export type { SessionControlOptions, SessionPolicy } from './context/index.js';
+export { bindSession, type BoundClientSession, type BoundSessionControls, type BoundSessionSource, } from './bound.js';
+export type { ReadyInstallation } from '../schema/index.js';
+export type { SessionSnapshot } from './discovery/index.js';
+export type { Auth, SessionAuth, SessionEnvelopeTransport, SessionRequestOptions, } from './routing/index.js';
+export { ClientSession, connect, type ClientSessionOptions, type ConnectOptions, } from './session.js';
+export type { CallableReference, InputOfReference, InstanceCallableReference, OutputOfReference, } from './reference.js';
+export { reference } from './reference.js';
+export type { ResolvedView, ViewCatalog } from './views/index.js';
+export type { DomainBinding } from '../graph/domain/index.js';

package/dist/session/index.js

@@ -1,9 +1,3 @@
-export { ClientSession } from './client-session.js';
-export { delegationMintVia } from './delegation-mint.js';
-export { DispatchRouteCache, MemoryDispatchRouteStore } from './dispatch-routes.js';
-export { allowAllPolicy, allowlistPolicy, promptPolicy, strictPolicy } from './redirect/policy.js';
-export { allowAllDelegations, allowlistDelegations, promptDelegations, scopedSelf, } from './delegation/policy.js';
-export { DelegationCache } from './delegation/cache.js';
-// Every ClientSession-thrown error shape, one import surface.
-export { ClientSessionError, DelegationMintError, DelegationPolicyError, DelegationRefusedError, HopLimitExceededError, IdentityPickerError, PersistenceLoadFailedError, PoolClosedError, RedirectPolicyError, RedirectRefusedError, RegistryWriteFailedError, SchemaOwnershipConflictError, UnresolvedIdentityError, } from './errors/index.js';
-//# sourceMappingURL=index.js.map
+export { bindSession, } from './bound.js';
+export { ClientSession, connect, } from './session.js';
+export { reference } from './reference.js';

package/dist/session/reference.d.ts

@@ -0,0 +1,36 @@
+import type { Path as PathValue, PathLike } from '@astrale-os/kernel-core/path';
+import type { CallableInputOf, CallableOutputOf, CallableResultOf, Domain, MethodInheritance, ResolvedFunction, ResolvedMethod } from '@astrale-os/kernel-dsl/v1';
+import type { Revision } from '@astrale-os/kernel-dsl/v1/addressing';
+import { type Key as KeyType } from '@astrale-os/kernel-dsl/v1/addressing';
+import type { Binary, Input, Result } from '../client/index.js';
+declare const REFERENCE_INPUT: unique symbol;
+declare const REFERENCE_OUTPUT: unique symbol;
+export interface CallableReference<InputValue extends Input = Input, Output = unknown> {
+    readonly origin: KeyType.Origin;
+    readonly revision: Revision;
+    readonly callable: KeyType.Callable;
+    readonly target: PathValue;
+    readonly outputMode: Exclude<Result['kind'], 'redirect'>;
+    readonly [REFERENCE_INPUT]?: InputValue;
+    readonly [REFERENCE_OUTPUT]?: Output;
+}
+export interface InstanceCallableReference<InputValue extends Input = Input, Output = unknown> {
+    (receiver: PathLike): CallableReference<InputValue, Output>;
+    readonly origin: KeyType.Origin;
+    readonly revision: Revision;
+    readonly callable: KeyType.Callable;
+    readonly outputMode: Exclude<Result['kind'], 'redirect'>;
+}
+export type InputOfReference<Reference extends CallableReference> = Reference extends CallableReference<infer InputValue, unknown> ? InputValue : never;
+export type OutputOfReference<Reference extends CallableReference> = Reference extends CallableReference<infer _Input, infer Output> ? Output : never;
+type ReferenceInput<Callable> = unknown extends CallableInputOf<Callable> ? Input : Extract<CallableInputOf<Callable>, Input>;
+type ReferenceOutput<Callable> = unknown extends CallableOutputOf<Callable> ? unknown : CallableResultOf<Callable, Binary>;
+type ExecutableMethodInheritance = Exclude<MethodInheritance, 'abstract'>;
+type ExecutableStaticMethod = ResolvedMethod<unknown, unknown, true, ExecutableMethodInheritance>;
+type ExecutableInstanceMethod = ResolvedMethod<unknown, unknown, false, ExecutableMethodInheritance>;
+/** Project one exact resolved Function or static Method into a typed Client reference. */
+export declare function reference<const Callable extends ResolvedFunction | ExecutableStaticMethod>(domain: Pick<Domain, 'origin' | 'revision'>, callable: Callable): CallableReference<ReferenceInput<Callable>, ReferenceOutput<Callable>>;
+/** Project one exact resolved instance Method into a receiver-bound typed Client reference. */
+export declare function reference<const Callable extends ExecutableInstanceMethod>(domain: Pick<Domain, 'origin' | 'revision'>, callable: Callable): InstanceCallableReference<ReferenceInput<Callable>, ReferenceOutput<Callable>>;
+export declare function admitReference(input: CallableReference): CallableReference;
+export {};

package/dist/session/reference.js

@@ -0,0 +1,74 @@
+import { Path } from '@astrale-os/kernel-core/path';
+import { callableAddress, Key, patterns, } from '@astrale-os/kernel-dsl/v1/addressing';
+export function reference(domain, callable) {
+    if ('owner' in callable && callable.inheritance === 'abstract')
+        invalid();
+    const common = Object.freeze({
+        origin: domain.origin,
+        revision: domain.revision,
+        callable: callable.key,
+        outputMode: callable.output.mode,
+    });
+    if ('owner' in callable && !callable.static) {
+        const bind = (receiver) => admitReference({
+            ...common,
+            target: Path.instanceMethod(Path.from(receiver), callable.name),
+        });
+        return Object.assign(bind, common);
+    }
+    const target = 'owner' in callable
+        ? Path.staticMethod(Path.project(callable.owner.ref), callable.name)
+        : Path.project(callable.ref);
+    return admitReference({ ...common, target });
+}
+export function admitReference(input) {
+    if (input === null || typeof input !== 'object')
+        invalid();
+    if (typeof input.origin !== 'string' ||
+        !patterns.origin.test(input.origin) ||
+        typeof input.revision !== 'string' ||
+        !patterns.revision.test(input.revision) ||
+        typeof input.callable !== 'string' ||
+        !Key.is(input.callable) ||
+        Key.origin(input.callable) !== input.origin ||
+        !['value', 'stream', 'binary'].includes(input.outputMode))
+        invalid();
+    const target = Path.from(input.target);
+    if (!matchesCallable(target, input.callable))
+        invalid();
+    return Object.freeze({
+        origin: input.origin,
+        revision: input.revision,
+        callable: input.callable,
+        target,
+        outputMode: input.outputMode,
+    });
+}
+function matchesCallable(target, callable) {
+    const coordinate = callableAddress(callable);
+    const { anchor, steps } = target.ast;
+    const last = steps.at(-1);
+    if (coordinate.kind === 'method') {
+        if (last?.kind !== 'method' || last.name !== coordinate.name)
+            return false;
+        if (last.dispatch === 'instance')
+            return true;
+        const owner = steps.at(-2);
+        return (anchor.kind === 'domain' &&
+            anchor.origin === Key.origin(callable) &&
+            steps.length === 2 &&
+            owner?.kind === 'projection' &&
+            owner.projection.kind === 'class' &&
+            owner.projection.name === coordinate.owner.name);
+    }
+    const projection = steps[0];
+    return (anchor.kind === 'domain' &&
+        anchor.origin === Key.origin(callable) &&
+        steps.length === 1 &&
+        projection?.kind === 'projection' &&
+        projection.projection.kind === 'function' &&
+        projection.projection.name === coordinate.name);
+}
+function invalid() {
+    throw new TypeError('Callable reference is invalid.');
+}

package/dist/session/routing/auth.d.ts

@@ -0,0 +1,18 @@
+import type * as invocation from '@astrale-os/kernel-protocol/invocation';
+import type { SessionOperation } from '../context/index.js';
+export interface Auth {
+    readonly credential?: string;
+    readonly delegate?: invocation.Delegate;
+}
+/** Resolve source-Kernel authority and the audience-free delegation choice for one Call. */
+export interface SessionAuth {
+    /** Default TTL for authenticated Calls whose Auth omits a delegation override. */
+    readonly ttlSeconds: number;
+    resolve(call: invocation.Call, signal: AbortSignal): Auth | Promise<Auth>;
+}
+export interface EffectiveAuth {
+    readonly credential?: string;
+    readonly delegate?: invocation.Delegate;
+}
+export declare function admitSessionAuth(input: SessionAuth | undefined): SessionAuth | undefined;
+export declare function resolveAuth(resolver: SessionAuth | undefined, call: invocation.Call, operation: SessionOperation): Promise<EffectiveAuth>;

package/dist/session/routing/auth.js

@@ -0,0 +1,39 @@
+import * as protocol from '@astrale-os/kernel-protocol/invocation';
+import { ClientError } from '../../errors/index.js';
+import { runSessionOperation } from '../context/index.js';
+export function admitSessionAuth(input) {
+    if (input === undefined)
+        return undefined;
+    if (input === null || typeof input !== 'object' || typeof input.resolve !== 'function') {
+        throw new TypeError('Session auth resolver is invalid.');
+    }
+    if (!Number.isSafeInteger(input.ttlSeconds) || input.ttlSeconds < 1) {
+        throw new TypeError('Session auth ttlSeconds must be a positive safe integer.');
+    }
+    return Object.freeze({ ttlSeconds: input.ttlSeconds, resolve: input.resolve.bind(input) });
+}
+export async function resolveAuth(resolver, call, operation) {
+    if (resolver === undefined)
+        return Object.freeze({});
+    const input = await runSessionOperation(operation, (signal) => resolver.resolve(call, signal));
+    if (input === null || typeof input !== 'object' || Array.isArray(input)) {
+        throw new ClientError('Session auth resolver returned an invalid value.');
+    }
+    const fields = Reflect.ownKeys(input);
+    if (fields.some((field) => field !== 'credential' && field !== 'delegate')) {
+        throw new ClientError('Session auth resolver returned unsupported fields.');
+    }
+    const credential = input.credential;
+    if (credential !== undefined && (typeof credential !== 'string' || credential.length === 0)) {
+        throw new ClientError('Session auth resolver returned an invalid credential.');
+    }
+    if (credential === undefined && input.delegate !== undefined) {
+        throw new ClientError('Session delegation overrides require a source credential.');
+    }
+    if (credential === undefined)
+        return Object.freeze({});
+    const delegate = input.delegate === undefined
+        ? protocol.acceptDelegate({ ttlSeconds: resolver.ttlSeconds })
+        : protocol.acceptDelegate(input.delegate);
+    return Object.freeze({ credential, delegate });
+}

package/dist/session/routing/cache.d.ts

@@ -0,0 +1,20 @@
+import type { invocation } from '@astrale-os/kernel-protocol';
+import type { EffectiveAuth } from './auth.js';
+import type { SchemaExpectation } from './expectation.js';
+export interface LearnedRoute {
+    readonly route: invocation.Route;
+    readonly credential?: string;
+    readonly expiresAt: number;
+}
+/** Confidential, process-local warm routing state owned by exactly one ClientSession. */
+export declare class RouteCache {
+    private readonly maximumAgeMs;
+    private readonly maximumSize;
+    private readonly entries;
+    constructor(maximumAgeMs: number, maximumSize?: number);
+    key(source: string, call: invocation.Call, auth: EffectiveAuth, expected?: SchemaExpectation): Promise<string>;
+    get(key: string, now?: number): LearnedRoute | undefined;
+    learn(key: string, route: invocation.Route, credential: string | undefined, now?: number): LearnedRoute;
+    delete(key: string): void;
+    clear(): void;
+}

package/dist/session/routing/cache.js

@@ -0,0 +1,115 @@
+import { DEFAULT_MAXIMUM_ROUTES } from '../context/index.js';
+/** Confidential, process-local warm routing state owned by exactly one ClientSession. */
+export class RouteCache {
+    maximumAgeMs;
+    maximumSize;
+    entries = new Map();
+    constructor(maximumAgeMs, maximumSize = DEFAULT_MAXIMUM_ROUTES) {
+        this.maximumAgeMs = maximumAgeMs;
+        this.maximumSize = maximumSize;
+    }
+    async key(source, call, auth, expected) {
+        const credential = auth.credential === undefined ? 'anonymous' : await digestText(auth.credential);
+        const delegate = auth.delegate === undefined ? 'anonymous' : await digestText(canonicalDelegate(auth.delegate));
+        return JSON.stringify([
+            source,
+            call.target,
+            credential,
+            delegate,
+            expected === undefined ? null : [expected.origin, expected.revision],
+        ]);
+    }
+    get(key, now = Date.now()) {
+        const entry = this.entries.get(key);
+        if (entry === undefined)
+            return undefined;
+        if (entry.expiresAt <= now) {
+            this.entries.delete(key);
+            return undefined;
+        }
+        this.entries.delete(key);
+        this.entries.set(key, entry);
+        return entry;
+    }
+    learn(key, route, credential, now = Date.now()) {
+        const credentialExpiry = credential === undefined ? undefined : jwtExpiry(credential);
+        const expiresAt = Math.min(now + this.maximumAgeMs, credentialExpiry ?? Number.POSITIVE_INFINITY);
+        const entry = Object.freeze({
+            route,
+            ...(credential === undefined ? {} : { credential }),
+            expiresAt,
+        });
+        // A carrier with no supported finite expiry may be used for this follow, but never warmed.
+        if (credential !== undefined && credentialExpiry === undefined)
+            return entry;
+        if (expiresAt <= now)
+            return entry;
+        this.entries.delete(key);
+        while (this.entries.size >= this.maximumSize) {
+            const oldest = this.entries.keys().next().value;
+            if (oldest === undefined)
+                break;
+            this.entries.delete(oldest);
+        }
+        this.entries.set(key, entry);
+        return entry;
+    }
+    delete(key) {
+        this.entries.delete(key);
+    }
+    clear() {
+        this.entries.clear();
+    }
+}
+function canonicalDelegate(input) {
+    return JSON.stringify({
+        ttlSeconds: input.ttlSeconds,
+        ...(input.attenuation === undefined ? {} : { attenuation: canonicalExpr(input.attenuation) }),
+    });
+}
+function canonicalExpr(input) {
+    if (input.kind === 'identity') {
+        return 'self' in input
+            ? { kind: 'identity', self: true }
+            : { kind: 'identity', credential: input.credential };
+    }
+    if (input.kind === 'exclude') {
+        return {
+            kind: 'exclude',
+            base: canonicalExpr(input.base),
+            excluded: input.excluded.map(canonicalExpr),
+        };
+    }
+    return { kind: input.kind, operands: input.operands.map(canonicalExpr) };
+}
+async function digestText(input) {
+    if (globalThis.crypto?.subtle === undefined) {
+        throw new TypeError('Session route caching requires Web Crypto SHA-256 support.');
+    }
+    const bytes = await globalThis.crypto.subtle.digest('SHA-256', new TextEncoder().encode(input));
+    return [...new Uint8Array(bytes)].map((byte) => byte.toString(16).padStart(2, '0')).join('');
+}
+function jwtExpiry(input) {
+    const parts = input.split('.');
+    if (parts.length !== 3)
+        return undefined;
+    try {
+        const encoded = parts[1].replace(/-/gu, '+').replace(/_/gu, '/');
+        const padding = '='.repeat((4 - (encoded.length % 4)) % 4);
+        const json = decodeBase64(encoded + padding);
+        const payload = JSON.parse(json);
+        return typeof payload.exp === 'number' && Number.isSafeInteger(payload.exp) && payload.exp > 0
+            ? payload.exp * 1_000
+            : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+function decodeBase64(input) {
+    if (typeof globalThis.atob === 'function') {
+        const binary = globalThis.atob(input);
+        return new TextDecoder().decode(Uint8Array.from(binary, (character) => character.charCodeAt(0)));
+    }
+    throw new TypeError('Session route caching requires base64 decoding support.');
+}

package/dist/session/routing/dispatch.d.ts

@@ -0,0 +1,34 @@
+import type { IssuerId } from '@astrale-os/kernel-core/auth/issuer';
+import type { Call, Result } from '../../client/index.js';
+import type { SessionOperation, SessionPolicy } from '../context/index.js';
+import type { SessionDiscovery } from '../discovery/index.js';
+import type { SessionAuth } from './auth.js';
+import type { RouteCache } from './cache.js';
+import type { ClientPoolCapability } from './envelope.js';
+import type { SchemaExpectation } from './expectation.js';
+import type { SessionEnvelopeTransport, SessionRequestOptions } from './request.js';
+export interface SessionDispatcherOptions {
+    readonly kernel: IssuerId;
+    readonly sourceEndpoint: string;
+    readonly pool: ClientPoolCapability;
+    readonly websocketAvailable: boolean;
+    readonly auth?: SessionAuth;
+    readonly cache: RouteCache;
+    readonly policy: Readonly<SessionPolicy>;
+    readonly envelopeTransport: SessionEnvelopeTransport;
+    readonly discovery: SessionDiscovery;
+    readonly requireOpen: () => void;
+}
+export declare class SessionDispatcher {
+    private readonly state;
+    constructor(state: SessionDispatcherOptions);
+    dispatch(input: Call, options: SessionRequestOptions, operation: SessionOperation, expected?: SchemaExpectation): Promise<Result>;
+    private dispatchSource;
+    private followSource;
+    private dispatchDestinationWithRecovery;
+    private dispatchDestination;
+    private sourceKernel;
+}
+export declare function requireResultKind<Kind extends 'value' | 'stream' | 'binary'>(expected: Kind, result: Result): Extract<Result, {
+    kind: Kind;
+}>;