@loutrejs/loutre 0.6.0 → 0.8.0

package/dist/http/runtime/response.js

@@ -1,4 +1,5 @@
 import { validateSchema } from '../../core/index.js';
+import { match } from 'ts-pattern';
 export async function validateResponseHeaders(schema, headers) {
     if (!schema) {
         if (headers !== undefined) {
@@ -15,18 +16,17 @@ export async function validateResponseHeaders(schema, headers) {
     return validated;
 }
 export function responseHeadersSchema(headers) {
-    if (isStandardSchema(headers))
-        return headers;
-    if (isResponseHeadersWithDefaults(headers))
-        return headers.schema;
-    return undefined;
+    return match(headers)
+        .when(isStandardSchema, (schema) => schema)
+        .when(isResponseHeadersWithDefaults, (definition) => definition.schema)
+        .otherwise(() => undefined);
 }
 export function responseHeadersDefaults(headers) {
-    if (headers === undefined || isStandardSchema(headers))
-        return undefined;
-    if (isResponseHeadersWithDefaults(headers))
-        return headers.defaults;
-    return headers;
+    return match(headers)
+        .with(undefined, () => undefined)
+        .when(isStandardSchema, () => undefined)
+        .when(isResponseHeadersWithDefaults, (definition) => definition.defaults)
+        .otherwise((definition) => definition);
 }
 export function isStandardSchema(value) {
     return typeof value === 'object' && value !== null && '~standard' in value;

package/dist/message-port/extension.js

@@ -97,8 +97,13 @@ function createMessagePortRuntime(executions, applicationRuntime) {
         }, () => execution.compiled.factory());
         for (const [method, definition] of Object.entries(execution.compiled.routes)) {
             const handler = handlers[method];
-            if (handler)
-                routes.set(method, { route: definition, handler });
+            if (handler) {
+                routes.set(method, {
+                    executionId: execution.id,
+                    route: definition,
+                    handler,
+                });
+            }
         }
     }
     return {
@@ -114,7 +119,12 @@ function createMessagePortRuntime(executions, applicationRuntime) {
             }
             let lease;
             try {
-                lease = applicationRuntime.beginExecution();
+                lease = applicationRuntime.beginExecution({
+                    executionId: route.executionId,
+                    executionKind: 'message-port.invocation',
+                    graphNodeId: route.executionId,
+                    name: method,
+                });
             }
             catch (error) {
                 completePendingIngress();
@@ -133,11 +143,12 @@ function createMessagePortRuntime(executions, applicationRuntime) {
                         value: result,
                     }),
                 ]));
