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

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/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,15 +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;

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,
         },

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,6 +16,8 @@ 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;
 }

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
             ? {}
             : {

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,5 +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;

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,5 +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');
 }

package/dist/invocation/routing.d.ts

@@ -1,14 +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;
+/** 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,3 +17,33 @@ export function acceptRouting(input) {
     }
     return invalid('routing.kind must be "via" or "refresh"');
 }
+/** 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,9 +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;

package/dist/invocation/schema.js

@@ -1,19 +1,13 @@
-import { patterns } from '@astrale-os/kernel-dsl/v1/addressing';
 import { digest, exactFields, invalid, portableObject } from './admission.js';
-const FIELDS = new Set(['target', 'revision']);
+const FIELDS = new Set(['target', 'fingerprint']);
 export function acceptSchemaTarget(input) {
     const object = portableObject(input, 'schema target');
     exactFields(object, FIELDS, 'schema target');
-    const hasTarget = Object.hasOwn(object, 'target');
-    const hasRevision = Object.hasOwn(object, 'revision');
-    if (hasTarget === hasRevision) {
-        invalid('schema target must contain exactly one of target or revision');
+    if ([...FIELDS].filter((field) => Object.hasOwn(object, field)).length !== 1) {
+        invalid('schema target must contain exactly one of target or fingerprint');
     }
-    if (hasTarget) {
+    if (Object.hasOwn(object, 'target')) {
         return Object.freeze({ target: digest(object.target, 'schema target.target') });
     }
-    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 });
+    return Object.freeze({ fingerprint: digest(object.fingerprint, 'schema target.fingerprint') });
 }

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

@@ -1,23 +1,21 @@
 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 { type Key } from '@astrale-os/kernel-dsl/v1/addressing';
+import { Key } from '@astrale-os/kernel-dsl/v1/addressing';
 import type { ErrorPayload, ErrorReason } from '../errors/index.js';
+import type { ReleaseDigest, Sha256Digest } from '../release/digest.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 CALLABLE_FINGERPRINT_MISMATCH: 'CALLABLE_FINGERPRINT_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 & {
+/** A deployment answers that it no longer serves: it runs no other code in its place. */
+export declare const DEPLOYMENT_RETIRED: 'DEPLOYMENT_RETIRED';
+export type CallableFingerprintMismatchDetails = ValueObject & {
     readonly origin: Key.Origin;
-    readonly installedRevision: Revision;
-    readonly candidateRevision: Revision;
-};
-export type SchemaRevisionMismatchDetails = ValueObject & {
-    readonly origin: Key.Origin;
-    readonly expectedRevision: Revision;
-    readonly installedRevision: Revision;
+    readonly callable: Key.Callable;
+    readonly expectedFingerprint: Sha256Digest;
+    readonly installedFingerprint: Sha256Digest;
 };
 export type ServiceTrustRequiredDetails = ValueObject & {
     readonly origin: Key.Origin;
@@ -31,18 +29,25 @@ export type ServiceUnavailableDetails = ValueObject & {
 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 DeploymentRetiredDetails = ValueObject & {
+    readonly deployment: IssuerId;
+    readonly release?: ReleaseDigest;
+};
+export type CallableFingerprintMismatchReason = ErrorReason<typeof CALLABLE_FINGERPRINT_MISMATCH, CallableFingerprintMismatchDetails>;
 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 = SchemaRevisionMismatchReason | SchemaUpgradeRequiredReason | ServiceTrustRequiredReason | ServiceUnavailableReason | ServiceCandidateInvalidReason;
+export type DeploymentRetiredReason = ErrorReason<typeof DEPLOYMENT_RETIRED, DeploymentRetiredDetails>;
+export type ServiceReason = CallableFingerprintMismatchReason | ServiceTrustRequiredReason | ServiceUnavailableReason | ServiceCandidateInvalidReason | DeploymentRetiredReason;
 export type ServiceErrorPayload = (Omit<ErrorPayload, 'code' | 'data'> & {
     readonly code: typeof CODES.CONFLICT;
-    readonly data: SchemaRevisionMismatchReason | SchemaUpgradeRequiredReason | ServiceTrustRequiredReason;
+    readonly data: CallableFingerprintMismatchReason | ServiceTrustRequiredReason;
 }) | (Omit<ErrorPayload, 'code' | 'data'> & {
     readonly code: typeof CODES.BACKEND_UNAVAILABLE;
     readonly data: ServiceUnavailableReason | ServiceCandidateInvalidReason;
+}) | (Omit<ErrorPayload, 'code' | 'data'> & {
+    readonly code: typeof CODES.NOT_FOUND;
+    readonly data: DeploymentRetiredReason;
 });
 /** Recognize only exact outer-code, reason-code, and detail-shape combinations. */
 export declare function serviceErrorOf(input: ErrorPayload): ServiceErrorPayload | undefined;

package/dist/invocation/service-reason.js

@@ -1,24 +1,21 @@
 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 { Key, 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 CALLABLE_FINGERPRINT_MISMATCH = 'CALLABLE_FINGERPRINT_MISMATCH';
 export const SERVICE_TRUST_REQUIRED = 'SERVICE_TRUST_REQUIRED';
 export const SERVICE_UNAVAILABLE = 'SERVICE_UNAVAILABLE';
 export const SERVICE_CANDIDATE_INVALID = 'SERVICE_CANDIDATE_INVALID';
+/** A deployment answers that it no longer serves: it runs no other code in its place. */
+export const DEPLOYMENT_RETIRED = 'DEPLOYMENT_RETIRED';
 /** Recognize only exact outer-code, reason-code, and detail-shape combinations. */
 export function serviceErrorOf(input) {
     const reason = reasonOf(input.data);
     if (reason === undefined)
         return undefined;
     switch (reason.code) {
-        case SCHEMA_REVISION_MISMATCH:
-            return input.code === CODES.CONFLICT && schemaRevisionMismatchDetails(reason.details)
-                ? input
-                : undefined;
-        case SCHEMA_UPGRADE_REQUIRED:
-            return input.code === CODES.CONFLICT && schemaUpgradeDetails(reason.details)
+        case CALLABLE_FINGERPRINT_MISMATCH:
+            return input.code === CODES.CONFLICT && callableFingerprintMismatchDetails(reason.details)
                 ? input
                 : undefined;
         case SERVICE_TRUST_REQUIRED:
@@ -33,21 +30,22 @@ export function serviceErrorOf(input) {
             return input.code === CODES.BACKEND_UNAVAILABLE && candidateInvalidDetails(reason.details)
                 ? input
                 : undefined;
+        case DEPLOYMENT_RETIRED:
+            return input.code === CODES.NOT_FOUND && deploymentRetiredDetails(reason.details)
+                ? input
+                : undefined;
         default:
             return undefined;
     }
 }
-function schemaRevisionMismatchDetails(input) {
-    return (exact(input, ['origin', 'expectedRevision', 'installedRevision']) &&
+function callableFingerprintMismatchDetails(input) {
+    return (exact(input, ['origin', 'callable', 'expectedFingerprint', 'installedFingerprint']) &&
         isOrigin(input.origin) &&
-        isRevision(input.expectedRevision) &&
-        isRevision(input.installedRevision));
-}
-function schemaUpgradeDetails(input) {
-    return (exact(input, ['origin', 'installedRevision', 'candidateRevision']) &&
-        isOrigin(input.origin) &&
-        isRevision(input.installedRevision) &&
-        isRevision(input.candidateRevision));
+        typeof input.callable === 'string' &&
+        Key.is(input.callable) &&
+        Key.origin(input.callable) === input.origin &&
+        isDigest(input.expectedFingerprint) &&
+        isDigest(input.installedFingerprint));
 }
 function serviceTrustDetails(input) {
     return (exact(input, ['origin', 'installedIssuer', 'candidateIssuer']) &&
@@ -61,6 +59,13 @@ function serviceUnavailableDetails(input) {
 function candidateInvalidDetails(input) {
     return exact(input, ['origin']) && isOrigin(input.origin);
 }
+function deploymentRetiredDetails(input) {
+    return Object.hasOwn(input, 'release')
+        ? exact(input, ['deployment', 'release']) &&
+            isIssuer(input.deployment) &&
+            isDigest(input.release)
+        : exact(input, ['deployment']) && isIssuer(input.deployment);
+}
 function exact(input, fields) {
     return (Object.keys(input).length === fields.length &&
         fields.every((field) => Object.hasOwn(input, field)));
@@ -71,6 +76,9 @@ function isOrigin(input) {
 function isRevision(input) {
     return typeof input === 'string' && patterns.revision.test(input);
 }
+function isDigest(input) {
+    return typeof input === 'string' && /^sha256:[0-9a-f]{64}$/u.test(input);
+}
 function isIssuer(input) {
     if (typeof input !== 'string')
         return false;

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

@@ -1,4 +1,4 @@
-import type { Etag } from '../publication/index.js';
+import type { ReleaseDigest } from '../release/digest.js';
 import type { RequestId } from './correlation.js';
 import type { InvocationId } from './identity.js';
 /** Reserved pre-handler routing control; never an application ErrorResponse. */
@@ -6,7 +6,7 @@ export interface Stale {
     readonly kind: 'stale';
     readonly requestId: RequestId;
     readonly invocation: InvocationId;
-    readonly current: Etag;
+    readonly current: ReleaseDigest;
 }
 export declare function decodeStale(input: unknown): Stale;
-export declare function stale(requestId: RequestId, assigned: InvocationId, current: Etag): Stale;
+export declare function stale(requestId: RequestId, assigned: InvocationId, current: ReleaseDigest): Stale;

package/dist/invocation/target.d.ts

@@ -1,3 +1,6 @@
-import type { Call } from '@astrale-os/kernel-core/callable';
-export type { Call } from '@astrale-os/kernel-core/callable';
+import type { Value } from '@astrale-os/kernel-dsl/value';
+import { type Call } from '@astrale-os/kernel-core/callable';
+export { Target, targetPath, type Call } from '@astrale-os/kernel-core/callable';
 export declare function acceptCall(input: unknown): Call;
+/** Package-private: consume the detached portable subtree captured by request admission. */
+export declare function callFromSnapshot(input: Value): Call;

package/dist/invocation/target.js

@@ -1,11 +1,33 @@
-import { exactFields, nodePath, portableObject, required } from './admission.js';
+import { Target } from '@astrale-os/kernel-core/callable';
+import { PathError } from '@astrale-os/kernel-core/path';
+import { exactFields, invalid, nodePath, portableObject, required } from './admission.js';
+export { Target, targetPath } from '@astrale-os/kernel-core/callable';
 const CALL_FIELDS = new Set(['target', 'input']);
 export function acceptCall(input) {
-    const object = portableObject(input, 'call');
+    return callFromSnapshot(portableObject(input, 'call'));
+}
+/** Package-private: consume the detached portable subtree captured by request admission. */
+export function callFromSnapshot(input) {
+    if (input === null || typeof input !== 'object' || Array.isArray(input)) {
+        invalid('call must be an object');
+    }
+    const object = input;
     exactFields(object, CALL_FIELDS, 'call');
     required(object, ['target', 'input'], 'call');
     return Object.freeze({
-        target: nodePath(object.target, 'call.target'),
+        target: acceptTarget(object.target),
         input: object.input,
     });
 }
+function acceptTarget(input) {
+    if (typeof input === 'string')
+        return nodePath(input, 'call.target');
+    try {
+        return Target(input);
+    }
+    catch (cause) {
+        if (cause instanceof TypeError || cause instanceof PathError)
+            return invalid('call.target must be a canonical NodePath or declaration Target');
+        throw cause;
+    }
+}