@astrale-os/kernel-client 0.6.0-beta.1 → 0.6.0-beta.11

package/dist/auth/auth.d.ts

@@ -1,6 +1,6 @@
 import type { Identity, IdentityId, MintedCredential, ProvisionRequest, ProvisionResult } from '@astrale-os/kernel-core/auth';
 import type { PathLike } from '@astrale-os/kernel-core/path';
-import type { Input } from '@astrale-os/kernel-ports/functions';
+import type { Input } from '../client/index.js';
 import type { RequestOptions } from '../transport/index.js';
 import type { PolicyDecisionInput } from './authorization.js';
 import type { DelegateOptions, MintOptions } from './credential.js';
@@ -16,4 +16,3 @@ export interface AuthApi {
 }
 /** Bind the current Core identity syscalls without recreating legacy grant-edge verbs. */
 export declare function createAuth(call: AuthCall): AuthApi;
-//# sourceMappingURL=auth.d.ts.map

package/dist/auth/auth.js

@@ -13,4 +13,3 @@ export function createAuth(call) {
         ...credentialApi(call),
     });
 }
-//# sourceMappingURL=auth.js.map

package/dist/auth/authorization.d.ts

@@ -1,14 +1,13 @@
 import type { NodeId } from '@astrale-os/kernel-core/graph/node';
 import type { NodePath, PathLike } from '@astrale-os/kernel-core/path';
-import type { schema } from '@astrale-os/kernel-dsl/v1';
+import type { PolicyRef } from '@astrale-os/kernel-dsl/v1';
 import type { RequestOptions } from '../transport/index.js';
 import type { AuthCall } from './auth.js';
 export interface PolicyDecisionInput {
-    readonly policy: PathLike | schema.PolicyRef;
+    readonly policy: PathLike | PolicyRef;
     readonly object: NodeId;
 }
 export declare const IDENTITY_CAN_PATH: NodePath;
 export declare function authorizationApi(call: AuthCall): Readonly<{
     can(input: PolicyDecisionInput, options?: RequestOptions): Promise<boolean>;
 }>;
-//# sourceMappingURL=authorization.d.ts.map

package/dist/auth/authorization.js

@@ -1,7 +1,7 @@
 import { Path } from '@astrale-os/kernel-core/path';