-                const result = await route.handler({
+                const invoke = () => route.handler({
                     input: value,
                     response,
                     signal: lease.signal,
                 });
+                const result = await (lease.run ? lease.run(invoke) : invoke());
                 const schema = route.route.responses[result.response];
                 if (!schema) {
                     throw new Error(`LUTRE_MESSAGE_PORT_RESPONSE_UNDECLARED: ${result.response}`);
@@ -155,6 +166,10 @@ function createMessagePortRuntime(executions, applicationRuntime) {
                     value: await validateSchema(schema, result.value),
                 };
             }
+            catch (error) {
+                lease.fail?.(error);
+                throw error;
+            }
             finally {
                 if (!executionOwnedByStream)
                     lease.complete();
@@ -290,6 +305,7 @@ function createLeasedMessagePortStream(schema, source, lease, activeStreams) {
     else
         lease.signal.addEventListener('abort', onAbort, { once: true });
     const closeAfterError = async (error) => {
+        lease.fail?.(error);
         let cleanupError;
         try {
             await startIteratorCleanup(error);

package/dist/runtime/di.d.ts

@@ -3,8 +3,12 @@ import { Logger } from './logger.js';
 export declare class DependencyResolutionError extends Error {
     constructor(message: string);
 }
+export interface ContainerHooks {
+    created?(provider: ProviderDescriptor, value: unknown): void;
+}
 export interface ContainerOptions {
     readonly logger?: Logger;
+    readonly hooks?: ContainerHooks;
     readonly environment?: ReadonlyMap<EnvClass, object>;
     readonly arguments?: ReadonlyMap<ArgsClass, object>;
 }

package/dist/runtime/di.js

@@ -1,5 +1,6 @@
 import { isArgsClass, isEnvClass, runInInjectionContext, tokenName, } from '../core/index.js';
 import { Logger } from './logger.js';
+import { match } from 'ts-pattern';
 export class DependencyResolutionError extends Error {
     constructor(message) {
         super(message);
@@ -10,11 +11,13 @@ export class Container {
     #providers = new Map();
     #applicationCache = new Map();
     #logger;
+    #hooks;
     #environment = new Map();
     #arguments = new Map();
     constructor(providers, options = {}) {
         this.#logger =
             options instanceof Logger ? options : (options.logger ?? new Logger());
+        this.#hooks = options instanceof Logger ? {} : (options.hooks ?? {});
         if (!(options instanceof Logger)) {
             for (const [environment, value] of options.environment ?? []) {
                 this.#environment.set(environment, value);
@@ -131,41 +134,49 @@ export class Container {
     }
     #create(provider, lineage) {
         try {
-            switch (provider.kind) {
-                case 'value':
-                    return provider.useValue;
-                case 'environment': {
-                    if (this.#environment.has(provider.provide)) {
-                        return this.#environment.get(provider.provide);
-                    }
-                    throw new DependencyResolutionError(`LUTRE_ENV_005: Environment ${provider.provide.name} requires a runtime Environment source before Application initialization.`);
+            return match(provider)
+                .with({ kind: 'value' }, (candidate) => {
+                this.#hooks.created?.(candidate, candidate.useValue);
+                return candidate.useValue;
+            })
+                .with({ kind: 'environment' }, (candidate) => {
+                if (this.#environment.has(candidate.provide)) {
+                    return this.#environment.get(candidate.provide);
                 }
-                case 'arguments': {
-                    if (this.#arguments.has(provider.provide)) {
-                        return this.#arguments.get(provider.provide);
-                    }
-                    throw new DependencyResolutionError(`LUTRE_ARGS_005: Arguments ${provider.provide.name} requires runtime Arguments before Application initialization.`);
+                throw new DependencyResolutionError(`LUTRE_ENV_005: Environment ${candidate.provide.name} requires a runtime Environment source before Application initialization.`);
+            })
+                .with({ kind: 'arguments' }, (candidate) => {
+                if (this.#arguments.has(candidate.provide)) {
+                    return this.#arguments.get(candidate.provide);
                 }
-                case 'class':
-                    return this.#instantiate(provider.useClass, lineage);
-                case 'factory': {
-                    const dependencies = provider.inject.map((token) => this.#resolve(token, tokenName(provider.provide), lineage));
-                    const value = provider.useFactory(...dependencies);
-                    if (isThenable(value)) {
-                        throw new DependencyResolutionError('LUTRE_DI_ASYNC_FACTORY: Async factory providers are not supported. Move asynchronous resource initialization to application lifecycle.');
-                    }
-                    return value;
+                throw new DependencyResolutionError(`LUTRE_ARGS_005: Arguments ${candidate.provide.name} requires runtime Arguments before Application initialization.`);
+            })
+                .with({ kind: 'class' }, (candidate) => {
+                const value = this.#instantiate(candidate.useClass, lineage);
+                this.#hooks.created?.(candidate, value);
+                return value;
+            })
+                .with({ kind: 'factory' }, (candidate) => {
+                const dependencies = candidate.inject.map((token) => this.#resolve(token, tokenName(candidate.provide), lineage));
+                const value = candidate.useFactory(...dependencies);
+                if (isThenable(value)) {
+                    throw new DependencyResolutionError('LUTRE_DI_ASYNC_FACTORY: Async factory providers are not supported. Move asynchronous resource initialization to application lifecycle.');
                 }
-                case 'conditional': {
-                    const input = this.#resolve(provider.select.contract, tokenName(provider.provide), lineage);
-                    const selected = input[provider.select.key];
-                    const implementation = provider.mapping[selected];
-                    if (!implementation) {
-                        throw new DependencyResolutionError(`No conditional Provider matches ${provider.select.key}=${String(selected)}`);
-                    }
-                    return this.#instantiate(implementation, lineage);
+                this.#hooks.created?.(candidate, value);
+                return value;
+            })
+                .with({ kind: 'conditional' }, (candidate) => {
+                const input = this.#resolve(candidate.select.contract, tokenName(candidate.provide), lineage);
+                const selected = input[candidate.select.key];
+                const implementation = candidate.mapping[selected];
+                if (!implementation) {
+                    throw new DependencyResolutionError(`No conditional Provider matches ${candidate.select.key}=${String(selected)}`);
                 }
-            }
+                const value = this.#instantiate(implementation, lineage);
+                this.#hooks.created?.(candidate, value);
+                return value;
+            })
+                .exhaustive();
         }
         catch (error) {
             if (provider.scope === 'application') {

package/dist/runtime/engine.d.ts

@@ -1,3 +1,3 @@
-export type RuntimeEngine = 'node' | 'bun' | 'deno' | 'cloudflare-workers' | 'aws-lambda' | 'electron' | 'unknown';
+export type RuntimeEngine = 'node' | 'bun' | 'cloudflare-workers' | 'aws-lambda' | 'electron' | 'unknown';
 export declare function detectRuntimeEngine(): RuntimeEngine;
 export declare function assertRuntimeEngine(expected: Exclude<RuntimeEngine, 'unknown'>): void;

package/dist/runtime/engine.js

@@ -1,7 +1,6 @@
 const runtimeLabels = {
     node: 'Node.js',
     bun: 'Bun',
-    deno: 'Deno',
     'cloudflare-workers': 'Cloudflare Workers',
     'aws-lambda': 'AWS Lambda',
     electron: 'Electron',
@@ -14,7 +13,7 @@ export function detectRuntimeEngine() {
         return 'bun';
     }
     if (globals.Deno !== undefined)
-        return 'deno';
+        return 'unknown';
     if (globals.navigator?.userAgent === 'Cloudflare-Workers' ||
         globals.WebSocketPair !== undefined) {
         return 'cloudflare-workers';

package/dist/runtime/kernel.d.ts

@@ -1,4 +1,4 @@
-import { RuntimeCapabilityRegistry, type ApplicationModel, type ExecutionExtension, type ExecutionExtensionRuntime, type ExecutionKernelRuntime, type ExecutionLease, type RuntimeCapabilityBinding, type TokenLike } from '../core/index.js';
+import { RuntimeCapabilityRegistry, type ApplicationModel, type ExecutionExtension, type ExecutionExtensionRuntime, type ExecutionKernelRuntime, type ExecutionLease, type ExecutionOperationLease, type RuntimeCapabilityBinding, type RuntimeExecutionMetadata, type RuntimeInstrumentation, type RuntimeInvocationRegistration, type RuntimeOperationMetadata, type TokenLike } from '../core/index.js';
 import { Container } from './di.js';
 import { Logger } from './logger.js';
 export interface ApplicationKernelRuntimeOptions {
@@ -7,6 +7,7 @@ export interface ApplicationKernelRuntimeOptions {
     readonly environmentSource?: unknown;
     readonly argumentsSource?: unknown;
     readonly forceShutdownTimeoutMs?: number;
+    readonly instrumentation?: RuntimeInstrumentation;
 }
 export declare class ApplicationKernelRuntime implements ExecutionKernelRuntime {
     #private;
@@ -18,6 +19,7 @@ export declare class ApplicationKernelRuntime implements ExecutionKernelRuntime
     resolve<TValue>(token: TokenLike<TValue>, source?: string): TValue;
     get<TValue>(token: TokenLike<TValue>): TValue;
     extensionRuntime<TRuntime extends ExecutionExtensionRuntime>(extension: ExecutionExtension<any, any, any, any, TRuntime>): TRuntime;
-    beginExecution(): ExecutionLease;
+    beginExecution(metadata?: RuntimeExecutionMetadata, invocation?: RuntimeInvocationRegistration): ExecutionLease;
+    beginOperation(metadata: RuntimeOperationMetadata, invocation?: RuntimeInvocationRegistration): ExecutionOperationLease;
     shutdown(signal?: string): Promise<void>;
 }

package/dist/runtime/kernel.js

@@ -1,4 +1,4 @@
-import { assertValidApplicationModel, loadArgs, loadEnv, RuntimeCapabilityRegistry, } from '../core/index.js';
+import { assertValidApplicationModel, loadArgs, loadEnv, RuntimeCapabilityRegistry, tokenName, } from '../core/index.js';
 import { Container } from './di.js';
 import { ExecutionTracker } from './execution-tracker.js';
 import { Logger } from './logger.js';
@@ -9,29 +9,39 @@ export class ApplicationKernelRuntime {
     capabilities;
     #extensionRuntimes = new Map();
     #providerInstances = new Map();
+    #providerNodes = new Map();
     #initializedModuleIds = new Set();
     #executions = new ExecutionTracker();
     #extensionDrainOperations = new Map();
     #environmentSource;
     #argumentsSource;
     #forceShutdownTimeoutMs;
+    #instrumentation;
     #state = 'created';
     #initialization;
     #shutdown;
     constructor(model, options = {}) {
         this.model = assertValidApplicationModel(model);
+        for (const node of this.model.nodes) {
+            if (node.kind === 'provider')
+                this.#providerNodes.set(node.provider, node);
+        }
         this.capabilities = new RuntimeCapabilityRegistry(options.capabilities ?? []);
         this.#environmentSource = options.environmentSource;
         this.#argumentsSource =
             'argumentsSource' in options ? options.argumentsSource : Object.freeze({});
         this.#forceShutdownTimeoutMs =
             options.forceShutdownTimeoutMs ?? defaultForceShutdownTimeoutMs;
+        this.#instrumentation = options.instrumentation;
         if (!Number.isFinite(this.#forceShutdownTimeoutMs) ||
             this.#forceShutdownTimeoutMs < 0) {
             throw new TypeError('LUTRE_FORCE_SHUTDOWN_TIMEOUT: forceShutdownTimeoutMs must be a non-negative finite number.');
         }
         this.container = new Container(model.providers, {
             logger: options.logger ?? new Logger(),
+            hooks: {
+                created: (provider, value) => this.#notifyProviderCreated(provider, value),
+            },
         });
     }
     initialize() {
@@ -149,10 +159,48 @@ export class ApplicationKernelRuntime {
         }
         return runtime;
     }
-    beginExecution() {
+    beginExecution(metadata, invocation) {
         if (this.#state !== 'running')
             throw applicationStateError(this.#state);
-        return this.#executions.begin();
+        const tracked = this.#executions.begin();
+        if (metadata === undefined)
+            return tracked;
+        const scope = safely(() => this.#instrumentation?.beginExecution?.(metadata, invocation));
+        if (!scope)
+            return tracked;
+        const instrumented = instrumentationLease(scope);
+        return {
+            signal: tracked.signal,
+            run: instrumented.run,
+            abort(reason) {
+                callInstrumentation(() => scope.abort?.(reason));
+                tracked.abort(reason);
+            },
+            fail: instrumented.fail,
+            annotate: instrumented.annotate,
+            complete(...result) {
+                instrumented.complete(...result);
+                tracked.complete();
+            },
+        };
+    }
+    beginOperation(metadata, invocation) {
+        return instrumentationLease(safely(() => this.#instrumentation?.beginOperation?.(metadata, invocation)));
+    }
+    #notifyProviderCreated(provider, value) {
+        const instrumentation = this.#instrumentation;
+        if (!instrumentation?.providerCreated)
+            return;
+        const providerNode = this.#providerNodes.get(provider);
+        if (!providerNode)
+            return;
+        callInstrumentation(() => instrumentation.providerCreated({
+            providerId: providerNode.id,
+            graphNodeId: providerNode.id,
+            name: tokenName(providerNode.token),
+            scope: provider.scope,
+            providerKind: provider.kind,
+        }, value));
     }
     shutdown(signal) {
         if (this.#state === 'stopped')
@@ -171,6 +219,7 @@ export class ApplicationKernelRuntime {
             await this.#initialization.catch(() => undefined);
         if (this.#state === 'created') {
             this.#state = 'stopped';
+            await closeInstrumentation(this.#instrumentation);
             return;
         }
         if (this.#state === 'stopped')
@@ -225,6 +274,7 @@ export class ApplicationKernelRuntime {
         this.#extensionDrainOperations.clear();
         await this.#cleanupProviders(signal, errors);
         this.#state = 'stopped';
+        await closeInstrumentation(this.#instrumentation);
         if (errors.length > 0) {
             throw new AggregateError(errors, 'Application shutdown failed.');
         }
@@ -281,6 +331,7 @@ export class ApplicationKernelRuntime {
                 await collectError(() => callLifecycle(instance, 'onModuleDestroy'), errors);
             }
         }
+        await closeInstrumentation(this.#instrumentation);
         return errors;
     }
     async #runHook(hook) {
@@ -306,6 +357,48 @@ function lifecycleHookOf(model, moduleId, phase) {
         node.moduleId === moduleId &&
         node.phase === phase)?.hook;
 }
+function instrumentationLease(scope) {
+    return {
+        run(operation) {
+            if (!scope?.run)
+                return operation();
+            return scope.run(operation);
+        },
+        fail(reason) {
+            callInstrumentation(() => scope?.fail?.(reason));
+        },
+        annotate(attributes) {
+            callInstrumentation(() => scope?.annotate?.(attributes));
+        },
+        complete(...result) {
+            callInstrumentation(() => scope?.complete(...result));
+        },
+    };
+}
+function safely(operation) {
+    try {
+        return operation();
+    }
+    catch {
+        return undefined;
+    }
+}
+function callInstrumentation(operation) {
+    try {
+        operation();
+    }
+    catch {
+        // instrumentation障害をApplication semanticsへ伝播させてはならない。
+    }
+}
+async function closeInstrumentation(instrumentation) {
+    try {
+        await instrumentation?.close?.();
+    }
+    catch {
+        // instrumentationのcleanup失敗をshutdown失敗として扱わない。
+    }
+}
 async function withTimeout(operation, timeoutMs, createTimeoutError) {
     let timer;
     try {

package/dist/runtime/node-capabilities.d.ts

@@ -1,4 +1,4 @@
-/** CLIが`@loutrejs/node`へ依存するとBun/DenoでもNode.js専用moduleを評価するため、Capability metadataだけをruntime-neutral側へ分離する。 */
+/** CLIが`@loutrejs/node`へ依存するとBunでもNode.js専用moduleを評価するため、Capability metadataだけをruntime-neutral側へ分離する。 */
 export declare const nodeRuntimeSupport: {
     readonly runtime: 'node';
     readonly capabilities: Set<string>;

package/dist/runtime/node-capabilities.js

@@ -1,8 +1,9 @@
-/** CLIが`@loutrejs/node`へ依存するとBun/DenoでもNode.js専用moduleを評価するため、Capability metadataだけをruntime-neutral側へ分離する。 */
+/** CLIが`@loutrejs/node`へ依存するとBunでもNode.js専用moduleを評価するため、Capability metadataだけをruntime-neutral側へ分離する。 */
 export const nodeRuntimeSupport = {
     runtime: 'node',
     capabilities: new Set([
         'http.server',
+        'websocket.server',
         'http.request.streaming',
         'http.response.streaming',
         'stream.readable',