@astrale-os/kernel-server 0.5.0-beta.1 → 0.5.0-beta.10

package/dist/issuer/exchange.js

@@ -0,0 +1,136 @@
+import { inspect as inspectCredential } from '@astrale-os/kernel-core/auth/credential';
+import * as errors from '@astrale-os/kernel-protocol/errors';
+import * as exchangeProtocol from '@astrale-os/kernel-protocol/issuer/exchange';
+import { paths as issuerPaths } from '@astrale-os/kernel-protocol/issuer/paths';
+const PROVIDER_CODES = new Set([
+    errors.CODES.AUTH_INVALID,
+    errors.CODES.AUTH_EXPIRED,
+    errors.CODES.BACKEND_UNAVAILABLE,
+    errors.CODES.DEADLINE_EXCEEDED,
+]);
+export function capture(input) {
+    if (input === null || typeof input !== 'object' || typeof input.exchange !== 'function') {
+        throw new TypeError('Token-exchange provider is invalid.');
+    }
+    const exchange = input.exchange;
+    return Object.freeze({
+        exchange: (request, context) => exchange.call(input, request, context),
+    });
+}
+export function mount(app, issuer, provider, cors, active, timeoutMs) {
+    const path = issuerPaths(issuer).tokenExchange;
+    if (cors.enabled) {
+        app.options(path, (context) => cors.preflight(context.req.raw, { methods: ['POST'], headers: ['authorization', 'accept'] }));
+    }
+    app.all(path, async (context) => {
+        const request = context.req.raw;
+        const respond = (payload, extra) => json(payload, errors.httpStatusOf(payload.error), request, cors, extra);
+        let admitted;
+        try {
+            admitted = exchangeProtocol.acceptHttpRequest({
+                method: request.method,
+                url: request.url,
+                authorization: request.headers.get('authorization'),
+                accept: request.headers.get('accept'),
+            });
+        }
+        catch (cause) {
+            if (cause instanceof errors.ProtocolError) {
+                return respond(exchangeProtocol.acceptErrorResponse({ error: cause.payload }), cause.payload.code === errors.CODES.METHOD_NOT_ALLOWED ? { allow: 'POST' } : undefined);
+            }
+            throw cause;
+        }
+        if (!active.isAccepting) {
+            return respond(error('BACKEND_UNAVAILABLE', 'Token exchange is unavailable.'));
+        }
+        const operation = active.begin(timeoutMs, request.signal);
+        if (operation === undefined) {
+            return respond(error('LIMIT_EXCEEDED', 'Token-exchange limit exceeded.'));
+        }
+        try {
+            try {
+                await requireEmptyBody(request, operation.signal);
+            }
+            catch (cause) {
+                if (operation.timedOut) {
+                    return respond(error('DEADLINE_EXCEEDED', 'Token-exchange deadline elapsed.'));
+                }
+                if (cause instanceof errors.ProtocolError) {
+                    return respond(exchangeProtocol.acceptErrorResponse({ error: cause.payload }));
+                }
+                throw cause;
+            }
+            let output;
+            try {
+                output = await provider.exchange(admitted, { signal: operation.signal });
+            }
+            catch (cause) {
+                if (operation.timedOut) {
+                    return respond(error('DEADLINE_EXCEEDED', 'Token-exchange deadline elapsed.'));
+                }
+                if (cause instanceof errors.ProtocolError && PROVIDER_CODES.has(cause.payload.code)) {
+                    return respond(exchangeProtocol.acceptErrorResponse({ error: cause.payload }));
+                }
+                throw cause;
+            }
+            if (operation.timedOut) {
+                return respond(error('DEADLINE_EXCEEDED', 'Token-exchange deadline elapsed.'));
+            }
+            const response = exchangeProtocol.acceptResponse(output);
+            if (inspectCredential(response.token).claims.exp !== response.expiresAt) {
+                throw new TypeError('Token-exchange provider returned inconsistent expiry evidence.');
+            }
+            return json(response, 200, request, cors);
+        }
+        catch {
+            return respond(error('INTERNAL_ERROR', 'Internal token-exchange failure.'));
+        }
+        finally {
+            operation.settle();
+        }
+    });
+}
+async function requireEmptyBody(request, signal) {
+    const declared = request.headers.get('content-length');
+    if (declared !== null && declared !== '0')
+        invalidRequest();
+    const reader = request.body?.getReader();
+    if (reader === undefined)
+        return;
+    const abort = () => void reader.cancel(signal.reason).catch(() => undefined);
+    signal.addEventListener('abort', abort, { once: true });
+    try {
+        if (signal.aborted)
+            throw signal.reason;
+        const first = await reader.read();
+        if (!first.done) {
+            await reader.cancel('token exchange requires an empty body').catch(() => undefined);
+            invalidRequest();
+        }
+    }
+    finally {
+        signal.removeEventListener('abort', abort);
+        reader.releaseLock();
+    }
+}
+function invalidRequest() {
+    throw new errors.ProtocolError({
+        code: errors.CODES.INVALID_REQUEST,
+        message: 'Token exchange requires an empty request body.',
+    });
+}
+function error(code, message) {
+    return exchangeProtocol.acceptErrorResponse({
+        error: { code: errors.CODES[code], message },
+    });
+}
+function json(value, status, request, cors, extra) {
+    const headers = new Headers(exchangeProtocol.responseHeaders());
+    for (const [name, value] of Object.entries(cors.response(request)))
+        headers.set(name, value);
+    if (extra !== undefined) {
+        for (const [name, value] of new Headers(extra))
+            headers.set(name, value);
+    }
+    return new Response(JSON.stringify(value), { status, headers });
+}

