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

package/dist/issuer/workflow-engine.js

@@ -0,0 +1,59 @@
+import { fail } from './error.js';
+import { acceptIssuer } from './url.js';
+/** Restate's `publickeyv1_` id: base58btc of a raw Ed25519 public key. */
+const IDENTITY_KEY = /^publickeyv1_[1-9A-HJ-NP-Za-km-z]{32,64}$/u;
+const BASE58 = '123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz';
+const MAXIMUM_IDENTITY_KEYS = 8;
+/** Admit one Restate request identity key without imposing a key-set policy. */
+export function acceptWorkflowEngineIdentityKey(input) {
+    if (typeof input !== 'string' || !IDENTITY_KEY.test(input) || decodedKeyBytes(input) !== 32) {
+        fail('ISSUER_DISCOVERY_INVALID', 'Workflow engine identity keys are invalid.');
+    }
+    return input;
+}
+export function workflowEngine(issuer, identityKeys) {
+    return Object.freeze({
+        issuer: acceptIssuer(issuer),
+        identity_keys: acceptIdentityKeys(identityKeys),
+    });
+}
+/**
+ * Admit a discovered engine for the expected issuer. Unlike issuer configuration, unknown fields are
+ * ignored: the Kernel may add some without breaking deployed Domains.
+ */
+export function acceptWorkflowEngine(input, expectedIssuer) {
+    if (input === null || typeof input !== 'object' || Array.isArray(input)) {
+        fail('ISSUER_DISCOVERY_INVALID', 'Workflow engine discovery is invalid.');
+    }
+    const value = input;
+    const admitted = acceptIssuer(value.issuer);
+    if (expectedIssuer !== undefined && admitted !== acceptIssuer(expectedIssuer)) {
+        fail('ISSUER_DISCOVERY_MISMATCH', 'Workflow engine discovery does not match the issuer.');
+    }
+    return Object.freeze({ issuer: admitted, identity_keys: acceptIdentityKeys(value.identity_keys) });
+}
+function acceptIdentityKeys(input) {
+    if (!Array.isArray(input) ||
+        input.length === 0 ||
+        input.length > MAXIMUM_IDENTITY_KEYS ||
+        new Set(input).size !== input.length) {
+        fail('ISSUER_DISCOVERY_INVALID', 'Workflow engine identity keys are invalid.');
+    }
+    return Object.freeze(Array.from(input, acceptWorkflowEngineIdentityKey));
+}
+/** Base58 leading '1' digits represent zero bytes omitted by the integer value. */
+function decodedKeyBytes(key) {
+    const encoded = key.slice('publickeyv1_'.length);
+    let value = 0n;
+    for (const digit of encoded)
+        value = value * 58n + BigInt(BASE58.indexOf(digit));
+    let bytes = 0;
+    for (; value > 0n; value >>= 8n)
+        bytes++;
+    for (const digit of encoded) {
+        if (digit !== '1')
+            break;
+        bytes++;
+    }
+    return bytes;
+}

package/dist/{publication → release}/bindings/callable.d.ts

@@ -6,4 +6,3 @@ export interface CallableBinding {
 }
 export declare function admitCallableBinding(input: unknown, origin: string): CallableBinding;
 export declare function admitCallableKey(input: unknown, origin: string): Key.Callable;
-//# sourceMappingURL=callable.d.ts.map

package/dist/release/bindings/callable.js

