@astrale-os/sdk 0.5.0-beta.2 → 0.5.0-beta.21

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

@@ -0,0 +1,111 @@
+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;
+export function project(callable, output) {
+    switch (callable.output.mode) {
+        case 'value':
+            return Object.freeze({ kind: 'value', value: validateOutput(callable, output) });
+        case 'stream':
+            return Object.freeze({ kind: 'stream', stream: stream(callable, output) });
+        case 'binary':
+            return Object.freeze({ kind: 'binary', value: binary(output) });
+    }
+}
+function stream(callable, input) {
+    if (input === null ||
+        (typeof input !== 'object' && typeof input !== 'function') ||
+        typeof input[Symbol.asyncIterator] !==
+            'function') {
+        throw new InvocationDefect('INVOCATION_OUTPUT_INVALID', 'Streaming Callable output must be an AsyncIterable.');
+    }
+    return new InvocationStream(input[Symbol.asyncIterator](), (value) => validateOutput(callable, value));
+}
+class InvocationStream {
+    source;
+    admit;
+    consumed = false;
+    terminal = false;
+    stopping;
+    constructor(source, admit) {
+        this.source = source;
+        this.admit = admit;
+    }
+    [Symbol.asyncIterator]() {
+        if (this.consumed) {
+            throw new InvocationDefect('INVOCATION_RESULT_CONTRACT_VIOLATION', 'Callable stream supports exactly one consumer.');
+        }
+        this.consumed = true;
+        return Object.freeze({ next: () => this.next(), return: () => this.return() });
+    }
+    async cancel() {
+        await this.stop();
+    }
+    async next() {
+        if (this.terminal)
+            return { done: true, value: undefined };
+        const next = await this.source.next();
+        if (next.done === true) {
+            this.terminal = true;
+            return { done: true, value: undefined };
+        }
+        return { done: false, value: this.admit(next.value) };
+    }
+    async return() {
+        await this.stop();
+        return { done: true, value: undefined };
+    }
+    stop() {
+        return (this.stopping ??= this.close());
+    }
+    async close() {
+        if (this.terminal)
+            return;
+        this.terminal = true;
+        await this.source.return?.();
+    }
+}
+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 !== 'headers') ||
+        !(value.body instanceof Uint8Array) ||
+        typeof value.mediaType !== 'string' ||
+        !MEDIA_TYPE.test(value.mediaType)) {
+        invalidBinary();
+    }
+    const headers = binaryHeaders(value.headers);
+    return Object.freeze({
+        body: new Uint8Array(value.body),
+        mediaType: value.mediaType,
+        ...(headers === undefined ? {} : { headers }),
+    });
+}
+function binaryHeaders(input) {
+    if (input === undefined)
+        return undefined;
+    if (input === null || typeof input !== 'object' || Array.isArray(input))
+        invalidBinary();
+    const headers = {};
+    for (const name of Reflect.ownKeys(input)) {
+        if (typeof name !== 'string')
+            invalidBinary();
+        const value = input[name];
+        const lower = name.toLowerCase();
+        if (typeof value !== 'string' ||
+            !HEADER_NAME.test(name) ||
+            /[\r\n]/u.test(value) ||
+            Object.hasOwn(headers, lower) ||
+            lower === 'content-length' ||
+            lower === 'transfer-encoding' ||
+            lower === 'connection') {
+            invalidBinary();
+        }
+        headers[lower] = value;
+    }
+    return Object.keys(headers).length === 0 ? undefined : Object.freeze(headers);
+}
+function invalidBinary() {
+    throw new InvocationDefect('INVOCATION_OUTPUT_INVALID', 'Binary Callable output is invalid.');
+}

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

@@ -0,0 +1,4 @@
+import type { ResolvedCallable } from '../../../application/action/index.js';
+import type { Value } from '../../../platform/value/index.js';
+export declare function validateInput(callable: ResolvedCallable, input: unknown): void;
+export declare function validateOutput(callable: ResolvedCallable, input: unknown): Value;

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

@@ -0,0 +1,25 @@
+import * as portable from '../../../platform/value/index.js';
+import { inputError, InvocationDefect } from './errors.js';
+export function validateInput(callable, input) {
+    const diagnostics = callable.validateInput(input);
+    if (diagnostics.length > 0)
+        throw inputError(callable.key, diagnostics);
+}
+export function validateOutput(callable, input) {
+    let value;
+    try {
+        value = portable.accept(input);
+    }
+    catch (cause) {
+        if (cause instanceof portable.BoundaryError) {
+            throw new InvocationDefect('INVOCATION_OUTPUT_INVALID', 'Callable output is not portable.', {
+                cause,
+            });
+        }
+        throw cause;
+    }
+    if (callable.validateOutput(value).length > 0) {
+        throw new InvocationDefect('INVOCATION_OUTPUT_INVALID', 'Callable output is invalid.');
+    }
+    return value;
+}

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

