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

package/dist/release/legacy/bundle.js

@@ -0,0 +1,31 @@
+import * as descriptor from '../bundle-descriptor.js';
+import * as bundle from '../bundle.js';
+import { withPublicationError } from './error.js';
+export { verifyBundleBytes } from './bundle-evidence.js';
+/** @deprecated Use `BUNDLE_MEDIA_TYPE` from `@astrale-os/kernel-protocol/release/bundle`. */
+export const BUNDLE_MEDIA_TYPE = descriptor.BUNDLE_MEDIA_TYPE;
+/**
+ * Resolve immutable bundle bytes beneath the exact serving issuer.
+ *
+ * @deprecated Use `bundleUrl` from `@astrale-os/kernel-protocol/release/bundle`, which reports
+ * `ReleaseError`.
+ */
+export function bundleUrl(issuer, ref) {
+    return withPublicationError(() => bundle.bundleUrl(issuer, ref));
+}
+/** @deprecated Use `describeBundle` from `@astrale-os/kernel-protocol/release/bundle`. */
+export function describeBundle(input, href) {
+    return withPublicationError(() => bundle.describeBundle(input, href));
+}
+/** @deprecated Use `acceptBundleValue` from `@astrale-os/kernel-protocol/release/bundle`. */
+export function acceptBundleValue(input) {
+    return withPublicationError(() => bundle.acceptBundleValue(input));
+}
+/** @deprecated Use `decodeBundleValue` from `@astrale-os/kernel-protocol/release/bundle`. */
+export function decodeBundleValue(publication, bytes) {
+    return withPublicationError(() => bundle.decodeBundleValue(publication, bytes));
+}
+/** @deprecated Use `admitBundleDescriptor` from `@astrale-os/kernel-protocol/release/bundle`. */
+export function admitBundleDescriptor(input) {
+    return withPublicationError(() => bundle.admitBundleDescriptor(input));
+}

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

@@ -0,0 +1,6 @@
+import type { Attestation as ReleaseAttestation } from '../../delivery/attestation.js';
+/**
+ * @deprecated Delivery v1 attestation, the one Delivery v2 carries; use `Attestation` of
+ * `@astrale-os/kernel-protocol/release/delivery`.
+ */
+export type Attestation = ReleaseAttestation;

package/dist/release/legacy/delivery/attestation.js

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

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