@@ -0,0 +1,34 @@
+import { callableAddress, Key } from '@astrale-os/kernel-dsl/v1/addressing';
+import { fail } from '../error.js';
+import { exact, record } from '../shape.js';
+import { acceptInvocationEndpoints } from './invocation.js';
+export function admitCallableBinding(input, origin) {
+    const value = record(input, 'RELEASE_BINDING_INVALID', 'Callable binding is invalid.');
+    exact(value, ['callable', 'endpoint'], 'RELEASE_BINDING_INVALID');
+    return Object.freeze({
+        callable: admitCallableKey(value.callable, origin),
+        endpoint: acceptInvocationEndpoints(value.endpoint),
+    });
+}
+export function admitCallableKey(input, origin) {
+    let callable;
+    try {
+        callable = Key(String(input));
+    }
+    catch (cause) {
+        if (cause instanceof TypeError) {
+            return fail('RELEASE_BINDING_INVALID', 'Callable key is invalid.', cause);
+        }
+        throw cause;
+    }
+    if (Key.origin(callable) !== origin) {
+        fail('RELEASE_BINDING_INVALID', 'Binding must name one callable owned by the root Domain.');
+    }
+    try {
+        callableAddress(callable);
+    }
+    catch (cause) {
+        return fail('RELEASE_BINDING_INVALID', 'Binding must name one callable owned by the root Domain.', cause);
+    }
+    return callable;
+}

package/dist/{publication → release}/bindings/index.d.ts

@@ -1,4 +1,3 @@
 export { admitCallableBinding, admitCallableKey, type CallableBinding } from './callable.js';
 export { acceptInvocationEndpoints, type InvocationEndpoints } from './invocation.js';
-export { admitViewBinding, type ViewBinding } from './view.js';
-//# sourceMappingURL=index.d.ts.map
+export { admitViewBinding, type IframeRequirements, type ViewBinding } from './view.js';

package/dist/{publication → release}/bindings/index.js

@@ -1,4 +1,3 @@
 export { admitCallableBinding, admitCallableKey } from './callable.js';
 export { acceptInvocationEndpoints } from './invocation.js';
 export { admitViewBinding } from './view.js';
-//# sourceMappingURL=index.js.map

package/dist/{publication → release}/bindings/invocation.d.ts

@@ -3,4 +3,3 @@ export interface InvocationEndpoints {
     readonly websocket?: string;
 }
 export declare function acceptInvocationEndpoints(input: unknown): InvocationEndpoints;
-//# sourceMappingURL=invocation.d.ts.map

package/dist/release/bindings/invocation.js

@@ -0,0 +1,13 @@
+import { absoluteHttpUrl, absoluteUrl, exact, record } from '../shape.js';
+export function acceptInvocationEndpoints(input) {
+    const value = record(input, 'RELEASE_BINDING_INVALID', 'Invocation endpoints are invalid.');
+    exact(value, ['http', 'websocket'], 'RELEASE_BINDING_INVALID');
+    const http = absoluteHttpUrl(value.http, true, 'RELEASE_BINDING_INVALID');
+    const websocket = value.websocket === undefined
+        ? undefined
+        : absoluteUrl(value.websocket, ['ws:', 'wss:'], true, 'RELEASE_BINDING_INVALID');
+    return Object.freeze({
+        http,
+        ...(websocket === undefined ? {} : { websocket }),
+    });
+}

package/dist/release/bindings/view.d.ts

@@ -0,0 +1,16 @@
+import { type ViewHostRequirements } from '@astrale-os/kernel-core/schema/kernel/syscalls/view-resolution';
+import { Key } from '@astrale-os/kernel-dsl/v1/addressing';
+export interface ViewBinding {
+    readonly view: Key.View;
+    readonly href: string;
+    readonly handshake: 'shell' | 'none';
+    readonly iframe?: IframeRequirements;
+    readonly host?: ViewHostRequirements;
+}
+export interface IframeRequirements {
+    readonly sandbox?: readonly string[];
+    readonly allow?: readonly string[];
+}
+export declare function admitViewBinding(input: unknown, origin: string): ViewBinding;
+/** Authoring-only normalization used before a release document is sealed. */
+export declare function canonicalizeViewBinding(input: unknown, origin: string): ViewBinding;

package/dist/release/bindings/view.js

