@astrale-os/kernel-protocol 0.5.0-beta.10

package/dist/invocation/http/negotiation.js

@@ -0,0 +1,207 @@
+import { CONTENT_TYPE_JSON, CONTENT_TYPE_MSGPACK } from '../../codecs/index.js';
+import { admitSupportedCodecs } from '../binding-codecs.js';
+const TOKEN = /^[!#$%&'*+.^_`|~0-9A-Za-z-]+$/u;
+const QVALUE = /^(?:0(?:\.\d{0,3})?|1(?:\.0{0,3})?)$/u;
+export function codecForContentType(contentType, supported) {
+    const admitted = admitSupportedCodecs(supported);
+    if (contentType === null || contentType.trim() === '')
+        return undefined;
+    const mediaType = parseContentType(contentType);
+    if (mediaType === undefined)
+        return undefined;
+    const profile = mediaType === CONTENT_TYPE_JSON
+        ? 'json'
+        : mediaType === CONTENT_TYPE_MSGPACK
+            ? 'msgpack'
+            : undefined;
+    return admitted.find((entry) => entry.profile === profile)?.codec;
+}
+export function negotiateResponseCodec(accept, requestCodec, supported) {
+    const admitted = admitSupportedCodecs(supported);
+    const request = admitted.find((entry) => entry.codec === requestCodec);
+    if (request === undefined)
+        throw new TypeError('requestCodec must occur exactly once in supported.');
+    if (accept === null || accept.trim() === '')
+        return request.codec;
+    const ranges = parseAccept(accept);
+    if (ranges.length === 0)
+        return undefined;
+    const candidates = admitted.flatMap((entry) => {
+        const [type, subtype] = contentTypeOf(entry.profile).split('/');
+        const governing = ranges
+            .filter((range) => range.mediaParameters === 0 &&
+            (range.type === '*' || range.type === type) &&
+            (range.subtype === '*' || range.subtype === subtype))
+            .sort((left, right) => right.specificity - left.specificity || left.index - right.index)[0];
+        return governing === undefined || governing.quality === 0 ? [] : [{ ...entry, governing }];
+    });
+    if (candidates.length === 0)
+        return undefined;
+    candidates.sort((left, right) => {
+        const quality = right.governing.quality - left.governing.quality;
+        if (quality !== 0)
+            return quality;
+        if (left.codec === request.codec)
+            return -1;
+        if (right.codec === request.codec)
+            return 1;
+        const order = left.governing.index - right.governing.index;
+        if (order !== 0)
+            return order;
+        if (left.profile === 'json')
+            return -1;
+        if (right.profile === 'json')
+            return 1;
+        return 0;
+    });
+    return candidates[0]?.codec;
+}
+function contentTypeOf(profile) {
+    return profile === 'json' ? CONTENT_TYPE_JSON : CONTENT_TYPE_MSGPACK;
+}
+function parseContentType(input) {
+    if (splitOutsideQuotes(input, ',')?.length !== 1)
+        return undefined;
+    const parts = splitOutsideQuotes(input, ';');
+    if (parts === undefined)
+        return undefined;
+    const mediaType = parts.shift()?.trim().toLowerCase();
+    if (mediaType === undefined || parseType(mediaType, false) === undefined)
+        return undefined;
+    const names = new Set();
+    for (const part of parts) {
+        const parameter = parseParameter(part);
+        if (parameter === undefined || names.has(parameter.name))
+            return undefined;
+        names.add(parameter.name);
+    }
+    return mediaType;
+}
+function parseAccept(input) {
+    const members = splitOutsideQuotes(input, ',');
+    if (members === undefined)
+        return [];
+    const ranges = [];
+    for (const [index, member] of members.entries()) {
+        const parts = splitOutsideQuotes(member, ';');
+        if (parts === undefined)
+            continue;
+        const media = parseType(parts.shift()?.trim().toLowerCase() ?? '', true);
+        if (media === undefined)
+            continue;
+        let quality = 1;
+        let qualitySeen = false;
+        let mediaParameters = 0;
+        let invalid = false;
+        const names = new Set();
+        for (const part of parts) {
+            const parameter = parseParameter(part);
+            if (parameter === undefined || names.has(parameter.name)) {
+                invalid = true;
+                break;
+            }
+            names.add(parameter.name);
+            if (parameter.name === 'q') {
+                if (qualitySeen || !QVALUE.test(parameter.value)) {
+                    invalid = true;
+                    break;
+                }
+                qualitySeen = true;
+                quality = Number(parameter.value);
+            }
+            else if (!qualitySeen) {
+                mediaParameters += 1;
+            }
+        }
+        if (invalid)
+            continue;
+        ranges.push({
+            ...media,
+            quality,
+            specificity: media.type === '*' ? 0 : media.subtype === '*' ? 1 : 2,
+            index,
+            mediaParameters,
+        });
+    }
+    return ranges;
+}
+function parseType(input, wildcards) {
+    const separator = input.indexOf('/');
+    if (separator <= 0 || separator !== input.lastIndexOf('/'))
+        return undefined;
+    const type = input.slice(0, separator);
+    const subtype = input.slice(separator + 1);
+    if (subtype === '')
+        return undefined;
+    const typeValid = TOKEN.test(type) || (wildcards && type === '*');
+    const subtypeValid = TOKEN.test(subtype) || (wildcards && subtype === '*');
+    if (!typeValid || !subtypeValid || (type === '*' && subtype !== '*'))
+        return undefined;
+    return { type, subtype };
+}
+function parseParameter(input) {
+    const separator = input.indexOf('=');
+    if (separator <= 0)
+        return undefined;
+    const name = input.slice(0, separator).trim().toLowerCase();
+    const value = input.slice(separator + 1).trim();
+    if (!TOKEN.test(name) || (!TOKEN.test(value) && !quotedString(value)))
+        return undefined;
+    return { name, value: unquote(value) };
+}
+function quotedString(input) {
+    if (input.length < 2 || input[0] !== '"' || input.at(-1) !== '"')
+        return false;
+    for (let index = 1; index < input.length - 1; index += 1) {
+        const code = input.charCodeAt(index);
+        if (input[index] === '\\') {
+            index += 1;
+            if (index >= input.length - 1)
+                return false;
+            continue;
+        }
+        if (input[index] === '"' || code === 0x7f || (code < 0x20 && code !== 0x09))
+            return false;
+    }
+    return true;
+}
+function unquote(input) {
+    if (input[0] !== '"')
+        return input;
+    let output = '';
+    for (let index = 1; index < input.length - 1; index += 1) {
+        if (input[index] === '\\')
+            index += 1;
+        output += input[index];
+    }
+    return output;
+}
+function splitOutsideQuotes(input, separator) {
+    const parts = [];
+    let quoted = false;
+    let escaped = false;
+    let start = 0;
+    for (let index = 0; index < input.length; index += 1) {
+        const character = input[index];
+        if (escaped) {
+            escaped = false;
+            continue;
+        }
+        if (quoted && character === '\\') {
+            escaped = true;
+            continue;
+        }
+        if (character === '"') {
+            quoted = !quoted;
+            continue;
+        }
+        if (!quoted && character === separator) {
+            parts.push(input.slice(start, index));
+            start = index + 1;
+        }
+    }
+    if (quoted || escaped)
+        return undefined;
+    parts.push(input.slice(start));
+    return parts;
+}

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

@@ -0,0 +1,5 @@
+import type { Codec } from '../../codecs/index.js';
+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;

package/dist/invocation/http/stream.js

@@ -0,0 +1,15 @@
+export const STREAM_FRAMING_FIELD = 'x-astrale-stream-framing';
+export const LENGTH_PREFIX_V1 = 'length-prefix-v1';
+const encoder = new TextEncoder();
+const MAXIMUM_UINT32 = 0xffff_ffff;
+export function encodeStreamFrame(codec, frame) {
+    const encoded = codec.encode(frame);
+    const payload = typeof encoded === 'string' ? encoder.encode(encoded) : encoded;
+    if (payload.byteLength > MAXIMUM_UINT32) {
+        throw new RangeError('stream frame exceeds the uint32 length-prefix-v1 payload bound.');
+    }
+    const output = new Uint8Array(4 + payload.byteLength);
+    new DataView(output.buffer).setUint32(0, payload.byteLength);
+    output.set(payload, 4);
+    return output;
+}

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

@@ -0,0 +1,6 @@
+import type { Trace } from '../trace.js';
+export declare const TRACEPARENT_FIELD = "traceparent";
+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>>;

package/dist/invocation/http/trace.js

@@ -0,0 +1,24 @@
+import { admitTrace } from '../trace.js';
+export const TRACEPARENT_FIELD = 'traceparent';
+export const TRACESTATE_FIELD = 'tracestate';
+export const BAGGAGE_FIELD = 'baggage';
+const EMPTY_HEADERS = Object.freeze({});
+export function decodeTraceHeaders(traceparent, tracestate) {
+    if (traceparent === null)
+        return undefined;
+    return admitTrace({
+        traceparent,
+        ...(tracestate === null ? {} : { tracestate }),
+    });
+}
+export function encodeTraceHeaders(carrier) {
+    if (carrier === undefined)
+        return EMPTY_HEADERS;
+    const admitted = admitTrace(carrier);
+    if (admitted === undefined)
+        return EMPTY_HEADERS;
+    return Object.freeze({
+        [TRACEPARENT_FIELD]: admitted.traceparent,
+        ...(admitted.tracestate === undefined ? {} : { [TRACESTATE_FIELD]: admitted.tracestate }),
+    });
+}

package/dist/invocation/idempotency.d.ts

@@ -0,0 +1,10 @@
+declare const IDEMPOTENCY_KEY: unique symbol;
+/** Caller-selected identity for one logical root invocation attempt group. */
+export type IdempotencyKey = string & {
+    readonly [IDEMPOTENCY_KEY]: true;
+};
+export declare const HTTP_IDEMPOTENCY_KEY: 'x-astrale-idempotency-key';
+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 {};

package/dist/invocation/idempotency.js

@@ -0,0 +1,13 @@
+import { invalid } from './admission.js';
+export const HTTP_IDEMPOTENCY_KEY = 'x-astrale-idempotency-key';
+export const MAXIMUM_IDEMPOTENCY_KEY_LENGTH = 128;
+/** Admit an opaque URL-safe ASCII key without assigning it semantic structure. */
+export function acceptIdempotencyKey(input, label = 'idempotency key') {
+    if (typeof input !== 'string' ||
+        input.length < 1 ||
+        input.length > MAXIMUM_IDEMPOTENCY_KEY_LENGTH ||
+        !/^[A-Za-z0-9._~-]+$/u.test(input)) {
+        invalid(`${label} must contain 1-128 URL-safe ASCII characters`);
+    }
+    return input;
+}

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

@@ -0,0 +1,20 @@
+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, 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 ResponseContext, type SuccessResponse, } from './response.js';
+export { SCHEMA_UPGRADE_REQUIRED, SCHEMA_REVISION_MISMATCH, SERVICE_CANDIDATE_INVALID, SERVICE_TRUST_REQUIRED, SERVICE_UNAVAILABLE, serviceErrorOf, type SchemaUpgradeRequiredDetails, type SchemaUpgradeRequiredReason, 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';

package/dist/invocation/index.js

@@ -0,0 +1,20 @@
+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, 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, 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';

package/dist/invocation/miss.d.ts

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

package/dist/invocation/miss.js

@@ -0,0 +1,17 @@
+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', 'requestId', 'invocation'], 'miss control');
+    if (object.kind !== 'miss')
+        invalid('miss control.kind must be "miss"');
+    return Object.freeze({
+        kind: 'miss',
+        requestId: requestId(object.requestId, 'miss control.requestId'),
+        invocation: invocation(object.invocation, 'miss control.invocation'),
+    });
+}
+export function miss(requestId, assigned) {
+    return decodeMiss({ kind: 'miss', requestId, invocation: assigned });
+}

