@astrale-os/kernel-protocol 0.5.0-beta.66 → 0.5.0-beta.68

package/dist/release/legacy/projection.js

@@ -0,0 +1,25 @@
+import { seal } from './publication.js';
+/**
+ * The v3 Publication a v4 deployment serves at `domain.json`, for the Kernels, Workers and tools
+ * that predate `DomainRelease` v4: the release's served content sealed as Publication v3. It drops
+ * `format`, `version`, `digest` and `build`, so its ETag covers what a v3 ETag always covered and
+ * never the code. Frozen forever: every party that projects a release (Kernel, Worker, tooling at
+ * any package version) must compute the same bytes, which the golden vectors pin.
+ *
+ * @deprecated Serves pre-v4 readers only; a v4 reader fetches the `DomainRelease` at `release.json`.
+ * Deleted with the projection row of `legacy/index.ts`.
+ */
+export function publication(release) {
+    return seal({
+        format: 'astrale.domain.publication',
+        version: 3,
+        origin: release.origin,
+        identity: release.identity,
+        schema: release.schema,
+        requirements: release.requirements,
+        ...(release.manifest === undefined ? {} : { manifest: release.manifest }),
+        bindings: release.bindings,
+        routes: release.routes,
+        ...(release.delivery === undefined ? {} : { delivery: release.delivery }),
+    });
+}

package/dist/release/legacy/publication.d.ts

@@ -0,0 +1,90 @@
+import type { IssuerId } from '@astrale-os/kernel-core/auth/issuer';
+import type { Key } from '@astrale-os/kernel-dsl/v1/addressing';
+import type { CallableBinding, ViewBinding } from '../bindings/index.js';
+import type { Endpoint as DeliveryEndpoint } from '../delivery-endpoint.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';
+import type { Etag } from './etag.js';
+/**
+ * @deprecated Path of the v2/v3 Publication; use the release `PATH` (`release.json`) from
+ * `@astrale-os/kernel-protocol/release` (added with `DomainRelease` v4).
+ */
+export declare const PATH: '/.well-known/astrale/domain.json';
+/**
+ * @deprecated Media type of Publication v3; use the release `MEDIA_TYPE` from
+ * `@astrale-os/kernel-protocol/release` (added with `DomainRelease` v4).
+ */
+export declare const MEDIA_TYPE: 'application/vnd.astrale.domain-publication+json;v=3';
+/**
+ * @deprecated Media type of Publication v2; use the release `MEDIA_TYPE` from
+ * `@astrale-os/kernel-protocol/release` (added with `DomainRelease` v4).
+ */
+export declare const LEGACY_MEDIA_TYPE: 'application/vnd.astrale.domain-publication+json;v=2';
+/**
+ * Select the media type of one v2 or v3 Publication.
+ *
+ * @deprecated Serves and retains v2/v3 Publications only; use the release `MEDIA_TYPE` from
+ * `@astrale-os/kernel-protocol/release` (added with `DomainRelease` v4), the one media type of a
+ * release.
+ */
+export declare function mediaType(input: Pick<Publication, 'version'>): typeof MEDIA_TYPE | typeof LEGACY_MEDIA_TYPE;
+/**
+ * Resolve the canonical Publication URL beneath one exact HTTP(S) serving issuer.
+ *
+ * @deprecated Locates the v2/v3 Publication; use the release `url` (`release.json`) from
+ * `@astrale-os/kernel-protocol/release` (added with `DomainRelease` v4).
+ */
+export declare function url(input: string): string;
+/**
+ * Immutable v2/v3 deployment snapshot of one root Domain.
+ *
+ * @deprecated Use `DomainRelease` from `@astrale-os/kernel-protocol/release` (added with
+ * `DomainRelease` v4). Kept to read and serve the documents of Kernels, Workers and installations
+ * that predate v4.
+ */
+export interface Publication {
+    readonly format: 'astrale.domain.publication';
+    readonly version: 2 | 3;
+    readonly origin: Key.Origin;
+    readonly identity: {
+        readonly issuer: IssuerId;
+        readonly subject: string;
+    };
+    readonly etag: Etag;
+    readonly schema: Schema;
+    readonly requirements: Requirements;
+    readonly manifest?: Manifest;
+    readonly bindings: {
+        readonly callables: readonly CallableBinding[];
+        readonly views: readonly ViewBinding[];
+    };
+    readonly routes: readonly HttpRoute[];
+    readonly delivery?: DeliveryEndpoint;
+}
+/**
+ * @deprecated Content of a v2/v3 Publication before its ETag is computed; use the release
+ * `Content` from `@astrale-os/kernel-protocol/release` (added with `DomainRelease` v4). Only
+ * version 3 is sealed; version 2 is read-only retained evidence.
+ */
+export type Content = Omit<Publication, 'etag' | 'version'> & {
+    readonly version: 3;
+};
+/** The ETag-covered content of any admitted Publication, including retained version 2. */
+export type EtagContent = Omit<Publication, 'etag'>;
+/**
+ * @deprecated Seals a v2/v3 Publication; use the release `seal` from
+ * `@astrale-os/kernel-protocol/release` (added with `DomainRelease` v4).
+ */
+export declare function seal(input: Content): Publication;
+/**
+ * @deprecated Admits a v2/v3 Publication; use the release `accept` from
+ * `@astrale-os/kernel-protocol/release` (added with `DomainRelease` v4).
+ */
+export declare function accept(input: unknown): Publication;
+/**
+ * @deprecated Encodes a v2/v3 Publication byte-identically to its accepted wire form; use the
+ * release `encode` from `@astrale-os/kernel-protocol/release` (added with `DomainRelease` v4).
+ */
+export declare function encode(input: Publication): Uint8Array;

