@astrale-os/kernel-server 0.5.0-beta.73 → 0.5.0-beta.75

package/dist/routes/routes.js

@@ -1,640 +1,34 @@
-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, 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 '../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';
+import { handleDelivery } from '../release/delivery/handler.js';
+import { servedDocument } from '../release/served.js';
+import { sameRoute } from './address.js';
+import { bundleResponse } from './bundle.js';
+import { mountDocuments } from './document.js';
+import { nativeResponse } from './native.js';
+import { releasePreflight } from './preflight.js';
+import { servingSnapshot } from './snapshot.js';
+/** Mount the advertised HTTP resources and native routes from one pinned serving snapshot. */
 export function mountRoutes(app, source, deliveryProvider, handler, active, nextInvocation, limits, cors, hostFor, reservations, externalIssuer, publicOrigin) {
     const externalOrigin = publicOrigin ?? (externalIssuer === undefined ? undefined : new URL(externalIssuer).origin);
     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,
-        }),
-    });
+    mountDocuments(app, cors, active, served, externalIssuer);
+    const native = { handler, active, nextInvocation, limits, cors, hostFor, externalOrigin };
     app.all('*', async (context) => {
-        const snapshot = served(context.req.raw);
+        const request = context.req.raw;
+        const snapshot = served(request);
         if (snapshot === undefined)
             return context.notFound();
-        const request = context.req.raw;
         if (request.method === 'OPTIONS' && cors.enabled) {
-            return publicationPreflight(cors, request, snapshot, externalOrigin);
+            return releasePreflight(cors, request, snapshot, externalOrigin);
         }
         const responseCors = cors.response(request);
         const corsFor = (exposed) => cors.response(request, exposed);
-        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, 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 !== 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;
-            return new Response(unchanged ? null : toBody(body), {
-                status: unchanged ? 304 : 200,
-                headers: {
-                    ...responseCors,
-                    'content-type': descriptor.ref.mediaType,
-                    etag,
-                    'cache-control': immutable
-                        ? 'public, max-age=31536000, immutable, no-transform'
-                        : 'public, max-age=0, must-revalidate, no-transform',
-                },
-            });
-        }
-        if (request.method === 'GET' && immutable) {
-            const pathname = new URL(addressed).pathname;
-            const directory = pathname.slice(0, pathname.lastIndexOf('/') + 1);
-            const requested = new URL(request.url);
-            if (requested.pathname.startsWith(directory) &&
-                /^[0-9a-f]{64}\.json$/u.test(requested.pathname.slice(directory.length))) {
-                return new Response(null, {
-                    status: 404,
-                    headers: { ...responseCors, 'cache-control': 'no-store' },
-                });
-            }
-        }
-        const deliveryUrl = document.delivery?.href;
+        const bundle = bundleResponse(request, snapshot, active, responseCors, corsFor, externalOrigin);
+        if (bundle !== undefined)
+            return bundle;
+        const deliveryUrl = servedDocument(snapshot).delivery?.href;
         if (deliveryUrl !== undefined && sameRoute(request.url, deliveryUrl, externalOrigin)) {
             return handleDelivery(request, snapshot, deliveryProvider, active, limits, corsFor);
         }
-        let routing;
-        try {
-            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));
-            }
-        }
-        catch (cause) {
-            if (cause instanceof routes.RouteError) {
-                return nativeError({ code: errors.CODES.INVALID_REQUEST, message: 'Native route routing is invalid.' }, 400, corsFor);
-            }
-            throw cause;
-        }
-        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(admissionRefusal(active.isAccepting), 503, corsFor);
-        let handedOff = false;
-        try {
-            const body = await readBoundedBody(request, limits.maximumRequestBytes, operation.signal);
-            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);
-            if (invocation.credentialIn === 'cookie' &&
-                isStateChanging(request) &&
-                isClearlyCrossSite(request, externalOrigin ?? new URL(request.url).origin)) {
-                const refusal = {
-                    code: errors.CODES.ACCESS_DENIED,
-                    message: 'Cross-site cookie-authenticated request to a native route is refused.',
-                };
-                return nativeError(refusal, errors.httpStatusOf(refusal), corsFor);
-            }
-            const idempotencyHeader = request.headers.get(protocol.HTTP_IDEMPOTENCY_KEY);
-            const idempotencyKey = idempotencyHeader === null
-                ? undefined
-                : protocol.acceptIdempotencyKey(idempotencyHeader, protocol.HTTP_IDEMPOTENCY_KEY);
-            const result = await handler.dispatch(Object.freeze({
-                call: invocation.call,
-                ...(invocation.credential === undefined ? {} : { credential: invocation.credential }),
-                ...(routing === undefined ? {} : { via: routing }),
-                ...pinned(snapshot),
-                context: invocationContext(assigned, operation, active, hostFor(request), body, idempotencyKey),
-            }));
-            if (result.kind === 'value') {
-                return new Response(encodedBody(codecs.json.encode(result.value)), {
-                    headers: {
-                        ...responseCors,
-                        'content-type': 'application/json',
-                    },
-                });
-            }
-            if (result.kind === 'binary') {
-                if (isStreamingBinary(result.value)) {
-                    // Hand the operation off only once the streaming response is built. A refused render
-                    // (reserved header or a body-forbidding status) throws before this point, so the
-                    // `finally` below still settles the operation instead of leaking its slot.
-                    const streaming = streamingBinaryResponse(result.value, operation, cors, request);
-                    handedOff = true;
-                    return streaming;
-                }
-                const applicationHeaders = applicationBinaryHeaders(result.value.headers);
-                return new Response(toBody(result.value.body), {
-                    status: result.value.status ?? 200,
-                    headers: {
-                        ...cors.response(request, [
-                            protocol.http.BINARY_HEADERS_FIELD,
-                            ...Object.keys(applicationHeaders),
-                        ]),
-                        ...applicationHeaders,
-                        'content-type': result.value.mediaType,
-                        [protocol.http.BINARY_HEADERS_FIELD]: protocol.http.encodeBinaryHeaderNames(applicationHeaders),
-                    },
-                });
-            }
-            if (result.kind === 'stream') {
-                handedOff = true;
-                return await streamResponse(result.stream, operation, corsFor);
-            }
-            if (result.kind === 'miss') {
-                return new Response(null, {
-                    status: routes.HTTP_ROUTE_MISS_STATUS,
-                    headers: {
-                        ...cors.response(request, [routes.HTTP_ROUTE_MISS]),
-                        ...routes.missHeaders(),
-                    },
-                });
-            }
-            return nativeError({
-                code: errors.CODES.UNSUPPORTED,
-                message: 'Native routes do not forward Runtime redirects.',
-            }, 502, corsFor);
-        }
-        catch (cause) {
-            if (cause instanceof RequestBodyTooLargeError) {
-                return nativeError({ code: errors.CODES.LIMIT_EXCEEDED, message: 'Request body is too large.' }, 413, corsFor);
-            }
-            if (cause instanceof RequestBodyInvalidError) {
-                return nativeError({ code: errors.CODES.INVALID_REQUEST, message: 'Request body is invalid.' }, 400, corsFor);
-            }
-            if (cause instanceof routes.RouteError) {
-                return nativeError({ code: errors.CODES.INVALID_REQUEST, message: 'Native route request is invalid.' }, 400, corsFor);
-            }
-            const payload = classifyRequestError(cause, operation);
-            return nativeError(payload, errors.httpStatusOf(payload), corsFor);
-        }
-        finally {
-            if (!handedOff)
-                operation.settle();
-        }
+        return (await nativeResponse(request, snapshot, native, responseCors)) ?? context.notFound();
     });
 }