package/dist/invocation/redirect.d.ts

@@ -0,0 +1,40 @@
+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';
+export interface Route {
+    readonly endpoint: InvocationEndpoints;
+    readonly via: {
+        readonly kind: 'via';
+        readonly publication: PublicationRef;
+        readonly issuer: IssuerId;
+    };
+}
+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: InvocationEndpoints;
+    readonly issuer: IssuerId;
+    readonly subject: string;
+    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 acceptRedirection(input: unknown): Redirection;
+export declare function decodeRedirectResponse(input: unknown): RedirectResponse;

package/dist/invocation/redirect.js

@@ -0,0 +1,81 @@
+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 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');
+    required(object, ['endpoint', 'via'], 'route');
+    try {
+        const via = portableObject(object.via, 'route.via');
+        exactFields(via, VIA_FIELDS, 'route.via');
+        required(via, ['kind', 'publication', 'issuer'], 'route.via');
+        if (via.kind !== 'via')
+            invalid('route.via.kind must be "via"');
+        return Object.freeze({
+            endpoint: acceptInvocationEndpoints(object.endpoint),
+            via: Object.freeze({
+                kind: 'via',
+                publication: acceptReference(via.publication),
+                issuer: issuerId(via.issuer, 'route.via.issuer'),
+            }),
+        });
+    }
+    catch (cause) {
+        if (cause instanceof PublicationError) {
+            return invalid(`route is invalid: ${cause.message}`);
+        }
+        throw cause;
+    }
+}
+/** Project one semantic remote binding into its admitted protocol route representation. */
+export function remoteRoute(origin, binding, issuer) {
+    return acceptRoute({
+        endpoint: binding.endpoint,
+        via: {
+            kind: 'via',
+            publication: {
+                origin,
+                identity: { issuer: binding.issuer, subject: binding.subject },
+                revision: binding.revision,
+                etag: binding.etag,
+            },
+            issuer,
+        },
+    });
+}
+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, 'redirection.credential');
+    const trace = object.trace === undefined ? undefined : admitTrace(object.trace);
+    if (credential !== undefined && credential.length === 0)
+        invalid('redirection.credential must be non-empty');
+    return Object.freeze({
+        route,
+        ...(credential === undefined ? {} : { credential }),
+        ...(trace === undefined ? {} : { trace }),
+    });
+}
+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

