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

package/dist/index.d.ts

@@ -6,4 +6,3 @@ export * as publication from './publication/index.js';
 export * as schema from './schema/index.js';
 export * as routes from './routes/index.js';
 export * as issuer from './issuer/index.js';
-//# sourceMappingURL=index.d.ts.map

package/dist/index.js

@@ -6,4 +6,3 @@ export * as publication from './publication/index.js';
 export * as schema from './schema/index.js';
 export * as routes from './routes/index.js';
 export * as issuer from './issuer/index.js';
-//# sourceMappingURL=index.js.map

package/dist/invocation/admission.d.ts

@@ -1,15 +1,17 @@
-import { type IssuerId } from '@astrale-os/kernel-core/auth';
+import { type IssuerId } from '@astrale-os/kernel-core/auth/issuer';
 import { NodePath } from '@astrale-os/kernel-core/path';
-import { Key } from '@astrale-os/kernel-dsl/v1';
+import { Key } from '@astrale-os/kernel-dsl/v1/addressing';
 import { type Object as ValueObject } from '@astrale-os/kernel-dsl/value';
 import type { ErrorPayload } from '../errors/index.js';
 import type { Etag } from '../publication/index.js';
 import { type RequestId } from './correlation.js';
+import { type InvocationId } from './identity.js';
 export declare function portableObject(input: unknown, label: string): ValueObject;
 export declare function exactDataObject(input: unknown, label: string): Record<string, unknown>;
 export declare function exactFields(object: Record<string, unknown>, allowed: ReadonlySet<string>, label: string): void;
 export declare function required(object: Record<string, unknown>, fields: readonly string[], label: string): void;
 export declare function requestId(input: unknown, label: string): RequestId;
+export declare function invocation(input: unknown, label: string): InvocationId;
 export declare function nodePath(input: unknown, label: string): NodePath;
 export declare function issuerId(input: unknown, label: string): IssuerId;
 export declare function string(input: unknown, label: string): string;
@@ -19,4 +21,3 @@ export declare function callableKey(input: unknown, label: string): Key.Callable
 export declare function errorPayload(input: unknown, label: string): ErrorPayload;
 export declare function acceptHeaders(input: unknown): Readonly<Record<string, string>>;
 export declare function invalid(message: string): never;
-//# sourceMappingURL=admission.d.ts.map

package/dist/invocation/admission.js

@@ -1,9 +1,11 @@
-import { AuthValueError, issuer } from '@astrale-os/kernel-core/auth';
+import { AuthValueError } from '@astrale-os/kernel-core/auth/error';
+import { accept as acceptIssuer } from '@astrale-os/kernel-core/auth/issuer';
 import { NodePath, PathError } from '@astrale-os/kernel-core/path';
-import { Key, Ref } from '@astrale-os/kernel-dsl/v1';
+import { callableAddress, Key } from '@astrale-os/kernel-dsl/v1/addressing';
 import { accept as acceptValue, BoundaryError, } from '@astrale-os/kernel-dsl/value';
 import { CODES, acceptPayload, ProtocolError } from '../errors/index.js';
 import { acceptRequestId } from './correlation.js';