package/dist/release/legacy/publication.js

@@ -0,0 +1,124 @@
+import * as portable from '@astrale-os/kernel-dsl/value';
+import { admitDigest } from '../digest.js';
+import { servedUrl } from '../issuer.js';
+import { admitServedContent } from '../served.js';
+import { deepFreeze } from '../shape.js';
+import { exact, fail, record, withPublicationError } from './error.js';
+import { computeEtag } from './etag.js';
+import { decodeLegacyRequirements, encodeLegacyRequirements } from './profiles.js';
+/**
+ * @deprecated Path of the v2/v3 Publication; use the release `PATH` (`release.json`) from
+ * `@astrale-os/kernel-protocol/release` (added with `DomainRelease` v4).
+ */
+export const PATH = '/.well-known/astrale/domain.json';
+/**
+ * @deprecated Media type of Publication v3; use the release `MEDIA_TYPE` from
+ * `@astrale-os/kernel-protocol/release` (added with `DomainRelease` v4).
+ */
+export const MEDIA_TYPE = 'application/vnd.astrale.domain-publication+json;v=3';
+/**
+ * @deprecated Media type of Publication v2; use the release `MEDIA_TYPE` from
+ * `@astrale-os/kernel-protocol/release` (added with `DomainRelease` v4).
+ */
+export const LEGACY_MEDIA_TYPE = 'application/vnd.astrale.domain-publication+json;v=2';
+/**
+ * Select the media type of one v2 or v3 Publication.
+ *
+ * @deprecated Serves and retains v2/v3 Publications only; use the release `MEDIA_TYPE` from
+ * `@astrale-os/kernel-protocol/release` (added with `DomainRelease` v4), the one media type of a
+ * release.
+ */
+export function mediaType(input) {
+    return input.version === 2 ? LEGACY_MEDIA_TYPE : MEDIA_TYPE;
+}
+/**
+ * Resolve the canonical Publication URL beneath one exact HTTP(S) serving issuer.
+ *
+ * @deprecated Locates the v2/v3 Publication; use the release `url` (`release.json`) from
+ * `@astrale-os/kernel-protocol/release` (added with `DomainRelease` v4).
+ */
+export function url(input) {
+    return withPublicationError(() => servedUrl(input, PATH));
+}
+/**
+ * @deprecated Seals a v2/v3 Publication; use the release `seal` from
+ * `@astrale-os/kernel-protocol/release` (added with `DomainRelease` v4).
+ */
+export function seal(input) {
+    return withPublicationError(() => {
+        const canonical = withoutEtag(acceptPublication({ ...input, etag: 'canonicalizing' }, 'seal'));
+        return acceptPublication({ ...canonical, etag: computeEtag(canonical) }, 'canonical');
+    });
+}
+/**
+ * @deprecated Admits a v2/v3 Publication; use the release `accept` from
+ * `@astrale-os/kernel-protocol/release` (added with `DomainRelease` v4).
+ */
+export function accept(input) {
+    return withPublicationError(() => {
+        const publication = acceptPublication(input, 'wire');
+        if (publication.etag !== computeEtag(withoutEtag(publication))) {
+            fail('PUBLICATION_ETAG_MISMATCH', 'Publication ETag does not match its canonical content.');
+        }
+        return publication;
+    });
+}
+/**
+ * @deprecated Encodes a v2/v3 Publication byte-identically to its accepted wire form; use the
+ * release `encode` from `@astrale-os/kernel-protocol/release` (added with `DomainRelease` v4).
+ */
+export function encode(input) {
+    const wire = input.version === 2
+        ? { ...input, requirements: encodeLegacyRequirements(input.requirements) }
+        : input;
+    return portable.json.encode(wire);
+}
+function acceptPublication(input, mode) {
+    const value = record(input, 'PUBLICATION_INVALID', 'Expected a Publication object.');
+    exact(value, [
+        'format',
+        'version',
+        'origin',
+        'identity',
+        'etag',
+        'schema',
+        'requirements',
+        'manifest',
+        'bindings',
+        'routes',
+        'delivery',
+    ], 'PUBLICATION_INVALID');
+    if (value.format !== 'astrale.domain.publication' ||
+        (value.version !== 2 && value.version !== 3)) {
+        fail('PUBLICATION_INVALID', 'Unsupported Publication format or version.');
+    }
+    // Version 2 is read-only: retained Publications keep their exact bytes and ETag, but no new one
+    // is sealed.
+    if (value.version !== 3 && mode === 'seal') {
+        fail('PUBLICATION_INVALID', 'Only Publication version 3 can be sealed.');
+    }
+    const served = admitServedContent(value, {
+        views: mode === 'seal' ? 'canonicalize' : 'admit',
+        ...(value.version === 2 && mode === 'wire' ? { requirements: decodeLegacyRequirements } : {}),
+    });
+    const admittedEtag = mode === 'wire' ? admitDigest(value.etag) : value.etag;
+    if (typeof admittedEtag !== 'string')
+        fail('PUBLICATION_INVALID', 'Publication ETag is missing.');
+    return deepFreeze({
+        format: 'astrale.domain.publication',
+        version: value.version,
+        origin: served.origin,
+        identity: served.identity,
+        etag: admittedEtag,
+        schema: served.schema,
+        requirements: served.requirements,
+        ...(served.manifest === undefined ? {} : { manifest: served.manifest }),
+        bindings: served.bindings,
+        routes: served.routes,
+        ...(served.delivery === undefined ? {} : { delivery: served.delivery }),
+    });
+}
+function withoutEtag(input) {
+    const { etag: _etag, ...content } = input;
+    return content;
+}

