@astrale-os/kernel-protocol 0.5.0-beta.7 → 0.5.0-beta.71

package/dist/routes/legacy/routing.js

@@ -0,0 +1,45 @@
+import { decodeInvocation } from '../decode.js';
+import { fail } from '../error.js';
+import { acceptIssuerHeader, reservedHeader, strongDigest } from '../header.js';
+import { HTTP_ROUTE_DIGEST, HTTP_ROUTE_ISSUER } from '../routing.js';
+/**
+ * The If-Match header native routing reads, named for the Publication ETag it carried.
+ *
+ * @deprecated Successor: `HTTP_ROUTE_DIGEST`, the same header named for the routed digest.
+ */
+export const HTTP_ROUTE_PUBLICATION = HTTP_ROUTE_DIGEST;
+/**
+ * Decode only the native strong If-Match representation of Publication routing, served by a
+ * v3-input destination; a mismatched ETag is invalid here because the Server answers stale first.
+ *
+ * @deprecated Successor: `decodeRouting`, which serves a release and its v3 projection.
+ */
+export function decodeRouting(input, publication) {
+    const encodedEtag = reservedHeader(input.headers, HTTP_ROUTE_DIGEST);
+    const encodedIssuer = reservedHeader(input.headers, HTTP_ROUTE_ISSUER);
+    if (encodedEtag === undefined && encodedIssuer === undefined)
+        return undefined;
+    if (encodedEtag === undefined || encodedIssuer === undefined) {
+        fail('NATIVE_ROUTE_ROUTING_INVALID', `${HTTP_ROUTE_DIGEST} and ${HTTP_ROUTE_ISSUER} must occur together.`);
+    }
+    const etag = strongDigest(encodedEtag);
+    if (etag === undefined) {
+        fail('NATIVE_ROUTE_ROUTING_INVALID', 'If-Match must contain exactly one strong quoted Publication ETag.');
+    }
+    if (etag !== publication.etag) {
+        fail('NATIVE_ROUTE_ROUTING_INVALID', 'If-Match does not name the compiled Publication.');
+    }
+    return Object.freeze({
+        kind: 'via',
+        publication,
+        issuer: acceptIssuerHeader(encodedIssuer, HTTP_ROUTE_ISSUER),
+    });
+}
+/**
+ * Decode one native route request served by a v3-input destination.
+ *
+ * @deprecated Successor: `decode`, which serves a release and its v3 projection.
+ */
+export function decode(entry, request, domain, served) {
+    return decodeInvocation(entry, request, domain, (input) => decodeRouting(input, served));
+}

package/dist/routes/legacy/table.d.ts

@@ -0,0 +1,34 @@
+import type { Domain } from '@astrale-os/kernel-dsl/v1';
+import type { Publication } from '../../release/legacy/publication.js';
+import type { PublicationRef } from '../../release/legacy/reference.js';
+import type { Plan } from '../plan.js';
+import type { Route } from '../table.js';
+/**
+ * Serving proof tied to one exact v2/v3 Publication and its resolved Domain.
+ *
+ * @deprecated Successor: `Table`, bound to the `ReleaseRef` of a `DomainRelease`.
+ */
+export interface Table {
+    readonly publication: PublicationRef;
+    readonly entries: readonly Route[];
+}
+/**
+ * Bind one Plan to an exact placed Publication and matching resolved Domain. Like the release
+ * Table, it also reserves `release.json`, so a v3 Domain cannot claim the document a v4 Kernel
+ * reads first.
+ *
+ * @deprecated Successor: `bind`, which binds a `DomainRelease`.
+ */
+export declare function bind(plan: Plan, deployed: Publication, domain: Domain, publicUrl?: string): Table;
+/**
+ * Admit one emitted portable Publication Table before Server composition.
+ *
+ * @deprecated Successor: `acceptTable`, which admits a release Table.
+ */
+export declare function acceptTable(input: unknown): Table;
+/**
+ * Verify exact Publication bytes and callable meaning before Server trusts one Table.
+ *
+ * @deprecated Successor: `verifyTable`, which verifies a release Table.
+ */
+export declare function verifyTable(table: Table, deployed: Publication, domain: Pick<Domain, 'origin' | 'revision' | 'callable'>): Table;

package/dist/routes/legacy/table.js