@@ -0,0 +1,2 @@
+export { listen, type NodeOptions } from './serve.js';
+export type { NodeListener } from './listener.js';

package/dist/execution/node/index.js

@@ -0,0 +1 @@
+export { listen } from './serve.js';

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

@@ -0,0 +1,10 @@
+import type { ServerCloseOptions } from '@astrale-os/kernel-server';
+import type { ServerType } from '@hono/node-server';
+export interface NodeListener {
+    readonly port: number;
+    close(options: ServerCloseOptions): Promise<void>;
+}
+export declare function listener(server: ServerType, port: number, lifecycle: {
+    drain(): void;
+    close(options: ServerCloseOptions): Promise<void>;
+}): NodeListener;

package/dist/execution/node/listener.js

@@ -0,0 +1,25 @@
+export function listener(server, port, lifecycle) {
+    let closing;
+    return Object.freeze({
+        port,
+        close(options) {
+            if (closing !== undefined)
+                return closing;
+            lifecycle.drain();
+            closing = settle(closeServer(server), lifecycle.close(options));
+            return closing;
+        },
+    });
+}
+function closeServer(server) {
+    return new Promise((resolve, reject) => {
+        server.close((cause) => (cause === undefined ? resolve() : reject(cause)));
+    });
+}
+async function settle(server, service) {
+    const [serverResult, serviceResult] = await Promise.allSettled([server, service]);
+    if (serverResult.status === 'rejected')
+        throw serverResult.reason;
+    if (serviceResult.status === 'rejected')
+        throw serviceResult.reason;
+}

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

