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

package/dist/index.d.ts

@@ -1,10 +1,5 @@
 export { createServer, prepareServer } from './server.js';
 export { DeliveryUnavailableError, IssuerKeysUnavailableError } from './errors/index.js';
-export { releaseProjectionRouteDecision, releaseRouteDecision, type RouteDecision, } from './invocation/index.js';
 export { prepareReleaseSnapshot } from './release/index.js';
 export * as release from './release/index.js';
-/** @deprecated Successor: `prepareReleaseSnapshot`; serves v3-input destinations only. */
-export { preparePublicationSnapshot } from './release/legacy/index.js';
-/** @deprecated Successor: `release`; the Publication snapshot of a v3-input destination. */
-export * as publication from './release/legacy/index.js';
-export type { Application, ApplicationHost, CorsConfig, ExecutionControl, Handler, HandlerRequest, HandlerResult, HandlerStream, HealthProbe, InvocationContext, InvocationSource, RequestBackground, RequestEvidence, RequestSleep, Issuer, exchange, PreparedServer, PublicationSnapshot, PublicationSnapshotInput, PublicationSource, ReleaseSnapshot, ReleaseSnapshotInput, ReleaseSource, Server, ServerCloseOptions, ServerConfig, ServerLimits, ServerOptions, WebSocketAdapter, WebSocketHandlers, WebSocketLike, WebSocketUpgradeOptions, } from './types.js';
+export type { Application, ApplicationHost, CorsConfig, ExecutionControl, Handler, HandlerRequest, HandlerResult, HandlerStream, HealthProbe, InvocationContext, InvocationSource, RequestBackground, RequestEvidence, RequestSleep, Issuer, exchange, PreparedServer, ReleaseSnapshot, ReleaseSnapshotInput, ReleaseSource, Server, ServerCloseOptions, ServerConfig, ServerLimits, ServerOptions, WebSocketAdapter, WebSocketHandlers, WebSocketLike, WebSocketUpgradeOptions, } from './types.js';

package/dist/index.js

@@ -1,9 +1,4 @@
 export { createServer, prepareServer } from './server.js';
 export { DeliveryUnavailableError, IssuerKeysUnavailableError } from './errors/index.js';
-export { releaseProjectionRouteDecision, releaseRouteDecision, } from './invocation/index.js';
 export { prepareReleaseSnapshot } from './release/index.js';
 export * as release from './release/index.js';
-/** @deprecated Successor: `prepareReleaseSnapshot`; serves v3-input destinations only. */
-export { preparePublicationSnapshot } from './release/legacy/index.js';
-/** @deprecated Successor: `release`; the Publication snapshot of a v3-input destination. */
-export * as publication from './release/legacy/index.js';

package/dist/invocation/index.d.ts

@@ -1,4 +1,4 @@
 export { defaultSleep, invocationContext } from './context.js';
 export { captureInvocationSource, type InvocationSource, type NextInvocationId, } from './identity.js';
-export { admitVia, releaseProjectionRouteDecision, releaseRouteDecision, type RouteDecision, } from './release-route.js';
+export { admitVia, releaseRouteDecision, type RouteDecision } from './release-route.js';
 export type { ApplicationHost, ExecutionControl, Handler, HandlerRequest, HandlerResult, HandlerStream, InvocationContext, RequestBackground, RequestEvidence, RequestSleep, } from './types.js';

package/dist/invocation/index.js

@@ -1,3 +1,3 @@
 export { defaultSleep, invocationContext } from './context.js';
 export { captureInvocationSource, } from './identity.js';
-export { admitVia, releaseProjectionRouteDecision, releaseRouteDecision, } from './release-route.js';
+export { admitVia, releaseRouteDecision } from './release-route.js';

package/dist/invocation/release-route.d.ts

@@ -1,9 +1,7 @@
 import type { ErrorPayload } from '@astrale-os/kernel-protocol/errors';
-import type { PublicationVia, Via } from '@astrale-os/kernel-protocol/invocation';
+import type { Via } from '@astrale-os/kernel-protocol/invocation';
 import type { DomainRelease, ReleaseDigest, ReleaseRef } from '@astrale-os/kernel-protocol/release';
-import type { PublicationRef } from '@astrale-os/kernel-protocol/release/legacy';
 import type { Served } from '../release/served.js';