@@ -0,0 +1,50 @@
+import { withPublicationError } from '../../release/legacy/error.js';
+import { acceptReference, compareReferences, reference } from '../../release/legacy/reference.js';
+import { acceptEntries, placedEntries, placementMismatch, sameServedWire, tableObject, verifyMeaning, } from '../entries.js';
+import { fail } from '../error.js';
+import { rejectReserved } from '../reservation.js';
+/**
+ * Bind one Plan to an exact placed Publication and matching resolved Domain. Like the release
+ * Table, it also reserves `release.json`, so a v3 Domain cannot claim the document a v4 Kernel
+ * reads first.
+ *
+ * @deprecated Successor: `bind`, which binds a `DomainRelease`.
+ */
+export function bind(plan, deployed, domain, publicUrl = deployed.identity.issuer) {
+    const mismatch = placementMismatch(plan, deployed, domain, publicUrl);
+    if (mismatch === 'identity') {
+        fail('NATIVE_ROUTE_BINDING_INVALID', 'Route Plan, Publication, and Domain identity differ.');
+    }
+    if (mismatch === 'routes') {
+        fail('NATIVE_ROUTE_BINDING_INVALID', 'Publication routes differ from the placed Route Plan.');
+    }
+    const entries = placedEntries(plan, deployed);
+    withPublicationError(() => rejectReserved(deployed, entries));
+    return Object.freeze({ publication: reference(deployed), entries });
+}
+/**
+ * Admit one emitted portable Publication Table before Server composition.
+ *
+ * @deprecated Successor: `acceptTable`, which admits a release Table.
+ */
+export function acceptTable(input) {
+    const value = tableObject(input, ['publication', 'entries']);
+    const publication = acceptReference(value.publication);
+    return Object.freeze({
+        publication,
+        entries: withPublicationError(() => acceptEntries(value.entries, publication.origin)),
+    });
+}
+/**
+ * Verify exact Publication bytes and callable meaning before Server trusts one Table.
+ *
+ * @deprecated Successor: `verifyTable`, which verifies a release Table.
+ */
+export function verifyTable(table, deployed, domain) {
+    if (compareReferences(table.publication, reference(deployed)) !== 'exact' ||
+        !sameServedWire(table.entries, deployed, domain)) {
+        fail('NATIVE_ROUTE_BINDING_INVALID', 'Route Table evidence differs from its Publication.');
+    }
+    verifyMeaning(table.entries, domain);
+    return table;
+}

package/dist/routes/mapping.d.ts

@@ -1,6 +1,5 @@
-import type { HttpRoute } from '../publication/index.js';
+import type { HttpRoute } from '../release/route.js';
 export declare function validateMapping(route: HttpRoute, fields: readonly string[] | undefined, instanceMethod: boolean): void;
 export declare function validateWireMapping(route: HttpRoute): void;
 export declare function validateCredentialMapping(route: HttpRoute): void;
 export declare function isReservedHeader(input: string): boolean;
-//# sourceMappingURL=mapping.d.ts.map

package/dist/routes/mapping.js

@@ -1,8 +1,8 @@
 import { HTTP_IDEMPOTENCY_KEY } from '../invocation/index.js';
 import { credentialSources } from './credential.js';
+import { HTTP_DEPLOYMENT_RETIRED } from './deployment-retired.js';
 import { fail } from './error.js';
