@astrale-os/kernel-client 0.6.0-beta.71 → 0.6.0-beta.74

package/dist/session/exchange/presentation.d.ts

@@ -0,0 +1,18 @@
+import type { AuthExchange, SessionAuth } from '../routing/index.js';
+import type { ExchangeDependencies } from './exchange.js';
+import type { SessionExchangeOptions } from './options.js';
+/** The per-Call exchange a Session applies after resolving its source authority. */
+export interface SessionExchange extends AuthExchange {
+    clear(): void;
+}
+/**
+ * Present each Call whose callable a remote installed Domain declares with the credential that
+ * Domain exchanged for the Call's source caller.
+ *
+ * Kernel callables, locally executed Domains, targets that name no Domain, and anonymous Calls keep
+ * the source authority unchanged. Domain credentials are held per source credential and replaced at
+ * the Session delegation threshold.
+ */
+export declare function createSessionExchange(dependencies: ExchangeDependencies & {
+    readonly auth: SessionAuth;
+}, options: Readonly<Required<SessionExchangeOptions>>): SessionExchange;

package/dist/session/exchange/presentation.js

@@ -0,0 +1,73 @@
+import { ClientError } from '../../errors/index.js';
+import { runSessionOperation } from '../context/index.js';
+import { createSessionCredentialProvider, delegationCoverageMs } from '../credential/index.js';
+import { createInstallations, declaringOrigin, isKernelOrigin } from './domain.js';
+import { exchangeDomainCredential, SELF_ATTENUATION } from './exchange.js';
+import { MAXIMUM_EXCHANGE_SOURCES } from './limits.js';
+import { isAuthority, renewing } from './source.js';
+/**
+ * Present each Call whose callable a remote installed Domain declares with the credential that
+ * Domain exchanged for the Call's source caller.
+ *
+ * Kernel callables, locally executed Domains, targets that name no Domain, and anonymous Calls keep
+ * the source authority unchanged. Domain credentials are held per source credential and replaced at
+ * the Session delegation threshold.
+ */
+export function createSessionExchange(dependencies, options) {
+    const { auth } = dependencies;
+    const coverageMs = delegationCoverageMs(auth.ttlSeconds);
+    const installations = createInstallations(dependencies);
+    const sources = new Map();
+    return Object.freeze({ resolve, clear });
+    async function resolve(call, effective, operation) {
+        if (!isAuthority(effective))
+            return effective;
+        const origin = declaringOrigin(call.target);
+        if (origin === undefined || isKernelOrigin(origin))
+            return effective;
+        const domain = await installations.issuerOf(origin, effective, operation);
+        if (domain === undefined)
+            return effective;
+        return renewing(auth, call, effective, operation, async (source) => {
+            if (source.delegate.ttlSeconds > auth.ttlSeconds) {
+                throw new ClientError('Session delegation outlives the Domain credential it would carry.');
+            }
+            const provider = providerFor(source, domain);
+            const exchanged = await runSessionOperation(operation, (signal) => provider.acquire(signal));
+            return Object.freeze({ credential: exchanged.credential, delegate: source.delegate });
+        });
+    }
+    function clear() {
+        installations.clear();
+        sources.clear();
+    }
+    function providerFor(source, domain) {
+        const held = heldFor(source.credential);
+        const known = held.get(domain);
+        if (known !== undefined)
+            return known;
+        const provider = createSessionCredentialProvider({
+            ttlSeconds: auth.ttlSeconds,
+            mint: (signal) => exchangeDomainCredential(dependencies, source, {
+                issuer: domain,
+                ttlSeconds: options.ttlSeconds,
+                attenuation: SELF_ATTENUATION,
+                coverageMs,
+            }, dependencies.operation(signal)),
+        });
+        held.set(domain, provider);
+        return provider;
+    }
+    /** Domain credentials never cross source credentials; the oldest source is forgotten first. */
+    function heldFor(credential) {
+        const known = sources.get(credential);
+        if (known !== undefined)
+            return known;
+        const held = new Map();
+        sources.set(credential, held);
+        if (sources.size > MAXIMUM_EXCHANGE_SOURCES) {
+            sources.delete(sources.keys().next().value);
+        }
+        return held;
+    }
+}

package/dist/session/exchange/source.d.ts

