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

package/dist/release/requirements.d.ts

@@ -29,7 +29,7 @@ export interface Requirements {
     readonly capabilities: CapabilityRequirements;
 }
 /**
- * Admit the exact closed canonical requirements object, the `core` form Publication v3 introduced.
+ * Admit the exact closed canonical Release requirements object.
  */
 export declare function admitRequirements(input: unknown): Requirements;
 /** Bind explicit capability targets to exact functional dependencies in the bundle closure. */

package/dist/release/requirements.js

@@ -17,7 +17,7 @@ export const ClassOperationOrder = Object.freeze([
     'delete',
 ]);
 /**
- * Admit the exact closed canonical requirements object, the `core` form Publication v3 introduced.
+ * Admit the exact closed canonical Release requirements object.
  */
 export function admitRequirements(input) {
     const requirements = record(input, 'RELEASE_INVALID', 'Release requirements are invalid.');

package/dist/release/served.d.ts

@@ -13,7 +13,7 @@ export interface ServedContent extends ServedRelease {
     };
     readonly delivery?: DeliveryEndpoint;
 }
-export interface ServedOptions {
+interface ServedOptions {
     /** `canonicalize` normalizes authored View bindings before sealing; `admit` requires canonical ones. */
     readonly views: 'canonicalize' | 'admit';
     /** Reads the requirements coordinate of the document version; canonical `core` by default. */
@@ -24,3 +24,4 @@ export interface ServedOptions {
  * these checks in this order, so a document of any version admits exactly the same served content.
  */
 export declare function admitServedContent(value: Readonly<Record<string, unknown>>, options: ServedOptions): ServedContent;
+export {};

package/dist/release/served.js

@@ -1,4 +1,4 @@
-import { Key, patterns } from '@astrale-os/kernel-dsl/v1/addressing';
+import { patterns } from '@astrale-os/kernel-dsl/v1/addressing';
 import { admitCallableBinding, admitViewBinding } from './bindings/index.js';
 import { canonicalizeViewBinding } from './bindings/view.js';
 import { admitEndpoint as admitDeliveryEndpoint } from './delivery-endpoint.js';
@@ -42,15 +42,6 @@ export function admitServedContent(value, options) {
             fail('RELEASE_ROUTE_INVALID', `Callable ${callable} has more than one default route.`);
         }
     }
-    if (manifest?.entrypoint !== undefined) {
-        if (manifest.entrypoint.origin !== origin) {
-            fail('RELEASE_VIEW_INVALID', 'Manifest entrypoint must belong to the root origin.');
-        }
-        const key = Key.of(manifest.entrypoint);
-        if (!views.some(({ view }) => view === key)) {
-            fail('RELEASE_VIEW_INVALID', 'Manifest entrypoint must have a published View binding.');
-        }
-    }
     const delivery = admitDeliveryEndpoint(value.delivery, schema.bundle.href);
     return {
         origin,

package/dist/routes/compiler.js

@@ -1,5 +1,4 @@
 import { isBinaryInput } from '@astrale-os/kernel-dsl/v1/language';
-import { withPublicationError } from '../release/legacy/error.js';
 import { admitRouteDeclaration } from '../release/route.js';
 import { rejectCollisions } from './collision.js';
 import { fail } from './error.js';
@@ -10,7 +9,7 @@ export function compile(input) {
     if (input === null || typeof input !== 'object' || !Array.isArray(input.routes)) {
         throw new TypeError('Route compilation input is invalid.');
     }
-    const authored = input.routes.map((entry) => withPublicationError(() => admitRouteDeclaration(entry, input.domain.origin)));
+    const authored = input.routes.map((entry) => admitRouteDeclaration(entry, input.domain.origin));
     const entries = authored.map((declaration) => {
         const meaning = input.domain.callable(declaration.callable);
         if (meaning === undefined || (isMethod(meaning) && !meaning.executable)) {

package/dist/routes/credential.d.ts

@@ -10,7 +10,6 @@ export interface LocatedCredential {
     readonly value: string;
     readonly in: SingleCredentialSource['in'];
 }
-export declare function readCredential(entry: Route, url: URL, headers: Record<string, string>): string | undefined;
 /**
  * Read the request credential and report which declared channel supplied it. A `cookie` channel is
  * ambient (the browser attaches it automatically), which the Server uses to decide CSRF defense; a

package/dist/routes/credential.js

@@ -51,9 +51,6 @@ export function withoutCredentialHeaders(entry, input) {
     }
     return output;
 }
-export function readCredential(entry, url, headers) {
-    return locateCredential(entry, url, headers)?.value;
-}
 /**
  * Read the request credential and report which declared channel supplied it. A `cookie` channel is
  * ambient (the browser attaches it automatically), which the Server uses to decide CSRF defense; a

package/dist/routes/index.d.ts

@@ -17,6 +17,3 @@ export { decodeRouting, decodeMiss, decodeStale, HTTP_ROUTE_DIGEST, HTTP_ROUTE_I
 export { select } from './select.js';
 export { decodeStreamFrame, encodeStreamFrame, STREAM_MEDIA_TYPE, type StreamFrame, } from './stream.js';
 export { templatesOverlap } from './template.js';
-/** @deprecated Native routes of a v3-input destination; use the release-bound Table and decoders. */
-export * as legacy from './legacy/index.js';
-export { HTTP_ROUTE_PUBLICATION } from './legacy/index.js';

package/dist/routes/index.js

@@ -14,6 +14,3 @@ export { decodeRouting, decodeMiss, decodeStale, HTTP_ROUTE_DIGEST, HTTP_ROUTE_I
 export { select } from './select.js';
 export { decodeStreamFrame, encodeStreamFrame, STREAM_MEDIA_TYPE, } from './stream.js';
 export { templatesOverlap } from './template.js';
-/** @deprecated Native routes of a v3-input destination; use the release-bound Table and decoders. */
-export * as legacy from './legacy/index.js';
-export { HTTP_ROUTE_PUBLICATION } from './legacy/index.js';

package/dist/routes/request.d.ts

@@ -1,5 +1,5 @@
 import type { Value } from '@astrale-os/kernel-dsl/value';
-import type { Call, PublicationVia, Via } from '../invocation/index.js';
+import type { Call, Via } from '../invocation/index.js';
 import type { HttpMethod } from '../release/route.js';
 /** Canonical invocation values presented to or returned from a native route mapping. */
 export interface Invocation {
@@ -7,7 +7,7 @@ export interface Invocation {
     readonly credential?: string;
     /** The request channel that carried `credential`; `cookie` is ambient (CSRF-exposed). */
     readonly credentialIn?: 'header' | 'cookie' | 'query';
-    readonly routing?: Via | PublicationVia;
+    readonly routing?: Via;
     readonly method?: Exclude<HttpMethod, '*'>;
 }
 export interface Request {

package/dist/routes/reservation.d.ts

@@ -1,5 +1,5 @@
 import type { DomainRelease } from '../release/release.js';
 import type { Route } from './table.js';
-/** The fields of a served document that route binding reads, whichever document version it is. */
+/** The canonical Release fields read by route reservation admission. */
 export type Placed = Pick<DomainRelease, 'origin' | 'identity' | 'schema' | 'bindings' | 'routes' | 'delivery'>;
-export declare function rejectReserved(publication: Placed, entries: readonly Route[]): void;
+export declare function rejectReserved(release: Placed, entries: readonly Route[]): void;

package/dist/routes/reservation.js

@@ -1,23 +1,22 @@
 import * as issuer from '../issuer/index.js';
 import { bundleUrl } from '../release/bundle.js';
-import { PATH as PUBLICATION_PATH } from '../release/legacy/publication.js';
 import { PATH as RELEASE_PATH } from '../release/release.js';
 import { fail } from './error.js';
 import { templateUrl, templatesOverlap } from './template.js';
-const STATIC_RESERVED_PATHS = new Set([RELEASE_PATH, PUBLICATION_PATH]);
-export function rejectReserved(publication, entries) {
-    const discovery = issuer.paths(publication.identity.issuer);
+const STATIC_RESERVED_PATHS = new Set([RELEASE_PATH]);
+export function rejectReserved(release, entries) {
+    const discovery = issuer.paths(release.identity.issuer);
     const reservedPaths = new Set([...STATIC_RESERVED_PATHS, discovery.configuration, discovery.keys]);
     const reservedUrls = [
-        publication.schema.bundle.href,
-        ...(publication.delivery === undefined ? [] : [publication.delivery.href]),
-        ...publication.bindings.callables.flatMap(({ endpoint }) => [
+        release.schema.bundle.href,
+        ...(release.delivery === undefined ? [] : [release.delivery.href]),
+        ...release.bindings.callables.flatMap(({ endpoint }) => [
             endpoint.http,
             ...(endpoint.websocket === undefined ? [] : [httpUrlForWebSocket(endpoint.websocket)]),
         ]),
     ];
-    const addressed = bundleUrl(publication.identity.issuer, publication.schema.bundle.ref);
-    const bundlePattern = publication.schema.bundle.href === addressed
+    const addressed = bundleUrl(release.identity.issuer, release.schema.bundle.ref);
+    const bundlePattern = release.schema.bundle.href === addressed
         ? `${addressed.slice(0, addressed.lastIndexOf('/') + 1)}{artifact}`
         : undefined;
     for (const entry of entries) {

package/dist/routes/routing.d.ts

@@ -1,11 +1,10 @@
 import type * as invocation from '../invocation/index.js';
 import type { Sha256Digest } from '../release/digest.js';
-import type { PublicationRef } from '../release/legacy/reference.js';
 import type { ReleaseRef } from '../release/reference.js';
 import type { HttpRequest } from './request.js';
 export interface StaleControl {
     readonly kind: 'stale';
-    /** Current Publication ETag; release-backed destinations report their frozen v3 projection's ETag. */
+    /** Current release digest. */
     readonly current: Sha256Digest;
 }
 export interface MissControl {
@@ -14,13 +13,6 @@ export interface MissControl {
 /** The references one release-backed destination answers native routes for. */
 export interface ServedReferences {
     readonly release: ReleaseRef;
-    /**
-     * Reference of the frozen v3 projection the destination serves at `domain.json`, which a
-     * legacy native-route If-Match names by its Publication ETag.
-     *
-     * @deprecated Successor: the release digest in If-Match, emitted by the breaking release (AM-1).
-     */
-    readonly projection: PublicationRef;
 }
 /** If-Match carries the routed digest of a native route request (`invocation.routedDigest`). */
 export declare const HTTP_ROUTE_DIGEST: 'if-match';
@@ -30,14 +22,10 @@ export declare const HTTP_ROUTE_STALE_STATUS: 412;
 export declare const HTTP_ROUTE_MISS: 'x-astrale-route-miss';
 export declare const HTTP_ROUTE_MISS_STATUS: 421;
 /**
- * Decode the native routing pair of one request against the references a release-backed
- * destination serves: an If-Match naming its release digest is a `Via`, one naming its projection
- * ETag a legacy `PublicationVia`. An If-Match naming any other strong digest is stale whether or
- * not the issuer header is present, as a Server answers before decoding; otherwise both headers
- * are required. Stale reports the projection ETag as current, the legacy meaning every
- * native-route value keeps until the breaking release (AM-1).
+ * Decode a native route witness against the served release. A different strong digest is stale
+ * before issuer admission; otherwise the digest and issuer must occur together.
  */
-export declare function decodeRouting(input: Pick<HttpRequest, 'headers'>, served: ServedReferences): invocation.Via | invocation.PublicationVia | StaleControl | undefined;
+export declare function decodeRouting(input: Pick<HttpRequest, 'headers'>, served: ServedReferences): invocation.Via | StaleControl | undefined;
 /** Emit the reserved stale header naming `current` (see `StaleControl.current`). */
 export declare function staleHeaders(current: Sha256Digest): Readonly<Record<string, string>>;
 export declare function decodeStale(status: number, headers: HttpRequest['headers']): StaleControl | undefined;

package/dist/routes/routing.js

@@ -8,12 +8,8 @@ export const HTTP_ROUTE_STALE_STATUS = 412;
 export const HTTP_ROUTE_MISS = 'x-astrale-route-miss';
 export const HTTP_ROUTE_MISS_STATUS = 421;
 /**
- * Decode the native routing pair of one request against the references a release-backed
- * destination serves: an If-Match naming its release digest is a `Via`, one naming its projection
- * ETag a legacy `PublicationVia`. An If-Match naming any other strong digest is stale whether or
- * not the issuer header is present, as a Server answers before decoding; otherwise both headers
- * are required. Stale reports the projection ETag as current, the legacy meaning every
- * native-route value keeps until the breaking release (AM-1).
+ * Decode a native route witness against the served release. A different strong digest is stale
+ * before issuer admission; otherwise the digest and issuer must occur together.
  */
 export function decodeRouting(input, served) {
     const encodedDigest = reservedHeader(input.headers, HTTP_ROUTE_DIGEST);
@@ -21,8 +17,8 @@ export function decodeRouting(input, served) {
     if (encodedDigest === undefined && encodedIssuer === undefined)
         return undefined;
     const named = encodedDigest === undefined ? undefined : strongDigest(encodedDigest);
-    if (named !== undefined && named !== served.release.digest && named !== served.projection.etag) {
-        return Object.freeze({ kind: 'stale', current: served.projection.etag });
+    if (named !== undefined && named !== served.release.digest) {
+        return Object.freeze({ kind: 'stale', current: served.release.digest });
     }
     if (encodedDigest === undefined || encodedIssuer === undefined) {
         fail('NATIVE_ROUTE_ROUTING_INVALID', `${HTTP_ROUTE_DIGEST} and ${HTTP_ROUTE_ISSUER} must occur together.`);
@@ -31,9 +27,7 @@ export function decodeRouting(input, served) {
         fail('NATIVE_ROUTE_ROUTING_INVALID', 'If-Match must contain exactly one strong quoted digest.');
     }
     const issuer = acceptIssuerHeader(encodedIssuer, HTTP_ROUTE_ISSUER);
-    return named === served.release.digest
-        ? Object.freeze({ kind: 'via', release: served.release, issuer })
-        : Object.freeze({ kind: 'via', publication: served.projection, issuer });
+    return Object.freeze({ kind: 'via', release: served.release, issuer });
 }
 /** Emit the reserved stale header naming `current` (see `StaleControl.current`). */
 export function staleHeaders(current) {

package/dist/routes/template.d.ts

@@ -1,7 +1,6 @@
 export declare const PLACEHOLDER: RegExp;
 export declare function validateTemplate(href: string): void;
 export declare function templateUrl(href: string): URL;
-export declare function routePattern(href: string): string;
 export declare function templatesOverlap(left: string, right: string): boolean;
 export declare function matchTemplate(template: string, input: string): Record<string, string> | undefined;
 export declare function encodeTemplate(value: unknown, catchall: string | undefined, host: boolean): string;

package/dist/routes/template.js

@@ -43,9 +43,6 @@ export function templateUrl(href) {
         throw cause;
     }
 }
-export function routePattern(href) {
-    return href.replaceAll(PLACEHOLDER, (_whole, _name, catchall) => catchall === '+' ? '{+}' : catchall === '*' ? '{*}' : '{}');
-}
 export function templatesOverlap(left, right) {
     const leftUrl = templateUrl(left);
     const rightUrl = templateUrl(right);

package/dist/runtime/artifact.d.ts

@@ -31,15 +31,14 @@ export interface Module {
 /** Immutable portable closure selected by one local Schema installation source. */
 export interface RuntimeArtifact {
     readonly format: 'astrale.domain-runtime-artifact';
-    readonly version: 2 | 3;
+    readonly version: 3;
     readonly issuer: IssuerId;
     readonly bundle: Ref;
     readonly requirements: Requirements;
     readonly modules: readonly [Module, ...Module[]];
 }
 export declare const MEDIA_TYPE: 'application/vnd.astrale.domain-runtime+json;v=3';
-export declare const LEGACY_MEDIA_TYPE: 'application/vnd.astrale.domain-runtime+json;v=2';
-export declare function mediaType(input: Pick<RuntimeArtifact, 'version'>): typeof MEDIA_TYPE | typeof LEGACY_MEDIA_TYPE;
+export declare function mediaType(_input: Pick<RuntimeArtifact, 'version'>): typeof MEDIA_TYPE;
 export declare function accept(input: unknown): RuntimeArtifact;
 export declare function encode(input: RuntimeArtifact): Uint8Array;
 export declare function runtimeDigest(input: RuntimeArtifact): Digest;

package/dist/runtime/artifact.js

@@ -3,27 +3,22 @@ import { patterns } from '@astrale-os/kernel-dsl/v1/addressing';
 import * as portable from '@astrale-os/kernel-dsl/value';
 import { sha256 } from '@noble/hashes/sha2.js';
 import * as artifact from '../artifact/index.js';
-import { decodeLegacyRequirements, encodeLegacyRequirements } from '../release/legacy/profiles.js';
-import { admitRequirements } from '../release/legacy/requirements.js';
+import { admitRequirements } from '../release/requirements.js';
 export const MEDIA_TYPE = 'application/vnd.astrale.domain-runtime+json;v=3';
-export const LEGACY_MEDIA_TYPE = 'application/vnd.astrale.domain-runtime+json;v=2';
-export function mediaType(input) {
-    return input.version === 2 ? LEGACY_MEDIA_TYPE : MEDIA_TYPE;
+export function mediaType(_input) {
+    return MEDIA_TYPE;
 }
 export function accept(input) {
     const root = record(input, 'Domain Runtime artifact');
     exact(root, ['bundle', 'format', 'issuer', 'modules', 'requirements', 'version']);
-    if (root.format !== 'astrale.domain-runtime-artifact' ||
-        (root.version !== 2 && root.version !== 3)) {
+    if (root.format !== 'astrale.domain-runtime-artifact' || root.version !== 3) {
         invalid('Domain Runtime artifact format or version is unsupported.');
     }
     if (typeof root.issuer !== 'string')
         invalid('Domain Runtime artifact issuer is invalid.');
     const admittedIssuer = acceptIssuer(root.issuer);
     const bundle = artifact.accept(root.bundle);
-    const requirements = root.version === 2
-        ? decodeLegacyRequirements(root.requirements)
-        : admitRequirements(root.requirements);
+    const requirements = admitRequirements(root.requirements);
     if (!Array.isArray(root.modules) || root.modules.length === 0) {
         invalid('Domain Runtime artifact requires at least one Module.');
     }
@@ -42,15 +37,10 @@ export function accept(input) {
     });
 }
 export function encode(input) {
-    return portable.json.encode(wire(accept(wire(input))));
+    return portable.json.encode(accept(input));
 }
 export function runtimeDigest(input) {
-    return digestBytes(portable.json.encode(wire(input)));
-}
-function wire(input) {
-    return input.version === 2
-        ? { ...input, requirements: encodeLegacyRequirements(input.requirements) }
-        : input;
+    return digestBytes(portable.json.encode(input));
 }
 export function acceptExecutable(input) {
     return executable(input, 0);

package/dist/runtime/index.d.ts

@@ -1 +1 @@
-export { MEDIA_TYPE, LEGACY_MEDIA_TYPE, mediaType, accept, acceptExecutable, encode, executableClosure, executableDigest, runtimeDigest, type Digest, type Executable, type ExecutableDependency, type Export, type Module, type RuntimeArtifact, type Ref, } from './artifact.js';
+export { MEDIA_TYPE, mediaType, accept, acceptExecutable, encode, executableClosure, executableDigest, runtimeDigest, type Digest, type Executable, type ExecutableDependency, type Export, type Module, type RuntimeArtifact, type Ref, } from './artifact.js';

package/dist/runtime/index.js

@@ -1 +1 @@
-export { MEDIA_TYPE, LEGACY_MEDIA_TYPE, mediaType, accept, acceptExecutable, encode, executableClosure, executableDigest, runtimeDigest, } from './artifact.js';
+export { MEDIA_TYPE, mediaType, accept, acceptExecutable, encode, executableClosure, executableDigest, runtimeDigest, } from './artifact.js';

package/dist/schema/installation/codec.d.ts

@@ -1,9 +1,4 @@
 import type { InstallResult } from './result.js';
-export declare const MEDIA_TYPE: 'application/vnd.astrale.schema-installation.v2+json';
+export declare const MEDIA_TYPE: 'application/vnd.astrale.schema-installation.v3+json';
 export declare function encode(result: InstallResult): Promise<Uint8Array>;
 export declare function decode(bytes: Uint8Array, maximumBytes: number): Promise<InstallResult>;
-/**
- * Package-private: admit one decoded installation result. Shared with the pre-R1 representation in
- * `./legacy/`, which decodes other bytes into this same wire value.
- */
-export declare function accept(input: unknown): InstallResult;

package/dist/schema/installation/codec.js

@@ -1,7 +1,7 @@
 import { installReceipt } from '@astrale-os/kernel-core/schema/kernel/syscalls/contracts';
 import { json } from '@astrale-os/kernel-dsl/value';
 import { acceptDomainInfo } from './introspection/index.js';
-export const MEDIA_TYPE = 'application/vnd.astrale.schema-installation.v2+json';
+export const MEDIA_TYPE = 'application/vnd.astrale.schema-installation.v3+json';
 const encoder = new TextEncoder();
 export async function encode(result) {
     return encoder.encode(json.serialize(accept(result)));
@@ -22,11 +22,7 @@ export async function decode(bytes, maximumBytes) {
     }
     return accept(value);
 }
-/**
- * Package-private: admit one decoded installation result. Shared with the pre-R1 representation in
- * `./legacy/`, which decodes other bytes into this same wire value.
- */
-export function accept(input) {
+function accept(input) {
     const value = record(input);
     if (value.changed === true) {
         exact(value, ['changed', 'receipt']);

package/dist/schema/installation/introspection/codec.d.ts

@@ -1,17 +1,8 @@
 import type { introspection } from '@astrale-os/kernel-core/schema';
-import type { DomainBundle, DomainDependencies, DomainInfo, InstalledRelease, Limits, ResultFor } from './result.js';
-export declare const MEDIA_TYPE: 'application/vnd.astrale.schema-introspection.v3+json';
+import type { DomainDependencies, DomainInfo, Limits, ResultFor } from './result.js';
+export declare const MEDIA_TYPE: 'application/vnd.astrale.schema-introspection.v4+json';
 export declare function encode<Input extends introspection.Introspection>(input: Input, result: ResultFor<Input>): Promise<Uint8Array>;
 export declare function decode<Input extends introspection.Introspection>(input: Input, bytes: Uint8Array, limits: Limits): Promise<ResultFor<Input>>;
-/**
- * Package-private: admit one decoded evidence value for an admitted request. Shared with the
- * pre-R1 representation in `../legacy/`, which decodes other bytes into this same wire value.
- */
-export declare function acceptEvidence(request: introspection.Introspection, decoded: unknown, limits: Limits): DomainInfo | DomainBundle | DomainDependencies | readonly InstalledRelease[];
-/** Package-private: admit the evidence bounds a request declares. Shared with `../legacy/`. */
-export declare function admitLimits(request: introspection.Introspection, limits: Limits): void;
 /** Admit dependency bindings: origin-ordered, one per origin, each label agreeing with its revisions. */
 export declare function acceptDomainDependencies(input: unknown): DomainDependencies;
 export declare function acceptDomainInfo(input: unknown): DomainInfo;
-/** Package-private: admit one introspection request. Shared with `../legacy/`. */
-export declare function admitRequest(input: introspection.Introspection): introspection.Introspection;

package/dist/schema/installation/introspection/codec.js

@@ -4,9 +4,8 @@ import * as bundle from '@astrale-os/kernel-dsl/v1/bundle/transport';
 import { revision as schemaRevision } from '@astrale-os/kernel-dsl/v1/schema/revision';
 import { json } from '@astrale-os/kernel-dsl/value';
 import { admitCallableBinding, admitViewBinding } from '../../../release/bindings/index.js';
-import { withPublicationError } from '../../../release/legacy/error.js';
-import * as publication from '../../../release/legacy/index.js';
-export const MEDIA_TYPE = 'application/vnd.astrale.schema-introspection.v3+json';
+import * as release from '../../../release/index.js';
+export const MEDIA_TYPE = 'application/vnd.astrale.schema-introspection.v4+json';
 const encoder = new TextEncoder();
 const serializedBundles = new WeakMap();
 const admittedBundles = new Map();
@@ -37,7 +36,7 @@ export async function decode(input, bytes, limits) {
     if (!(bytes instanceof Uint8Array))
         invalid('Schema introspection evidence must be binary.');
     admitLimits(request, limits);
-    const maximumEvidenceBytes = limits.maximumPublicationBytes +
+    const maximumEvidenceBytes = limits.maximumReleaseBytes +
         (request.kind === 'bundle' ? BUNDLE_ESCAPE_FACTOR * limits.maximumBundleBytes : 0) +
         4_096;
     if (bytes.byteLength > maximumEvidenceBytes) {
@@ -57,11 +56,7 @@ export async function decode(input, bytes, limits) {
     }
     return acceptEvidence(request, decoded, limits);
 }
-/**
- * Package-private: admit one decoded evidence value for an admitted request. Shared with the
- * pre-R1 representation in `../legacy/`, which decodes other bytes into this same wire value.
- */
-export function acceptEvidence(request, decoded, limits) {
+function acceptEvidence(request, decoded, limits) {
     if (request.kind === 'installed')
         return acceptInstalledReleases(decoded);
     const result = request.kind === 'bundle'
@@ -72,9 +67,9 @@ export function acceptEvidence(request, decoded, limits) {
     proveRequestedOrigin(request, result);
     return result;
 }
-/** Package-private: admit the evidence bounds a request declares. Shared with `../legacy/`. */
-export function admitLimits(request, limits) {
-    admitLimit(limits.maximumPublicationBytes, 'Publication');
+/** Admit the evidence bounds a request declares. */
+function admitLimits(request, limits) {
+    admitLimit(limits.maximumReleaseBytes, 'Release');
     if (request.kind === 'bundle')
         admitLimit(limits.maximumBundleBytes, 'Bundle');
 }
@@ -174,19 +169,6 @@ function installedPin(input) {
             build: digest(value.build, 'Installed build'),
         });
     }
-    // Deprecated legacy v2/v3 pin: deleted with the `legacy` variant of `InstalledPin`, in the
-    // breaking release that deletes `runtime/schema/installation/source/legacy/`.
-    if (value.kind === 'legacy') {
-        exact(value, ['document', 'etag', 'kind'], 'Installed legacy pin');
-        if (value.document !== 2 && value.document !== 3) {
-            invalid('Installed legacy pin document version is invalid.');
-        }
-        return Object.freeze({
-            kind: 'legacy',
-            document: value.document,
-            etag: digest(value.etag, 'Installed legacy Publication'),
-        });
-    }
     return invalid('Installed pin kind is invalid.');
 }
 function inFlightIssuers(input, current) {
@@ -279,7 +261,7 @@ function encodeDomainInfo(input) {
 }
 export function acceptDomainInfo(input) {
     const value = record(input, 'Domain info');
-    exact(value, ['bindings', 'capabilities', 'generation', 'origin', 'publication', 'readiness', 'revision'], 'Domain info');
+    exact(value, ['bindings', 'capabilities', 'generation', 'origin', 'release', 'readiness', 'revision'], 'Domain info');
     if (typeof value.origin !== 'string' || !patterns.origin.test(value.origin)) {
         invalid('Domain info origin is invalid.');
     }
@@ -288,29 +270,29 @@ export function acceptDomainInfo(input) {
     }
     const origin = value.origin;
     const revision = value.revision;
-    const published = publicationReference(value.publication, origin, revision);
+    const published = releaseReference(value.release, origin, revision);
     return Object.freeze({
         origin,
         revision,
         generation: digest(value.generation, 'Domain generation'),
-        publication: published,
+        release: published,
         readiness: digest(value.readiness, 'Domain readiness'),
         capabilities: capabilities(value.capabilities),
         bindings: bindings(value.bindings, origin),
     });
 }
-function publicationReference(input, origin, revision) {
+function releaseReference(input, origin, revision) {
     if (input === null)
         return null;
     let admitted;
     try {
-        admitted = publication.acceptReference(input);
+        admitted = release.acceptReference(input);
     }
     catch (cause) {
-        throw new TypeError('Domain Publication metadata is invalid.', { cause });
+        throw new TypeError('Domain Release metadata is invalid.', { cause });
     }
     if (admitted.origin !== origin || admitted.revision !== revision) {
-        invalid('Domain Publication metadata does not match its Schema coordinate.');
+        invalid('Domain Release metadata does not match its Schema coordinate.');
     }
     return admitted;
 }
@@ -322,10 +304,10 @@ function bindings(input, origin) {
         invalid('Domain bindings are invalid.');
     }
     try {
-        return withPublicationError(() => Object.freeze({
+        return Object.freeze({
             callables: Object.freeze(callables.map((entry) => admitCallableBinding(entry, origin))),
             views: Object.freeze(views.map((entry) => admitViewBinding(entry, origin))),
-        }));
+        });
     }
     catch (cause) {
         throw new TypeError('Domain bindings are invalid.', { cause });
@@ -340,8 +322,8 @@ function capabilities(input) {
     const value = record(input, 'Domain capabilities');
     exact(value, ['materialized', 'requested'], 'Domain capabilities');
     try {
-        const requested = publication.admitRequirements({ capabilities: value.requested }).capabilities;
-        const materialized = publication.admitRequirements({
+        const requested = release.admitRequirements({ capabilities: value.requested }).capabilities;
+        const materialized = release.admitRequirements({
             capabilities: value.materialized,
         }).capabilities;
         return Object.freeze({ requested, materialized });
@@ -350,8 +332,8 @@ function capabilities(input) {
         throw new TypeError('Domain capabilities are invalid.', { cause });
     }
 }
-/** Package-private: admit one introspection request. Shared with `../legacy/`. */
-export function admitRequest(input) {
+/** Admit one introspection request. */
+function admitRequest(input) {
     const value = record(input, 'Schema introspection request');
     if (value.kind === 'installed') {
         exact(value, ['kind'], 'Schema introspection request');

package/dist/schema/installation/introspection/result.d.ts

@@ -1,28 +1,21 @@
 import type { IssuerId } from '@astrale-os/kernel-core/auth/issuer';
 import type { introspection } from '@astrale-os/kernel-core/schema';
 import type { bundle, Key, Revision } from '@astrale-os/kernel-dsl/v1';
-import type { BuildDigest, ReleaseDigest } from '../../../release/index.js';
-import type { Publication, PublicationRef, PublicationRequirements } from '../../../release/legacy/index.js';
+import type { BuildDigest, ReleaseDigest, ReleaseRef, DomainRelease, Requirements } from '../../../release/index.js';
 export type Digest = `sha256:${string}`;
 /** Lightweight proof of one exact ready installed Domain generation. */
 export interface DomainInfo {
     readonly origin: Key.Origin;
     readonly revision: Revision;
     readonly generation: Digest;
-    /**
-     * Installed Publication reference: the pinned document's own for a legacy pin, the reference of
-     * the frozen v3 projection for a v4 pin.
-     *
-     * @deprecated Successor: `DomainInfo.release`, the installed `ReleaseRef`, emitted by the
-     * breaking release (AM-1).
-     */
-    readonly publication: PublicationRef | null;
+    /** Exact reference of the ready pinned release, or null for a local Domain. */
+    readonly release: ReleaseRef | null;
     readonly readiness: Digest;
     readonly capabilities: {
-        readonly requested: PublicationRequirements['capabilities'];
-        readonly materialized: PublicationRequirements['capabilities'];
+        readonly requested: Requirements['capabilities'];
+        readonly materialized: Requirements['capabilities'];
     };
-    readonly bindings: Publication['bindings'];
+    readonly bindings: DomainRelease['bindings'];
 }
 /** Explicit complete Bundle observed coherently with its ready Domain generation. */
 export interface DomainBundle {
@@ -45,31 +38,12 @@ export interface DomainDependencies {
     readonly domain: DomainInfo;
     readonly dependencies: readonly DependencyBinding[];
 }
-/**
- * What one installation pins, one meaning per variant: a `DomainRelease` v4 by its release digest
- * beside the build digest it runs, or a legacy v2/v3 Publication by its strong ETag.
- */
-export type InstalledPin = ReleasePin | LegacyPin;
-/** A `DomainRelease` v4 pin: its release digest beside the build digest it runs. */
-interface ReleasePin {
+/** A DomainRelease v4 pin: its release digest beside the build digest it runs. */
+export interface InstalledPin {
     readonly kind: 'release';
     readonly release: ReleaseDigest;
     readonly build: BuildDigest;
 }
-/**
- * A legacy v2/v3 Publication pin: its document version and strong ETag.
- *
- * @deprecated Successor: the `release` pin. Short-term consumer: the installations that still pin
- * a v2/v3 Publication, such as the astrale Host's v3 installs until Shell is republished as a
- * release. Deleted, with its codec branch, in the separate breaking release that deletes
- * `runtime/schema/installation/source/legacy/`, once no installation pins a v2/v3 Publication
- * (the conditions of `protocol/release/legacy/index.ts`).
- */
-interface LegacyPin {
-    readonly kind: 'legacy';
-    readonly document: 2 | 3;
-    readonly etag: Digest;
-}
 /**
  * The issuer of a release one installation replaced, as the Kernel records it: accepted while its
  * work drains, and listed until a later consented install re-pins or prunes it, drained or not.
@@ -101,7 +75,6 @@ export type ResultFor<Input extends introspection.Introspection> = Input extends
     readonly kind: 'dependencies';
 } ? DomainDependencies : DomainInfo;
 export interface Limits {
-    readonly maximumPublicationBytes: number;
+    readonly maximumReleaseBytes: number;
     readonly maximumBundleBytes: number;
 }
-export {};