@astrale-os/kernel-protocol 0.5.0-beta.10

package/dist/publication/bundle.d.ts

@@ -0,0 +1,9 @@
+import * as bundle from '@astrale-os/kernel-dsl/v1/bundle/transport';
+import type { BundleDescriptor } from './bundle-descriptor.js';
+import type { Publication } from './publication.js';
+import { verifyBundleBytes } from './bundle-evidence.js';
+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 { verifyBundleBytes };
+export { admitBundleDescriptor, BUNDLE_MEDIA_TYPE, type BundleDescriptor, } from './bundle-descriptor.js';

package/dist/publication/bundle.js

@@ -0,0 +1,44 @@
+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';
+export function describeBundle(input, href) {
+    const bytes = bundle.encode(input);
+    return Object.freeze({
+        href: absoluteHttpUrl(href, true, 'PUBLICATION_INVALID'),
+        ref: Object.freeze({
+            ...artifact.identify(bytes, BUNDLE_MEDIA_TYPE),
+            mediaType: BUNDLE_MEDIA_TYPE,
+        }),
+    });
+}
+export function acceptBundleValue(input) {
+    try {
+        return bundle.accept(input);
+    }
+    catch (cause) {
+        if (cause instanceof bundle.Error) {
+            return fail('PUBLICATION_INVALID', 'Publication bundle is invalid.', cause);
+        }
+        throw cause;
+    }
+}
+export function decodeBundleValue(publication, bytes) {
+    if (!(bytes instanceof Uint8Array)) {
+        fail('PUBLICATION_INVALID', 'Bundle artifact bytes are invalid.');
+    }
+    verifyBundleBytes(publication, bytes);
+    try {
+        return bundle.decode(bytes);
+    }
+    catch (cause) {
+        if (cause instanceof bundle.Error) {
+            return fail('PUBLICATION_INVALID', 'Bundle artifact cannot be decoded.', cause);
+        }
+        throw cause;
+    }
+}
+export { verifyBundleBytes };
+export { admitBundleDescriptor, BUNDLE_MEDIA_TYPE, } from './bundle-descriptor.js';

package/dist/publication/content.d.ts

@@ -0,0 +1,10 @@
+import type { PublicationErrorCode } from './error.js';
+import type { Publication } from './publication.js';
+export type Content = Omit<Publication, 'etag'>;
+export declare function record(input: unknown, code: PublicationErrorCode, message: string): Record<string, unknown>;
+export declare function exact(value: Record<string, unknown>, allowed: readonly string[], code: PublicationErrorCode): void;
+export declare function array(input: unknown, code: PublicationErrorCode): readonly unknown[];
+export declare function unique(values: readonly string[], code: PublicationErrorCode, label: string): void;
+export declare function deepFreeze<T>(value: T): T;
+export declare function absoluteHttpUrl(input: unknown, allowSearch: boolean, code: PublicationErrorCode, allowTemplate?: boolean): string;
+export declare function absoluteUrl(input: unknown, protocols: readonly string[], allowSearch: boolean, code: PublicationErrorCode, allowTemplate?: boolean): string;

package/dist/publication/content.js

