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

package/dist/release/served.js

@@ -0,0 +1,65 @@
+import { Key, 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';
+import { fail } from './error.js';
+import { admitIssuer } from './issuer.js';
+import { admitManifest } from './manifest.js';
+import { admitRequirements } from './requirements.js';
+import { admitRoute } from './route.js';
+import { admitSchema } from './schema.js';
+import { array, exact, record, unique } from './shape.js';
+/**
+ * Admit the version-neutral content of one served release document. Every document version runs
+ * these checks in this order, so a document of any version admits exactly the same served content.
+ */
+export function admitServedContent(value, options) {
+    if (typeof value.origin !== 'string' || !patterns.origin.test(value.origin)) {
+        fail('RELEASE_INVALID', 'Release origin is invalid.');
+    }
+    const origin = value.origin;
+    const identity = record(value.identity, 'RELEASE_INVALID', 'Release identity is invalid.');
+    exact(identity, ['issuer', 'subject'], 'RELEASE_INVALID');
+    const issuer = admitIssuer(identity.issuer);
+    if (identity.subject !== origin) {
+        fail('RELEASE_INVALID', 'Release identity subject must equal its root origin.');
+    }
+    const schema = admitSchema(value.schema);
+    const requirements = (options.requirements ?? admitRequirements)(value.requirements);
+    const manifest = admitManifest(value.manifest);
+    const bindingSet = record(value.bindings, 'RELEASE_BINDING_INVALID', 'Release bindings are invalid.');
+    exact(bindingSet, ['callables', 'views'], 'RELEASE_BINDING_INVALID');
+    const callables = array(bindingSet.callables, 'RELEASE_BINDING_INVALID').map((entry) => admitCallableBinding(entry, origin));
+    unique(callables.map(({ callable }) => callable), 'RELEASE_BINDING_INVALID', 'callable binding');
+    const views = array(bindingSet.views, 'RELEASE_VIEW_INVALID').map((entry) => options.views === 'canonicalize'
+        ? canonicalizeViewBinding(entry, origin)
+        : admitViewBinding(entry, origin));
+    unique(views.map(({ view }) => view), 'RELEASE_VIEW_INVALID', 'View binding');
+    const routes = array(value.routes, 'RELEASE_ROUTE_INVALID').map((entry) => admitRoute(entry, origin));
+    unique(routes.map(({ name }) => name), 'RELEASE_ROUTE_INVALID', 'route name');
+    for (const callable of new Set(routes.map(({ callable }) => callable))) {
+        if (routes.filter((route) => route.callable === callable && route.default === true).length > 1) {
+            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,
+        identity: { issuer, subject: origin },
+        schema,
+        requirements,
+        ...(manifest === undefined ? {} : { manifest }),
+        bindings: { callables, views },
+        routes,
+        ...(delivery === undefined ? {} : { delivery }),
+    };
+}

package/dist/release/shape.d.ts

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

package/dist/routes/admission.d.ts

@@ -1,3 +1,3 @@
 import type { Table } from './table.js';
-/** Admit one emitted portable Table before Server composition. */
+/** Admit one emitted portable release Table before Server composition. */
 export declare function acceptTable(input: unknown): Table;

package/dist/routes/admission.js

@@ -1,89 +1,11 @@
-import { accept as acceptPortable } from '@astrale-os/kernel-dsl/value';
-import { acceptReference } from '../publication/reference.js';
-import { admitRoute } from '../publication/route.js';
-import { fail } from './error.js';
-const AUTH = new Set(['anonymous', 'authenticated', 'authorized']);
-const OUTPUT = new Set(['value', 'stream', 'binary']);
-/** Admit one emitted portable Table before Server composition. */
+import { acceptReference } from '../release/reference.js';
+import { acceptEntries, tableObject } from './entries.js';
+/** Admit one emitted portable release Table before Server composition. */
 export function acceptTable(input) {
-    const value = object(acceptPortable(input), 'Route Table');
-    exact(value, ['publication', 'entries'], 'Route Table');
-    const reference = acceptReference(value.publication);
-    if (!Array.isArray(value.entries))
-        invalid('Route Table entries');
-    const entries = value.entries.map((entry) => acceptRoute(entry, reference.origin));
-    if (new Set(entries.map(({ name }) => name)).size !== entries.length) {
-        fail('NATIVE_ROUTE_BINDING_INVALID', 'Route Table names must be unique.');
-    }
-    return Object.freeze({ publication: reference, entries: Object.freeze(entries) });
-}
-function acceptRoute(input, origin) {
-    const value = object(input, 'Route Table entry');
-    exact(value, ['name', 'callable', 'target', 'auth', 'output', 'href', 'method', 'default'], 'Route Table entry', ['requestMethod', 'query', 'headers', 'body', 'credential']);
-    if (typeof value.default !== 'boolean')
-        invalid('Route Table default');
-    if (typeof value.auth !== 'string' || !AUTH.has(value.auth)) {
-        invalid('Route Table auth');
-    }
-    if (typeof value.output !== 'string' || !OUTPUT.has(value.output))
-        invalid('Route Table output');
-    const wire = admitRoute({
-        name: value.name,
-        callable: value.callable,
-        href: value.href,
-        method: value.method,
-        ...(value.default === true ? { default: true } : {}),
-        ...(value.requestMethod === undefined ? {} : { requestMethod: value.requestMethod }),
-        ...(value.query === undefined ? {} : { query: value.query }),
-        ...(value.headers === undefined ? {} : { headers: value.headers }),
-        ...(value.body === undefined ? {} : { body: value.body }),
-        ...(value.credential === undefined ? {} : { credential: value.credential }),
-        ...receiver(value.target),
-    }, origin);
-    const { default: _default, receiver: _receiver, ...common } = wire;
+    const value = tableObject(input, ['release', 'entries']);
+    const reference = acceptReference(value.release);
     return Object.freeze({
-        ...common,
-        target: target(value.target),
-        auth: value.auth,
-        output: value.output,
-        default: value.default,
+        release: reference,
+        entries: acceptEntries(value.entries, reference.origin),
     });
 }
-function target(input) {
-    const value = object(input, 'Route target');
-    if (value.kind === 'function') {
-        exact(value, ['kind'], 'Route Function target');
-        return Object.freeze({ kind: 'function' });
-    }
-    if (value.kind !== 'method' || (value.dispatch !== 'static' && value.dispatch !== 'instance')) {
-        invalid('Route Method target');
-    }
-    if (value.dispatch === 'static') {
-        exact(value, ['kind', 'dispatch'], 'Route static Method target');
-        return Object.freeze({ kind: 'method', dispatch: 'static' });
-    }
-    exact(value, ['kind', 'dispatch', 'receiver'], 'Route instance Method target');
-    if (typeof value.receiver !== 'string')
-        invalid('Route receiver');
-    return Object.freeze({ kind: 'method', dispatch: 'instance', receiver: value.receiver });
-}
-function receiver(input) {
-    const admitted = target(input);
-    return admitted.kind === 'method' && admitted.dispatch === 'instance'
-        ? { receiver: admitted.receiver }
-        : {};
-}
-function object(input, label) {
-    if (input === null || typeof input !== 'object' || Array.isArray(input))
-        invalid(label);
-    return input;
-}
-function exact(value, required, label, optional = []) {
-    const allowed = new Set([...required, ...optional]);
-    if (Object.keys(value).some((key) => !allowed.has(key)) ||
-        required.some((key) => !Object.hasOwn(value, key)))
-        invalid(label);
-}
-function invalid(label) {
-    return fail('NATIVE_ROUTE_BINDING_INVALID', `${label} is invalid.`);
-}

package/dist/routes/binding.d.ts

@@ -1,6 +1,6 @@
 import type { Domain } from '@astrale-os/kernel-dsl/v1';
-import type { Publication } from '../publication/publication.js';
+import type { DomainRelease } from '../release/release.js';
 import type { Plan } from './plan.js';
 import type { Table } from './table.js';
-/** Bind one Plan to an exact placed Publication and matching resolved Domain. */
-export declare function bind(plan: Plan, deployed: Publication, domain: Domain, publicUrl?: string): Table;
+/** Bind one Plan to an exact placed release and matching resolved Domain. */
+export declare function bind(plan: Plan, deployed: DomainRelease, domain: Domain, publicUrl?: string): Table;

package/dist/routes/binding.js

@@ -1,26 +1,17 @@
-import { json } from '@astrale-os/kernel-dsl/value';
-import { reference } from '../publication/reference.js';
+import { reference } from '../release/reference.js';
+import { placedEntries, placementMismatch } from './entries.js';
 import { fail } from './error.js';
-import { place } from './placement.js';
 import { rejectReserved } from './reservation.js';
-/** Bind one Plan to an exact placed Publication and matching resolved Domain. */
+/** Bind one Plan to an exact placed release and matching resolved Domain. */
 export function bind(plan, deployed, domain, publicUrl = deployed.identity.issuer) {
-    if (plan.origin !== deployed.origin ||
-        plan.origin !== domain.origin ||
-        plan.revision !== deployed.schema.revision ||
-        plan.revision !== domain.revision) {
-        fail('NATIVE_ROUTE_BINDING_INVALID', 'Route Plan, Publication, and Domain identity differ.');
+    const mismatch = placementMismatch(plan, deployed, domain, publicUrl);
+    if (mismatch === 'identity') {
+        fail('NATIVE_ROUTE_BINDING_INVALID', 'Route Plan, Release, and Domain identity differ.');
     }
-    if (json.serialize(place(plan, publicUrl)) !== json.serialize(deployed.routes)) {
-        fail('NATIVE_ROUTE_BINDING_INVALID', 'Publication routes differ from the placed Route Plan.');
+    if (mismatch === 'routes') {
+        fail('NATIVE_ROUTE_BINDING_INVALID', 'Release routes differ from the placed Route Plan.');
     }
-    const entries = plan.entries.map((entry, index) => {
-        const { path: _path, ...portable } = entry;
-        return Object.freeze({ ...portable, href: deployed.routes[index].href });
-    });
+    const entries = placedEntries(plan, deployed);
     rejectReserved(deployed, entries);
-    return Object.freeze({
-        publication: reference(deployed),
-        entries: Object.freeze(entries),
-    });
+    return Object.freeze({ release: reference(deployed), entries });
 }

package/dist/routes/compiler.d.ts

@@ -1,8 +1,8 @@
 import type { Domain } from '@astrale-os/kernel-dsl/v1';
-import type * as publication from '../publication/index.js';
+import type { HttpRouteDeclaration } from '../release/route.js';
 import type { Plan } from './plan.js';
 export interface CompileInput {
-    readonly routes: readonly publication.HttpRouteDeclaration[];
+    readonly routes: readonly HttpRouteDeclaration[];
     readonly domain: Domain;
 }
 export declare function compile(input: CompileInput): Plan;

package/dist/routes/compiler.js

@@ -1,5 +1,6 @@
 import { isBinaryInput } from '@astrale-os/kernel-dsl/v1/language';
-import { admitRouteDeclaration } from '../publication/route.js';
+import { withPublicationError } from '../release/legacy/error.js';
+import { admitRouteDeclaration } from '../release/route.js';
 import { rejectCollisions } from './collision.js';
 import { fail } from './error.js';
 import { validateCredentialMapping, validateMapping, validateWireMapping } from './mapping.js';
@@ -9,7 +10,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) => admitRouteDeclaration(entry, input.domain.origin));
+    const authored = input.routes.map((entry) => withPublicationError(() => 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

@@ -1,4 +1,4 @@
-import type { HttpRoute, SingleCredentialSource } from '../publication/index.js';
+import type { HttpRoute, SingleCredentialSource } from '../release/route.js';
 import type { Route } from './table.js';
 export declare function credentialSources(route: Pick<HttpRoute, 'credential'>): readonly SingleCredentialSource[];
 export declare function firstCredentialIsAmbient(entry: Route): boolean;

package/dist/routes/decode.d.ts

@@ -1,5 +1,8 @@
 import type { Domain } from '@astrale-os/kernel-dsl/v1';
-import type { PublicationRef } from '../publication/index.js';
 import type { HttpRequest, Invocation } from './request.js';
+import type { ServedReferences } from './routing.js';
 import type { Route } from './table.js';
-export declare function decode(entry: Route, request: HttpRequest, domain: Domain, served: PublicationRef): Invocation;
+/** Decode one native route request served by a release-backed destination. */
+export declare function decode(entry: Route, request: HttpRequest, domain: Domain, served: ServedReferences): Invocation;
+/** Decode one native route request, reading its routing pair with `routing` at its fixed step. */
+export declare function decodeInvocation(entry: Route, request: HttpRequest, domain: Domain, routing: (input: HttpRequest) => Invocation['routing']): Invocation;

package/dist/routes/decode.js

@@ -7,9 +7,20 @@ import { methodMatches } from './match.js';
 import { bodyText, normalizeHeaders, parseJsonObject } from './request.js';
 import { decodeRouting } from './routing.js';
 import { decodeScalar } from './scalar.js';
-import { requiresReceiver } from './target.js';
+import { requiresReceiver, routeFingerprint } from './target.js';
 import { matchTemplate, PLACEHOLDER } from './template.js';
+/** Decode one native route request served by a release-backed destination. */
 export function decode(entry, request, domain, served) {
+    return decodeInvocation(entry, request, domain, (input) => {
+        const routing = decodeRouting(input, served);
+        if (routing?.kind === 'stale') {
+            fail('NATIVE_ROUTE_ROUTING_INVALID', 'If-Match does not name the served release.');
+        }
+        return routing;
+    });
+}
+/** Decode one native route request, reading its routing pair with `routing` at its fixed step. */
+export function decodeInvocation(entry, request, domain, routing) {
     if (!methodMatches(entry, request.method))
         invalidRequest('HTTP method does not match the route.');
     const matched = matchTemplate(entry.href, request.url);
@@ -34,7 +45,7 @@ export function decode(entry, request, domain, served) {
     }
     const headers = normalizeHeaders(request.headers);
     const credential = readCredential(entry, url, headers);
-    const routing = decodeRouting(request, served);
+    const routed = routing(request);
     const applicationHeaders = withoutCredentialHeaders(entry, headers);
     for (const [name, wire] of Object.entries(entry.query ?? {})) {
         const found = url.searchParams.getAll(wire);
@@ -113,13 +124,13 @@ export function decode(entry, request, domain, served) {
     }
     const target = Object.freeze({
         callable: entry.callable,
-        revision: domain.revision,
+        fingerprint: routeFingerprint(domain, entry.callable),
         ...(receiver === undefined ? {} : { instance: receiver }),
     });
     return Object.freeze({
         call: Object.freeze({ target, input }),
         ...(credential === undefined ? {} : { credential }),
-        ...(routing === undefined ? {} : { routing }),
+        ...(routed === undefined ? {} : { routing: routed }),
     });
 }
 function remainderFields(entry, domain) {

package/dist/routes/deployment-retired.d.ts

@@ -0,0 +1,30 @@
+import { type IssuerId } from '@astrale-os/kernel-core/auth/issuer';
+import type { DeploymentRetiredReason, ErrorResponse } from '../invocation/index.js';
+import type { ReleaseDigest } from '../release/digest.js';
+import type { HttpRequest } from './request.js';
+/**
+ * Reserved control of a deployment that no longer serves. Every emitter (the deployment
+ * dispatchers, a release-snapshot server) answers every path with the same 410, headers and
+ * envelope, and never runs other code in its place.
+ */
+export interface DeploymentRetired {
+    readonly kind: 'deployment-retired';
+    readonly reason: DeploymentRetiredReason;
+}
+export declare const HTTP_DEPLOYMENT_RETIRED: 'x-astrale-deployment-retired';
+export declare const HTTP_DEPLOYMENT_RETIRED_STATUS: 410;
+export declare function deploymentRetiredHeaders(): Readonly<Record<string, string>>;
+/**
+ * The envelope every deployed client already decodes from any status: a not-found Service error
+ * carrying `DEPLOYMENT_RETIRED`, attributed to the deployment rather than to one request. An
+ * emitter passing a deployment that is not a canonical issuer origin, or a release that is not a
+ * release digest, gets a `TypeError` naming that argument.
+ */
+export declare function deploymentRetiredBody(deployment: IssuerId, release?: ReleaseDigest): ErrorResponse;
+/**
+ * Recognize only the reserved status, header, `no-store` and envelope together. A 410 without the
+ * header is ordinary application behavior; the header with another status or value, without
+ * `Cache-Control: no-store`, or beside any other body (including one correlated to a request or
+ * whose invocation source is not the retired deployment), is an invalid response.
+ */
+export declare function decodeDeploymentRetired(status: number, headers: HttpRequest['headers'], body: unknown): DeploymentRetired | undefined;

package/dist/routes/deployment-retired.js

@@ -0,0 +1,96 @@
+import { is as isIssuer } from '@astrale-os/kernel-core/auth/issuer';
+import { CONTENT_TYPE_JSON } from '../codecs/media-types.js';
+import { CODES, ProtocolError } from '../errors/index.js';
+import { DEPLOYMENT_RETIRED, decodeResponse, serviceErrorOf } from '../invocation/index.js';
+import { fail } from './error.js';
+import { reservedHeader } from './header.js';
+export const HTTP_DEPLOYMENT_RETIRED = 'x-astrale-deployment-retired';
+export const HTTP_DEPLOYMENT_RETIRED_STATUS = 410;
+const MESSAGE = 'This deployment is retired.';
+const DIGEST = /^sha256:[0-9a-f]{64}$/u;
+export function deploymentRetiredHeaders() {
+    return Object.freeze({
+        [HTTP_DEPLOYMENT_RETIRED]: '1',
+        'cache-control': 'no-store',
+        'content-type': CONTENT_TYPE_JSON,
+    });
+}
+/**
+ * The envelope every deployed client already decodes from any status: a not-found Service error
+ * carrying `DEPLOYMENT_RETIRED`, attributed to the deployment rather than to one request. An
+ * emitter passing a deployment that is not a canonical issuer origin, or a release that is not a
+ * release digest, gets a `TypeError` naming that argument.
+ */
+export function deploymentRetiredBody(deployment, release) {
+    assertEmitterInput(deployment, release);
+    return decodeRetired({
+        requestId: null,
+        invocation: { source: deployment, id: 'unavailable' },
+        error: {
+            code: CODES.NOT_FOUND,
+            message: MESSAGE,
+            data: {
+                code: DEPLOYMENT_RETIRED,
+                details: { deployment, ...(release === undefined ? {} : { release }) },
+            },
+        },
+    }).envelope;
+}
+/**
+ * Recognize only the reserved status, header, `no-store` and envelope together. A 410 without the
+ * header is ordinary application behavior; the header with another status or value, without
+ * `Cache-Control: no-store`, or beside any other body (including one correlated to a request or
+ * whose invocation source is not the retired deployment), is an invalid response.
+ */
+export function decodeDeploymentRetired(status, headers, body) {
+    const encoded = reservedHeader(headers, HTTP_DEPLOYMENT_RETIRED);
+    if (encoded === undefined)
+        return undefined;
+    if (status !== HTTP_DEPLOYMENT_RETIRED_STATUS || encoded !== '1') {
+        fail('NATIVE_ROUTE_ROUTING_INVALID', `${HTTP_DEPLOYMENT_RETIRED} is reserved for status ${HTTP_DEPLOYMENT_RETIRED_STATUS} with value 1.`);
+    }
+    if (!cacheDirectives(headers).includes('no-store')) {
+        fail('NATIVE_ROUTE_ROUTING_INVALID', `${HTTP_DEPLOYMENT_RETIRED} requires Cache-Control: no-store.`);
+    }
+    return Object.freeze({ kind: 'deployment-retired', reason: decodeRetired(body).reason });
+}
+function decodeRetired(input) {
+    let envelope;
+    try {
+        envelope = decodeResponse(input);
+    }
+    catch (cause) {
+        if (cause instanceof ProtocolError)
+            return invalid(cause);
+        throw cause;
+    }
+    const failure = 'error' in envelope ? serviceErrorOf(envelope.error) : undefined;
+    if (failure === undefined ||
+        failure.data.code !== DEPLOYMENT_RETIRED ||
+        envelope.requestId !== null ||
+        envelope.invocation.source !== failure.data.details.deployment) {
+        return invalid();
+    }
+    return { envelope: envelope, reason: failure.data };
+}
+/** Every `Cache-Control` directive, lower-cased, across repeated fields in any spelling. */
+function cacheDirectives(input) {
+    const fields = input instanceof Headers
+        ? [input.get('cache-control') ?? '']
+        : Object.entries(input ?? {})
+            .filter(([name]) => name.toLowerCase() === 'cache-control')
+            .flatMap(([, value]) => value ?? []);
+    return fields.flatMap((field) => field.split(',').map((d) => d.trim().toLowerCase()));
+}
+/** Emitter-side programmer invariant: never reported as a received-response decode failure. */
+function assertEmitterInput(deployment, release) {
+    if (!isIssuer(deployment)) {
+        throw new TypeError('deploymentRetiredBody: deployment must be a canonical issuer origin.');
+    }
+    if (release !== undefined && (typeof release !== 'string' || !DIGEST.test(release))) {
+        throw new TypeError('deploymentRetiredBody: release must be a sha256 release digest.');
+    }
+}
+function invalid(cause) {
+    return fail('NATIVE_ROUTE_ROUTING_INVALID', `${HTTP_DEPLOYMENT_RETIRED} requires the deployment-retired error envelope.`, cause);
+}

package/dist/routes/encode.js

@@ -2,18 +2,19 @@ import { targetPath } from '@astrale-os/kernel-core/callable';
 import { Path } from '@astrale-os/kernel-core/path';
 import { callableAddress } from '@astrale-os/kernel-dsl/v1/addressing';
 import * as portable from '@astrale-os/kernel-dsl/value';
+import { routedDigest } from '../invocation/index.js';
 import { firstCredentialIsAmbient, putCredential, specificHeaderWires, withoutCredentialHeaders, } from './credential.js';
 import { fail, invalidRequest } from './error.js';
 import { isReservedHeader } from './mapping.js';
-import { encodeStrongEtag, HTTP_ROUTE_ISSUER, HTTP_ROUTE_PUBLICATION } from './routing.js';
+import { encodeStrongEtag, HTTP_ROUTE_DIGEST, HTTP_ROUTE_ISSUER } from './routing.js';
 import { asObject, encodeScalar, scalar } from './scalar.js';
-import { requiresReceiver } from './target.js';
+import { requiresReceiver, routeFingerprint } from './target.js';
 import { authorityEnd, encodeTemplate, PLACEHOLDER } from './template.js';
 export function encode(entry, invocation, domain) {
     if (typeof invocation.call.target !== 'string' &&
-        invocation.call.target.revision !== undefined &&
-        invocation.call.target.revision !== domain.revision) {
-        invalidRequest('Invocation Target revision does not match the selected route Domain.');
+        invocation.call.target.fingerprint !== undefined &&
+        invocation.call.target.fingerprint !== routeFingerprint(domain, entry.callable)) {
+        invalidRequest('Invocation Target fingerprint does not match the selected route Domain.');
     }
     const input = asObject(invocation.call.input);
     const target = Path.from(targetPath(invocation.call.target));
@@ -109,7 +110,7 @@ export function encode(entry, invocation, domain) {
         }
     }
     if (invocation.routing !== undefined) {
-        headers[HTTP_ROUTE_PUBLICATION] = encodeStrongEtag(invocation.routing.publication.etag);
+        headers[HTTP_ROUTE_DIGEST] = encodeStrongEtag(routedDigest(invocation.routing));
         headers[HTTP_ROUTE_ISSUER] = invocation.routing.issuer;
     }
     url = parsed.toString();

package/dist/routes/entries.d.ts

@@ -0,0 +1,23 @@
+import type { Domain } from '@astrale-os/kernel-dsl/v1';
+import type { Object as JsonObject, Value as JsonValue } from '@astrale-os/kernel-dsl/value';
+import type { Plan } from './plan.js';
+import type { Placed } from './reservation.js';
+import type { Route } from './table.js';
+type Meaning = Pick<Domain, 'origin' | 'revision' | 'callable'>;
+/**
+ * The coordinate in which a served document differs from one Plan placed at `publicUrl`: its
+ * origin or schema revision (`identity`), or its route wire (`routes`). Each Table words its own
+ * refusal after the document it binds.
+ */
+export declare function placementMismatch(plan: Plan, deployed: Placed, domain: Domain, publicUrl: string): 'identity' | 'routes' | undefined;
+/** The entries of one placed Plan at the hrefs its served document publishes. */
+export declare function placedEntries(plan: Plan, deployed: Pick<Placed, 'routes'>): readonly Route[];
+/** Whether entries carry exactly the route wire and Domain identity of one served document. */
+export declare function sameServedWire(entries: readonly Route[], deployed: Pick<Placed, 'origin' | 'schema' | 'routes'>, domain: Meaning): boolean;
+/** Refuse an entry whose target, auth or output differs from the Domain's callable meaning. */
+export declare function verifyMeaning(entries: readonly Route[], domain: Meaning): void;
+/** Admit one portable Table object holding exactly `fields`. */
+export declare function tableObject(input: unknown, fields: readonly string[]): JsonObject;
+/** Admit the entries of one Table bound to `origin`; an invalid route wire is a `ReleaseError`. */
+export declare function acceptEntries(input: JsonValue | undefined, origin: string): readonly Route[];
+export {};