@astrale-os/kernel-protocol 0.5.0-beta.7 → 0.5.0-beta.71

package/dist/invocation/routing.d.ts

@@ -1,15 +1,28 @@
 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';
+import type { PublicationVia } from './legacy/via.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;
 }
-export type Routing = Via | Refresh;
+/** A received `Via` names exactly one of a `ReleaseRef` or a legacy `PublicationRef`. */
+export type Routing = Via | PublicationVia | Refresh;
 export declare function acceptRouting(input: unknown): Routing;
-//# sourceMappingURL=routing.d.ts.map
+/** Admit one routed witness carrying exactly one of `release` or legacy `publication`. */
+export declare function acceptVia(object: ValueObject, label: string): Via | PublicationVia;
+/** Schema revision of the release or Publication the witness routed the call to. */
+export declare function routedRevision(via: Via | PublicationVia): Revision;
+/**
+ * Digest designating what the witness routed the call to: the release digest of a `Via`, the
+ * Publication ETag of a legacy `PublicationVia`.
+ */
+export declare function routedDigest(via: Via | PublicationVia): Sha256Digest;

package/dist/invocation/routing.js

@@ -1,27 +1,13 @@
-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']);
+import { acceptPublicationReference } from './legacy/via.js';
+const VIA_FIELDS = new Set(['kind', 'release', 'publication', '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 +18,47 @@ export function acceptRouting(input) {
     }
     return invalid('routing.kind must be "via" or "refresh"');
 }
-//# sourceMappingURL=routing.js.map
+/** Admit one routed witness carrying exactly one of `release` or legacy `publication`. */
+export function acceptVia(object, label) {
+    exactFields(object, VIA_FIELDS, label);
+    if (object.kind !== 'via')
+        invalid(`${label}.kind must be "via"`);
+    const hasRelease = Object.hasOwn(object, 'release');
+    if (hasRelease === Object.hasOwn(object, 'publication')) {
+        invalid(`${label} must contain exactly one of release or publication`);
+    }
+    required(object, ['issuer'], label);
+    if (!hasRelease) {
+        return Object.freeze({
+            kind: 'via',
+            publication: acceptPublicationReference(object.publication, `${label}.publication`),
+            issuer: issuerId(object.issuer, `${label}.issuer`),
+        });
+    }
+    return Object.freeze({
+        kind: 'via',
+        release: acceptReleaseReference(object.release, `${label}.release`),
+        issuer: issuerId(object.issuer, `${label}.issuer`),
+    });
+}
+/** Schema revision of the release or Publication the witness routed the call to. */
+export function routedRevision(via) {
+    return 'release' in via ? via.release.revision : via.publication.revision;
+}
+/**
+ * Digest designating what the witness routed the call to: the release digest of a `Via`, the
+ * Publication ETag of a legacy `PublicationVia`.
+ */
+export function routedDigest(via) {
+    return 'release' in via ? via.release.digest : via.publication.etag;
+}
+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/schema';
-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/schema';
+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

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;
@@ -83,4 +91,3 @@ function isIssuer(input) {
         throw cause;
     }
 }
-//# sourceMappingURL=service-reason.js.map

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

@@ -1,4 +1,4 @@
-import type { Etag } from '../publication/index.js';
+import type { Etag } from '../release/legacy/etag.js';
 import type { RequestId } from './correlation.js';
 import type { InvocationId } from './identity.js';
 /** Reserved pre-handler routing control; never an application ErrorResponse. */
@@ -10,4 +10,3 @@ export interface Stale {
 }
 export declare function decodeStale(input: unknown): Stale;
 export declare function stale(requestId: RequestId, assigned: InvocationId, current: Etag): Stale;
-//# sourceMappingURL=stale-route.d.ts.map

package/dist/invocation/stale-route.js