@@ -0,0 +1,55 @@
+import { fail } from './error.js';
+export function record(input, code, message) {
+    if (input === null || typeof input !== 'object' || Array.isArray(input))
+        fail(code, message);
+    return input;
+}
+export function exact(value, allowed, code) {
+    const admitted = new Set(allowed);
+    if (Object.keys(value).some((key) => !admitted.has(key))) {
+        fail(code, 'Object contains unknown fields.');
+    }
+}
+export function array(input, code) {
+    if (!Array.isArray(input))
+        fail(code, 'Expected an array.');
+    return input;
+}
+export function unique(values, code, label) {
+    if (new Set(values).size !== values.length)
+        fail(code, `Duplicate ${label}.`);
+}
+export 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);
+}
+export function absoluteHttpUrl(input, allowSearch, code, allowTemplate = false) {
+    return absoluteUrl(input, ['http:', 'https:'], allowSearch, code, allowTemplate);
+}
+export function absoluteUrl(input, protocols, allowSearch, code, allowTemplate = false) {
+    if (typeof input !== 'string')
+        return fail(code, 'Expected an absolute URL.');
+    if (!allowTemplate && (input.includes('{') || input.includes('}'))) {
+        return fail(code, 'Only native route URLs may contain placeholders.');
+    }
+    let url;
+    try {
+        url = new URL(allowTemplate ? input.replaceAll(/\{[A-Za-z][A-Za-z0-9_]*\+?\}/gu, 'placeholder') : input);
+    }
+    catch (cause) {
+        if (cause instanceof TypeError)
+            return fail(code, 'Expected an absolute URL.', cause);
+        throw cause;
+    }
+    if (!protocols.includes(url.protocol) ||
+        url.username !== '' ||
+        url.password !== '' ||
+        url.hash !== '' ||
+        (!allowSearch && url.search !== '')) {
+        fail(code, 'URL has a forbidden protocol, credentials, query, or fragment.');
+    }
+    return input;
+}

package/dist/publication/declaration.d.ts

@@ -0,0 +1,11 @@
+import type { Authentication as DeliveryAuthentication } from './delivery-endpoint.js';
+import type { HttpRouteDeclaration } from './route.js';
+export interface DeliveryDeclaration {
+    readonly path: string;
+    readonly authentication: DeliveryAuthentication;
+}
+/** Provider-neutral deployment input selected independently from Domain and Adapter. */
+export interface Declaration {
+    readonly routes: readonly HttpRouteDeclaration[];
+    readonly delivery?: DeliveryDeclaration;
+}

package/dist/publication/declaration.js

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

package/dist/publication/delivery/attestation.d.ts

@@ -0,0 +1,6 @@
+declare const ATTESTATION: unique symbol;
+export type Attestation = string & {
+    readonly [ATTESTATION]: true;
+};
+export declare function acceptAttestation(input: unknown): Attestation;
+export {};

package/dist/publication/delivery/attestation.js

@@ -0,0 +1,10 @@
+import { fail } from './error.js';
+import { ATTESTATION_MAX_BYTES } from './limits.js';
+export function acceptAttestation(input) {
+    if (typeof input !== 'string' ||
+        input.length === 0 ||
+        new TextEncoder().encode(input).byteLength > ATTESTATION_MAX_BYTES) {
+        fail('DELIVERY_INVALID', 'Delivery attestation is invalid.');
+    }
+    return input;
+}

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

@@ -0,0 +1,16 @@
+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 { PURPOSE } from './limits.js';
+export interface Claims {
+    readonly purpose: typeof PURPOSE;
+    readonly iss: IssuerId;
+    readonly sub: Subject;
+    readonly aud: IssuerId;
+    readonly nonce: string;
+    readonly etag: Etag;
+    readonly schemaRevision: Revision;
+    readonly exp: number;
+}
+export declare function acceptClaims(input: unknown): Claims;

package/dist/publication/delivery/claims.js

@@ -0,0 +1,61 @@
+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 { fail } from './error.js';
+import { NONCE_MAX_LENGTH, NONCE_MIN_LENGTH, PURPOSE } from './limits.js';
+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))) {
+        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.etag !== 'string' || !/^sha256:[0-9a-f]{64}$/u.test(value.etag)) {
+        fail('DELIVERY_CLAIMS_INVALID', 'Delivery claims ETag 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,
+        etag: value.etag,
+        schemaRevision: value.schemaRevision,
+        exp: value.exp,
+    });
+}
+function acceptIssuer(input) {
+    try {
+        return acceptIssuerId(String(input));
+    }
+    catch (cause) {
+        if (cause instanceof AuthValueError) {
+            return fail('DELIVERY_CLAIMS_INVALID', 'Delivery claims issuer is invalid.', cause);
+        }
+        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);
+}

package/dist/publication/delivery/delivery.d.ts