@@ -0,0 +1,34 @@
+import type { invocation } from '@astrale-os/kernel-protocol';
+import type { AuthCall } from '../../auth/auth.js';
+import type { Call, Result } from '../../client/index.js';
+import type { SessionOperation } from '../context/index.js';
+import type { EffectiveAuth, SessionAuth } from '../routing/index.js';
+import type { ExchangeDependencies } from './exchange.js';
+import { ClientError } from '../../errors/index.js';
+/** A resolved source that carries both a credential and its delegation. */
+export type SourceAuthority = Required<EffectiveAuth>;
+/** Source Kernel syscalls issued as exactly one admitted source caller within one operation. */
+export interface SourceCaller {
+    dispatch(call: Call): Promise<Result>;
+    readonly call: AuthCall;
+}
+/** The source credential can no longer grant a delegation that covers what its exchange carries. */
+export declare class SourceExhausted extends ClientError {
+    constructor();
+}
+export declare function isAuthority(auth: EffectiveAuth): auth is SourceAuthority;
+/** The source Kernel conversation of one exchange, acting as exactly the admitted source caller. */
+export declare function sourceCaller(dependencies: Pick<ExchangeDependencies, 'source'>, auth: EffectiveAuth, operation: SessionOperation): SourceCaller;
+/**
+ * Bound a requested delegation by the source credential's expiry less the issuance margin: the
+ * Kernel rejects a delegation that outlives its source, judged by its own clock. An opaque or
+ * transport-held source leaves the bound to the Kernel. A source that cannot grant one second, or
+ * bounds the delegation within `coverageMs`, is exhausted.
+ */
+export declare function delegationTtl(credential: string | undefined, ttlSeconds: number, coverageMs?: number): number;
+/**
+ * Run `attempt` with the resolved source, and once more with a renewed source if that one proved
+ * exhausted. The Session auth is refreshed only while it still resolves the exhausted credential, so
+ * concurrent Calls share one renewal; an auth that cannot refresh keeps the failure.
+ */
+export declare function renewing<T>(auth: SessionAuth, call: invocation.Call, source: SourceAuthority, operation: SessionOperation, attempt: (source: SourceAuthority) => Promise<T>): Promise<T>;

package/dist/session/exchange/source.js

@@ -0,0 +1,78 @@
+import { inspect } from '@astrale-os/kernel-core/auth/credential';
+import { ClientError } from '../../errors/index.js';
+import { runSessionOperation, sessionTransportOptions } from '../context/index.js';
+import { requireResultKind, resolveAuth } from '../routing/index.js';
+import { ISSUANCE_MARGIN_SECONDS } from './limits.js';
+/** The source credential can no longer grant a delegation that covers what its exchange carries. */
+export class SourceExhausted extends ClientError {
+    constructor() {
+        super('The source credential expires too soon for a Domain token exchange.');
+    }
+}
+export function isAuthority(auth) {
+    return auth.credential !== undefined && auth.delegate !== undefined;
+}
+/** The source Kernel conversation of one exchange, acting as exactly the admitted source caller. */
+export function sourceCaller(dependencies, auth, operation) {
+    const client = dependencies.source();
+    const caller = auth.credential === undefined ? client : client.as(auth.credential);
+    const dispatch = (input) => runSessionOperation(operation, () => caller.dispatch(input, {
+        ...sessionTransportOptions(operation),
+        ...(auth.delegate === undefined ? {} : { delegate: auth.delegate }),
+    }));
+    const call = async (target, input) => requireResultKind('value', await dispatch({ target, input })).value;
+    return Object.freeze({ dispatch, call });
+}
+/**
+ * Bound a requested delegation by the source credential's expiry less the issuance margin: the
+ * Kernel rejects a delegation that outlives its source, judged by its own clock. An opaque or
+ * transport-held source leaves the bound to the Kernel. A source that cannot grant one second, or
+ * bounds the delegation within `coverageMs`, is exhausted.
+ */
+export function delegationTtl(credential, ttlSeconds, coverageMs = 0) {
+    const remaining = remainingSeconds(credential);
+    if (remaining === undefined || remaining >= ttlSeconds)
+        return ttlSeconds;
+    if (remaining < 1 || remaining * 1_000 <= coverageMs)
+        throw new SourceExhausted();
+    return remaining;
+}
+/**
+ * Run `attempt` with the resolved source, and once more with a renewed source if that one proved
+ * exhausted. The Session auth is refreshed only while it still resolves the exhausted credential, so
+ * concurrent Calls share one renewal; an auth that cannot refresh keeps the failure.
+ */
+export async function renewing(auth, call, source, operation, attempt) {
+    try {
+        return await attempt(source);
+    }
+    catch (cause) {
+        if (!(cause instanceof SourceExhausted))
+            throw cause;
+        let renewed = await resolveAuth(auth, call, operation);
+        if (renewed.credential === source.credential && auth.refresh !== undefined) {
+            const refresh = auth.refresh;
+            await runSessionOperation(operation, async (signal) => {
+                await refresh(signal);
+            });
+            renewed = await resolveAuth(auth, call, operation);
+        }
+        if (!isAuthority(renewed) || renewed.credential === source.credential)
+            throw cause;
+        return attempt(renewed);
+    }
+}
+function remainingSeconds(credential) {
+    if (credential === undefined)
+        return undefined;
+    let expiresAt;
+    try {
+        expiresAt = inspect(credential).claims.exp;
+    }
+    catch {
+        return undefined;
+    }
+    if (typeof expiresAt !== 'number' || !Number.isSafeInteger(expiresAt))
+        return undefined;
+    return expiresAt - Math.ceil(Date.now() / 1_000) - ISSUANCE_MARGIN_SECONDS;
+}

