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

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

@@ -0,0 +1,26 @@
+import type { Domain } from '@astrale-os/kernel-dsl/v1';
+import type * as publication from '@astrale-os/kernel-protocol/publication';
+import type { Table } from '@astrale-os/kernel-protocol/routes/legacy';
+import type { PublicationSnapshot, PublicationSnapshotInput } from './types.js';
+/** @deprecated Successor: `PreparedReleaseSnapshot`. */
+export interface PreparedPublicationSnapshot {
+    readonly kind: 'publication';
+    readonly snapshot: PublicationSnapshot;
+    readonly publication: publication.Publication;
+    readonly publicationBytes: Uint8Array;
+    readonly bundle: Uint8Array;
+    readonly table: Table;
+    readonly domain: Domain;
+}
+/**
+ * Admit and detach one revision-coherent serving snapshot.
+ *
+ * @deprecated Use `prepareReleaseSnapshot` to serve a release and its v3 projection.
+ */
+export declare function preparePublicationSnapshot(input: PublicationSnapshotInput): PublicationSnapshot;
+/**
+ * Internal proof that a PublicationSource returned a Server-prepared snapshot without cloning it.
+ *
+ * @deprecated Successor: `readPreparedReleaseSnapshot`.
+ */
+export declare function readPreparedPublicationSnapshot(input: unknown): PreparedPublicationSnapshot | undefined;

package/dist/release/legacy/snapshot.js

@@ -0,0 +1,55 @@
+import { bundleUrl } from '@astrale-os/kernel-protocol/publication';
+import { verifyBundleBytes } from '@astrale-os/kernel-protocol/publication/bundle-evidence';
+import { accept as acceptPublication, encode as encodePublication, } from '@astrale-os/kernel-protocol/publication/publication';
+import { admitTable } from './table.js';
+const snapshots = new WeakMap();
+/**
+ * Admit and detach one revision-coherent serving snapshot.
+ *
+ * @deprecated Use `prepareReleaseSnapshot` to serve a release and its v3 projection.
+ */
+export function preparePublicationSnapshot(input) {
+    if (input === null || typeof input !== 'object' || !(input.bundle instanceof Uint8Array)) {
+        throw new TypeError('Publication snapshot input is invalid.');
+    }
+    const admittedPublication = acceptPublication(input.publication);
+    const bundleBytes = new Uint8Array(input.bundle);
+    verifyBundleBytes(admittedPublication, bundleBytes);
+    const domain = input.domain;
+    if (domain.origin !== admittedPublication.origin ||
+        domain.revision !== admittedPublication.schema.revision) {
+        throw new TypeError('Publication snapshot Domain identity differs from its Publication.');
+    }
+    const table = admitTable(admittedPublication, input.table, domain);
+    const addressed = new URL(bundleUrl(admittedPublication.identity.issuer, admittedPublication.schema.bundle.ref));
+    const addressedDirectory = addressed.pathname.slice(0, addressed.pathname.lastIndexOf('/') + 1);
+    const servingBundle = new URL(admittedPublication.schema.bundle.href);
+    if (servingBundle.origin === addressed.origin &&
+        servingBundle.pathname.startsWith(addressedDirectory) &&
+        servingBundle.href !== addressed.href) {
+        throw new TypeError('Publication bundle URL differs from its artifact digest.');
+    }
+    const publicationBytes = encodePublication(admittedPublication);
+    const snapshot = Object.freeze({ publication: admittedPublication });
+    const prepared = Object.freeze({
+        kind: 'publication',
+        snapshot,
+        publication: admittedPublication,
+        publicationBytes,
+        bundle: bundleBytes,
+        table,
+        domain,
+    });
+    snapshots.set(snapshot, prepared);
+    return snapshot;
+}
+/**
+ * Internal proof that a PublicationSource returned a Server-prepared snapshot without cloning it.
+ *
+ * @deprecated Successor: `readPreparedReleaseSnapshot`.
+ */
+export function readPreparedPublicationSnapshot(input) {
+    if (input === null || typeof input !== 'object')
+        return undefined;
+    return snapshots.get(input);
+}

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

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

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

@@ -1,7 +1,7 @@
 import { reference } from '@astrale-os/kernel-protocol/publication/reference';
-import { acceptTable } from '@astrale-os/kernel-protocol/routes/admission';
-import { verifyTable } from '@astrale-os/kernel-protocol/routes/evidence';
-export function admitTable(deployed, input, validator) {
+import { acceptTable, verifyTable } from '@astrale-os/kernel-protocol/routes/legacy';
+/** @deprecated Use `admitTable` in `server/release/table.ts` for release-bound routes. */
+export function admitTable(deployed, input, domain) {
     if (input === undefined) {
         if (deployed.routes.length !== 0) {
             throw new TypeError('A Publication with native routes requires a Route Table.');
@@ -9,9 +9,8 @@ export function admitTable(deployed, input, validator) {
         return verifyTable(Object.freeze({
             publication: reference(deployed),
             entries: Object.freeze([]),
-        }), deployed, validator);
+        }), deployed, domain);
     }
     const table = acceptTable(input);
-    return verifyTable(table, deployed, validator);
+    return verifyTable(table, deployed, domain);
 }
-//# sourceMappingURL=table.js.map

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

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

package/dist/release/legacy/types.js

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

package/dist/release/served.d.ts

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

package/dist/release/served.js

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

package/dist/release/snapshot.d.ts

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

package/dist/release/snapshot.js

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

package/dist/release/table.d.ts

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

package/dist/release/table.js

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

package/dist/release/types.d.ts

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

package/dist/release/types.js

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

package/dist/routes/index.d.ts

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

package/dist/routes/index.js

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

package/dist/routes/routes.d.ts

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