@@ -0,0 +1,9 @@
+import type { Publication } from '../publication.js';
+import type { Attestation } from './attestation.js';
+export interface Delivery {
+    readonly format: 'astrale.domain.delivery';
+    readonly version: 1;
+    readonly publication: Publication;
+    readonly attestation: Attestation;
+}
+export declare function accept(input: unknown): Delivery;

package/dist/publication/delivery/delivery.js

@@ -0,0 +1,29 @@
+import { accept as acceptPublication } from '../publication.js';
+import { acceptAttestation } from './attestation.js';
+import { fail } from './error.js';
+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']);
+    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) {
+        fail('DELIVERY_INVALID', 'Unsupported Delivery format or version.');
+    }
+    return deepFreeze({
+        format: 'astrale.domain.delivery',
+        version: 1,
+        publication: acceptPublication(value.publication),
+        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);
+}

package/dist/publication/delivery/error.d.ts

@@ -0,0 +1,7 @@
+export type DeliveryErrorCode = 'DELIVERY_INVALID' | 'DELIVERY_REQUEST_INVALID' | 'DELIVERY_CLAIMS_INVALID';
+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;

package/dist/publication/delivery/error.js

@@ -0,0 +1,11 @@
+export class DeliveryError extends Error {
+    code;
+    name = 'DeliveryError';
+    constructor(code, message, options) {
+        super(message, options);
+        this.code = code;
+    }
+}
+export function fail(code, message, cause) {
+    throw new DeliveryError(code, message, cause === undefined ? undefined : { cause });
+}

package/dist/publication/delivery/index.d.ts

@@ -0,0 +1,6 @@
+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';

package/dist/publication/delivery/index.js

@@ -0,0 +1,6 @@
+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';

package/dist/publication/delivery/limits.d.ts

@@ -0,0 +1,4 @@
+export declare const PURPOSE: 'astrale.domain.delivery.v1';
+export declare const NONCE_MIN_LENGTH = 16;
+export declare const NONCE_MAX_LENGTH = 256;
+export declare const ATTESTATION_MAX_BYTES = 16384;

package/dist/publication/delivery/limits.js

@@ -0,0 +1,4 @@
+export const PURPOSE = 'astrale.domain.delivery.v1';
+export const NONCE_MIN_LENGTH = 16;
+export const NONCE_MAX_LENGTH = 256;
+export const ATTESTATION_MAX_BYTES = 16_384;

package/dist/publication/delivery/request.d.ts

@@ -0,0 +1,15 @@
+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. */
+export interface Token {
+    readonly kind: 'bearer';
+    readonly token: string;
+}
+/** Admit the exact request representation accepted by a Delivery transport boundary. */
+export declare function acceptRequest(input: unknown): Request;

package/dist/publication/delivery/request.js

@@ -0,0 +1,52 @@
+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. */
+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) {
+        fail('DELIVERY_REQUEST_INVALID', 'Delivery request is invalid.');
+    }
+    for (const field of fields) {
+        if (typeof field !== 'string' || !expected.includes(field)) {
+            fail('DELIVERY_REQUEST_INVALID', 'Delivery request is invalid.');
+        }
+        const descriptor = Object.getOwnPropertyDescriptor(input, field);
+        if (descriptor === undefined || !descriptor.enumerable || !('value' in descriptor)) {
+            fail('DELIVERY_REQUEST_INVALID', 'Delivery request is invalid.');
+        }
+        value[field] = descriptor.value;
+    }
+    if (expected.some((field) => !Object.hasOwn(value, field)) ||
+        value.version !== 1 ||
+        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)) {
+        fail('DELIVERY_REQUEST_INVALID', 'Delivery request is invalid.');
+    }
+    let kernel;
+    try {
+        kernel = acceptIssuer(value.kernel);
+    }
+    catch (cause) {
+        if (cause instanceof AuthValueError) {
+            return fail('DELIVERY_REQUEST_INVALID', 'Delivery request issuer is invalid.', cause);
+        }
+        throw cause;
+    }
+    return Object.freeze({
+        version: 1,
+        kernel,
+        nonce: value.nonce,
+        etag: value.etag,
+    });
+}