-import type { ReleaseSnapshot } from '../release/types.js';
 export type RouteDecision = {
     readonly kind: 'admitted';
 } | {
@@ -20,7 +18,5 @@ export type RouteDecision = {
  * the witness pairs it with a different revision or issuer.
  */
 export declare function releaseRouteDecision(current: DomainRelease, installed: ReleaseRef): RouteDecision;
-/** Only the exact v3 projection reference admits, including its ETag, Schema and issuer. */
-export declare function releaseProjectionRouteDecision(current: ReleaseSnapshot, installed: PublicationRef): RouteDecision;
-/** Admit routing before credential resolution; Publication sources accept only legacy witnesses. */
-export declare function admitVia(served: Served | undefined, via: Via | PublicationVia): RouteDecision;
+/** Admit routing against the exact release before credential resolution. */
+export declare function admitVia(served: Served | undefined, via: Via): RouteDecision;

package/dist/invocation/release-route.js

@@ -1,7 +1,5 @@
 import { CODES } from '@astrale-os/kernel-protocol/errors';
 import { compareReferences, reference } from '@astrale-os/kernel-protocol/release';
-import { compareReference } from '@astrale-os/kernel-protocol/release/legacy';
-import { publicationRouteDecision } from './legacy/index.js';
 const ADMITTED = Object.freeze({ kind: 'admitted' });
 const RETIRED = Object.freeze({ kind: 'retired' });
 /**
@@ -20,32 +18,11 @@ export function releaseRouteDecision(current, installed) {
             return invalid('Routed release origin differs from the served Domain.');
     }
 }
-/** Only the exact v3 projection reference admits, including its ETag, Schema and issuer. */
-export function releaseProjectionRouteDecision(current, installed) {
-    switch (compareReference(current.publication, installed)) {
-        case 'exact':
-            return ADMITTED;
-        case 'same-schema':
-        case 'schema-drift':
-        case 'identity-drift':
-            return RETIRED;
-        case 'origin-drift':
-            return invalid('Routed Publication origin differs from the served Domain.');
-    }
-}
-/** Admit routing before credential resolution; Publication sources accept only legacy witnesses. */
+/** Admit routing against the exact release before credential resolution. */
 export function admitVia(served, via) {
-    if ('release' in via) {
-        return served?.kind === 'release'
-            ? releaseRouteDecision(served.release, via.release)
-            : invalid('Release routing requires a release-backed destination.');
-    }
-    if (served === undefined) {
-        return invalid('Publication routing requires a Publication-backed destination.');
-    }
-    return served.kind === 'release'
-        ? releaseProjectionRouteDecision(served.snapshot, via.publication)
-        : publicationRouteDecision(served.publication, via.publication);
+    return served === undefined
+        ? invalid('Release routing requires a release-backed destination.')
+        : releaseRouteDecision(served.release, via.release);
 }
 function invalid(message) {
     return Object.freeze({

package/dist/invocation/types.d.ts

@@ -3,7 +3,6 @@ import type { BinaryRequestBody, CallableResult } from '@astrale-os/kernel-core/
 import type { Value } from '@astrale-os/kernel-dsl/value';
 import type * as protocol from '@astrale-os/kernel-protocol/invocation';
 import type { ReleaseSnapshot } from '../release/index.js';
-import type { PublicationSnapshot } from '../release/legacy/index.js';
 /** Optional platform retention and timer adaptation for one Fetch invocation. */
 export interface ApplicationHost {
     waitUntil(promise: Promise<unknown>): void;
@@ -52,23 +51,12 @@ export interface HandlerRequest {
     readonly credential?: CredentialInput;
     /** Source-only effective delegation forwarded unchanged to Runtime. */
     readonly delegate?: protocol.Delegate;
-    /**
-     * Destination routing witness forwarded after Server admission: at a release-backed destination
-     * a `Via` naming its exact release or a `PublicationVia` naming its exact v3 projection; at a
-     * v3-input destination only a `PublicationVia`.
-     */
-    readonly via?: protocol.Via | protocol.PublicationVia;
+    /** Destination witness admitted against the exact served release. */
+    readonly via?: protocol.Via;
     /** Source-only local-target or remote-revision Schema Registration precondition. */
     readonly schema?: protocol.SchemaTarget;
     /** Exact Server-pinned release for a request at a release-backed destination. */
     readonly release?: ReleaseSnapshot;
-    /**
-     * Exact Server-pinned Publication snapshot for a request at a v3-input destination.
-     *
-     * @deprecated Successor: `release`. Present only on a Server built from a v2/v3 Publication;
-     * deleted with `server/release/legacy/`.
-     */
-    readonly publication?: PublicationSnapshot;
     readonly context: InvocationContext;
 }
 export interface Handler {

package/dist/issuer/routes.js

@@ -92,56 +92,37 @@ export function mountIssuer(app, input, cors, active, timeoutMs, tokenExchange)
             app.options(`${base}/iss/:thumbprint/.well-known/openid-configuration`, (context) => cors.preflight(context.req.raw, { methods: ['GET'] }));
             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 = 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);
-            if (operation === undefined) {
-                const refused = refusal(context.req.raw);
-                return context.json(refused.body, 503, refused.headers);
-            }
-            try {
-                const keys = await hostedKeys(loadIssuerPublicKeys, hostedIssuer, operation.signal, algorithm);
-                if (keys.length === 0)
+        const mountHostedDiscovery = (path, document) => {
+            app.get(path, async (context) => {
+                const hostedIssuer = hosted(issuer, context.req.param('thumbprint'));
+                if (hostedIssuer === undefined)
                     return context.json({ error: 'Issuer not found.' }, 404, headers(context.req.raw));
-                return context.json(configuration(hostedIssuer, [algorithm]), 200, headers(context.req.raw));
-            }
-            catch (cause) {
-                if (operation.signal.aborted || cause instanceof IssuerKeysUnavailableError) {
-                    return context.json({ error: 'Issuer keys are unavailable.' }, 503, headers(context.req.raw));
+                const operation = active.begin(timeoutMs, context.req.raw.signal);
+                if (operation === undefined) {
+                    const refused = refusal(context.req.raw);
+                    return context.json(refused.body, 503, refused.headers);
                 }
-                throw cause;
-            }
-            finally {
-                operation.settle();
-            }
-        });
-        app.get(`${base}/iss/:thumbprint/.well-known/jwks.json`, async (context) => {
-            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);
-            if (operation === undefined) {
-                const refused = refusal(context.req.raw);
-                return context.json(refused.body, 503, refused.headers);
-            }
-            try {
-                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({ keys }, 200, headers(context.req.raw));
-            }
-            catch (cause) {
-                if (operation.signal.aborted || cause instanceof IssuerKeysUnavailableError) {
-                    return context.json({ error: 'Issuer keys are unavailable.' }, 503, headers(context.req.raw));
+                try {
+                    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(document(hostedIssuer, keys), 200, headers(context.req.raw));
                 }
-                throw cause;
-            }
-            finally {
-                operation.settle();
-            }
-        });
+                catch (cause) {
+                    if (operation.signal.aborted || cause instanceof IssuerKeysUnavailableError) {
+                        return context.json({ error: 'Issuer keys are unavailable.' }, 503, headers(context.req.raw));
+                    }
+                    throw cause;
+                }
+                finally {
+                    operation.settle();
+                }
+            });
+        };
+        mountHostedDiscovery(`${base}/iss/:thumbprint/.well-known/openid-configuration`, (issuer) => configuration(issuer, [algorithm]));
+        mountHostedDiscovery(`${base}/iss/:thumbprint/.well-known/jwks.json`, (_issuer, keys) => ({
+            keys,
+        }));
     }
 }
 async function hostedKeys(load, issuer, signal, algorithm) {

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

@@ -5,9 +5,5 @@ export interface Limits {
     readonly maximumDeliveryBytes: number;
     readonly invocationTimeoutMs: number;
 }
-/**
- * Serve one delivery request against the exact snapshot that selected its URL, in the request's
- * version: Delivery v2 names the served release, Delivery v1 the served Publication (a release's
- * frozen v3 projection). A v3-input destination keeps its Delivery v1 decoder.
- */
+/** Serve one version-two Delivery against the exact snapshot that selected its URL. */
 export declare function handleDelivery(request: Request, snapshot: Served, provider: Provider | undefined, active: ActiveOperations, limits: Limits, corsFor: (exposedHeaders?: readonly string[]) => Readonly<Record<string, string>>): Promise<Response>;

package/dist/release/delivery/handler.js

@@ -5,12 +5,7 @@ import { RequestBodyInvalidError, RequestBodyTooLargeError } from '../../errors/
 import { readBoundedBody } from '../../transport/index.js';
 import { servedDocument } from '../served.js';
 const delivery = release.delivery;
-const publicationDelivery = release.legacy.delivery;
-/**
- * Serve one delivery request against the exact snapshot that selected its URL, in the request's
- * version: Delivery v2 names the served release, Delivery v1 the served Publication (a release's
- * frozen v3 projection). A v3-input destination keeps its Delivery v1 decoder.
- */
+/** Serve one version-two Delivery against the exact snapshot that selected its URL. */
 export async function handleDelivery(request, snapshot, provider, active, limits, corsFor) {
     const cors = corsFor();
     if (request.method !== 'POST') {
@@ -66,10 +61,7 @@ export async function handleDelivery(request, snapshot, provider, active, limits
         }
         let input;
         try {
-            input =
-                snapshot.kind === 'release'
-                    ? delivery.acceptRequest(decoded)
-                    : publicationDelivery.acceptRequest(decoded);
+            input = delivery.acceptRequest(decoded);
         }
         catch (cause) {
             if (cause instanceof delivery.Error && cause.code === 'DELIVERY_REQUEST_INVALID') {
@@ -77,13 +69,9 @@ export async function handleDelivery(request, snapshot, provider, active, limits
             }
             throw cause;
         }
-        const named = input.version === 2 ? input.release : input.etag;
-        const served = input.version === 2 ? servedRelease(snapshot) : snapshot.publication.etag;
-        if (named !== served) {
-            const error = input.version === 2
-                ? 'Release digest differs from request.'
-                : 'Publication ETag differs from request.';
-            return response({ error }, 409, cors);
+        const served = snapshot.release.digest;
+        if (input.release !== served) {
+            return response({ error: 'Release digest differs from request.' }, 409, cors);
         }
         let candidate;
         try {
@@ -100,8 +88,7 @@ export async function handleDelivery(request, snapshot, provider, active, limits
         }
         let created;
         try {
-            created =
-                input.version === 2 ? delivery.accept(candidate) : publicationDelivery.accept(candidate);
+            created = delivery.accept(candidate);
         }
         catch (cause) {
             if (cause instanceof delivery.Error) {
@@ -109,12 +96,8 @@ export async function handleDelivery(request, snapshot, provider, active, limits
             }
             throw cause;
         }
-        const delivered = created.version === 2 ? created.release.digest : created.publication.etag;
-        if (delivered !== served) {
-            const error = created.version === 2
-                ? 'Delivery provider returned a different release.'
-                : 'Delivery provider returned a different Publication.';
-            return response({ error }, 500, cors);
+        if (created.release.digest !== served) {
+            return response({ error: 'Delivery provider returned a different release.' }, 500, cors);
         }
         const encoded = codecs.json.encode(created);
         if (encodedSize(encoded) > limits.maximumDeliveryBytes) {
@@ -128,10 +111,6 @@ export async function handleDelivery(request, snapshot, provider, active, limits
         operation.settle();
     }
 }
-/** Digest a Delivery v2 must name: only a release-backed destination serves one. */
-function servedRelease(snapshot) {
-    return snapshot.kind === 'release' ? snapshot.release.digest : undefined;
-}
 function bearer(input) {
     if (input === null)
         return undefined;

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

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

package/dist/release/delivery/index.js

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

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

@@ -4,18 +4,8 @@ export interface Context {
     readonly token?: release.delivery.Token;
     readonly signal: AbortSignal;
 }
-/** Provider-owned retrieval, construction, and attestation signing. */
+/** Provider-owned retrieval, construction, and attestation signing for the served release. */
 export interface Provider {
-    /**
-     * Answer in the request's version: a Delivery v2 carrying the served release for a v2 request,
-     * and a Delivery v1 carrying the served Publication (at a release-backed destination, its frozen
-     * v3 projection) for a deprecated v1 request. A v3-input destination passes only v1 requests.
-     * Throw DeliveryUnavailableError only for an expected dependency outage.
-     *
-     * A release-backed destination (`ServerOptions.release`) passes v2 requests, so its provider
-     * must answer both versions. The deprecated v1-only `publication.delivery.Provider` still
-     * type-checks here, because method parameters are compared bivariantly, but every v2 request
-     * it receives fails with 500 `Delivery provider returned an invalid response.`
-     */
-    create(request: release.delivery.Request | release.legacy.delivery.Request, context: Context): Promise<release.delivery.Delivery | release.legacy.delivery.Delivery>;
+    /** Throw DeliveryUnavailableError only for an expected dependency outage. */
+    create(request: release.delivery.Request, context: Context): Promise<release.delivery.Delivery>;
 }

package/dist/release/served.d.ts

@@ -1,30 +1,21 @@
 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 = {
+export interface ServingSource {
     readonly kind: 'release';
     readonly source: ReleaseSource;
-} | {
-    readonly kind: 'publication';
-    readonly source: PublicationSource;
-};
-export type Served = PreparedReleaseSnapshot | PreparedPublicationSnapshot;
+}
+export type Served = PreparedReleaseSnapshot;
 export interface RequestServing {
-    readonly kind: ServingSource['kind'];
+    readonly kind: 'release';
     /** 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. */
+    /** The public serving origin named by a DEPLOYMENT_RETIRED answer. */
     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 servedDocument(served: Served): DomainRelease;
 export declare function pinned(served: Served): {
     readonly release: ReleaseSnapshot;
-} | {
-    readonly publication: PublicationSnapshot;
 };

package/dist/release/served.js

@@ -1,14 +1,10 @@
-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());
+    return readPreparedReleaseSnapshot(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;
+    return served.release;
 }
 export function pinned(served) {
-    return served.kind === 'release' ? { release: served.snapshot } : { publication: served.snapshot };
+    return { release: served.snapshot };
 }

package/dist/release/snapshot.d.ts

@@ -1,17 +1,13 @@
 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. */
+    /** The exact release reference native-route If-Match names. */
     readonly references: ServedReferences;
     readonly bundle: Uint8Array;
     readonly table: Table;
@@ -19,7 +15,7 @@ export interface PreparedReleaseSnapshot {
 }
 /**
  * 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.
+ * bundle bytes, its resolved Domain and route Table.
  */
 export declare function prepareReleaseSnapshot(input: ReleaseSnapshotInput): ReleaseSnapshot;
 /** Internal proof that a ReleaseSource returned a Server-prepared snapshot without cloning it. */

package/dist/release/snapshot.js

@@ -1,10 +1,9 @@
 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.
+ * bundle bytes, its resolved Domain and route Table.
  */
 export function prepareReleaseSnapshot(input) {
     if (input === null || typeof input !== 'object' || !(input.bundle instanceof Uint8Array)) {
@@ -26,18 +25,14 @@ export function prepareReleaseSnapshot(input) {
         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 snapshot = Object.freeze({ release });
     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,

package/dist/release/types.d.ts

@@ -10,19 +10,9 @@ export interface ReleaseSnapshotInput {
     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.
- */
+/** Immutable admitted serving identity; 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. */

package/dist/routes/address.d.ts

@@ -0,0 +1,2 @@
+/** Match a resource path and query against its trusted serving origin. */
+export declare function sameRoute(left: string, right: string, externalOrigin?: string): boolean;

package/dist/routes/address.js

@@ -0,0 +1,6 @@
+/** Match a resource path and query against its trusted serving origin. */
+export 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);
+}

package/dist/routes/binary.d.ts

@@ -0,0 +1,9 @@
+import type { BinaryOutput, StreamingBinaryResult } from '@astrale-os/kernel-core/callable';
+import type { CorsPolicy } from '../cors/index.js';
+import type { ActiveOperation } from '../lifecycle/index.js';
+/** Retain the native operation until its byte producer ends or is closed. */
+export declare function streamingBinaryResponse(binary: StreamingBinaryResult, operation: ActiveOperation, cors: CorsPolicy, request: Request): Response;
+/** Identify a producer-backed binary result before handing off operation ownership. */
+export declare function isStreamingBinary(input: BinaryOutput): input is StreamingBinaryResult;
+/** Render buffered application bytes with the native binary header manifest. */
+export declare function binaryResponse(binary: Exclude<BinaryOutput, StreamingBinaryResult>, cors: CorsPolicy, request: Request): Response;

package/dist/routes/binary.js

@@ -0,0 +1,110 @@
+import * as protocol from '@astrale-os/kernel-protocol/invocation';
+import * as routes from '@astrale-os/kernel-protocol/routes';
+import { toBody } from './response.js';
+/** Retain the native operation until its byte producer ends or is closed. */
+export 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;
+    }
+}
+/** Identify a producer-backed binary result before handing off operation ownership. */
+export function isStreamingBinary(input) {
+    return !(input.body instanceof Uint8Array);
+}
+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;
+}
+/** Render buffered application bytes with the native binary header manifest. */
+export function binaryResponse(binary, cors, request) {
+    const applicationHeaders = applicationBinaryHeaders(binary.headers);
+    return new Response(toBody(binary.body), {
+        status: binary.status ?? 200,
+        headers: {
+            ...cors.response(request, [
+                protocol.http.BINARY_HEADERS_FIELD,
+                ...Object.keys(applicationHeaders),
+            ]),
+            ...applicationHeaders,
+            'content-type': binary.mediaType,
+            [protocol.http.BINARY_HEADERS_FIELD]: protocol.http.encodeBinaryHeaderNames(applicationHeaders),
+        },
+    });
+}

package/dist/routes/bundle.d.ts

@@ -0,0 +1,5 @@
+import type { ActiveOperations } from '../lifecycle/index.js';
+import type { Served } from '../release/served.js';
+import type { CorsHeaders } from './model.js';
+/** Serve exact bundle bytes or an uncached miss inside its immutable artifact directory. */
+export declare function bundleResponse(request: Request, snapshot: Served, active: ActiveOperations, responseCors: Readonly<Record<string, string>>, corsFor: CorsHeaders, externalOrigin?: string): Response | undefined;