@@ -17,4 +17,3 @@ export function decodeStale(input) {
 export function stale(requestId, assigned, current) {
     return decodeStale({ kind: 'stale', requestId, invocation: assigned, current });
 }
-//# sourceMappingURL=stale-route.js.map

package/dist/invocation/stream.d.ts

@@ -25,4 +25,3 @@ export interface StreamErrorFrame {
 }
 export type StreamFrame = StreamStartFrame | StreamItemFrame | StreamEndFrame | StreamErrorFrame;
 export declare function decodeStreamFrame(input: unknown): StreamFrame;
-//# sourceMappingURL=stream.d.ts.map

package/dist/invocation/stream.js

@@ -42,4 +42,3 @@ export function decodeStreamFrame(input) {
             return invalid(`unsupported stream frame kind ${JSON.stringify(kind)}`);
     }
 }
-//# sourceMappingURL=stream.js.map

package/dist/invocation/target.d.ts

@@ -1,4 +1,6 @@
-import type { Call } from '@astrale-os/kernel-core/domain';
-export type { Call } from '@astrale-os/kernel-core/domain';
+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;
-//# sourceMappingURL=target.d.ts.map
+/** Package-private: consume the detached portable subtree captured by request admission. */
+export declare function callFromSnapshot(input: Value): Call;

package/dist/invocation/target.js

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

package/dist/invocation/trace.d.ts

@@ -7,4 +7,3 @@ export interface Trace {
 }
 /** Admit portable correlation syntax without making it an invocation validity condition. */
 export declare function admitTrace(input: unknown): Trace | undefined;
-//# sourceMappingURL=trace.d.ts.map

package/dist/invocation/trace.js

@@ -84,4 +84,3 @@ function validStateKey(input) {
         return false;
     return TENANT_ID.test(input.slice(0, separator)) && SYSTEM_ID.test(input.slice(separator + 1));
 }
-//# sourceMappingURL=trace.js.map

package/dist/invocation/version.d.ts

@@ -1,3 +1,2 @@
 export declare const VERSION: 2;
 export type Version = typeof VERSION;
-//# sourceMappingURL=version.d.ts.map

package/dist/invocation/version.js

@@ -1,2 +1 @@
 export const VERSION = 2;
-//# sourceMappingURL=version.js.map

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

@@ -1,4 +1,3 @@
 import type { BinaryResponse } from '../binary.js';
 export declare function encodeBinary(response: BinaryResponse): Uint8Array;
 export declare function decodeBinary(input: Uint8Array): BinaryResponse | undefined;
-//# sourceMappingURL=binary.d.ts.map

package/dist/invocation/websocket/binary.js

@@ -14,6 +14,7 @@ export function encodeBinary(response) {
         requestId: response.requestId,
         invocation: response.invocation,
         mediaType: response.mediaType,
+        status: response.status,
         ...(headers === undefined ? {} : { headers }),
     }));
     if (metadata.byteLength > MAXIMUM_METADATA_BYTES)
@@ -69,4 +70,3 @@ function invalid() {
         message: 'WebSocket binary response is invalid.',
     });
 }
-//# sourceMappingURL=binary.js.map

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

@@ -1,3 +1,2 @@
 export { decodeBinary, encodeBinary } from './binary.js';
-export { JSON_SUBPROTOCOL, MSGPACK_SUBPROTOCOL, selectSubprotocol, subprotocolFor, type Subprotocol, type SubprotocolSelection, } from './subprotocol.js';
-//# sourceMappingURL=index.d.ts.map
+export { JSON_SUBPROTOCOL, selectSubprotocol, subprotocolFor, type Subprotocol, type SubprotocolSelection, } from './subprotocol.js';

package/dist/invocation/websocket/index.js

@@ -1,3 +1,2 @@
 export { decodeBinary, encodeBinary } from './binary.js';
-export { JSON_SUBPROTOCOL, MSGPACK_SUBPROTOCOL, selectSubprotocol, subprotocolFor, } from './subprotocol.js';
-//# sourceMappingURL=index.js.map
+export { JSON_SUBPROTOCOL, selectSubprotocol, subprotocolFor, } from './subprotocol.js';

package/dist/invocation/websocket/subprotocol.d.ts

@@ -1,11 +1,9 @@
 import type { Codec } from '../../codecs/index.js';
 export declare const JSON_SUBPROTOCOL: 'astrale.invocation.v2.json';
