@astrale-os/kernel-server 0.5.0-beta.69 → 0.5.0-beta.70

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

@@ -0,0 +1,5 @@
+import type { Domain } from '@astrale-os/kernel-dsl/v1';
+import type * as publication from '@astrale-os/kernel-protocol/publication';
+import { type Table } from '@astrale-os/kernel-protocol/routes/legacy';
+/** @deprecated Use `admitTable` in `server/release/table.ts` for release-bound routes. */
+export declare function admitTable(deployed: publication.Publication, input: Table | undefined, domain: Domain): Table;

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

@@ -1,6 +1,6 @@
 import { reference } from '@astrale-os/kernel-protocol/publication/reference';
-import { acceptTable } from '@astrale-os/kernel-protocol/routes/admission';
-import { verifyTable } from '@astrale-os/kernel-protocol/routes/evidence';
+import { acceptTable, verifyTable } from '@astrale-os/kernel-protocol/routes/legacy';
+/** @deprecated Use `admitTable` in `server/release/table.ts` for release-bound routes. */
 export function admitTable(deployed, input, domain) {
     if (input === undefined) {
         if (deployed.routes.length !== 0) {

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

@@ -1,20 +1,29 @@
 import type { Domain } from '@astrale-os/kernel-dsl/v1';
 import type * as publication from '@astrale-os/kernel-protocol/publication';
-import type * as routes from '@astrale-os/kernel-protocol/routes';
+import type { Table } from '@astrale-os/kernel-protocol/routes/legacy';
 declare const PUBLICATION_SNAPSHOT: unique symbol;
+/** @deprecated Successor: `ReleaseSnapshotInput`, which serves a `DomainRelease`. */
 export interface PublicationSnapshotInput {
     readonly publication: publication.Publication;
     /** Exact artifact served at Publication.schema.bundle.href. */
     readonly bundle: Uint8Array;
-    readonly table?: routes.Table;
+    readonly table?: Table;
     readonly domain: Domain;
 }
-/** Immutable admitted serving identity; bundle and compiled routes remain Server-private. */
+/**
+ * Immutable admitted serving identity; bundle and compiled routes remain Server-private.
+ *
+ * @deprecated Successor: `ReleaseSnapshot`, which serves a `DomainRelease` and its v3 projection.
+ */
 export interface PublicationSnapshot {
     readonly publication: publication.Publication;
     readonly [PUBLICATION_SNAPSHOT]: true;
 }
-/** Atomically readable source swapped only after a complete snapshot is prepared. */
+/**
+ * Atomically readable source swapped only after a complete snapshot is prepared.
+ *
+ * @deprecated Successor: `ReleaseSource`.
+ */
 export interface PublicationSource {
     /** Undefined until the first revision-coherent snapshot is ready. */
     current(): PublicationSnapshot | undefined;

package/dist/release/served.d.ts

@@ -0,0 +1,30 @@
+import type { IssuerId } from '@astrale-os/kernel-core/auth/issuer';
+import type { DomainRelease } from '@astrale-os/kernel-protocol/release';
+import type { Publication } from '@astrale-os/kernel-protocol/release/legacy';
+import type { PreparedPublicationSnapshot } from './legacy/snapshot.js';
+import type { PublicationSnapshot, PublicationSource } from './legacy/types.js';
+import type { PreparedReleaseSnapshot } from './snapshot.js';
+import type { ReleaseSnapshot, ReleaseSource } from './types.js';
+export type ServingSource = {
+    readonly kind: 'release';
+    readonly source: ReleaseSource;
+} | {
+    readonly kind: 'publication';
+    readonly source: PublicationSource;
+};
+export type Served = PreparedReleaseSnapshot | PreparedPublicationSnapshot;
+export interface RequestServing {
+    readonly kind: ServingSource['kind'];
+    /** The snapshot the request pins; undefined while none is ready or it is withheld. */
+    current(): Served | undefined;
+    /** The deployment a DEPLOYMENT_RETIRED answer names: the Server's public serving origin. */
+    deployment(): IssuerId;
+}
+export declare function readServed(serving: ServingSource): Served | undefined;
+/** A release and its v3 projection share bundles, Delivery endpoints and native routes. */
+export declare function servedDocument(served: Served): DomainRelease | Publication;
+export declare function pinned(served: Served): {
+    readonly release: ReleaseSnapshot;
+} | {
+    readonly publication: PublicationSnapshot;
+};

package/dist/release/served.js

@@ -0,0 +1,14 @@
+import { readPreparedPublicationSnapshot } from './legacy/snapshot.js';
+import { readPreparedReleaseSnapshot } from './snapshot.js';
+export function readServed(serving) {
+    return serving.kind === 'release'
+        ? readPreparedReleaseSnapshot(serving.source.current())
+        : readPreparedPublicationSnapshot(serving.source.current());
+}
+/** A release and its v3 projection share bundles, Delivery endpoints and native routes. */
+export function servedDocument(served) {
+    return served.kind === 'release' ? served.release : served.publication;
+}
+export function pinned(served) {
+    return served.kind === 'release' ? { release: served.snapshot } : { publication: served.snapshot };
+}

package/dist/release/snapshot.d.ts

@@ -0,0 +1,26 @@
+import type { Domain } from '@astrale-os/kernel-dsl/v1';
+import type { ServedReferences, Table } from '@astrale-os/kernel-protocol/routes';
+import { type DomainRelease } from '@astrale-os/kernel-protocol/release';
+import { type Publication } from '@astrale-os/kernel-protocol/release/legacy';
+import type { ReleaseSnapshot, ReleaseSnapshotInput } from './types.js';
+export interface PreparedReleaseSnapshot {
+    readonly kind: 'release';
+    readonly snapshot: ReleaseSnapshot;
+    readonly release: DomainRelease;
+    readonly releaseBytes: Uint8Array;
+    /** @deprecated Use `release`. Frozen v3 projection served at `domain.json`. */
+    readonly publication: Publication;
+    readonly publicationBytes: Uint8Array;
+    /** The release and the projection reference native-route If-Match may name. */
+    readonly references: ServedReferences;
+    readonly bundle: Uint8Array;
+    readonly table: Table;
+    readonly domain: Domain;
+}
+/**
+ * Admit and detach one deployment's serving snapshot before it is served: the release, its exact
+ * bundle bytes, its resolved Domain and route Table, and its frozen v3 projection.
+ */
+export declare function prepareReleaseSnapshot(input: ReleaseSnapshotInput): ReleaseSnapshot;
+/** Internal proof that a ReleaseSource returned a Server-prepared snapshot without cloning it. */
+export declare function readPreparedReleaseSnapshot(input: unknown): PreparedReleaseSnapshot | undefined;

package/dist/release/snapshot.js

@@ -0,0 +1,54 @@
+import { accept as acceptRelease, bundleUrl, encode as encodeRelease, verifyBundleBytes, } from '@astrale-os/kernel-protocol/release';
+import { encode as encodePublication, publication as project, reference as publicationReference, } from '@astrale-os/kernel-protocol/release/legacy';
+import { admitTable } from './table.js';
+const snapshots = new WeakMap();
+/**
+ * Admit and detach one deployment's serving snapshot before it is served: the release, its exact
+ * bundle bytes, its resolved Domain and route Table, and its frozen v3 projection.
+ */
+export function prepareReleaseSnapshot(input) {
+    if (input === null || typeof input !== 'object' || !(input.bundle instanceof Uint8Array)) {
+        throw new TypeError('Release snapshot input is invalid.');
+    }
+    const release = acceptRelease(input.release);
+    const bundleBytes = new Uint8Array(input.bundle);
+    verifyBundleBytes(release, bundleBytes);
+    const domain = input.domain;
+    if (domain.origin !== release.origin || domain.revision !== release.schema.revision) {
+        throw new TypeError('Release snapshot Domain identity differs from its release.');
+    }
+    const table = admitTable(release, input.table, domain);
+    const addressed = new URL(bundleUrl(release.identity.issuer, release.schema.bundle.ref));
+    const addressedDirectory = addressed.pathname.slice(0, addressed.pathname.lastIndexOf('/') + 1);
+    const servingBundle = new URL(release.schema.bundle.href);
+    if (servingBundle.origin === addressed.origin &&
+        servingBundle.pathname.startsWith(addressedDirectory) &&
+        servingBundle.href !== addressed.href) {
+        throw new TypeError('Release bundle URL differs from its artifact digest.');
+    }
+    const projection = project(release);
+    const snapshot = Object.freeze({ release, publication: projection });
+    const prepared = Object.freeze({
+        kind: 'release',
+        snapshot,
+        release,
+        releaseBytes: encodeRelease(release),
+        publication: projection,
+        publicationBytes: encodePublication(projection),
+        references: Object.freeze({
+            release: table.release,
+            projection: publicationReference(projection),
+        }),
+        bundle: bundleBytes,
+        table,
+        domain,
+    });
+    snapshots.set(snapshot, prepared);
+    return snapshot;
+}
+/** Internal proof that a ReleaseSource returned a Server-prepared snapshot without cloning it. */
+export function readPreparedReleaseSnapshot(input) {
+    if (input === null || typeof input !== 'object')
+        return undefined;
+    return snapshots.get(input);
+}

package/dist/release/table.d.ts

@@ -0,0 +1,4 @@
+import type { Domain } from '@astrale-os/kernel-dsl/v1';
+import type { DomainRelease } from '@astrale-os/kernel-protocol/release';
+import { type Table } from '@astrale-os/kernel-protocol/routes';
+export declare function admitTable(deployed: DomainRelease, input: Table | undefined, domain: Domain): Table;

package/dist/release/table.js

@@ -0,0 +1,11 @@
+import { reference } from '@astrale-os/kernel-protocol/release';
+import { acceptTable, verifyTable } from '@astrale-os/kernel-protocol/routes';
+export function admitTable(deployed, input, domain) {
+    if (input === undefined) {
+        if (deployed.routes.length !== 0) {
+            throw new TypeError('A release with native routes requires a Route Table.');
+        }
+        return verifyTable(Object.freeze({ release: reference(deployed), entries: Object.freeze([]) }), deployed, domain);
+    }
+    return verifyTable(acceptTable(input), deployed, domain);
+}

package/dist/release/types.d.ts

@@ -0,0 +1,33 @@
+import type { Domain } from '@astrale-os/kernel-dsl/v1';
+import type * as release from '@astrale-os/kernel-protocol/release';
+import type { Table } from '@astrale-os/kernel-protocol/routes';
+declare const RELEASE_SNAPSHOT: unique symbol;
+export interface ReleaseSnapshotInput {
+    readonly release: release.DomainRelease;
+    /** Exact artifact served at DomainRelease.schema.bundle.href. */
+    readonly bundle: Uint8Array;
+    /** Route Table bound to this release; required when it declares native routes. */
+    readonly table?: Table;
+    readonly domain: Domain;
+}
+/**
+ * Immutable admitted serving identity of one deployment: the release it serves at `release.json`
+ * and the frozen v3 projection it also serves at `domain.json`. Bundle and compiled routes remain
+ * Server-private.
+ */
+export interface ReleaseSnapshot {
+    readonly release: release.DomainRelease;
+    /**
+     * The frozen v3 projection served at `domain.json` and named by legacy routing witnesses.
+     *
+     * @deprecated Use `release`.
+     */
+    readonly publication: release.legacy.Publication;
+    readonly [RELEASE_SNAPSHOT]: true;
+}
+/** Atomically readable source swapped only after a complete snapshot is prepared. */
+export interface ReleaseSource {
+    /** Undefined until the first snapshot is ready. */
+    current(): ReleaseSnapshot | undefined;
+}
+export {};

package/dist/release/types.js

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

package/dist/routes/index.d.ts

@@ -1 +1 @@
-export { currentPublicationSnapshot, mountRoutes, type RouteLimits, type RouteReservation, } from './routes.js';
+export { currentServed, mountRoutes, type RouteLimits, type RouteReservation } from './routes.js';

package/dist/routes/index.js

@@ -1 +1 @@
-export { currentPublicationSnapshot, mountRoutes, } from './routes.js';
+export { currentServed, mountRoutes } from './routes.js';

package/dist/routes/routes.d.ts

@@ -1,10 +1,9 @@
 import type { CorsPolicy } from '../cors/index.js';
 import type { NextInvocationId } from '../invocation/index.js';
 import type { ActiveOperations } from '../lifecycle/index.js';
-import type { Provider as DeliveryProvider } from '../publication/delivery/index.js';
-import type { PublicationSource } from '../publication/index.js';
+import type { Provider as DeliveryProvider } from '../release/delivery/index.js';
+import type { Served, ServingSource } from '../release/served.js';
 import { type ApplicationHost, type Handler } from '../invocation/index.js';
-import { type PreparedPublicationSnapshot } from '../publication/index.js';
 import { type ServerRouter } from '../transport/router.js';
 export interface RouteLimits {
     readonly maximumRequestBytes: number;
@@ -17,9 +16,13 @@ export interface RouteReservation {
     readonly path: string;
     readonly methods: readonly string[];
 }
-export declare function mountRoutes(app: ServerRouter, source: PublicationSource, deliveryProvider: DeliveryProvider | undefined, handler: Handler, active: ActiveOperations, nextInvocation: NextInvocationId, limits: RouteLimits, cors: CorsPolicy, hostFor: (request: Request) => ApplicationHost | undefined, reservations: readonly RouteReservation[], externalIssuer?: string, publicOrigin?: string): void;
-export declare function currentPublicationSnapshot(source: PublicationSource, limits: Pick<RouteLimits, 'maximumPublicationBytes' | 'maximumBundleBytes'>, serving?: {
+export declare function mountRoutes(app: ServerRouter, source: ServingSource, deliveryProvider: DeliveryProvider | undefined, handler: Handler, active: ActiveOperations, nextInvocation: NextInvocationId, limits: RouteLimits, cors: CorsPolicy, hostFor: (request: Request) => ApplicationHost | undefined, reservations: readonly RouteReservation[], externalIssuer?: string, publicOrigin?: string): void;
+/**
+ * Read the one snapshot a request pins, withheld while it exceeds a serving limit, names another
+ * serving issuer, or claims a route this Server reserves.
+ */
+export declare function currentServed(source: ServingSource, limits: Pick<RouteLimits, 'maximumPublicationBytes' | 'maximumBundleBytes'>, serving?: {
     readonly origin: string;
     readonly issuer?: string;
     readonly reservations: readonly RouteReservation[];
-}): PreparedPublicationSnapshot | undefined;
+}): Served | undefined;

package/dist/routes/routes.js

@@ -1,59 +1,46 @@
 import * as codecs from '@astrale-os/kernel-protocol/codecs';
 import * as errors from '@astrale-os/kernel-protocol/errors';
 import * as protocol from '@astrale-os/kernel-protocol/invocation';
-import { bundleUrl } from '@astrale-os/kernel-protocol/publication';
-import { mediaType as publicationMediaType, PATH as PUBLICATION_PATH, url as publicationUrl, } from '@astrale-os/kernel-protocol/publication/publication';
-import { reference as publicationReference } from '@astrale-os/kernel-protocol/publication/reference';
+import { bundleUrl, MEDIA_TYPE as RELEASE_MEDIA_TYPE, PATH as RELEASE_PATH, url as releaseUrl, } from '@astrale-os/kernel-protocol/release';
+import { mediaType as publicationMediaType, PATH as PUBLICATION_PATH, reference as publicationReference, url as publicationUrl, } from '@astrale-os/kernel-protocol/release/legacy';
 import * as routes from '@astrale-os/kernel-protocol/routes';
 import { admissionRefusal, classifyError, classifyRequestError, RequestBodyInvalidError, RequestBodyTooLargeError, retryAfterHeaders, } from '../errors/index.js';
 import { invocationContext } from '../invocation/index.js';
-import { handleDelivery } from '../publication/delivery/index.js';
-import { readPreparedPublicationSnapshot, } from '../publication/index.js';
+import { handleDelivery } from '../release/delivery/index.js';
+import { pinned, readServed, servedDocument } from '../release/served.js';
 import { readBoundedBody } from '../transport/body.js';
 import {} from '../transport/router.js';
 import { interruptedStreamError } from '../transport/stream-error.js';
 export function mountRoutes(app, source, deliveryProvider, handler, active, nextInvocation, limits, cors, hostFor, reservations, externalIssuer, publicOrigin) {
-    const publicationPath = externalIssuer === undefined
-        ? PUBLICATION_PATH
-        : new URL(publicationUrl(externalIssuer)).pathname;
     const externalOrigin = publicOrigin ?? (externalIssuer === undefined ? undefined : new URL(externalIssuer).origin);
-    if (cors.enabled) {
-        app.options(publicationPath, (context) => cors.preflight(context.req.raw, {
-            methods: ['GET'],
-            headers: ['if-none-match'],
-        }));
-    }
-    app.get(publicationPath, (context) => {
-        const responseCors = cors.response(context.req.raw, ['etag']);
-        if (!active.isAccepting) {
-            return drained('Publication is unavailable while draining.', (exposed) => cors.response(context.req.raw, exposed));
-        }
-        const snapshot = servingSnapshot(source, limits, context.req.raw, reservations, externalIssuer, externalOrigin);
-        if (snapshot === undefined)
-            return response({ error: 'Publication is not ready.' }, 503, responseCors);
-        const body = snapshot.publicationBytes;
-        if (context.req.raw.headers.get('if-none-match') === quoteEtag(snapshot.publication.etag)) {
-            return new Response(null, {
-                status: 304,
-                headers: {
-                    ...responseCors,
-                    etag: quoteEtag(snapshot.publication.etag),
-                    'cache-control': 'public, max-age=0, must-revalidate, no-transform',
-                },
-            });
-        }
-        return new Response(toBody(body), {
-            status: 200,
-            headers: {
-                ...responseCors,
-                'content-type': publicationMediaType(snapshot.publication),
-                etag: quoteEtag(snapshot.publication.etag),
-                'cache-control': 'public, max-age=0, must-revalidate, no-transform',
-            },
+    const served = (request) => servingSnapshot(source, limits, request, reservations, externalIssuer, externalOrigin);
+    if (source.kind === 'release') {
+        mountDocument(app, documentPath(RELEASE_PATH, releaseUrl, externalIssuer), 'Release', {
+            cors,
+            active,
+            served,
+            read: (snapshot) => snapshot.kind === 'release'
+                ? {
+                    bytes: snapshot.releaseBytes,
+                    mediaType: RELEASE_MEDIA_TYPE,
+                    etag: snapshot.release.digest,
+                }
+                : undefined,
         });
+    }
+    // At a release-backed destination `domain.json` serves the frozen v3 projection.
+    mountDocument(app, documentPath(PUBLICATION_PATH, publicationUrl, externalIssuer), 'Publication', {
+        cors,
+        active,
+        served,
+        read: (snapshot) => ({
+            bytes: snapshot.publicationBytes,
+            mediaType: publicationMediaType(snapshot.publication),
+            etag: snapshot.publication.etag,
+        }),
     });
     app.all('*', async (context) => {
-        const snapshot = servingSnapshot(source, limits, context.req.raw, reservations, externalIssuer, externalOrigin);
+        const snapshot = served(context.req.raw);
         if (snapshot === undefined)
             return context.notFound();
         const request = context.req.raw;
@@ -62,17 +49,27 @@ export function mountRoutes(app, source, deliveryProvider, handler, active, next
         }
         const responseCors = cors.response(request);
         const corsFor = (exposed) => cors.response(request, exposed);
-        const descriptor = snapshot.publication.schema.bundle;
-        const addressed = bundleUrl(snapshot.publication.identity.issuer, descriptor.ref);
+        const document = servedDocument(snapshot);
+        const descriptor = document.schema.bundle;
+        const addressed = bundleUrl(document.identity.issuer, descriptor.ref);
         const immutable = descriptor.href === addressed;
-        if (sameRoute(request.url, snapshot.publication.schema.bundle.href, externalOrigin)) {
-            if (!active.isAccepting)
-                return drained('Publication artifact is unavailable while draining.', corsFor);
+        if (sameRoute(request.url, descriptor.href, externalOrigin)) {
+            // A release names its own document; a v3-input destination keeps its recorded bytes.
+            const releaseBacked = snapshot.kind === 'release';
+            if (!active.isAccepting) {
+                return drained(releaseBacked
+                    ? 'Release artifact is unavailable while draining.'
+                    : 'Publication artifact is unavailable while draining.', corsFor);
+            }
             if (request.method !== 'GET')
                 return response({ error: 'Bundle retrieval requires GET.' }, 405, responseCors);
             const body = snapshot.bundle;
-            if (body.byteLength !== snapshot.publication.schema.bundle.ref.size) {
-                return response({ error: 'Bundle differs from its Publication.' }, 500, responseCors);
+            if (body.byteLength !== descriptor.ref.size) {
+                return response({
+                    error: releaseBacked
+                        ? 'Bundle differs from its release.'
+                        : 'Bundle differs from its Publication.',
+                }, 500, responseCors);
             }
             const etag = quoteEtag(descriptor.ref.digest);
             const unchanged = request.headers.get('if-none-match') === etag;
@@ -80,7 +77,7 @@ export function mountRoutes(app, source, deliveryProvider, handler, active, next
                 status: unchanged ? 304 : 200,
                 headers: {
                     ...responseCors,
-                    'content-type': snapshot.publication.schema.bundle.ref.mediaType,
+                    'content-type': descriptor.ref.mediaType,
                     etag,
                     'cache-control': immutable
                         ? 'public, max-age=31536000, immutable, no-transform'
@@ -100,25 +97,27 @@ export function mountRoutes(app, source, deliveryProvider, handler, active, next
                 });
             }
         }
-        const deliveryUrl = snapshot.publication.delivery?.href;
+        const deliveryUrl = document.delivery?.href;
         if (deliveryUrl !== undefined && sameRoute(request.url, deliveryUrl, externalOrigin)) {
             return handleDelivery(request, snapshot, deliveryProvider, active, limits, corsFor);
         }
         let routing;
         try {
-            const ifMatch = request.headers.get(routes.HTTP_ROUTE_PUBLICATION);
-            if (ifMatch !== null &&
-                /^"sha256:[0-9a-f]{64}"$/u.test(ifMatch) &&
-                ifMatch !== quoteEtag(snapshot.publication.etag)) {
-                return new Response(null, {
-                    status: routes.HTTP_ROUTE_STALE_STATUS,
-                    headers: {
-                        ...cors.response(request, [routes.HTTP_ROUTE_STALE]),
-                        ...routes.staleHeaders(snapshot.publication.etag),
-                    },
-                });
+            if (snapshot.kind === 'release') {
+                const decoded = routes.decodeRouting(request, snapshot.references);
+                if (decoded?.kind === 'stale')
+                    return stale(request, decoded.current, cors);
+                routing = decoded;
+            }
+            else {
+                const ifMatch = request.headers.get(routes.HTTP_ROUTE_DIGEST);
+                if (ifMatch !== null &&
+                    /^"sha256:[0-9a-f]{64}"$/u.test(ifMatch) &&
+                    ifMatch !== quoteEtag(snapshot.publication.etag)) {
+                    return stale(request, snapshot.publication.etag, cors);
+                }
+                routing = routes.legacy.decodeRouting(request, publicationReference(snapshot.publication));
             }
-            routing = routes.decodeRouting(request, publicationReference(snapshot.publication));
         }
         catch (cause) {
             if (cause instanceof routes.RouteError) {
@@ -136,7 +135,10 @@ export function mountRoutes(app, source, deliveryProvider, handler, active, next
         let handedOff = false;
         try {
             const body = await readBoundedBody(request, limits.maximumRequestBytes, operation.signal);
-            const invocation = routes.decode(route, { url: request.url, method: request.method, headers: request.headers, body }, snapshot.domain, snapshot.table.publication);
+            const native = { url: request.url, method: request.method, headers: request.headers, body };
+            const invocation = snapshot.kind === 'release'
+                ? routes.decode(route, native, snapshot.domain, snapshot.references)
+                : routes.legacy.decode(route, native, snapshot.domain, snapshot.table.publication);
             const idempotencyHeader = request.headers.get(protocol.HTTP_IDEMPOTENCY_KEY);
             const idempotencyKey = idempotencyHeader === null
                 ? undefined
@@ -145,7 +147,7 @@ export function mountRoutes(app, source, deliveryProvider, handler, active, next
                 call: invocation.call,
                 ...(invocation.credential === undefined ? {} : { credential: invocation.credential }),
                 ...(routing === undefined ? {} : { via: routing }),
-                publication: snapshot.snapshot,
+                ...pinned(snapshot),
                 context: invocationContext(assigned, operation, active, hostFor(request), body, idempotencyKey),
             }));
             if (result.kind === 'value') {
@@ -280,10 +282,11 @@ function isStreamingBinary(input) {
     return !(input.body instanceof Uint8Array);
 }
 function publicationPreflight(cors, request, snapshot, externalOrigin) {
-    if (sameRoute(request.url, snapshot.publication.schema.bundle.href, externalOrigin)) {
+    const document = servedDocument(snapshot);
+    if (sameRoute(request.url, document.schema.bundle.href, externalOrigin)) {
         return cors.preflight(request, { methods: ['GET'], headers: ['if-none-match'] });
     }
-    const deliveryUrl = snapshot.publication.delivery?.href;
+    const deliveryUrl = document.delivery?.href;
     if (deliveryUrl !== undefined && sameRoute(request.url, deliveryUrl, externalOrigin)) {
         return cors.preflight(request, {
             methods: ['POST'],
@@ -299,7 +302,7 @@ function publicationPreflight(cors, request, snapshot, externalOrigin) {
 function nativeCorsRoute(entry, requestedMethod) {
     const headers = new Set([
         'accept',
-        routes.HTTP_ROUTE_PUBLICATION,
+        routes.HTTP_ROUTE_DIGEST,
         routes.HTTP_ROUTE_ISSUER,
         protocol.HTTP_IDEMPOTENCY_KEY,
     ]);
@@ -328,22 +331,26 @@ function nativeCorsRoute(entry, requestedMethod) {
         ...(allowAnyHeaders ? { allowAnyHeaders: true } : {}),
     });
 }
-export function currentPublicationSnapshot(source, limits, serving) {
-    const snapshot = source.current();
-    if (snapshot === undefined)
-        return undefined;
-    const prepared = readPreparedPublicationSnapshot(snapshot);
+/**
+ * Read the one snapshot a request pins, withheld while it exceeds a serving limit, names another
+ * serving issuer, or claims a route this Server reserves.
+ */
+export function currentServed(source, limits, serving) {
+    const prepared = readServed(source);
     if (prepared === undefined ||
+        (prepared.kind === 'release' &&
+            prepared.releaseBytes.byteLength > limits.maximumPublicationBytes) ||
         prepared.publicationBytes.byteLength > limits.maximumPublicationBytes ||
         prepared.bundle.byteLength > limits.maximumBundleBytes ||
-        (serving?.issuer !== undefined && prepared.publication.identity.issuer !== serving.issuer) ||
+        (serving?.issuer !== undefined &&
+            servedDocument(prepared).identity.issuer !== serving.issuer) ||
         (serving !== undefined && conflictsWithServingRoutes(prepared, serving))) {
         return undefined;
     }
     return prepared;
 }
 function servingSnapshot(source, limits, request, reservations, externalIssuer, publicOrigin) {
-    return currentPublicationSnapshot(source, limits, {
+    return currentServed(source, limits, {
         origin: publicOrigin ??
             (externalIssuer === undefined ? new URL(request.url).origin : new URL(externalIssuer).origin),
         ...(externalIssuer === undefined ? {} : { issuer: externalIssuer }),
@@ -362,6 +369,58 @@ function conflictsWithServingRoutes(snapshot, serving) {
     }
     return false;
 }
+function documentPath(path, url, externalIssuer) {
+    return externalIssuer === undefined ? path : new URL(url(externalIssuer)).pathname;
+}
+function mountDocument(app, path, name, serving) {
+    const { cors, active } = serving;
+    if (cors.enabled) {
+        app.options(path, (context) => cors.preflight(context.req.raw, {
+            methods: ['GET'],
+            headers: ['if-none-match'],
+        }));
+    }
+    app.get(path, (context) => {
+        const responseCors = cors.response(context.req.raw, ['etag']);
+        if (!active.isAccepting) {
+            return drained(`${name} is unavailable while draining.`, (exposed) => cors.response(context.req.raw, exposed));
+        }
+        const snapshot = serving.served(context.req.raw);
+        const document = snapshot === undefined ? undefined : serving.read(snapshot);
+        if (document === undefined)
+            return response({ error: `${name} is not ready.` }, 503, responseCors);
+        const etag = quoteEtag(document.etag);
+        if (context.req.raw.headers.get('if-none-match') === etag) {
+            return new Response(null, {
+                status: 304,
+                headers: {
+                    ...responseCors,
+                    etag,
+                    'cache-control': 'public, max-age=0, must-revalidate, no-transform',
+                },
+            });
+        }
+        return new Response(toBody(document.bytes), {
+            status: 200,
+            headers: {
+                ...responseCors,
+                'content-type': document.mediaType,
+                etag,
+                'cache-control': 'public, max-age=0, must-revalidate, no-transform',
+            },
+        });
+    });
+}
+/** Reserved native stale control naming the digest the destination serves (`StaleControl.current`). */
+function stale(request, current, cors) {
+    return new Response(null, {
+        status: routes.HTTP_ROUTE_STALE_STATUS,
+        headers: {
+            ...cors.response(request, [routes.HTTP_ROUTE_STALE]),
+            ...routes.staleHeaders(current),
+        },
+    });
+}
 async function streamResponse(stream, operation, cors) {
     const iterator = stream[Symbol.asyncIterator]();
     let rejectSetup;
@@ -504,7 +563,7 @@ function response(body, status, cors) {
         headers: { ...cors, 'content-type': 'application/json' },
     });
 }
-/** A Publication artifact refused while draining presents the lifecycle retry delay. */
+/** A served document or artifact refused while draining presents the lifecycle retry delay. */
 function drained(message, cors) {
     const retry = retryAfterHeaders(admissionRefusal(false));
     return response({ error: message }, 503, { ...cors(Object.keys(retry)), ...retry });