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

package/dist/routes/routes.js

@@ -1,28 +1,43 @@
-import { codecs, errors, invocation as protocol, publication, routes, } from '@astrale-os/kernel-protocol';
+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 { 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 * as routes from '@astrale-os/kernel-protocol/routes';
 import { classifyError, RequestBodyInvalidError, RequestBodyTooLargeError, } from '../errors/index.js';
-import { handleInstallation } from '../installation/index.js';
 import { invocationContext } from '../invocation/index.js';
+import { handleDelivery } from '../publication/delivery/index.js';
 import { readPreparedPublicationSnapshot, } from '../publication/index.js';
-import { interruptedStreamError, readBoundedBody } from '../transport/index.js';
-export function mountRoutes(app, source, installationProvider, handler, active, limits, cors, hostFor, reservations, externalOrigin) {
+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) {
+    const publicationPath = externalIssuer === undefined
+        ? PUBLICATION_PATH
+        : new URL(publicationUrl(externalIssuer)).pathname;
+    const externalOrigin = externalIssuer === undefined ? undefined : new URL(externalIssuer).origin;
     if (cors.enabled) {
-        app.options(publication.PATH, (context) => cors.preflight(context.req.raw, {
+        app.options(publicationPath, (context) => cors.preflight(context.req.raw, {
             methods: ['GET'],
             headers: ['if-none-match'],
         }));
     }
-    app.get(publication.PATH, (context) => {
+    app.get(publicationPath, (context) => {
         const responseCors = cors.response(context.req.raw, ['etag']);
         if (!active.isAccepting)
             return response({ error: 'Publication is unavailable while draining.' }, 503, responseCors);
-        const snapshot = servingSnapshot(source, limits, context.req.raw, reservations, externalOrigin);
+        const snapshot = servingSnapshot(source, limits, context.req.raw, reservations, externalIssuer);
         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) },
+                headers: {
+                    ...responseCors,
+                    etag: quoteEtag(snapshot.publication.etag),
+                    'cache-control': 'public, max-age=0, must-revalidate, no-transform',
+                },
             });
         }
         return new Response(toBody(body), {
@@ -31,12 +46,12 @@ export function mountRoutes(app, source, installationProvider, handler, active,
                 ...responseCors,
                 'content-type': 'application/json',
                 etag: quoteEtag(snapshot.publication.etag),
-                'cache-control': 'public, max-age=0, must-revalidate',
+                'cache-control': 'public, max-age=0, must-revalidate, no-transform',
             },
         });
     });
     app.all('*', async (context) => {
-        const snapshot = servingSnapshot(source, limits, context.req.raw, reservations, externalOrigin);
+        const snapshot = servingSnapshot(source, limits, context.req.raw, reservations, externalIssuer);
         if (snapshot === undefined)
             return context.notFound();
         const request = context.req.raw;
@@ -50,22 +65,22 @@ export function mountRoutes(app, source, installationProvider, handler, active,
             if (request.method !== 'GET')
                 return response({ error: 'Bundle retrieval requires GET.' }, 405, responseCors);
             const body = snapshot.bundle;
-            if (body.byteLength !== snapshot.publication.schema.bundle.size) {
+            if (body.byteLength !== snapshot.publication.schema.bundle.ref.size) {
                 return response({ error: 'Bundle differs from its Publication.' }, 500, responseCors);
             }
             return new Response(toBody(body), {
                 status: 200,
                 headers: {
                     ...responseCors,
-                    'content-type': snapshot.publication.schema.bundle.mediaType,
-                    etag: quoteEtag(snapshot.publication.schema.bundle.digest),
-                    'cache-control': 'public, max-age=31536000, immutable',
+                    'content-type': snapshot.publication.schema.bundle.ref.mediaType,
+                    etag: quoteEtag(snapshot.publication.schema.bundle.ref.digest),
+                    'cache-control': 'public, max-age=31536000, immutable, no-transform',
                 },
             });
         }
-        const installationUrl = snapshot.publication.installation?.href;
-        if (installationUrl !== undefined && sameRoute(request.url, installationUrl, externalOrigin)) {
-            return handleInstallation(request, snapshot, installationProvider, active, limits, cors.response(request));
+        const deliveryUrl = snapshot.publication.delivery?.href;
+        if (deliveryUrl !== undefined && sameRoute(request.url, deliveryUrl, externalOrigin)) {
+            return handleDelivery(request, snapshot, deliveryProvider, active, limits, cors.response(request));
         }
         let routing;
         try {
@@ -81,7 +96,7 @@ export function mountRoutes(app, source, installationProvider, handler, active,
                     },
                 });
             }
-            routing = routes.decodeRouting(request, publication.reference(snapshot.publication));
+            routing = routes.decodeRouting(request, publicationReference(snapshot.publication));
         }
         catch (cause) {
             if (cause instanceof routes.RouteError) {
@@ -89,9 +104,10 @@ export function mountRoutes(app, source, installationProvider, handler, active,
             }
             throw cause;
         }
-        const route = routes.match(snapshot.routes, request);
+        const route = routes.match(snapshot.table, request);
         if (route === undefined)
             return context.notFound();
+        const assigned = nextInvocation();
         const operation = active.begin(limits.invocationTimeoutMs, request.signal);
         if (operation === undefined)
             return nativeError({
@@ -101,12 +117,7 @@ export function mountRoutes(app, source, installationProvider, handler, active,
         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,
-            });
+            const invocation = routes.decode(route, { url: request.url, method: request.method, headers: request.headers, body }, snapshot.domain, snapshot.table.publication);
             const idempotencyHeader = request.headers.get(protocol.HTTP_IDEMPOTENCY_KEY);
             const idempotencyKey = idempotencyHeader === null
                 ? undefined
@@ -116,7 +127,7 @@ export function mountRoutes(app, source, installationProvider, handler, active,
                 ...(invocation.credential === undefined ? {} : { credential: invocation.credential }),
                 ...(routing === undefined ? {} : { via: routing }),
                 publication: snapshot.snapshot,
-                context: invocationContext(operation, active, hostFor(request), body, idempotencyKey),
+                context: invocationContext(assigned, operation, active, hostFor(request), body, idempotencyKey),
             }));
             if (result.kind === 'value') {
                 return new Response(encodedBody(codecs.json.encode(result.value)), {
@@ -190,8 +201,8 @@ function publicationPreflight(cors, request, snapshot, externalOrigin) {
     if (sameRoute(request.url, snapshot.publication.schema.bundle.href, externalOrigin)) {
         return cors.preflight(request, { methods: ['GET'], headers: ['if-none-match'] });
     }
-    const installationUrl = snapshot.publication.installation?.href;
-    if (installationUrl !== undefined && sameRoute(request.url, installationUrl, externalOrigin)) {
+    const deliveryUrl = snapshot.publication.delivery?.href;
+    if (deliveryUrl !== undefined && sameRoute(request.url, deliveryUrl, externalOrigin)) {
         return cors.preflight(request, {
             methods: ['POST'],
             headers: ['authorization', 'content-type'],
@@ -200,7 +211,7 @@ function publicationPreflight(cors, request, snapshot, externalOrigin) {
     const requestedMethod = request.headers.get('access-control-request-method');
     const route = requestedMethod === null
         ? undefined
-        : routes.match(snapshot.routes, { url: request.url, method: requestedMethod });
+        : routes.match(snapshot.table, { url: request.url, method: requestedMethod });
     return cors.preflight(request, route === undefined ? undefined : nativeCorsRoute(route, requestedMethod));
 }
 function nativeCorsRoute(entry, requestedMethod) {
@@ -210,16 +221,16 @@ function nativeCorsRoute(entry, requestedMethod) {
         routes.HTTP_ROUTE_ISSUER,
         protocol.HTTP_IDEMPOTENCY_KEY,
     ]);
-    if (entry.route.body !== undefined)
+    if (entry.body !== undefined)
         headers.add('content-type');
     let allowAnyHeaders = false;
-    for (const pick of Object.values(entry.route.headers ?? {})) {
+    for (const pick of Object.values(entry.headers ?? {})) {
         if (pick === '*')
             allowAnyHeaders = true;
         else
             headers.add(pick.toLowerCase());
     }
-    const credential = entry.route.credential;
+    const credential = entry.credential;
     const sources = credential === undefined
         ? [{ in: 'header' }]
         : Array.isArray(credential)
@@ -230,9 +241,7 @@ function nativeCorsRoute(entry, requestedMethod) {
             headers.add((source.name ?? 'authorization').toLowerCase());
     }
     return Object.freeze({
-        methods: Object.freeze([
-            entry.route.method === '*' ? requestedMethod.toUpperCase() : entry.route.method,
-        ]),
+        methods: Object.freeze([entry.method === '*' ? requestedMethod.toUpperCase() : entry.method]),
         headers: Object.freeze([...headers]),
         ...(allowAnyHeaders ? { allowAnyHeaders: true } : {}),
     });
@@ -245,23 +254,25 @@ export function currentPublicationSnapshot(source, limits, serving) {
     if (prepared === undefined ||
         prepared.publicationBytes.byteLength > limits.maximumPublicationBytes ||
         prepared.bundle.byteLength > limits.maximumBundleBytes ||
+        (serving?.issuer !== undefined && prepared.publication.identity.issuer !== serving.issuer) ||
         (serving !== undefined && conflictsWithServingRoutes(prepared, serving))) {
         return undefined;
     }
     return prepared;
 }
-function servingSnapshot(source, limits, request, reservations, externalOrigin) {
+function servingSnapshot(source, limits, request, reservations, externalIssuer) {
     return currentPublicationSnapshot(source, limits, {
-        origin: externalOrigin ?? new URL(request.url).origin,
+        origin: externalIssuer === undefined ? new URL(request.url).origin : new URL(externalIssuer).origin,
+        ...(externalIssuer === undefined ? {} : { issuer: externalIssuer }),
         reservations,
     });
 }
 function conflictsWithServingRoutes(snapshot, serving) {
     for (const reservation of serving.reservations) {
         const href = `${serving.origin}${reservation.path}`;
-        for (const entry of snapshot.routes) {
-            if (reservation.methods.some((method) => entry.route.method === '*' || entry.route.method === method) &&
-                routes.templatesOverlap(entry.route.href, href)) {
+        for (const entry of snapshot.table.entries) {
+            if (reservation.methods.some((method) => entry.method === '*' || entry.method === method) &&
+                routes.templatesOverlap(entry.href, href)) {
                 return true;
             }
         }
@@ -435,4 +446,3 @@ function encodedBody(input) {
 function toBody(input) {
     return input.buffer.slice(input.byteOffset, input.byteOffset + input.byteLength);
 }
-//# sourceMappingURL=routes.js.map

package/dist/server.d.ts

@@ -2,4 +2,3 @@ import type { Server, ServerConfig, ServerOptions, PreparedServer } from './type
 export declare function createServer(config: ServerConfig): Server;
 /** Validate all static transport configuration before a Host starts Runtime recovery/bootstrap. */
 export declare function prepareServer(options: ServerOptions): PreparedServer;
-//# sourceMappingURL=server.d.ts.map

package/dist/server.js

@@ -1,9 +1,14 @@
+import { PATH as PUBLICATION_PATH, url as publicationUrl, } from '@astrale-os/kernel-protocol/publication/publication';
 import { captureMethod } from './capture.js';
 import { prepareCors } from './cors/index.js';
+import { captureInvocationSource } from './invocation/index.js';
+import { capture as captureExchangeProvider } from './issuer/exchange.js';
 import { admitIssuer, issuerRouteReservations, mountIssuer } from './issuer/index.js';
 import { ActiveOperations } from './lifecycle/index.js';
 import { currentPublicationSnapshot, mountRoutes } from './routes/index.js';
-import { createHttpHandler, createServerRouter, handleWebSocketUpgrade } from './transport/index.js';
+import { createHttpHandler } from './transport/http/handler.js';
+import { createServerRouter } from './transport/router.js';
+import { handleWebSocketUpgrade } from './transport/websocket/upgrade.js';
 export function createServer(config) {
     const { handler, ...options } = config;
     return prepareServer(options).create(handler);
@@ -20,10 +25,12 @@ function createPreparedServer(input, config) {
     const active = new ActiveOperations(config.limits.maximumConcurrentOperations);
     const app = createServerRouter();
     const hosts = new WeakMap();
-    const externalOrigin = config.issuer === undefined ? undefined : new URL(config.issuer.issuer).origin;
+    const externalIssuer = config.issuer?.issuer;
+    const externalOrigin = externalIssuer === undefined ? undefined : new URL(externalIssuer).origin;
     const handleHttp = createHttpHandler({
         handler,
         active,
+        invocation: config.invocation,
         ...config.limits,
         cors: config.cors,
         websocket: config.websocket !== undefined,
@@ -32,6 +39,7 @@ function createPreparedServer(input, config) {
             : {
                 currentPublication: (request) => currentPublicationSnapshot(config.publication, config.limits, {
                     origin: externalOrigin ?? new URL(request.url).origin,
+                    ...(externalIssuer === undefined ? {} : { issuer: externalIssuer }),
                     reservations: config.routeReservations,
                 })?.snapshot,
             }),
@@ -42,6 +50,7 @@ function createPreparedServer(input, config) {
             adapter: config.websocket,
             handler,
             active,
+            invocation: config.invocation,
             ...config.limits,
             cors: config.cors,
             ...(config.publication === undefined
@@ -49,6 +58,7 @@ function createPreparedServer(input, config) {
                 : {
                     currentPublication: () => currentPublicationSnapshot(config.publication, config.limits, {
                         origin: externalOrigin ?? new URL(context.req.raw.url).origin,
+                        ...(externalIssuer === undefined ? {} : { issuer: externalIssuer }),
                         reservations: config.routeReservations,
                     })?.snapshot,
                 }),
@@ -69,10 +79,10 @@ function createPreparedServer(input, config) {
         }
     }
     if (config.issuer !== undefined) {
-        mountIssuer(app, config.issuer, config.cors, active, config.limits.invocationTimeoutMs);
+        mountIssuer(app, config.issuer, config.cors, active, config.limits.invocationTimeoutMs, config.tokenExchange);
     }
     if (config.publication !== undefined) {
-        mountRoutes(app, config.publication, config.installation, handler, active, config.limits, config.cors, (request) => hosts.get(request), config.routeReservations, externalOrigin);
+        mountRoutes(app, config.publication, config.delivery, handler, active, config.invocation, config.limits, config.cors, (request) => hosts.get(request), config.routeReservations, externalIssuer);
     }
     app.onError((_error, context) => new Response('{"error":"Internal server error."}', {
         status: 500,
@@ -121,9 +131,14 @@ function captureHandler(input) {
     return Object.freeze({ dispatch });
 }
 function admitOptions(config) {
+    const invocation = captureInvocationSource(config.invocation);
     const limits = admitLimits(config.limits);
     const path = admitRoute(config.path ?? '/', 'invocation path');
     const issuer = config.issuer === undefined ? undefined : admitIssuer(config.issuer);
+    const tokenExchange = config.tokenExchange === undefined ? undefined : captureExchangeProvider(config.tokenExchange);
+    if (tokenExchange !== undefined && issuer === undefined) {
+        throw new TypeError('Token exchange requires issuer configuration.');
+    }
     const health = config.health === undefined || config.health === false
         ? undefined
         : Object.freeze({
@@ -132,34 +147,52 @@ function admitOptions(config) {
         });
     const websocket = config.websocket === undefined ? undefined : captureWebSocket(config.websocket);
     const publication = config.publication === undefined ? undefined : capturePublicationSource(config.publication);
-    const installation = config.installation === undefined ? undefined : captureInstallationProvider(config.installation);
-    if (installation !== undefined && publication === undefined) {
-        throw new TypeError('Installation requires a Publication source.');
+    const delivery = config.delivery === undefined ? undefined : captureDeliveryProvider(config.delivery);
+    if (delivery !== undefined && publication === undefined) {
+        throw new TypeError('Publication Delivery requires a Publication source.');
     }
+    const publicationPath = publication === undefined
+        ? undefined
+        : issuer === undefined
+            ? protocolPublicationPath()
+            : protocolPublicationPath(issuer.issuer);
     if (health?.path === path)
         throw new TypeError('Health and invocation paths must be distinct.');
+    if (publicationPath === path) {
+        throw new TypeError('Publication and invocation paths must be distinct.');
+    }
+    if (health !== undefined && publicationPath === health.path) {
+        throw new TypeError('Health and Publication paths must be distinct.');
+    }
     if (issuer !== undefined) {
-        const issuerPaths = issuerRouteReservations(issuer).map(({ path }) => path);
+        const issuerReservations = issuerRouteReservations(issuer, tokenExchange !== undefined);
+        const issuerPaths = issuerReservations.map(({ path }) => path);
         if (health !== undefined && issuerPaths.includes(health.path)) {
             throw new TypeError('Health and issuer paths must be distinct.');
         }
         if (websocket !== undefined && issuerPaths.includes(path)) {
             throw new TypeError('WebSocket invocation and issuer paths must be distinct.');
         }
+        if (websocket === undefined &&
+            issuerReservations.some((reservation) => reservation.path === path && reservation.methods.includes('POST'))) {
+            throw new TypeError('Invocation and token-exchange paths must be distinct.');
+        }
     }
     return Object.freeze({
+        invocation,
         limits,
         path,
         cors: prepareCors(config.cors),
         ...(health === undefined ? {} : { health }),
         ...(issuer === undefined ? {} : { issuer }),
+        ...(tokenExchange === undefined ? {} : { tokenExchange }),
         ...(publication === undefined ? {} : { publication }),
-        ...(installation === undefined ? {} : { installation }),
-        routeReservations: routeReservations(path, health?.path, issuer, websocket !== undefined),
+        ...(delivery === undefined ? {} : { delivery }),
+        routeReservations: routeReservations(path, health?.path, issuer, websocket !== undefined, tokenExchange !== undefined, publicationPath),
         ...(websocket === undefined ? {} : { websocket }),
     });
 }
-function routeReservations(invocationPath, healthPath, issuer, websocket) {
+function routeReservations(invocationPath, healthPath, issuer, websocket, tokenExchange, publicationPath) {
     const reservations = [
         Object.freeze({
             path: invocationPath,
@@ -170,10 +203,18 @@ function routeReservations(invocationPath, healthPath, issuer, websocket) {
         reservations.push(Object.freeze({ path: healthPath, methods: Object.freeze(['GET']) }));
     }
     if (issuer !== undefined) {
-        reservations.push(...issuerRouteReservations(issuer));
+        reservations.push(...issuerRouteReservations(issuer, tokenExchange));
+    }
+    if (publicationPath !== undefined) {
+        reservations.push(Object.freeze({ path: publicationPath, methods: Object.freeze(['GET']) }));
     }
     return Object.freeze(reservations);
 }
+function protocolPublicationPath(issuer) {
+    if (issuer === undefined)
+        return PUBLICATION_PATH;
+    return new URL(publicationUrl(issuer)).pathname;
+}
 function captureHealthProbe(probe) {
     const check = captureMethod(probe, 'check', 'Health probe is invalid.');
     return Object.freeze({ check });
@@ -186,8 +227,8 @@ function capturePublicationSource(input) {
     const current = captureMethod(input, 'current', 'Publication source is invalid.');
     return Object.freeze({ current });
 }
-function captureInstallationProvider(input) {
-    const create = captureMethod(input, 'create', 'Installation provider is invalid.');
+function captureDeliveryProvider(input) {
+    const create = captureMethod(input, 'create', 'Publication Delivery provider is invalid.');
     return Object.freeze({ create });
 }
 function admitLimits(limits) {
@@ -206,7 +247,7 @@ function admitLimits(limits) {
         maximumConcurrentOperations: admitOptionalLimit(limits.maximumConcurrentOperations, 1_024, 'maximumConcurrentOperations'),
         maximumPublicationBytes: admitOptionalLimit(limits.maximumPublicationBytes, limits.maximumRequestBytes, 'maximumPublicationBytes'),
         maximumBundleBytes: admitOptionalLimit(limits.maximumBundleBytes, 16 * 1024 * 1024, 'maximumBundleBytes'),
-        maximumInstallationBytes: admitOptionalLimit(limits.maximumInstallationBytes, limits.maximumRequestBytes, 'maximumInstallationBytes'),
+        maximumDeliveryBytes: admitOptionalLimit(limits.maximumDeliveryBytes, limits.maximumRequestBytes, 'maximumDeliveryBytes'),
         invocationTimeoutMs: limits.invocationTimeoutMs,
     });
 }
@@ -223,4 +264,3 @@ function admitRoute(path, label) {
     }
     return path;
 }
-//# sourceMappingURL=server.js.map

package/dist/transport/body.d.ts

@@ -2,4 +2,3 @@ export { RequestBodyInvalidError, RequestBodyTooLargeError } from '../errors/ind
 /** Read a request body while enforcing the limit before retaining excess bytes. */
 export declare function readBoundedBody(request: Request, maximumBytes: number, signal: AbortSignal): Promise<Uint8Array>;
 export declare function byteLength(input: string | Uint8Array): number;
-//# sourceMappingURL=body.d.ts.map

package/dist/transport/body.js

@@ -48,4 +48,3 @@ export async function readBoundedBody(request, maximumBytes, signal) {
 export function byteLength(input) {
     return typeof input === 'string' ? new TextEncoder().encode(input).byteLength : input.byteLength;
 }
-//# sourceMappingURL=body.js.map

package/dist/transport/codecs.d.ts

@@ -1,5 +1,4 @@
-import { codecs } from '@astrale-os/kernel-protocol';
+import * as codecs from '@astrale-os/kernel-protocol/codecs';
 export type LoadedCodec = codecs.Codec;
 /** Load the built-in Server representation set before pure Protocol binding selection. */
 export declare function loadCodecs(): Promise<readonly [codecs.Codec, codecs.Codec]>;
-//# sourceMappingURL=codecs.d.ts.map

package/dist/transport/codecs.js

@@ -1,6 +1,5 @@
-import { codecs } from '@astrale-os/kernel-protocol';
+import * as codecs from '@astrale-os/kernel-protocol/codecs';
 /** Load the built-in Server representation set before pure Protocol binding selection. */
 export async function loadCodecs() {
     return Object.freeze([codecs.json, await codecs.loadMsgpack()]);
 }
-//# sourceMappingURL=codecs.js.map

package/dist/transport/credential.d.ts

@@ -1,4 +1,4 @@
-import { errors } from '@astrale-os/kernel-protocol';
+import * as errors from '@astrale-os/kernel-protocol/errors';
 export type CredentialResult = {
     readonly ok: true;
     readonly credential: string | undefined;
@@ -8,4 +8,3 @@ export type CredentialResult = {
 };
 /** Resolve exactly zero or one untrusted credential channel without authenticating it. */
 export declare function resolveCredential(envelope: string | undefined, authorization: string | null): CredentialResult;
-//# sourceMappingURL=credential.d.ts.map

package/dist/transport/credential.js

@@ -1,4 +1,4 @@
-import { errors } from '@astrale-os/kernel-protocol';
+import * as errors from '@astrale-os/kernel-protocol/errors';
 /** Resolve exactly zero or one untrusted credential channel without authenticating it. */
 export function resolveCredential(envelope, authorization) {
     if (envelope !== undefined && authorization !== null) {
@@ -26,4 +26,3 @@ function failure(message) {
         error: { code: errors.CODES.INVALID_REQUEST, message },
     };
 }
-//# sourceMappingURL=credential.js.map

package/dist/transport/http/handler.d.ts

@@ -1,10 +1,12 @@
 import type { CorsPolicy } from '../../cors/index.js';
+import type { NextInvocationId } from '../../invocation/index.js';
 import type { ActiveOperations } from '../../lifecycle/index.js';
 import type { PublicationSnapshot } from '../../publication/index.js';
 import { type ApplicationHost, type Handler } from '../../invocation/index.js';
 export interface HttpHandlerConfig {
     readonly handler: Handler;
     readonly active: ActiveOperations;
+    readonly invocation: NextInvocationId;
     readonly maximumRequestBytes: number;
     readonly maximumResponseBytes: number;
     readonly invocationTimeoutMs: number;
@@ -13,4 +15,3 @@ export interface HttpHandlerConfig {
     readonly currentPublication?: (request: Request) => PublicationSnapshot | undefined;
 }
 export declare function createHttpHandler(config: HttpHandlerConfig): (request: Request, host?: ApplicationHost) => Promise<Response>;
-//# sourceMappingURL=handler.d.ts.map