@@ -0,0 +1,21 @@
+import type { RequestId } from './correlation.js';
+import type { Delegate } from './delegate.js';
+import type { IdempotencyKey } from './idempotency.js';
+import type { Routing } from './routing.js';
+import type { SchemaTarget } from './schema.js';
+import type { Call } from './target.js';
+import type { Trace } from './trace.js';
+import type { Version } from './version.js';
+export interface Request {
+    readonly version: Version;
+    readonly requestId: RequestId;
+    readonly call: Call;
+    readonly credential?: string;
+    readonly delegate?: Delegate;
+    readonly routing?: Routing;
+    /** Source-Kernel precondition; forbidden on an already-routed destination request. */
+    readonly schema?: SchemaTarget;
+    readonly idempotencyKey?: IdempotencyKey;
+    readonly trace?: Trace;
+}
+export declare function decodeRequest(input: unknown): Request;

package/dist/invocation/request.js

@@ -0,0 +1,54 @@
+import { exactFields, invalid, portableObject, requestId, required, string } from './admission.js';
+import { acceptDelegate } from './delegate.js';
+import { acceptIdempotencyKey } from './idempotency.js';
+import { acceptRouting } from './routing.js';
+import { acceptSchemaTarget } from './schema.js';
+import { acceptCall } from './target.js';
+import { admitTrace } from './trace.js';
+const REQUEST_FIELDS = new Set([
+    'version',
+    'requestId',
+    'call',
+    'credential',
+    'delegate',
+    'routing',
+    'schema',
+    'idempotencyKey',
+    'trace',
+]);
+export function decodeRequest(input) {
+    const object = portableObject(input, 'request');
+    exactFields(object, REQUEST_FIELDS, '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');
+    const delegate = object.delegate === undefined ? undefined : acceptDelegate(object.delegate);
+    const routing = object.routing === undefined ? undefined : acceptRouting(object.routing);
+    const schema = object.schema === undefined ? undefined : acceptSchemaTarget(object.schema);
+    const trace = object.trace === undefined ? undefined : admitTrace(object.trace);
+    if (routing?.kind === 'via') {
+        if (delegate !== undefined)
+            invalid('destination requests with via routing forbid delegate');
+        if (schema !== undefined)
+            invalid('destination requests with via routing forbid schema target');
+    }
+    else if ((credential === undefined) !== (delegate === undefined)) {
+        invalid('source requests require credential and delegate together');
+    }
+    return Object.freeze({
+        version: 2,
+        requestId: requestId(object.requestId, 'request.requestId'),
+        call: acceptCall(object.call),
+        ...(credential === undefined ? {} : { credential }),
+        ...(delegate === undefined ? {} : { delegate }),
+        ...(routing === undefined ? {} : { routing }),
+        ...(schema === undefined ? {} : { schema }),
+        ...(object.idempotencyKey === undefined
+            ? {}
+            : {
+                idempotencyKey: acceptIdempotencyKey(object.idempotencyKey, 'request.idempotencyKey'),
+            }),
+        ...(trace === undefined ? {} : { trace }),
+    });
+}

package/dist/invocation/response.d.ts

@@ -0,0 +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 { RedirectResponse } from './redirect.js';
+import type { Stale } from './stale-route.js';
+export interface ResponseContext {
+    readonly requestId: RequestId;
+    readonly invocation: InvocationId;
+}
+export interface SuccessResponse<Result extends Value = Value> extends ResponseContext {
+    readonly result: Result;
+}
+export interface ErrorResponse extends ResponseContext {
+    readonly error: ErrorPayload;
+}
+export type Response<Result extends Value = Value> = SuccessResponse<Result> | ErrorResponse | RedirectResponse | Stale | Miss;
+export declare function decodeResponse(input: unknown): Response;