package/dist/session/execution.d.ts

@@ -0,0 +1,65 @@
+import type { NodeId } from '@astrale-os/kernel-core/graph/node';
+import type { Value } from '@astrale-os/kernel-dsl/value';
+import type { CallableReference } from './reference.js';
+declare const EXECUTION_OUTPUT: unique symbol;
+/**
+ * Immediate value of a durable call: the `K.Execution` it created or recovered. `Output` is the
+ * handler output of the called declaration, carried only by the type.
+ */
+export interface ExecutionRef<Output = unknown> {
+    readonly id: NodeId;
+    readonly [EXECUTION_OUTPUT]?: Output;
+}
+export type ExecutionOutcome<Output = unknown> = {
+    readonly kind: 'completed';
+    readonly value: Output;
+} | {
+    readonly kind: 'failed';
+    readonly error: {
+        readonly code: string;
+        readonly message: string;
+        readonly family?: string;
+        readonly details?: Value;
+    };
+} | {
+    readonly kind: 'cancelled';
+};
+export type ExecutionState = 'pending' | 'running' | 'waiting' | 'paused' | 'completed' | 'failed' | 'cancelled' | 'expired';
+export interface ExecutionStatus<Output = unknown> {
+    readonly id: NodeId;
+    readonly function: NodeId;
+    readonly version: `sha256:${string}`;
+    readonly state: ExecutionState;
+    readonly createdAt: string;
+    readonly outcome?: ExecutionOutcome<Output>;
+}
+type Empty = Readonly<Record<string, never>>;
+type ExecutionLike<Output> = ExecutionRef<Output> | NodeId;
+/**
+ * Typed references to the methods of one Execution, for `session.invoke`:
+ *
+ * ```ts
+ * const run = await session.invoke(remind(invoice), { days: 3 })
+ * const outcome = await session.invoke(execution.result(run), { waitMs: 10_000 })
+ * ```
+ */
+export declare const execution: Readonly<{
+    status: <Output>(target: ExecutionLike<Output>) => CallableReference<Empty, ExecutionStatus<Output>>;
+    /** Outcome once terminal; fails `EXECUTION_PENDING` when `waitMs` elapses first. */
+    result: <Output>(target: ExecutionLike<Output>) => CallableReference<{
+        readonly waitMs?: number;
+    }, ExecutionOutcome<Output>>;
+    /** Cooperative cancellation; `force` kills without compensation (owner Domain only). */
+    cancel: <Output>(target: ExecutionLike<Output>) => CallableReference<{
+        readonly force?: boolean;
+    }, ExecutionStatus<Output>>;
+    /** Resolve a named durable promise once (owner Domain only). */
+    signal: (target: ExecutionLike<unknown>) => CallableReference<{
+        readonly name: string;
+        readonly value: Value;
+    }, Empty>;
+    resume: <Output>(target: ExecutionLike<Output>) => CallableReference<Empty, ExecutionStatus<Output>>;
+    /** Forget the Execution and stop its run (owner Domain only). */
+    delete: (target: ExecutionLike<unknown>) => CallableReference<Empty, Empty>;
+}>;
+export {};