package/dist/publication/delivery-declaration.d.ts

@@ -0,0 +1,4 @@
+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;

package/dist/publication/delivery-declaration.js

@@ -0,0 +1,25 @@
+import { admitEndpoint } from './delivery-endpoint.js';
+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.');
+    }
+    if (Reflect.ownKeys(input).some((key) => key !== 'path' && key !== 'authentication') ||
+        typeof input.path !== 'string' ||
+        !input.path.startsWith('/')) {
+        fail('PUBLICATION_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.');
+        }
+        href = url.href;
+    }
+    catch (cause) {
+        return fail('PUBLICATION_INVALID', 'Delivery declaration path is invalid.', cause);
+    }
+    return admitEndpoint({ href, method: 'POST', authentication: input.authentication }, bundleHref);
+}

package/dist/publication/delivery-endpoint.d.ts

@@ -0,0 +1,11 @@
+export type Authentication = {
+    readonly kind: 'public';
+} | {
+    readonly kind: 'bearer';
+};
+export interface Endpoint {
+    readonly href: string;
+    readonly method: 'POST';
+    readonly authentication: Authentication;
+}
+export declare function admitEndpoint(input: unknown, publicUrl: string): Endpoint | undefined;

package/dist/publication/delivery-endpoint.js

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

package/dist/publication/error.d.ts

@@ -0,0 +1,7 @@
+export type PublicationErrorCode = 'PUBLICATION_INVALID' | 'PUBLICATION_ETAG_MISMATCH' | 'PUBLICATION_BINDING_INVALID' | 'PUBLICATION_ROUTE_INVALID' | 'PUBLICATION_VIEW_INVALID';
+export declare class PublicationError extends Error {
+    readonly code: PublicationErrorCode;
+    readonly name = "PublicationError";
+    constructor(code: PublicationErrorCode, message: string, options?: ErrorOptions);
+}
+export declare function fail(code: PublicationErrorCode, message: string, cause?: unknown): never;

package/dist/publication/error.js

@@ -0,0 +1,11 @@
+export class PublicationError extends Error {
+    code;
+    name = 'PublicationError';
+    constructor(code, message, options) {
+        super(message, options);
+        this.code = code;
+    }
+}
+export function fail(code, message, cause) {
+    throw new PublicationError(code, message, cause === undefined ? undefined : { cause });
+}

package/dist/publication/etag.d.ts

@@ -0,0 +1,6 @@
+import type { Content } from './content.js';
+export type Sha256Digest = `sha256:${string}`;
+export type Etag = Sha256Digest;
+export declare function admitDigest(input: unknown): Sha256Digest;
+export declare function computeEtag(input: Content): Etag;
+export declare function sha256Hex(input: Uint8Array): string;

package/dist/publication/etag.js