@@ -0,0 +1,148 @@
+import { acceptViewHostRequirements, } from '@astrale-os/kernel-core/schema/kernel/syscalls/view-resolution';
+import { Key } from '@astrale-os/kernel-dsl/v1/addressing';
+import { fail } from '../error.js';
+import { absoluteHttpUrl, exact, record } from '../shape.js';
+const TOKEN = /^[a-z][a-z0-9-]*$/u;
+export function admitViewBinding(input, origin) {
+    return readViewBinding(input, origin, false);
+}
+/** Authoring-only normalization used before a release document is sealed. */
+export function canonicalizeViewBinding(input, origin) {
+    return readViewBinding(input, origin, true);
+}
+function readViewBinding(input, origin, canonicalize) {
+    const value = record(input, 'RELEASE_VIEW_INVALID', 'Release View binding is invalid.');
+    exact(value, ['view', 'href', 'handshake', 'iframe', 'host'], 'RELEASE_VIEW_INVALID');
+    let view;
+    try {
+        view = Key(String(value.view));
+    }
+    catch (cause) {
+        if (cause instanceof TypeError) {
+            return fail('RELEASE_VIEW_INVALID', 'View key is invalid.', cause);
+        }
+        throw cause;
+    }
+    if (Key.origin(view) !== origin || !view.slice(view.indexOf(':') + 1).startsWith('view.')) {
+        fail('RELEASE_VIEW_INVALID', 'View binding must name a root View.');
+    }
+    if (value.handshake !== 'shell' && value.handshake !== 'none') {
+        fail('RELEASE_VIEW_INVALID', 'View handshake is invalid.');
+    }
+    const iframe = admitIframeRequirements(dataValue(value, 'iframe'), value.handshake, canonicalize);
+    let host;
+    try {
+        host = acceptViewHostRequirements(dataValue(value, 'host'), value.handshake, canonicalize);
+    }
+    catch (cause) {
+        if (cause instanceof TypeError)
+            return fail('RELEASE_VIEW_INVALID', 'View host requirements are invalid.', cause);
+        throw cause;
+    }
+    return Object.freeze({
+        view,
+        href: absoluteHttpUrl(value.href, true, 'RELEASE_VIEW_INVALID'),
+        handshake: value.handshake,
+        ...(iframe === undefined ? {} : { iframe }),
+        ...(host === undefined ? {} : { host }),
+    });
+}
+function admitIframeRequirements(input, handshake, canonicalize) {
+    if (input === undefined)
+        return undefined;
+    const value = plainRecord(input);
+    exactOwnKeys(value, ['sandbox', 'allow']);
+    if (!canonicalize && (!Object.hasOwn(value, 'sandbox') || !Object.hasOwn(value, 'allow'))) {
+        invalid();
+    }
+    const sandbox = tokens(dataValue(value, 'sandbox'), canonicalize);
+    const allow = tokens(dataValue(value, 'allow'), canonicalize);
+    assertRelationships(sandbox);
+    const baselineSandbox = handshake === 'shell' ? ['allow-same-origin', 'allow-scripts'] : ['allow-scripts'];
+    const baselineAllow = handshake === 'shell' ? ['clipboard-write'] : [];
+    if (!canonicalize &&
+        (sandbox.some((token) => baselineSandbox.includes(token)) ||
+            allow.some((feature) => baselineAllow.includes(feature)))) {
+        invalid();
+    }
+    const canonicalSandbox = canonicalize
+        ? sandbox.filter((token) => !baselineSandbox.includes(token))
+        : sandbox;
+    const canonicalAllow = canonicalize
+        ? allow.filter((feature) => !baselineAllow.includes(feature))
+        : allow;
+    if (!canonicalize && canonicalSandbox.length === 0 && canonicalAllow.length === 0)
+        invalid();
+    if (canonicalSandbox.length === 0 && canonicalAllow.length === 0)
+        return undefined;
+    return Object.freeze({
+        sandbox: Object.freeze(canonicalSandbox),
+        allow: Object.freeze(canonicalAllow),
+    });
+}
+function plainRecord(input) {
+    if (input === null || typeof input !== 'object' || Array.isArray(input))
+        invalid();
+    const prototype = Object.getPrototypeOf(input);
+    if (prototype !== Object.prototype && prototype !== null)
+        invalid();
+    return input;
+}
+function exactOwnKeys(input, allowed) {
+    const keys = new Set(allowed);
+    if (Reflect.ownKeys(input).some((key) => typeof key !== 'string' || !keys.has(key)))
+        invalid();
+}
+function dataValue(input, key) {
+    const descriptor = Object.getOwnPropertyDescriptor(input, key);
+    if (descriptor === undefined)
+        return undefined;
+    if (!('value' in descriptor))
+        invalid();
+    return descriptor.value;
+}
+function tokens(input, canonicalize) {
+    if (input === undefined)
+        return [];
+    if (!Array.isArray(input))
+        invalid();
+    const descriptors = Object.getOwnPropertyDescriptors(input);
+    const values = [];
+    for (let index = 0; index < input.length; index += 1) {
+        const descriptor = descriptors[String(index)];
+        if (descriptor === undefined || !('value' in descriptor))
+            invalid();
+        if (typeof descriptor.value !== 'string' || !TOKEN.test(descriptor.value))
+            invalid();
+        values.push(descriptor.value);
+    }
+    for (const key of Reflect.ownKeys(descriptors)) {
+        if (key === 'length')
+            continue;
+        if (typeof key !== 'string' || !/^(0|[1-9][0-9]*)$/u.test(key) || Number(key) >= input.length) {
+            invalid();
+        }
+    }
+    if (canonicalize)
+        return [...new Set(values)].sort();
+    for (let index = 1; index < values.length; index += 1) {
+        if (values[index - 1] >= values[index])
+            invalid();
+    }
+    return values;
+}
+function assertRelationships(sandbox) {
+    const tokens = new Set(sandbox);
+    if (tokens.has('allow-popups-to-escape-sandbox') && !tokens.has('allow-popups'))
+        invalid();
+    if (tokens.has('allow-top-navigation') && tokens.has('allow-top-navigation-by-user-activation')) {
+        invalid();
+    }
+    if (tokens.has('allow-top-navigation-to-custom-protocols') &&
+        (tokens.has('allow-top-navigation') || tokens.has('allow-popups'))) {
+        invalid();
+    }
+}
+function invalid() {
+    return fail('RELEASE_VIEW_INVALID', 'View iframe requirements are invalid.');
+}

