@astrale-os/kernel-protocol 0.5.0-beta.2 → 0.5.0-beta.21

package/dist/invocation/redirect.js

@@ -1,9 +1,12 @@
-import * as publication from '../publication/index.js';
-import { exactFields, invalid, issuerId, portableObject, requestId, required, string, } from './admission.js';
+import { acceptInvocationEndpoints } from '../publication/bindings/invocation.js';
+import { PublicationError } from '../publication/error.js';
+import { acceptReference } from '../publication/reference.js';
+import { exactFields, invalid, issuerId, invocation, portableObject, requestId, required, string, } from './admission.js';
 import { admitTrace } from './trace.js';
 const ROUTE_FIELDS = new Set(['endpoint', 'via']);
 const VIA_FIELDS = new Set(['kind', 'publication', 'issuer']);
-const REDIRECT_FIELDS = new Set(['kind', 'id', 'route', 'credential', 'trace']);
+const REDIRECTION_FIELDS = new Set(['route', 'credential', 'trace']);
+const REDIRECT_RESPONSE_FIELDS = new Set(['kind', 'requestId', 'invocation', 'redirect']);
 export function acceptRoute(input) {
     const object = portableObject(input, 'route');
     exactFields(object, ROUTE_FIELDS, 'route');
@@ -15,16 +18,16 @@ export function acceptRoute(input) {
         if (via.kind !== 'via')
             invalid('route.via.kind must be "via"');
         return Object.freeze({
-            endpoint: publication.acceptInvocationEndpoints(object.endpoint),
+            endpoint: acceptInvocationEndpoints(object.endpoint),
             via: Object.freeze({
                 kind: 'via',
-                publication: publication.acceptReference(via.publication),
+                publication: acceptReference(via.publication),
                 issuer: issuerId(via.issuer, 'route.via.issuer'),
             }),
         });
     }
     catch (cause) {
-        if (cause instanceof publication.PublicationError) {
+        if (cause instanceof PublicationError) {
             return invalid(`route is invalid: ${cause.message}`);
         }
         throw cause;
@@ -46,23 +49,33 @@ export function remoteRoute(origin, binding, issuer) {
         },
     });
 }