@@ -0,0 +1,79 @@
+import * as portable from '@astrale-os/kernel-dsl/value';
+import { fail } from './error.js';
+const DIGEST = /^sha256:[0-9a-f]{64}$/u;
+export function admitDigest(input) {
+    if (typeof input !== 'string' || !DIGEST.test(input)) {
+        fail('PUBLICATION_INVALID', 'Digest is invalid.');
+    }
+    return input;
+}
+export function computeEtag(input) {
+    const bytes = portable.json.encode(input);
+    return `sha256:${sha256Hex(bytes)}`;
+}
+export function sha256Hex(input) {
+    const bitLength = input.length * 8;
+    const paddedLength = Math.ceil((input.length + 9) / 64) * 64;
+    const bytes = new Uint8Array(paddedLength);
+    bytes.set(input);
+    bytes[input.length] = 0x80;
+    const view = new DataView(bytes.buffer);
+    view.setUint32(paddedLength - 8, Math.floor(bitLength / 0x1_0000_0000), false);
+    view.setUint32(paddedLength - 4, bitLength >>> 0, false);
+    const state = new Uint32Array(INITIAL);
+    const words = new Uint32Array(64);
+    for (let offset = 0; offset < paddedLength; offset += 64) {
+        for (let index = 0; index < 16; index += 1) {
+            words[index] = view.getUint32(offset + index * 4, false);
+        }
+        for (let index = 16; index < 64; index += 1) {
+            const x = words[index - 15];
+            const y = words[index - 2];
+            const s0 = rotate(x, 7) ^ rotate(x, 18) ^ (x >>> 3);
+            const s1 = rotate(y, 17) ^ rotate(y, 19) ^ (y >>> 10);
+            words[index] = (words[index - 16] + s0 + words[index - 7] + s1) >>> 0;
+        }
+        let [a, b, c, d, e, f, g, h] = state;
+        for (let index = 0; index < 64; index += 1) {
+            const s1 = rotate(e, 6) ^ rotate(e, 11) ^ rotate(e, 25);
+            const choice = (e & f) ^ (~e & g);
+            const temporary1 = (h + s1 + choice + ROUND[index] + words[index]) >>> 0;
+            const s0 = rotate(a, 2) ^ rotate(a, 13) ^ rotate(a, 22);
+            const majority = (a & b) ^ (a & c) ^ (b & c);
+            const temporary2 = (s0 + majority) >>> 0;
+            h = g;
+            g = f;
+            f = e;
+            e = (d + temporary1) >>> 0;
+            d = c;
+            c = b;
+            b = a;
+            a = (temporary1 + temporary2) >>> 0;
+        }
+        state[0] = (state[0] + a) >>> 0;
+        state[1] = (state[1] + b) >>> 0;
+        state[2] = (state[2] + c) >>> 0;
+        state[3] = (state[3] + d) >>> 0;
+        state[4] = (state[4] + e) >>> 0;
+        state[5] = (state[5] + f) >>> 0;
+        state[6] = (state[6] + g) >>> 0;
+        state[7] = (state[7] + h) >>> 0;
+    }
+    return [...state].map((word) => word.toString(16).padStart(8, '0')).join('');
+}
+function rotate(value, count) {
+    return (value >>> count) | (value << (32 - count));
+}
+const INITIAL = new Uint32Array([
+    0x6a09e667, 0xbb67ae85, 0x3c6ef372, 0xa54ff53a, 0x510e527f, 0x9b05688c, 0x1f83d9ab, 0x5be0cd19,
+]);
+const ROUND = new Uint32Array([
+    0x428a2f98, 0x71374491, 0xb5c0fbcf, 0xe9b5dba5, 0x3956c25b, 0x59f111f1, 0x923f82a4, 0xab1c5ed5,
+    0xd807aa98, 0x12835b01, 0x243185be, 0x550c7dc3, 0x72be5d74, 0x80deb1fe, 0x9bdc06a7, 0xc19bf174,
+    0xe49b69c1, 0xefbe4786, 0x0fc19dc6, 0x240ca1cc, 0x2de92c6f, 0x4a7484aa, 0x5cb0a9dc, 0x76f988da,
+    0x983e5152, 0xa831c66d, 0xb00327c8, 0xbf597fc7, 0xc6e00bf3, 0xd5a79147, 0x06ca6351, 0x14292967,
+    0x27b70a85, 0x2e1b2138, 0x4d2c6dfc, 0x53380d13, 0x650a7354, 0x766a0abb, 0x81c2c92e, 0x92722c85,
+    0xa2bfe8a1, 0xa81a664b, 0xc24b8b70, 0xc76c51a3, 0xd192e819, 0xd6990624, 0xf40e3585, 0x106aa070,
+    0x19a4c116, 0x1e376c08, 0x2748774c, 0x34b0bcb5, 0x391c0cb3, 0x4ed8aa4a, 0x5b9cca4f, 0x682e6ff3,
+    0x748f82ee, 0x78a5636f, 0x84c87814, 0x8cc70208, 0x90befffa, 0xa4506ceb, 0xbef9a3f7, 0xc67178f2,
+]);

package/dist/publication/index.d.ts