-function streamingBinaryResponse(binary, operation, cors, request) {
-    // Admit the reserved/invalid headers before acquiring the producer, so a refused render never
-    // captures the stream it would then have to abandon.
-    const applicationHeaders = applicationBinaryHeaders(binary.headers);
-    const iterator = binary.body[Symbol.asyncIterator]();
-    let terminal = false;
-    let controller;
-    let stopping;
-    const stop = (reason = 'Binary response was interrupted.') => {
-        if (terminal)
-            return stopping ?? Promise.resolve();
-        terminal = true;
-        controller?.error(new Error(reason));
-        stopping = Promise.resolve().then(async () => {
-            try {
-                await iterator.return?.();
-            }
-            finally {
-                operation.settle();
-            }
-        });
-        return stopping;
-    };
-    const body = new ReadableStream({
-        start(output) {
-            controller = output;
-        },
-        async pull(controller) {
-            if (terminal)
-                return;
-            try {
-                const next = await iterator.next();
-                if (terminal)
-                    return;
-                if (next.done) {
-                    terminal = true;
-                    controller.close();
-                    operation.settle();
-                    return;
-                }
-                controller.enqueue(next.value);
-            }
-            catch (cause) {
-                if (terminal)
-                    return;
-                terminal = true;
-                controller.error(cause);
-                operation.settle();
-            }
-        },
-        async cancel(reason) {
-            const message = typeof reason === 'string' ? reason : 'native binary response cancelled';
-            operation.cancel(message);
-            await stop();
-        },
-    });
-    operation.onCancel(stop);
-    try {
-        return new Response(body, {
-            status: binary.status ?? 200,
-            headers: {
-                ...cors.response(request, Object.keys(applicationHeaders)),
-                ...applicationHeaders,
-                'content-type': binary.mediaType,
-            },
-        });
-    }
-    catch (cause) {
-        // A body-forbidding status (e.g. 204) rejects the Response after the producer was wired:
-        // close it and let the caller settle the operation rather than leaking its slot.
-        void stop('Binary response was refused.');
-        throw cause;
-    }
-}
-function isStreamingBinary(input) {
-    return !(input.body instanceof Uint8Array);
-}
-function publicationPreflight(cors, request, snapshot, 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 = document.delivery?.href;
-    if (deliveryUrl !== undefined && sameRoute(request.url, deliveryUrl, externalOrigin)) {
-        return cors.preflight(request, {
-            methods: ['POST'],
-            headers: ['authorization', 'content-type'],
-        });
-    }
-    const requestedMethod = request.headers.get('access-control-request-method');
-    const route = requestedMethod === null
-        ? undefined
-        : routes.match(snapshot.table, { url: request.url, method: requestedMethod });
-    return cors.preflight(request, route === undefined ? undefined : nativeCorsRoute(route, requestedMethod));
-}
-function nativeCorsRoute(entry, requestedMethod) {
-    const headers = new Set([
-        'accept',
-        routes.HTTP_ROUTE_DIGEST,
-        routes.HTTP_ROUTE_ISSUER,
-        protocol.HTTP_IDEMPOTENCY_KEY,
-    ]);
-    if (entry.body !== undefined)
-        headers.add('content-type');
-    let allowAnyHeaders = false;
-    for (const pick of Object.values(entry.headers ?? {})) {
-        if (pick === '*')
-            allowAnyHeaders = true;
-        else
-            headers.add(pick.toLowerCase());
-    }
-    const credential = entry.credential;
-    const sources = credential === undefined
-        ? [{ in: 'header' }]
-        : Array.isArray(credential)
-            ? credential
-            : [credential];
-    for (const source of sources) {
-        if (source.in === 'header')
-            headers.add((source.name ?? 'authorization').toLowerCase());
-    }
-    return Object.freeze({
-        methods: Object.freeze([entry.method === '*' ? requestedMethod.toUpperCase() : entry.method]),
-        headers: Object.freeze([...headers]),
-        ...(allowAnyHeaders ? { allowAnyHeaders: true } : {}),
-    });
-}
-/**
- * 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 &&
-            servedDocument(prepared).identity.issuer !== serving.issuer) ||
-        (serving !== undefined && conflictsWithServingRoutes(prepared, serving))) {
-        return undefined;
-    }
-    return prepared;
-}
-function servingSnapshot(source, limits, request, reservations, externalIssuer, publicOrigin) {
-    return currentServed(source, limits, {
-        origin: publicOrigin ??
-            (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.table.entries) {
-            if (reservation.methods.some((method) => entry.method === '*' || entry.method === method) &&
-                routes.templatesOverlap(entry.href, href)) {
-                return true;
-            }
-        }
-    }
-    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;
-    const setupInterrupted = new Promise((_resolve, reject) => {
-        rejectSetup = reject;
-    });
-    let setupCleanup;
-    const cancelSetup = (reason) => {
-        rejectSetup(operation.signal.reason ?? new Error(reason));
-        setupCleanup ??= Promise.allSettled([
-            Promise.resolve().then(() => stream.cancel(reason)),
-            Promise.resolve().then(() => iterator.return?.()),
-        ]).then(() => operation.settle());
-        return setupCleanup;
-    };
-    const unregisterSetupCancellation = operation.onCancel(cancelSetup);
-    let first;
-    try {
-        first = await Promise.race([iterator.next(), setupInterrupted]);
-    }
-    catch (cause) {
-        unregisterSetupCancellation();
-        const cleanup = cancelSetup('native stream setup failed');
-        if (!operation.signal.aborted)
-            await cleanup;
-        const payload = classifyRequestError(cause, operation);
-        return nativeError(payload, errors.httpStatusOf(payload), cors);
-    }
-    unregisterSetupCancellation();
-    if (operation.signal.aborted) {
-        void cancelSetup('native stream setup cancelled');
-        const payload = classifyRequestError(operation.signal.reason, operation);
-        return response({ error: payload }, errors.httpStatusOf(payload), cors());
-    }
-    const encoder = new TextEncoder();
-    let pending = first;
-    let terminal = false;
-    let controller;
-    let stopping;
-    const encoded = (frame) => encoder.encode(routes.encodeStreamFrame(frame));
-    const stop = (reason, error) => {
-        stopping ??= (async () => {
-            if (terminal)
-                return;
-            terminal = true;
-            if (controller !== undefined) {
-                if (error !== undefined) {
-                    try {
-                        controller.enqueue(encoded({ kind: 'error', error }));
-                    }
-                    catch {
-                        // The transport consumer may already have disconnected.
-                    }
-                }
-                try {
-                    controller.close();
-                }
-                catch {
-                    // A cancelled response body is already terminal.
-                }
-            }
-            try {
-                await Promise.allSettled([
-                    Promise.resolve().then(() => stream.cancel(reason)),
-                    Promise.resolve().then(() => iterator.return?.()),
-                ]);
-            }
-            finally {
-                operation.settle();
-            }
-        })();
-        return stopping;
-    };
-    const body = new ReadableStream({
-        start(output) {
-            controller = output;
-        },
-        async pull(output) {
-            if (terminal)
-                return;
-            try {
-                const next = pending ?? (await iterator.next());
-                pending = undefined;
-                if (terminal)
-                    return;
-                if (next.done) {
-                    terminal = true;
-                    output.enqueue(encoded({ kind: 'end' }));
-                    output.close();
-                    operation.settle();
-                }
-                else {
-                    output.enqueue(encoded({ kind: 'item', value: next.value }));
-                }
-            }
-            catch (cause) {
-                await stop('native stream failed', operation.signal.aborted
-                    ? interruptedStreamError(operation.timedOut)
-                    : classifyError(cause));
-            }
-        },
-        async cancel(reason) {
-            const message = typeof reason === 'string' ? reason : 'native response cancelled';
-            operation.cancel(message);
-            await stop(message);
-        },
-    });
-    operation.onCancel((reason) => stop(reason, interruptedStreamError(operation.timedOut)));
-    return new Response(body, {
-        headers: {
-            ...cors(),
-            'content-type': routes.STREAM_MEDIA_TYPE,
-            'cache-control': 'no-cache',
-        },
-    });
-}
-function sameRoute(left, right, externalOrigin) {
-    const a = new URL(left);
-    const b = new URL(right);
-    return ((externalOrigin ?? a.origin) === b.origin && a.pathname === b.pathname && a.search === b.search);
-}
-/**
- * A request that mutates state or navigates to an effectful target. Non-safe HTTP methods always
- * qualify; a GET or HEAD qualifies only as a top-level browser navigation (`Sec-Fetch-Mode:
- * navigate`), the one GET shape that carries SameSite=Lax cookies cross-site. Programmatic GETs
- * (`cors`/`no-cors`) are left untouched so read clients are never broken.
- */
-function isStateChanging(request) {
-    switch (request.method.toUpperCase()) {
-        case 'POST':
-        case 'PUT':
-        case 'PATCH':
-        case 'DELETE':
-            return true;
-        case 'GET':
-        case 'HEAD':
-            return request.headers.get('sec-fetch-mode') === 'navigate';
-        default:
-            return false;
-    }
-}
-/**
- * Positive evidence that a request originates from another site. `Sec-Fetch-Site` is set by the
- * browser and cannot be forged by page script, so when present it is authoritative: only
- * `cross-site` is refused, and `same-origin`/`same-site`/`none` are trusted (a shared-domain
- * subdomain deployment keeps working). When it is absent, a differing `Origin` is the next-best
- * signal. Absence of both is treated as not-cross-site, so same-origin browsers and non-browser
- * clients that omit these headers are never refused.
- */
-function isClearlyCrossSite(request, serviceOrigin) {
-    const site = request.headers.get('sec-fetch-site');
-    if (site !== null)
-        return site === 'cross-site';
-    const origin = request.headers.get('origin');
-    return origin !== null && origin !== serviceOrigin;
-}
-function applicationBinaryHeaders(input) {
-    const output = {};
-    for (const [name, value] of Object.entries(input ?? {})) {
-        if (name.toLowerCase() === routes.HTTP_ROUTE_STALE ||
-            name.toLowerCase() === routes.HTTP_ROUTE_MISS) {
-            throw new TypeError(`${name.toLowerCase()} is reserved for native routing control.`);
-        }
-        if (protocol.http.isApplicationBinaryHeader(name))
-            output[name] = value;
-    }
-    return output;
-}
-function quoteEtag(digest) {
-    return `"${digest}"`;
-}
-function response(body, status, cors) {
-    return new Response(encodedBody(codecs.json.encode(body)), {
-        status,
-        headers: { ...cors, 'content-type': 'application/json' },
-    });
-}
-/** 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 });
-}
-/** Every native error, including a capacity refusal raised by dispatch, presents its retry delay. */
-function nativeError(error, status, cors) {
-    const admitted = routes.decodeErrorResponse({ error });
-    const retry = retryAfterHeaders(error);
-    return response(admitted, status, { ...cors(Object.keys(retry)), ...retry });
-}
-function encodedBody(input) {
-    return typeof input === 'string' ? input : toBody(input);
-}
-function toBody(input) {
-    return input.buffer.slice(input.byteOffset, input.byteOffset + input.byteLength);
-}

package/dist/routes/snapshot.d.ts

@@ -0,0 +1,13 @@
+import type { Served, ServingSource } from '../release/served.js';
+import type { RouteLimits, RouteReservation } from './model.js';
+/**
+ * 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, 'maximumReleaseBytes' | 'maximumBundleBytes'>, serving?: {
+    readonly origin: string;
+    readonly issuer?: string;
+    readonly reservations: readonly RouteReservation[];
+}): Served | undefined;
+/** Admit the one request snapshot against its trusted origin and reserved routes. */
+export declare function servingSnapshot(source: ServingSource, limits: Pick<RouteLimits, 'maximumReleaseBytes' | 'maximumBundleBytes'>, request: Request, reservations: readonly RouteReservation[], externalIssuer?: string, publicOrigin?: string): Served | undefined;