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

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

@@ -9,13 +9,12 @@ 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 { 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

@@ -9,13 +9,12 @@ 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/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

@@ -19,4 +19,3 @@ export interface Request {
     readonly trace?: Trace;
 }
 export declare function decodeRequest(input: unknown): Request;
-//# sourceMappingURL=request.d.ts.map

package/dist/invocation/request.js

@@ -3,7 +3,7 @@ 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 { callFromSnapshot } from './target.js';
 import { admitTrace } from './trace.js';
 const REQUEST_FIELDS = new Set([
     'version',
@@ -39,7 +39,7 @@ 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 }),
@@ -52,4 +52,3 @@ export function decodeRequest(input) {
         ...(trace === undefined ? {} : { trace }),
     });
 }
-//# sourceMappingURL=request.js.map

package/dist/invocation/response.d.ts

@@ -17,4 +17,3 @@ export interface ErrorResponse extends ResponseContext {
 }
 export type Response<Result extends Value = Value> = SuccessResponse<Result> | ErrorResponse | RedirectResponse | Stale | Miss;
 export declare function decodeResponse(input: unknown): Response;
-//# sourceMappingURL=response.d.ts.map

package/dist/invocation/response.js

@@ -36,4 +36,3 @@ export function decodeResponse(input) {
         return decodeMiss(object);
     return invalid('response must contain a result, error, redirect, stale, or miss control');
 }
-//# sourceMappingURL=response.js.map

package/dist/invocation/routing.d.ts

@@ -1,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

package/dist/invocation/schema.js

@@ -1,20 +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') });
 }
-//# sourceMappingURL=schema.js.map

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,19 +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;
-//# sourceMappingURL=service-reason.d.ts.map