@loutrejs/loutre 0.9.1 → 0.10.0

package/dist/adapters/aws-lambda.d.ts

@@ -46,7 +46,7 @@ export interface AwsLambdaResponseStream {
 export type AwsLambdaStreamingHttpHandler = (event: AwsLambdaHttpEvent, output: AwsLambdaResponseStream, context?: unknown) => Promise<void>;
 export declare const awsLambdaRuntime: {
     readonly runtime: 'aws-lambda';
-    readonly capabilities: Set<string>;
+    readonly capabilities: ReadonlySet<import("../runtime/capability.js").RuntimeSupportFeature>;
     readonly bind: typeof bind;
 };
 declare function bind<const TDefinition extends ApplicationDefinition>(options: AwsLambdaStreamingBindOptions<TDefinition>): AwsLambdaStreamingHttpHandler;

package/dist/adapters/aws-lambda.js

@@ -1,10 +1,11 @@
+import { runtimeSupportFeatures } from '../runtime/capability.js';
 import { createKernelApplication, } from '../application/index.js';
 import { bindApplicationCapability } from '../application/kernel-internal.js';
 import { httpExecutionExtension } from '../http/index.js';
 import { assertRuntimeEngine } from '../runtime/engine.js';
 export const awsLambdaRuntime = {
     runtime: 'aws-lambda',
-    capabilities: new Set([
+    capabilities: runtimeSupportFeatures([
         'http.server',
         'http.response.streaming',
         'stream.readable',
@@ -35,7 +36,12 @@ function bind(options) {
         initialize: async () => {
             await application.init();
         },
-        fetch: (request) => application.http.fetch(request),
+        fetch: (request) => {
+            const hosted = application;
+            if (!hosted.http)
+                throw new Error('LUTRE_RUNTIME_HTTP_REQUIRED');
+            return hosted.http.fetch(request);
+        },
     };
     if (options.response === 'streaming') {
         const handler = createAwsLambdaStreamingHttpDriver(http);

package/dist/adapters/bun.d.ts

@@ -1,3 +1,4 @@
+import { type BoundPort } from '../runtime/server-port.js';
 import { type ApplicationDefinition, type BootstrapArguments, type KernelHostedApplication } from '../application/index.js';
 import type { RuntimeCapabilityBinding } from '../core/index.js';
 export type BunCreateOptions<TDefinition extends ApplicationDefinition> = {
@@ -13,14 +14,14 @@ export interface BunServeOptions {
     readonly shutdownHooks?: boolean;
 }
 export interface BunListenerHandle {
-    readonly port: number;
+    readonly port: BoundPort;
 }
 export type BunRuntimeApplication<TDefinition extends ApplicationDefinition = ApplicationDefinition> = KernelHostedApplication<TDefinition> & {
     serve(options?: BunServeOptions): Promise<BunListenerHandle>;
 };
 export declare const bunRuntime: {
     readonly runtime: 'bun';
-    readonly capabilities: Set<string>;
+    readonly capabilities: ReadonlySet<import("../runtime/capability.js").RuntimeSupportFeature>;
     readonly create: typeof create;
 };
 declare function create<const TDefinition extends ApplicationDefinition>(options: BunCreateOptions<TDefinition>): Promise<BunRuntimeApplication<TDefinition>>;

package/dist/adapters/bun.js

@@ -1,6 +1,8 @@
+import { boundPort, } from '../runtime/server-port.js';
+import { runtimeSupportFeatures } from '../runtime/capability.js';
 import { RuntimeShutdown } from '../runtime/shutdown.js';
 import { ProcessShutdownHooks } from '../runtime/shutdown-hooks.js';
-import { Logger } from '../runtime/logger.js';
+import { LoggerToken } from '../runtime/logger.js';
 import { createBunWebSocketDriver, } from './websocket-native.js';
 import { serverTransportBindings, dispatchServerRequest, } from './server-transports.js';
 import { createKernelApplication, } from '../application/index.js';
@@ -10,7 +12,7 @@ import { serverUrl } from '../runtime/server-url.js';
 import { canRetryOnNextPort, initialServerPort, } from '../runtime/server-port.js';
 export const bunRuntime = {
     runtime: 'bun',
-    capabilities: new Set([
+    capabilities: runtimeSupportFeatures([
         'http.server',
         'websocket.server',
         'http.request.streaming',
@@ -47,7 +49,7 @@ async function create(options) {
     const application = hosted;
     const closeApplication = application.close.bind(application);
     let server;
-    const logger = options.application.logger ?? new Logger();
+    const logger = application.get(LoggerToken);
     let serving = false;
     let serverClosingPromise;
     const beginServerClose = () => {
@@ -108,14 +110,14 @@ async function create(options) {
                         fetch: (request, upgradeServer) => websocketDriver.fetch(hosted, request, upgradeServer, dispatchServerRequest),
                         websocket: websocketDriver.websocket,
                     });
-                    port = server.port;
+                    port = boundPort(server.port);
                     break;
                 }
                 catch (error) {
                     if (requestedPort !== undefined || !canRetryOnNextPort(error, port)) {
                         throw error;
                     }
-                    port += 1;
+                    port = initialServerPort(port + 1);
                 }
             }
             presentation.ready({
@@ -134,7 +136,11 @@ async function create(options) {
     const shutdownHooks = new ProcessShutdownHooks({
         source: process,
         close,
-        onError: (error, signal) => logger.error('Bun runtime shutdown failed', { error, signal }),
+        onError: (error, signal) => logger.error('Bun runtime shutdown failed', {
+            source: 'BunRuntime',
+            error,
+            signal,
+        }),
     });
     Object.assign(application, { serve, close });
     shutdownHooks.setEnabled(options.shutdownHooks !== false);

package/dist/adapters/cloudflare-workers.d.ts

@@ -11,7 +11,7 @@ export interface CloudflareWorkersBinding {
 export declare const cloudflareWorkersRuntime: {
     readonly runtime: 'cloudflare-workers';
     readonly compatibilityDateMinimum: '2026-08-04';
-    readonly capabilities: Set<string>;
+    readonly capabilities: ReadonlySet<import("../runtime/capability.js").RuntimeSupportFeature>;
     readonly bind: typeof bind;
 };
 declare function bind<const TDefinition extends ApplicationDefinition>(options: CloudflareWorkersBindOptions<TDefinition>): CloudflareWorkersBinding;

package/dist/adapters/cloudflare-workers.js

@@ -1,3 +1,4 @@
+import { runtimeSupportFeatures } from '../runtime/capability.js';
 import { createCloudflareWebSocketDriver } from './websocket-native.js';
 import { serverTransportBindings, dispatchServerRequest, } from './server-transports.js';
 import { createKernelApplication, } from '../application/index.js';
@@ -5,7 +6,7 @@ import { assertRuntimeEngine } from '../runtime/engine.js';
 export const cloudflareWorkersRuntime = {
     runtime: 'cloudflare-workers',
     compatibilityDateMinimum: '2026-08-04',
-    capabilities: new Set([
+    capabilities: runtimeSupportFeatures([
         'http.server',
         'websocket.server',
         'http.request.streaming',

package/dist/adapters/electron.d.ts

@@ -28,7 +28,7 @@ export interface ElectronAttachment<TDefinition extends ApplicationDefinition =
 }
 export declare const electronRuntime: {
     readonly runtime: 'electron';
-    readonly capabilities: Set<string>;
+    readonly capabilities: ReadonlySet<import("../runtime/capability.js").RuntimeSupportFeature>;
     readonly attach: typeof attach;
 };
 declare function attach<const TDefinition extends ApplicationDefinition>(options: ElectronAttachOptions<TDefinition>): ElectronAttachment<TDefinition>;

package/dist/adapters/electron.js

@@ -1,9 +1,10 @@
+import { runtimeSupportFeatures } from '../runtime/capability.js';
 import { createKernelApplication, } from '../application/index.js';
-import { messagePortExtension } from '../message-port/index.js';
+import { messagePortExtension, attachMessagePort, } from '../message-port/index.js';
 import { assertRuntimeEngine } from '../runtime/engine.js';
 export const electronRuntime = {
     runtime: 'electron',
-    capabilities: new Set([
+    capabilities: runtimeSupportFeatures([
         'messagePort.send',
         'messagePort.receive',
         'messagePort.transfer',
@@ -34,8 +35,10 @@ function attach(options) {
     void initialization.catch(() => undefined);
     attachElectronMessagePortInvocation(async (method, input) => {
         await initialization;
-        const host = application.messagePort;
-        return host.invoke(method, input);
+        const hosted = application;
+        if (!hosted.messagePort)
+            throw new Error('LUTRE_RUNTIME_MESSAGE_PORT_REQUIRED');
+        return hosted.messagePort.invoke(method, input);
     }, options.port);
     return {
         application,
@@ -43,47 +46,7 @@ function attach(options) {
     };
 }
 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);
+    attachMessagePort({ invoke }, normalizeMessagePort(port));
 }
 function normalizeMessagePort(port) {
     if ('addEventListener' in port)
@@ -94,9 +57,3 @@ function normalizeMessagePort(port) {
         start: () => port.start(),
     };
 }
-function isAsyncIterable(value) {
-    return (typeof value === 'object' &&
-        value !== null &&
-        Symbol.asyncIterator in value &&
-        typeof value[Symbol.asyncIterator] === 'function');
-}

package/dist/adapters/server-transports.js

@@ -1,4 +1,4 @@
-import { bindHttpServer } from '../http/index.js';
+import { bindHttpServer, isWebSocketUpgrade, } from '../http/index.js';
 import { bindWebSocketServer, } from '../websocket/index.js';
 export function serverTransportBindings(model, runtime, websocket) {
     const requires = (id) => model.executions.some((execution) => execution.capabilities.some((capability) => capability.id === id));
@@ -9,7 +9,7 @@ export function serverTransportBindings(model, runtime, websocket) {
 }
 export function dispatchServerRequest(application, request) {
     const transports = application;
-    if (request.headers.get('upgrade')?.toLowerCase() === 'websocket') {
+    if (isWebSocketUpgrade(request)) {
         return (transports.websocket?.upgrade(request) ??
             Promise.resolve(new Response('Not Found', { status: 404 })));
     }

package/dist/adapters/websocket-native.js

@@ -3,7 +3,10 @@ export function createCloudflareWebSocketDriver() {
     return {
         runtime: 'cloudflare-workers',
         async upgrade(_request, { protocol }) {
-            const Pair = globalThis.WebSocketPair;
+            const platform = globalThis;
+            const Pair = platform.WebSocketPair;
+            if (!Pair)
+                throw new Error('WebSocketPairを利用できません。');
             const pair = new Pair();
             pair[1].accept();
             // WorkersのI/Oはopening requestへ所属するため、別requestからのdrainをそのcontextへ戻す。

package/dist/application/definition.d.ts

@@ -1,19 +1,16 @@
 /// <reference lib="esnext.disposable" preserve="true" />
-import type { ArgsClass, ApplicationModel, ExecutionExtension, HostApiOfExtension, ModuleExtensions, ModuleInput, SchemaInput } from '../core/index.js';
-import type { Logger } from '../runtime/index.js';
-export interface ApplicationDefinitionOptions<TModules extends readonly ModuleInput[], TArguments extends ArgsClass | undefined> {
+import type { ArgsClass, ApplicationModel, ExecutionExtension, HostApiOfExtension, ModuleExtensions, ModuleInstance, SchemaInput } from '../core/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 ModuleInput[] = readonly ModuleInput[], TArguments extends ArgsClass | undefined = ArgsClass | undefined> {
+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 ModuleInput[], const TArguments extends ArgsClass | undefined = undefined>(options: ApplicationDefinitionOptions<TModules, TArguments>): ApplicationDefinition<TModules, TArguments>;
+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>;

package/dist/application/definition.js

@@ -1,6 +1,9 @@
 /// <reference lib="esnext.disposable" preserve="true" />
 import { buildApplicationModel } from '../core/index.js';
 export function defineApplication(options) {
+    if ('logger' in options) {
+        throw new TypeError('LUTRE_LOGGER_CONFIGURATION: Register provide(LoggerToken).useClass(LoggerService) in Module.providers.');
+    }
     return Object.freeze({
         kind: 'application-definition',
         model: buildApplicationModel({
@@ -11,6 +14,5 @@ export function defineApplication(options) {
         }),
         modules: options.modules,
         arguments: options.arguments,
-        ...(options.logger === undefined ? {} : { logger: options.logger }),
     });
 }

package/dist/application/kernel.d.ts

@@ -1,7 +1,6 @@
 /// <reference lib="esnext.disposable" preserve="true" />
 import type { RuntimeCapabilityBinding, RuntimeInstrumentation, 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;
@@ -14,7 +13,6 @@ export type KernelApplicationOptions<TDefinition extends ApplicationDefinition>
     readonly application: TDefinition;
     readonly capabilities?: readonly RuntimeCapabilityBinding[];
     readonly environment?: unknown;
-    readonly logger?: Logger;
     readonly forceShutdownTimeoutMs?: number;
     readonly instrumentation?: RuntimeInstrumentation;
 } & BootstrapArguments<TDefinition>;

package/dist/application/kernel.js

@@ -2,10 +2,8 @@
 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 }
             : {}),
@@ -53,7 +51,7 @@ export function createKernelApplication(options) {
             return runtime.shutdown(signal);
         },
         [Symbol.asyncDispose]() {
-            return application.close();
+            return this.close();
         },
     });
     return application;

package/dist/core/args.d.ts

@@ -7,6 +7,7 @@ export type ArgsKey<TValue = unknown> = RuntimeInputKey<TValue> & {
     readonly contract: ArgsClass;
 };
 export interface ArgsClass<TSchema extends ArgsSchema = ArgsSchema> extends Class<SchemaOutput<TSchema>> {
+    readonly '~loutre.descriptor': 'args';
     readonly kind: 'arguments';
     readonly schema: TSchema;
     key<TKey extends keyof SchemaOutput<TSchema> & string>(key: TKey): ArgsKey<SchemaOutput<TSchema>[TKey]>;

package/dist/core/args.js

@@ -4,12 +4,13 @@ export function defineArgs(schema) {
         static kind = 'arguments';
         static schema = schema;
         static key(key) {
-            return {
+            const descriptor = {
                 kind: 'runtime-input-key',
                 source: 'arguments',
                 contract: this,
                 key,
             };
+            return descriptor;
         }
         constructor(values) {
             Object.assign(this, values);

package/dist/core/env.d.ts

@@ -7,6 +7,7 @@ export type EnvKey<TValue = unknown> = RuntimeInputKey<TValue> & {
     readonly contract: EnvClass;
 };
 export interface EnvClass<TSchema extends EnvSchema = EnvSchema> extends Class<SchemaOutput<TSchema>> {
+    readonly '~loutre.descriptor': 'env';
     readonly kind: 'environment';
     readonly schema: TSchema;
     key<TKey extends keyof SchemaOutput<TSchema> & string>(key: TKey): EnvKey<SchemaOutput<TSchema>[TKey]>;

package/dist/core/env.js

@@ -4,12 +4,13 @@ export function defineEnv(schema) {
         static kind = 'environment';
         static schema = schema;
         static key(key) {
-            return {
+            const descriptor = {
                 kind: 'runtime-input-key',
                 source: 'environment',
                 contract: this,
                 key,
             };
+            return descriptor;
         }
         constructor(values) {
             Object.assign(this, values);

package/dist/core/extension.d.ts

@@ -1,13 +1,17 @@
+import type { Descriptor } from '../internal/brand.js';
+import type { ModuleId, ExecutionNodeId } from './model/identity.js';
+import type { CapabilityId, CapabilityIdentity, ExtensionName, ExtensionAbiVersion, ExtensionIdentity } from './identity.js';
+import type { DurationMs } from './units.js';
 import type { DependencyResolver } from './injection.js';
 import type { Diagnostic } from './diagnostic.js';
 import type { RuntimeExecutionMetadata, RuntimeInvocationRegistration, RuntimeOperationMetadata } from './instrumentation.js';
 import type { TokenLike } from './token.js';
 declare const runtimeCapabilityValue: unique symbol;
 declare const executionExtensionTypeInfo: unique symbol;
-export interface RuntimeCapability<TValue = unknown> {
+export interface RuntimeCapability<TValue = unknown> extends Descriptor<'runtime-capability'> {
     readonly kind: 'runtime-capability';
-    readonly id: string;
-    readonly identity: symbol;
+    readonly id: CapabilityId;
+    readonly identity: CapabilityIdentity;
     readonly [runtimeCapabilityValue]?: TValue;
 }
 export type RuntimeCapabilityValue<TCapability> = TCapability extends RuntimeCapability<infer TValue> ? TValue : never;
@@ -46,14 +50,14 @@ export interface ExecutionKernelRuntime {
     beginOperation?(metadata: RuntimeOperationMetadata, invocation?: RuntimeInvocationRegistration): ExecutionOperationLease;
 }
 export interface ExecutionExtensionDrainContext {
-    readonly timeoutMs: number;
+    readonly timeoutMs: DurationMs;
 }
 export interface ExecutionExtensionRuntime {
     drain?(context: ExecutionExtensionDrainContext): void | Promise<void>;
     close?(): void | Promise<void>;
 }
 export interface ExecutionCompileContext {
-    readonly moduleId: string;
+    readonly moduleId: ModuleId;
     readonly definitionIndex: number;
 }
 export interface ExecutionContribution<TCompiled = unknown> {
@@ -64,15 +68,18 @@ export interface ExecutionContribution<TCompiled = unknown> {
     readonly capabilities: readonly RuntimeCapability[];
     readonly compiled: TCompiled;
 }
+export type ModelExecutionContribution<TCompiled = unknown> = ExecutionContribution<TCompiled> & {
+    readonly id: ExecutionNodeId;
+};
 export interface ExecutionRuntimeBinding<TCompiled = unknown> {
-    readonly execution: ExecutionContribution<TCompiled>;
+    readonly execution: ModelExecutionContribution<TCompiled>;
     readonly resolve: DependencyResolver;
 }
 export interface ExecutionExtensionValidationContext<TCompiled = unknown> {
-    readonly executions: readonly ExecutionContribution<TCompiled>[];
+    readonly executions: readonly ModelExecutionContribution<TCompiled>[];
 }
 export interface ExecutionProjectionContext<TCompiled = unknown> {
-    readonly execution: ExecutionContribution<TCompiled>;
+    readonly execution: ModelExecutionContribution<TCompiled>;
 }
 export interface ExecutionExtensionRuntimeContext<TCompiled = unknown> {
     readonly executions: readonly ExecutionRuntimeBinding<TCompiled>[];
@@ -88,11 +95,11 @@ export interface HostExtension<TNamespace extends string = string, TApi extends
     readonly namespace: TNamespace;
     create(context: HostExtensionContext<TCompiled, TRuntime>): TApi;
 }
-export interface ExecutionExtension<TDefinition extends ExecutionDefinition<any> = ExecutionDefinition<any>, TCompiled = unknown, TNamespace extends string = string, THostApi extends object = object, TRuntime extends ExecutionExtensionRuntime = ExecutionExtensionRuntime> {
+export interface ExecutionExtension<TDefinition extends ExecutionDefinition<any> = ExecutionDefinition<any>, TCompiled = unknown, TNamespace extends string = string, THostApi extends object = object, TRuntime extends ExecutionExtensionRuntime = ExecutionExtensionRuntime> extends Descriptor<'execution-extension'> {
     readonly kind: 'execution-extension';
-    readonly name: string;
-    readonly abiVersion: string;
-    readonly identity: symbol;
+    readonly name: ExtensionName;
+    readonly abiVersion: ExtensionAbiVersion;
+    readonly identity: ExtensionIdentity;
     readonly [executionExtensionTypeInfo]?: readonly [TNamespace, THostApi];
     compile(definition: TDefinition, context: ExecutionCompileContext): ExecutionContribution<TCompiled>;
     references?(definition: TDefinition): readonly ExecutionDefinition[];
@@ -101,7 +108,10 @@ export interface ExecutionExtension<TDefinition extends ExecutionDefinition<any>
     projectGraph?(context: ExecutionProjectionContext<TCompiled>): unknown;
     readonly host?: HostExtension<TNamespace, THostApi, TCompiled, TRuntime>;
 }
-export declare function defineExecutionExtension<const TDefinition extends ExecutionDefinition, TCompiled, const TNamespace extends string = never, THostApi extends object = {}, TRuntime extends ExecutionExtensionRuntime = ExecutionExtensionRuntime>(extension: Omit<ExecutionExtension<TDefinition, TCompiled, TNamespace, THostApi, TRuntime>, 'identity'>): ExecutionExtension<TDefinition, TCompiled, TNamespace, THostApi, TRuntime>;
+export declare function defineExecutionExtension<const TDefinition extends ExecutionDefinition, TCompiled, const TNamespace extends string = never, THostApi extends object = {}, TRuntime extends ExecutionExtensionRuntime = ExecutionExtensionRuntime>(extension: Omit<ExecutionExtension<TDefinition, TCompiled, TNamespace, THostApi, TRuntime>, 'identity' | 'name' | 'abiVersion' | '~loutre.descriptor'> & {
+    readonly name: string;
+    readonly abiVersion: string;
+}): ExecutionExtension<TDefinition, TCompiled, TNamespace, THostApi, TRuntime>;
 export declare const executionDefinitionBrand: unique symbol;
 export interface ExecutionDefinition<TExtension extends AnyExecutionExtension = AnyExecutionExtension> {
     readonly kind: 'execution-definition';

package/dist/core/extension.js

@@ -6,7 +6,7 @@ export function runtimeCapability(id) {
     }
     return Object.freeze({
         kind: 'runtime-capability',
-        id,
+        id: id,
         identity: Symbol.for(`${runtimeCapabilityIdentityNamespace}${id}`),
     });
 }
@@ -49,6 +49,8 @@ export function defineExecutionExtension(extension) {
     }
     return Object.freeze({
         ...extension,
+        name: extension.name,
+        abiVersion: extension.abiVersion,
         ...(extension.host === undefined
             ? {}
             : { host: Object.freeze({ ...extension.host }) }),

package/dist/core/generic-layer.d.ts

@@ -1,17 +1,23 @@
+import type { Descriptor } from '../internal/brand.js';
 import type { RuntimeCapability } from './extension.js';
 import { type DependencyResolver } from './injection.js';
 import type { Type } from './type.js';
 export interface GenericLayerContext<TState extends object = {}> {
     readonly state: Readonly<TState>;
 }
-export type GenericLayerNext<TContribution extends object> = keyof TContribution extends never ? () => Promise<void> : (contribution: TContribution) => Promise<void>;
-export interface GenericLayer<TContext extends object = object, TContribution extends object = {}, TOutcome = unknown> {
+export type GenericLayerNext<TContribution extends object> = keyof TContribution extends never ? () => Promise<void> : {} extends TContribution ? (contribution?: TContribution) => Promise<void> : (contribution: TContribution) => Promise<void>;
+export interface GenericLayer<TContext extends object = object, TContribution extends object = {}, TOutcome = unknown> extends Descriptor<'generic-layer'> {
     readonly kind: 'generic-layer';
     readonly state?: Type<TContribution>;
     readonly name: string;
     readonly capabilities: readonly RuntimeCapability[];
     readonly factory: () => (context: TContext & GenericLayerContext, next: GenericLayerNext<TContribution>) => Promise<void | TOutcome>;
 }
+type LayerContribution<TLayer> = TLayer extends GenericLayer<any, infer TState, any> ? TState : never;
+type UnionToIntersection<T> = (T extends unknown ? (value: T) => void : never) extends (value: infer TState) => void ? TState : never;
+export type LayerState<TLayers extends readonly GenericLayer<any, any, any>[]> = [
+    TLayers[number]
+] extends [never] ? {} : UnionToIntersection<LayerContribution<TLayers[number]>> & object;
 export declare function defineLayer<TContribution extends object = {}, TContext extends object = object, TOutcome = never>(declaration: {
     readonly name: string;
     readonly state?: Type<TContribution>;
@@ -24,3 +30,4 @@ export declare function composeLayers<TContext extends object, TOutcome>(options
     readonly resolve: DependencyResolver;
     readonly terminal: (context: TContext & GenericLayerContext<Record<string, unknown>>) => Promise<TOutcome>;
 }): Promise<TOutcome>;
+export {};

package/dist/core/generic-layer.js

@@ -1,3 +1,4 @@
+import { dependencyConsumerId } from './identity.js';
 import { runInInjectionContext } from './injection.js';
 export function defineLayer(declaration) {
     return Object.freeze({
@@ -12,7 +13,7 @@ export function composeLayers(options) {
     const runtimes = options.layers.map((layer, index) => runInInjectionContext({
         consumer: {
             kind: 'layer',
-            id: `layer:${index}:${layer.name}`,
+            id: dependencyConsumerId(`layer:${index}:${layer.name}`),
             name: layer.name,
         },
         resolve: (token, consumer) => options.resolve(token, { source: layer.name, consumer }),

package/dist/core/identity.d.ts

@@ -0,0 +1,18 @@
+import type { Brand } from '../internal/brand.js';
+import type { ExecutionNodeId, ModelNodeId } from './model/identity.js';
+export type CapabilityId = Brand<string, 'core.capability-id'>;
+export type CapabilityIdentity = Brand<symbol, 'core.capability-identity'>;
+export type ExtensionName = Brand<string, 'core.extension-name'>;
+export type ExtensionAbiVersion = Brand<string, 'core.extension-abi'>;
+export type ExtensionIdentity = Brand<symbol, 'core.extension-identity'>;
+export type TokenKey = Brand<symbol, 'core.token-key'>;
+export type SyntheticExecutionId = Brand<string, 'core.synthetic-execution-id'>;
+export type RuntimeExecutionId = ExecutionNodeId | SyntheticExecutionId;
+export type DependencyConsumerId = ModelNodeId | Brand<string, 'core.dependency-consumer-id'>;
+export type ModuleName = Brand<string, 'core.module-name'>;
+export type HostNamespace = Brand<string, 'core.host-namespace'>;
+export declare const runtimeExecutionId: (value: string) => RuntimeExecutionId;
+export declare const syntheticExecutionId: (value: string) => SyntheticExecutionId;
+export declare const dependencyConsumerId: (value: string) => DependencyConsumerId;
+export declare const moduleName: (value: string) => ModuleName;
+export declare const hostNamespace: (value: string) => HostNamespace;

package/dist/core/identity.js

@@ -0,0 +1,5 @@
+export const runtimeExecutionId = (value) => value;
+export const syntheticExecutionId = (value) => value;
+export const dependencyConsumerId = (value) => value;
+export const moduleName = (value) => value;
+export const hostNamespace = (value) => value;

package/dist/core/index.d.ts

@@ -1,3 +1,5 @@
+export { LoggerService, LoggerToken } from './logger.js';
+export { LoggerModule } from './logger-module.js';
 export { defineArgs, isArgsClass, loadArgs } from './args.js';
 export type { ArgsClass, ArgsKey, ArgsSchema } from './args.js';
 export { diagnostic, hasErrorDiagnostics, isErrorDiagnostic, } from './diagnostic.js';
@@ -7,18 +9,18 @@ export type { EnvClass, EnvKey, EnvSchema } from './env.js';
 export { defineError, DomainError } from './error.js';
 export type { ErrorDefinition } from './error.js';
 export { bindRuntimeCapability, defineExecution, defineExecutionExtension, executionDefinitionBrand, isExecutionDefinition, runtimeCapability, RuntimeCapabilityRegistry, } from './extension.js';
-export type { AnyExecutionExtension, ExecutionCompileContext, ExecutionContribution, ExecutionRuntimeBinding, ExecutionDefinition, ExecutionDeclaration, ExecutionGroup, ExecutionContextView, ExecutionExtension, ExecutionExtensionDrainContext, ExecutionExtensionRuntime, ExecutionExtensionRuntimeContext, ExecutionExtensionValidationContext, ExecutionKernelRuntime, ExecutionLease, ExecutionProjectionContext, ExecutionOperationLease, ExtensionOfDefinition, HostApiOfExtension, HostExtension, HostExtensionContext, RuntimeCapability, RuntimeCapabilityBinding, RuntimeCapabilityBindings, RuntimeCapabilityValue, } from './extension.js';
+export type { AnyExecutionExtension, ExecutionCompileContext, ExecutionContribution, ModelExecutionContribution, ExecutionRuntimeBinding, ExecutionDefinition, ExecutionDeclaration, ExecutionGroup, ExecutionContextView, ExecutionExtension, ExecutionExtensionDrainContext, ExecutionExtensionRuntime, ExecutionExtensionRuntimeContext, ExecutionExtensionValidationContext, ExecutionKernelRuntime, ExecutionLease, ExecutionProjectionContext, ExecutionOperationLease, ExtensionOfDefinition, HostApiOfExtension, HostExtension, HostExtensionContext, RuntimeCapability, RuntimeCapabilityBinding, RuntimeCapabilityBindings, RuntimeCapabilityValue, } from './extension.js';
 export type { RuntimeExecutionMetadata, RuntimeInstrumentation, RuntimeInstrumentationScope, RuntimeInvocationRegistration, RuntimeProviderMetadata, RuntimeOperationMetadata, } from './instrumentation.js';
 export { composeLayers, defineLayer } from './generic-layer.js';
-export type { GenericLayer, GenericLayerContext, GenericLayerNext, } from './generic-layer.js';
+export type { GenericLayer, GenericLayerContext, GenericLayerNext, LayerState, } from './generic-layer.js';
 export { collectInjectedDependencies, inject, injectInquirer, InjectionContextError, runInInjectionContext, } from './injection.js';
 export type { DependencyConsumer, DependencyConsumerDescriptor, DependencyResolutionContext, DependencyResolver, InjectionContext, } from './injection.js';
 export { hook } from './lifecycle.js';
-export type { BeforeApplicationShutdown, LifecycleHook, ModuleLifecycle, OnApplicationBootstrap, OnApplicationShutdown, OnModuleDestroy, OnModuleInit, } from './lifecycle.js';
+export type { BeforeApplicationShutdown, LifecycleHook, ModuleLifecycle, OnApplicationBootstrap, OnApplicationShutdown, OnApplicationDispose, OnModuleDestroy, OnModuleInit, } from './lifecycle.js';
 export { ApplicationModelError, assertValidApplicationModel, buildApplicationModel, } from './model.js';
 export type { ApplicationModel, ApplicationModelBuildOptions, ApplicationModelEdge, ApplicationModelExtension, ApplicationModelExtensions, ApplicationModelNode, CompiledOf, ExecutionModelNode, FrameworkModelNode, LifecycleModelNode, ModuleModelNode, ProviderModelNode, } from './model.js';
-export { asModuleInstance, defineModule, moduleTypeInfo } from './module.js';
-export type { AnyModuleTemplate, ExtensionsOfModuleDefinition, ModuleDefinition, ModuleExtensions, ModuleHostApis, ModuleInstance, ModuleInput, ModuleTemplate, ModuleTypeInfo, } from './module.js';
+export { defineModule, moduleTypeInfo } from './module.js';
+export type { AnyModuleTemplate, ExtensionsOfModuleDefinition, ModuleDefinition, ModuleExtensions, ModuleHostApis, ModuleInstance, ModuleTemplate, ModuleTypeInfo, } from './module.js';
 export { argumentsProvider, environmentProvider, normalizeProvider, provide, } from './provider.js';
 export type { ArgumentsProvider, ClassProvider, ConditionalProvider, EnvironmentProvider, FactoryDefinition, FactoryProvider, ProviderDeclaration, ProviderDescriptor, ProviderScopeOptions, Scope, ValueProvider, } from './provider.js';
 export type { RuntimeInputContract, RuntimeInputKey } from './runtime-input.js';
@@ -30,3 +32,9 @@ export { token, tokenName } from './token.js';
 export type { AbstractClass, Class, Token, TokenLike, TokenOptions, TokenValue, } from './token.js';
 export { type } from './type.js';
 export type { Type, TypeOf } from './type.js';
+export type * from './model/identity.js';
+export * from './identity.js';
+export * from './units.js';
+export { parseModelNodeId, parseProviderNodeId } from './model/identity.js';
+export { sourceFileReference, sourceLine, sourceColumn, } from './source-location.js';
+export type { SourceLocationInput, SourceFileReference, SourceLine, SourceColumn, } from './source-location.js';