-export function decodeRedirect(input) {
-    const object = portableObject(input, 'redirect');
-    exactFields(object, REDIRECT_FIELDS, 'redirect');
-    required(object, ['kind', 'id', 'route'], 'redirect');
-    if (object.kind !== 'redirect')
-        invalid('redirect.kind must be "redirect"');
+export function acceptRedirection(input) {
+    const object = portableObject(input, 'redirection');
+    exactFields(object, REDIRECTION_FIELDS, 'redirection');
+    required(object, ['route'], 'redirection');
     const route = acceptRoute(object.route);
-    const credential = object.credential === undefined ? undefined : string(object.credential, 'redirect.credential');
+    const credential = object.credential === undefined
+        ? undefined
+        : string(object.credential, 'redirection.credential');
     const trace = object.trace === undefined ? undefined : admitTrace(object.trace);
     if (credential !== undefined && credential.length === 0)
-        invalid('redirect.credential must be non-empty');
+        invalid('redirection.credential must be non-empty');
     return Object.freeze({
-        kind: 'redirect',
-        id: requestId(object.id, 'redirect.id'),
         route,
         ...(credential === undefined ? {} : { credential }),
         ...(trace === undefined ? {} : { trace }),
     });
 }
-//# sourceMappingURL=redirect.js.map
+export function decodeRedirectResponse(input) {
+    const object = portableObject(input, 'redirect response');
+    exactFields(object, REDIRECT_RESPONSE_FIELDS, 'redirect response');
+    required(object, ['kind', 'requestId', 'invocation', 'redirect'], 'redirect response');
+    if (object.kind !== 'redirect')
+        invalid('redirect response.kind must be "redirect"');
+    return Object.freeze({
+        kind: 'redirect',
+        requestId: requestId(object.requestId, 'redirect response.requestId'),
+        invocation: invocation(object.invocation, 'redirect response.invocation'),
+        redirect: acceptRedirection(object.redirect),
+    });
+}

package/dist/invocation/request.d.ts

@@ -8,7 +8,7 @@ import type { Trace } from './trace.js';
 import type { Version } from './version.js';
 export interface Request {
     readonly version: Version;
-    readonly id: RequestId;
+    readonly requestId: RequestId;
     readonly call: Call;
     readonly credential?: string;
     readonly delegate?: Delegate;
@@ -19,4 +19,3 @@ export interface Request {
     readonly trace?: Trace;
 }
 export declare function decodeRequest(input: unknown): Request;
-//# sourceMappingURL=request.d.ts.map

package/dist/invocation/request.js

@@ -7,7 +7,7 @@ import { acceptCall } from './target.js';
 import { admitTrace } from './trace.js';
 const REQUEST_FIELDS = new Set([
     'version',
-    'id',
+    'requestId',
     'call',
     'credential',
     'delegate',
@@ -19,7 +19,7 @@ const REQUEST_FIELDS = new Set([
 export function decodeRequest(input) {
     const object = portableObject(input, 'request');
     exactFields(object, REQUEST_FIELDS, 'request');
-    required(object, ['version', 'id', 'call'], 'request');
+    required(object, ['version', 'requestId', 'call'], 'request');
     if (object.version !== 2)
         invalid('request.version must be 2');
     const credential = object.credential === undefined ? undefined : string(object.credential, 'request.credential');
@@ -38,7 +38,7 @@ export function decodeRequest(input) {
     }
     return Object.freeze({
         version: 2,
-        id: requestId(object.id, 'request.id'),
+        requestId: requestId(object.requestId, 'request.requestId'),
         call: acceptCall(object.call),
         ...(credential === undefined ? {} : { credential }),
         ...(delegate === undefined ? {} : { delegate }),
@@ -52,4 +52,3 @@ export function decodeRequest(input) {
         ...(trace === undefined ? {} : { trace }),
     });
 }
-//# sourceMappingURL=request.js.map

package/dist/invocation/response.d.ts

@@ -1,17 +1,19 @@
 import type { Value } from '@astrale-os/kernel-dsl/value';
 import type { ErrorPayload } from '../errors/index.js';
 import type { RequestId } from './correlation.js';
+import type { InvocationId } from './identity.js';
 import type { Miss } from './miss.js';
-import type { Redirect } from './redirect.js';
+import type { RedirectResponse } from './redirect.js';
 import type { Stale } from './stale-route.js';
-export interface SuccessResponse<Result extends Value = Value> {
+export interface ResponseContext {
+    readonly requestId: RequestId;
+    readonly invocation: InvocationId;
+}
+export interface SuccessResponse<Result extends Value = Value> extends ResponseContext {
     readonly result: Result;
-    readonly id: RequestId;
 }
-export interface ErrorResponse {
+export interface ErrorResponse extends ResponseContext {
     readonly error: ErrorPayload;
-    readonly id: RequestId;
 }
-export type Response<Result extends Value = Value> = SuccessResponse<Result> | ErrorResponse | Redirect | Stale | Miss;
+export type Response<Result extends Value = Value> = SuccessResponse<Result> | ErrorResponse | RedirectResponse | Stale | Miss;
 export declare function decodeResponse(input: unknown): Response;
-//# sourceMappingURL=response.d.ts.map

package/dist/invocation/response.js

@@ -1,9 +1,9 @@
-import { errorPayload, exactFields, invalid, portableObject, requestId, required, } from './admission.js';
+import { errorPayload, exactFields, invalid, invocation, portableObject, requestId, required, } from './admission.js';
 import { decodeMiss } from './miss.js';
-import { decodeRedirect } from './redirect.js';
+import { decodeRedirectResponse } from './redirect.js';
 import { decodeStale } from './stale-route.js';
-const SUCCESS_FIELDS = new Set(['result', 'id']);
-const ERROR_FIELDS = new Set(['error', 'id']);
+const SUCCESS_FIELDS = new Set(['result', 'requestId', 'invocation']);
+const ERROR_FIELDS = new Set(['error', 'requestId', 'invocation']);
 export function decodeResponse(input) {
     const object = portableObject(input, 'response');
     const hasResult = Object.hasOwn(object, 'result');
@@ -13,22 +13,26 @@ export function decodeResponse(input) {
             invalid('response must contain exactly one of result or error');
         if (hasResult) {
             exactFields(object, SUCCESS_FIELDS, 'response');
-            required(object, ['id'], 'response');
-            return Object.freeze({ result: object.result, id: requestId(object.id, 'response.id') });
+            required(object, ['requestId', 'invocation'], 'response');
+            return Object.freeze({
+                result: object.result,
+                requestId: requestId(object.requestId, 'response.requestId'),
+                invocation: invocation(object.invocation, 'response.invocation'),
+            });
         }
         exactFields(object, ERROR_FIELDS, 'response');
-        required(object, ['id', 'error'], 'response');
+        required(object, ['requestId', 'error', 'invocation'], 'response');
         return Object.freeze({
             error: errorPayload(object.error, 'response.error'),
-            id: requestId(object.id, 'response.id'),
+            requestId: requestId(object.requestId, 'response.requestId'),
+            invocation: invocation(object.invocation, 'response.invocation'),
         });
     }
     if (object.kind === 'redirect')
-        return decodeRedirect(object);
+        return decodeRedirectResponse(object);
     if (object.kind === 'stale')
         return decodeStale(object);
     if (object.kind === 'miss')
         return decodeMiss(object);
     return invalid('response must contain a result, error, redirect, stale, or miss control');
 }
-//# sourceMappingURL=response.js.map

package/dist/invocation/routing.d.ts

@@ -1,5 +1,6 @@
-import type { IssuerId } from '@astrale-os/kernel-core/auth';
-import type { Etag, PublicationRef } from '../publication/index.js';
+import type { IssuerId } from '@astrale-os/kernel-core/auth/issuer';
+import type { Etag } from '../publication/etag.js';
+import type { PublicationRef } from '../publication/reference.js';
 export interface Via {
     readonly kind: 'via';
     readonly publication: PublicationRef;
@@ -11,4 +12,3 @@ export interface Refresh {
 }
 export type Routing = Via | Refresh;
 export declare function acceptRouting(input: unknown): Routing;
-//# sourceMappingURL=routing.d.ts.map

package/dist/invocation/routing.js

@@ -1,4 +1,5 @@
-import * as publication from '../publication/index.js';
+import { PublicationError } from '../publication/error.js';
+import { acceptReference } from '../publication/reference.js';
 import { digest, exactFields, invalid, issuerId, portableObject, required } from './admission.js';
 const VIA_FIELDS = new Set(['kind', 'publication', 'issuer']);
 const REFRESH_FIELDS = new Set(['kind', 'stale']);
@@ -10,12 +11,12 @@ export function acceptRouting(input) {
         try {
             return Object.freeze({
                 kind: 'via',
-                publication: publication.acceptReference(object.publication),
+                publication: acceptReference(object.publication),
                 issuer: issuerId(object.issuer, 'via routing.issuer'),
             });
         }
         catch (cause) {
-            if (cause instanceof publication.PublicationError) {
+            if (cause instanceof PublicationError) {
                 return invalid(`via routing.publication is invalid: ${cause.message}`);
             }
             throw cause;
@@ -31,4 +32,3 @@ export function acceptRouting(input) {
     }
     return invalid('routing.kind must be "via" or "refresh"');
 }
-//# sourceMappingURL=routing.js.map

package/dist/invocation/schema.d.ts

@@ -1,10 +1,9 @@
-import { type schema } from '@astrale-os/kernel-dsl/v1';
+import type { Revision } from '@astrale-os/kernel-dsl/v1/addressing';
 import type { Sha256Digest } from '../publication/index.js';
 /** Source-Kernel precondition for the active Schema Registration selected by one invocation. */
 export type SchemaTarget = {
     readonly target: Sha256Digest;
 } | {
-    readonly revision: schema.Revision;
+    readonly revision: Revision;
 };
 export declare function acceptSchemaTarget(input: unknown): SchemaTarget;
-//# sourceMappingURL=schema.d.ts.map

package/dist/invocation/schema.js

@@ -1,4 +1,4 @@
-import { schema as dslSchema } from '@astrale-os/kernel-dsl/v1';
+import { patterns } from '@astrale-os/kernel-dsl/v1/addressing';
 import { digest, exactFields, invalid, portableObject } from './admission.js';
 const FIELDS = new Set(['target', 'revision']);
 export function acceptSchemaTarget(input) {
@@ -12,9 +12,8 @@ export function acceptSchemaTarget(input) {
     if (hasTarget) {
         return Object.freeze({ target: digest(object.target, 'schema target.target') });
     }
-    if (typeof object.revision !== 'string' || !dslSchema.patterns.revision.test(object.revision)) {
+    if (typeof object.revision !== 'string' || !patterns.revision.test(object.revision)) {
         invalid('schema target.revision must be a Schema revision');
     }
     return Object.freeze({ revision: object.revision });
 }
-//# sourceMappingURL=schema.js.map

package/dist/invocation/service-reason.d.ts

@@ -1,41 +1,41 @@
+import type { IssuerId } from '@astrale-os/kernel-core/auth/issuer';
+import type { Revision } from '@astrale-os/kernel-dsl/v1/addressing';
 import type { Object as ValueObject } from '@astrale-os/kernel-dsl/value';
-import * as auth from '@astrale-os/kernel-core/auth';
-import { schema as dslSchema, type Key } from '@astrale-os/kernel-dsl/v1';
+import { type Key } from '@astrale-os/kernel-dsl/v1/addressing';
 import type { ErrorPayload, ErrorReason } from '../errors/index.js';
 import { CODES } from '../errors/index.js';
-export declare const SCHEMA_UPGRADE_REQUIRED: 'SCHEMA_UPGRADE_REQUIRED';
+export declare const SCHEMA_REVISION_MISMATCH: 'SCHEMA_REVISION_MISMATCH';
 export declare const SERVICE_TRUST_REQUIRED: 'SERVICE_TRUST_REQUIRED';
 export declare const SERVICE_UNAVAILABLE: 'SERVICE_UNAVAILABLE';
 export declare const SERVICE_CANDIDATE_INVALID: 'SERVICE_CANDIDATE_INVALID';
-export type SchemaUpgradeRequiredDetails = ValueObject & {
+export type SchemaRevisionMismatchDetails = ValueObject & {
     readonly origin: Key.Origin;
-    readonly installedRevision: dslSchema.Revision;
-    readonly candidateRevision: dslSchema.Revision;
+    readonly expectedRevision: Revision;
+    readonly installedRevision: Revision;
 };
 export type ServiceTrustRequiredDetails = ValueObject & {
     readonly origin: Key.Origin;
-    readonly installedIssuer: auth.IssuerId;
-    readonly candidateIssuer: auth.IssuerId;
+    readonly installedIssuer: IssuerId;
+    readonly candidateIssuer: IssuerId;
 };
 export type ServiceUnavailableDetails = ValueObject & {
     readonly origin: Key.Origin;
-    readonly revision: dslSchema.Revision;
+    readonly revision: Revision;
 };
 export type ServiceCandidateInvalidDetails = ValueObject & {
     readonly origin: Key.Origin;
 };
-export type SchemaUpgradeRequiredReason = ErrorReason<typeof SCHEMA_UPGRADE_REQUIRED, SchemaUpgradeRequiredDetails>;
+export type SchemaRevisionMismatchReason = ErrorReason<typeof SCHEMA_REVISION_MISMATCH, SchemaRevisionMismatchDetails>;
 export type ServiceTrustRequiredReason = ErrorReason<typeof SERVICE_TRUST_REQUIRED, ServiceTrustRequiredDetails>;
 export type ServiceUnavailableReason = ErrorReason<typeof SERVICE_UNAVAILABLE, ServiceUnavailableDetails>;
 export type ServiceCandidateInvalidReason = ErrorReason<typeof SERVICE_CANDIDATE_INVALID, ServiceCandidateInvalidDetails>;
-export type ServiceReason = SchemaUpgradeRequiredReason | ServiceTrustRequiredReason | ServiceUnavailableReason | ServiceCandidateInvalidReason;
+export type ServiceReason = SchemaRevisionMismatchReason | ServiceTrustRequiredReason | ServiceUnavailableReason | ServiceCandidateInvalidReason;
 export type ServiceErrorPayload = (Omit<ErrorPayload, 'code' | 'data'> & {
     readonly code: typeof CODES.CONFLICT;
-    readonly data: SchemaUpgradeRequiredReason | ServiceTrustRequiredReason;
+    readonly data: SchemaRevisionMismatchReason | ServiceTrustRequiredReason;
 }) | (Omit<ErrorPayload, 'code' | 'data'> & {
     readonly code: typeof CODES.BACKEND_UNAVAILABLE;
     readonly data: ServiceUnavailableReason | ServiceCandidateInvalidReason;
 });
 /** Recognize only exact outer-code, reason-code, and detail-shape combinations. */
 export declare function serviceErrorOf(input: ErrorPayload): ServiceErrorPayload | undefined;
-//# sourceMappingURL=service-reason.d.ts.map

package/dist/invocation/service-reason.js

@@ -1,7 +1,8 @@
-import * as auth from '@astrale-os/kernel-core/auth';
-import { schema as dslSchema } from '@astrale-os/kernel-dsl/v1';
+import { AuthValueError } from '@astrale-os/kernel-core/auth/error';
+import { accept as acceptIssuer } from '@astrale-os/kernel-core/auth/issuer';
+import { patterns } from '@astrale-os/kernel-dsl/v1/addressing';
 import { CODES, reasonOf } from '../errors/index.js';
-export const SCHEMA_UPGRADE_REQUIRED = 'SCHEMA_UPGRADE_REQUIRED';
+export const SCHEMA_REVISION_MISMATCH = 'SCHEMA_REVISION_MISMATCH';
 export const SERVICE_TRUST_REQUIRED = 'SERVICE_TRUST_REQUIRED';
 export const SERVICE_UNAVAILABLE = 'SERVICE_UNAVAILABLE';
 export const SERVICE_CANDIDATE_INVALID = 'SERVICE_CANDIDATE_INVALID';
@@ -11,8 +12,8 @@ export function serviceErrorOf(input) {
     if (reason === undefined)
         return undefined;
     switch (reason.code) {
-        case SCHEMA_UPGRADE_REQUIRED:
-            return input.code === CODES.CONFLICT && schemaUpgradeDetails(reason.details)
+        case SCHEMA_REVISION_MISMATCH:
+            return input.code === CODES.CONFLICT && schemaRevisionMismatchDetails(reason.details)
                 ? input
                 : undefined;
         case SERVICE_TRUST_REQUIRED:
@@ -31,11 +32,11 @@ export function serviceErrorOf(input) {
             return undefined;
     }
 }
-function schemaUpgradeDetails(input) {
-    return (exact(input, ['origin', 'installedRevision', 'candidateRevision']) &&
+function schemaRevisionMismatchDetails(input) {
+    return (exact(input, ['origin', 'expectedRevision', 'installedRevision']) &&
         isOrigin(input.origin) &&
-        isRevision(input.installedRevision) &&
-        isRevision(input.candidateRevision));
+        isRevision(input.expectedRevision) &&
+        isRevision(input.installedRevision));
 }
 function serviceTrustDetails(input) {
     return (exact(input, ['origin', 'installedIssuer', 'candidateIssuer']) &&
@@ -54,21 +55,20 @@ function exact(input, fields) {
         fields.every((field) => Object.hasOwn(input, field)));
 }
 function isOrigin(input) {
-    return typeof input === 'string' && dslSchema.patterns.origin.test(input);
+    return typeof input === 'string' && patterns.origin.test(input);
 }
 function isRevision(input) {
-    return typeof input === 'string' && dslSchema.patterns.revision.test(input);
+    return typeof input === 'string' && patterns.revision.test(input);
 }
 function isIssuer(input) {
     if (typeof input !== 'string')
         return false;
     try {
-        return auth.issuer.accept(input) === input;
+        return acceptIssuer(input) === input;
     }
     catch (cause) {
-        if (cause instanceof auth.AuthValueError)
+        if (cause instanceof AuthValueError)
             return false;
         throw cause;
     }
 }
-//# sourceMappingURL=service-reason.js.map

package/dist/invocation/stale-route.d.ts

@@ -1,11 +1,12 @@
 import type { Etag } from '../publication/index.js';
 import type { RequestId } from './correlation.js';
+import type { InvocationId } from './identity.js';
 /** Reserved pre-handler routing control; never an application ErrorResponse. */
 export interface Stale {
     readonly kind: 'stale';
-    readonly id: RequestId;
+    readonly requestId: RequestId;
+    readonly invocation: InvocationId;
     readonly current: Etag;
 }
 export declare function decodeStale(input: unknown): Stale;
-export declare function stale(id: RequestId, current: Etag): Stale;
-//# sourceMappingURL=stale-route.d.ts.map
+export declare function stale(requestId: RequestId, assigned: InvocationId, current: Etag): Stale;

package/dist/invocation/stale-route.js

@@ -1,19 +1,19 @@
-import { digest, exactFields, invalid, portableObject, requestId, required } from './admission.js';
-const FIELDS = new Set(['kind', 'id', 'current']);
+import { digest, exactFields, invalid, invocation, portableObject, requestId, required, } from './admission.js';
+const FIELDS = new Set(['kind', 'requestId', 'invocation', 'current']);
 export function decodeStale(input) {
     const object = portableObject(input, 'stale control');
     exactFields(object, FIELDS, 'stale control');
-    required(object, ['kind', 'id', 'current'], 'stale control');
+    required(object, ['kind', 'requestId', 'invocation', 'current'], 'stale control');
     if (object.kind !== 'stale') {
         invalid('stale control.kind must be "stale"');
     }
     return Object.freeze({
         kind: 'stale',
-        id: requestId(object.id, 'stale control.id'),
+        requestId: requestId(object.requestId, 'stale control.requestId'),
+        invocation: invocation(object.invocation, 'stale control.invocation'),
         current: digest(object.current, 'stale control.current'),
     });
 }
-export function stale(id, current) {
-    return Object.freeze({ kind: 'stale', id, current });
+export function stale(requestId, assigned, current) {
+    return decodeStale({ kind: 'stale', requestId, invocation: assigned, current });
 }
-//# sourceMappingURL=stale-route.js.map

package/dist/invocation/stream.d.ts

@@ -1,26 +1,27 @@
 import type { Value } from '@astrale-os/kernel-dsl/value';
 import type { ErrorPayload } from '../errors/index.js';
 import type { RequestId } from './correlation.js';
+import type { InvocationId } from './identity.js';
 export interface StreamStartFrame {
     readonly kind: 'stream.start';
-    readonly id: RequestId;
+    readonly requestId: RequestId;
+    readonly invocation: InvocationId;
 }
 export interface StreamItemFrame {
     readonly kind: 'stream.item';
-    readonly id: RequestId;
+    readonly requestId: RequestId;
     readonly index: number;
     readonly value: Value;
 }
 export interface StreamEndFrame {
     readonly kind: 'stream.end';
-    readonly id: RequestId;
+    readonly requestId: RequestId;
     readonly count: number;
 }
 export interface StreamErrorFrame {
     readonly kind: 'stream.error';
-    readonly id: RequestId;
+    readonly requestId: RequestId;
     readonly error: ErrorPayload;
 }
 export type StreamFrame = StreamStartFrame | StreamItemFrame | StreamEndFrame | StreamErrorFrame;
 export declare function decodeStreamFrame(input: unknown): StreamFrame;
-//# sourceMappingURL=stream.d.ts.map

package/dist/invocation/stream.js

@@ -1,4 +1,4 @@
-import { count, errorPayload, exactFields, invalid, portableObject, requestId, required, } from './admission.js';
+import { count, errorPayload, exactFields, invalid, invocation, portableObject, requestId, required, } from './admission.js';
 export function decodeStreamFrame(input) {
     const object = portableObject(input, 'stream frame');
     const kind = object.kind;
@@ -6,36 +6,39 @@ export function decodeStreamFrame(input) {
         invalid('stream frame.kind must be a string');
     switch (kind) {
         case 'stream.start':
-            exactFields(object, new Set(['kind', 'id']), 'stream.start');
-            required(object, ['id'], 'stream.start');
-            return Object.freeze({ kind, id: requestId(object.id, 'stream.start.id') });
+            exactFields(object, new Set(['kind', 'requestId', 'invocation']), 'stream.start');
+            required(object, ['requestId', 'invocation'], 'stream.start');
+            return Object.freeze({
+                kind,
+                requestId: requestId(object.requestId, 'stream.start.requestId'),
+                invocation: invocation(object.invocation, 'stream.start.invocation'),
+            });
         case 'stream.item':
-            exactFields(object, new Set(['kind', 'id', 'index', 'value']), 'stream.item');
-            required(object, ['id', 'index', 'value'], 'stream.item');
+            exactFields(object, new Set(['kind', 'requestId', 'index', 'value']), 'stream.item');
+            required(object, ['requestId', 'index', 'value'], 'stream.item');
             return Object.freeze({
                 kind,
-                id: requestId(object.id, 'stream.item.id'),
+                requestId: requestId(object.requestId, 'stream.item.requestId'),
                 index: count(object.index, 'stream.item.index'),
                 value: object.value,
             });
         case 'stream.end':
-            exactFields(object, new Set(['kind', 'id', 'count']), 'stream.end');
-            required(object, ['id', 'count'], 'stream.end');
+            exactFields(object, new Set(['kind', 'requestId', 'count']), 'stream.end');
+            required(object, ['requestId', 'count'], 'stream.end');
             return Object.freeze({
                 kind,
-                id: requestId(object.id, 'stream.end.id'),
+                requestId: requestId(object.requestId, 'stream.end.requestId'),
                 count: count(object.count, 'stream.end.count'),
             });
         case 'stream.error':
-            exactFields(object, new Set(['kind', 'id', 'error']), 'stream.error');
-            required(object, ['id', 'error'], 'stream.error');
+            exactFields(object, new Set(['kind', 'requestId', 'error']), 'stream.error');
+            required(object, ['requestId', 'error'], 'stream.error');
             return Object.freeze({
                 kind,
-                id: requestId(object.id, 'stream.error.id'),
+                requestId: requestId(object.requestId, 'stream.error.requestId'),
                 error: errorPayload(object.error, 'stream.error.error'),
             });
         default:
             return invalid(`unsupported stream frame kind ${JSON.stringify(kind)}`);
     }
 }
-//# sourceMappingURL=stream.js.map

package/dist/invocation/target.d.ts

@@ -1,9 +1,3 @@
-import type { NodePath } from '@astrale-os/kernel-core/path';
-import type { Value } from '@astrale-os/kernel-dsl/value';
-/** One portable invocation meaning. Resolution remains Runtime-owned. */
-export interface Call {
-    readonly target: NodePath;
-    readonly input: Value;
-}
+import type { Call } from '@astrale-os/kernel-core/callable';
+export type { Call } from '@astrale-os/kernel-core/callable';
 export declare function acceptCall(input: unknown): Call;
-//# sourceMappingURL=target.d.ts.map

package/dist/invocation/target.js

@@ -9,4 +9,3 @@ export function acceptCall(input) {
         input: object.input,
     });
 }
-//# sourceMappingURL=target.js.map

package/dist/invocation/trace.d.ts

@@ -7,4 +7,3 @@ export interface Trace {
 }
 /** Admit portable correlation syntax without making it an invocation validity condition. */
 export declare function admitTrace(input: unknown): Trace | undefined;
-//# sourceMappingURL=trace.d.ts.map

package/dist/invocation/trace.js

@@ -84,4 +84,3 @@ function validStateKey(input) {
         return false;
     return TENANT_ID.test(input.slice(0, separator)) && SYSTEM_ID.test(input.slice(separator + 1));
 }
-//# sourceMappingURL=trace.js.map

package/dist/invocation/version.d.ts

@@ -1,3 +1,2 @@
 export declare const VERSION: 2;
 export type Version = typeof VERSION;
-//# sourceMappingURL=version.d.ts.map

package/dist/invocation/version.js

@@ -1,2 +1 @@
 export const VERSION = 2;
-//# sourceMappingURL=version.js.map

package/dist/invocation/websocket/binary.d.ts

@@ -1,4 +1,3 @@
 import type { BinaryResponse } from '../binary.js';
 export declare function encodeBinary(response: BinaryResponse): Uint8Array;
 export declare function decodeBinary(input: Uint8Array): BinaryResponse | undefined;
-//# sourceMappingURL=binary.d.ts.map

package/dist/invocation/websocket/binary.js

@@ -4,15 +4,17 @@ const MAGIC = new Uint8Array([0x41, 0x53, 0x54, 0x42, 0x01]);
 const LENGTH_BYTES = 4;
 const MAXIMUM_METADATA_BYTES = 65_536;
 const encoder = new TextEncoder();
-const decoder = new TextDecoder('utf-8', { fatal: true });
+const decoder = new TextDecoder('utf-8', { fatal: true, ignoreBOM: false });
 export function encodeBinary(response) {
     const headers = response.headers === undefined
         ? undefined
         : Object.fromEntries(Object.entries(response.headers).sort(([left], [right]) => left < right ? -1 : left > right ? 1 : 0));
     const metadata = encoder.encode(JSON.stringify({
         kind: response.kind,
-        id: response.id,
+        requestId: response.requestId,
+        invocation: response.invocation,
         mediaType: response.mediaType,
+        status: response.status,
         ...(headers === undefined ? {} : { headers }),
     }));
     if (metadata.byteLength > MAXIMUM_METADATA_BYTES)
@@ -68,4 +70,3 @@ function invalid() {
         message: 'WebSocket binary response is invalid.',
     });
 }
-//# sourceMappingURL=binary.js.map

package/dist/invocation/websocket/index.d.ts

@@ -1,3 +1,2 @@
 export { decodeBinary, encodeBinary } from './binary.js';
 export { JSON_SUBPROTOCOL, MSGPACK_SUBPROTOCOL, selectSubprotocol, subprotocolFor, type Subprotocol, type SubprotocolSelection, } from './subprotocol.js';
-//# sourceMappingURL=index.d.ts.map

package/dist/invocation/websocket/index.js

@@ -1,3 +1,2 @@
 export { decodeBinary, encodeBinary } from './binary.js';
 export { JSON_SUBPROTOCOL, MSGPACK_SUBPROTOCOL, selectSubprotocol, subprotocolFor, } from './subprotocol.js';
-//# sourceMappingURL=index.js.map

package/dist/invocation/websocket/subprotocol.d.ts

@@ -8,4 +8,3 @@ export interface SubprotocolSelection {
 }
 export declare function subprotocolFor(codec: Codec): Subprotocol;
 export declare function selectSubprotocol(offered: string | null, supported: readonly Codec[]): SubprotocolSelection | undefined;
-//# sourceMappingURL=subprotocol.d.ts.map

package/dist/invocation/websocket/subprotocol.js

@@ -27,4 +27,3 @@ export function selectSubprotocol(offered, supported) {
     }
     return undefined;
 }
-//# sourceMappingURL=subprotocol.js.map