@@ -0,0 +1,9 @@
+import type { ServedApplication } from '../serve.js';
+import type { NodeListener } from './listener.js';
+export interface NodeOptions<Environment> {
+    readonly environment: Environment;
+    readonly port?: number;
+    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>;

package/dist/execution/node/serve.js

@@ -0,0 +1,44 @@
+import { serve as honoServe } from '@hono/node-server';
+import { listener } from './listener.js';
+/** Listen on Node around one already composed provider-neutral served application. */
+export async function listen(application, options) {
+    if (application === null ||
+        typeof application !== 'object' ||
+        typeof application.fetch !== 'function' ||
+        typeof application.drain !== 'function' ||
+        typeof application.close !== 'function') {
+        throw new TypeError('Node listener requires a served Application.');
+    }
+    const config = admit(options);
+    let server;
+    const address = await new Promise((resolve, reject) => {
+        const failed = (cause) => reject(cause);
+        server = honoServe({
+            fetch: (request) => application.fetch(request, config.environment),
+            ...(config.port === undefined ? {} : { port: config.port }),
+            ...(config.hostname === undefined ? {} : { hostname: config.hostname }),
+        }, (info) => {
+            server.off('error', failed);
+            resolve(info);
+        });
+        server.once('error', failed);
+    });
+    return listener(server, address.port, application);
+}
+function admit(input) {
+    if (input === null ||
+        typeof input !== 'object' ||
+        Array.isArray(input) ||
+        !Object.hasOwn(input, 'environment') ||
+        Reflect.ownKeys(input).some((key) => key !== 'environment' && key !== 'port' && key !== 'hostname')) {
+        throw new TypeError('Node listener options are invalid.');
+    }
+    if (input.port !== undefined &&
+        (!Number.isSafeInteger(input.port) || input.port < 0 || input.port > 65_535)) {
+        throw new TypeError('Node listener port must be an integer between 0 and 65535.');
+    }
+    if (input.hostname !== undefined && input.hostname.length === 0) {
+        throw new TypeError('Node listener hostname must not be empty.');
+    }
+    return Object.freeze({ ...input });
+}

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

@@ -0,0 +1,3 @@
+import type { LoadedRuntime } from './load.js';
+export declare function capture<RuntimeValue extends LoadedRuntime>(runtime: RuntimeValue): RuntimeValue;
+export declare function isLoadedRuntime(input: unknown): input is LoadedRuntime;

package/dist/execution/runtime/admission.js

@@ -0,0 +1,8 @@
+const admittedRuntimes = new WeakSet();
+export function capture(runtime) {
+    admittedRuntimes.add(runtime);
+    return runtime;
+}
+export function isLoadedRuntime(input) {
+    return input !== null && typeof input === 'object' && admittedRuntimes.has(input);
+}

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

@@ -0,0 +1,5 @@
+export { capture, isLoadedRuntime } from './admission.js';
+export { initialize, type InitializedRuntime } from './initialize.js';
+export { integrations } from './integrations.js';
+export { load, type LoadedRuntime } from './load.js';
+export { providers } from './providers.js';

package/dist/execution/runtime/index.js

@@ -0,0 +1,5 @@
+export { capture, isLoadedRuntime } from './admission.js';
+export { initialize } from './initialize.js';
+export { integrations } from './integrations.js';
+export { load } from './load.js';
+export { providers } from './providers.js';

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

@@ -0,0 +1,11 @@
+import type { IntegrationClientFactory, Integrations } from '../../application/integration/index.js';
+import type { RuntimeInitialization } from '../../application/runtime/index.js';
+import type { Build } from '../../deployment/build/index.js';
+import type { LoadedRuntime } from './load.js';
+export interface InitializedRuntime<BuildValue extends Build = Build> {
+    readonly loaded: LoadedRuntime<BuildValue>;
+    readonly initialization: RuntimeInitialization;
+    readonly clients: IntegrationClientFactory<Integrations>;
+}
+/** Initialize one loaded Runtime; Service owns one-shot promise sharing and retry policy. */
+export declare function initialize<const BuildValue extends Build>(loaded: LoadedRuntime<BuildValue>, environment: unknown): Promise<InitializedRuntime<BuildValue>>;

package/dist/execution/runtime/initialize.js

@@ -0,0 +1,13 @@
+import { isLoadedRuntime } from './admission.js';
+import { integrations } from './integrations.js';
+import { providers } from './providers.js';
+/** Initialize one loaded Runtime; Service owns one-shot promise sharing and retry policy. */
+export async function initialize(loaded, environment) {
+    if (!isLoadedRuntime(loaded)) {
+        throw new TypeError('Runtime initialization requires an admitted loaded Runtime.');
+    }
+    const runtime = loaded.release.build.runtime;
+    const initialization = providers(await runtime.initialize(environment));
+    const clients = integrations(runtime.integrations, initialization.providers);
+    return Object.freeze({ loaded, initialization, clients });
+}

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

@@ -0,0 +1,3 @@
+import type { IntegrationClientFactory, Integrations } from '../../application/integration/index.js';
+/** Bind exact initialized Providers once for invocation-scoped Integration clients. */
+export declare function integrations(definitions: Integrations, providers: unknown): IntegrationClientFactory<Integrations>;

package/dist/execution/runtime/integrations.js

@@ -0,0 +1,5 @@
+import { bindProviders } from '../../application/integration/index.js';
+/** Bind exact initialized Providers once for invocation-scoped Integration clients. */
+export function integrations(definitions, providers) {
+    return bindProviders(definitions, providers);
+}

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

@@ -0,0 +1,11 @@
+import type { Domain } from '@astrale-os/kernel-dsl/v1/domain';
+import type { RuntimeRegistry } from '../../application/runtime/index.js';
+import type { Build } from '../../deployment/build/build.js';
+import type { Release } from '../../deployment/release/release.js';
+export interface LoadedRuntime<BuildValue extends Build = Build> {
+    readonly release: Release<BuildValue>;
+    readonly domain: Domain;
+    readonly registry: RuntimeRegistry;
+}
+/** Load the compiled Domain and re-admit its exact Runtime registry at execution startup. */
+export declare function load<const BuildValue extends Build>(release: Release<BuildValue>): LoadedRuntime<BuildValue>;

package/dist/execution/runtime/load.js

@@ -0,0 +1,17 @@
+import { load as loadCompiledSchema } from '@astrale-os/kernel-dsl/v1/compiled/loader';
+import { admitRuntimeRegistry } from '../../application/runtime/index.js';
+import { isRelease } from '../../deployment/release/admission.js';
+import { capture } from './admission.js';
+/** Load the compiled Domain and re-admit its exact Runtime registry at execution startup. */
+export function load(release) {
+    if (!isRelease(release))
+        throw new TypeError('Runtime loading requires an admitted Release.');
+    const domain = loadCompiledSchema(release.build.schema.compiled);
+    const registry = admitRuntimeRegistry(domain, release.build.runtime);
+    const actual = registry.implementations.map(({ callable }) => callable.key).sort();
+    if (actual.length !== release.build.callables.length ||
+        actual.some((key, index) => key !== release.build.callables[index])) {
+        throw new TypeError('Runtime registry differs from its compiled Build callable set.');
+    }
+    return capture(Object.freeze({ release, domain, registry }));
+}

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

@@ -0,0 +1,3 @@
+import type { RuntimeInitialization } from '../../application/runtime/index.js';
+/** Admit the initializer's exact Provider result. */
+export declare function providers(input: unknown): RuntimeInitialization;

package/dist/execution/runtime/providers.js

@@ -0,0 +1,12 @@
+/** Admit the initializer's exact Provider result. */
+export function providers(input) {
+    if (input === null ||
+        typeof input !== 'object' ||
+        Array.isArray(input) ||
+        Reflect.ownKeys(input).length !== 1 ||
+        !Object.hasOwn(input, 'providers')) {
+        throw new TypeError('Runtime initialization must contain exactly providers.');
+    }
+    const value = input;
+    return Object.freeze({ providers: value.providers });
+}

package/dist/execution/serve.d.ts

@@ -0,0 +1,27 @@
+import type { ServerCloseOptions } from '@astrale-os/kernel-server';
+import type { publication } from '@astrale-os/kernel-server';
+import type { Runtime } from '../application/runtime/index.js';
+import type { WorkflowRunner } from '../application/workflow/runner/index.js';
+import type { Identity } from './identity/index.js';
+import type { ReleaseLoader } from './service/index.js';
+import type { ServiceServerOptions } from './service/index.js';
+export interface ExecutionContext {
+    waitUntil(promise: Promise<unknown>): void;
+    readonly sleep?: (durationMs: number) => Promise<void>;
+}
+export interface ServeInput<Environment, RuntimeValue extends Runtime, RuntimeEnvironment = Environment> {
+    readonly runtime: RuntimeValue;
+    readonly load: ReleaseLoader<Environment, RuntimeValue>;
+    identity(environment: Environment): Identity;
+    readonly initialize?: (environment: Environment) => RuntimeEnvironment;
+    readonly server: ServiceServerOptions;
+    readonly delivery?: (environment: Environment) => publication.delivery.Provider | undefined;
+    readonly workflows?: WorkflowRunner;
+}
+export interface ServedApplication<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>;

package/dist/execution/serve.js

@@ -0,0 +1,61 @@
+import { createService } from './service/index.js';
+/** Create one provider-neutral Fetch entrypoint around a lazily initialized current Service. */
+export function serve(input) {
+    if (input === null || typeof input !== 'object' || Array.isArray(input))
+        invalid();
+    let service;
+    let drained = false;
+    let closeOptions;
+    const realize = (environment) => {
+        if (service !== undefined)
+            return service;
+        if (typeof input.identity !== 'function')
+            invalid();
+        const runtimeEnvironment = input.initialize === undefined
+            ? environment
+            : input.initialize(environment);
+        service = createService({
+            runtime: input.runtime,
+            environment: runtimeEnvironment,
+            load: () => input.load(environment),
+            identity: input.identity(environment),
+            server: input.server,
+            ...(input.delivery === undefined ? {} : { delivery: input.delivery(environment) }),
+            ...(input.workflows === undefined ? {} : { workflows: input.workflows }),
+        });
+        if (drained)
+            service.drain();
+        if (closeOptions !== undefined)
+            void service.close(closeOptions);
+        return service;
+    };
+    const application = Object.freeze({
+        fetch(request, environment, context) {
+            return realize(environment).fetch(request, host(context));
+        },
+        drain() {
+            drained = true;
+            service?.drain();
+        },
+        close(options) {
+            const selected = (closeOptions ??= options);
+            drained = true;
+            return service === undefined ? Promise.resolve() : service.close(selected);
+        },
+    });
+    return application;
+}
+function host(context) {
+    if (context === undefined)
+        return undefined;
+    if (context === null || typeof context !== 'object' || typeof context.waitUntil !== 'function') {
+        invalid();
+    }
+    return Object.freeze({
+        waitUntil: context.waitUntil.bind(context),
+        ...(context.sleep === undefined ? {} : { sleep: context.sleep.bind(context) }),
+    });
+}
+function invalid() {
+    throw new TypeError('serve() input is invalid.');
+}

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

@@ -0,0 +1,4 @@
+import type { Runtime } from '../../application/runtime/index.js';
+import type { Service, ServiceInput } from './service.js';
+/** Create one lazy running Service around the exact current Release. */
+export declare function createService<Environment, RuntimeValue extends Runtime>(input: ServiceInput<Environment, RuntimeValue>): Service;

package/dist/execution/service/create.js

@@ -0,0 +1,118 @@
+import { prepareServer } from '@astrale-os/kernel-server';
+import { isRuntime } from '../../application/runtime/index.js';
+import { invocationPath, releaseUnavailable, requestedRevision, } 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 { initialization } from './initialization.js';
+import { lifecycle } from './lifecycle.js';
+import { delivery, installation, source } from './publication/index.js';
+import { loadRelease } from './release.js';
+/** Create one lazy running Service around the exact current Release. */
+export function createService(input) {
+    if (input === null || typeof input !== 'object' || Array.isArray(input))
+        invalid();
+    if (!isRuntime(input.runtime))
+        throw new TypeError('Service Runtime is not admitted.');
+    const selectedIdentity = captureIdentity(input.identity);
+    const providedDelivery = delivery(input.delivery);
+    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) {
+            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 loaded = load(release);
+        const runtime = await initialize(loaded, input.environment);
+        const prepared = prepareServer({
+            ...serverOptions(input.server),
+            path: invocationPath(release.build.schema.compiled.root.revision),
+            invocation: {
+                source: selectedIdentity.issuer,
+                next: () => globalThis.crypto.randomUUID(),
+            },
+            issuer: selectedIdentity,
+            ...(selectedIdentity.tokenExchange === undefined
+                ? {}
+                : { tokenExchange: selectedIdentity.tokenExchange }),
+            publication: source(loaded),
+            ...(selectedDelivery === undefined ? {} : { delivery: selectedDelivery }),
+        });
+        const server = prepared.create(createHandler({
+            runtime,
+            authority: selectedIdentity,
+            ...(input.workflows === undefined ? {} : { workflows: input.workflows }),
+        }));
+        running = Object.freeze({ release, runtime, server });
+        if (!state.accepting)
+            server.drain();
+        return running;
+    });
+    let closing;
+    const service = Object.freeze({
+        async fetch(request, host) {
+            if (!state.accepting)
+                return unavailable();
+            const ready = await realized.get();
+            if (!state.accepting)
+                return unavailable();
+            const requested = requestedRevision(new URL(request.url).pathname);
+            if (requested !== undefined &&
+                requested !== ready.release.build.schema.compiled.root.revision) {
+                return releaseUnavailable();
+            }
+            return ready.server.app.fetch(request, host);
+        },
+        async release() {
+            return (await realized.get()).release;
+        },
+        drain: state.drain,
+        close(options) {
+            if (!Number.isFinite(options.deadline)) {
+                return Promise.reject(new TypeError('Service close deadline must be finite.'));
+            }
+            if (closing !== undefined)
+                return closing;
+            state.close();
+            const current = realized.current();
+            closing =
+                current === undefined
+                    ? Promise.resolve()
+                    : current.then(({ server }) => server.close(options), () => undefined);
+            return closing;
+        },
+    });
+    return service;
+}
+function serverOptions(input) {
+    if (input === null || typeof input !== 'object' || Array.isArray(input))
+        invalid();
+    const forbidden = [
+        'path',
+        'invocation',
+        'issuer',
+        'tokenExchange',
+        'publication',
+        'delivery',
+        'handler',
+    ];
+    if (Reflect.ownKeys(input).some((key) => typeof key === 'string' && forbidden.includes(key))) {
+        throw new TypeError('Service cannot override SDK-owned Kernel Server composition.');
+    }
+    return input;
+}
+function unavailable() {
+    return new Response('{"error":"Service is draining."}', {
+        status: 503,
+        headers: { 'content-type': 'application/json', 'cache-control': 'no-store' },
+    });
+}
+function invalid() {
+    throw new TypeError('Service input is invalid.');
+}

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

@@ -0,0 +1,3 @@
+export declare class ServiceUnavailableError extends Error {
+    readonly name = "ServiceUnavailableError";
+}

package/dist/execution/service/errors.js

@@ -0,0 +1,3 @@
+export class ServiceUnavailableError extends Error {
+    name = 'ServiceUnavailableError';
+}

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

@@ -0,0 +1,3 @@
+export { createService } from './create.js';
+export type { Service, ServiceInput, ServiceServerOptions } from './service.js';
+export type { ReleaseLoader } from './release.js';

package/dist/execution/service/index.js

@@ -0,0 +1 @@
+export { createService } from './create.js';

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

@@ -0,0 +1,6 @@
+export interface Initialization<Value> {
+    get(): 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>;

package/dist/execution/service/initialization.js

@@ -0,0 +1,18 @@
+/** Share one successful initialization and allow a later retry after failure. */
+export function initialization(create) {
+    let current;
+    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,
+    });
+}

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

@@ -0,0 +1,7 @@
+export interface ServiceLifecycle {
+    readonly accepting: boolean;
+    readonly closed: boolean;
+    drain(): void;
+    close(): void;
+}
+export declare function lifecycle(onDrain: () => void): ServiceLifecycle;