-export declare const MSGPACK_SUBPROTOCOL: 'astrale.invocation.v2.msgpack';
-export type Subprotocol = typeof JSON_SUBPROTOCOL | typeof MSGPACK_SUBPROTOCOL;
+export type Subprotocol = typeof JSON_SUBPROTOCOL;
 export interface SubprotocolSelection {
     readonly subprotocol: Subprotocol;
     readonly codec: Codec;
 }
 export declare function subprotocolFor(codec: Codec): Subprotocol;
 export declare function selectSubprotocol(offered: string | null, supported: readonly Codec[]): SubprotocolSelection | undefined;
-//# sourceMappingURL=subprotocol.d.ts.map

package/dist/invocation/websocket/subprotocol.js

@@ -1,12 +1,11 @@
 import { admitSupportedCodecs, codecProfile } from '../binding-codecs.js';
 export const JSON_SUBPROTOCOL = 'astrale.invocation.v2.json';
-export const MSGPACK_SUBPROTOCOL = 'astrale.invocation.v2.msgpack';
 const TOKEN = /^[!#$%&'*+.^_`|~0-9A-Za-z-]+$/u;
 export function subprotocolFor(codec) {
-    const profile = codecProfile(codec);
-    if (profile === undefined)
+    if (codecProfile(codec) === undefined) {
         throw new TypeError('codec is not a canonical Invocation codec.');
-    return profile === 'json' ? JSON_SUBPROTOCOL : MSGPACK_SUBPROTOCOL;
+    }
+    return JSON_SUBPROTOCOL;
 }
 export function selectSubprotocol(offered, supported) {
     const admitted = admitSupportedCodecs(supported);
@@ -27,4 +26,3 @@ export function selectSubprotocol(offered, supported) {
     }
     return undefined;
 }
-//# sourceMappingURL=subprotocol.js.map

package/dist/issuer/claims.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Private JWT claim of the self credential a durable step's Domain signs for the Kernel: the id of
+ * the Execution the step belongs to. After a consented issuer change, the Kernel accepts the
+ * replaced issuer past its window only for a credential naming an unfinished run of its Domain
+ * that was in flight at that change.
+ */
+export declare const EXECUTION_CLAIM = "execution";

package/dist/issuer/claims.js

@@ -0,0 +1,7 @@
+/**
+ * Private JWT claim of the self credential a durable step's Domain signs for the Kernel: the id of
+ * the Execution the step belongs to. After a consented issuer change, the Kernel accepts the
+ * replaced issuer past its window only for a credential naming an unfinished run of its Domain
+ * that was in flight at that change.
+ */
+export const EXECUTION_CLAIM = 'execution';

package/dist/issuer/configuration.d.ts

@@ -12,4 +12,3 @@ export interface ConfigurationOptions {
 export declare function configuration(issuer: string, algorithms: readonly [string, ...string[]], options?: ConfigurationOptions): Configuration;
 export declare function acceptConfiguration(input: unknown, expectedIssuer?: string): Configuration;
 export declare function acceptAlgorithms(input: unknown): readonly [string, ...string[]];
-//# sourceMappingURL=configuration.d.ts.map

package/dist/issuer/configuration.js

@@ -84,4 +84,3 @@ function deepFreeze(input) {
         deepFreeze(value);
     return Object.freeze(input);
 }
-//# sourceMappingURL=configuration.js.map

package/dist/issuer/error.d.ts

@@ -5,4 +5,3 @@ export declare class DiscoveryError extends Error {
     constructor(code: DiscoveryErrorCode, message: string, options?: ErrorOptions);
 }
 export declare function fail(code: DiscoveryErrorCode, message: string, cause?: unknown): never;
-//# sourceMappingURL=error.d.ts.map

package/dist/issuer/error.js

@@ -9,4 +9,3 @@ export class DiscoveryError extends Error {
 export function fail(code, message, cause) {
     throw new DiscoveryError(code, message, cause === undefined ? undefined : { cause });
 }
-//# sourceMappingURL=error.js.map

package/dist/issuer/exchange.d.ts

@@ -23,4 +23,3 @@ export declare function acceptResponse(input: unknown): Response;
 export declare function acceptErrorResponse(input: unknown): ErrorResponse;
 export declare function acceptHttpRequest(input: HttpRequest): Request;
 export declare function responseHeaders(): Readonly<Record<string, string>>;
-//# sourceMappingURL=exchange.d.ts.map

package/dist/issuer/exchange.js

@@ -127,4 +127,3 @@ function nonEmptyText(input, label) {
     }
     return input;
 }
-//# sourceMappingURL=exchange.js.map

package/dist/issuer/hosted.d.ts

@@ -1,3 +1,2 @@
 import type { IssuerId } from '@astrale-os/kernel-core/auth/issuer';
 export declare function hosted(base: string, thumbprint: string): IssuerId | undefined;
-//# sourceMappingURL=hosted.d.ts.map

package/dist/issuer/hosted.js

@@ -5,4 +5,3 @@ export function hosted(base, thumbprint) {
         return undefined;
     return acceptIssuer(`${acceptIssuer(base)}/iss/${thumbprint}`);
 }
-//# sourceMappingURL=hosted.js.map

package/dist/issuer/index.d.ts

@@ -1,7 +1,8 @@
+export { EXECUTION_CLAIM } from './claims.js';
 export { acceptConfiguration, configuration, type Configuration, type ConfigurationOptions, } from './configuration.js';
 export { DiscoveryError, type DiscoveryErrorCode } from './error.js';
 export { hosted } from './hosted.js';
 export { acceptKeySet, keySet, type KeySet } from './key-set.js';
 export { paths, type Paths } from './paths.js';
+export { acceptWorkflowEngine, acceptWorkflowEngineIdentityKey, workflowEngine, type WorkflowEngine, } from './workflow-engine.js';
 export * as exchange from './exchange.js';
-//# sourceMappingURL=index.d.ts.map

package/dist/issuer/index.js

@@ -1,7 +1,8 @@
+export { EXECUTION_CLAIM } from './claims.js';
 export { acceptConfiguration, configuration, } from './configuration.js';
 export { DiscoveryError } from './error.js';
 export { hosted } from './hosted.js';
 export { acceptKeySet, keySet } from './key-set.js';
 export { paths } from './paths.js';
+export { acceptWorkflowEngine, acceptWorkflowEngineIdentityKey, workflowEngine, } from './workflow-engine.js';
 export * as exchange from './exchange.js';
-//# sourceMappingURL=index.js.map

package/dist/issuer/key-set.d.ts

@@ -4,4 +4,3 @@ export interface KeySet {
 }
 export declare function keySet(keys: readonly JsonWebKey[], algorithms: readonly [string, ...string[]]): KeySet;
 export declare function acceptKeySet(input: unknown, algorithms: readonly [string, ...string[]]): KeySet;
-//# sourceMappingURL=key-set.d.ts.map

package/dist/issuer/key-set.js

@@ -46,4 +46,3 @@ function deepFreeze(input) {
         deepFreeze(value);
     return Object.freeze(input);
 }
-//# sourceMappingURL=key-set.js.map

package/dist/issuer/paths.d.ts

@@ -2,6 +2,7 @@ export interface Paths {
     readonly configuration: string;
     readonly keys: string;
     readonly tokenExchange: string;
+    /** Where Domains discover the workflow engine of a Kernel that drives one. */
+    readonly workflowEngine: string;
 }
 export declare function paths(issuer: string): Paths;
-//# sourceMappingURL=paths.d.ts.map

package/dist/issuer/paths.js

@@ -6,6 +6,6 @@ export function paths(issuer) {
         configuration: `${pathname}/.well-known/openid-configuration`,
         keys: `${pathname}/.well-known/jwks.json`,
         tokenExchange: `${pathname}/.well-known/astrale/token`,
+        workflowEngine: `${pathname}/.well-known/astrale/workflow-engine.json`,
     });
 }
-//# sourceMappingURL=paths.js.map

package/dist/issuer/url.d.ts

@@ -1,3 +1,2 @@
 import { type IssuerId } from '@astrale-os/kernel-core/auth/issuer';
 export declare function acceptIssuer(input: unknown): IssuerId;
-//# sourceMappingURL=url.d.ts.map

package/dist/issuer/url.js

@@ -32,4 +32,3 @@ export function acceptIssuer(input) {
         throw cause;
     }
 }
-//# sourceMappingURL=url.js.map