@astrale-os/sdk 0.6.0-beta.4 → 0.6.0-beta.41

package/dist/execution/invocation/result/errors.d.ts

@@ -2,16 +2,6 @@ import * as errors from '@astrale-os/kernel-protocol/errors';
 import type { ResolvedCallable } from '../../../application/action/index.js';
 import type { Key } from '../../../platform/schema/index.js';
 import type { Value } from '../../../platform/value/index.js';
-export type InvocationErrorCode = Extract<keyof typeof errors.CODES, 'VALIDATION_ERROR' | 'ACCESS_DENIED' | 'NOT_FOUND' | 'CONFLICT' | 'UNSUPPORTED' | 'LIMIT_EXCEEDED' | 'BACKEND_UNAVAILABLE'>;
-/** @deprecated Declare expected failures on defineAction or defineWorkflow instead. */
-export declare class InvocationError extends Error {
-    readonly code: InvocationErrorCode;
-    readonly name = "InvocationError";
-    readonly reason?: errors.ErrorReason;
-    constructor(code: InvocationErrorCode, message: string, options?: ErrorOptions & {
-        readonly reason?: errors.ErrorReason;
-    });
-}
 export type InvocationDefectCode = 'INVOCATION_TARGET_INVALID' | 'INVOCATION_HANDLER_INVALID' | 'INVOCATION_OUTPUT_INVALID' | 'INVOCATION_RESULT_CONTRACT_VIOLATION';
 export declare class InvocationDefect extends Error {
     readonly code: InvocationDefectCode;

package/dist/execution/invocation/result/errors.js

@@ -5,20 +5,6 @@ const PUBLIC_ERROR_CODES = new Set(Object.values(errors.CODES));
 const PUBLIC_ERROR_NAMES = new Map(Object.entries(errors.CODES).map(([name, code]) => [code, name]));
 const MAXIMUM_DIAGNOSTICS = 32;
 const admittedProtocolErrors = new WeakSet();
-/** @deprecated Declare expected failures on defineAction or defineWorkflow instead. */
-export class InvocationError extends Error {
-    code;
-    name = 'InvocationError';
-    reason;
-    constructor(code, message, options = {}) {
-        super(message, options);
-        this.code = code;
-        this.reason =
-            options.reason === undefined
-                ? undefined
-                : errors.acceptReason(options.reason, 'InvocationError reason');
-    }
-}
 export class InvocationDefect extends Error {
     code;
     name = 'InvocationDefect';
@@ -62,9 +48,6 @@ export function projectError(input) {
             ? input
             : protocolError('INTERNAL_ERROR', 'Internal application error.');
     }
-    if (input instanceof InvocationError) {
-        return protocolError('INTERNAL_ERROR', 'Internal application error.');
-    }
     if (input instanceof ResponseError) {
         if (!PUBLIC_ERROR_CODES.has(input.code)) {
             return protocolError('BACKEND_UNAVAILABLE', 'Dependency Kernel returned invalid error evidence.');

package/dist/execution/invocation/result/index.d.ts

@@ -1,4 +1,4 @@
-export { inputError, InvocationDefect, InvocationError, projectError, protocolError, } from './errors.js';
-export type { InvocationDefectCode, InvocationErrorCode } from './errors.js';
+export { inputError, InvocationDefect, projectError, protocolError } from './errors.js';
+export type { InvocationDefectCode } from './errors.js';
 export { project } from './project.js';
 export { validateInput, validateOutput } from './validate.js';

package/dist/execution/invocation/result/index.js

@@ -1,3 +1,3 @@
-export { inputError, InvocationDefect, InvocationError, projectError, protocolError, } from './errors.js';
+export { inputError, InvocationDefect, projectError, protocolError } from './errors.js';
 export { project } from './project.js';
 export { validateInput, validateOutput } from './validate.js';

package/dist/execution/invocation/result/project.js

@@ -2,6 +2,10 @@ import { InvocationDefect } from './errors.js';
 import { validateOutput } from './validate.js';
 const MEDIA_TYPE = /^[!#$%&'*+.^_`|~0-9A-Za-z-]+\/[!#$%&'*+.^_`|~0-9A-Za-z-]+$/u;
 const HEADER_NAME = /^[!#$%&'*+.^_`|~0-9A-Za-z-]+$/u;
+const BUFFERED_FIELDS = new Set(['body', 'mediaType', 'status', 'headers']);
+const STREAMING_FIELDS = new Set([...BUFFERED_FIELDS, 'length', 'delivery']);
+/** Largest delay a host timer accepts; the Server rejects a longer delivery budget. */
+const MAXIMUM_TIMER_MS = 2_147_483_647;
 export function project(callable, output) {
     switch (callable.output.mode) {
         case 'value':
@@ -72,7 +76,8 @@ function binary(input) {
     if (input === null || typeof input !== 'object' || Array.isArray(input))
         invalidBinary();
     const value = input;
-    if (Reflect.ownKeys(input).some((key) => key !== 'body' && key !== 'mediaType' && key !== 'status' && key !== 'headers') ||
+    const fields = isBytes(value.body) ? BUFFERED_FIELDS : STREAMING_FIELDS;
+    if (Reflect.ownKeys(input).some((key) => typeof key !== 'string' || !fields.has(key)) ||
         (!isBytes(value.body) && !isAsyncBytes(value.body)) ||
         typeof value.mediaType !== 'string' ||
         !MEDIA_TYPE.test(value.mediaType) ||
@@ -89,13 +94,48 @@ function binary(input) {
             ...(headers === undefined ? {} : { headers }),
         });
     }
+    const length = streamingLength(value.length);
+    const delivery = deliveryBudget(value.delivery);
     return Object.freeze({
         body: new InvocationByteStream(value.body),
         mediaType: value.mediaType,
+        // The declared length is the only count a Client verifies a streaming delivery against.
+        ...(length === undefined ? {} : { length }),
+        ...(delivery === undefined ? {} : { delivery }),
         ...(value.status === undefined ? {} : { status: value.status }),
         ...(headers === undefined ? {} : { headers }),
     });
 }
+function streamingLength(input) {
+    if (input === undefined)
+        return undefined;
+    if (typeof input !== 'number' || !Number.isSafeInteger(input) || input < 0)
+        invalidBinary();
+    return input;
+}
+function deliveryBudget(input) {
+    if (input === undefined)
+        return undefined;
+    if (input === null || typeof input !== 'object' || Array.isArray(input))
+        invalidBinary();
+    const value = input;
+    if (Reflect.ownKeys(input).some((key) => key !== 'maximumDurationMs' && key !== 'idleTimeoutMs') ||
+        !isTimerDuration(value.maximumDurationMs) ||
+        !isTimerDuration(value.idleTimeoutMs) ||
+        value.idleTimeoutMs > value.maximumDurationMs) {
+        invalidBinary();
+    }
+    return Object.freeze({
+        maximumDurationMs: value.maximumDurationMs,
+        idleTimeoutMs: value.idleTimeoutMs,
+    });
+}
+function isTimerDuration(input) {
+    return (typeof input === 'number' &&
+        Number.isSafeInteger(input) &&
+        input > 0 &&
+        input <= MAXIMUM_TIMER_MS);
+}
 class InvocationByteStream {
     source;
     consumed = false;

package/dist/execution/node/serve.d.ts

@@ -1,4 +1,4 @@
-import type { ServedApplication } from '../serve.js';
+import type { ServedDomain } from '../serve.js';
 import type { NodeListener } from './listener.js';
 export interface NodeOptions<Environment> {
     readonly environment: Environment;
@@ -6,4 +6,4 @@ export interface NodeOptions<Environment> {
     readonly hostname?: string;
 }
 /** Listen on Node around one already composed provider-neutral served application. */
-export declare function listen<Environment>(application: ServedApplication<Environment>, options: NodeOptions<Environment>): Promise<NodeListener>;
+export declare function listen<Environment>(application: ServedDomain<Environment>, options: NodeOptions<Environment>): Promise<NodeListener>;

package/dist/execution/node/serve.js

@@ -7,7 +7,7 @@ export async function listen(application, options) {
         typeof application.fetch !== 'function' ||
         typeof application.drain !== 'function' ||
         typeof application.close !== 'function') {
-        throw new TypeError('Node listener requires a served Application.');
+        throw new TypeError('Node listener requires a served Domain.');
     }
     const config = admit(options);
     let server;

package/dist/execution/runtime/index.d.ts

@@ -3,3 +3,4 @@ export { initialize, type InitializedRuntime } from './initialize.js';
 export { integrations } from './integrations.js';
 export { load, type LoadedRuntime } from './load.js';
 export { providers } from './providers.js';
+export { isServedRelease, serving, type ServedRelease, type Serving } from './release.js';

package/dist/execution/runtime/index.js

@@ -3,3 +3,4 @@ export { initialize } from './initialize.js';
 export { integrations } from './integrations.js';
 export { load } from './load.js';
 export { providers } from './providers.js';
+export { isServedRelease, serving } from './release.js';

package/dist/execution/runtime/load.d.ts

@@ -2,13 +2,13 @@ import type { Domain } from '@astrale-os/kernel-dsl/v1/domain';
 import type { DomainSchema, DomainOf } from '@astrale-os/kernel-dsl/v1/schema';
 import type { RuntimeRegistry } from '../../application/runtime/index.js';
 import type { Build } from '../../deployment/build/build.js';
-import type { Release } from '../../deployment/release/release.js';
+import type { ServedRelease } from './release.js';
 type DomainOfBuild<BuildValue extends Build> = BuildValue extends Build<infer Schema extends DomainSchema, object> ? Extract<DomainOf<Schema>, Domain> : Domain;
 export interface LoadedRuntime<BuildValue extends Build = Build> {
-    readonly release: Release<BuildValue>;
+    readonly release: ServedRelease<BuildValue>;
     readonly domain: DomainOfBuild<BuildValue>;
     readonly registry: RuntimeRegistry;
 }
 /** Load one execution Runtime from the exact evidence retained by its admitted Build. */
-export declare function load<const BuildValue extends Build>(release: Release<BuildValue>): LoadedRuntime<BuildValue>;
+export declare function load<const BuildValue extends Build>(release: ServedRelease<BuildValue>): LoadedRuntime<BuildValue>;
 export {};

package/dist/execution/runtime/load.js

@@ -1,10 +1,11 @@
 import { evidenceOf } from '../../deployment/build/admission.js';
-import { isRelease } from '../../deployment/release/admission.js';
 import { capture } from './admission.js';
+import { isServedRelease } from './release.js';
 /** Load one execution Runtime from the exact evidence retained by its admitted Build. */
 export function load(release) {
-    if (!isRelease(release))
+    if (!isServedRelease(release)) {
         throw new TypeError('Runtime loading requires an admitted Release.');
+    }
     const evidence = evidenceOf(release.build);
     const domain = evidence.domain;
     const { registry } = evidence;

package/dist/execution/runtime/release.d.ts

@@ -0,0 +1,17 @@
+import type * as release from '@astrale-os/kernel-protocol/release';
+import type { Build } from '../../deployment/build/build.js';
+import type { Release } from '../../deployment/release/release.js';
+import type { IssuerId } from '../../platform/auth/index.js';
+/** The DomainRelease v4 served by one immutable deployment. */
+export type ServedRelease<BuildValue extends Build = Build> = Release<BuildValue>;
+/** Where and as whom one served Release answers, and the document it serves. */
+export interface Serving {
+    /** Domain identity issuer: this deployment's URL. */
+    readonly issuer: IssuerId;
+    /** Public origin the Server answers at: this deployment's URL. */
+    readonly publicUrl: IssuerId;
+    /** The document served at release.json. */
+    readonly document: release.DomainRelease;
+}
+export declare function isServedRelease(input: unknown): input is ServedRelease;
+export declare function serving(served: ServedRelease): Serving;

package/dist/execution/runtime/release.js

@@ -0,0 +1,7 @@
+import { isRelease } from '../../deployment/release/admission.js';
+export function isServedRelease(input) {
+    return isRelease(input);
+}
+export function serving(served) {
+    return Object.freeze({ issuer: served.url, publicUrl: served.url, document: served.document });
+}

package/dist/execution/serve.d.ts

@@ -1,10 +1,12 @@
 import type { ServerCloseOptions } from '@astrale-os/kernel-server';
-import type { publication } from '@astrale-os/kernel-server';
+import type { release } from '@astrale-os/kernel-server';
 import type { Runtime } from '../application/runtime/index.js';
 import type { WorkflowRunner } from '../application/workflow/runner/index.js';
+import type { DeploymentCache } from './cache/index.js';
 import type { Identity } from './identity/index.js';
 import type { ReleaseLoader } from './service/index.js';
 import type { ServiceServerOptions } from './service/index.js';
+import type { DurableServingProvider } from './workflows/index.js';
 export interface ExecutionContext {
     waitUntil(promise: Promise<unknown>): void;
     readonly sleep?: (durationMs: number) => Promise<void>;
@@ -15,13 +17,25 @@ export interface ServeInput<Environment, RuntimeValue extends Runtime, RuntimeEn
     identity(environment: Environment): Identity;
     readonly initialize?: (environment: Environment) => RuntimeEnvironment;
     readonly server: ServiceServerOptions;
-    readonly delivery?: (environment: Environment) => publication.delivery.Provider | undefined;
+    readonly delivery?: (environment: Environment) => release.delivery.Provider | undefined;
     readonly workflows?: WorkflowRunner;
+    /**
+     * The deployment's cache of disposable entries, created once with the Service. It keeps the
+     * admissions of callables whose Schema declares an admission age, so that a call within that age
+     * skips its `Function.admit` round trip. Defaults to a bounded memory cache of this process or
+     * isolate; `false` keeps nothing, and every call is admitted by its source Kernel.
+     */
+    readonly cache?: ((environment: Environment) => DeploymentCache) | false;
+    /**
+     * Serve durable Workflows to the workflow engine; required when the Release declares any.
+     * Undefined for an environment that names no engine: engine requests are then refused.
+     */
+    readonly durable?: (environment: Environment, request: Request) => ReturnType<DurableServingProvider>;
 }
-export interface ServedApplication<Environment> {
+export interface ServedDomain<Environment> {
     fetch(request: Request, environment: Environment, context?: ExecutionContext): Promise<Response>;
     drain(): void;
     close(options: ServerCloseOptions): Promise<void>;
 }
 /** Create one provider-neutral Fetch entrypoint around a lazily initialized current Service. */
-export declare function serve<Environment, RuntimeValue extends Runtime, RuntimeEnvironment = Environment>(input: ServeInput<Environment, RuntimeValue, RuntimeEnvironment>): ServedApplication<Environment>;
+export declare function serve<Environment, RuntimeValue extends Runtime, RuntimeEnvironment = Environment>(input: ServeInput<Environment, RuntimeValue, RuntimeEnvironment>): ServedDomain<Environment>;

package/dist/execution/serve.js

@@ -1,3 +1,4 @@
+import { memoryCache } from './cache/index.js';
 import { createService } from './service/index.js';
 /** Create one provider-neutral Fetch entrypoint around a lazily initialized current Service. */
 export function serve(input) {
@@ -11,6 +12,9 @@ export function serve(input) {
             return service;
         if (typeof input.identity !== 'function')
             invalid();
+        if (input.cache !== undefined && input.cache !== false && typeof input.cache !== 'function') {
+            invalid();
+        }
         const runtimeEnvironment = input.initialize === undefined
             ? environment
             : input.initialize(environment);
@@ -22,6 +26,12 @@ export function serve(input) {
             server: input.server,
             ...(input.delivery === undefined ? {} : { delivery: input.delivery(environment) }),
             ...(input.workflows === undefined ? {} : { workflows: input.workflows }),
+            ...(input.cache === false
+                ? {}
+                : { cache: input.cache === undefined ? memoryCache() : input.cache(environment) }),
+            ...(input.durable === undefined
+                ? {}
+                : { durable: (request) => input.durable(environment, request) }),
         });
         if (drained)
             service.drain();

package/dist/execution/service/create.js

@@ -3,11 +3,12 @@ import { isRuntime } from '../../application/runtime/index.js';
 import { invocationPath } from '../../deployment/release/invocation.js';
 import { identity as captureIdentity } from '../identity/index.js';
 import { createHandler } from '../invocation/index.js';
-import { initialize, load } from '../runtime/index.js';
+import { initialize, load, serving as servedRelease } from '../runtime/index.js';
+import { createDurableReceiver, durableServing, isCanonicalDurableRequest, isDurableRequest, } from '../workflows/index.js';
 import { initialization } from './initialization.js';
 import { lifecycle } from './lifecycle.js';
-import { delivery, installation, source } from './publication/index.js';
 import { loadRelease } from './release.js';
+import { delivery, installation, source } from './serving/index.js';
 /** Create one lazy running Service around the exact current Release. */
 export function createService(input) {
     if (input === null || typeof input !== 'object' || Array.isArray(input))
@@ -16,24 +17,28 @@ export function createService(input) {
         throw new TypeError('Service Runtime is not admitted.');
     const selectedIdentity = captureIdentity(input.identity);
     const providedDelivery = delivery(input.delivery);
+    const durable = input.durable;
+    // Preserve eager admission for an already loaded engine; providers stay outside ordinary startup.
+    const serving = durable === undefined || typeof durable === 'function' ? undefined : durableServing(durable);
     let running;
     const state = lifecycle(() => running?.server.drain());
     const realized = initialization(async () => {
         const release = await loadRelease(input.load, input.environment, input.runtime);
-        if (release.addressing.issuer !== selectedIdentity.issuer) {
+        const served = servedRelease(release);
+        if (served.issuer !== selectedIdentity.issuer) {
             throw new TypeError('Service Identity differs from Release Addressing.');
         }
         if (selectedIdentity.subject !== release.build.schema.compiled.root.origin) {
             throw new TypeError('Service Identity subject differs from the Release Domain origin.');
         }
-        const selectedDelivery = providedDelivery ?? selectedIdentity.delivery(release.publication);
-        installation(release, selectedDelivery);
+        const selectedDelivery = providedDelivery ?? selectedIdentity.delivery(served.document);
+        installation(served.document, selectedDelivery);
         const loaded = load(release);
         const runtime = await initialize(loaded, input.environment);
         const prepared = prepareServer({
             ...serverOptions(input.server),
             path: invocationPath(),
-            publicOrigin: release.addressing.publicUrl,
+            publicOrigin: served.publicUrl,
             invocation: {
                 source: selectedIdentity.issuer,
                 next: () => crypto.randomUUID(),
@@ -42,19 +47,34 @@ export function createService(input) {
             ...(selectedIdentity.tokenExchange === undefined
                 ? {}
                 : { tokenExchange: selectedIdentity.tokenExchange }),
-            publication: source(loaded),
+            ...source(loaded),
             ...(selectedDelivery === undefined ? {} : { delivery: selectedDelivery }),
         });
         const server = prepared.create(createHandler({
             runtime,
             authority: selectedIdentity,
             ...(input.workflows === undefined ? {} : { workflows: input.workflows }),
+            ...(input.cache === undefined ? {} : { cache: input.cache }),
         }));
         running = Object.freeze({ release, runtime, server });
         if (!state.accepting)
             server.drain();
         return running;
     });
+    const receiver = initialization(async (request) => {
+        const selected = typeof durable === 'function' ? await durable(request) : undefined;
+        const configuration = serving ?? (selected === undefined ? undefined : durableServing(selected));
+        if (configuration === undefined)
+            return undefined;
+        const { runtime } = await realized.get();
+        return createDurableReceiver({
+            workflows: runtime.loaded.registry.workflows,
+            domain: runtime.loaded.domain,
+            identity: selectedIdentity,
+            serving: configuration,
+            integrations: runtime.clients,
+        });
+    });
     let closing;
     const service = Object.freeze({
         async fetch(request, host) {
@@ -63,6 +83,15 @@ export function createService(input) {
             const ready = await realized.get();
             if (!state.accepting)
                 return unavailable();
+            // Without engine configuration only durable calls fail: the engine's discovery is refused.
+            if (isDurableRequest(request)) {
+                if (!isCanonicalDurableRequest(request))
+                    return notServed();
+                const selected = await receiver.get(request);
+                if (!state.accepting)
+                    return unavailable();
+                return selected?.fetch(request) ?? notServed();
+            }
             return ready.server.app.fetch(request, host);
         },
         async release() {
@@ -95,6 +124,7 @@ function serverOptions(input) {
         'issuer',
         'publicOrigin',
         'tokenExchange',
+        'release',
         'publication',
         'delivery',
         'handler',
@@ -104,6 +134,12 @@ function serverOptions(input) {
     }
     return input;
 }
+function notServed() {
+    return new Response('{"error":"This deployment serves no durable Workflows."}', {
+        status: 404,
+        headers: { 'content-type': 'application/json', 'cache-control': 'no-store' },
+    });
+}
 function unavailable() {
     return new Response('{"error":"Service is draining."}', {
         status: 503,

package/dist/execution/service/initialization.d.ts

@@ -1,6 +1,6 @@
-export interface Initialization<Value> {
-    get(): Promise<Value>;
+export interface Initialization<Value, Arguments extends readonly unknown[] = []> {
+    get(...args: Arguments): Promise<Value>;
     current(): Promise<Value> | undefined;
 }
-/** Share one successful initialization and allow a later retry after failure. */
-export declare function initialization<Value>(create: () => Promise<Value>): Initialization<Value>;
+/** Share an initialized value; absence and failure leave initialization retryable. */
+export declare function initialization<Value, Arguments extends readonly unknown[] = []>(create: (...args: Arguments) => Promise<Value>): Initialization<Value, Arguments>;

package/dist/execution/service/initialization.js

@@ -1,18 +1,27 @@
-/** Share one successful initialization and allow a later retry after failure. */
+/** Share an initialized value; absence and failure leave initialization retryable. */
 export function initialization(create) {
-    let current;
+    let state;
+    const get = (...args) => {
+        if (state?.phase === 'ready')
+            return state.promise;
+        if (state !== undefined) {
+            // Absence can depend on the initializing request. A waiter gets its own eligibility check.
+            return state.promise.then((value) => (value === undefined ? get(...args) : value));
+        }
+        const pending = create(...args).then((value) => {
+            if (state?.promise === pending)
+                state = value === undefined ? undefined : { phase: 'ready', promise: pending };
+            return value;
+        }, (cause) => {
+            if (state?.promise === pending)
+                state = undefined;
+            throw cause;
+        });
+        state = { phase: 'pending', promise: pending };
+        return pending;
+    };
     return Object.freeze({
-        get() {
-            if (current !== undefined)
-                return current;
-            const pending = create().catch((cause) => {
-                if (current === pending)
-                    current = undefined;
-                throw cause;
-            });
-            current = pending;
-            return pending;
-        },
-        current: () => current,
+        get,
+        current: () => state?.promise,
     });
 }

package/dist/execution/service/release.d.ts

@@ -1,7 +1,7 @@
 import type { Runtime } from '../../application/runtime/index.js';
 import type { Build } from '../../deployment/build/build.js';
-import type { Release } from '../../deployment/release/release.js';
 import type { schema } from '../../platform/schema/index.js';
-export type ReleaseForRuntime<RuntimeValue extends Runtime> = Release<Build<schema.DomainSchema, RuntimeValue>>;
+import type { ServedRelease } from '../runtime/index.js';
+export type ReleaseForRuntime<RuntimeValue extends Runtime> = ServedRelease<Build<schema.DomainSchema, RuntimeValue>>;
 export type ReleaseLoader<Environment, RuntimeValue extends Runtime = Runtime> = (environment: Environment) => ReleaseForRuntime<RuntimeValue> | Promise<ReleaseForRuntime<RuntimeValue>>;
 export declare function loadRelease<Environment, RuntimeValue extends Runtime>(load: ReleaseLoader<Environment, RuntimeValue>, environment: Environment, runtime: RuntimeValue): Promise<ReleaseForRuntime<RuntimeValue>>;

package/dist/execution/service/release.js

@@ -1,10 +1,11 @@
-import { isRelease } from '../../deployment/release/admission.js';
+import { isServedRelease } from '../runtime/index.js';
 export async function loadRelease(load, environment, runtime) {
     if (typeof load !== 'function')
         throw new TypeError('Service Release loader is invalid.');
     const release = await load(environment);
-    if (!isRelease(release))
+    if (!isServedRelease(release)) {
         throw new TypeError('Service loader returned an unadmitted Release.');
+    }
     if (release.build.runtime !== runtime) {
         throw new TypeError('Service Release Runtime differs from the generated entrypoint Runtime.');
     }

package/dist/execution/service/service.d.ts

@@ -1,23 +1,38 @@
 import type { ApplicationHost, ServerCloseOptions, ServerOptions } from '@astrale-os/kernel-server';
-import type { publication } from '@astrale-os/kernel-server';
+import type { release } from '@astrale-os/kernel-server';
 import type { Runtime } from '../../application/runtime/index.js';
 import type { WorkflowRunner } from '../../application/workflow/runner/index.js';
-import type { Release } from '../../deployment/release/index.js';
+import type { DeploymentCache } from '../cache/index.js';
 import type { Identity } from '../identity/index.js';
+import type { ServedRelease } from '../runtime/index.js';
+import type { DurableServing, DurableServingProvider } from '../workflows/index.js';
 import type { ReleaseLoader } from './release.js';
-export type ServiceServerOptions = Omit<ServerOptions, 'path' | 'invocation' | 'issuer' | 'publicOrigin' | 'tokenExchange' | 'publication' | 'delivery'>;
+export type ServiceServerOptions = Omit<ServerOptions, 'path' | 'invocation' | 'issuer' | 'publicOrigin' | 'tokenExchange' | 'release' | 'delivery'>;
 export interface ServiceInput<Environment, RuntimeValue extends Runtime = Runtime> {
     readonly runtime: RuntimeValue;
     readonly environment: Environment;
     readonly load: ReleaseLoader<Environment, RuntimeValue>;
     readonly identity: Identity;
     readonly server: ServiceServerOptions;
-    readonly delivery?: publication.delivery.Provider;
+    /**
+     * Answers Delivery v2 over an immutable deployment's Release. Defaults to the Identity's own.
+     */
+    readonly delivery?: release.delivery.Provider;
     readonly workflows?: WorkflowRunner;
+    /**
+     * Where admissions of callables that declare an admission age are kept for the next calls.
+     * Absent: every call is admitted by its source Kernel.
+     */
+    readonly cache?: DeploymentCache;
+    /**
+     * Serve the Release's durable Workflows. A provider is resolved on the first engine request,
+     * shared by concurrent requests, and retried after initialization fails.
+     */
+    readonly durable?: DurableServing | DurableServingProvider;
 }
 export interface Service {
     fetch(request: Request, host?: ApplicationHost): Promise<Response>;
-    release(): Promise<Release>;
+    release(): Promise<ServedRelease>;
     drain(): void;
     close(options: ServerCloseOptions): Promise<void>;
 }

package/dist/execution/service/serving/delivery.d.ts

@@ -0,0 +1,5 @@
+import type { release } from '@astrale-os/kernel-server';
+/**
+ * Capture an explicit Delivery v2 Provider over an immutable deployment's Release.
+ */
+export declare function delivery(input: release.delivery.Provider | undefined): release.delivery.Provider | undefined;

package/dist/execution/service/{publication → serving}/delivery.js

@@ -1,8 +1,11 @@
+/**
+ * Capture an explicit Delivery v2 Provider over an immutable deployment's Release.
+ */
 export function delivery(input) {
     if (input === undefined)
         return undefined;
     if (input === null || typeof input !== 'object' || typeof input.create !== 'function') {
-        throw new TypeError('Publication delivery Provider is invalid.');
+        throw new TypeError('Delivery Provider is invalid.');
     }
     const create = input.create.bind(input);
     return Object.freeze({ create });

package/dist/execution/service/{publication → serving}/index.d.ts

@@ -1,3 +1,3 @@
 export { delivery } from './delivery.js';
 export { installation } from './installation.js';
-export { source } from './source.js';
+export { source, type ServingSource } from './source.js';

package/dist/execution/service/serving/installation.d.ts

@@ -0,0 +1,4 @@
+import type { release } from '@astrale-os/kernel-server';
+import type { Serving } from '../../runtime/index.js';
+/** A served document advertises Delivery exactly when the Service has a Provider for it. */
+export declare function installation(served: Serving['document'], provider: release.delivery.Provider | undefined): void;

package/dist/execution/service/serving/installation.js

@@ -0,0 +1,9 @@
+/** A served document advertises Delivery exactly when the Service has a Provider for it. */
+export function installation(served, provider) {
+    const advertised = served.delivery !== undefined;
+    if (advertised !== (provider !== undefined)) {
+        throw new TypeError(advertised
+            ? 'Release advertises delivery without a Provider.'
+            : 'Delivery Provider has no Release endpoint.');
+    }
+}

package/dist/execution/service/serving/source.d.ts

@@ -0,0 +1,11 @@
+import type { ReleaseSource } from '@astrale-os/kernel-server';
+import type { LoadedRuntime } from '../../runtime/index.js';
+/** The one source a Kernel Server serves, as `ServerOptions` takes it. */
+export type ServingSource = {
+    readonly release: ReleaseSource;
+};
+/**
+ * Prepare, once, the exact snapshot the loaded Release serves: an immutable deployment serves its
+ * DomainRelease through prepareReleaseSnapshot, which admits routing naming that exact release.
+ */
+export declare function source(runtime: LoadedRuntime): ServingSource;

package/dist/execution/service/serving/source.js

@@ -0,0 +1,15 @@
+import { prepareReleaseSnapshot } from '@astrale-os/kernel-server';
+/**
+ * Prepare, once, the exact snapshot the loaded Release serves: an immutable deployment serves its
+ * DomainRelease through prepareReleaseSnapshot, which admits routing naming that exact release.
+ */
+export function source(runtime) {
+    const served = runtime.release;
+    const snapshot = prepareReleaseSnapshot({
+        release: served.document,
+        bundle: served.build.schema.bundle.bytes(),
+        table: served.routes,
+        domain: runtime.domain,
+    });
+    return Object.freeze({ release: Object.freeze({ current: () => snapshot }) });
+}