package/dist/session/execution.js

@@ -0,0 +1,35 @@
+import { Path } from '@astrale-os/kernel-core/path';
+import { K } from '@astrale-os/kernel-core/schema';
+import { reference } from './reference.js';
+const methods = K.classes.Execution.methods;
+const bound = {
+    status: reference(K, methods.status),
+    result: reference(K, methods.result),
+    cancel: reference(K, methods.cancel),
+    signal: reference(K, methods.signal),
+    resume: reference(K, methods.resume),
+    delete: reference(K, methods.delete),
+};
+function receiver(execution) {
+    return Path.id(typeof execution === 'string' ? execution : execution.id);
+}
+/**
+ * Typed references to the methods of one Execution, for `session.invoke`:
+ *
+ * ```ts
+ * const run = await session.invoke(remind(invoice), { days: 3 })
+ * const outcome = await session.invoke(execution.result(run), { waitMs: 10_000 })
+ * ```
+ */
+export const execution = Object.freeze({
+    status: (target) => bound.status(receiver(target)),
+    /** Outcome once terminal; fails `EXECUTION_PENDING` when `waitMs` elapses first. */
+    result: (target) => bound.result(receiver(target)),
+    /** Cooperative cancellation; `force` kills without compensation (owner Domain only). */
+    cancel: (target) => bound.cancel(receiver(target)),
+    /** Resolve a named durable promise once (owner Domain only). */
+    signal: (target) => bound.signal(receiver(target)),
+    resume: (target) => bound.resume(receiver(target)),
+    /** Forget the Execution and stop its run (owner Domain only). */
+    delete: (target) => bound.delete(receiver(target)),
+});

package/dist/session/index.d.ts

@@ -1,10 +1,13 @@
 export type { SessionControlOptions, SessionPolicy } from './context/index.js';
+export type { ContentApi, ContentLocation, ContentUploadOptions, ContentUploadResult, } from './content.js';
 export { bindSession, type BoundClientSession, type BoundSessionControls, type BoundSessionSource, } from './bound.js';
 export { createSessionCredentialProvider, type SessionCredential, type SessionCredentialProvider, type SessionCredentialProviderOptions, type SessionCredentialState, } from './credential/index.js';
 export type { SessionSnapshot } from './discovery/index.js';
-export type { Auth, PersistedRoute, SessionRouteArtifact, SessionRouteStore, SessionAuth, SessionEnvelopeTransport, SessionRequestOptions, } from './routing/index.js';
+export type { SessionExchangeOptions, SessionExchangeRequest } from './exchange/index.js';
+export type { Auth, PersistedRoute, SessionRouteArtifact, SessionRouteStore, SessionAuth, SessionEnvelopeTransport, SessionRequestOptions, SessionRequestOptionsWithBody, } from './routing/index.js';
 export { ClientSession, connect, type ClientSessionOptions, type ConnectOptions, } from './session.js';
-export type { CallableReference, InputOfReference, InstanceCallableReference, OutputOfReference, } from './reference.js';
+export type { CallableReference, InputOfReference, InputModeOfReference, InstanceCallableReference, OutputOfReference, } from './reference.js';
 export { reference } from './reference.js';
+export { execution, type ExecutionOutcome, type ExecutionRef, type ExecutionState, type ExecutionStatus, } from './execution.js';
 export type { ResolvedView, ViewCatalog } from './views/index.js';
 export type { DomainBinding } from '../graph/domain/index.js';

package/dist/session/index.js

@@ -2,3 +2,4 @@ export { bindSession, } from './bound.js';
 export { createSessionCredentialProvider, } from './credential/index.js';
 export { ClientSession, connect, } from './session.js';
 export { reference } from './reference.js';
+export { execution, } from './execution.js';

package/dist/session/reference.d.ts

@@ -1,12 +1,14 @@
 import type { Path as PathValue, PathLike } from '@astrale-os/kernel-core/path';
-import type { CallableInputOf, CallableOutputOf, CallableResultOf, Domain, ResolvedFunction, ExecutableMethod } from '@astrale-os/kernel-dsl/v1';
+import type { CallableInputOf, CallableInputModeOf, CallableOutputOf, CallableResultOf, Domain, ResolvedFunction, ExecutableMethod } from '@astrale-os/kernel-dsl/v1';
 import type { Revision } from '@astrale-os/kernel-dsl/v1/addressing';
 import type { MeaningFingerprint } from '@astrale-os/kernel-dsl/v1/schema/fingerprint';
 import { type Key as KeyType } from '@astrale-os/kernel-dsl/v1/addressing';
 import type { Binary, Input } from '../client/index.js';