-import { HTTP_ROUTE_RELEASE_UNAVAILABLE } from './release-unavailable.js';
-import { HTTP_ROUTE_ISSUER, HTTP_ROUTE_MISS, HTTP_ROUTE_PUBLICATION, HTTP_ROUTE_STALE, } from './routing.js';
+import { HTTP_ROUTE_DIGEST, HTTP_ROUTE_ISSUER, HTTP_ROUTE_MISS, HTTP_ROUTE_STALE, } from './routing.js';
 import { PLACEHOLDER } from './template.js';
 export function validateMapping(route, fields, instanceMethod) {
     if (fields === undefined) {
@@ -110,10 +110,10 @@ export function validateCredentialMapping(route) {
 }
 const RESERVED_HEADERS = new Set([
     HTTP_IDEMPOTENCY_KEY,
+    HTTP_DEPLOYMENT_RETIRED,
+    HTTP_ROUTE_DIGEST,
     HTTP_ROUTE_ISSUER,
     HTTP_ROUTE_MISS,
-    HTTP_ROUTE_PUBLICATION,
-    HTTP_ROUTE_RELEASE_UNAVAILABLE,
     HTTP_ROUTE_STALE,
 ]);
 export function isReservedHeader(input) {
@@ -124,4 +124,3 @@ function uniqueWires(route, kind, wires) {
         fail('NATIVE_ROUTE_MAPPING_AMBIGUOUS', `Route ${route.name} maps one ${kind} wire source more than once.`);
     }
 }
-//# sourceMappingURL=mapping.js.map

package/dist/routes/match.d.ts

@@ -1,5 +1,4 @@
 import type { HttpRequest } from './request.js';
 import type { Route, Table } from './table.js';
-export declare function match(table: Table, request: Pick<HttpRequest, 'url' | 'method'>): Route | undefined;
+export declare function match(table: Pick<Table, 'entries'>, request: Pick<HttpRequest, 'url' | 'method'>): Route | undefined;
 export declare function methodMatches(entry: Route, method: string): boolean;
-//# sourceMappingURL=match.d.ts.map

package/dist/routes/match.js

@@ -5,4 +5,3 @@ export function match(table, request) {
 export function methodMatches(entry, method) {
     return entry.method === '*' || entry.method === method.toUpperCase();
 }
-//# sourceMappingURL=match.js.map

package/dist/routes/placement.d.ts

@@ -1,6 +1,5 @@
-import type * as publication from '../publication/index.js';
+import type { HttpRoute } from '../release/route.js';
 import type { Plan } from './plan.js';
 /** Resolve a provider-neutral Plan beneath one exact serving issuer. */
-export declare function place(plan: Plan, issuer: string): readonly publication.HttpRoute[];
+export declare function place(plan: Plan, issuer: string): readonly HttpRoute[];
 export declare function placePath(path: string, issuer: string): string;
-//# sourceMappingURL=placement.d.ts.map

package/dist/routes/placement.js

@@ -1,7 +1,7 @@
 /** Resolve a provider-neutral Plan beneath one exact serving issuer. */
 export function place(plan, issuer) {
     return Object.freeze(plan.entries.map((entry) => {
-        const { path, target, authentication: _authentication, output: _output, default: isDefault, ...wire } = entry;
+        const { path, target, auth: _auth, output: _output, default: isDefault, ...wire } = entry;
         return Object.freeze({
             ...wire,
             href: placePath(path, issuer),
@@ -16,4 +16,3 @@ export function placePath(path, issuer) {
     const base = new URL(issuer);
     return `${base.origin}${path}`;
 }
-//# sourceMappingURL=placement.js.map

package/dist/routes/plan.d.ts

@@ -1,12 +1,13 @@
-import type { Key, schema } from '@astrale-os/kernel-dsl/v1';
-import type { CredentialSource, HttpMethod, RouteBody, RouteHeaders } from '../publication/index.js';
+import type { FunctionAuth, Key, Revision } from '@astrale-os/kernel-dsl/v1';
+import type { OutputMode } from '@astrale-os/kernel-dsl/v1/language';
+import type { CredentialSource, HttpMethod, RouteBody, RouteHeaders } from '../release/route.js';
 import type { RouteTarget } from './target.js';
 export interface PlanEntry {
     readonly name: string;
     readonly callable: Key.Callable;
     readonly target: RouteTarget;
-    readonly authentication: schema.FunctionAuth;
-    readonly output: schema.OutputMode;
+    readonly auth: FunctionAuth;
+    readonly output: OutputMode;
     readonly path: string;
     readonly method: HttpMethod;
     readonly requestMethod?: string;
@@ -18,7 +19,6 @@ export interface PlanEntry {
 }
 export interface Plan {
     readonly origin: Key.Origin;
-    readonly revision: schema.Revision;
+    readonly revision: Revision;
     readonly entries: readonly PlanEntry[];
 }
-//# sourceMappingURL=plan.d.ts.map

package/dist/routes/plan.js

@@ -1,2 +1 @@
 export {};
-//# sourceMappingURL=plan.js.map

package/dist/routes/request.d.ts

@@ -1,11 +1,13 @@
 import type { Value } from '@astrale-os/kernel-dsl/value';
-import type { Call, Via } from '../invocation/index.js';
-import type { HttpMethod } from '../publication/index.js';
+import type { Call, PublicationVia, 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 {
     readonly call: Call;
     readonly credential?: string;
-    readonly routing?: Via;
+    /** The request channel that carried `credential`; `cookie` is ambient (CSRF-exposed). */
+    readonly credentialIn?: 'header' | 'cookie' | 'query';
+    readonly routing?: Via | PublicationVia;
     readonly method?: Exclude<HttpMethod, '*'>;
 }
 export interface Request {
@@ -24,4 +26,3 @@ export interface HttpRequest {
 export declare function bodyText(body: HttpRequest['body']): string;
 export declare function parseJsonObject(body: HttpRequest['body']): Record<string, Value>;
 export declare function normalizeHeaders(input: HttpRequest['headers']): Record<string, string>;
-//# sourceMappingURL=request.d.ts.map

package/dist/routes/request.js

@@ -51,4 +51,3 @@ export function normalizeHeaders(input) {
     }
     return output;
 }
-//# sourceMappingURL=request.js.map

package/dist/routes/reservation.d.ts

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

package/dist/routes/reservation.js

@@ -1,8 +1,10 @@
 import * as issuer from '../issuer/index.js';
-import { PATH as PUBLICATION_PATH } from '../publication/publication.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([PUBLICATION_PATH]);
+const STATIC_RESERVED_PATHS = new Set([RELEASE_PATH, PUBLICATION_PATH]);
 export function rejectReserved(publication, entries) {
     const discovery = issuer.paths(publication.identity.issuer);
     const reservedPaths = new Set([...STATIC_RESERVED_PATHS, discovery.configuration, discovery.keys]);
@@ -14,8 +16,13 @@ export function rejectReserved(publication, entries) {
             ...(endpoint.websocket === undefined ? [] : [httpUrlForWebSocket(endpoint.websocket)]),
         ]),
     ];
+    const addressed = bundleUrl(publication.identity.issuer, publication.schema.bundle.ref);
+    const bundlePattern = publication.schema.bundle.href === addressed
+        ? `${addressed.slice(0, addressed.lastIndexOf('/') + 1)}{artifact}`
+        : undefined;
     for (const entry of entries) {
-        const claimed = [...reservedPaths].some((path) => templateClaimsPath(entry.href, path)) ||
+        const claimed = (bundlePattern !== undefined && templatesOverlap(entry.href, bundlePattern)) ||
+            [...reservedPaths].some((path) => templateClaimsPath(entry.href, path)) ||
             reservedUrls.some((reserved) => templatesOverlap(entry.href, routeLocation(reserved)));
         if (claimed) {
             fail('NATIVE_ROUTE_RESERVED', `Route ${entry.name} claims reserved URL ${templateUrl(entry.href).href}.`);
@@ -35,4 +42,3 @@ function templateClaimsPath(template, path) {
     const url = templateUrl(template);
     return templatesOverlap(template, `${url.origin}${path}`);
 }
-//# sourceMappingURL=reservation.js.map

package/dist/routes/routing.d.ts

@@ -1,23 +1,46 @@
 import type * as invocation from '../invocation/index.js';
-import type { Etag, PublicationRef } from '../publication/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';
-    readonly current: Etag;
+    /** Current Publication ETag; release-backed destinations report their frozen v3 projection's ETag. */
+    readonly current: Sha256Digest;
 }
 export interface MissControl {
     readonly kind: 'miss';
 }
-export declare const HTTP_ROUTE_PUBLICATION: 'if-match';
+/** 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';
 export declare const HTTP_ROUTE_ISSUER: 'x-astrale-issuer';
 export declare const HTTP_ROUTE_STALE: 'x-astrale-route-stale';
 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;
-export declare function decodeRouting(input: Pick<HttpRequest, 'headers'>, publication: PublicationRef): invocation.Via | undefined;
-export declare function staleHeaders(current: Etag): Readonly<Record<string, string>>;
+/**
+ * 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).
+ */
+export declare function decodeRouting(input: Pick<HttpRequest, 'headers'>, served: ServedReferences): invocation.Via | invocation.PublicationVia | 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;
 export declare function missHeaders(): Readonly<Record<string, string>>;
 export declare function decodeMiss(status: number, headers: HttpRequest['headers']): MissControl | undefined;
-export declare function encodeStrongEtag(input: Etag): string;
-//# sourceMappingURL=routing.d.ts.map
+export declare function encodeStrongEtag(input: Sha256Digest): string;

package/dist/routes/routing.js

@@ -1,36 +1,41 @@
-import * as auth from '@astrale-os/kernel-core/auth';
 import { fail } from './error.js';
-export const HTTP_ROUTE_PUBLICATION = 'if-match';
+import { acceptIssuerHeader, reservedHeader, strongDigest } from './header.js';
+/** If-Match carries the routed digest of a native route request (`invocation.routedDigest`). */
+export const HTTP_ROUTE_DIGEST = 'if-match';
 export const HTTP_ROUTE_ISSUER = 'x-astrale-issuer';
 export const HTTP_ROUTE_STALE = 'x-astrale-route-stale';
 export const HTTP_ROUTE_STALE_STATUS = 412;
 export const HTTP_ROUTE_MISS = 'x-astrale-route-miss';
 export const HTTP_ROUTE_MISS_STATUS = 421;
-const STRONG_ETAG = /^"(sha256:[0-9a-f]{64})"$/u;
-export function decodeRouting(input, publication) {
-    const encodedEtag = routingHeader(input.headers, HTTP_ROUTE_PUBLICATION);
-    const encodedIssuer = routingHeader(input.headers, HTTP_ROUTE_ISSUER);
-    if (encodedEtag === undefined && encodedIssuer === undefined)
+/**
+ * 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).
+ */
+export function decodeRouting(input, served) {
+    const encodedDigest = reservedHeader(input.headers, HTTP_ROUTE_DIGEST);
+    const encodedIssuer = reservedHeader(input.headers, HTTP_ROUTE_ISSUER);
+    if (encodedDigest === undefined && encodedIssuer === undefined)
         return undefined;
-    if (encodedEtag === undefined || encodedIssuer === undefined) {
-        fail('NATIVE_ROUTE_ROUTING_INVALID', `${HTTP_ROUTE_PUBLICATION} and ${HTTP_ROUTE_ISSUER} must occur together.`);
+    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 });
     }
-    const etag = decodeStrongEtag(encodedEtag, 'If-Match');
-    if (etag !== publication.etag) {
-        fail('NATIVE_ROUTE_ROUTING_INVALID', 'If-Match does not name the compiled Publication.');
+    if (encodedDigest === undefined || encodedIssuer === undefined) {
+        fail('NATIVE_ROUTE_ROUTING_INVALID', `${HTTP_ROUTE_DIGEST} and ${HTTP_ROUTE_ISSUER} must occur together.`);
     }
-    let issuer;
-    try {
-        issuer = auth.issuer.accept(encodedIssuer);
+    if (named === undefined) {
+        fail('NATIVE_ROUTE_ROUTING_INVALID', 'If-Match must contain exactly one strong quoted digest.');
     }
-    catch (cause) {
-        if (cause instanceof auth.AuthValueError) {
-            return fail('NATIVE_ROUTE_ROUTING_INVALID', `${HTTP_ROUTE_ISSUER} is invalid.`, cause);
-        }
-        throw cause;
-    }
-    return Object.freeze({ kind: 'via', publication, issuer });
+    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 });
 }
+/** Emit the reserved stale header naming `current` (see `StaleControl.current`). */
 export function staleHeaders(current) {
     return Object.freeze({
         [HTTP_ROUTE_STALE]: encodeStrongEtag(current),
@@ -38,22 +43,23 @@ export function staleHeaders(current) {
     });
 }
 export function decodeStale(status, headers) {
-    const encoded = routingHeader(headers, HTTP_ROUTE_STALE);
+    const encoded = reservedHeader(headers, HTTP_ROUTE_STALE);
     if (encoded === undefined)
         return undefined;
     if (status !== HTTP_ROUTE_STALE_STATUS) {
         fail('NATIVE_ROUTE_ROUTING_INVALID', `Header ${HTTP_ROUTE_STALE} is reserved for status ${HTTP_ROUTE_STALE_STATUS}.`);
     }
-    return Object.freeze({
-        kind: 'stale',
-        current: decodeStrongEtag(encoded, HTTP_ROUTE_STALE),
-    });
+    const current = strongDigest(encoded);
+    if (current === undefined) {
+        fail('NATIVE_ROUTE_ROUTING_INVALID', `${HTTP_ROUTE_STALE} must contain exactly one strong quoted digest.`);
+    }
+    return Object.freeze({ kind: 'stale', current });
 }
 export function missHeaders() {
     return Object.freeze({ [HTTP_ROUTE_MISS]: '1', 'cache-control': 'no-store' });
 }
 export function decodeMiss(status, headers) {
-    const encoded = routingHeader(headers, HTTP_ROUTE_MISS);
+    const encoded = reservedHeader(headers, HTTP_ROUTE_MISS);
     if (encoded === undefined)
         return undefined;
     if (status !== HTTP_ROUTE_MISS_STATUS || encoded !== '1') {
@@ -64,25 +70,3 @@ export function decodeMiss(status, headers) {
 export function encodeStrongEtag(input) {
     return `"${input}"`;
 }
-function decodeStrongEtag(input, label) {
-    const matched = STRONG_ETAG.exec(input);
-    if (matched === null) {
-        fail('NATIVE_ROUTE_ROUTING_INVALID', `${label} must contain exactly one strong quoted Publication ETag.`);
-    }
-    return matched[1];
-}
-function routingHeader(input, name) {
-    if (input instanceof Headers)
-        return input.get(name) ?? undefined;
-    let found;
-    for (const [candidate, value] of Object.entries(input ?? {})) {
-        if (candidate.toLowerCase() !== name || value === undefined)
-            continue;
-        if (found !== undefined || (Array.isArray(value) && value.length !== 1)) {
-            fail('NATIVE_ROUTE_ROUTING_INVALID', `Header ${name} must occur at most once.`);
-        }
-        found = typeof value === 'string' ? value : value[0];
-    }
-    return found;
-}
-//# sourceMappingURL=routing.js.map

package/dist/routes/scalar.d.ts

@@ -1,8 +1,7 @@
-import type { schema } from '@astrale-os/kernel-dsl/v1';
+import type { Domain } from '@astrale-os/kernel-dsl/v1';
 import type * as portable from '@astrale-os/kernel-dsl/value';
 import type { Route } from './table.js';
-export declare function encodeScalar(entry: Route, name: string, value: unknown, validator: schema.Validator): string;
-export declare function decodeScalar(entry: Route, name: string, encoded: string, validator: schema.Validator): portable.Value;
+export declare function encodeScalar(entry: Route, name: string, value: unknown, domain: Domain): string;
+export declare function decodeScalar(entry: Route, name: string, encoded: string, domain: Domain): portable.Value;
 export declare function scalar(value: unknown): string;
 export declare function asObject(value: unknown): Record<string, portable.Value>;
-//# sourceMappingURL=scalar.d.ts.map

package/dist/routes/scalar.js

@@ -1,20 +1,20 @@
 import { invalidRequest } from './error.js';
 const JSON_NUMBER = /^-?(?:0|[1-9]\d*)(?:\.\d+)?(?:[eE][+-]?\d+)?$/u;
-export function encodeScalar(entry, name, value, validator) {
+export function encodeScalar(entry, name, value, domain) {
     const encoded = scalar(value);
     if (name === receiver(entry))
         return encoded;
-    const decoded = decodeScalar(entry, name, encoded, validator);
+    const decoded = decodeScalar(entry, name, encoded, domain);
     if (!sameScalar(decoded, value)) {
         invalidRequest(`Native route field ${name} does not round-trip through its declared value schema.`);
     }
     return encoded;
 }
-export function decodeScalar(entry, name, encoded, validator) {
+export function decodeScalar(entry, name, encoded, domain) {
     if (name === receiver(entry))
         return encoded;
-    const meaning = validator.callable(entry.callable);
-    if (meaning?.fields?.includes(name) !== true) {
+    const meaning = domain.callable(entry.callable);
+    if (meaning?.inputFields?.includes(name) !== true) {
         invalidRequest(`Native route maps unknown input field ${name}.`);
     }
     const candidates = [encoded];
@@ -59,4 +59,3 @@ function sameScalar(left, right) {
     return (Object.is(left, right) ||
         (typeof left === 'number' && typeof right === 'number' && left === 0 && right === 0));
 }
-//# sourceMappingURL=scalar.js.map

package/dist/routes/select.d.ts

@@ -1,4 +1,3 @@
 import type { Key } from '@astrale-os/kernel-dsl/v1';
 import type { Route, Table } from './table.js';
-export declare function select(table: Table, callable: Key.Callable, route?: string): Route | undefined;
-//# sourceMappingURL=select.d.ts.map
+export declare function select(table: Pick<Table, 'entries'>, callable: Key.Callable, route?: string): Route | undefined;

package/dist/routes/select.js

@@ -14,4 +14,3 @@ export function select(table, callable, route) {
         return candidates[0];
     return candidates.find((entry) => entry.default);
 }
-//# sourceMappingURL=select.js.map

package/dist/routes/stream.d.ts

@@ -12,4 +12,3 @@ export type StreamFrame = {
 };
 export declare function encodeStreamFrame(input: StreamFrame): string;
 export declare function decodeStreamFrame(event: string, data: string): StreamFrame;
-//# sourceMappingURL=stream.d.ts.map

package/dist/routes/stream.js

@@ -48,4 +48,3 @@ export function decodeStreamFrame(event, data) {
     }
     return fail('NATIVE_ROUTE_RESPONSE_INVALID', `Unknown native stream event ${JSON.stringify(event)}.`);
 }
-//# sourceMappingURL=stream.js.map

package/dist/routes/table.d.ts

@@ -1,10 +1,10 @@
-import type { PublicationRef } from '../publication/index.js';
+import type { ReleaseRef } from '../release/reference.js';
 import type { PlanEntry } from './plan.js';
 export interface Route extends Omit<PlanEntry, 'path'> {
     readonly href: string;
 }
+/** Serving proof tied to one exact release and its resolved Domain. */
 export interface Table {
-    readonly publication: PublicationRef;
+    readonly release: ReleaseRef;
     readonly entries: readonly Route[];
 }
-//# sourceMappingURL=table.d.ts.map

package/dist/routes/table.js

@@ -1,2 +1 @@
 export {};
-//# sourceMappingURL=table.js.map

package/dist/routes/target.d.ts

@@ -1,3 +1,6 @@
+import type { Domain } from '@astrale-os/kernel-dsl/v1';
+import type { Key } from '@astrale-os/kernel-dsl/v1/addressing';
+import type { MeaningFingerprint } from '@astrale-os/kernel-dsl/v1/schema/fingerprint';
 export type RouteTarget = {
     readonly kind: 'function';
 } | {
@@ -11,4 +14,5 @@ export type RouteTarget = {
 export declare function requiresReceiver(entry: {
     readonly target: RouteTarget;
 }): boolean;
-//# sourceMappingURL=target.d.ts.map
+/** Fingerprint of the route Domain's callable meaning, which every native route Target pins. */
+export declare function routeFingerprint(domain: Pick<Domain, 'callable'>, callable: Key.Callable): MeaningFingerprint;

package/dist/routes/target.js

@@ -1,4 +1,19 @@
+import { callableFingerprint } from '@astrale-os/kernel-dsl/v1/schema/fingerprint';
+import { fail } from './error.js';
 export function requiresReceiver(entry) {
     return entry.target.kind === 'method' && entry.target.dispatch === 'instance';
 }
-//# sourceMappingURL=target.js.map
+const FINGERPRINTS = new WeakMap();
+/** Fingerprint of the route Domain's callable meaning, which every native route Target pins. */
+export function routeFingerprint(domain, callable) {
+    const meaning = domain.callable(callable);
+    if (meaning === undefined) {
+        fail('NATIVE_ROUTE_BINDING_INVALID', `Route callable ${callable} is absent from its Domain.`);
+    }
+    let fingerprint = FINGERPRINTS.get(meaning);
+    if (fingerprint === undefined) {
+        fingerprint = callableFingerprint(meaning);
+        FINGERPRINTS.set(meaning, fingerprint);
+    }
+    return fingerprint;
+}

package/dist/routes/template.d.ts

@@ -6,4 +6,3 @@ 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;
 export declare function authorityEnd(input: string): number;
-//# sourceMappingURL=template.d.ts.map

package/dist/routes/template.js

@@ -225,4 +225,3 @@ function segmentsOverlap(left, right) {
 function escapePattern(value) {
     return value.replace(/[.*+?^${}()|[\]\\]/gu, '\\$&');
 }
-//# sourceMappingURL=template.js.map