@astrale-os/kernel-protocol 0.5.0-beta.8 → 0.5.0

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

@@ -0,0 +1,11 @@
+import { type Request } from '../request.js';
+export declare const REQUEST_ENVELOPE_FIELD: 'x-astrale-request';
+export declare const BINARY_LENGTH_FIELD: 'x-astrale-binary-length';
+export declare const BINARY_REQUEST_CONTENT_TYPE: 'application/octet-stream';
+export declare const MAXIMUM_REQUEST_ENVELOPE_BYTES = 8192;
+/** Decode one declared byte count: a canonical unsigned decimal within the safe integer range. */
+export declare function decodeBinaryLength(input: string): number | undefined;
+/** Encode one canonical V2 Request into the binary-request HTTP field. */
+export declare function encodeBinaryRequestEnvelope(input: Request): string;
+/** Decode one bounded base64url JSON V2 Request from the binary-request HTTP field. */
+export declare function decodeBinaryRequestEnvelope(input: string | null): Request;

package/dist/invocation/http/request.js

@@ -0,0 +1,69 @@
+import { json } from '../../codecs/index.js';
+import { CODES, ProtocolError } from '../../errors/index.js';
+import { decodeRequest } from '../request.js';
+export const REQUEST_ENVELOPE_FIELD = 'x-astrale-request';
+export const BINARY_LENGTH_FIELD = 'x-astrale-binary-length';
+export const BINARY_REQUEST_CONTENT_TYPE = 'application/octet-stream';
+export const MAXIMUM_REQUEST_ENVELOPE_BYTES = 8_192;
+const BASE64URL = /^[A-Za-z0-9_-]+$/u;
+const MAXIMUM_ENCODED_BYTES = Math.ceil(MAXIMUM_REQUEST_ENVELOPE_BYTES / 3) * 4;
+const DECIMAL = /^(?:0|[1-9][0-9]*)$/u;
+/** Decode one declared byte count: a canonical unsigned decimal within the safe integer range. */
+export function decodeBinaryLength(input) {
+    if (!DECIMAL.test(input))
+        return undefined;
+    const length = Number(input);
+    return Number.isSafeInteger(length) ? length : undefined;
+}
+/** Encode one canonical V2 Request into the binary-request HTTP field. */
+export function encodeBinaryRequestEnvelope(input) {
+    const request = decodeRequest(input);
+    const encoded = json.encode(request);
+    if (typeof encoded !== 'string')
+        throw new TypeError('JSON Request codec returned non-text output.');
+    const bytes = new TextEncoder().encode(encoded);
+    if (bytes.byteLength > MAXIMUM_REQUEST_ENVELOPE_BYTES)
+        return invalid();
+    return btoa(String.fromCharCode(...bytes))
+        .replaceAll('+', '-')
+        .replaceAll('/', '_')
+        .replace(/=+$/u, '');
+}
+/** Decode one bounded base64url JSON V2 Request from the binary-request HTTP field. */
+export function decodeBinaryRequestEnvelope(input) {
+    if (input === null ||
+        input.length === 0 ||
+        input.length > MAXIMUM_ENCODED_BYTES ||
+        !BASE64URL.test(input)) {
+        return invalid();
+    }
+    let bytes;
+    try {
+        const binary = atob(input.replaceAll('-', '+').replaceAll('_', '/') + '='.repeat((4 - (input.length % 4)) % 4));
+        bytes = Uint8Array.from(binary, (character) => character.charCodeAt(0));
+    }
+    catch {
+        return invalid();
+    }
+    if (bytes.byteLength > MAXIMUM_REQUEST_ENVELOPE_BYTES)
+        return invalid();
+    try {
+        // Require canonical base64url so alternate encodings cannot name the same envelope.
+        const canonical = btoa(String.fromCharCode(...bytes))
+            .replaceAll('+', '-')
+            .replaceAll('/', '_')
+            .replace(/=+$/u, '');
+        if (canonical !== input)
+            return invalid();
+        return decodeRequest(json.decode(bytes));
+    }
+    catch {
+        return invalid();
+    }
+}
+function invalid() {
+    throw new ProtocolError({
+        code: CODES.INVALID_REQUEST,
+        message: 'HTTP binary Request envelope is invalid.',
+    });
+}

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