package/dist/issuer/index.d.ts

@@ -1,3 +1,3 @@
 export { admitIssuer, issuerRouteReservations, mountIssuer, type IssuerRouteReservation, } from './routes.js';
+export type * as exchange from './exchange.js';
 export type { Issuer } from './types.js';
-//# sourceMappingURL=index.d.ts.map

package/dist/issuer/index.js

@@ -1,2 +1 @@
 export { admitIssuer, issuerRouteReservations, mountIssuer, } from './routes.js';
-//# sourceMappingURL=index.js.map

package/dist/issuer/routes.d.ts

@@ -1,13 +1,13 @@
 import type { CorsPolicy } from '../cors/index.js';
 import type { ActiveOperations } from '../lifecycle/index.js';
 import type { ServerRouter } from '../transport/index.js';
+import type { Provider } from './exchange.js';
 import type { Issuer } from './types.js';
 export interface IssuerRouteReservation {
     readonly path: string;
     readonly methods: readonly string[];
 }
-export declare function issuerRouteReservations(input: Issuer): readonly IssuerRouteReservation[];
-export declare function mountIssuer(app: ServerRouter, input: Issuer, cors: CorsPolicy, active: ActiveOperations, timeoutMs: number): void;
+export declare function issuerRouteReservations(input: Issuer, tokenExchange?: boolean): readonly IssuerRouteReservation[];
+export declare function mountIssuer(app: ServerRouter, input: Issuer, cors: CorsPolicy, active: ActiveOperations, timeoutMs: number, tokenExchange?: Provider): void;
 /** Admit static discovery configuration before Runtime Boot performs any durable work. */
 export declare function admitIssuer(input: Issuer): Issuer;
-//# sourceMappingURL=routes.d.ts.map

package/dist/issuer/routes.js

@@ -1,11 +1,18 @@
-import { issuer as issuerDiscovery } from '@astrale-os/kernel-protocol';
+import { configuration } from '@astrale-os/kernel-protocol/issuer/configuration';
+import { hosted } from '@astrale-os/kernel-protocol/issuer/hosted';
+import { keySet } from '@astrale-os/kernel-protocol/issuer/key-set';
+import { paths as issuerPaths } from '@astrale-os/kernel-protocol/issuer/paths';
 import { IssuerKeysUnavailableError } from '../errors/index.js';