@@ -3,6 +3,11 @@ 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';
+/**
+ * @deprecated Delivery v1 claims bind a Publication ETag; use the Delivery v2 `Claims` of
+ * `@astrale-os/kernel-protocol/release/delivery` (added with `DomainRelease` v4), which bind a
+ * release digest.
+ */
 export interface Claims {
     readonly purpose: typeof PURPOSE;
     readonly iss: IssuerId;
@@ -13,4 +18,8 @@ export interface Claims {
     readonly schemaRevision: Revision;
     readonly exp: number;
 }
+/**
+ * @deprecated Admits Delivery v1 claims; use `acceptClaims` from
+ * `@astrale-os/kernel-protocol/release/delivery` (Delivery v2, added with `DomainRelease` v4).
+ */
 export declare function acceptClaims(input: unknown): Claims;

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

@@ -1,8 +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 { fail } from './error.js';
-import { NONCE_MAX_LENGTH, NONCE_MIN_LENGTH, PURPOSE } from './limits.js';
+import { fail } from '../../delivery/error.js';
+import { NONCE_MAX_LENGTH, NONCE_MIN_LENGTH } from '../../delivery/limits.js';
+import { PURPOSE } from './limits.js';
+/**
+ * @deprecated Admits Delivery v1 claims; use `acceptClaims` from
+ * `@astrale-os/kernel-protocol/release/delivery` (Delivery v2, added with `DomainRelease` v4).
+ */
 export function acceptClaims(input) {
     if (input === null || typeof input !== 'object' || Array.isArray(input)) {
         fail('DELIVERY_CLAIMS_INVALID', 'Expected delivery claims.');

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

@@ -0,0 +1,18 @@
+import type { Attestation } from '../../delivery/attestation.js';
+import type { Publication } from '../publication.js';
+/**
+ * @deprecated Delivery v1 carries a v2/v3 Publication; use the Delivery v2 `Delivery` of
+ * `@astrale-os/kernel-protocol/release/delivery` (added with `DomainRelease` v4), which carries a
+ * `DomainRelease`.
+ */
+export interface Delivery {
+    readonly format: 'astrale.domain.delivery';
+    readonly version: 1;
+    readonly publication: Publication;
+    readonly attestation: Attestation;
+}
+/**
+ * @deprecated Admits Delivery v1; use `accept` from `@astrale-os/kernel-protocol/release/delivery`
+ * (Delivery v2, added with `DomainRelease` v4).
+ */
+export declare function accept(input: unknown): Delivery;

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

@@ -1,6 +1,10 @@
+import { acceptAttestation } from '../../delivery/attestation.js';
+import { fail } from '../../delivery/error.js';
 import { accept as acceptPublication } from '../publication.js';
-import { acceptAttestation } from './attestation.js';
-import { fail } from './error.js';
+/**
+ * @deprecated Admits Delivery v1; use `accept` from `@astrale-os/kernel-protocol/release/delivery`
+ * (Delivery v2, added with `DomainRelease` v4).
+ */
 export function accept(input) {
     if (input === null || typeof input !== 'object' || Array.isArray(input)) {
         fail('DELIVERY_INVALID', 'Expected a Delivery object.');

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

@@ -0,0 +1,16 @@
+import { DeliveryError as ReleaseDeliveryError, type DeliveryErrorCode as ReleaseDeliveryErrorCode } from '../../delivery/error.js';
+/**
+ * @deprecated Delivery v1 failure code, the one Delivery v2 reports; use `ErrorCode` of
+ * `@astrale-os/kernel-protocol/release/delivery`.
+ */
+export type DeliveryErrorCode = ReleaseDeliveryErrorCode;
+/**
+ * @deprecated Delivery v1 failure, the class Delivery v2 reports; use `Error` of
+ * `@astrale-os/kernel-protocol/release/delivery`.
+ */
+export declare const DeliveryError: typeof ReleaseDeliveryError;
+/**
+ * @deprecated Delivery v1 failure, the class Delivery v2 reports; use `Error` of
+ * `@astrale-os/kernel-protocol/release/delivery`.
+ */
+export type DeliveryError = ReleaseDeliveryError;

package/dist/release/legacy/delivery/error.js

@@ -0,0 +1,6 @@
+import { DeliveryError as ReleaseDeliveryError, } from '../../delivery/error.js';
+/**
+ * @deprecated Delivery v1 failure, the class Delivery v2 reports; use `Error` of
+ * `@astrale-os/kernel-protocol/release/delivery`.
+ */
+export const DeliveryError = ReleaseDeliveryError;

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

@@ -0,0 +1,13 @@
+/**
+ * Delivery v1: the challenge-bound envelope carrying the v2/v3 Publication a Kernel fetched at
+ * `domain.json`, bound to its ETag. Every v1 export is deprecated and replaced by Delivery v2
+ * (`@astrale-os/kernel-protocol/release/delivery`). The attestation, failure, bearer token, and
+ * limits are version-neutral: each name here is a deprecated alias of the Delivery v2 one, so
+ * `Error` is the very class Delivery v2 reports.
+ */
+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 Request, type Token } from './request.js';

package/dist/release/legacy/delivery/index.js

@@ -0,0 +1,13 @@
+/**
+ * Delivery v1: the challenge-bound envelope carrying the v2/v3 Publication a Kernel fetched at
+ * `domain.json`, bound to its ETag. Every v1 export is deprecated and replaced by Delivery v2
+ * (`@astrale-os/kernel-protocol/release/delivery`). The attestation, failure, bearer token, and
+ * limits are version-neutral: each name here is a deprecated alias of the Delivery v2 one, so
+ * `Error` is the very class Delivery v2 reports.
+ */
+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/release/legacy/delivery/limits.d.ts

@@ -0,0 +1,21 @@
+/**
+ * @deprecated Purpose of Delivery v1 attestations; Delivery v2
+ * (`@astrale-os/kernel-protocol/release/delivery`, added with `DomainRelease` v4) has its own
+ * purpose.
+ */
+export declare const PURPOSE: 'astrale.domain.delivery.v1';
+/**
+ * @deprecated Delivery v1 limit, the one Delivery v2 applies; use `NONCE_MIN_LENGTH` of
+ * `@astrale-os/kernel-protocol/release/delivery`.
+ */
+export declare const NONCE_MIN_LENGTH = 16;
+/**
+ * @deprecated Delivery v1 limit, the one Delivery v2 applies; use `NONCE_MAX_LENGTH` of
+ * `@astrale-os/kernel-protocol/release/delivery`.
+ */
+export declare const NONCE_MAX_LENGTH = 256;
+/**
+ * @deprecated Delivery v1 limit, the one Delivery v2 applies; use `ATTESTATION_MAX_BYTES` of
+ * `@astrale-os/kernel-protocol/release/delivery`.
+ */
+export declare const ATTESTATION_MAX_BYTES = 16384;

package/dist/release/legacy/delivery/limits.js

@@ -0,0 +1,22 @@
+import * as release from '../../delivery/limits.js';
+/**
+ * @deprecated Purpose of Delivery v1 attestations; Delivery v2
+ * (`@astrale-os/kernel-protocol/release/delivery`, added with `DomainRelease` v4) has its own
+ * purpose.
+ */
+export const PURPOSE = 'astrale.domain.delivery.v1';
+/**
+ * @deprecated Delivery v1 limit, the one Delivery v2 applies; use `NONCE_MIN_LENGTH` of
+ * `@astrale-os/kernel-protocol/release/delivery`.
+ */
+export const NONCE_MIN_LENGTH = release.NONCE_MIN_LENGTH;
+/**
+ * @deprecated Delivery v1 limit, the one Delivery v2 applies; use `NONCE_MAX_LENGTH` of
+ * `@astrale-os/kernel-protocol/release/delivery`.
+ */
+export const NONCE_MAX_LENGTH = release.NONCE_MAX_LENGTH;
+/**
+ * @deprecated Delivery v1 limit, the one Delivery v2 applies; use `ATTESTATION_MAX_BYTES` of
+ * `@astrale-os/kernel-protocol/release/delivery`.
+ */
+export const ATTESTATION_MAX_BYTES = release.ATTESTATION_MAX_BYTES;

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

@@ -0,0 +1,26 @@
+import { type IssuerId } from '@astrale-os/kernel-core/auth/issuer';
+import type { Token as ReleaseToken } from '../../delivery/request.js';
+import type { Etag } from '../etag.js';
+/**
+ * @deprecated Delivery v1 request names a Publication ETag; use the Delivery v2 `Request` of
+ * `@astrale-os/kernel-protocol/release/delivery` (added with `DomainRelease` v4), which names a
+ * release digest.
+ */
+export interface Request {
+    readonly version: 1;
+    readonly kernel: IssuerId;
+    readonly nonce: string;
+    readonly etag: Etag;
+}
+/**
+ * @deprecated Bearer credential of a Delivery transport boundary, the one Delivery v2 admits; use
+ * `Token` of `@astrale-os/kernel-protocol/release/delivery`.
+ */
+export type Token = ReleaseToken;
+/**
+ * Admit the exact request representation accepted by a Delivery transport boundary.
+ *
+ * @deprecated Admits Delivery v1 requests; use `acceptRequest` from
+ * `@astrale-os/kernel-protocol/release/delivery` (Delivery v2, added with `DomainRelease` v4).
+ */
+export declare function acceptRequest(input: unknown): Request;

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

@@ -1,8 +1,13 @@
 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. */
+import { fail } from '../../delivery/error.js';
+import { NONCE_MAX_LENGTH, NONCE_MIN_LENGTH } from '../../delivery/limits.js';
+/**
+ * Admit the exact request representation accepted by a Delivery transport boundary.
+ *
+ * @deprecated Admits Delivery v1 requests; use `acceptRequest` from
+ * `@astrale-os/kernel-protocol/release/delivery` (Delivery v2, added with `DomainRelease` v4).
+ */
 export function acceptRequest(input) {
     if (input === null || typeof input !== 'object' || Array.isArray(input)) {
         fail('DELIVERY_REQUEST_INVALID', 'Expected a Delivery request.');

package/dist/release/legacy/delivery-declaration.d.ts

@@ -0,0 +1,9 @@
+import type { DeliveryDeclaration } from '../declaration.js';
+import type { Endpoint } from '../delivery-endpoint.js';
+/**
+ * Place one provider-neutral Delivery declaration beneath an exact serving issuer.
+ *
+ * @deprecated Use `placeDelivery` from
+ * `@astrale-os/kernel-protocol/release/delivery-declaration`, which reports `ReleaseError`.
+ */
+export declare function placeDelivery(input: DeliveryDeclaration, issuer: string, bundleHref: string): Endpoint;

package/dist/release/legacy/delivery-declaration.js

@@ -0,0 +1,11 @@
+import * as declaration from '../delivery-declaration.js';
+import { withPublicationError } from './error.js';
+/**
+ * Place one provider-neutral Delivery declaration beneath an exact serving issuer.
+ *
+ * @deprecated Use `placeDelivery` from
+ * `@astrale-os/kernel-protocol/release/delivery-declaration`, which reports `ReleaseError`.
+ */
+export function placeDelivery(input, issuer, bundleHref) {
+    return withPublicationError(() => declaration.placeDelivery(input, issuer, bundleHref));
+}

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

@@ -0,0 +1,26 @@
+/**
+ * @deprecated Use `ReleaseErrorCode` from `@astrale-os/kernel-protocol/release`; only the legacy
+ * Publication surface reports these codes.
+ */
+export type PublicationErrorCode = 'PUBLICATION_INVALID' | 'PUBLICATION_ETAG_MISMATCH' | 'PUBLICATION_BINDING_INVALID' | 'PUBLICATION_ROUTE_INVALID' | 'PUBLICATION_VIEW_INVALID';
+/**
+ * @deprecated Use `ReleaseError` from `@astrale-os/kernel-protocol/release`; only the legacy
+ * Publication surface throws it.
+ */
+export declare class PublicationError extends Error {
+    readonly code: PublicationErrorCode;
+    readonly name = "PublicationError";
+    constructor(code: PublicationErrorCode, message: string, options?: ErrorOptions);
+}
+/** Report a failure of a check only Publication v2/v3 performs. */
+export declare function fail(code: PublicationErrorCode, message: string, cause?: unknown): never;
+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;
+/**
+ * Run release validation and report its failure as the legacy surface always has:
+ * `PublicationError` with the corresponding `PUBLICATION_*` code, the historical message, and a
+ * translated cause chain. A `PublicationError` or any other failure passes through unchanged.
+ */
+export declare function withPublicationError<Result>(operation: () => Result): Result;

package/dist/release/legacy/error.js

@@ -0,0 +1,114 @@
+import { ReleaseError } from '../error.js';
+/**
+ * @deprecated Use `ReleaseError` from `@astrale-os/kernel-protocol/release`; only the legacy
+ * Publication surface throws it.
+ */
+export class PublicationError extends Error {
+    code;
+    name = 'PublicationError';
+    constructor(code, message, options) {
+        super(message, options);
+        this.code = code;
+    }
+}
+/** Report a failure of a check only Publication v2/v3 performs. */
+export function fail(code, message, cause) {
+    throw new PublicationError(code, message, cause === undefined ? undefined : { cause });
+}
+/*
+ * Structural checks only Publication v2/v3 performs, reported as `PublicationError` directly. They
+ * are frozen copies of the release checks in `../shape.ts` and leave with this folder.
+ */
+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}.`);
+}
+const CODES = Object.freeze({
+    RELEASE_INVALID: 'PUBLICATION_INVALID',
+    RELEASE_DIGEST_MISMATCH: 'PUBLICATION_ETAG_MISMATCH',
+    RELEASE_BINDING_INVALID: 'PUBLICATION_BINDING_INVALID',
+    RELEASE_ROUTE_INVALID: 'PUBLICATION_ROUTE_INVALID',
+    RELEASE_VIEW_INVALID: 'PUBLICATION_VIEW_INVALID',
+});
+/**
+ * Frozen text the legacy surface reported for each release validator message that names the served
+ * document. Every other release message is reported unchanged.
+ */
+const MESSAGES = new Map([
+    ['Release schema is invalid.', 'Published schema is invalid.'],
+    ['Release schema revision is invalid.', 'Published schema revision is invalid.'],
+    ['Release HTTP route is invalid.', 'Published HTTP route is invalid.'],
+    ['Release View binding is invalid.', 'Published View binding is invalid.'],
+    ['Release issuer is invalid.', 'Publication issuer is invalid.'],
+    ['Release issuer is not an HTTP(S) URL.', 'Publication issuer is not an HTTP(S) URL.'],
+    ['Release bundle is invalid.', 'Publication bundle is invalid.'],
+    ['Release requirements are invalid.', 'Publication requirements are invalid.'],
+    [
+        'Release capability requirements are invalid.',
+        'Publication capability requirements are invalid.',
+    ],
+    ['Release bundle omits an exact dependency.', 'Publication Bundle omits an exact dependency.'],
+    [
+        'Bundle root does not match the release schema.',
+        'Bundle root does not match the Publication schema.',
+    ],
+    ['Release origin is invalid.', 'Publication origin is invalid.'],
+    ['Release identity is invalid.', 'Publication identity is invalid.'],
+    [
+        'Release identity subject must equal its root origin.',
+        'Publication identity subject must equal its root origin.',
+    ],
+    ['Release bindings are invalid.', 'Publication bindings are invalid.'],
+]);
+/**
+ * Run release validation and report its failure as the legacy surface always has:
+ * `PublicationError` with the corresponding `PUBLICATION_*` code, the historical message, and a
+ * translated cause chain. A `PublicationError` or any other failure passes through unchanged.
+ */
+export function withPublicationError(operation) {
+    try {
+        return operation();
+    }
+    catch (cause) {
+        if (cause instanceof ReleaseError)
+            throw publicationError(cause);
+        throw cause;
+    }
+}
+function publicationError(error) {
+    const cause = error.cause instanceof ReleaseError ? publicationError(error.cause) : error.cause;
+    const translated = new PublicationError(CODES[error.code], MESSAGES.get(error.message) ?? error.message, cause === undefined ? undefined : { cause });
+    const stack = validatorStack(error, translated);
+    if (stack !== undefined)
+        translated.stack = stack;
+    return translated;
+}
+/**
+ * Keep the frames of the release check that failed, under the translated header, so the legacy
+ * failure still points at the validator rather than at this translation.
+ */
+function validatorStack(error, translated) {
+    const stack = error.stack;
+    if (stack === undefined)
+        return undefined;
+    const header = `${error.name}: ${error.message}`;
+    return stack.startsWith(header)
+        ? `${translated.name}: ${translated.message}${stack.slice(header.length)}`
+        : stack;
+}

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

@@ -0,0 +1,12 @@
+import type { Sha256Digest } from '../digest.js';
+import type { EtagContent } from './publication.js';
+/**
+ * @deprecated Digest of one v2/v3 Publication; use `ReleaseDigest` from
+ * `@astrale-os/kernel-protocol/release` (added with `DomainRelease` v4).
+ */
+export type Etag = Sha256Digest;
+/**
+ * @deprecated Computes a v2/v3 Publication ETag; use the release `digestOf` from
+ * `@astrale-os/kernel-protocol/release` (added with `DomainRelease` v4).
+ */
+export declare function computeEtag(input: EtagContent): Etag;

package/dist/release/legacy/etag.js

@@ -0,0 +1,14 @@
+import * as portable from '@astrale-os/kernel-dsl/value';
+import { sha256Hex } from '../digest.js';
+import { encodeLegacyRequirements } from './profiles.js';
+/**
+ * @deprecated Computes a v2/v3 Publication ETag; use the release `digestOf` from
+ * `@astrale-os/kernel-protocol/release` (added with `DomainRelease` v4).
+ */
+export function computeEtag(input) {
+    const wire = input.version === 2
+        ? { ...input, requirements: encodeLegacyRequirements(input.requirements) }
+        : input;
+    const bytes = portable.json.encode(wire);
+    return `sha256:${sha256Hex(bytes)}`;
+}

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

@@ -0,0 +1,72 @@
+/**
+ * Publication v2/v3 and Delivery v1 compatibility surface. Shared validators report failures as
+ * `PublicationError`, preserving historical codes, messages and cause chains.
+ *
+ * @deprecated Use `@astrale-os/kernel-protocol/release`, the version-neutral contracts to which
+ * `DomainRelease` v4 (`release.json`), `ReleaseRef` and Delivery v2 are added.
+ *
+ * Historical Publication subpaths resolve here. Persisted Runtime artifacts and installation
+ * fingerprints depend on the v2 `profiles` encoding.
+ *
+ * Short-term consumers:
+ * - the `./publication*` subpaths and the root `publication` namespace: the SDK, which seals,
+ *   serves and admits v3 through them until it adopts the release names, and the CLI, Admin and
+ *   the Issues Domain tests through `@astrale-os/sdk/publication`;
+ * - this folder: the astrale Host's existing v3 installations until their Domains are republished
+ *   as releases, and the 1Pact path, where the client in GUI and Admin reads v3 documents for the
+ *   Kernel .117 Host, whose instances pin the shell-v2 and services-v2 deployments.
+ *
+ * Removal, each in a separate breaking release: the subpaths and the namespace once no repository
+ * imports them; this folder once no supported Kernel predates v4, no installation pins a v2/v3
+ * document, no stable Worker serves one, and the Runtime artifact codec and the installation target
+ * digest own a frozen copy of the v2 `profiles` encoding. With the folder go the
+ * `withPublicationError` call sites outside it (`protocol/routes/compiler.ts`,
+ * `protocol/schema/installation/introspection/codec.ts`; `protocol/routes/legacy/table.ts` goes
+ * with `protocol/routes/legacy/`), whose callers then report `ReleaseError`, once
+ * `protocol/invocation`, `protocol/routes` and `protocol/schema/installation/introspection` no
+ * longer import this folder (`protocol/invocation/legacy/` and `protocol/routes/legacy/` go under
+ * their own headers), and the version-1 branch of the Delivery v2 `acceptRequest`, which then
+ * returns only its own `Request`.
+ *
+ * The frozen v3 projection of a `DomainRelease` (`projection.ts`, served at `domain.json` by v4
+ * deployments) and its golden vectors have their own, later deletion condition: no pre-v4 Kernel
+ * remains, 1Pact `install-domains.mjs` is gone, and the CLI and Admin read `release.json`.
+ */
+import type * as deliveryEndpoint from '../delivery-endpoint.js';
+import type * as digest from '../digest.js';
+import type * as manifest from '../manifest.js';
+import type * as route from '../route.js';
+export { MEDIA_TYPE, LEGACY_MEDIA_TYPE, mediaType, PATH, url, seal, accept, encode, type Content, type Publication, } from './publication.js';
+export { publication } from './projection.js';
+export { acceptBundle, decodeBundle } from './bundle-admission.js';
+export { BUNDLE_MEDIA_TYPE, bundleUrl, describeBundle, type BundleDescriptor } from './bundle.js';
+export { verifyBundleBytes } from './bundle-evidence.js';
+export { placeDelivery } from './delivery-declaration.js';
+/** @deprecated Use `Sha256Digest` from `@astrale-os/kernel-protocol/release`. */
+export type Sha256Digest = digest.Sha256Digest;
+export type { Etag } from './etag.js';
+export { PublicationError, type PublicationErrorCode } from './error.js';
+/**
+ * @deprecated Delivery v1; use Delivery v2 (`@astrale-os/kernel-protocol/release/delivery`, added
+ * with `DomainRelease` v4).
+ */
+export * as delivery from './delivery/index.js';
+/** @deprecated Use `DeliveryEndpoint` from `@astrale-os/kernel-protocol/release`. */
+export type DeliveryEndpoint = deliveryEndpoint.Endpoint;
+/** @deprecated Use `Manifest` from `@astrale-os/kernel-protocol/release`. */
+export type Manifest = manifest.Manifest;
+export { admitRequirements, validateRequirements, type CapabilityAuthorityRequirements, type CoreCapabilityRequirement, 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';
+/** @deprecated Use `HttpRoute` from `@astrale-os/kernel-protocol/release`. */
+export type HttpRoute = route.HttpRoute;
+/** @deprecated Use `HttpRouteDeclaration` from `@astrale-os/kernel-protocol/release`. */
+export type HttpRouteDeclaration = route.HttpRouteDeclaration;
+/** @deprecated Use `HttpMethod` from `@astrale-os/kernel-protocol/release`. */
+export type HttpMethod = route.HttpMethod;
+/** @deprecated Use `RouteBody` from `@astrale-os/kernel-protocol/release`. */
+export type RouteBody = route.RouteBody;
+/** @deprecated Use `RouteHeaders` from `@astrale-os/kernel-protocol/release`. */
+export type RouteHeaders = route.RouteHeaders;
+/** @deprecated Use `CredentialSource` from `@astrale-os/kernel-protocol/release`. */
+export type CredentialSource = route.CredentialSource;
+export { acceptInvocationEndpoints, type CallableBinding, type InvocationEndpoints, type ViewBinding, } from './bindings.js';

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

@@ -1,10 +1,15 @@
 export { MEDIA_TYPE, LEGACY_MEDIA_TYPE, mediaType, PATH, url, seal, accept, encode, } from './publication.js';
+export { publication } from './projection.js';
 export { acceptBundle, decodeBundle } from './bundle-admission.js';
 export { BUNDLE_MEDIA_TYPE, bundleUrl, describeBundle } from './bundle.js';
 export { verifyBundleBytes } from './bundle-evidence.js';
 export { placeDelivery } from './delivery-declaration.js';
 export { PublicationError } from './error.js';
+/**
+ * @deprecated Delivery v1; use Delivery v2 (`@astrale-os/kernel-protocol/release/delivery`, added
+ * with `DomainRelease` v4).
+ */
 export * as delivery from './delivery/index.js';
-export { ClassOperationOrder, admitRequirements, validateRequirements, } from './requirements.js';
+export { admitRequirements, validateRequirements, } from './requirements.js';
 export { acceptReference, compareReference, compareReferences, matchesReference, reference, } from './reference.js';
-export { acceptInvocationEndpoints, } from './bindings/index.js';
+export { acceptInvocationEndpoints, } from './bindings.js';

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

@@ -0,0 +1,23 @@
+import type { Requirements } from '../requirements.js';
+/**
+ * Read the retired v2 wire coordinate without exposing it in canonical requirements.
+ *
+ * @deprecated Only Publication v2 and Runtime artifact v2 carry `profiles`; use `admitRequirements`
+ * from `@astrale-os/kernel-protocol/release`, whose canonical requirements carry `core`.
+ */
+export declare function decodeLegacyRequirements(input: unknown): Requirements;
+/**
+ * Preserve immutable v2 bytes and the historical installation-target digest vocabulary.
+ *
+ * @deprecated Only Publication v2 and Runtime artifact v2 carry `profiles`; use the canonical
+ * `Requirements` from `@astrale-os/kernel-protocol/release`, which carry `core` and are encoded as
+ * they are.
+ */
+export declare function encodeLegacyRequirements(input: Requirements): Readonly<{
+    capabilities: Readonly<{
+        functions?: import("../requirements.js").NonEmpty<import("@astrale-os/kernel-dsl/v1").Key.Callable>;
+        classes?: import("../requirements.js").NonEmpty<import("../requirements.js").ClassCapabilityRequirement>;
+        authority?: import("../requirements.js").CapabilityAuthorityRequirements;
+        profiles?: import("../requirements.js").NonEmpty<import("../requirements.js").CoreCapabilityRequirement> | undefined;
+    }>;
+}>;

package/dist/release/legacy/profiles.js

@@ -0,0 +1,36 @@
+import { admitRequirements } from '../requirements.js';
+import { exact, record, withPublicationError } from './error.js';
+/**
+ * Read the retired v2 wire coordinate without exposing it in canonical requirements.
+ *
+ * @deprecated Only Publication v2 and Runtime artifact v2 carry `profiles`; use `admitRequirements`
+ * from `@astrale-os/kernel-protocol/release`, whose canonical requirements carry `core`.
+ */
+export function decodeLegacyRequirements(input) {
+    return withPublicationError(() => {
+        const requirements = record(input, 'PUBLICATION_INVALID', 'Publication requirements are invalid.');
+        exact(requirements, ['capabilities'], 'PUBLICATION_INVALID');
+        const capabilities = record(requirements.capabilities, 'PUBLICATION_INVALID', 'Publication capability requirements are invalid.');
+        exact(capabilities, ['authority', 'classes', 'functions', 'profiles'], 'PUBLICATION_INVALID');
+        const { profiles, ...principal } = capabilities;
+        return admitRequirements({
+            capabilities: { ...principal, ...(profiles === undefined ? {} : { core: profiles }) },
+        });
+    });
+}
+/**
+ * Preserve immutable v2 bytes and the historical installation-target digest vocabulary.
+ *
+ * @deprecated Only Publication v2 and Runtime artifact v2 carry `profiles`; use the canonical
+ * `Requirements` from `@astrale-os/kernel-protocol/release`, which carry `core` and are encoded as
+ * they are.
+ */
+export function encodeLegacyRequirements(input) {
+    const { core, ...principal } = input.capabilities;
+    return Object.freeze({
+        capabilities: Object.freeze({
+            ...principal,
+            ...(core === undefined ? {} : { profiles: core }),
+        }),
+    });
+}

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

@@ -0,0 +1,13 @@
+import type { DomainRelease } from '../release.js';
+import type { Publication } 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 declare function publication(release: DomainRelease): Publication;