+import type { ExecutionRef } from './execution.js';
 declare const REFERENCE_INPUT: unique symbol;
+declare const REFERENCE_INPUT_MODE: unique symbol;
 declare const REFERENCE_OUTPUT: unique symbol;
-export interface CallableReference<InputValue = Input, Output = unknown> {
+export interface CallableReference<InputValue = Input, Output = unknown, InputMode extends 'value' | 'binary' = 'value' | 'binary'> {
     readonly origin: KeyType.Origin;
     /** @deprecated Informational only; dispatch pins `fingerprint` and revision pinning will be removed. */
     readonly revision: Revision;
@@ -16,6 +18,7 @@ export interface CallableReference<InputValue = Input, Output = unknown> {
     readonly target: PathValue;
     readonly outputMode: 'value' | 'stream' | 'binary';
     readonly [REFERENCE_INPUT]?: InputValue;
+    readonly [REFERENCE_INPUT_MODE]?: InputMode;
     readonly [REFERENCE_OUTPUT]?: Output;
 }
 export interface InstanceCallableReference<InputValue = Input, Output = unknown> {
@@ -28,12 +31,18 @@ export interface InstanceCallableReference<InputValue = Input, Output = unknown>
 }
 export type InputOfReference<Reference extends CallableReference<unknown>> = Reference extends CallableReference<infer InputValue, unknown> ? InputValue : never;
 export type OutputOfReference<Reference extends CallableReference<unknown>> = Reference extends CallableReference<infer _Input, infer Output> ? Output : never;
+export type InputModeOfReference<Reference extends CallableReference<unknown>> = Reference extends CallableReference<infer _Input, infer _Output, infer Mode> ? Mode : never;
 type ReferenceInput<Callable> = unknown extends CallableInputOf<Callable> ? Input : CallableInputOf<Callable>;
-type ReferenceOutput<Callable> = unknown extends CallableOutputOf<Callable> ? unknown : CallableResultOf<Callable, Binary>;
+type HandlerOutput<Callable> = unknown extends CallableOutputOf<Callable> ? unknown : CallableResultOf<Callable, Binary>;
+type ReferenceOutput<Callable> = Callable extends {
+    readonly execution: {
+        readonly durable: true;
+    };
+} ? ExecutionRef<HandlerOutput<Callable>> : HandlerOutput<Callable>;
 type ExecutableStaticMethod = ExecutableMethod<unknown, unknown, true>;
 type ExecutableInstanceMethod = ExecutableMethod<unknown, unknown, false>;
 /** 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>>;
+export declare function reference<const Callable extends ResolvedFunction | ExecutableStaticMethod>(domain: Pick<Domain, 'origin' | 'revision'>, callable: Callable): CallableReference<ReferenceInput<Callable>, ReferenceOutput<Callable>, CallableInputModeOf<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<unknown>): CallableReference<unknown>;

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

@@ -9,10 +9,20 @@ 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>;
+    /**
+     * Replace the source credential now, before `resolve` would. A Session asks for it only when a
+     * credential it derives from the current source, such as a Domain exchange, could not cover
+     * `ttlSeconds`: a derived credential never outlives its source.
+     */
+    refresh?(signal: AbortSignal): PromiseLike<unknown> | void;
 }
 export interface EffectiveAuth {
     readonly credential?: string;
     readonly delegate?: invocation.Delegate;
 }
+/** Replace the resolved source authority of one Call before routing partitions and presents it. */
+export interface AuthExchange {
+    resolve(call: invocation.Call, auth: EffectiveAuth, operation: SessionOperation): Promise<EffectiveAuth>;
+}
 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

@@ -10,7 +10,14 @@ export function admitSessionAuth(input) {
     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) });