package/dist/release/build.d.ts

@@ -0,0 +1,6 @@
+import type { BuildDigest } from './digest.js';
+/** Identity of the code a release runs: the digest of the bytes its build produced. */
+export interface Build {
+    readonly digest: BuildDigest;
+}
+export declare function admitBuild(input: unknown): Build;

package/dist/release/build.js

@@ -0,0 +1,7 @@
+import { admitDigest } from './digest.js';
+import { exact, record } from './shape.js';
+export function admitBuild(input) {
+    const value = record(input, 'RELEASE_INVALID', 'Release build is invalid.');
+    exact(value, ['digest'], 'RELEASE_INVALID');
+    return Object.freeze({ digest: admitDigest(value.digest) });
+}

package/dist/release/bundle-admission.d.ts

@@ -0,0 +1,21 @@
+import { Key } from '@astrale-os/kernel-dsl/v1/addressing';
+import * as dslBundle from '@astrale-os/kernel-dsl/v1/bundle';
+import type { CallableBinding, ViewBinding } from './bindings/index.js';
+import type { Manifest } from './manifest.js';
+import type { Requirements } from './requirements.js';
+import type { HttpRoute } from './route.js';
+import type { Schema } from './schema.js';
+/** The served release content one external Schema Bundle must exactly match. */
+export interface ServedRelease {
+    readonly origin: Key.Origin;
+    readonly schema: Schema;
+    readonly requirements: Requirements;
+    readonly manifest?: Manifest;
+    readonly bindings: {
+        readonly callables: readonly CallableBinding[];
+        readonly views: readonly ViewBinding[];
+    };
+    readonly routes: readonly HttpRoute[];
+}
+export declare function acceptBundle(input: ServedRelease, artifact: unknown): dslBundle.Bundle;
+export declare function decodeBundle(input: ServedRelease, bytes: Uint8Array): dslBundle.Bundle;