@@ -14,4 +14,3 @@ export declare class InvocationError extends TypeError {
 export declare function acceptInvocationId(input: unknown): InvocationId;
 /** Compare both canonical coordinate fields exactly. */
 export declare function sameInvocationId(left: InvocationId, right: InvocationId): boolean;
-//# sourceMappingURL=identity.d.ts.map

package/dist/invocation/identity.js

@@ -53,4 +53,3 @@ function isLocalInvocationId(input) {
 function invalid(input) {
     throw new InvocationError(input);
 }
-//# sourceMappingURL=identity.js.map

package/dist/invocation/index.d.ts

@@ -5,17 +5,17 @@ export { acceptIdempotencyKey, HTTP_IDEMPOTENCY_KEY, MAXIMUM_IDEMPOTENCY_KEY_LEN
 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 { acceptMaintenance, MAXIMUM_MAINTENANCE_SESSION_LENGTH, type Maintenance, type MaintenanceSession, } from './maintenance.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 { acceptRouting, routedDigest, routedRevision, 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 { decodeResponse, type ErrorResponse, type ExecutionResponse, type Response, type ResponseContext, type SuccessResponse, } from './response.js';
+export { CALLABLE_FINGERPRINT_MISMATCH, DEPLOYMENT_RETIRED, SERVICE_CANDIDATE_INVALID, SERVICE_TRUST_REQUIRED, SERVICE_UNAVAILABLE, serviceErrorOf, type CallableFingerprintMismatchDetails, type CallableFingerprintMismatchReason, type DeploymentRetiredDetails, type DeploymentRetiredReason, 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 { Target, targetPath, 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

@@ -5,17 +5,17 @@ export { acceptIdempotencyKey, HTTP_IDEMPOTENCY_KEY, MAXIMUM_IDEMPOTENCY_KEY_LEN
 export { acceptInvocationId, InvocationError, MAXIMUM_INVOCATION_ID_LENGTH, sameInvocationId, } from './identity.js';
 export * as http from './http/index.js';
 export { acceptDelegate } from './delegate.js';
+export { acceptMaintenance, MAXIMUM_MAINTENANCE_SESSION_LENGTH, } from './maintenance.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 { acceptRouting, routedDigest, routedRevision, } 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 { CALLABLE_FINGERPRINT_MISMATCH, DEPLOYMENT_RETIRED, 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 { Target, targetPath, acceptCall } from './target.js';
 export { VERSION } from './version.js';
 export * as websocket from './websocket/index.js';
-//# sourceMappingURL=index.js.map

package/dist/invocation/maintenance.d.ts

@@ -0,0 +1,14 @@
+declare const MAINTENANCE_SESSION: unique symbol;
+/** Identity of the install Execution that owns one maintenance session; it grants no authority. */
+export type MaintenanceSession = string & {
+    readonly [MAINTENANCE_SESSION]: true;
+};
+/** Source-Kernel guard naming the maintenance session a root request expects to act within. */
+export interface Maintenance {
+    readonly session: MaintenanceSession;
+}
+/** An Execution identifier: 1-255 ASCII characters drawn from `[A-Za-z0-9._-]`. */
+export declare const MAXIMUM_MAINTENANCE_SESSION_LENGTH = 255;
+/** Admit one exact maintenance guard without deciding whether its session is active. */
+export declare function acceptMaintenance(input: unknown): Maintenance;
+export {};

package/dist/invocation/maintenance.js

@@ -0,0 +1,18 @@
+import { isNodeId } from '@astrale-os/kernel-core/graph/node';
+import { exactFields, invalid, portableObject, required } from './admission.js';
+/** An Execution identifier: 1-255 ASCII characters drawn from `[A-Za-z0-9._-]`. */
+export const MAXIMUM_MAINTENANCE_SESSION_LENGTH = 255;
+const FIELDS = new Set(['session']);
+/** Admit one exact maintenance guard without deciding whether its session is active. */
+export function acceptMaintenance(input) {
+    const object = portableObject(input, 'maintenance');
+    exactFields(object, FIELDS, 'maintenance');
+    required(object, ['session'], 'maintenance');
+    // An Execution identifier shares the Core NodeId grammar; it names no graph Node.
+    const session = object.session;
+    if (!isNodeId(session)) {
+        invalid('maintenance.session must contain 1-255 ASCII characters drawn from [A-Za-z0-9._-]');
+    }
+    const admitted = session;
+    return Object.freeze({ session: admitted });
+}

package/dist/invocation/miss.d.ts

@@ -7,4 +7,3 @@ export interface Miss {
 }
 export declare function decodeMiss(input: unknown): Miss;
 export declare function miss(requestId: RequestId, assigned: InvocationId): Miss;
-//# sourceMappingURL=miss.d.ts.map

package/dist/invocation/miss.js

@@ -15,4 +15,3 @@ export function decodeMiss(input) {
 export function miss(requestId, assigned) {
     return decodeMiss({ kind: 'miss', requestId, invocation: assigned });
 }
-//# sourceMappingURL=miss.js.map

package/dist/invocation/redirect.d.ts

@@ -1,18 +1,15 @@
 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 { Key, Revision } from '@astrale-os/kernel-dsl/v1';
+import type { InvocationEndpoints } from '../release/bindings/invocation.js';
+import type { ReleaseDigest } from '../release/digest.js';
 import type { RequestId } from './correlation.js';
 import type { InvocationId } from './identity.js';
+import type { Via } from './routing.js';
 import type { Trace } from './trace.js';
 export interface Route {
     readonly endpoint: InvocationEndpoints;
-    readonly via: {
-        readonly kind: 'via';
-        readonly publication: PublicationRef;
-        readonly issuer: IssuerId;
-    };
+    /** Routed witness of the exact installed release. */
+    readonly via: Via;
 }
 export interface Redirection {
     readonly route: Route;
@@ -26,16 +23,16 @@ export interface RedirectResponse {
     readonly invocation: InvocationId;
     readonly redirect: Redirection;
 }
+/** Remote binding of one installed release: the endpoint and the release it routes to. */
 export interface RemoteBindingInput {
     readonly endpoint: InvocationEndpoints;
     readonly issuer: IssuerId;
     readonly subject: string;
-    readonly revision: PublicationRef['revision'];
-    readonly etag: Etag;
+    readonly revision: Revision;
+    readonly release: ReleaseDigest;
 }
 export declare function acceptRoute(input: unknown): Route;
-/** Project one semantic remote binding into its admitted protocol route representation. */
+/** Project one installed release binding into its routed witness. */
 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;
-//# sourceMappingURL=redirect.d.ts.map

package/dist/invocation/redirect.js

@@ -1,49 +1,37 @@
-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 { acceptInvocationEndpoints } from '../release/bindings/index.js';
+import { ReleaseError } from '../release/error.js';
+import { exactFields, invalid, invocation, portableObject, requestId, required, string, } from './admission.js';
+import { acceptVia } from './routing.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');
+    const via = acceptVia(portableObject(object.via, 'route.via'), 'route.via');
     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'),
-            }),
-        });
+        return Object.freeze({ endpoint: acceptInvocationEndpoints(object.endpoint), via });
     }
     catch (cause) {
-        if (cause instanceof PublicationError) {
+        if (cause instanceof ReleaseError) {
             return invalid(`route is invalid: ${cause.message}`);
         }
         throw cause;
     }
 }
-/** Project one semantic remote binding into its admitted protocol route representation. */
+/** Project one installed release binding into its routed witness. */
 export function remoteRoute(origin, binding, issuer) {
     return acceptRoute({
         endpoint: binding.endpoint,
         via: {
             kind: 'via',
-            publication: {
+            release: {
                 origin,
                 identity: { issuer: binding.issuer, subject: binding.subject },
                 revision: binding.revision,
-                etag: binding.etag,
+                digest: binding.release,
             },
             issuer,
         },
@@ -79,4 +67,3 @@ export function decodeRedirectResponse(input) {
         redirect: acceptRedirection(object.redirect),
     });
 }
-//# sourceMappingURL=redirect.js.map

package/dist/invocation/request.d.ts

@@ -1,6 +1,7 @@
 import type { RequestId } from './correlation.js';
 import type { Delegate } from './delegate.js';
 import type { IdempotencyKey } from './idempotency.js';
+import type { Maintenance } from './maintenance.js';
 import type { Routing } from './routing.js';
 import type { SchemaTarget } from './schema.js';
 import type { Call } from './target.js';
@@ -15,8 +16,9 @@ export interface Request {
     readonly routing?: Routing;
     /** Source-Kernel precondition; forbidden on an already-routed destination request. */
     readonly schema?: SchemaTarget;
+    /** Source-Kernel maintenance session guard; forbidden on an already-routed destination request. */
+    readonly maintenance?: Maintenance;
     readonly idempotencyKey?: IdempotencyKey;
     readonly trace?: Trace;
 }
 export declare function decodeRequest(input: unknown): Request;
-//# sourceMappingURL=request.d.ts.map

package/dist/invocation/request.js

@@ -1,9 +1,10 @@
 import { exactFields, invalid, portableObject, requestId, required, string } from './admission.js';
 import { acceptDelegate } from './delegate.js';
 import { acceptIdempotencyKey } from './idempotency.js';
+import { acceptMaintenance } from './maintenance.js';
 import { acceptRouting } from './routing.js';
 import { acceptSchemaTarget } from './schema.js';
-import { acceptCall } from './target.js';
+import { callFromSnapshot } from './target.js';
 import { admitTrace } from './trace.js';
 const REQUEST_FIELDS = new Set([
     'version',
@@ -13,6 +14,7 @@ const REQUEST_FIELDS = new Set([
     'delegate',
     'routing',
     'schema',
+    'maintenance',
     'idempotencyKey',
     'trace',
 ]);
@@ -26,12 +28,16 @@ export function decodeRequest(input) {
     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 maintenance = object.maintenance === undefined ? undefined : acceptMaintenance(object.maintenance);
     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');
+        if (maintenance !== undefined) {
+            invalid('destination requests with via routing forbid maintenance');
+        }
     }
     else if ((credential === undefined) !== (delegate === undefined)) {
         invalid('source requests require credential and delegate together');
@@ -39,11 +45,12 @@ export function decodeRequest(input) {
     return Object.freeze({
         version: 2,
         requestId: requestId(object.requestId, 'request.requestId'),
-        call: acceptCall(object.call),
+        call: callFromSnapshot(object.call),
         ...(credential === undefined ? {} : { credential }),
         ...(delegate === undefined ? {} : { delegate }),
         ...(routing === undefined ? {} : { routing }),
         ...(schema === undefined ? {} : { schema }),
+        ...(maintenance === undefined ? {} : { maintenance }),
         ...(object.idempotencyKey === undefined
             ? {}
             : {
@@ -52,4 +59,3 @@ export function decodeRequest(input) {
         ...(trace === undefined ? {} : { trace }),
     });
 }
-//# sourceMappingURL=request.js.map

package/dist/invocation/response.d.ts

@@ -1,4 +1,5 @@
 import type { Value } from '@astrale-os/kernel-dsl/value';
+import { type NodeId } from '@astrale-os/kernel-core/graph/node';
 import type { ErrorPayload } from '../errors/index.js';
 import type { RequestId } from './correlation.js';
 import type { InvocationId } from './identity.js';
@@ -15,6 +16,9 @@ export interface SuccessResponse<Result extends Value = Value> extends ResponseC
 export interface ErrorResponse extends ResponseContext {
     readonly error: ErrorPayload;
 }
-export type Response<Result extends Value = Value> = SuccessResponse<Result> | ErrorResponse | RedirectResponse | Stale | Miss;
+/** A durable call's answer: the Execution it started or recovered, never a handler result. */
+export interface ExecutionResponse extends ResponseContext {
+    readonly execution: NodeId;
+}
+export type Response<Result extends Value = Value> = SuccessResponse<Result> | ErrorResponse | ExecutionResponse | RedirectResponse | Stale | Miss;
 export declare function decodeResponse(input: unknown): Response;
-//# sourceMappingURL=response.d.ts.map

package/dist/invocation/response.js

@@ -1,17 +1,18 @@
+import { isNodeId } from '@astrale-os/kernel-core/graph/node';
 import { errorPayload, exactFields, invalid, invocation, portableObject, requestId, required, } from './admission.js';
 import { decodeMiss } from './miss.js';
 import { decodeRedirectResponse } from './redirect.js';
 import { decodeStale } from './stale-route.js';
 const SUCCESS_FIELDS = new Set(['result', 'requestId', 'invocation']);
 const ERROR_FIELDS = new Set(['error', 'requestId', 'invocation']);
+const EXECUTION_FIELDS = new Set(['execution', 'requestId', 'invocation']);
 export function decodeResponse(input) {
     const object = portableObject(input, 'response');
-    const hasResult = Object.hasOwn(object, 'result');
-    const hasError = Object.hasOwn(object, 'error');
-    if (hasResult || hasError) {
-        if (hasResult === hasError)
-            invalid('response must contain exactly one of result or error');
-        if (hasResult) {
+    const outcomes = ['result', 'error', 'execution'].filter((field) => Object.hasOwn(object, field));
+    if (outcomes.length > 1)
+        invalid('response must contain exactly one of result, error or execution');
+    switch (outcomes[0]) {
+        case 'result':
             exactFields(object, SUCCESS_FIELDS, 'response');
             required(object, ['requestId', 'invocation'], 'response');
             return Object.freeze({
@@ -19,14 +20,24 @@ export function decodeResponse(input) {
                 requestId: requestId(object.requestId, 'response.requestId'),
                 invocation: invocation(object.invocation, 'response.invocation'),
             });
-        }
-        exactFields(object, ERROR_FIELDS, 'response');
-        required(object, ['requestId', 'error', 'invocation'], 'response');
-        return Object.freeze({
-            error: errorPayload(object.error, 'response.error'),
-            requestId: requestId(object.requestId, 'response.requestId'),
-            invocation: invocation(object.invocation, 'response.invocation'),
-        });
+        case 'error':
+            exactFields(object, ERROR_FIELDS, 'response');
+            required(object, ['requestId', 'error', 'invocation'], 'response');
+            return Object.freeze({
+                error: errorPayload(object.error, 'response.error'),
+                requestId: requestId(object.requestId, 'response.requestId'),
+                invocation: invocation(object.invocation, 'response.invocation'),
+            });
+        case 'execution':
+            exactFields(object, EXECUTION_FIELDS, 'response');
+            required(object, ['requestId', 'execution', 'invocation'], 'response');
+            if (!isNodeId(object.execution))
+                invalid('response.execution must be a NodeId');
+            return Object.freeze({
+                execution: object.execution,
+                requestId: requestId(object.requestId, 'response.requestId'),
+                invocation: invocation(object.invocation, 'response.invocation'),
+            });
     }
     if (object.kind === 'redirect')
         return decodeRedirectResponse(object);
@@ -34,6 +45,5 @@ export function decodeResponse(input) {
         return decodeStale(object);
     if (object.kind === 'miss')
         return decodeMiss(object);
-    return invalid('response must contain a result, error, redirect, stale, or miss control');
+    return invalid('response must contain a result, error, execution, redirect, stale, or miss control');
 }
-//# sourceMappingURL=response.js.map

package/dist/invocation/routing.d.ts

@@ -1,15 +1,24 @@
 import type { IssuerId } from '@astrale-os/kernel-core/auth/issuer';
-import type { Etag } from '../publication/etag.js';
-import type { PublicationRef } from '../publication/reference.js';
+import type { Revision } from '@astrale-os/kernel-dsl/v1/addressing';
+import type { Object as ValueObject } from '@astrale-os/kernel-dsl/value';
+import type { Sha256Digest } from '../release/digest.js';
+import type { ReleaseRef } from '../release/reference.js';
+/** Routed witness of one installed release: the Kernel routed this call to that exact release. */
 export interface Via {
     readonly kind: 'via';
-    readonly publication: PublicationRef;
+    readonly release: ReleaseRef;
     readonly issuer: IssuerId;
 }
 export interface Refresh {
     readonly kind: 'refresh';
-    readonly stale: Etag;
+    readonly stale: Sha256Digest;
 }
+/** A received `Via` names one exact `ReleaseRef`. */
 export type Routing = Via | Refresh;
 export declare function acceptRouting(input: unknown): Routing;
-//# sourceMappingURL=routing.d.ts.map
+/** Admit one routed witness carrying one exact `release`. */
+export declare function acceptVia(object: ValueObject, label: string): Via;
+/** Schema revision of the release the witness routed the call to. */
+export declare function routedRevision(via: Via): Revision;
+/** Digest of the release the witness routed this call to. */
+export declare function routedDigest(via: Via): Sha256Digest;

package/dist/invocation/routing.js

@@ -1,27 +1,12 @@
-import { PublicationError } from '../publication/error.js';
-import { acceptReference } from '../publication/reference.js';
+import { ReleaseError } from '../release/error.js';
+import { acceptReference } from '../release/reference.js';
 import { digest, exactFields, invalid, issuerId, portableObject, required } from './admission.js';
-const VIA_FIELDS = new Set(['kind', 'publication', 'issuer']);
+const VIA_FIELDS = new Set(['kind', 'release', 'issuer']);
 const REFRESH_FIELDS = new Set(['kind', 'stale']);
 export function acceptRouting(input) {
     const object = portableObject(input, 'routing');
-    if (object.kind === 'via') {
-        exactFields(object, VIA_FIELDS, 'via routing');
-        required(object, ['kind', 'publication', 'issuer'], 'via routing');
-        try {
-            return Object.freeze({
-                kind: 'via',
-                publication: acceptReference(object.publication),
-                issuer: issuerId(object.issuer, 'via routing.issuer'),
-            });
-        }
-        catch (cause) {
-            if (cause instanceof PublicationError) {
-                return invalid(`via routing.publication is invalid: ${cause.message}`);
-            }
-            throw cause;
-        }
-    }
+    if (object.kind === 'via')
+        return acceptVia(object, 'via routing');
     if (object.kind === 'refresh') {
         exactFields(object, REFRESH_FIELDS, 'refresh routing');
         required(object, ['kind', 'stale'], 'refresh routing');
@@ -32,4 +17,33 @@ export function acceptRouting(input) {
     }
     return invalid('routing.kind must be "via" or "refresh"');
 }
-//# sourceMappingURL=routing.js.map
+/** Admit one routed witness carrying one exact `release`. */
+export function acceptVia(object, label) {
+    exactFields(object, VIA_FIELDS, label);
+    if (object.kind !== 'via')
+        invalid(`${label}.kind must be "via"`);
+    required(object, ['release', 'issuer'], label);
+    return Object.freeze({
+        kind: 'via',
+        release: acceptReleaseReference(object.release, `${label}.release`),
+        issuer: issuerId(object.issuer, `${label}.issuer`),
+    });
+}
+/** Schema revision of the release the witness routed the call to. */
+export function routedRevision(via) {
+    return via.release.revision;
+}
+/** Digest of the release the witness routed this call to. */
+export function routedDigest(via) {
+    return via.release.digest;
+}
+function acceptReleaseReference(input, label) {
+    try {
+        return acceptReference(input);
+    }
+    catch (cause) {
+        if (cause instanceof ReleaseError)
+            return invalid(`${label} is invalid: ${cause.message}`);
+        throw cause;
+    }
+}

package/dist/invocation/schema.d.ts

@@ -1,10 +1,11 @@
-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. */
+import type { Sha256Digest } from '../release/digest.js';
+/**
+ * Source-Kernel precondition for one invocation: the exact installed artifact target, or the
+ * fingerprint of the callable meaning the static consumer compiled against.
+ */
 export type SchemaTarget = {
     readonly target: Sha256Digest;
 } | {
-    readonly revision: Revision;
+    readonly fingerprint: Sha256Digest;
 };
 export declare function acceptSchemaTarget(input: unknown): SchemaTarget;
-//# sourceMappingURL=schema.d.ts.map