package/dist/release/legacy/reference.d.ts

@@ -0,0 +1,47 @@
+import type { Revision } from '@astrale-os/kernel-dsl/v1/addressing';
+import { type Key } from '@astrale-os/kernel-dsl/v1/addressing';
+import type { Etag } from './etag.js';
+import type { Publication } from './publication.js';
+/**
+ * Compact untrusted projection that witnesses one exact Publication.
+ *
+ * @deprecated Witnesses a v2/v3 Publication; use `ReleaseRef` from
+ * `@astrale-os/kernel-protocol/release` (added with `DomainRelease` v4).
+ */
+export interface PublicationRef {
+    readonly origin: Key.Origin;
+    readonly identity: Publication['identity'];
+    readonly revision: Revision;
+    readonly etag: Etag;
+}
+/**
+ * @deprecated Relation between two `PublicationRef`s; use `ReleaseReferenceRelation` from
+ * `@astrale-os/kernel-protocol/release` (added with `DomainRelease` v4).
+ */
+export type PublicationReferenceRelation = 'exact' | 'same-schema' | 'schema-drift' | 'identity-drift' | 'origin-drift';
+/**
+ * @deprecated Projects a v2/v3 Publication; use the release `reference` from
+ * `@astrale-os/kernel-protocol/release` (added with `DomainRelease` v4).
+ */
+export declare function reference(input: Publication): PublicationRef;
+/**
+ * @deprecated Admits a v2/v3 Publication reference; use the release `acceptReference` from
+ * `@astrale-os/kernel-protocol/release` (added with `DomainRelease` v4).
+ */
+export declare function acceptReference(input: unknown): PublicationRef;
+/**
+ * @deprecated Classifies two `PublicationRef`s; use the release `compareReferences` from
+ * `@astrale-os/kernel-protocol/release` (added with `DomainRelease` v4).
+ */
+export declare function compareReferences(input: PublicationRef, expected: PublicationRef): PublicationReferenceRelation;
+/**
+ * @deprecated Compares a v2/v3 Publication with a `PublicationRef`; use
+ * `compareReferences(reference(release), expected)` from `@astrale-os/kernel-protocol/release`
+ * (added with `DomainRelease` v4).
+ */
+export declare function compareReference(input: Publication, expected: PublicationRef): PublicationReferenceRelation;
+/**
+ * @deprecated Matches a v2/v3 Publication with a `PublicationRef`; use the release
+ * `matchesReference` from `@astrale-os/kernel-protocol/release` (added with `DomainRelease` v4).
+ */
+export declare function matchesReference(input: Publication, expected: PublicationRef): boolean;