@@ -0,0 +1,17 @@
+export { MEDIA_TYPE, PATH, url, seal, accept, encode, type Publication } from './publication.js';
+export { acceptBundle, decodeBundle } from './bundle-admission.js';
+export { BUNDLE_MEDIA_TYPE, describeBundle, type BundleDescriptor } from './bundle.js';
+export { verifyBundleBytes } from './bundle-evidence.js';
+export type { Content } from './content.js';
+export type { Declaration, DeliveryDeclaration } from './declaration.js';
+export { placeDelivery } from './delivery-declaration.js';
+export type { Etag, Sha256Digest } from './etag.js';
+export { PublicationError, type PublicationErrorCode } from './error.js';
+export * as delivery from './delivery/index.js';
+export type { Authentication as DeliveryAuthentication, Endpoint as DeliveryEndpoint, } from './delivery-endpoint.js';
+export type { Manifest } from './manifest.js';
+export { ClassOperationOrder, admitRequirements, validateRequirements, type CapabilityAdminRequirements, type CapabilityRequirements, type ClassCapabilityRequirement, type ClassOperation, type NonEmpty, type PublicationRequirements, } from './requirements.js';
+export { acceptReference, compareReference, compareReferences, matchesReference, reference, type PublicationRef, type PublicationReferenceRelation, } from './reference.js';
+export type { BodyPick, CredentialSource, HttpMethod, HttpRoute, HttpRouteDeclaration, RouteBody, RouteHeaders, SingleCredentialSource, } from './route.js';
+export type { Schema } from './schema.js';
+export { acceptInvocationEndpoints, type CallableBinding, type InvocationEndpoints, type ViewBinding, } from './bindings/index.js';

package/dist/publication/index.js

@@ -0,0 +1,10 @@
+export { MEDIA_TYPE, PATH, url, seal, accept, encode } from './publication.js';
+export { acceptBundle, decodeBundle } from './bundle-admission.js';
+export { BUNDLE_MEDIA_TYPE, describeBundle } from './bundle.js';
+export { verifyBundleBytes } from './bundle-evidence.js';
+export { placeDelivery } from './delivery-declaration.js';
+export { PublicationError } from './error.js';
+export * as delivery from './delivery/index.js';
+export { ClassOperationOrder, admitRequirements, validateRequirements, } from './requirements.js';
+export { acceptReference, compareReference, compareReferences, matchesReference, reference, } from './reference.js';
+export { acceptInvocationEndpoints, } from './bindings/index.js';

package/dist/publication/manifest.d.ts

@@ -0,0 +1,6 @@
+import { type ViewRef } from '@astrale-os/kernel-dsl/v1/addressing';
+export interface Manifest {
+    readonly logo?: string;
+    readonly entrypoint?: ViewRef;
+}
+export declare function admitManifest(input: unknown): Manifest | undefined;

package/dist/publication/manifest.js

@@ -0,0 +1,30 @@
+import { acceptDefinitionRef } from '@astrale-os/kernel-dsl/v1/addressing';
+import { exact, record } from './content.js';
+import { fail } from './error.js';
+export function admitManifest(input) {
+    if (input === undefined)
+        return undefined;
+    const value = record(input, 'PUBLICATION_INVALID', 'Manifest is invalid.');
+    exact(value, ['logo', 'entrypoint'], 'PUBLICATION_INVALID');
+    if (value.logo !== undefined && typeof value.logo !== 'string') {
+        fail('PUBLICATION_INVALID', 'Manifest logo must be a string.');
+    }
+    let entrypoint;
+    if (value.entrypoint !== undefined) {
+        let ref;
+        try {
+            ref = acceptDefinitionRef(value.entrypoint);
+        }
+        catch (cause) {
+            return fail('PUBLICATION_INVALID', 'Manifest entrypoint must be a root View reference.', cause);
+        }
+        if (ref.kind !== 'view') {
+            fail('PUBLICATION_INVALID', 'Manifest entrypoint must be a root View reference.');
+        }
+        entrypoint = ref;
+    }
+    return Object.freeze({
+        ...(value.logo === undefined ? {} : { logo: value.logo }),
+        ...(entrypoint === undefined ? {} : { entrypoint }),
+    });
+}