-import { syscalls } from '@astrale-os/kernel-core/schema';
-const identityOwner = Path.project(syscalls.identity.whoami.ref.owner);
-export const IDENTITY_CAN_PATH = Path.staticMethod(identityOwner, syscalls.identity.can.ref.name).raw;
+import { identity } from '@astrale-os/kernel-core/schema/kernel/syscalls/references';
+const identityOwner = Path.project(identity.whoami.owner);
+export const IDENTITY_CAN_PATH = Path.staticMethod(identityOwner, identity.can.name).raw;
 export function authorizationApi(call) {
     return Object.freeze({
         async can(input, options) {
@@ -15,4 +15,3 @@ function policyPath(input) {
         ? Path.from(input).raw
         : Path.project(input).raw;
 }
-//# sourceMappingURL=authorization.js.map

package/dist/auth/credential.d.ts

@@ -10,11 +10,10 @@ export interface MintOptions {
 export interface DelegateOptions {
     readonly audience: string;
     readonly ttlSeconds: number;
-    readonly delegation: UnresolvedIdentityExpr;
+    readonly attenuation: UnresolvedIdentityExpr;
 }
 export declare const IDENTITY_MINT_PATH: NodePath;
 export declare function credentialApi(call: AuthCall): Readonly<{
     mint(input: MintOptions, options?: RequestOptions): Promise<MintedCredential>;
-    delegate(identity: IdentityId, input: DelegateOptions, options?: RequestOptions): Promise<MintedCredential>;
+    delegate(principal: IdentityId, input: DelegateOptions, options?: RequestOptions): Promise<MintedCredential>;
 }>;
-//# sourceMappingURL=credential.d.ts.map

package/dist/auth/credential.js

@@ -1,14 +1,14 @@
 import { Path } from '@astrale-os/kernel-core/path';
-import { syscalls } from '@astrale-os/kernel-core/schema';
-const identityOwner = Path.project(syscalls.identity.whoami.ref.owner);
-export const IDENTITY_MINT_PATH = Path.staticMethod(identityOwner, syscalls.identity.mint.ref.name).raw;
+import { identity } from '@astrale-os/kernel-core/schema/kernel/syscalls/references';
+const identityOwner = Path.project(identity.whoami.owner);
+export const IDENTITY_MINT_PATH = Path.staticMethod(identityOwner, identity.mint.name).raw;
 export function credentialApi(call) {
     return Object.freeze({
         async mint(input, options) {
             return credential(await call(IDENTITY_MINT_PATH, input, options));
         },
-        async delegate(identity, input, options) {
-            const target = Path.instanceMethod(Path.id(identity), syscalls.identity.delegate.ref.name).raw;
+        async delegate(principal, input, options) {
+            const target = Path.instanceMethod(Path.id(principal), identity.delegate.name).raw;
             return credential(await call(target, input, options));
         },
     });
@@ -19,4 +19,3 @@ function credential(input) {
     }
     return input;
 }
-//# sourceMappingURL=credential.js.map

package/dist/auth/identity.d.ts

@@ -1,10 +1,10 @@
-import type { Identity, IdentitySubject, IssuerId } from '@astrale-os/kernel-core/auth';
+import type { Identity, IssuerId, Subject } from '@astrale-os/kernel-core/auth';
 import type { NodePath } from '@astrale-os/kernel-core/path';
 import type { RequestOptions } from '../transport/index.js';
 import type { AuthCall } from './auth.js';
 export interface WhoisInput {
     readonly issuer: IssuerId;
-    readonly subject: IdentitySubject;
+    readonly subject: Subject;
 }
 export declare const IDENTITY_WHOAMI_PATH: NodePath;
 export declare const IDENTITY_WHOIS_PATH: NodePath;
@@ -12,4 +12,3 @@ export declare function identityApi(call: AuthCall): Readonly<{
     whoami(options?: RequestOptions): Promise<Identity>;
     whois(input: WhoisInput, options?: RequestOptions): Promise<Identity | null>;
 }>;
-//# sourceMappingURL=identity.d.ts.map

package/dist/auth/identity.js

@@ -1,8 +1,8 @@
 import { Path } from '@astrale-os/kernel-core/path';
-import { syscalls } from '@astrale-os/kernel-core/schema';
-const identityOwner = Path.project(syscalls.identity.whoami.ref.owner);
-export const IDENTITY_WHOAMI_PATH = Path.staticMethod(identityOwner, syscalls.identity.whoami.ref.name).raw;
-export const IDENTITY_WHOIS_PATH = Path.staticMethod(identityOwner, syscalls.identity.whois.ref.name).raw;
+import { identity } from '@astrale-os/kernel-core/schema/kernel/syscalls/references';
+const identityOwner = Path.project(identity.whoami.owner);
+export const IDENTITY_WHOAMI_PATH = Path.staticMethod(identityOwner, identity.whoami.name).raw;
+export const IDENTITY_WHOIS_PATH = Path.staticMethod(identityOwner, identity.whois.name).raw;
 export function identityApi(call) {
     return Object.freeze({
         async whoami(options) {
@@ -13,4 +13,3 @@ export function identityApi(call) {
         },
     });
 }
-//# sourceMappingURL=identity.js.map

package/dist/auth/index.d.ts

@@ -3,5 +3,4 @@ export { IDENTITY_CAN_PATH, type PolicyDecisionInput } from './authorization.js'
 export { IDENTITY_MINT_PATH, type DelegateOptions, type MintOptions } from './credential.js';
 export { IDENTITY_WHOAMI_PATH, IDENTITY_WHOIS_PATH, type WhoisInput } from './identity.js';
 export { IDENTITY_PROVISION_PATH } from './provision.js';
-export type { Identity, IdentityId, IdentitySubject, IssuerId, MintedCredential, ProvisionRequest, ProvisionResult, UnresolvedGrant, UnresolvedIdentityExpr, } from '@astrale-os/kernel-core/auth';
-//# sourceMappingURL=index.d.ts.map
+export type { Identity, IdentityId, Subject, IssuerId, MintedCredential, ProvisionRequest, ProvisionResult, UnresolvedGrant, UnresolvedIdentityExpr, } from '@astrale-os/kernel-core/auth';

package/dist/auth/index.js

@@ -3,4 +3,3 @@ export { IDENTITY_CAN_PATH } from './authorization.js';
 export { IDENTITY_MINT_PATH } from './credential.js';
 export { IDENTITY_WHOAMI_PATH, IDENTITY_WHOIS_PATH } from './identity.js';
 export { IDENTITY_PROVISION_PATH } from './provision.js';
-//# sourceMappingURL=index.js.map

package/dist/auth/provision.d.ts

@@ -6,4 +6,3 @@ export declare const IDENTITY_PROVISION_PATH: NodePath;
 export declare function provisionApi(call: AuthCall): Readonly<{
     provision(input: ProvisionRequest, options?: RequestOptions): Promise<ProvisionResult>;
 }>;
-//# sourceMappingURL=provision.d.ts.map

package/dist/auth/provision.js

@@ -1,6 +1,6 @@
 import { Path } from '@astrale-os/kernel-core/path';
-import { syscalls } from '@astrale-os/kernel-core/schema';
-export const IDENTITY_PROVISION_PATH = Path.project(syscalls.provision.ref).raw;
+import { provision } from '@astrale-os/kernel-core/schema/kernel/syscalls/references';
+export const IDENTITY_PROVISION_PATH = Path.project(provision).raw;
 export function provisionApi(call) {
     return Object.freeze({
         async provision(input, options) {
@@ -8,4 +8,3 @@ export function provisionApi(call) {
         },
     });
 }
-//# sourceMappingURL=provision.js.map

package/dist/client/admission.d.ts

@@ -2,4 +2,3 @@ import type { invocation as protocol } from '@astrale-os/kernel-protocol';
 import type { Call } from './request.js';
 /** Parent-private Call acceptance shared by Client and Client Session. */
 export declare function acceptCall(input: Call): protocol.Call;
-//# sourceMappingURL=admission.d.ts.map

package/dist/client/admission.js

@@ -32,4 +32,3 @@ function freezeValue(input) {
     }
     return input;
 }
-//# sourceMappingURL=admission.js.map

package/dist/client/client.d.ts

@@ -1,11 +1,14 @@
-import type { Binary, Input, Result, Stream } from '@astrale-os/kernel-ports/functions';
+import type { invocation as protocol } from '@astrale-os/kernel-protocol';
 import type { Transport } from '../transport/index.js';
 import type { AuthenticatedClient, RemoteCredential } from './credential.js';
 import type { Call, ClientDispatchOptions } from './request.js';
+import type { BinaryResponse, Result, StreamResult, ValueResult } from './result.js';
 import { type HttpTransportOptions } from '../transport/http/index.js';
 export type ClientOptions = HttpTransportOptions | {
     readonly transport: Transport;
 };
+/** Package-private redirect continuation path; intentionally absent from the public Client facade. */
+export declare function dispatchTrace(client: Client, credential: RemoteCredential | undefined, call: Call, options: ClientDispatchOptions | undefined, trace: protocol.Trace): Promise<Result>;
 /** Pure client for the universal remote Function invocation boundary. */
 export declare class Client implements AuthenticatedClient {
     private readonly transport;
@@ -13,11 +16,10 @@ export declare class Client implements AuthenticatedClient {
     private closed;
     constructor(options: ClientOptions);
     dispatch(call: Call, options?: ClientDispatchOptions): Promise<Result>;
-    call(call: Call, options?: ClientDispatchOptions): Promise<Input>;
-    stream(call: Call, options?: ClientDispatchOptions): Promise<Stream>;
-    binary(call: Call, options?: ClientDispatchOptions): Promise<Binary>;
+    call(call: Call, options?: ClientDispatchOptions): Promise<ValueResult>;
+    stream(call: Call, options?: ClientDispatchOptions): Promise<StreamResult>;
+    binary(call: Call, options?: ClientDispatchOptions): Promise<BinaryResponse>;
     as(credential: RemoteCredential): AuthenticatedClient;
     close(): void;
     private dispatchWith;
 }
-//# sourceMappingURL=client.d.ts.map

package/dist/client/client.js

@@ -4,6 +4,14 @@ import { authenticated, resolveCredential } from './credential.js';
 import { admitRequest, invocation } from './request.js';
 import { requireBinary, requireStream, requireValue } from './result.js';
 import { admittedMissError, admittedStaleRouteError } from './routing-control.js';
+const controlledDispatch = new WeakMap();
+/** Package-private redirect continuation path; intentionally absent from the public Client facade. */
+export function dispatchTrace(client, credential, call, options, trace) {
+    const dispatch = controlledDispatch.get(client);
+    if (dispatch === undefined)
+        throw new TypeError('Trace dispatch requires an owned Client.');
+    return dispatch(credential, call, options, trace);
+}
 /** Pure client for the universal remote Function invocation boundary. */
 export class Client {
     transport;
@@ -16,6 +24,7 @@ export class Client {
         this.transport = Object.hasOwn(options, 'transport')
             ? admitTransport(options.transport)
             : new HttpTransport(options);
+        controlledDispatch.set(this, (credential, call, requestOptions, trace) => this.dispatchWith(credential, call, requestOptions, trace));
     }
     dispatch(call, options) {
         return this.dispatchWith(undefined, call, options);
@@ -40,7 +49,7 @@ export class Client {
         this.lifecycle.abort(failure);
         this.transport.close?.();
     }
-    async dispatchWith(credential, input, options) {
+    async dispatchWith(credential, input, options, trace) {
         if (this.closed)
             throw new ClientError('Client is closed.');
         const request = admitRequest(input, options, this.lifecycle.signal);
@@ -48,11 +57,11 @@ export class Client {
             ? undefined
             : await resolveCredential(credential, request.options.signal);
         requireRequestLive(request.options.signal);
-        const result = await this.transport.dispatch(invocation(request, resolved), request.options);
+        const result = await this.transport.dispatch(invocation(request, resolved, trace), request.options);
         if (result.kind === 'stale')
-            throw admittedStaleRouteError(result.current);
+            throw admittedStaleRouteError(result.current, result.invocation);
         if (result.kind === 'miss')
-            throw admittedMissError();
+            throw admittedMissError(result.invocation);
         return result;
     }
 }
@@ -81,4 +90,3 @@ function admitTransport(input) {
         ...(close === undefined ? {} : { close: close.bind(input) }),
     });
 }
-//# sourceMappingURL=client.js.map

package/dist/client/credential.d.ts

@@ -1,13 +1,12 @@
-import type { Binary, Input, Result, Stream } from '@astrale-os/kernel-ports/functions';
 import type { Call, ClientDispatchOptions } from './request.js';
+import type { BinaryResponse, Result, StreamResult, ValueResult } from './result.js';
 export type RemoteCredential = string | (() => string | Promise<string>);
 export interface AuthenticatedClient {
     dispatch(call: Call, options?: ClientDispatchOptions): Promise<Result>;
-    call(call: Call, options?: ClientDispatchOptions): Promise<Input>;
-    stream(call: Call, options?: ClientDispatchOptions): Promise<Stream>;
-    binary(call: Call, options?: ClientDispatchOptions): Promise<Binary>;
+    call(call: Call, options?: ClientDispatchOptions): Promise<ValueResult>;
+    stream(call: Call, options?: ClientDispatchOptions): Promise<StreamResult>;
+    binary(call: Call, options?: ClientDispatchOptions): Promise<BinaryResponse>;
 }
 export type CredentialDispatch = (credential: RemoteCredential, call: Call, options?: ClientDispatchOptions) => Promise<Result>;
 export declare function authenticated(dispatchWith: CredentialDispatch, credential: RemoteCredential): AuthenticatedClient;
 export declare function resolveCredential(input: RemoteCredential, signal?: AbortSignal): Promise<string>;
-//# sourceMappingURL=credential.d.ts.map

package/dist/client/credential.js

@@ -49,4 +49,3 @@ function cancellation(reason) {
         ? reason
         : new ClientError('Client request was cancelled.', { cause: reason });
 }
-//# sourceMappingURL=credential.js.map

package/dist/client/index.d.ts

@@ -1,6 +1,6 @@
-export { Client, type ClientOptions } from './client.js';
+export { Client, dispatchTrace, type ClientOptions } from './client.js';
 export { acceptCall } from './admission.js';
 export type { AuthenticatedClient, RemoteCredential } from './credential.js';
 export { call, type Call, type ClientDispatchOptions } from './request.js';
+export type { Binary, BinaryResponse, Input, RedirectResult, Result, Stream, StreamResult, ValueResult, } from './result.js';
 export { isAdmittedMissError, isAdmittedStaleRouteError } from './routing-control.js';
-//# sourceMappingURL=index.d.ts.map

package/dist/client/index.js

@@ -1,5 +1,4 @@
-export { Client } from './client.js';
+export { Client, dispatchTrace } from './client.js';
 export { acceptCall } from './admission.js';
 export { call } from './request.js';
 export { isAdmittedMissError, isAdmittedStaleRouteError } from './routing-control.js';
-//# sourceMappingURL=index.js.map

package/dist/client/request.d.ts

@@ -1,7 +1,7 @@
 import type { PathLike } from '@astrale-os/kernel-core/path';
-import type { Input } from '@astrale-os/kernel-ports/functions';
-import type { invocation as protocol } from '@astrale-os/kernel-protocol';
+import type * as protocol from '@astrale-os/kernel-protocol/invocation';
 import type { RequestOptions, TransportRequest } from '../transport/index.js';
+import type { Input } from './result.js';
 /** One portable call before Path canonicalization, correlation, and credential binding. */
 export interface Call {
     readonly target: PathLike;
@@ -11,14 +11,16 @@ export interface ClientDispatchOptions extends RequestOptions {
     /** Untrusted delivery context; it changes neither Call meaning nor authority. */
     readonly delegate?: protocol.Delegate;
     readonly routing?: protocol.Routing;
+    /** Package-owned local-target or remote-revision precondition for a bound invocation. */
+    readonly schema?: protocol.SchemaTarget;
 }
 export interface AdmittedRequest {
     readonly call: protocol.Call;
     readonly delegate?: protocol.Delegate;
     readonly routing?: protocol.Routing;
+    readonly schema?: protocol.SchemaTarget;
     readonly options: RequestOptions;
 }
 export declare function call(target: PathLike, input: Input): Call;
 export declare function admitRequest(input: Call, options: ClientDispatchOptions | undefined, lifecycle: AbortSignal): AdmittedRequest;
-export declare function invocation(request: AdmittedRequest, credential?: string): TransportRequest;
-//# sourceMappingURL=request.d.ts.map
+export declare function invocation(request: AdmittedRequest, credential?: string, trace?: protocol.Trace): TransportRequest;

package/dist/client/request.js

@@ -1,4 +1,4 @@
-import { invocation as invocationProtocol } from '@astrale-os/kernel-protocol';
+import * as invocationProtocol from '@astrale-os/kernel-protocol/invocation';
 import { acceptCall } from './admission.js';
 export function call(target, input) {
     return Object.freeze({ target, input });
@@ -8,18 +8,24 @@ export function admitRequest(input, options, lifecycle) {
     const admittedOptions = lifecycleOptions(admitRequestOptions(options), lifecycle);
     const delegate = admitDelegate(options?.delegate);
     const routing = admitRouting(options?.routing);
+    const schema = admitSchemaTarget(options?.schema);
     return Object.freeze({
         call,
         ...(delegate === undefined ? {} : { delegate }),
         ...(routing === undefined ? {} : { routing }),
+        ...(schema === undefined ? {} : { schema }),
         options: admittedOptions,
     });
 }
-export function invocation(request, credential) {
+export function invocation(request, credential, trace) {
+    const admittedTrace = trace === undefined ? undefined : invocationProtocol.admitTrace(trace);
     if (request.routing?.kind === 'via') {
         if (request.delegate !== undefined) {
             throw new TypeError('Destination Client requests cannot carry a delegation request.');
         }
+        if (request.schema !== undefined) {
+            throw new TypeError('Destination Client requests cannot carry a Schema target.');
+        }
     }
     else if ((credential === undefined) !== (request.delegate === undefined)) {
         throw new TypeError('Source Client credentials and delegation requests must occur together.');
@@ -29,6 +35,8 @@ export function invocation(request, credential) {
         ...(credential === undefined ? {} : { credential }),
         ...(request.delegate === undefined ? {} : { delegate: request.delegate }),
         ...(request.routing === undefined ? {} : { routing: request.routing }),
+        ...(request.schema === undefined ? {} : { schema: request.schema }),
+        ...(admittedTrace === undefined ? {} : { trace: admittedTrace }),
     });
 }
 function admitRequestOptions(input) {
@@ -72,6 +80,16 @@ function admitRouting(input) {
         throw new TypeError('Client routing context is invalid.', { cause });
     }
 }
+function admitSchemaTarget(input) {
+    if (input === undefined)
+        return undefined;
+    try {
+        return invocationProtocol.acceptSchemaTarget(input);
+    }
+    catch (cause) {
+        throw new TypeError('Client Schema target is invalid.', { cause });
+    }
+}
 function lifecycleOptions(input, lifecycle) {
     const signal = input?.signal === undefined ? lifecycle : AbortSignal.any([input.signal, lifecycle]);
     return Object.freeze({
@@ -80,4 +98,3 @@ function lifecycleOptions(input, lifecycle) {
         ...(input?.idempotencyKey === undefined ? {} : { idempotencyKey: input.idempotencyKey }),
     });
 }
-//# sourceMappingURL=request.js.map

package/dist/client/result.d.ts

@@ -1,5 +1,35 @@
-import type { Binary, Input, Result, Stream } from '@astrale-os/kernel-ports/functions';
-export declare function requireValue(result: Promise<Result>): Promise<Input>;
-export declare function requireStream(result: Promise<Result>): Promise<Stream>;
-export declare function requireBinary(result: Promise<Result>): Promise<Binary>;
-//# sourceMappingURL=result.d.ts.map
+import type { BinaryResult, CallableResult } from '@astrale-os/kernel-core/callable';
+import type { Value } from '@astrale-os/kernel-dsl/value';
+import type { invocation as protocol } from '@astrale-os/kernel-protocol';
+/** Caller-visible value accepted from one admitted remote invocation. */
+export type Input = Value;
+/** Caller-visible finite binary response. */
+export type Binary = BinaryResult;
+/** Caller-owned remote stream. */
+export interface Stream extends AsyncIterable<Value> {
+    cancel(reason?: string): Promise<void>;
+}
+/** Complete result observed by a Client before result-mode narrowing. */
+type Correlated<Result> = Result & {
+    readonly invocation: protocol.InvocationId;
+};
+type Callable = CallableResult<Value, Stream>;
+export type ValueResult = Correlated<Extract<Callable, {
+    readonly kind: 'value';
+}>>;
+export type StreamResult = Correlated<Extract<Callable, {
+    readonly kind: 'stream';
+}>>;
+export type BinaryResponse = Correlated<Extract<Callable, {
+    readonly kind: 'binary';
+}>>;
+export interface RedirectResult {
+    readonly kind: 'redirect';
+    readonly redirect: protocol.Redirection;
+    readonly invocation: protocol.InvocationId;
+}
+export type Result = ValueResult | StreamResult | BinaryResponse | RedirectResult;
+export declare function requireValue(result: Promise<Result>): Promise<ValueResult>;
+export declare function requireStream(result: Promise<Result>): Promise<StreamResult>;
+export declare function requireBinary(result: Promise<Result>): Promise<BinaryResponse>;
+export {};

package/dist/client/result.js

@@ -3,19 +3,19 @@ export async function requireValue(result) {
     const settled = await result;
     if (settled.kind !== 'value')
         return rejectMismatch('value', settled);
-    return settled.value;
+    return settled;
 }
 export async function requireStream(result) {
     const settled = await result;
     if (settled.kind !== 'stream')
         mismatch('stream', settled.kind);
-    return settled.stream;
+    return settled;
 }
 export async function requireBinary(result) {
     const settled = await result;
     if (settled.kind !== 'binary')
         return rejectMismatch('binary', settled);
-    return settled.value;
+    return settled;
 }
 function mismatch(expected, received) {
     throw new ClientError(`Function returned ${received}; ${expected} was required.`);
@@ -26,4 +26,3 @@ async function rejectMismatch(expected, result) {
     }
     mismatch(expected, result.kind);
 }
-//# sourceMappingURL=result.js.map

package/dist/client/routing-control.d.ts

@@ -1,11 +1,10 @@
-import type { publication } from '@astrale-os/kernel-protocol';
+import type { invocation as protocol, publication } from '@astrale-os/kernel-protocol';
 import { MissError, StaleRouteError } from '../errors/index.js';
 /** Create a private routing witness only after exact reserved-control decoding. */
-export declare function admittedMissError(): MissError;
+export declare function admittedMissError(invocation: protocol.InvocationId): MissError;
 /** Create a private routing witness only after exact reserved-control decoding. */
-export declare function admittedStaleRouteError(currentEtag: publication.Etag): StaleRouteError;
+export declare function admittedStaleRouteError(currentEtag: publication.Etag, invocation: protocol.InvocationId): StaleRouteError;
 /** Distinguish decoded routing control from public or caller-supplied lookalike errors. */
 export declare function isAdmittedMissError(input: unknown): input is MissError;
 /** Distinguish decoded routing control from public or caller-supplied lookalike errors. */
 export declare function isAdmittedStaleRouteError(input: unknown): input is StaleRouteError;
-//# sourceMappingURL=routing-control.d.ts.map

package/dist/client/routing-control.js

@@ -2,14 +2,14 @@ import { MissError, StaleRouteError } from '../errors/index.js';
 const admittedMisses = new WeakSet();
 const admittedStaleRoutes = new WeakSet();
 /** Create a private routing witness only after exact reserved-control decoding. */
-export function admittedMissError() {
-    const error = new MissError();
+export function admittedMissError(invocation) {
+    const error = new MissError(invocation);
     admittedMisses.add(error);
     return error;
 }
 /** Create a private routing witness only after exact reserved-control decoding. */
-export function admittedStaleRouteError(currentEtag) {
-    const error = new StaleRouteError(currentEtag);
+export function admittedStaleRouteError(currentEtag, invocation) {
+    const error = new StaleRouteError(currentEtag, invocation);
     admittedStaleRoutes.add(error);
     return error;
 }
@@ -21,4 +21,3 @@ export function isAdmittedMissError(input) {
 export function isAdmittedStaleRouteError(input) {
     return input instanceof StaleRouteError && admittedStaleRoutes.has(input);
 }
-//# sourceMappingURL=routing-control.js.map

package/dist/errors/client-error.d.ts

@@ -1,4 +1,3 @@
 export declare class ClientError extends Error {
     constructor(message: string, options?: ErrorOptions);
 }
-//# sourceMappingURL=client-error.d.ts.map

package/dist/errors/client-error.js

@@ -1,7 +1,8 @@
 export class ClientError extends Error {
     constructor(message, options) {
+        if (message.trim() === '')
+            throw new TypeError('Client error message must be non-blank.');
         super(message, options);
         this.name = 'ClientError';
     }
 }
-//# sourceMappingURL=client-error.js.map

package/dist/errors/index.d.ts

@@ -1,7 +1,7 @@
-export { ClientError } from './client-error.js';
-export { MissError } from './miss-error.js';
-export { ProtocolError } from './protocol-error.js';
-export { ResponseError } from './response-error.js';
-export { StaleRouteError } from './stale-route-error.js';
-export { TransportError, type TransportDelivery, type TransportErrorOptions, type TransportPhase, } from './transport-error.js';
-//# sourceMappingURL=index.d.ts.map
+export * from './client-error.js';
+export * from './miss-error.js';
+export * from './protocol-error.js';
+export * from './response-error.js';
+export * from './session-error.js';
+export * from './stale-route-error.js';
+export * from './transport-error.js';

package/dist/errors/index.js

@@ -1,7 +1,7 @@
-export { ClientError } from './client-error.js';
-export { MissError } from './miss-error.js';
-export { ProtocolError } from './protocol-error.js';
-export { ResponseError } from './response-error.js';
-export { StaleRouteError } from './stale-route-error.js';
-export { TransportError, } from './transport-error.js';
-//# sourceMappingURL=index.js.map
+export * from './client-error.js';
+export * from './miss-error.js';
+export * from './protocol-error.js';
+export * from './response-error.js';
+export * from './session-error.js';
+export * from './stale-route-error.js';
+export * from './transport-error.js';

package/dist/errors/miss-error.d.ts

@@ -1,7 +1,8 @@
+import type { invocation as protocol } from '@astrale-os/kernel-protocol';
 import { ClientError } from './client-error.js';
 /** Client-visible indication that the current Path is no longer served at the learned destination. */
 export declare class MissError extends ClientError {
+    readonly invocation: protocol.InvocationId;
     readonly name = "MissError";
-    constructor();
+    constructor(invocation: protocol.InvocationId);
 }
-//# sourceMappingURL=miss-error.d.ts.map

package/dist/errors/miss-error.js

@@ -1,9 +1,10 @@
 import { ClientError } from './client-error.js';
 /** Client-visible indication that the current Path is no longer served at the learned destination. */
 export class MissError extends ClientError {
+    invocation;
     name = 'MissError';
-    constructor() {
+    constructor(invocation) {
         super('The destination no longer serves this Path.');
+        this.invocation = invocation;
     }
 }
-//# sourceMappingURL=miss-error.js.map

package/dist/errors/protocol-error.d.ts

@@ -1,5 +1,9 @@
+import type { invocation as protocol } from '@astrale-os/kernel-protocol';
 import { ClientError } from './client-error.js';
+export interface ProtocolErrorOptions extends ErrorOptions {
+    readonly invocation?: protocol.InvocationId;
+}
 export declare class ProtocolError extends ClientError {
-    constructor(message: string, options?: ErrorOptions);
+    readonly invocation?: protocol.InvocationId;
+    constructor(message: string, options?: ProtocolErrorOptions);
 }
-//# sourceMappingURL=protocol-error.d.ts.map

package/dist/errors/protocol-error.js

@@ -1,8 +1,9 @@
 import { ClientError } from './client-error.js';
 export class ProtocolError extends ClientError {
+    invocation;
     constructor(message, options) {
         super(message, options);
         this.name = 'ProtocolError';
+        this.invocation = options?.invocation;
     }
 }
-//# sourceMappingURL=protocol-error.js.map

package/dist/errors/response-error.d.ts

@@ -1,10 +1,11 @@
 import type { Value } from '@astrale-os/kernel-dsl/value';
-import { errors } from '@astrale-os/kernel-protocol';
+import type * as protocol from '@astrale-os/kernel-protocol/invocation';
+import * as errors from '@astrale-os/kernel-protocol/errors';
 import { ClientError } from './client-error.js';
 export declare class ResponseError extends ClientError {
     readonly code: errors.ErrorCode;
+    readonly invocation: protocol.InvocationId;
     readonly data?: Value | undefined;
     readonly reason?: errors.ErrorReason;
-    constructor(code: errors.ErrorCode, message: string, data?: Value | undefined);
+    constructor(code: errors.ErrorCode, message: string, invocation: protocol.InvocationId, data?: Value | undefined);
 }
-//# sourceMappingURL=response-error.d.ts.map