package/dist/{publication → release/legacy}/reference.js

@@ -1,9 +1,13 @@
 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, exact, record } from './content.js';
-import { fail } from './error.js';
-import { admitDigest } from './etag.js';
+import { admitDigest } from '../digest.js';
+import { deepFreeze } from '../shape.js';
+import { exact, fail, record, withPublicationError } from './error.js';
+/**
+ * @deprecated Projects a v2/v3 Publication; use the release `reference` from
+ * `@astrale-os/kernel-protocol/release` (added with `DomainRelease` v4).
+ */
 export function reference(input) {
     return deepFreeze({
         origin: input.origin,
@@ -12,7 +16,14 @@ export function reference(input) {
         etag: input.etag,
     });
 }
+/**
+ * @deprecated Admits a v2/v3 Publication reference; use the release `acceptReference` from
+ * `@astrale-os/kernel-protocol/release` (added with `DomainRelease` v4).
+ */
 export function acceptReference(input) {
+    return withPublicationError(() => admitReference(input));
+}
+function admitReference(input) {
     const value = record(input, 'PUBLICATION_INVALID', 'Publication reference is invalid.');
     exact(value, ['origin', 'identity', 'revision', 'etag'], 'PUBLICATION_INVALID');
     if (typeof value.origin !== 'string' || !patterns.origin.test(value.origin)) {
@@ -35,6 +46,10 @@ export function acceptReference(input) {
         etag: admitDigest(value.etag),
     });
 }
+/**
+ * @deprecated Classifies two `PublicationRef`s; use the release `compareReferences` from
+ * `@astrale-os/kernel-protocol/release` (added with `DomainRelease` v4).
+ */
 export function compareReferences(input, expected) {
     if (input.origin !== expected.origin)
         return 'origin-drift';
@@ -46,9 +61,18 @@ export function compareReferences(input, expected) {
         return 'schema-drift';
     return input.etag === expected.etag ? 'exact' : 'same-schema';
 }
+/**
+ * @deprecated Compares a v2/v3 Publication with a `PublicationRef`; use
+ * `compareReferences(reference(release), expected)` from `@astrale-os/kernel-protocol/release`
+ * (added with `DomainRelease` v4).
+ */
 export function compareReference(input, expected) {
     return compareReferences(reference(input), expected);
 }
+/**
+ * @deprecated Matches a v2/v3 Publication with a `PublicationRef`; use the release
+ * `matchesReference` from `@astrale-os/kernel-protocol/release` (added with `DomainRelease` v4).
+ */
 export function matchesReference(input, expected) {
     return compareReference(input, expected) === 'exact';
 }

package/dist/release/legacy/requirements.d.ts

@@ -0,0 +1,30 @@
+import type { schema } from '@astrale-os/kernel-dsl/v1';
+import * as requirements from '../requirements.js';
+/** @deprecated Use `NonEmpty` from `@astrale-os/kernel-protocol/release`. */
+export type NonEmpty<Value> = requirements.NonEmpty<Value>;
+/** @deprecated Use `ClassOperation` from `@astrale-os/kernel-protocol/release`. */
+export type ClassOperation = requirements.ClassOperation;
+/** @deprecated Use `ClassCapabilityRequirement` from `@astrale-os/kernel-protocol/release`. */
+export type ClassCapabilityRequirement = requirements.ClassCapabilityRequirement;
+/** @deprecated Use `CapabilityAuthorityRequirements` from `@astrale-os/kernel-protocol/release`. */
+export type CapabilityAuthorityRequirements = requirements.CapabilityAuthorityRequirements;
+/** @deprecated Use `CapabilityRequirements` from `@astrale-os/kernel-protocol/release`. */
+export type CapabilityRequirements = requirements.CapabilityRequirements;
+/** @deprecated Use `CoreCapabilityRequirement` from `@astrale-os/kernel-protocol/release`. */
+export type CoreCapabilityRequirement = requirements.CoreCapabilityRequirement;
+/** @deprecated Use `Requirements` from `@astrale-os/kernel-protocol/release`. */
+export type PublicationRequirements = requirements.Requirements;
+/**
+ * Admit the exact closed canonical requirements object used by Publication v3.
+ *
+ * @deprecated Use `admitRequirements` from `@astrale-os/kernel-protocol/release`, which reports
+ * `ReleaseError`.
+ */
+export declare function admitRequirements(input: unknown): PublicationRequirements;
+/**
+ * Bind explicit capability targets to exact functional dependencies in the bundle closure.
+ *
+ * @deprecated Use `validateRequirements` from `@astrale-os/kernel-protocol/release`, which reports
+ * `ReleaseError`.
+ */
+export declare function validateRequirements(root: schema.DomainSchema, closure: readonly schema.DomainSchema[], input: PublicationRequirements): void;

package/dist/release/legacy/requirements.js

@@ -0,0 +1,20 @@
+import * as requirements from '../requirements.js';
+import { withPublicationError } from './error.js';
+/**
+ * Admit the exact closed canonical requirements object used by Publication v3.
+ *
+ * @deprecated Use `admitRequirements` from `@astrale-os/kernel-protocol/release`, which reports
+ * `ReleaseError`.
+ */
+export function admitRequirements(input) {
+    return withPublicationError(() => requirements.admitRequirements(input));
+}
+/**
+ * Bind explicit capability targets to exact functional dependencies in the bundle closure.
+ *
+ * @deprecated Use `validateRequirements` from `@astrale-os/kernel-protocol/release`, which reports
+ * `ReleaseError`.
+ */
+export function validateRequirements(root, closure, input) {
+    withPublicationError(() => requirements.validateRequirements(root, closure, input));
+}

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

@@ -1,13 +1,13 @@
 import { acceptDefinitionRef } from '@astrale-os/kernel-dsl/v1/addressing';
-import { exact, record } from './content.js';
 import { fail } from './error.js';
+import { exact, record } from './shape.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');
+    const value = record(input, 'RELEASE_INVALID', 'Manifest is invalid.');
+    exact(value, ['logo', 'entrypoint'], 'RELEASE_INVALID');
     if (value.logo !== undefined && typeof value.logo !== 'string') {
-        fail('PUBLICATION_INVALID', 'Manifest logo must be a string.');
+        fail('RELEASE_INVALID', 'Manifest logo must be a string.');
     }
     let entrypoint;
     if (value.entrypoint !== undefined) {
@@ -16,10 +16,10 @@ export function admitManifest(input) {
             ref = acceptDefinitionRef(value.entrypoint);
         }
         catch (cause) {
-            return fail('PUBLICATION_INVALID', 'Manifest entrypoint must be a root View reference.', cause);
+            return fail('RELEASE_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.');
+            fail('RELEASE_INVALID', 'Manifest entrypoint must be a root View reference.');
         }
         entrypoint = ref;
     }

package/dist/release/reference.d.ts

@@ -0,0 +1,26 @@
+import type { Revision } from '@astrale-os/kernel-dsl/v1/addressing';
+import { type Key } from '@astrale-os/kernel-dsl/v1/addressing';
+import type { ReleaseDigest } from './digest.js';
+import type { DomainRelease } from './release.js';
+/** Compact untrusted projection that witnesses one exact `DomainRelease`. */
+export interface ReleaseRef {
+    readonly origin: Key.Origin;
+    readonly identity: DomainRelease['identity'];
+    readonly revision: Revision;
+    readonly digest: ReleaseDigest;
+}
+/**
+ * Relation between two `ReleaseRef`s. A release digest commits to identity, schema and build, so
+ * within one origin anything but the exact reference designates another release.
+ */
+export type ReleaseReferenceRelation = 'exact' | 'release-drift' | 'origin-drift';
+export declare function reference(input: DomainRelease): ReleaseRef;
+export declare function acceptReference(input: unknown): ReleaseRef;
+/**
+ * Classify a received reference against the expected one. A different origin is origin drift.
+ * Within one origin the reference is exact only when every coordinate equals the expected one: for
+ * references of admitted releases that is digest equality, and a received reference that names
+ * the expected digest beside any other coordinate witnesses no release, so it is release drift.
+ */
+export declare function compareReferences(input: ReleaseRef, expected: ReleaseRef): ReleaseReferenceRelation;
+export declare function matchesReference(input: DomainRelease, expected: ReleaseRef): boolean;

package/dist/release/reference.js

@@ -0,0 +1,70 @@
+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 { admitDigest } from './digest.js';
+import { fail } from './error.js';
+import { deepFreeze, exact, record } from './shape.js';
+export function reference(input) {
+    return deepFreeze({
+        origin: input.origin,
+        identity: { ...input.identity },
+        revision: input.schema.revision,
+        digest: input.digest,
+    });
+}
+export function acceptReference(input) {
+    const value = record(input, 'RELEASE_INVALID', 'Release reference is invalid.');
+    exact(value, ['origin', 'identity', 'revision', 'digest'], 'RELEASE_INVALID');
+    if (typeof value.origin !== 'string' || !patterns.origin.test(value.origin)) {
+        fail('RELEASE_INVALID', 'Release reference origin is invalid.');
+    }
+    const origin = value.origin;
+    const identity = record(value.identity, 'RELEASE_INVALID', 'Release reference identity is invalid.');
+    exact(identity, ['issuer', 'subject'], 'RELEASE_INVALID');
+    const issuer = acceptIssuer(identity.issuer);
+    if (identity.subject !== origin) {
+        fail('RELEASE_INVALID', 'Release reference subject must equal its root origin.');
+    }
+    if (typeof value.revision !== 'string' || !patterns.revision.test(value.revision)) {
+        fail('RELEASE_INVALID', 'Release reference revision is invalid.');
+    }
+    return deepFreeze({
+        origin,
+        identity: { issuer, subject: origin },
+        revision: value.revision,
+        digest: admitDigest(value.digest),
+    });
+}
+/**
+ * Classify a received reference against the expected one. A different origin is origin drift.
+ * Within one origin the reference is exact only when every coordinate equals the expected one: for
+ * references of admitted releases that is digest equality, and a received reference that names
+ * the expected digest beside any other coordinate witnesses no release, so it is release drift.
+ */
+export function compareReferences(input, expected) {
+    if (input.origin !== expected.origin)
+        return 'origin-drift';
+    return input.digest === expected.digest &&
+        input.revision === expected.revision &&
+        input.identity.issuer === expected.identity.issuer &&
+        input.identity.subject === expected.identity.subject
+        ? 'exact'
+        : 'release-drift';
+}
+export function matchesReference(input, expected) {
+    return compareReferences(reference(input), expected) === 'exact';
+}
+function acceptIssuer(input) {
+    if (typeof input !== 'string') {
+        fail('RELEASE_INVALID', 'Release reference issuer is invalid.');
+    }
+    try {
+        return acceptIssuerId(input);
+    }
+    catch (cause) {
+        if (cause instanceof AuthValueError) {
+            return fail('RELEASE_INVALID', 'Release reference issuer is invalid.', cause);
+        }
+        throw cause;
+    }
+}

package/dist/release/release.d.ts

@@ -0,0 +1,60 @@
+import type { IssuerId } from '@astrale-os/kernel-core/auth/issuer';
+import type { Key } from '@astrale-os/kernel-dsl/v1/addressing';
+import type { CallableBinding, ViewBinding } from './bindings/index.js';
+import type { Build } from './build.js';
+import type { Endpoint as DeliveryEndpoint } from './delivery-endpoint.js';
+import type { ReleaseDigest } from './digest.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';
+/** Path of the release a deployment serves beneath its serving issuer. */
+export declare const PATH: '/.well-known/astrale/release.json';
+/** Media type of `DomainRelease` v4. */
+export declare const MEDIA_TYPE: 'application/vnd.astrale.domain-release+json;v=4';
+/** Resolve the canonical release URL beneath one exact HTTP(S) serving issuer, keeping its path. */
+export declare function url(issuer: string): string;
+/**
+ * Immutable deployment document pinned by the Kernel. Its digest covers the schema, serving
+ * identity and code through the build digest; `version` identifies the document format.
+ */
+export interface DomainRelease {
+    readonly format: 'astrale.domain.release';
+    readonly version: 4;
+    readonly origin: Key.Origin;
+    readonly identity: {
+        readonly issuer: IssuerId;
+        /** Always the root origin. */
+        readonly subject: string;
+    };
+    readonly digest: ReleaseDigest;
+    readonly build: Build;
+    readonly schema: Schema;
+    readonly requirements: Requirements;
+    readonly manifest?: Manifest;
+    readonly bindings: {
+        readonly callables: readonly CallableBinding[];
+        readonly views: readonly ViewBinding[];
+    };
+    readonly routes: readonly HttpRoute[];
+    readonly delivery?: DeliveryEndpoint;
+}
+/** Content of a release before its digest is computed. */
+export type Content = Omit<DomainRelease, 'digest'>;
+/**
+ * Release digest of canonical release content: SHA-256 of its canonical JSON. The content must be
+ * exactly what `seal` produces, a sealed release without its digest; content that `seal` would
+ * canonicalize or refuse throws `ReleaseError` instead of yielding a digest no decoder accepts.
+ * Authored content gets its digest from `seal(content).digest`.
+ */
+export declare function digestOf(input: Content): ReleaseDigest;
+/** Validate release content, canonicalize its View bindings, and set its release digest. */
+export declare function seal(input: Content): DomainRelease;
+/**
+ * Admit one wire release: exact fields at every level, every value in the canonical form `seal`
+ * produces, and a digest matching its content. One release therefore has exactly one wire
+ * document: `encode(accept(input))` is the canonical JSON of `input`.
+ */
+export declare function accept(input: unknown): DomainRelease;
+/** Encode one release as its canonical JSON bytes. */
+export declare function encode(input: DomainRelease): Uint8Array;