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

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/{publication → release}/bundle-admission.js

@@ -1,5 +1,6 @@
 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';
@@ -15,32 +16,26 @@ export function decodeBundle(input, bytes) {
     validateInventory(input, decoded);
     return decoded;
 }
-function validateInventory(publication, bundle) {
+function validateInventory(release, bundle) {
     const root = bundle.root;
-    if (root.origin !== publication.origin || revision(root) !== publication.schema.revision) {
-        fail('PUBLICATION_INVALID', 'Bundle root does not match the Publication schema.');
+    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, publication.requirements);
+    validateRequirements(root, bundle.closure, release.requirements);
     const callables = concreteCallables(root);
-    const publishedCallables = new Set(publication.bindings.callables.map(({ callable }) => callable));
-    if (publishedCallables.size !== callables.size ||
-        [...callables].some((key) => !publishedCallables.has(key))) {
-        fail('PUBLICATION_BINDING_INVALID', 'Callable bindings must exhaust the root Domain.');
+    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 publishedViews = new Set(publication.bindings.views.map(({ view }) => view));
-    if (publishedViews.size !== views.size || [...views].some((key) => !publishedViews.has(key))) {
-        fail('PUBLICATION_VIEW_INVALID', 'View bindings must exhaust the root Domain.');
+    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 (publication.manifest?.entrypoint !== undefined &&
-        (publication.manifest.entrypoint.origin !== root.origin ||
-            publication.manifest.entrypoint.kind !== 'view' ||
-            root.views[publication.manifest.entrypoint.name] === undefined)) {
-        fail('PUBLICATION_INVALID', 'Manifest entrypoint does not exist in the root schema.');
-    }
-    for (const route of publication.routes) {
+    for (const route of release.routes) {
         if (!callables.has(route.callable)) {
-            fail('PUBLICATION_ROUTE_INVALID', `Route ${route.name} names an unknown callable.`);
+            fail('RELEASE_ROUTE_INVALID', `Route ${route.name} names an unknown callable.`);
         }
     }
 }
@@ -57,10 +52,9 @@ function addClassMethods(result, origin, definitions) {
         if (declaration.kind !== 'node')
             continue;
         for (const [name, method] of Object.entries(declaration.methods)) {
-            if (method.inheritance === 'abstract')
+            if (!isMethodExecutable(declaration, method))
                 continue;
             result.add(MethodKey.of({ origin, kind: 'class', name: owner }, name));
         }
     }
 }
-//# sourceMappingURL=bundle-admission.js.map

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/{publication → release}/bundle.d.ts

@@ -1,10 +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 type { Publication } from './publication.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(publication: Publication, bytes: Uint8Array): 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';
-//# sourceMappingURL=bundle.d.ts.map

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

@@ -2,12 +2,18 @@ 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,
@@ -20,26 +26,25 @@ export function acceptBundleValue(input) {
     }
     catch (cause) {
         if (cause instanceof bundle.Error) {
-            return fail('PUBLICATION_INVALID', 'Publication bundle is invalid.', cause);
+            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 bundle.Error) {
-            return fail('PUBLICATION_INVALID', 'Bundle artifact cannot be decoded.', cause);
+            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/{publication → release}/delivery/claims.d.ts

@@ -1,17 +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 { Etag } from '../etag.js';
+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 etag: Etag;
+    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;
-//# sourceMappingURL=claims.d.ts.map

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

@@ -1,15 +1,26 @@
 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;
-    const expected = ['purpose', 'iss', 'sub', 'aud', 'nonce', 'etag', 'schemaRevision', 'exp'];
-    if (Object.keys(value).some((field) => !expected.includes(field))) {
+    if (Object.keys(value).some((field) => !FIELDS.includes(field))) {
         fail('DELIVERY_CLAIMS_INVALID', 'Delivery claims contain unknown fields.');
     }
     if (value.purpose !== PURPOSE ||
@@ -24,8 +35,8 @@ export function acceptClaims(input) {
     }
     const iss = acceptIssuer(value.iss);
     const aud = acceptIssuer(value.aud);
-    if (typeof value.etag !== 'string' || !/^sha256:[0-9a-f]{64}$/u.test(value.etag)) {
-        fail('DELIVERY_CLAIMS_INVALID', 'Delivery claims ETag is invalid.');
+    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.');
@@ -36,14 +47,17 @@ export function acceptClaims(input) {
         sub: value.sub,
         aud,
         nonce: value.nonce,
-        etag: value.etag,
+        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(String(input));
+        return acceptIssuerId(input);
     }
     catch (cause) {
         if (cause instanceof AuthValueError) {
@@ -52,11 +66,3 @@ function acceptIssuer(input) {
         throw cause;
     }
 }
-function deepFreeze(value) {
-    if (value === null || typeof value !== 'object' || Object.isFrozen(value))
-        return value;
-    for (const nested of Object.values(value))
-        deepFreeze(nested);
-    return Object.freeze(value);
-}
-//# sourceMappingURL=claims.js.map

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;

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

@@ -1,30 +1,24 @@
-import { accept as acceptPublication } from '../publication.js';
+import { accept as acceptRelease } from '../release.js';
+import { deepFreeze } from '../shape.js';
 import { acceptAttestation } from './attestation.js';
 import { fail } from './error.js';
+/** Admit one Delivery v2 envelope: its release is admitted whole, its attestation stays opaque. */
 export function accept(input) {
     if (input === null || typeof input !== 'object' || Array.isArray(input)) {
         fail('DELIVERY_INVALID', 'Expected a Delivery object.');
     }
     const value = input;
-    const expected = new Set(['format', 'version', 'publication', 'attestation']);
+    const expected = new Set(['format', 'version', 'release', 'attestation']);
     if (Object.keys(value).some((field) => !expected.has(field))) {
         fail('DELIVERY_INVALID', 'Delivery contains unknown fields.');
     }
-    if (value.format !== 'astrale.domain.delivery' || value.version !== 1) {
+    if (value.format !== 'astrale.domain.delivery' || value.version !== 2) {
         fail('DELIVERY_INVALID', 'Unsupported Delivery format or version.');
     }
     return deepFreeze({
         format: 'astrale.domain.delivery',
-        version: 1,
-        publication: acceptPublication(value.publication),
+        version: 2,
+        release: acceptRelease(value.release),
         attestation: acceptAttestation(value.attestation),
     });
 }
-function deepFreeze(value) {
-    if (value === null || typeof value !== 'object' || Object.isFrozen(value))
-        return value;
-    for (const nested of Object.values(value))
-        deepFreeze(nested);
-    return Object.freeze(value);
-}
-//# sourceMappingURL=delivery.js.map

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

@@ -1,8 +1,9 @@
+/** Failure code of a Delivery request, envelope, or claims set, whatever its version. */
 export type DeliveryErrorCode = 'DELIVERY_INVALID' | 'DELIVERY_REQUEST_INVALID' | 'DELIVERY_CLAIMS_INVALID';
+/** Reported by every Delivery decoder, v1 and v2. */
 export declare class DeliveryError extends Error {
     readonly code: DeliveryErrorCode;
     readonly name = "DeliveryError";
     constructor(code: DeliveryErrorCode, message: string, options?: ErrorOptions);
 }
 export declare function fail(code: DeliveryErrorCode, message: string, cause?: unknown): never;
-//# sourceMappingURL=error.d.ts.map

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

@@ -1,3 +1,4 @@
+/** Reported by every Delivery decoder, v1 and v2. */
 export class DeliveryError extends Error {
     code;
     name = 'DeliveryError';
@@ -9,4 +10,3 @@ export class DeliveryError extends Error {
 export function fail(code, message, cause) {
     throw new DeliveryError(code, message, cause === undefined ? undefined : { cause });
 }
-//# sourceMappingURL=error.js.map

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

@@ -1,7 +1,10 @@
+/**
+ * Delivery v2: the challenge-bound envelope carrying the exact `DomainRelease` a Kernel fetched at
+ * `release.json`, bound to its release digest. Only the version 2 request is admitted.
+ */
 export { type Attestation } from './attestation.js';
 export { acceptClaims, type Claims } from './claims.js';
 export { DeliveryError as Error, type DeliveryErrorCode as ErrorCode } from './error.js';
 export { accept, type Delivery } from './delivery.js';
 export { ATTESTATION_MAX_BYTES, NONCE_MAX_LENGTH, NONCE_MIN_LENGTH, PURPOSE } from './limits.js';
-export { acceptRequest, type Token, type Request } from './request.js';
-//# sourceMappingURL=index.d.ts.map
+export { acceptRequest, type Request, type Token } from './request.js';

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

@@ -1,7 +1,10 @@
+/**
+ * Delivery v2: the challenge-bound envelope carrying the exact `DomainRelease` a Kernel fetched at
+ * `release.json`, bound to its release digest. Only the version 2 request is admitted.
+ */
 export {} from './attestation.js';
 export { acceptClaims } from './claims.js';
 export { DeliveryError as Error } from './error.js';
 export { accept } from './delivery.js';
 export { ATTESTATION_MAX_BYTES, NONCE_MAX_LENGTH, NONCE_MIN_LENGTH, PURPOSE } from './limits.js';
 export { acceptRequest } from './request.js';
-//# sourceMappingURL=index.js.map

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

@@ -1,5 +1,5 @@
-export declare const PURPOSE: 'astrale.domain.delivery.v1';
+/** Purpose of Delivery v2 attestations, which bind a release digest. */
+export declare const PURPOSE: 'astrale.domain.delivery.v2';
 export declare const NONCE_MIN_LENGTH = 16;
 export declare const NONCE_MAX_LENGTH = 256;
 export declare const ATTESTATION_MAX_BYTES = 16384;
-//# sourceMappingURL=limits.d.ts.map

package/dist/release/delivery/limits.js

@@ -0,0 +1,5 @@
+/** Purpose of Delivery v2 attestations, which bind a release digest. */
+export const PURPOSE = 'astrale.domain.delivery.v2';
+export const NONCE_MIN_LENGTH = 16;
+export const NONCE_MAX_LENGTH = 256;
+export const ATTESTATION_MAX_BYTES = 16_384;

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

@@ -1,16 +1,16 @@
 import { type IssuerId } from '@astrale-os/kernel-core/auth/issuer';
-import type { Etag } from '../etag.js';
-export interface Request {
-    readonly version: 1;
-    readonly kernel: IssuerId;
-    readonly nonce: string;
-    readonly etag: Etag;
-}
-/** Exact bearer credential admitted by a Delivery transport boundary. */
+import type { ReleaseDigest } from '../digest.js';
+/** Exact bearer credential admitted by a Delivery transport boundary; never inside a document. */
 export interface Token {
     readonly kind: 'bearer';
     readonly token: string;
 }
-/** Admit the exact request representation accepted by a Delivery transport boundary. */
+/** A requesting Kernel's challenge for the one exact release it fetched at `release.json`. */
+export interface Request {
+    readonly version: 2;
+    readonly kernel: IssuerId;
+    readonly nonce: string;
+    readonly release: ReleaseDigest;
+}
+/** Admit the exact version-two challenge at a Delivery transport boundary. */
 export declare function acceptRequest(input: unknown): Request;
-//# sourceMappingURL=request.d.ts.map

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

@@ -2,19 +2,19 @@ import { AuthValueError } from '@astrale-os/kernel-core/auth/error';
 import { accept as acceptIssuer } from '@astrale-os/kernel-core/auth/issuer';
 import { fail } from './error.js';
 import { NONCE_MAX_LENGTH, NONCE_MIN_LENGTH } from './limits.js';
-/** Admit the exact request representation accepted by a Delivery transport boundary. */
+const FIELDS = ['version', 'kernel', 'nonce', 'release'];
+/** Admit the exact version-two challenge at a Delivery transport boundary. */
 export function acceptRequest(input) {
     if (input === null || typeof input !== 'object' || Array.isArray(input)) {
         fail('DELIVERY_REQUEST_INVALID', 'Expected a Delivery request.');
     }
-    const expected = ['version', 'kernel', 'nonce', 'etag'];
     const value = {};
     const fields = Reflect.ownKeys(input);
-    if (fields.length !== expected.length) {
+    if (fields.length !== FIELDS.length) {
         fail('DELIVERY_REQUEST_INVALID', 'Delivery request is invalid.');
     }
     for (const field of fields) {
-        if (typeof field !== 'string' || !expected.includes(field)) {
+        if (typeof field !== 'string' || !FIELDS.includes(field)) {
             fail('DELIVERY_REQUEST_INVALID', 'Delivery request is invalid.');
         }
         const descriptor = Object.getOwnPropertyDescriptor(input, field);
@@ -23,14 +23,13 @@ export function acceptRequest(input) {
         }
         value[field] = descriptor.value;
     }
-    if (expected.some((field) => !Object.hasOwn(value, field)) ||
-        value.version !== 1 ||
+    if (value.version !== 2 ||
         typeof value.kernel !== 'string' ||
         typeof value.nonce !== 'string' ||
         value.nonce.length < NONCE_MIN_LENGTH ||
         value.nonce.length > NONCE_MAX_LENGTH ||
-        typeof value.etag !== 'string' ||
-        !/^sha256:[0-9a-f]{64}$/u.test(value.etag)) {
+        typeof value.release !== 'string' ||
+        !/^sha256:[0-9a-f]{64}$/u.test(value.release)) {
         fail('DELIVERY_REQUEST_INVALID', 'Delivery request is invalid.');
     }
     let kernel;
@@ -44,10 +43,9 @@ export function acceptRequest(input) {
         throw cause;
     }
     return Object.freeze({
-        version: 1,
+        version: 2,
         kernel,
         nonce: value.nonce,
-        etag: value.etag,
+        release: value.release,
     });
 }
-//# sourceMappingURL=request.js.map

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

@@ -2,4 +2,3 @@ import type { DeliveryDeclaration } from './declaration.js';
 import type { Endpoint } from './delivery-endpoint.js';
 /** Place one provider-neutral Delivery declaration beneath an exact serving issuer. */
 export declare function placeDelivery(input: DeliveryDeclaration, issuer: string, bundleHref: string): Endpoint;
-//# sourceMappingURL=delivery-declaration.d.ts.map

package/dist/{publication → release}/delivery-declaration.js

@@ -3,24 +3,23 @@ import { fail } from './error.js';
 /** Place one provider-neutral Delivery declaration beneath an exact serving issuer. */
 export function placeDelivery(input, issuer, bundleHref) {
     if (input === null || typeof input !== 'object' || Array.isArray(input)) {
-        fail('PUBLICATION_INVALID', 'Delivery declaration is invalid.');
+        fail('RELEASE_INVALID', 'Delivery declaration is invalid.');
     }
     if (Reflect.ownKeys(input).some((key) => key !== 'path' && key !== 'authentication') ||
         typeof input.path !== 'string' ||
         !input.path.startsWith('/')) {
-        fail('PUBLICATION_INVALID', 'Delivery declaration is invalid.');
+        fail('RELEASE_INVALID', 'Delivery declaration is invalid.');
     }
     let href;
     try {
         const url = new URL(input.path, issuer);
         if (url.origin !== new URL(issuer).origin || url.search !== '' || url.hash !== '') {
-            fail('PUBLICATION_INVALID', 'Delivery declaration must be one relative path.');
+            fail('RELEASE_INVALID', 'Delivery declaration must be one relative path.');
         }
         href = url.href;
     }
     catch (cause) {
-        return fail('PUBLICATION_INVALID', 'Delivery declaration path is invalid.', cause);
+        return fail('RELEASE_INVALID', 'Delivery declaration path is invalid.', cause);
     }
     return admitEndpoint({ href, method: 'POST', authentication: input.authentication }, bundleHref);
 }
-//# sourceMappingURL=delivery-declaration.js.map

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

@@ -9,4 +9,3 @@ export interface Endpoint {
     readonly authentication: Authentication;
 }
 export declare function admitEndpoint(input: unknown, publicUrl: string): Endpoint | undefined;
-//# sourceMappingURL=delivery-endpoint.d.ts.map

package/dist/release/delivery-endpoint.js

@@ -0,0 +1,22 @@
+import { fail } from './error.js';
+import { absoluteHttpUrl, exact, record } from './shape.js';
+export function admitEndpoint(input, publicUrl) {
+    if (input === undefined)
+        return undefined;
+    const value = record(input, 'RELEASE_INVALID', 'Delivery endpoint is invalid.');
+    exact(value, ['href', 'method', 'authentication'], 'RELEASE_INVALID');
+    const href = absoluteHttpUrl(value.href, true, 'RELEASE_INVALID');
+    if (new URL(href).origin !== new URL(publicUrl).origin || value.method !== 'POST') {
+        fail('RELEASE_INVALID', 'Delivery endpoint must be same-origin POST.');
+    }
+    const authentication = record(value.authentication, 'RELEASE_INVALID', 'Delivery authentication is invalid.');
+    exact(authentication, ['kind'], 'RELEASE_INVALID');
+    if (authentication.kind !== 'public' && authentication.kind !== 'bearer') {
+        fail('RELEASE_INVALID', 'Delivery authentication kind is invalid.');
+    }
+    return Object.freeze({
+        href,
+        method: 'POST',
+        authentication: Object.freeze({ kind: authentication.kind }),
+    });
+}

package/dist/release/digest.d.ts

@@ -0,0 +1,13 @@
+export type Sha256Digest = `sha256:${string}`;
+/**
+ * Digest of one canonical `DomainRelease`: its build, its addresses and issuer, and through the
+ * address the variables frozen at deploy. One per deployment.
+ */
+export type ReleaseDigest = Sha256Digest;
+/**
+ * Hash of the bytes one build produced (modules, assets, schema, requirements). An address, key or
+ * secret never enters those bytes, so the same build has the same digest in every environment.
+ */
+export type BuildDigest = Sha256Digest;
+export declare function admitDigest(input: unknown): Sha256Digest;
+export declare function sha256Hex(input: Uint8Array): string;