@loutrejs/loutre 0.4.1 → 0.6.0

package/dist/adapters/deno.js

@@ -1,7 +1,10 @@
-import { binding, } from '../application/index.js';
+import { createKernelApplication, } from '../application/index.js';
+import { bindApplicationCapability } from '../application/kernel-internal.js';
+import { httpExecutionExtension } from '../http/index.js';
 import { LOUTRE_VERSION, startStartupPresentation } from '../presentation.js';
 import { assertRuntimeEngine } from '../runtime/engine.js';
 import { serverUrl } from '../runtime/server-url.js';
+import { canRetryOnNextPort, initialServerPort, } from '../runtime/server-port.js';
 export const denoRuntime = {
     runtime: 'deno',
     capabilities: new Set([
@@ -20,18 +23,29 @@ export const denoRuntime = {
 };
 function bind(options) {
     assertRuntimeEngine('deno');
-    const invocation = binding.invocation(bindingOptions(options, denoEnvironment()));
-    const http = 'http' in invocation
-        ? invocation.http
-        : undefined;
-    if (!http) {
-        void invocation.application.close();
-        throw new Error('LUTRE_RUNTIME_HTTP_REQUIRED: denoRuntime.bind() requires an HTTP-capable Application.');
+    if (options.application.model.extensions.get(httpExecutionExtension) ===
+        undefined) {
+        throw new Error('LUTRE_RUNTIME_HTTP_REQUIRED: denoRuntime.bind() requires the HTTP Execution Extension.');
     }
-    const fetch = createDenoFetchDriver(http);
+    const application = createKernelApplication({
+        ...options,
+        application: options.application,
+        capabilities: [
+            bindApplicationCapability(options.application.model, 'http.server', {
+                runtime: 'deno',
+            }),
+            ...(options.capabilities ?? []),
+        ],
+        environment: 'environment' in options ? options.environment : denoEnvironment(),
+    });
+    let initialization;
     return {
-        fetch,
-        close: (signal) => invocation.application.close(signal),
+        async fetch(request) {
+            initialization ??= application.init();
+            await initialization;
+            return application.http.fetch(request);
+        },
+        close: (signal) => application.close(signal),
     };
 }
 async function create(options) {
@@ -46,42 +60,83 @@ async function create(options) {
         },
         write: (value) => console.log(value),
     });
-    const host = binding.host(bindingOptions(options, denoEnvironment()));
-    const http = 'http' in host ? host.http : undefined;
-    if (!http) {
-        await host.application.close();
-        throw new Error('LUTRE_RUNTIME_HTTP_REQUIRED: denoRuntime.create() requires an HTTP-capable Application.');
+    if (options.application.model.extensions.get(httpExecutionExtension) ===
+        undefined) {
+        throw new Error('LUTRE_RUNTIME_HTTP_REQUIRED: denoRuntime.create() requires the HTTP Execution Extension.');
     }
-    await host.application.init();
-    const application = host.application;
-    const closeApplication = host.application.close.bind(host.application);
+    const hosted = createKernelApplication({
+        ...options,
+        application: options.application,
+        capabilities: [
+            bindApplicationCapability(options.application.model, 'http.server', {
+                runtime: 'deno',
+            }),
+            ...(options.capabilities ?? []),
+        ],
+        environment: 'environment' in options ? options.environment : denoEnvironment(),
+    });
+    await hosted.init();
+    const application = hosted;
+    const http = hosted
+        .http;
+    const closeApplication = application.close.bind(application);
     let server;
     let removeShutdownHooks;
     let serving = false;
     let closed = false;
-    const close = async (signal) => {
+    let closingPromise;
+    let serverClosingPromise;
+    const beginServerClose = () => {
+        if (serverClosingPromise)
+            return serverClosingPromise;
+        if (!server)
+            return Promise.resolve();
+        const closingServer = server;
+        serverClosingPromise = Promise.resolve()
+            .then(() => closingServer.shutdown())
+            .then(() => {
+            if (server === closingServer)
+                server = undefined;
+        }, (error) => {
+            serverClosingPromise = undefined;
+            throw error;
+        });
+        void serverClosingPromise.catch(() => undefined);
+        return serverClosingPromise;
+    };
+    const close = (signal) => {
         if (closed)
-            return;
-        closed = true;
-        removeShutdownHooks?.();
-        removeShutdownHooks = undefined;
-        const errors = [];
-        if (server) {
+            return Promise.resolve();
+        if (closingPromise)
+            return closingPromise;
+        closingPromise = (async () => {
+            removeShutdownHooks?.();
+            removeShutdownHooks = undefined;
+            const errors = [];
+            const serverClosing = beginServerClose();
             try {
-                await server.shutdown();
+                await closeApplication(signal);
             }
             catch (error) {
                 errors.push(error);
             }
-        }
-        try {
-            await closeApplication(signal);
-        }
-        catch (error) {
-            errors.push(error);
-        }
-        if (errors.length > 0)
-            throw new AggregateError(errors, 'Deno runtime shutdown failed');
+            if (errors.length === 0) {
+                try {
+                    await serverClosing;
+                }
+                catch (error) {
+                    errors.push(error);
+                }
+            }
+            if (errors.length > 0) {
+                throw new AggregateError(errors, 'Deno runtime shutdown failed');
+            }
+            closed = true;
+        })().catch((error) => {
+            closingPromise = undefined;
+            throw error;
+        });
+        return closingPromise;
     };
     const serve = async (serveOptions = {}) => {
         if (closed) {
@@ -96,10 +151,8 @@ async function create(options) {
         }
         serving = true;
         try {
-            if ('triggers' in application)
-                await application.triggers.start();
             const requestedPort = serveOptions.port;
-            let port = requestedPort ?? 3000;
+            let port = initialServerPort(requestedPort);
             while (true) {
                 try {
                     server = deno.serve({
@@ -161,28 +214,12 @@ function registerDenoShutdownHooks(deno, close) {
     }
     return remove;
 }
-function canRetryOnNextPort(error, port) {
-    return port < 65_535 && isAddressInUseError(error);
-}
-function isAddressInUseError(error) {
-    return (typeof error === 'object' &&
-        error !== null &&
-        'code' in error &&
-        error.code === 'EADDRINUSE');
-}
 function createDenoFetchDriver(application) {
     let initialization;
     return async (request) => {
-        initialization ??= application.initialize();
+        initialization ??= application.initialize?.() ?? Promise.resolve();
         await initialization;
-        return application.handle(request);
-    };
-}
-function bindingOptions(options, environment) {
-    return {
-        application: options.application,
-        environment: 'environment' in options ? options.environment : environment,
-        ...('arguments' in options ? { arguments: options.arguments } : {}),
+        return application.fetch(request);
     };
 }
 function denoEnvironment() {

package/dist/adapters/electron.d.ts

@@ -1,7 +1,14 @@
-import { type ApplicationDefinition, type BootstrapArguments, type HasMessagePort, type InvocationApplication } from '../application/index.js';
-import { type MessagePortLike } from '../message-port/index.js';
-type IsAny<TValue> = 0 extends 1 & TValue ? true : false;
-type MessagePortApplication<TDefinition extends ApplicationDefinition> = IsAny<TDefinition> extends true ? TDefinition : HasMessagePort<TDefinition> extends true ? TDefinition : never;
+import { type ApplicationDefinition, type BootstrapArguments, type KernelHostedApplication, type RequireApplicationExtension } from '../application/index.js';
+import type { RuntimeCapabilityBinding } from '../core/index.js';
+import { messagePortExtension } from '../message-port/index.js';
+type MessagePortApplication<TDefinition extends ApplicationDefinition> = RequireApplicationExtension<TDefinition, typeof messagePortExtension>;
+export interface MessagePortLike {
+    postMessage(value: unknown): void;
+    addEventListener(type: 'message', listener: (event: {
+        readonly data: unknown;
+    }) => void): void;
+    start?(): void;
+}
 export interface ElectronMessagePortMainLike {
     postMessage(value: unknown): void;
     on(type: 'message', listener: (event: {
@@ -13,9 +20,10 @@ export type ElectronAttachOptions<TDefinition extends ApplicationDefinition> = {
     readonly application: MessagePortApplication<TDefinition>;
     readonly port: MessagePortLike | ElectronMessagePortMainLike;
     readonly environment?: unknown;
+    readonly capabilities?: readonly RuntimeCapabilityBinding[];
 } & BootstrapArguments<TDefinition>;
 export interface ElectronAttachment<TDefinition extends ApplicationDefinition = ApplicationDefinition> {
-    readonly application: InvocationApplication<TDefinition>;
+    readonly application: KernelHostedApplication<TDefinition>;
     close(signal?: string): Promise<void>;
 }
 export declare const electronRuntime: {

package/dist/adapters/electron.js

@@ -1,5 +1,5 @@
-import { binding, } from '../application/index.js';
-import { attachMessagePort, } from '../message-port/index.js';
+import { createKernelApplication, } from '../application/index.js';
+import { messagePortExtension } from '../message-port/index.js';
 import { assertRuntimeEngine } from '../runtime/engine.js';
 export const electronRuntime = {
     runtime: 'electron',
@@ -17,38 +17,86 @@ export const electronRuntime = {
 };
 function attach(options) {
     assertRuntimeEngine('electron');
-    const invocation = binding.invocation({
+    if (options.application.model.extensions.get(messagePortExtension) === undefined) {
+        throw new Error('LUTRE_RUNTIME_MESSAGE_PORT_REQUIRED: electronRuntime.attach() requires the MessagePort Execution Extension.');
+    }
+    const environment = 'environment' in options
+        ? options.environment
+        : typeof process === 'undefined'
+            ? undefined
+            : process.env;
+    const application = createKernelApplication({
+        ...options,
         application: options.application,
-        environment: 'environment' in options
-            ? options.environment
-            : typeof process === 'undefined'
-                ? undefined
-                : process.env,
-        ...('arguments' in options ? { arguments: options.arguments } : {}),
+        environment,
     });
-    const messagePort = 'messagePort' in invocation
-        ? invocation.messagePort
-        : undefined;
-    if (!messagePort) {
-        void invocation.application.close();
-        throw new Error('LUTRE_RUNTIME_MESSAGE_PORT_REQUIRED: electronRuntime.attach() requires a MessagePort-capable Application.');
-    }
-    attachElectronMessagePort(messagePort, options.port);
+    const initialization = application.init();
+    void initialization.catch(() => undefined);
+    attachElectronMessagePortInvocation(async (method, input) => {
+        await initialization;
+        const host = application.messagePort;
+        return host.invoke(method, input);
+    }, options.port);
     return {
-        application: invocation.application,
-        close: (signal) => invocation.application.close(signal),
+        application,
+        close: (signal) => application.close(signal),
     };
 }
-function attachElectronMessagePort(application, port) {
-    const initialization = application.initialize();
-    void initialization.catch(() => undefined);
-    if ('addEventListener' in port) {
-        attachMessagePort(application, port);
-        return;
-    }
-    attachMessagePort(application, {
+function attachElectronMessagePortInvocation(invoke, port) {
+    const normalized = normalizeMessagePort(port);
+    normalized.addEventListener('message', async (event) => {
+        const request = event.data;
+        try {
+            const result = await invoke(request.procedure, request.input);
+            if (isAsyncIterable(result.value)) {
+                for await (const value of result.value) {
+                    postToMessagePort(normalized, {
+                        id: request.id,
+                        response: result.response,
+                        value,
+                        done: false,
+                    });
+                }
+                postToMessagePort(normalized, {
+                    id: request.id,
+                    response: result.response,
+                    done: true,
+                });
+            }
+            else {
+                postToMessagePort(normalized, {
+                    id: request.id,
+                    response: result.response,
+                    value: result.value,
+                    done: true,
+                });
+            }
+        }
+        catch (error) {
+            postToMessagePort(normalized, {
+                id: request.id,
+                error: error instanceof Error ? error.message : String(error),
+                done: true,
+            });
+        }
+    });
+    normalized.start?.();
+}
+function postToMessagePort(port, value) {
+    port.postMessage(value);
+}
+function normalizeMessagePort(port) {
+    if ('addEventListener' in port)
+        return port;
+    return {
         postMessage: (value) => port.postMessage(value),
         addEventListener: (_type, listener) => port.on('message', listener),
         start: () => port.start(),
-    });
+    };
+}
+function isAsyncIterable(value) {
+    return (typeof value === 'object' &&
+        value !== null &&
+        Symbol.asyncIterator in value &&
+        typeof value[Symbol.asyncIterator] === 'function');
 }

package/dist/application/definition.d.ts

@@ -0,0 +1,31 @@
+/// <reference lib="esnext.disposable" preserve="true" />
+import type { ArgsClass, ApplicationModel, ExecutionExtension, HostApiOfExtension, ModuleExtensions, ModuleInstance, SchemaInput } from '../core/index.js';
+import type { Logger } from '../runtime/index.js';
+export interface ApplicationDefinitionOptions<TModules extends readonly ModuleInstance[], TArguments extends ArgsClass | undefined> {
+    readonly modules: TModules;
+    readonly arguments?: TArguments;
+    readonly logger?: Logger;
+}
+export interface ApplicationDefinition<TModules extends readonly ModuleInstance[] = readonly ModuleInstance[], TArguments extends ArgsClass | undefined = ArgsClass | undefined> {
+    readonly kind: 'application-definition';
+    readonly model: ApplicationModel;
+    readonly modules: TModules;
+    readonly arguments: TArguments;
+    readonly logger?: Logger;
+}
+export declare function defineApplication<const TModules extends readonly ModuleInstance[], const TArguments extends ArgsClass | undefined = undefined>(options: ApplicationDefinitionOptions<TModules, TArguments>): ApplicationDefinition<TModules, TArguments>;
+export type ApplicationArgumentsInput<TDefinition extends ApplicationDefinition> = TDefinition['arguments'] extends ArgsClass<infer TSchema> ? SchemaInput<TSchema> : never;
+export type BootstrapArguments<TDefinition extends ApplicationDefinition> = TDefinition['arguments'] extends ArgsClass<infer TSchema> ? {} extends SchemaInput<TSchema> ? {
+    readonly arguments?: SchemaInput<TSchema>;
+} : {
+    readonly arguments: SchemaInput<TSchema>;
+} : {
+    readonly arguments?: never;
+};
+type UnionToIntersection<TUnion> = (TUnion extends unknown ? (value: TUnion) => void : never) extends (value: infer TIntersection) => void ? TIntersection : never;
+export type ApplicationExtensions<TDefinition extends ApplicationDefinition> = ModuleExtensions<TDefinition['modules'][number]>;
+export type ApplicationExtensionHostApis<TDefinition extends ApplicationDefinition> = UnionToIntersection<HostApiOfExtension<ApplicationExtensions<TDefinition>>>;
+type IsAny<TValue> = 0 extends 1 & TValue ? true : false;
+export type RequireApplicationHost<TDefinition extends ApplicationDefinition, TNamespace extends PropertyKey> = IsAny<TDefinition> extends true ? TDefinition : TNamespace extends keyof ApplicationExtensionHostApis<TDefinition> ? TDefinition : never;
+export type RequireApplicationExtension<TDefinition extends ApplicationDefinition, TExtension extends ExecutionExtension> = IsAny<TDefinition> extends true ? TDefinition : [Extract<ApplicationExtensions<TDefinition>, TExtension>] extends [never] ? never : TDefinition;
+export {};

package/dist/application/definition.js

@@ -0,0 +1,16 @@
+/// <reference lib="esnext.disposable" preserve="true" />
+import { buildApplicationModel } from '../core/index.js';
+export function defineApplication(options) {
+    return Object.freeze({
+        kind: 'application-definition',
+        model: buildApplicationModel({
+            modules: options.modules,
+            ...(options.arguments === undefined
+                ? {}
+                : { arguments: options.arguments }),
+        }),
+        modules: options.modules,
+        arguments: options.arguments,
+        ...(options.logger === undefined ? {} : { logger: options.logger }),
+    });
+}

package/dist/application/index.d.ts

@@ -1,63 +1,4 @@
-import type { ArgsClass, ModuleProtocols, ModuleInstance, SchemaInput, TaskArguments, TaskDescriptor, TaskOutput, TokenLike, TokenValue, TriggerDescriptor } from '../core/index.js';
-import type { ApplicationGraphIR } from '../graph/index.js';
-import type { Logger } from '../runtime/index.js';
-export interface ApplicationDefinitionOptions<TModules extends readonly ModuleInstance[], TArguments extends ArgsClass | undefined, TTasks extends readonly TaskDescriptor<any, any>[], TTriggers extends readonly TriggerDescriptor[]> {
-    readonly modules: TModules;
-    readonly arguments?: TArguments;
-    readonly tasks?: TTasks;
-    readonly triggers?: TTriggers;
-    readonly logger?: Logger;
-}
-export interface ApplicationDefinition<TModules extends readonly ModuleInstance[] = readonly ModuleInstance[], TArguments extends ArgsClass | undefined = ArgsClass | undefined, TTasks extends readonly TaskDescriptor<any, any>[] = readonly TaskDescriptor<any, any>[], TTriggers extends readonly TriggerDescriptor[] = readonly TriggerDescriptor[]> {
-    readonly kind: 'application-definition';
-    readonly modules: TModules;
-    readonly arguments: TArguments;
-    readonly tasks: TTasks;
-    readonly triggers: TTriggers;
-    readonly logger?: Logger;
-}
-export declare function defineApplication<const TModules extends readonly ModuleInstance[], const TArguments extends ArgsClass | undefined = undefined, const TTasks extends readonly TaskDescriptor<any, any>[] = readonly [], const TTriggers extends readonly TriggerDescriptor[] = readonly []>(options: ApplicationDefinitionOptions<TModules, TArguments, TTasks, TTriggers>): ApplicationDefinition<TModules, TArguments, TTasks, TTriggers>;
-export type ApplicationArgumentsInput<TDefinition extends ApplicationDefinition> = TDefinition['arguments'] extends ArgsClass<infer TSchema> ? SchemaInput<TSchema> : never;
-export type BootstrapArguments<TDefinition extends ApplicationDefinition> = TDefinition['arguments'] extends ArgsClass<infer TSchema> ? {} extends SchemaInput<TSchema> ? {
-    readonly arguments?: SchemaInput<TSchema>;
-} : {
-    readonly arguments: SchemaInput<TSchema>;
-} : {
-    readonly arguments?: never;
-};
-export interface BaseApplication {
-    readonly graph: ApplicationGraphIR;
-    get<TToken extends TokenLike>(token: TToken): TokenValue<TToken>;
-    init(): Promise<this>;
-    close(signal?: string): Promise<void>;
-}
-export interface TaskApplicationCapability<TTasks extends readonly TaskDescriptor<any, any>[]> {
-    run<TTask extends TTasks[number]>(task: TTask, ...args: TaskArguments<TTask>): Promise<TaskOutput<TTask>>;
-}
-export interface HttpApplicationCapability {
-    fetch(request: Request): Promise<Response>;
-}
-export interface TriggerApplicationCapability {
-    readonly triggers: {
-        start(): Promise<void>;
-        stop(): Promise<void>;
-    };
-}
-export interface QueueConsumerHandle {
-    stop(): Promise<void>;
-}
-export interface QueueConsumerDriver {
-    start(options: {
-        consume(payload: unknown): Promise<void>;
-    }): Promise<QueueConsumerHandle>;
-}
-export type HasProtocol<TDefinition extends ApplicationDefinition, TProtocol extends string> = Extract<ModuleProtocols<TDefinition['modules'][number]>, TProtocol> extends never ? false : true;
-export type HasHttp<TDefinition extends ApplicationDefinition> = HasProtocol<TDefinition, 'http'>;
-export type HasMessagePort<TDefinition extends ApplicationDefinition> = HasProtocol<TDefinition, 'messagePort'>;
-export type HasTasks<TDefinition extends ApplicationDefinition> = TDefinition['tasks'] extends readonly [] ? false : true;
-export type HasTriggers<TDefinition extends ApplicationDefinition> = TDefinition['triggers'] extends readonly [] ? false : true;
-type TaskCapability<TDefinition extends ApplicationDefinition> = TDefinition['tasks'] extends readonly [] ? {} : TaskApplicationCapability<TDefinition['tasks']>;
-export type HostedApplication<TDefinition extends ApplicationDefinition> = BaseApplication & TaskCapability<TDefinition> & (HasHttp<TDefinition> extends true ? HttpApplicationCapability : {}) & (HasTriggers<TDefinition> extends true ? TriggerApplicationCapability : {});
-export type InvocationApplication<TDefinition extends ApplicationDefinition> = BaseApplication & TaskCapability<TDefinition>;
-export { binding } from './binding.js';
-export type { HostBinding, HostBindingApplication, InvocationBinding, InvocationBindingBaseOptions, InvocationBindingOptions, } from './binding.js';
+export { defineApplication } from './definition.js';
+export type { ApplicationArgumentsInput, ApplicationDefinition, ApplicationDefinitionOptions, ApplicationExtensionHostApis, ApplicationExtensions, BootstrapArguments, RequireApplicationExtension, RequireApplicationHost, } from './definition.js';
+export { bootstrapApplication, createKernelApplication } from './kernel.js';
+export type { KernelApplicationBase, KernelApplicationOptions, KernelHostedApplication, } from './kernel.js';

package/dist/application/index.js

@@ -1,11 +1,2 @@
-export function defineApplication(options) {
-    return Object.freeze({
-        kind: 'application-definition',
-        modules: options.modules,
-        arguments: options.arguments,
-        tasks: options.tasks ?? [],
-        triggers: options.triggers ?? [],
-        ...(options.logger === undefined ? {} : { logger: options.logger }),
-    });
-}
-export { binding } from './binding.js';
+export { defineApplication } from './definition.js';
+export { bootstrapApplication, createKernelApplication } from './kernel.js';

package/dist/application/kernel-internal.d.ts

@@ -0,0 +1,2 @@
+import { type ApplicationModel, type RuntimeCapabilityBinding } from '../core/index.js';
+export declare function bindApplicationCapability<TValue>(model: ApplicationModel, id: string, value: TValue): RuntimeCapabilityBinding<TValue>;

package/dist/application/kernel-internal.js

@@ -0,0 +1,10 @@
+import { bindRuntimeCapability, } from '../core/index.js';
+export function bindApplicationCapability(model, id, value) {
+    const capability = model.executions
+        .flatMap((execution) => execution.capabilities)
+        .find((candidate) => candidate.id === id);
+    if (!capability) {
+        throw new Error(`LUTRE_CAPABILITY_NOT_REQUIRED: ${id}`);
+    }
+    return bindRuntimeCapability(capability, value);
+}

package/dist/application/kernel.d.ts

@@ -0,0 +1,21 @@
+/// <reference lib="esnext.disposable" preserve="true" />
+import type { RuntimeCapabilityBinding, TokenLike, TokenValue } from '../core/index.js';
+import { type ApplicationModelGraphIR } from '../graph/index.js';
+import { type Logger } from '../runtime/index.js';
+import type { ApplicationDefinition, ApplicationExtensionHostApis, BootstrapArguments } from './definition.js';
+export interface KernelApplicationBase extends AsyncDisposable {
+    readonly graph: ApplicationModelGraphIR;
+    init(): Promise<this>;
+    get<TToken extends TokenLike>(token: TToken): TokenValue<TToken>;
+    close(signal?: string): Promise<void>;
+}
+export type KernelHostedApplication<TDefinition extends ApplicationDefinition> = KernelApplicationBase & ApplicationExtensionHostApis<TDefinition>;
+export type KernelApplicationOptions<TDefinition extends ApplicationDefinition> = {
+    readonly application: TDefinition;
+    readonly capabilities?: readonly RuntimeCapabilityBinding[];
+    readonly environment?: unknown;
+    readonly logger?: Logger;
+    readonly forceShutdownTimeoutMs?: number;
+} & BootstrapArguments<TDefinition>;
+export declare function createKernelApplication<const TDefinition extends ApplicationDefinition>(options: KernelApplicationOptions<TDefinition>): KernelHostedApplication<TDefinition>;
+export declare function bootstrapApplication<const TDefinition extends ApplicationDefinition>(options: KernelApplicationOptions<TDefinition>): Promise<KernelHostedApplication<TDefinition>>;

package/dist/application/kernel.js

@@ -0,0 +1,65 @@
+/// <reference lib="esnext.disposable" preserve="true" />
+import { projectApplicationModel, } from '../graph/index.js';
+import { ApplicationKernelRuntime } from '../runtime/index.js';
+export function createKernelApplication(options) {
+    const logger = options.logger ?? options.application.logger;
+    const runtime = new ApplicationKernelRuntime(options.application.model, {
+        ...options,
+        ...(logger === undefined ? {} : { logger }),
+        ...('environment' in options
+            ? { environmentSource: options.environment }
+            : {}),
+        ...('arguments' in options ? { argumentsSource: options.arguments } : {}),
+    });
+    let initialized = false;
+    const application = Object.assign(Object.create(null), {
+        graph: projectApplicationModel(options.application.model),
+        async init() {
+            await runtime.initialize();
+            if (initialized)
+                return application;
+            const createdNamespaces = [];
+            try {
+                for (const modelExtension of options.application.model.extensions) {
+                    const host = modelExtension.extension.host;
+                    if (!host)
+                        continue;
+                    application[host.namespace] = host.create({
+                        executions: modelExtension.executions,
+                        runtime: runtime.extensionRuntime(modelExtension.extension),
+                        applicationRuntime: runtime,
+                    });
+                    createdNamespaces.push(host.namespace);
+                }
+                initialized = true;
+                return application;
+            }
+            catch (error) {
+                for (const namespace of createdNamespaces)
+                    delete application[namespace];
+                try {
+                    await runtime.shutdown();
+                }
+                catch (cleanupError) {
+                    throw new AggregateError([error, cleanupError], 'Host API creation failed and runtime rollback also failed.', { cause: cleanupError });
+                }
+                throw error;
+            }
+        },
+        get(token) {
+            return runtime.get(token);
+        },
+        close(signal) {
+            return runtime.shutdown(signal);
+        },
+        [Symbol.asyncDispose]() {
+            return application.close();
+        },
+    });
+    return application;
+}
+export async function bootstrapApplication(options) {
+    const application = createKernelApplication(options);
+    await application.init();
+    return application;
+}

package/dist/core/diagnostic.d.ts

@@ -0,0 +1,9 @@
+export interface Diagnostic {
+    readonly code: string;
+    readonly message: string;
+    readonly path: string;
+    readonly severity?: 'error' | 'warning';
+}
+export declare function isErrorDiagnostic(item: Diagnostic): boolean;
+export declare function hasErrorDiagnostics(diagnostics: readonly Diagnostic[]): boolean;
+export declare function diagnostic(code: string, message: string, path: string, severity?: Diagnostic['severity']): Diagnostic;

package/dist/core/diagnostic.js

@@ -0,0 +1,9 @@
+export function isErrorDiagnostic(item) {
+    return (item.severity ?? 'error') === 'error';
+}
+export function hasErrorDiagnostics(diagnostics) {
+    return diagnostics.some(isErrorDiagnostic);
+}
+export function diagnostic(code, message, path, severity = 'error') {
+    return Object.freeze({ code, message, path, severity });
+}