package/dist/release/bundle-admission.js

@@ -0,0 +1,66 @@
+import { Key, MethodKey } from '@astrale-os/kernel-dsl/v1/addressing';
+import * as dslBundle from '@astrale-os/kernel-dsl/v1/bundle';
+import { isMethodExecutable } from '@astrale-os/kernel-dsl/v1/language';
+import { revision } from '@astrale-os/kernel-dsl/v1/schema/revision';
+import { acceptBundleValue, decodeBundleValue, verifyBundleBytes } from './bundle.js';
+import { fail } from './error.js';
+import { validateRequirements } from './requirements.js';
+export function acceptBundle(input, artifact) {
+    const accepted = acceptBundleValue(artifact);
+    verifyBundleBytes(input, dslBundle.encode(accepted));
+    validateInventory(input, accepted);
+    return accepted;
+}
+export function decodeBundle(input, bytes) {
+    const decoded = decodeBundleValue(input, bytes);
+    validateInventory(input, decoded);
+    return decoded;
+}
+function validateInventory(release, bundle) {
+    const root = bundle.root;
+    if (root.origin !== release.origin || revision(root) !== release.schema.revision) {
+        fail('RELEASE_INVALID', 'Bundle root does not match the release schema.');
+    }
+    validateRequirements(root, bundle.closure, release.requirements);
+    const callables = concreteCallables(root);
+    const boundCallables = new Set(release.bindings.callables.map(({ callable }) => callable));
+    if (boundCallables.size !== callables.size ||
+        [...callables].some((key) => !boundCallables.has(key))) {
+        fail('RELEASE_BINDING_INVALID', 'Callable bindings must exhaust the root Domain.');
+    }
+    const views = new Set(Object.keys(root.views).map((name) => Key.of({ origin: root.origin, kind: 'view', name })));
+    const boundViews = new Set(release.bindings.views.map(({ view }) => view));
+    if (boundViews.size !== views.size || [...views].some((key) => !boundViews.has(key))) {
+        fail('RELEASE_VIEW_INVALID', 'View bindings must exhaust the root Domain.');
+    }
+    if (release.manifest?.entrypoint !== undefined &&
+        (release.manifest.entrypoint.origin !== root.origin ||
+            release.manifest.entrypoint.kind !== 'view' ||
+            root.views[release.manifest.entrypoint.name] === undefined)) {
+        fail('RELEASE_INVALID', 'Manifest entrypoint does not exist in the root schema.');
+    }
+    for (const route of release.routes) {
+        if (!callables.has(route.callable)) {
+            fail('RELEASE_ROUTE_INVALID', `Route ${route.name} names an unknown callable.`);
+        }
+    }
+}
+function concreteCallables(root) {
+    const result = new Set();
+    for (const name of Object.keys(root.functions)) {
+        result.add(Key.of({ origin: root.origin, kind: 'function', name }));
+    }
+    addClassMethods(result, root.origin, root.classes);
+    return result;
+}
+function addClassMethods(result, origin, definitions) {
+    for (const [owner, declaration] of Object.entries(definitions)) {
+        if (declaration.kind !== 'node')
+            continue;
+        for (const [name, method] of Object.entries(declaration.methods)) {
+            if (!isMethodExecutable(declaration, method))
+                continue;
+            result.add(MethodKey.of({ origin, kind: 'class', name: owner }, name));
+        }
+    }
+}

package/dist/{publication → release}/bundle-descriptor.d.ts

@@ -7,4 +7,3 @@ export interface BundleDescriptor {
     };
 }
 export declare function admitBundleDescriptor(input: unknown): BundleDescriptor;
-//# sourceMappingURL=bundle-descriptor.d.ts.map

package/dist/release/bundle-descriptor.js