+import { acceptInvocationId, InvocationError } from './identity.js';
 export function portableObject(input, label) {
     let cloned;
     try {
@@ -61,6 +63,16 @@ export function requestId(input, label) {
         throw cause;
     }
 }
+export function invocation(input, label) {
+    try {
+        return acceptInvocationId(input);
+    }
+    catch (cause) {
+        if (cause instanceof InvocationError)
+            return invalid(`${label} must be a valid Invocation`);
+        throw cause;
+    }
+}
 export function nodePath(input, label) {
     if (typeof input !== 'string')
         invalid(`${label} must be a NodePath string`);
@@ -77,7 +89,7 @@ export function issuerId(input, label) {
     if (typeof input !== 'string')
         invalid(`${label} must be an issuer identifier`);
     try {
-        return issuer.accept(input);
+        return acceptIssuer(input);
     }
     catch (cause) {
         if (cause instanceof AuthValueError)
@@ -107,10 +119,7 @@ export function callableKey(input, label) {
         invalid(`${label} must be a callable Key string`);
     try {
         const callable = Key(input);
-        const reference = Key.ref(callable);
-        if (!reference.startsWith('function.') && !Ref.isMethod(reference)) {
-            invalid(`${label} must name a Function or Method`);
-        }
+        callableAddress(callable);
         return callable;
     }
     catch (cause) {
@@ -166,4 +175,3 @@ function hasControlCharacter(input) {
     }
     return false;
 }
-//# sourceMappingURL=admission.js.map

package/dist/invocation/binary.d.ts

@@ -1,10 +1,12 @@
 import type { RequestId } from './correlation.js';
+import type { InvocationId } from './identity.js';
 export interface BinaryResponse {
     readonly kind: 'binary';
-    readonly id: RequestId;
+    readonly requestId: RequestId;
+    readonly invocation: InvocationId;
     readonly body: Uint8Array;
     readonly mediaType: string;
+    readonly status: number;
     readonly headers?: Readonly<Record<string, string>>;
 }
 export declare function decodeBinaryResponse(input: unknown): BinaryResponse;
-//# sourceMappingURL=binary.d.ts.map

package/dist/invocation/binary.js

@@ -1,10 +1,18 @@
-import { acceptHeaders, exactDataObject, exactFields, invalid, requestId, required, string, } from './admission.js';
-const FIELDS = new Set(['kind', 'id', 'body', 'mediaType', 'headers']);
+import { acceptHeaders, exactDataObject, exactFields, invalid, invocation, requestId, required, string, } from './admission.js';
+const FIELDS = new Set([
+    'kind',
+    'requestId',
+    'invocation',
+    'body',
+    'mediaType',
+    'status',
+    'headers',
+]);
 const MEDIA_TYPE = /^[!#$%&'*+.^_`|~0-9A-Za-z-]+\/[!#$%&'*+.^_`|~0-9A-Za-z-]+$/u;
 export function decodeBinaryResponse(input) {
     const object = exactDataObject(input, 'binary response');
     exactFields(object, FIELDS, 'binary response');
-    required(object, ['kind', 'id', 'body', 'mediaType'], 'binary response');
+    required(object, ['kind', 'requestId', 'invocation', 'body', 'mediaType'], 'binary response');
     if (object.kind !== 'binary')
         invalid('binary response.kind must be "binary"');
     if (!(object.body instanceof Uint8Array))
@@ -12,13 +20,18 @@ export function decodeBinaryResponse(input) {
     const mediaType = string(object.mediaType, 'binary response.mediaType');
     if (!MEDIA_TYPE.test(mediaType))
         invalid('binary response.mediaType is invalid');
+    const status = object.status ?? 200;
+    if (!Number.isInteger(status) || status < 200 || status > 599) {
+        invalid('binary response.status is invalid');
+    }
     const headers = object.headers === undefined ? undefined : acceptHeaders(object.headers);
     return Object.freeze({
         kind: 'binary',
-        id: requestId(object.id, 'binary response.id'),
+        requestId: requestId(object.requestId, 'binary response.requestId'),
+        invocation: invocation(object.invocation, 'binary response.invocation'),
         body: new Uint8Array(object.body),
         mediaType,
+        status: status,
         ...(headers === undefined ? {} : { headers }),
     });
 }
-//# sourceMappingURL=binary.js.map

package/dist/invocation/binding-codecs.d.ts

@@ -6,4 +6,3 @@ export interface SupportedCodec {
 }
 export declare function codecProfile(codec: Codec): CodecProfile | undefined;
 export declare function admitSupportedCodecs(supported: readonly Codec[]): readonly SupportedCodec[];
-//# sourceMappingURL=binding-codecs.d.ts.map

package/dist/invocation/binding-codecs.js

@@ -25,4 +25,3 @@ export function admitSupportedCodecs(supported) {
         throw new TypeError('supported must contain the canonical JSON codec.');
     return Object.freeze(admitted);
 }
-//# sourceMappingURL=binding-codecs.js.map

package/dist/invocation/cancellation.d.ts

@@ -3,7 +3,6 @@ import type { Version } from './version.js';
 export interface CancelRequest {
     readonly version: Version;
     readonly kind: 'cancel';
-    readonly id: RequestId;
+    readonly requestId: RequestId;
 }
 export declare function decodeCancelRequest(input: unknown): CancelRequest;
-//# sourceMappingURL=cancellation.d.ts.map

package/dist/invocation/cancellation.js

@@ -1,9 +1,9 @@
 import { exactFields, invalid, portableObject, requestId, required } from './admission.js';
-const FIELDS = new Set(['version', 'kind', 'id']);
+const FIELDS = new Set(['version', 'kind', 'requestId']);
 export function decodeCancelRequest(input) {
     const object = portableObject(input, 'cancel request');
     exactFields(object, FIELDS, 'cancel request');
-    required(object, ['version', 'kind', 'id'], 'cancel request');
+    required(object, ['version', 'kind', 'requestId'], 'cancel request');
     if (object.version !== 2)
         invalid('cancel request.version must be 2');
     if (object.kind !== 'cancel')
@@ -11,7 +11,6 @@ export function decodeCancelRequest(input) {
     return Object.freeze({
         version: 2,
         kind: 'cancel',
-        id: requestId(object.id, 'cancel request.id'),
+        requestId: requestId(object.requestId, 'cancel request.requestId'),
     });
 }
-//# sourceMappingURL=cancellation.js.map

package/dist/invocation/correlation.d.ts

@@ -1,3 +1,2 @@
 export type RequestId = string | number | null;
 export declare function acceptRequestId(input: unknown, label: string): RequestId;
-//# sourceMappingURL=correlation.d.ts.map

package/dist/invocation/correlation.js

@@ -5,4 +5,3 @@ export function acceptRequestId(input, label) {
         return input;
     throw new TypeError(`${label} must be a string, finite number, or null`);
 }
-//# sourceMappingURL=correlation.js.map

package/dist/invocation/delegate.d.ts

@@ -22,4 +22,3 @@ export interface Delegate {
     readonly attenuation?: Delegate.Expr;
 }
 export declare function acceptDelegate(input: unknown): Delegate;
-//# sourceMappingURL=delegate.d.ts.map

package/dist/invocation/delegate.js

@@ -41,4 +41,3 @@ function requireTextCredentials(input) {
     for (const operand of input.operands)
         requireTextCredentials(operand);
 }
-//# sourceMappingURL=delegate.js.map

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

@@ -1,6 +1,14 @@
+import { type InvocationId } from '../identity.js';
 export declare const BINARY_HEADERS_FIELD: 'x-astrale-binary-headers';
+export declare const BINARY_DELIVERY_FIELD: 'x-astrale-binary-delivery';
+export declare const STREAMING_BINARY_DELIVERY: 'streaming';
 export declare const REQUEST_ID_FIELD: 'x-astrale-request-id';
+export declare const INVOCATION_FIELD: 'x-astrale-invocation';
+export declare const MAXIMUM_INVOCATION_FIELD_BYTES = 8192;
+/** Encode one admitted InvocationId as percent-encoded source plus opaque ID. */
+export declare function encodeInvocationId(input: InvocationId): string;
+/** Decode one complete binary InvocationId field. */
+export declare function decodeInvocationId(input: string | null): InvocationId;
 export declare function isApplicationBinaryHeader(name: string): boolean;
 export declare function encodeBinaryHeaderNames(headers: Readonly<Record<string, string>> | undefined): string;
 export declare function decodeBinaryHeaderNames(input: string | null): readonly string[];
-//# sourceMappingURL=binary.d.ts.map

package/dist/invocation/http/binary.js

@@ -1,6 +1,11 @@
 import { CODES, ProtocolError } from '../../errors/index.js';
+import { acceptInvocationId } from '../identity.js';
 export const BINARY_HEADERS_FIELD = 'x-astrale-binary-headers';
+export const BINARY_DELIVERY_FIELD = 'x-astrale-binary-delivery';
+export const STREAMING_BINARY_DELIVERY = 'streaming';
 export const REQUEST_ID_FIELD = 'x-astrale-request-id';
+export const INVOCATION_FIELD = 'x-astrale-invocation';
+export const MAXIMUM_INVOCATION_FIELD_BYTES = 8_192;
 const HEADER_NAME = /^[!#$%&'*+.^_`|~0-9A-Za-z-]+$/u;
 const MAXIMUM_MANIFEST_BYTES = 8_192;
 const MAXIMUM_MANIFEST_NAMES = 128;
@@ -30,9 +35,51 @@ const RESERVED = new Set([
     'www-authenticate',
     EMPTY_MANIFEST,
     BINARY_HEADERS_FIELD,
+    BINARY_DELIVERY_FIELD,
+    INVOCATION_FIELD,
     REQUEST_ID_FIELD,
     'x-astrale-stream-framing',
 ]);
+/** Encode one admitted InvocationId as percent-encoded source plus opaque ID. */
+export function encodeInvocationId(input) {
+    let source;
+    try {
+        source = encodeURIComponent(input.source);
+    }
+    catch {
+        return invalid('HTTP binary InvocationId field is invalid.');
+    }
+    const encoded = `${source};${input.id}`;
+    if (new TextEncoder().encode(encoded).byteLength > MAXIMUM_INVOCATION_FIELD_BYTES) {
+        invalid('HTTP binary InvocationId field is invalid.');
+    }
+    return encoded;
+}
+/** Decode one complete binary InvocationId field. */
+export function decodeInvocationId(input) {
+    if (input === null ||
+        input.length === 0 ||
+        new TextEncoder().encode(input).byteLength > MAXIMUM_INVOCATION_FIELD_BYTES) {
+        return invalid('HTTP binary InvocationId field is invalid.');
+    }
+    const separator = input.indexOf(';');
+    if (separator < 1 || input.indexOf(';', separator + 1) !== -1) {
+        invalid('HTTP binary InvocationId field is invalid.');
+    }
+    let source;
+    try {
+        source = decodeURIComponent(input.slice(0, separator));
+    }
+    catch {
+        return invalid('HTTP binary InvocationId field is invalid.');
+    }
+    try {
+        return acceptInvocationId({ source, id: input.slice(separator + 1) });
+    }
+    catch {
+        return invalid('HTTP binary InvocationId field is invalid.');
+    }
+}
 export function isApplicationBinaryHeader(name) {
     const normalized = name.toLowerCase();
     return (HEADER_NAME.test(normalized) &&
@@ -80,10 +127,9 @@ export function decodeBinaryHeaderNames(input) {
     }
     return Object.freeze(admitted);
 }
-function invalid() {
+function invalid(message = 'HTTP binary application-header manifest is invalid.') {
     throw new ProtocolError({
         code: CODES.INVALID_REQUEST,
-        message: 'HTTP binary application-header manifest is invalid.',
+        message,
     });
 }
-//# sourceMappingURL=binary.js.map

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

@@ -1,5 +1,4 @@
-export { BINARY_HEADERS_FIELD, decodeBinaryHeaderNames, encodeBinaryHeaderNames, isApplicationBinaryHeader, REQUEST_ID_FIELD, } from './binary.js';
+export { BINARY_DELIVERY_FIELD, BINARY_HEADERS_FIELD, decodeBinaryHeaderNames, decodeInvocationId, encodeBinaryHeaderNames, encodeInvocationId, isApplicationBinaryHeader, MAXIMUM_INVOCATION_FIELD_BYTES, INVOCATION_FIELD, REQUEST_ID_FIELD, STREAMING_BINARY_DELIVERY, } from './binary.js';
 export { codecForContentType, negotiateResponseCodec } from './negotiation.js';
 export { encodeStreamFrame, LENGTH_PREFIX_V1, STREAM_FRAMING_FIELD } from './stream.js';
 export { BAGGAGE_FIELD, decodeTraceHeaders, encodeTraceHeaders, TRACEPARENT_FIELD, TRACESTATE_FIELD, } from './trace.js';
-//# sourceMappingURL=index.d.ts.map

package/dist/invocation/http/index.js

@@ -1,5 +1,4 @@
-export { BINARY_HEADERS_FIELD, decodeBinaryHeaderNames, encodeBinaryHeaderNames, isApplicationBinaryHeader, REQUEST_ID_FIELD, } from './binary.js';
+export { BINARY_DELIVERY_FIELD, BINARY_HEADERS_FIELD, decodeBinaryHeaderNames, decodeInvocationId, encodeBinaryHeaderNames, encodeInvocationId, isApplicationBinaryHeader, MAXIMUM_INVOCATION_FIELD_BYTES, INVOCATION_FIELD, REQUEST_ID_FIELD, STREAMING_BINARY_DELIVERY, } from './binary.js';
 export { codecForContentType, negotiateResponseCodec } from './negotiation.js';
 export { encodeStreamFrame, LENGTH_PREFIX_V1, STREAM_FRAMING_FIELD } from './stream.js';
 export { BAGGAGE_FIELD, decodeTraceHeaders, encodeTraceHeaders, TRACEPARENT_FIELD, TRACESTATE_FIELD, } from './trace.js';
-//# sourceMappingURL=index.js.map

package/dist/invocation/http/negotiation.d.ts

@@ -1,4 +1,3 @@
 import type { Codec } from '../../codecs/index.js';
 export declare function codecForContentType(contentType: string | null, supported: readonly Codec[]): Codec | undefined;
 export declare function negotiateResponseCodec(accept: string | null, requestCodec: Codec, supported: readonly Codec[]): Codec | undefined;
-//# sourceMappingURL=negotiation.d.ts.map

package/dist/invocation/http/negotiation.js

@@ -205,4 +205,3 @@ function splitOutsideQuotes(input, separator) {
     parts.push(input.slice(start));
     return parts;
 }
-//# sourceMappingURL=negotiation.js.map

package/dist/invocation/http/stream.d.ts

@@ -3,4 +3,3 @@ import type { StreamFrame } from '../stream.js';
 export declare const STREAM_FRAMING_FIELD: 'x-astrale-stream-framing';
 export declare const LENGTH_PREFIX_V1: 'length-prefix-v1';
 export declare function encodeStreamFrame(codec: Codec, frame: StreamFrame): Uint8Array;
-//# sourceMappingURL=stream.d.ts.map

package/dist/invocation/http/stream.js

@@ -13,4 +13,3 @@ export function encodeStreamFrame(codec, frame) {
     output.set(payload, 4);
     return output;
 }
-//# sourceMappingURL=stream.js.map

package/dist/invocation/http/trace.d.ts

@@ -4,4 +4,3 @@ export declare const TRACESTATE_FIELD = "tracestate";
 export declare const BAGGAGE_FIELD = "baggage";
 export declare function decodeTraceHeaders(traceparent: string | null, tracestate: string | null): Trace | undefined;
 export declare function encodeTraceHeaders(carrier: Trace | undefined): Readonly<Record<string, string>>;
-//# sourceMappingURL=trace.d.ts.map

package/dist/invocation/http/trace.js

@@ -22,4 +22,3 @@ export function encodeTraceHeaders(carrier) {
         ...(admitted.tracestate === undefined ? {} : { [TRACESTATE_FIELD]: admitted.tracestate }),
     });
 }
-//# sourceMappingURL=trace.js.map

package/dist/invocation/idempotency.d.ts

@@ -8,4 +8,3 @@ export declare const MAXIMUM_IDEMPOTENCY_KEY_LENGTH = 128;
 /** Admit an opaque URL-safe ASCII key without assigning it semantic structure. */
 export declare function acceptIdempotencyKey(input: unknown, label?: string): IdempotencyKey;
 export {};
-//# sourceMappingURL=idempotency.d.ts.map

package/dist/invocation/idempotency.js

@@ -11,4 +11,3 @@ export function acceptIdempotencyKey(input, label = 'idempotency key') {
     }
     return input;
 }
-//# sourceMappingURL=idempotency.js.map

package/dist/invocation/identity.d.ts

@@ -0,0 +1,16 @@
+import type { IssuerId } from '@astrale-os/kernel-core/auth';
+export declare const MAXIMUM_INVOCATION_ID_LENGTH = 255;
+/** Portable identity of one source-owned Invocation attempt; it grants no authority. */
+export interface InvocationId {
+    readonly source: IssuerId;
+    readonly id: string;
+}
+export declare class InvocationError extends TypeError {
+    readonly input: unknown;
+    readonly code: 'INVOCATION_INVALID';
+    constructor(input: unknown, message?: string, options?: ErrorOptions);
+}
+/** Admit, canonicalize, detach, and freeze one exact source-qualified Invocation identity. */
+export declare function acceptInvocationId(input: unknown): InvocationId;
+/** Compare both canonical coordinate fields exactly. */
+export declare function sameInvocationId(left: InvocationId, right: InvocationId): boolean;

package/dist/invocation/identity.js

@@ -0,0 +1,55 @@
+import { issuer } from '@astrale-os/kernel-core/auth';
+export const MAXIMUM_INVOCATION_ID_LENGTH = 255;
+const INVALID_ID_CHARACTER = /[^A-Za-z0-9._-]/u;
+const ID_ERROR_MESSAGE = 'InvocationId must contain 1-255 ASCII characters drawn from [A-Za-z0-9._-].';
+export class InvocationError extends TypeError {
+    input;
+    code = 'INVOCATION_INVALID';
+    constructor(input, message = 'Invocation is invalid.', options) {
+        super(message, options);
+        this.input = input;
+        this.name = 'InvocationError';
+    }
+}
+/** Admit, canonicalize, detach, and freeze one exact source-qualified Invocation identity. */
+export function acceptInvocationId(input) {
+    if (input === null || typeof input !== 'object' || Array.isArray(input))
+        invalid(input);
+    const candidate = input;
+    const source = Object.getOwnPropertyDescriptor(candidate, 'source');
+    const id = Object.getOwnPropertyDescriptor(candidate, 'id');
+    if (Reflect.ownKeys(candidate).some((key) => key !== 'source' && key !== 'id') ||
+        source === undefined ||
+        id === undefined ||
+        !source.enumerable ||
+        !id.enumerable ||
+        !('value' in source) ||
+        !('value' in id) ||
+        typeof source.value !== 'string' ||
+        typeof id.value !== 'string') {
+        invalid(input);
+    }
+    let admittedSource;
+    try {
+        admittedSource = issuer.accept(source.value);
+    }
+    catch (cause) {
+        throw new InvocationError(input, 'Invocation source is invalid.', { cause });
+    }
+    if (!isLocalInvocationId(id.value))
+        throw new InvocationError(input, ID_ERROR_MESSAGE);
+    return Object.freeze({ source: admittedSource, id: id.value });
+}
+/** Compare both canonical coordinate fields exactly. */
+export function sameInvocationId(left, right) {
+    return left.source === right.source && left.id === right.id;
+}
+function isLocalInvocationId(input) {
+    return (typeof input === 'string' &&
+        input.length > 0 &&
+        input.length <= MAXIMUM_INVOCATION_ID_LENGTH &&
+        !INVALID_ID_CHARACTER.test(input));
+}
+function invalid(input) {
+    throw new InvocationError(input);
+}

package/dist/invocation/index.d.ts

@@ -2,19 +2,19 @@ export { decodeBinaryResponse, type BinaryResponse } from './binary.js';
 export { decodeCancelRequest, type CancelRequest } from './cancellation.js';
 export { type RequestId } from './correlation.js';
 export { acceptIdempotencyKey, HTTP_IDEMPOTENCY_KEY, MAXIMUM_IDEMPOTENCY_KEY_LENGTH, type IdempotencyKey, } from './idempotency.js';
+export { acceptInvocationId, InvocationError, MAXIMUM_INVOCATION_ID_LENGTH, sameInvocationId, type InvocationId, } from './identity.js';
 export * as http from './http/index.js';
 export { acceptDelegate, type Delegate } from './delegate.js';
 export { decodeMiss, miss, type Miss } from './miss.js';
-export { acceptRoute, decodeRedirect, remoteRoute, type RemoteBindingInput, type Redirect, type Route, } from './redirect.js';
+export { acceptRoute, acceptRedirection, decodeRedirectResponse, remoteRoute, type RemoteBindingInput, type Redirection, type RedirectResponse, type Route, } from './redirect.js';
 export { decodeRequest, type Request } from './request.js';
 export { admitTrace, MAXIMUM_TRACEPARENT_BYTES, MAXIMUM_TRACESTATE_BYTES, MAXIMUM_TRACESTATE_MEMBERS, type Trace, } from './trace.js';
 export { acceptRouting, type Refresh, type Routing, type Via } from './routing.js';
 export { acceptSchemaTarget, type SchemaTarget } from './schema.js';
-export { decodeResponse, type ErrorResponse, type Response, type SuccessResponse, } from './response.js';
-export { SCHEMA_UPGRADE_REQUIRED, SERVICE_CANDIDATE_INVALID, SERVICE_TRUST_REQUIRED, SERVICE_UNAVAILABLE, serviceErrorOf, type SchemaUpgradeRequiredDetails, type SchemaUpgradeRequiredReason, type ServiceCandidateInvalidDetails, type ServiceCandidateInvalidReason, type ServiceErrorPayload, type ServiceReason, type ServiceTrustRequiredDetails, type ServiceTrustRequiredReason, type ServiceUnavailableDetails, type ServiceUnavailableReason, } from './service-reason.js';
+export { decodeResponse, type ErrorResponse, type Response, type ResponseContext, type SuccessResponse, } from './response.js';
+export { SCHEMA_REVISION_MISMATCH, SERVICE_CANDIDATE_INVALID, SERVICE_TRUST_REQUIRED, SERVICE_UNAVAILABLE, serviceErrorOf, type SchemaRevisionMismatchDetails, type SchemaRevisionMismatchReason, type ServiceCandidateInvalidDetails, type ServiceCandidateInvalidReason, type ServiceErrorPayload, type ServiceReason, type ServiceTrustRequiredDetails, type ServiceTrustRequiredReason, type ServiceUnavailableDetails, type ServiceUnavailableReason, } from './service-reason.js';
 export { decodeStale, stale, type Stale } from './stale-route.js';
 export { decodeStreamFrame, type StreamEndFrame, type StreamErrorFrame, type StreamFrame, type StreamItemFrame, type StreamStartFrame, } from './stream.js';
 export { acceptCall, type Call } from './target.js';
 export { VERSION, type Version } from './version.js';
 export * as websocket from './websocket/index.js';
-//# sourceMappingURL=index.d.ts.map

package/dist/invocation/index.js

@@ -2,19 +2,19 @@ export { decodeBinaryResponse } from './binary.js';
 export { decodeCancelRequest } from './cancellation.js';
 export {} from './correlation.js';
 export { acceptIdempotencyKey, HTTP_IDEMPOTENCY_KEY, MAXIMUM_IDEMPOTENCY_KEY_LENGTH, } from './idempotency.js';
+export { acceptInvocationId, InvocationError, MAXIMUM_INVOCATION_ID_LENGTH, sameInvocationId, } from './identity.js';
 export * as http from './http/index.js';
 export { acceptDelegate } from './delegate.js';
 export { decodeMiss, miss } from './miss.js';
-export { acceptRoute, decodeRedirect, remoteRoute, } from './redirect.js';
+export { acceptRoute, acceptRedirection, decodeRedirectResponse, remoteRoute, } from './redirect.js';
 export { decodeRequest } from './request.js';
 export { admitTrace, MAXIMUM_TRACEPARENT_BYTES, MAXIMUM_TRACESTATE_BYTES, MAXIMUM_TRACESTATE_MEMBERS, } from './trace.js';
 export { acceptRouting } from './routing.js';
 export { acceptSchemaTarget } from './schema.js';
 export { decodeResponse, } from './response.js';
-export { SCHEMA_UPGRADE_REQUIRED, SERVICE_CANDIDATE_INVALID, SERVICE_TRUST_REQUIRED, SERVICE_UNAVAILABLE, serviceErrorOf, } from './service-reason.js';
+export { SCHEMA_REVISION_MISMATCH, SERVICE_CANDIDATE_INVALID, SERVICE_TRUST_REQUIRED, SERVICE_UNAVAILABLE, serviceErrorOf, } from './service-reason.js';
 export { decodeStale, stale } from './stale-route.js';
 export { decodeStreamFrame, } from './stream.js';
 export { acceptCall } from './target.js';
 export { VERSION } from './version.js';
 export * as websocket from './websocket/index.js';
-//# sourceMappingURL=index.js.map

package/dist/invocation/miss.d.ts

@@ -1,8 +1,9 @@
 import type { RequestId } from './correlation.js';
+import type { InvocationId } from './identity.js';
 export interface Miss {
     readonly kind: 'miss';
-    readonly id: RequestId;
+    readonly requestId: RequestId;
+    readonly invocation: InvocationId;
 }
 export declare function decodeMiss(input: unknown): Miss;
-export declare function miss(id: RequestId): Miss;
-//# sourceMappingURL=miss.d.ts.map
+export declare function miss(requestId: RequestId, assigned: InvocationId): Miss;

package/dist/invocation/miss.js

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

package/dist/invocation/redirect.d.ts

@@ -1,33 +1,40 @@
-import type { IssuerId } from '@astrale-os/kernel-core/auth';
+import type { IssuerId } from '@astrale-os/kernel-core/auth/issuer';
 import type { Key } from '@astrale-os/kernel-dsl/v1';
+import type { InvocationEndpoints } from '../publication/bindings/invocation.js';
+import type { Etag } from '../publication/etag.js';
+import type { PublicationRef } from '../publication/reference.js';
 import type { RequestId } from './correlation.js';
+import type { InvocationId } from './identity.js';
 import type { Trace } from './trace.js';
-import * as publication from '../publication/index.js';
 export interface Route {
-    readonly endpoint: publication.InvocationEndpoints;
+    readonly endpoint: InvocationEndpoints;
     readonly via: {
         readonly kind: 'via';
-        readonly publication: publication.PublicationRef;
+        readonly publication: PublicationRef;
         readonly issuer: IssuerId;
     };
 }
-export interface Redirect {
-    readonly kind: 'redirect';
-    readonly id: RequestId;
+export interface Redirection {
     readonly route: Route;
     readonly credential?: string;
     /** Ephemeral one-hop correlation hint; never cached or treated as authority. */
     readonly trace?: Trace;
 }
+export interface RedirectResponse {
+    readonly kind: 'redirect';
+    readonly requestId: RequestId;
+    readonly invocation: InvocationId;
+    readonly redirect: Redirection;
+}
 export interface RemoteBindingInput {
-    readonly endpoint: publication.InvocationEndpoints;
+    readonly endpoint: InvocationEndpoints;
     readonly issuer: IssuerId;
     readonly subject: string;
-    readonly revision: publication.PublicationRef['revision'];
-    readonly etag: publication.Etag;
+    readonly revision: PublicationRef['revision'];
+    readonly etag: Etag;
 }
 export declare function acceptRoute(input: unknown): Route;
 /** Project one semantic remote binding into its admitted protocol route representation. */
 export declare function remoteRoute(origin: Key.Origin, binding: RemoteBindingInput, issuer: IssuerId): Route;
-export declare function decodeRedirect(input: unknown): Redirect;
-//# sourceMappingURL=redirect.d.ts.map
+export declare function acceptRedirection(input: unknown): Redirection;
+export declare function decodeRedirectResponse(input: unknown): RedirectResponse;