+    if (input.refresh !== undefined && typeof input.refresh !== 'function') {
+        throw new TypeError('Session auth refresh capability is invalid.');
+    }
+    return Object.freeze({
+        ttlSeconds: input.ttlSeconds,
+        resolve: input.resolve.bind(input),
+        ...(input.refresh === undefined ? {} : { refresh: input.refresh.bind(input) }),
+    });
 }
 export async function resolveAuth(resolver, call, operation) {
     if (resolver === undefined)

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

@@ -1,7 +1,8 @@
 import type { IssuerId } from '@astrale-os/kernel-core/auth/issuer';
 import type { Result } from '../../client/index.js';
+import type { Fetch } from '../../transport/http/index.js';
 import type { SessionOperation, SessionPolicy } from '../context/index.js';
-import type { SessionAuth } from './auth.js';
+import type { AuthExchange, SessionAuth } from './auth.js';
 import type { RouteCache } from './cache.js';
 import type { ClientPoolCapability } from './envelope.js';
 import type { SessionEnvelopeTransport, SessionRequestOptions } from './request.js';
@@ -12,19 +13,29 @@ export interface SessionDispatcherOptions {
     readonly pool: ClientPoolCapability;
     readonly websocketAvailable: boolean;
     readonly auth?: SessionAuth;
+    readonly exchange?: AuthExchange;
     readonly cache: RouteCache;
     readonly policy: Readonly<SessionPolicy>;
     readonly envelopeTransport: SessionEnvelopeTransport;
     readonly requireOpen: () => void;
+    readonly streamingHttp: {
+        readonly fetch: Fetch;
+        readonly maximumResponseBytes: number;
+        readonly timeoutMs: number;
+    };
 }
 export declare class SessionDispatcher {
     private readonly state;
     constructor(state: SessionDispatcherOptions);
     dispatch(input: Parameters<typeof acceptCall>[0], options: SessionRequestOptions, operation: SessionOperation): Promise<Result>;
+    /** Reuse Session authority and route recovery while forcing HTTP for streaming calls. */
+    dispatchHttp(input: Parameters<typeof acceptCall>[0], options: SessionRequestOptions, operation: SessionOperation, body?: Blob): Promise<Result>;
+    private dispatchWith;
     private dispatchSource;
     private followSource;
     private dispatchDestinationWithRecovery;
     private dispatchDestination;
+    private streamingClientFor;
 }
 export declare function requireResultKind<Kind extends 'value' | 'stream' | 'binary'>(expected: Kind, result: Result): Extract<Result, {
     kind: Kind;

package/dist/session/routing/dispatch.js

@@ -1,6 +1,6 @@
 import { Key } from '@astrale-os/kernel-dsl/v1/addressing';
 import * as invocationProtocol from '@astrale-os/kernel-protocol/invocation';
-import { acceptCall, dispatchTrace, isAdmittedMissError, isAdmittedStaleRouteError, } from '../../client/index.js';
+import { acceptCall, Client, dispatchTrace, isAdmittedMissError, isAdmittedStaleRouteError, } from '../../client/index.js';
 import { ClientError, ResponseError } from '../../errors/index.js';
 import { runSessionOperation, sessionTransportOptions, allowEndpoint } from '../context/index.js';
 import { resolveAuth } from './auth.js';
@@ -11,11 +11,21 @@ export class SessionDispatcher {
         this.state = state;
     }
     async dispatch(input, options, operation) {
+        return this.dispatchWith(input, options, operation);
+    }
+    /** Reuse Session authority and route recovery while forcing HTTP for streaming calls. */
+    async dispatchHttp(input, options, operation, body) {
+        return this.dispatchWith(input, options, operation, { body });
+    }
+    async dispatchWith(input, options, operation, streaming) {
         this.state.requireOpen();
         const call = acceptCall(input);
         // Authority is resolved before warm lookup so changed credentials or delegation cannot reuse a
-        // carrier minted for a different caller partition.
-        const auth = await resolveAuth(this.state.auth, call, operation);
+        // carrier minted for a different caller partition. An exchanged credential is its own partition.
+        const resolved = await resolveAuth(this.state.auth, call, operation);
+        const auth = this.state.exchange === undefined
+            ? resolved
+            : await this.state.exchange.resolve(call, resolved, operation);
         const source = this.state.kernel;
         const cacheKey = await this.state.cache.key(source, call, auth);
         const dispatch = Object.freeze({
@@ -27,7 +37,7 @@ export class SessionDispatcher {
         let learned = await this.state.cache.get(cacheKey, auth.credential);
         if (learned !== undefined) {
             try {
-                requireCachedRoute(learned, source, call.target, this.state.envelopeTransport, this.state.websocketAvailable, this.state.policy);
+                requireCachedRoute(learned, source, call.target, streaming === undefined ? this.state.envelopeTransport : 'http', this.state.websocketAvailable, this.state.policy);
             }
             catch {
                 this.state.cache.delete(cacheKey);
@@ -35,22 +45,31 @@ export class SessionDispatcher {
             }
         }
         if (learned !== undefined) {
-            return this.dispatchDestinationWithRecovery(learned, dispatch, options, operation);
+            return this.dispatchDestinationWithRecovery(learned, dispatch, options, operation, undefined, streaming);
         }
-        const result = await this.dispatchSource(dispatch, undefined, options, operation);
-        return this.followSource(result, dispatch, options, operation);
+        const result = await this.dispatchSource(dispatch, undefined, options, operation, streaming);
+        return this.followSource(result, dispatch, options, operation, streaming);
     }
-    async dispatchSource(state, routing, options, operation) {
+    async dispatchSource(state, routing, options, operation, streaming) {
         this.state.requireOpen();
         allowEndpoint(this.state.sourceEndpoint, this.state.policy);
-        const client = this.state.pool.clientFor(Object.freeze({ transport: 'http', url: this.state.sourceEndpoint }));
-        return runSessionOperation(operation, () => authenticated(client, state.auth.credential).dispatch(state.call, {
-            ...sessionTransportOptions(operation, options.idempotencyKey),
-            ...(state.auth.delegate === undefined ? {} : { delegate: state.auth.delegate }),
-            ...(routing === undefined ? {} : { routing }),
-        }));
+        const client = streaming === undefined
+            ? this.state.pool.clientFor(Object.freeze({ transport: 'http', url: this.state.sourceEndpoint }))
+            : this.streamingClientFor(this.state.sourceEndpoint);
+        return runSessionOperation(operation, () => streaming?.body === undefined
+            ? authenticated(client, state.auth.credential).dispatch(state.call, {
+                ...sessionTransportOptions(operation, options.idempotencyKey),
+                ...(state.auth.delegate === undefined ? {} : { delegate: state.auth.delegate }),
+                ...(routing === undefined ? {} : { routing }),
+            })
+            : authenticated(client, state.auth.credential).dispatch(state.call, {
+                ...sessionTransportOptions(operation),
+                ...(state.auth.delegate === undefined ? {} : { delegate: state.auth.delegate }),
+                ...(routing === undefined ? {} : { routing }),
+                body: streaming.body,
+            }));
     }
-    async followSource(result, state, options, operation) {
+    async followSource(result, state, options, operation, streaming) {
         if (result.kind !== 'redirect')
             return result;
         const redirect = result.redirect;
@@ -59,11 +78,11 @@ export class SessionDispatcher {
         }
         requireTargetPublication(redirect.route, state.call.target);
         const learned = await this.state.cache.learn(state.cacheKey, redirect.route, redirect.credential, state.auth.credential);
-        return this.dispatchDestinationWithRecovery(learned, state, options, operation, redirect.trace);
+        return this.dispatchDestinationWithRecovery(learned, state, options, operation, redirect.trace, streaming);
     }
-    async dispatchDestinationWithRecovery(learned, state, options, operation, trace) {
+    async dispatchDestinationWithRecovery(learned, state, options, operation, trace, streaming) {
         try {
-            return await this.dispatchDestination(learned, state.call, options, operation, state.source, trace);
+            return await this.dispatchDestination(learned, state.call, options, operation, state.source, trace, streaming);
         }
         catch (cause) {
             const stale = isAdmittedStaleRouteError(cause);
@@ -83,20 +102,31 @@ export class SessionDispatcher {
                     stale: learned.route.via.publication.etag,
                 })
                 : undefined;
-            const refreshed = await this.dispatchSource(state, routing, options, operation);
-            return this.followSource(refreshed, state, options, operation);
+            const refreshed = await this.dispatchSource(state, routing, options, operation, streaming);
+            return this.followSource(refreshed, state, options, operation, streaming);
         }
     }
-    async dispatchDestination(learned, call, options, operation, source, trace) {
+    async dispatchDestination(learned, call, options, operation, source, trace, streaming) {
         if (learned.route.via.issuer !== source) {
             throw new ClientError('Learned route issuer differs from the session-pinned source Kernel.');
         }
         requireTargetPublication(learned.route, call.target);
-        const envelope = selectEnvelope(learned.route.endpoint, this.state.envelopeTransport, this.state.websocketAvailable, this.state.pool, this.state.policy);
+        const destination = streaming === undefined
+            ? undefined
+            : selectEnvelopeTarget(learned.route.endpoint, 'http', this.state.websocketAvailable, this.state.policy);
+        const client = streaming === undefined
+            ? selectEnvelope(learned.route.endpoint, this.state.envelopeTransport, this.state.websocketAvailable, this.state.pool, this.state.policy).client
+            : destination?.transport === 'http'
+                ? this.streamingClientFor(destination.url)
+                : invalidStreamingDestination();
         const requestOptions = {
             ...sessionTransportOptions(operation, options.idempotencyKey),
             routing: learned.route.via,
         };
+        const binaryRequestOptions = {
+            ...sessionTransportOptions(operation),
+            routing: learned.route.via,
+        };
         // The source has admitted this fingerprint against the exact Publication carried by Via.
         // Pin that revision at the destination so existing Workers can execute the same admitted
         // callable without understanding the newer fingerprint Target representation. The cache
@@ -111,14 +141,32 @@ export class SessionDispatcher {
                 }),
             }
             : call;
-        const result = await runSessionOperation(operation, () => trace === undefined
-            ? authenticated(envelope.client, learned.credential).dispatch(destinationCall, requestOptions)
-            : dispatchTrace(envelope.client, learned.credential, destinationCall, requestOptions, trace));
+        const result = await runSessionOperation(operation, () => streaming?.body !== undefined
+            ? trace === undefined
+                ? authenticated(client, learned.credential).dispatch(destinationCall, {
+                    ...binaryRequestOptions,
+                    body: streaming.body,
+                })
+                : dispatchTrace(client, learned.credential, destinationCall, { ...binaryRequestOptions, body: streaming.body }, trace)
+            : trace === undefined
+                ? authenticated(client, learned.credential).dispatch(destinationCall, requestOptions)
+                : dispatchTrace(client, learned.credential, destinationCall, requestOptions, trace));
         if (result.kind === 'redirect') {
             throw new ClientError('A destination redirect is invalid; only the source Kernel may redirect.');
         }
         return result;
     }
+    streamingClientFor(url) {
+        return new Client({
+            url,
+            fetch: this.state.streamingHttp.fetch,
+            timeoutMs: this.state.streamingHttp.timeoutMs,
+            maximumResponseBytes: this.state.streamingHttp.maximumResponseBytes,
+        });
+    }
+}
+function invalidStreamingDestination() {
+    throw new ClientError('Streaming route has no HTTP endpoint.');
 }
 function requireCachedRoute(learned, source, target, envelopeTransport, websocketAvailable, policy) {
     if (learned.route.via.issuer !== source) {

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

@@ -1,5 +1,5 @@
-export { admitSessionAuth, resolveAuth, type Auth, type EffectiveAuth, type SessionAuth, } from './auth.js';
+export { admitSessionAuth, resolveAuth, type Auth, type AuthExchange, type EffectiveAuth, type SessionAuth, } from './auth.js';
 export { RouteCache, type LearnedRoute, type PersistedRoute, type SessionRouteArtifact, type SessionRouteStore, } from './cache.js';
 export { requireResultKind, SessionDispatcher, type SessionDispatcherOptions } from './dispatch.js';
 export { type ClientPoolCapability, type EnvelopeSelection } from './envelope.js';
-export { admitEnvelopeTransport, admitRequestOptions, type SessionEnvelopeTransport, type SessionRequestOptions, } from './request.js';
+export { admitEnvelopeTransport, admitInvocationOptions, admitRequestOptions, type SessionEnvelopeTransport, type SessionRequestOptions, type SessionRequestOptionsWithBody, } from './request.js';

package/dist/session/routing/index.js

@@ -2,4 +2,4 @@ export { admitSessionAuth, resolveAuth, } from './auth.js';
 export { RouteCache, } from './cache.js';
 export { requireResultKind, SessionDispatcher } from './dispatch.js';
 export {} from './envelope.js';
-export { admitEnvelopeTransport, admitRequestOptions, } from './request.js';
+export { admitEnvelopeTransport, admitInvocationOptions, admitRequestOptions, } from './request.js';