@@ -0,0 +1,19 @@
+import * as artifact from '../artifact/index.js';
+import { fail } from './error.js';
+import { absoluteHttpUrl, exact, record } from './shape.js';
+export const BUNDLE_MEDIA_TYPE = 'application/vnd.astrale.domain-bundle+json;v=1';
+export function admitBundleDescriptor(input) {
+    const value = record(input, 'RELEASE_INVALID', 'Bundle descriptor is invalid.');
+    exact(value, ['href', 'ref'], 'RELEASE_INVALID');
+    const ref = artifact.accept(value.ref);
+    if (ref.mediaType !== BUNDLE_MEDIA_TYPE) {
+        fail('RELEASE_INVALID', 'Bundle media type is unsupported.');
+    }
+    if (ref.size < 1) {
+        fail('RELEASE_INVALID', 'Bundle size is invalid.');
+    }
+    return Object.freeze({
+        href: absoluteHttpUrl(value.href, true, 'RELEASE_INVALID'),
+        ref: Object.freeze({ ...ref, mediaType: BUNDLE_MEDIA_TYPE }),
+    });
+}

package/dist/release/bundle-evidence.d.ts

@@ -0,0 +1,3 @@
+import type { ServedRelease } from './bundle-admission.js';
+/** Verify exact artifact bytes without decoding an authored Schema Bundle. */
+export declare function verifyBundleBytes(release: Pick<ServedRelease, 'schema'>, bytes: Uint8Array): void;

package/dist/release/bundle-evidence.js

@@ -0,0 +1,13 @@
+import { sha256Hex } from './digest.js';
+import { fail } from './error.js';
+/** Verify exact artifact bytes without decoding an authored Schema Bundle. */
+export function verifyBundleBytes(release, bytes) {
+    if (!(bytes instanceof Uint8Array)) {
+        fail('RELEASE_INVALID', 'Bundle artifact bytes are invalid.');
+    }
+    const descriptor = release.schema.bundle;
+    if (bytes.byteLength !== descriptor.ref.size ||
+        `sha256:${sha256Hex(bytes)}` !== descriptor.ref.digest) {
+        fail('RELEASE_INVALID', 'Bundle artifact does not match its descriptor.');
+    }
+}

package/dist/release/bundle.d.ts

@@ -0,0 +1,12 @@
+import * as bundle from '@astrale-os/kernel-dsl/v1/bundle/transport';
+import type { ServedRelease } from './bundle-admission.js';
+import type { BundleDescriptor } from './bundle-descriptor.js';
+import * as artifact from '../artifact/index.js';
+import { verifyBundleBytes } from './bundle-evidence.js';
+/** Resolve immutable bundle bytes beneath the exact serving issuer. */
+export declare function bundleUrl(issuer: string, ref: artifact.Ref): string;
+export declare function describeBundle(input: bundle.Bundle, href: string): BundleDescriptor;
+export declare function acceptBundleValue(input: unknown): bundle.Bundle;
+export declare function decodeBundleValue(release: Pick<ServedRelease, 'schema'>, bytes: Uint8Array): bundle.Bundle;
+export { verifyBundleBytes };
+export { admitBundleDescriptor, BUNDLE_MEDIA_TYPE, type BundleDescriptor, } from './bundle-descriptor.js';

package/dist/{publication → release}/bundle.js

@@ -1,13 +1,19 @@
-import { bundle, schema } from '@astrale-os/kernel-dsl/v1';
+import * as bundle from '@astrale-os/kernel-dsl/v1/bundle/transport';
 import * as artifact from '../artifact/index.js';
 import { BUNDLE_MEDIA_TYPE } from './bundle-descriptor.js';
 import { verifyBundleBytes } from './bundle-evidence.js';
-import { absoluteHttpUrl } from './content.js';
 import { fail } from './error.js';