-export function issuerRouteReservations(input) {
-    const paths = issuerDiscovery.paths(input.issuer);
+import { mount } from './exchange.js';
+export function issuerRouteReservations(input, tokenExchange = false) {
+    const paths = issuerPaths(input.issuer);
     const reservations = [
         Object.freeze({ path: paths.configuration, methods: Object.freeze(['GET']) }),
         Object.freeze({ path: paths.keys, methods: Object.freeze(['GET']) }),
     ];
+    if (tokenExchange) {
+        reservations.push(Object.freeze({ path: paths.tokenExchange, methods: Object.freeze(['POST']) }));
+    }
     if (input.loadIssuerPublicKeys !== undefined) {
         const base = new URL(input.issuer).pathname.replace(/\/+$/u, '');
         reservations.push(Object.freeze({
@@ -18,16 +25,18 @@ export function issuerRouteReservations(input) {
     }
     return Object.freeze(reservations);
 }
-export function mountIssuer(app, input, cors, active, timeoutMs) {
+export function mountIssuer(app, input, cors, active, timeoutMs, tokenExchange) {
     const issuer = input.issuer;
-    const paths = issuerDiscovery.paths(issuer);
+    const paths = issuerPaths(issuer);
     const headers = (request) => ({
         ...cors.response(request),
         'cache-control': 'no-cache',
     });
     const algorithm = input.signingAlgorithm ?? 'ES256';
-    const configuration = issuerDiscovery.configuration(issuer, [algorithm]);
-    app.get(paths.configuration, (context) => context.json(configuration, 200, headers(context.req.raw)));
+    const discovery = configuration(issuer, [algorithm], {
+        tokenExchange: tokenExchange !== undefined,
+    });
+    app.get(paths.configuration, (context) => context.json(discovery, 200, headers(context.req.raw)));
     if (cors.enabled) {
         app.options(paths.configuration, (context) => cors.preflight(context.req.raw, { methods: ['GET'] }));
         app.options(paths.keys, (context) => cors.preflight(context.req.raw, { methods: ['GET'] }));
@@ -39,7 +48,7 @@ export function mountIssuer(app, input, cors, active, timeoutMs) {
         }
         try {
             const keys = await input.loadPublicKeys(operation.signal);
-            return context.json(issuerDiscovery.keySet(keys, [algorithm]), 200, headers(context.req.raw));
+            return context.json(keySet(keys, [algorithm]), 200, headers(context.req.raw));
         }
         catch (cause) {
             if (operation.signal.aborted || cause instanceof IssuerKeysUnavailableError) {
@@ -51,6 +60,9 @@ export function mountIssuer(app, input, cors, active, timeoutMs) {
             operation.settle();
         }
     });
+    if (tokenExchange !== undefined) {
+        mount(app, issuer, tokenExchange, cors, active, timeoutMs);
+    }
     const loadIssuerPublicKeys = input.loadIssuerPublicKeys;
     if (loadIssuerPublicKeys !== undefined) {
         const base = new URL(issuer).pathname.replace(/\/+$/, '');
@@ -59,7 +71,7 @@ export function mountIssuer(app, input, cors, active, timeoutMs) {
             app.options(`${base}/iss/:thumbprint/.well-known/jwks.json`, (context) => cors.preflight(context.req.raw, { methods: ['GET'] }));
         }
         app.get(`${base}/iss/:thumbprint/.well-known/openid-configuration`, async (context) => {
-            const hostedIssuer = issuerDiscovery.hosted(issuer, context.req.param('thumbprint'));
+            const hostedIssuer = hosted(issuer, context.req.param('thumbprint'));
             if (hostedIssuer === undefined)
                 return context.json({ error: 'Issuer not found.' }, 404, headers(context.req.raw));
             const operation = active.begin(timeoutMs, context.req.raw.signal);
@@ -70,7 +82,7 @@ export function mountIssuer(app, input, cors, active, timeoutMs) {
                 const keys = await hostedKeys(loadIssuerPublicKeys, hostedIssuer, operation.signal, algorithm);
                 if (keys.length === 0)
                     return context.json({ error: 'Issuer not found.' }, 404, headers(context.req.raw));
-                return context.json(issuerDiscovery.configuration(hostedIssuer, [algorithm]), 200, headers(context.req.raw));
+                return context.json(configuration(hostedIssuer, [algorithm]), 200, headers(context.req.raw));
             }
             catch (cause) {
                 if (operation.signal.aborted || cause instanceof IssuerKeysUnavailableError) {
@@ -83,7 +95,7 @@ export function mountIssuer(app, input, cors, active, timeoutMs) {
             }
         });
         app.get(`${base}/iss/:thumbprint/.well-known/jwks.json`, async (context) => {
-            const hostedIssuer = issuerDiscovery.hosted(issuer, context.req.param('thumbprint'));
+            const hostedIssuer = hosted(issuer, context.req.param('thumbprint'));
             if (hostedIssuer === undefined)
                 return context.json({ error: 'Issuer not found.' }, 404, headers(context.req.raw));
             const operation = active.begin(timeoutMs, context.req.raw.signal);
@@ -109,12 +121,12 @@ export function mountIssuer(app, input, cors, active, timeoutMs) {
     }
 }
 async function hostedKeys(load, issuer, signal, algorithm) {
-    return issuerDiscovery.keySet(await load(issuer, signal), [algorithm]).keys;
+    return keySet(await load(issuer, signal), [algorithm]).keys;
 }
 /** Admit static discovery configuration before Runtime Boot performs any durable work. */
 export function admitIssuer(input) {
     const signingAlgorithm = input.signingAlgorithm ?? 'ES256';
-    const issuer = issuerDiscovery.configuration(input.issuer, [signingAlgorithm]).issuer;
+    const issuer = configuration(input.issuer, [signingAlgorithm]).issuer;
     if (typeof input.loadPublicKeys !== 'function') {
         throw new TypeError('Issuer public-key loader is invalid.');
     }
@@ -135,4 +147,3 @@ export function admitIssuer(input) {
             }),
     });
 }
-//# sourceMappingURL=routes.js.map

package/dist/issuer/types.d.ts

@@ -1,4 +1,5 @@
-import type { IssuerId, JsonWebKey } from '@astrale-os/kernel-core/auth';
+import type { IssuerId } from '@astrale-os/kernel-core/auth/issuer';
+import type { JsonWebKey } from '@astrale-os/kernel-core/auth/jwk';
 /** Public issuer material; Server never receives private signing material. */
 export interface Issuer {
     readonly issuer: IssuerId;
@@ -8,4 +9,3 @@ export interface Issuer {
     /** Optional hosted-key discovery for issuers below `<issuer>/iss/:thumbprint`. */
     readonly loadIssuerPublicKeys?: (issuer: IssuerId, signal: AbortSignal) => Promise<readonly JsonWebKey[]>;
 }
-//# sourceMappingURL=types.d.ts.map

package/dist/issuer/types.js

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

package/dist/lifecycle/active.d.ts

@@ -37,4 +37,3 @@ export declare class ActiveOperations {
     private closeSockets;
 }
 export {};
-//# sourceMappingURL=active.d.ts.map

package/dist/lifecycle/active.js

@@ -197,4 +197,3 @@ async function settleCancellation(cancel, reason) {
 function abortReason(signal) {
     return signal.reason instanceof Error ? signal.reason.message : 'operation cancelled';
 }
-//# sourceMappingURL=active.js.map

package/dist/lifecycle/index.d.ts

@@ -1,2 +1 @@
 export { ActiveOperations, type ActiveOperation, type ActiveSocket } from './active.js';
-//# sourceMappingURL=index.d.ts.map

package/dist/lifecycle/index.js

@@ -1,2 +1 @@
 export { ActiveOperations } from './active.js';
-//# sourceMappingURL=index.js.map

package/dist/publication/delivery/handler.d.ts

@@ -0,0 +1,9 @@
+import type { ActiveOperations } from '../../lifecycle/index.js';
+import type { PreparedPublicationSnapshot } from '../snapshot.js';
+import type { Provider } from './types.js';
+export interface Limits {
+    readonly maximumDeliveryBytes: number;
+    readonly invocationTimeoutMs: number;
+}
+/** Serve one delivery request against the exact Publication snapshot that selected its URL. */
+export declare function handleDelivery(request: Request, snapshot: PreparedPublicationSnapshot, provider: Provider | undefined, active: ActiveOperations, limits: Limits, cors: Readonly<Record<string, string>>): Promise<Response>;

package/dist/{installation → publication/delivery}/handler.js

@@ -1,18 +1,20 @@
-import { codecs, installation } from '@astrale-os/kernel-protocol';
-import { InstallationUnavailableError } from '../errors/index.js';
-import { RequestBodyInvalidError, RequestBodyTooLargeError } from '../errors/index.js';
-import { readBoundedBody } from '../transport/index.js';
-/** Serve one installation request against the exact Publication snapshot that selected its URL. */
-export async function handleInstallation(request, snapshot, provider, active, limits, cors) {
+import * as codecs from '@astrale-os/kernel-protocol/codecs';
+import * as protocolPublication from '@astrale-os/kernel-protocol/publication';
+import { DeliveryUnavailableError } from '../../errors/index.js';
+import { RequestBodyInvalidError, RequestBodyTooLargeError } from '../../errors/index.js';
+import { readBoundedBody } from '../../transport/index.js';
+const delivery = protocolPublication.delivery;
+/** Serve one delivery request against the exact Publication snapshot that selected its URL. */
+export async function handleDelivery(request, snapshot, provider, active, limits, cors) {
     if (request.method !== 'POST') {
-        return response({ error: 'Installation requires POST.' }, 405, cors);
+        return response({ error: 'Delivery requires POST.' }, 405, cors);
     }
     if (provider === undefined) {
-        return response({ error: 'Installation is unavailable.' }, 503, cors);
+        return response({ error: 'Delivery is unavailable.' }, 503, cors);
     }
-    const advertised = snapshot.publication.installation;
+    const advertised = snapshot.publication.delivery;
     if (advertised === undefined) {
-        return response({ error: 'Installation is unavailable.' }, 404, cors);
+        return response({ error: 'Delivery is unavailable.' }, 404, cors);
     }
     const operation = active.begin(limits.invocationTimeoutMs, request.signal);
     if (operation === undefined)
@@ -24,21 +26,21 @@ export async function handleInstallation(request, snapshot, provider, active, li
             return response({ error: 'Bearer authentication is required.' }, 401, cors);
         }
         if (advertised.authentication.kind === 'public' && authorization !== null) {
-            return response({ error: 'This installation endpoint is public.' }, 400, cors);
+            return response({ error: 'This delivery endpoint is public.' }, 400, cors);
         }
         let body;
         try {
-            body = await readBoundedBody(request, limits.maximumInstallationBytes, operation.signal);
+            body = await readBoundedBody(request, limits.maximumDeliveryBytes, operation.signal);
         }
         catch (cause) {
             if (cause instanceof RequestBodyTooLargeError) {
-                return response({ error: 'Installation request is too large.' }, 413, cors);
+                return response({ error: 'Delivery request is too large.' }, 413, cors);
             }
             if (cause instanceof RequestBodyInvalidError) {
-                return response({ error: 'Installation request is invalid.' }, 400, cors);
+                return response({ error: 'Delivery request is invalid.' }, 400, cors);
             }
             if (operation.signal.aborted) {
-                return response({ error: 'Installation request was cancelled.' }, 503, cors);
+                return response({ error: 'Delivery request was cancelled.' }, 503, cors);
             }
             throw cause;
         }
@@ -48,17 +50,17 @@ export async function handleInstallation(request, snapshot, provider, active, li
         }
         catch (cause) {
             if (cause instanceof codecs.DecodeError) {
-                return response({ error: 'Installation request is invalid.' }, 400, cors);
+                return response({ error: 'Delivery request is invalid.' }, 400, cors);
             }
             throw cause;
         }
         let input;
         try {
-            input = installation.acceptRequest(decoded);
+            input = delivery.acceptRequest(decoded);
         }
         catch (cause) {
-            if (cause instanceof installation.Error && cause.code === 'INSTALLATION_REQUEST_INVALID') {
-                return response({ error: 'Installation request is invalid.' }, 400, cors);
+            if (cause instanceof delivery.Error && cause.code === 'DELIVERY_REQUEST_INVALID') {
+                return response({ error: 'Delivery request is invalid.' }, 400, cors);
             }
             throw cause;
         }
@@ -73,27 +75,27 @@ export async function handleInstallation(request, snapshot, provider, active, li
             });
         }
         catch (cause) {
-            if (cause instanceof InstallationUnavailableError) {
-                return response({ error: 'Installation provider is unavailable.' }, 503, cors);
+            if (cause instanceof DeliveryUnavailableError) {
+                return response({ error: 'Delivery provider is unavailable.' }, 503, cors);
             }
             throw cause;
         }
         let created;
         try {
-            created = installation.accept(candidate);
+            created = delivery.accept(candidate);
         }
         catch (cause) {
-            if (cause instanceof installation.Error) {
-                return response({ error: 'Installation provider returned an invalid response.' }, 500, cors);
+            if (cause instanceof delivery.Error) {
+                return response({ error: 'Delivery provider returned an invalid response.' }, 500, cors);
             }
             throw cause;
         }
         if (created.publication.etag !== snapshot.publication.etag) {
-            return response({ error: 'Installation provider returned a different Publication.' }, 500, cors);
+            return response({ error: 'Delivery provider returned a different Publication.' }, 500, cors);
         }
         const encoded = codecs.json.encode(created);
-        if (encodedSize(encoded) > limits.maximumInstallationBytes) {
-            return response({ error: 'Installation response exceeds its serving limit.' }, 500, cors);
+        if (encodedSize(encoded) > limits.maximumDeliveryBytes) {
+            return response({ error: 'Delivery response exceeds its serving limit.' }, 500, cors);
         }
         return new Response(encodedBody(encoded), {
             headers: { ...cors, 'content-type': 'application/json' },
@@ -123,4 +125,3 @@ function encodedSize(input) {
 function toBody(input) {
     return input.buffer.slice(input.byteOffset, input.byteOffset + input.byteLength);
 }
-//# sourceMappingURL=handler.js.map

package/dist/publication/delivery/index.d.ts

@@ -0,0 +1,2 @@
+export { handleDelivery, type Limits } from './handler.js';
+export type { Context, Provider } from './types.js';

package/dist/publication/delivery/index.js

@@ -0,0 +1 @@
+export { handleDelivery } from './handler.js';

package/dist/publication/delivery/types.d.ts

@@ -0,0 +1,11 @@
+import type * as publication from '@astrale-os/kernel-protocol/publication';
+export interface Context {
+    /** Omitted for a public endpoint; otherwise the exact admitted retrieval credential. */
+    readonly token?: publication.delivery.Token;
+    readonly signal: AbortSignal;
+}
+/** Provider-owned retrieval, construction, and attestation signing. */
+export interface Provider {
+    /** Throw DeliveryUnavailableError only for an expected dependency outage. */
+    create(request: publication.delivery.Request, context: Context): Promise<publication.delivery.Delivery>;
+}

package/dist/publication/delivery/types.js

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

package/dist/publication/index.d.ts

@@ -1,3 +1,3 @@
 export { preparePublicationSnapshot, readPreparedPublicationSnapshot, type PreparedPublicationSnapshot, } from './snapshot.js';
 export type { PublicationSnapshot, PublicationSnapshotInput, PublicationSource } from './types.js';
-//# sourceMappingURL=index.d.ts.map
+export * as delivery from './delivery/index.js';

package/dist/publication/index.js

@@ -1,2 +1,2 @@
 export { preparePublicationSnapshot, readPreparedPublicationSnapshot, } from './snapshot.js';
-//# sourceMappingURL=index.js.map
+export * as delivery from './delivery/index.js';

package/dist/publication/snapshot.d.ts

@@ -1,14 +1,16 @@
-import { publication, routes } from '@astrale-os/kernel-protocol';
+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 { PublicationSnapshot, PublicationSnapshotInput } from './types.js';
 export interface PreparedPublicationSnapshot {
     readonly snapshot: PublicationSnapshot;
     readonly publication: publication.Publication;
     readonly publicationBytes: Uint8Array;
     readonly bundle: Uint8Array;
-    readonly routes: readonly routes.CompiledRoute[];
+    readonly table: routes.Table;
+    readonly domain: Domain;
 }
 /** Admit and detach one revision-coherent serving snapshot before publication. */
 export declare function preparePublicationSnapshot(input: PublicationSnapshotInput): PublicationSnapshot;
 /** Internal proof that a PublicationSource returned a Server-prepared snapshot without cloning it. */
 export declare function readPreparedPublicationSnapshot(input: unknown): PreparedPublicationSnapshot | undefined;
-//# sourceMappingURL=snapshot.d.ts.map

package/dist/publication/snapshot.js

@@ -1,22 +1,30 @@
-import { publication, routes } from '@astrale-os/kernel-protocol';
+import { verifyBundleBytes } from '@astrale-os/kernel-protocol/publication/bundle-evidence';
+import { accept as acceptPublication, encode as encodePublication, } from '@astrale-os/kernel-protocol/publication/publication';
+import { admitTable } from './table.js';
 const snapshots = new WeakMap();
 /** Admit and detach one revision-coherent serving snapshot before publication. */
 export function preparePublicationSnapshot(input) {
     if (input === null || typeof input !== 'object' || !(input.bundle instanceof Uint8Array)) {
         throw new TypeError('Publication snapshot input is invalid.');
     }
-    const admittedPublication = publication.accept(input.publication);
+    const admittedPublication = acceptPublication(input.publication);
     const bundleBytes = new Uint8Array(input.bundle);
-    const artifact = publication.decodeBundle(admittedPublication, bundleBytes);
-    const compiledRoutes = routes.compile(admittedPublication, artifact);
-    const publicationBytes = publication.encode(admittedPublication);
+    verifyBundleBytes(admittedPublication, bundleBytes);
+    const domain = input.domain;
+    if (domain.origin !== admittedPublication.origin ||
+        domain.revision !== admittedPublication.schema.revision) {
+        throw new TypeError('Publication snapshot Domain identity differs from its Publication.');
+    }
+    const table = admitTable(admittedPublication, input.table, domain);
+    const publicationBytes = encodePublication(admittedPublication);
     const snapshot = Object.freeze({ publication: admittedPublication });
     const prepared = Object.freeze({
         snapshot,
         publication: admittedPublication,
         publicationBytes,
         bundle: bundleBytes,
-        routes: compiledRoutes,
+        table,
+        domain,
     });
     snapshots.set(snapshot, prepared);
     return snapshot;
@@ -27,4 +35,3 @@ export function readPreparedPublicationSnapshot(input) {
         return undefined;
     return snapshots.get(input);
 }
-//# sourceMappingURL=snapshot.js.map

package/dist/publication/table.d.ts

@@ -0,0 +1,4 @@
+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';
+export declare function admitTable(deployed: publication.Publication, input: routes.Table | undefined, domain: Domain): routes.Table;

package/dist/publication/table.js

@@ -0,0 +1,16 @@
+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';
+export function admitTable(deployed, input, domain) {
+    if (input === undefined) {
+        if (deployed.routes.length !== 0) {
+            throw new TypeError('A Publication with native routes requires a Route Table.');
+        }
+        return verifyTable(Object.freeze({
+            publication: reference(deployed),
+            entries: Object.freeze([]),
+        }), deployed, domain);
+    }
+    const table = acceptTable(input);
+    return verifyTable(table, deployed, domain);
+}

package/dist/publication/types.d.ts

@@ -1,9 +1,13 @@
-import type { publication } from '@astrale-os/kernel-protocol';
+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';
 declare const PUBLICATION_SNAPSHOT: unique symbol;
 export interface PublicationSnapshotInput {
     readonly publication: publication.Publication;
     /** Exact artifact served at Publication.schema.bundle.href. */
     readonly bundle: Uint8Array;
+    readonly table?: routes.Table;
+    readonly domain: Domain;
 }
 /** Immutable admitted serving identity; bundle and compiled routes remain Server-private. */
 export interface PublicationSnapshot {
@@ -16,4 +20,3 @@ export interface PublicationSource {
     current(): PublicationSnapshot | undefined;
 }
 export {};
-//# sourceMappingURL=types.d.ts.map

package/dist/publication/types.js

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

package/dist/routes/index.d.ts

@@ -1,2 +1 @@
 export { currentPublicationSnapshot, mountRoutes, type RouteLimits, type RouteReservation, } from './routes.js';
-//# sourceMappingURL=index.d.ts.map

package/dist/routes/index.js

@@ -1,2 +1 @@
 export { currentPublicationSnapshot, mountRoutes, } from './routes.js';
-//# sourceMappingURL=index.js.map

package/dist/routes/routes.d.ts

@@ -1,24 +1,25 @@
 import type { CorsPolicy } from '../cors/index.js';
-import type { InstallationProvider } from '../installation/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 ApplicationHost, type Handler } from '../invocation/index.js';
 import { type PreparedPublicationSnapshot } from '../publication/index.js';
-import { type ServerRouter } from '../transport/index.js';
+import { type ServerRouter } from '../transport/router.js';
 export interface RouteLimits {
     readonly maximumRequestBytes: number;
     readonly maximumPublicationBytes: number;
     readonly maximumBundleBytes: number;
-    readonly maximumInstallationBytes: number;
+    readonly maximumDeliveryBytes: number;
     readonly invocationTimeoutMs: number;
 }
 export interface RouteReservation {
     readonly path: string;
     readonly methods: readonly string[];
 }
-export declare function mountRoutes(app: ServerRouter, source: PublicationSource, installationProvider: InstallationProvider | undefined, handler: Handler, active: ActiveOperations, limits: RouteLimits, cors: CorsPolicy, hostFor: (request: Request) => ApplicationHost | undefined, reservations: readonly RouteReservation[], externalOrigin?: string): void;
+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): void;
 export declare function currentPublicationSnapshot(source: PublicationSource, limits: Pick<RouteLimits, 'maximumPublicationBytes' | 'maximumBundleBytes'>, serving?: {
     readonly origin: string;
+    readonly issuer?: string;
     readonly reservations: readonly RouteReservation[];
 }): PreparedPublicationSnapshot | undefined;
-//# sourceMappingURL=routes.d.ts.map