+import { servedUrl } from './issuer.js';
+import { absoluteHttpUrl } from './shape.js';
+/** Resolve immutable bundle bytes beneath the exact serving issuer. */
+export function bundleUrl(issuer, ref) {
+    const digest = ref.digest.slice('sha256:'.length);
+    return servedUrl(issuer, `/.well-known/astrale/bundles/sha256/${digest}.json`);
+}
 export function describeBundle(input, href) {
     const bytes = bundle.encode(input);
     return Object.freeze({
-        href: absoluteHttpUrl(href, true, 'PUBLICATION_INVALID'),
+        href: absoluteHttpUrl(href, true, 'RELEASE_INVALID'),
         ref: Object.freeze({
             ...artifact.identify(bytes, BUNDLE_MEDIA_TYPE),
             mediaType: BUNDLE_MEDIA_TYPE,
@@ -19,27 +25,26 @@ export function acceptBundleValue(input) {
         return bundle.accept(input);
     }
     catch (cause) {
-        if (cause instanceof schema.Error) {
-            return fail('PUBLICATION_INVALID', 'Publication bundle is invalid.', cause);
+        if (cause instanceof bundle.Error) {
+            return fail('RELEASE_INVALID', 'Release bundle is invalid.', cause);
         }
         throw cause;
     }
 }
-export function decodeBundleValue(publication, bytes) {
+export function decodeBundleValue(release, bytes) {
     if (!(bytes instanceof Uint8Array)) {
-        fail('PUBLICATION_INVALID', 'Bundle artifact bytes are invalid.');
+        fail('RELEASE_INVALID', 'Bundle artifact bytes are invalid.');
     }
-    verifyBundleBytes(publication, bytes);
+    verifyBundleBytes(release, bytes);
     try {
         return bundle.decode(bytes);
     }
     catch (cause) {
-        if (cause instanceof schema.Error) {
-            return fail('PUBLICATION_INVALID', 'Bundle artifact cannot be decoded.', cause);
+        if (cause instanceof bundle.Error) {
+            return fail('RELEASE_INVALID', 'Bundle artifact cannot be decoded.', cause);
         }
         throw cause;
     }
 }
 export { verifyBundleBytes };
 export { admitBundleDescriptor, BUNDLE_MEDIA_TYPE, } from './bundle-descriptor.js';
-//# sourceMappingURL=bundle.js.map

package/dist/{publication → release}/declaration.d.ts

@@ -9,4 +9,3 @@ export interface Declaration {
     readonly routes: readonly HttpRouteDeclaration[];
     readonly delivery?: DeliveryDeclaration;
 }
-//# sourceMappingURL=declaration.d.ts.map

package/dist/release/declaration.js

@@ -0,0 +1 @@
+export {};

package/dist/{publication → release}/delivery/attestation.d.ts

@@ -1,7 +1,7 @@
 declare const ATTESTATION: unique symbol;
+/** Opaque, bounded attestation text a Delivery carries; Core Auth verifies it. */
 export type Attestation = string & {
     readonly [ATTESTATION]: true;
 };
 export declare function acceptAttestation(input: unknown): Attestation;
 export {};
-//# sourceMappingURL=attestation.d.ts.map

package/dist/{publication → release}/delivery/attestation.js

@@ -8,4 +8,3 @@ export function acceptAttestation(input) {
     }
     return input;
 }
-//# sourceMappingURL=attestation.js.map

package/dist/release/delivery/claims.d.ts

@@ -0,0 +1,21 @@
+import type { Subject } from '@astrale-os/kernel-core/auth/identity';
+import type { Revision } from '@astrale-os/kernel-dsl/v1/addressing';
+import { type IssuerId } from '@astrale-os/kernel-core/auth/issuer';
+import type { ReleaseDigest } from '../digest.js';
+import { PURPOSE } from './limits.js';
+/**
+ * What a verified Delivery v2 attestation asserts: the serving Domain identity delivers the release
+ * with this digest and schema revision to the requesting Kernel, for its challenge nonce.
+ */
+export interface Claims {
+    readonly purpose: typeof PURPOSE;
+    readonly iss: IssuerId;
+    readonly sub: Subject;
+    readonly aud: IssuerId;
+    readonly nonce: string;
+    readonly release: ReleaseDigest;
+    readonly schemaRevision: Revision;
+    readonly exp: number;
+}
+/** Admit the claims of an attestation Core Auth already verified. */
+export declare function acceptClaims(input: unknown): Claims;

package/dist/release/delivery/claims.js

@@ -0,0 +1,68 @@
+import { AuthValueError } from '@astrale-os/kernel-core/auth/error';
+import { accept as acceptIssuerId } from '@astrale-os/kernel-core/auth/issuer';
+import { patterns } from '@astrale-os/kernel-dsl/v1/addressing';
+import { deepFreeze } from '../shape.js';
+import { fail } from './error.js';
+import { NONCE_MAX_LENGTH, NONCE_MIN_LENGTH, PURPOSE } from './limits.js';
+const FIELDS = [
+    'purpose',
+    'iss',
+    'sub',
+    'aud',
+    'nonce',
+    'release',
+    'schemaRevision',
+    'exp',
+];
+/** Admit the claims of an attestation Core Auth already verified. */
+export function acceptClaims(input) {
+    if (input === null || typeof input !== 'object' || Array.isArray(input)) {
+        fail('DELIVERY_CLAIMS_INVALID', 'Expected delivery claims.');
+    }
+    const value = input;
+    if (Object.keys(value).some((field) => !FIELDS.includes(field))) {
+        fail('DELIVERY_CLAIMS_INVALID', 'Delivery claims contain unknown fields.');
+    }
+    if (value.purpose !== PURPOSE ||
+        typeof value.sub !== 'string' ||
+        value.sub.length === 0 ||
+        typeof value.nonce !== 'string' ||
+        value.nonce.length < NONCE_MIN_LENGTH ||
+        value.nonce.length > NONCE_MAX_LENGTH ||
+        typeof value.exp !== 'number' ||
+        !Number.isSafeInteger(value.exp)) {
+        fail('DELIVERY_CLAIMS_INVALID', 'Delivery claims are invalid.');
+    }
+    const iss = acceptIssuer(value.iss);
+    const aud = acceptIssuer(value.aud);
+    if (typeof value.release !== 'string' || !/^sha256:[0-9a-f]{64}$/u.test(value.release)) {
+        fail('DELIVERY_CLAIMS_INVALID', 'Delivery claims release digest is invalid.');
+    }
+    if (typeof value.schemaRevision !== 'string' || !patterns.revision.test(value.schemaRevision)) {
+        fail('DELIVERY_CLAIMS_INVALID', 'Schema revision is invalid.');
+    }
+    return deepFreeze({
+        purpose: PURPOSE,
+        iss,
+        sub: value.sub,
+        aud,
+        nonce: value.nonce,
+        release: value.release,
+        schemaRevision: value.schemaRevision,
+        exp: value.exp,
+    });
+}
+function acceptIssuer(input) {
+    if (typeof input !== 'string') {
+        fail('DELIVERY_CLAIMS_INVALID', 'Delivery claims issuer is invalid.');
+    }
+    try {
+        return acceptIssuerId(input);
+    }
+    catch (cause) {
+        if (cause instanceof AuthValueError) {
+            return fail('DELIVERY_CLAIMS_INVALID', 'Delivery claims issuer is invalid.', cause);
+        }
+        throw cause;
+    }
+}

package/dist/release/delivery/delivery.d.ts

@@ -0,0 +1,11 @@
+import type { DomainRelease } from '../release.js';
+import type { Attestation } from './attestation.js';
+/** The challenge-bound envelope carrying the exact `DomainRelease` a Kernel asked for. */
+export interface Delivery {
+    readonly format: 'astrale.domain.delivery';
+    readonly version: 2;
+    readonly release: DomainRelease;
+    readonly attestation: Attestation;
+}
+/** Admit one Delivery v2 envelope: its release is admitted whole, its attestation stays opaque. */
+export declare function accept(input: unknown): Delivery;