@loutrejs/loutre 0.6.0 → 0.7.0

package/dist/devtools/values.js

@@ -0,0 +1,175 @@
+const defaultMaxValueBytes = 64 * 1024;
+const defaultMaxDepth = 8;
+export function previewDevtoolsValue(value, options = {}) {
+    const maxValueBytes = options.maxValueBytes ?? defaultMaxValueBytes;
+    const maxDepth = options.maxDepth ?? defaultMaxDepth;
+    const redactions = new Set((options.redact ?? []).map((entry) => entry.trim().toLowerCase()));
+    let redacted = false;
+    let truncated = false;
+    const seen = new WeakSet();
+    const encode = (current, depth, path) => {
+        if (depth > maxDepth) {
+            truncated = true;
+            return '[Truncated]';
+        }
+        if (current === null)
+            return null;
+        switch (typeof current) {
+            case 'boolean':
+            case 'number':
+            case 'string':
+                return current;
+            case 'undefined':
+                return { $type: 'undefined' };
+            case 'bigint':
+                return { $type: 'bigint', value: current.toString() };
+            case 'function':
+            case 'symbol':
+                truncated = true;
+                return `[${typeof current}]`;
+            case 'object':
+                break;
+        }
+        if (current instanceof Date) {
+            return { $type: 'date', value: current.toISOString() };
+        }
+        if (current instanceof Uint8Array) {
+            return { $type: 'bytes', base64: bytesToBase64(current) };
+        }
+        if (seen.has(current)) {
+            truncated = true;
+            return '[Circular]';
+        }
+        seen.add(current);
+        try {
+            if (Array.isArray(current)) {
+                const output = [];
+                const descriptors = Object.getOwnPropertyDescriptors(current);
+                for (let index = 0; index < current.length; index += 1) {
+                    const descriptor = descriptors[String(index)];
+                    if (!descriptor) {
+                        output.length = index + 1;
+                        continue;
+                    }
+                    if (!('value' in descriptor)) {
+                        truncated = true;
+                        output[index] = '[Accessor]';
+                        continue;
+                    }
+                    output[index] = encode(descriptor.value, depth + 1, [
+                        ...path,
+                        String(index),
+                    ]);
+                }
+                return output;
+            }
+            if (current instanceof Map) {
+                return {
+                    $type: 'map',
+                    entries: [...current.entries()].map(([key, item], index) => [
+                        encode(key, depth + 1, [...path, String(index), 'key']),
+                        encode(item, depth + 1, [...path, String(index), 'value']),
+                    ]),
+                };
+            }
+            if (current instanceof Set) {
+                return {
+                    $type: 'set',
+                    values: [...current.values()].map((item, index) => encode(item, depth + 1, [...path, String(index)])),
+                };
+            }
+            const output = {};
+            for (const [key, descriptor] of Object.entries(Object.getOwnPropertyDescriptors(current))) {
+                if (!descriptor.enumerable)
+                    continue;
+                const nextPath = [...path, key];
+                if (shouldRedact(key, nextPath, redactions)) {
+                    redacted = true;
+                    output[key] = { $type: 'redacted' };
+                    continue;
+                }
+                if (!('value' in descriptor)) {
+                    truncated = true;
+                    output[key] = '[Accessor]';
+                    continue;
+                }
+                output[key] = encode(descriptor.value, depth + 1, nextPath);
+            }
+            return output;
+        }
+        finally {
+            seen.delete(current);
+        }
+    };
+    try {
+        const encoded = encode(value, 0, []);
+        const serialized = JSON.stringify(encoded);
+        const bytes = utf8ByteLength(serialized);
+        const preview = serialized.length > 512 ? `${serialized.slice(0, 509)}...` : serialized;
+        if (bytes > maxValueBytes) {
+            return {
+                preview,
+                truncated: true,
+                ...(redacted ? { redacted: true } : {}),
+                type: valueType(value),
+            };
+        }
+        return {
+            value: encoded,
+            preview,
+            ...(truncated ? { truncated: true } : {}),
+            ...(redacted ? { redacted: true } : {}),
+            type: valueType(value),
+        };
+    }
+    catch {
+        const type = safeValueType(value);
+        return {
+            preview: `[${type}]`,
+            truncated: true,
+            type,
+        };
+    }
+}
+function shouldRedact(key, path, redactions) {
+    if (redactions.size === 0)
+        return false;
+    const normalizedKey = key.toLowerCase();
+    const normalizedPath = path.join('.').toLowerCase();
+    return redactions.has(normalizedKey) || redactions.has(normalizedPath);
+}
+function valueType(value) {
+    if (value === null)
+        return 'null';
+    if (Array.isArray(value))
+        return 'array';
+    if (value instanceof Date)
+        return 'date';
+    if (value instanceof Uint8Array)
+        return 'bytes';
+    if (value instanceof Map)
+        return 'map';
+    if (value instanceof Set)
+        return 'set';
+    return typeof value === 'object' ? 'object' : typeof value;
+}
+function safeValueType(value) {
+    try {
+        return valueType(value);
+    }
+    catch {
+        return typeof value;
+    }
+}
+function utf8ByteLength(value) {
+    return new TextEncoder().encode(value).byteLength;
+}
+function bytesToBase64(value) {
+    let binary = '';
+    for (const byte of value)
+        binary += String.fromCharCode(byte);
+    const encoder = globalThis.btoa;
+    if (typeof encoder === 'function')
+        return encoder(binary);
+    return binary;
+}

package/dist/generated/version.d.ts

@@ -1 +1 @@
-export declare const LOUTRE_VERSION = "0.6.0";
+export declare const LOUTRE_VERSION = "0.7.0";

package/dist/generated/version.js

@@ -1,2 +1,2 @@
 // package manifestとのずれを避けるため、scripts/generate-version.mjsがbuild前に更新する。
-export const LOUTRE_VERSION = '0.6.0';
+export const LOUTRE_VERSION = '0.7.0';

package/dist/http/extension.js

@@ -409,7 +409,12 @@ function createHttpExtensionRuntime(executions, applicationRuntime) {
                         }
                         let lease;
                         try {
-                            lease = applicationRuntime.beginExecution();
+                            lease = applicationRuntime.beginExecution({
+                                executionId: match.executionId,
+                                executionKind: 'http.request',
+                                graphNodeId: match.executionId,
+                                name: `OPTIONS ${match.route.path}`,
+                            });
                         }
                         catch (error) {
                             completePendingIngress();
@@ -418,6 +423,7 @@ function createHttpExtensionRuntime(executions, applicationRuntime) {
                         try {
                             const headers = await createCorsPreflightResponseHeaders(match.route.middlewares, request, match.route.method);
                             if (headers) {
+                                lease.annotate?.({ 'http.status_code': 204 });
                                 return new Response(null, { status: 204, headers });
                             }
                         }
@@ -445,7 +451,30 @@ function createHttpExtensionRuntime(executions, applicationRuntime) {
                 return Response.json({ error: 'Internal Server Error' }, { status: 500 });
             }
             if (!match) {
-                return Response.json({ error: 'Not Found' }, { status: 404 });
+                const completePendingIngress = ingress.enter();
+                if (!completePendingIngress) {
+                    return Response.json({ error: 'Service Unavailable' }, { status: 503 });
+                }
+                let lease;
+                try {
+                    lease = applicationRuntime.beginExecution({
+                        executionId: 'http.not-found',
+                        executionKind: 'http.request',
+                        name: `${method} ${url.pathname}`,
+                    });
+                }
+                catch (error) {
+                    completePendingIngress();
+                    throw error;
+                }
+                try {
+                    lease.annotate?.({ 'http.status_code': 404 });
+                    return Response.json({ error: 'Not Found' }, { status: 404 });
+                }
+                finally {
+                    lease.complete();
+                    completePendingIngress();
+                }
             }
             const completePendingIngress = ingress.enter();
             if (!completePendingIngress) {
@@ -453,7 +482,12 @@ function createHttpExtensionRuntime(executions, applicationRuntime) {
             }
             let lease;
             try {
-                lease = applicationRuntime.beginExecution();
+                lease = applicationRuntime.beginExecution({
+                    executionId: match.executionId,
+                    executionKind: 'http.request',
+                    graphNodeId: match.executionId,
+                    name: `${match.route.method} ${match.route.path}`,
+                });
             }
             catch (error) {
                 completePendingIngress();
@@ -462,12 +496,17 @@ function createHttpExtensionRuntime(executions, applicationRuntime) {
             const abortRequest = () => lease.abort(request.signal.reason);
             let executionOwnedByStream = false;
             let executionFinished = false;
+            let executionResult;
+            let hasExecutionResult = false;
             const finishExecution = () => {
                 if (executionFinished)
                     return;
                 executionFinished = true;
                 request.signal.removeEventListener('abort', abortRequest);
-                lease.complete();
+                if (hasExecutionResult)
+                    lease.complete(executionResult);
+                else
+                    lease.complete();
             };
             const adoptResponseStream = (stream) => {
                 executionOwnedByStream = true;
@@ -486,9 +525,13 @@ function createHttpExtensionRuntime(executions, applicationRuntime) {
             request.signal.addEventListener('abort', abortRequest, { once: true });
             if (request.signal.aborted)
                 abortRequest();
+            const annotateResponse = (response) => {
+                lease.annotate?.({ 'http.status_code': response.status });
+                return response;
+            };
             try {
                 const corsHeaders = await createCorsActualResponseHeaders(match.route.middlewares, request);
-                const complete = (response) => applyFrameworkHeadersToResponse(response, corsHeaders);
+                const complete = (response) => annotateResponse(applyFrameworkHeadersToResponse(response, corsHeaders));
                 let context;
                 try {
                     context = await createHttpContext(request, url, match.params, match.route, lease.signal);
@@ -509,17 +552,50 @@ function createHttpExtensionRuntime(executions, applicationRuntime) {
                 if (!handler) {
                     throw new Error(`LUTRE_HTTP_HANDLER_MISSING: ${match.executionId}.${match.route.name}`);
                 }
-                const result = await composeLayers({
+                const dispatch = () => composeLayers({
                     context,
                     layers: match.route.middlewares,
                     resolve: (token, source) => applicationRuntime.resolve(token, source),
-                    terminal: async (middlewareContext) => handler({
-                        input: middlewareContext.input,
-                        response: middlewareContext.response,
-                        signal: middlewareContext.signal,
-                        state: middlewareContext.state,
-                    }),
+                    terminal: async (middlewareContext) => {
+                        const handlerName = `${match.executionId}.${match.route.name}`;
+                        const handlerOperation = applicationRuntime.beginOperation?.({
+                            kind: 'http.handler',
+                            name: handlerName,
+                            graphNodeId: match.executionId,
+                        }, {
+                            input: middlewareContext.input,
+                            invoke: (input) => replayHttpHandler(applicationRuntime, handler, match, input, middlewareContext.state),
+                        });
+                        const invoke = () => handler({
+                            input: middlewareContext.input,
+                            response: middlewareContext.response,
+                            signal: middlewareContext.signal,
+                            state: middlewareContext.state,
+                        });
+                        let result;
+                        let hasResult = false;
+                        try {
+                            result = await (handlerOperation?.run
+                                ? handlerOperation.run(invoke)
+                                : invoke());
+                            hasResult = true;
+                            return result;
+                        }
+                        catch (error) {
+                            handlerOperation?.fail?.(error);
+                            throw error;
+                        }
+                        finally {
+                            if (hasResult)
+                                handlerOperation?.complete(result);
+                            else
+                                handlerOperation?.complete();
+                        }
+                    },
                 });
+                const result = await (lease.run ? lease.run(dispatch) : dispatch());
+                executionResult = result;
+                hasExecutionResult = true;
                 const finalized = await finalizeHttpResult(match.route.definition, result, lease.signal, finishExecution);
                 if (finalized.streamControl)
                     adoptResponseStream(finalized.streamControl);
@@ -527,11 +603,12 @@ function createHttpExtensionRuntime(executions, applicationRuntime) {
             }
             catch (error) {
                 if (error instanceof HttpInputDecodeError) {
-                    return applyFrameworkHeadersToResponse(Response.json({ error: 'Invalid request' }, { status: 400 }), await safeCorsHeaders(match.route.middlewares, request));
+                    return annotateResponse(applyFrameworkHeadersToResponse(Response.json({ error: 'Invalid request' }, { status: 400 }), await safeCorsHeaders(match.route.middlewares, request)));
                 }
                 if (error instanceof HttpInputValidationError) {
-                    return applyFrameworkHeadersToResponse(Response.json({ error: 'Validation failed' }, { status: 400 }), await safeCorsHeaders(match.route.middlewares, request));
+                    return annotateResponse(applyFrameworkHeadersToResponse(Response.json({ error: 'Validation failed' }, { status: 400 }), await safeCorsHeaders(match.route.middlewares, request)));
                 }
+                lease.fail?.(error);
                 try {
                     const mapped = await mapDeclaredError(match.route.definition, error);
                     if (mapped) {
@@ -539,13 +616,13 @@ function createHttpExtensionRuntime(executions, applicationRuntime) {
                         if (finalized.streamControl) {
                             adoptResponseStream(finalized.streamControl);
                         }
-                        return applyFrameworkHeadersToResponse(finalized.response, await safeCorsHeaders(match.route.middlewares, request));
+                        return annotateResponse(applyFrameworkHeadersToResponse(finalized.response, await safeCorsHeaders(match.route.middlewares, request)));
                     }
                 }
                 catch {
                     // 内部のmapping/finalization errorをclientへ公開しない。
                 }
-                return applyFrameworkHeadersToResponse(Response.json({ error: 'Internal Server Error' }, { status: 500 }), await safeCorsHeaders(match.route.middlewares, request));
+                return annotateResponse(applyFrameworkHeadersToResponse(Response.json({ error: 'Internal Server Error' }, { status: 500 }), await safeCorsHeaders(match.route.middlewares, request)));
             }
             finally {
                 if (!executionOwnedByStream)
@@ -595,7 +672,16 @@ async function createHttpContext(request, url, rawParams, route, signal) {
         ? await validateRequestHeaders(definition.headers, definition.body !== undefined, request.headers)
         : Object.fromEntries(request.headers.entries());
     const body = definition?.body ? request.body : undefined;
-    const response = Object.fromEntries(Object.keys(route.definition.responses).map((name) => [
+    const response = createHttpResponseHelpers(route.definition.responses);
+    return {
+        request,
+        input: { params, query, headers, body },
+        response,
+        signal,
+    };
+}
+function createHttpResponseHelpers(responses) {
+    return Object.fromEntries(Object.keys(responses).map((name) => [
         name,
         (value = {}) => ({
             kind: 'http-result',
@@ -604,12 +690,40 @@ async function createHttpContext(request, url, rawParams, route, signal) {
             ...(value.headers === undefined ? {} : { headers: value.headers }),
         }),
     ]));
-    return {
-        request,
-        input: { params, query, headers, body },
-        response,
-        signal,
-    };
+}
+async function replayHttpHandler(applicationRuntime, handler, match, input, state) {
+    if (typeof input !== 'object' || input === null || Array.isArray(input)) {
+        throw new TypeError('LUTRE_DEVTOOLS_HTTP_HANDLER_INPUT_REQUIRED');
+    }
+    const lease = applicationRuntime.beginExecution({
+        executionId: match.executionId,
+        executionKind: 'http.handler',
+        graphNodeId: match.executionId,
+        name: `${match.executionId}.${match.route.name}`,
+    });
+    const invoke = () => handler({
+        input,
+        response: createHttpResponseHelpers(match.route.definition.responses),
+        signal: lease.signal,
+        state,
+    });
+    let result;
+    let hasResult = false;
+    try {
+        result = await (lease.run ? lease.run(invoke) : invoke());
+        hasResult = true;
+        return result;
+    }
+    catch (error) {
+        lease.fail?.(error);
+        throw error;
+    }
+    finally {
+        if (hasResult)
+            lease.complete(result);
+        else
+            lease.complete();
+    }
 }
 async function finalizeHttpResult(route, result, signal, completeExecution) {
     const response = route.responses[result.response];

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

@@ -10,11 +10,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);
@@ -132,8 +134,10 @@ export class Container {
     #create(provider, lineage) {
         try {
             switch (provider.kind) {
-                case 'value':
+                case 'value': {
+                    this.#hooks.created?.(provider, provider.useValue);
                     return provider.useValue;
+                }
                 case 'environment': {
                     if (this.#environment.has(provider.provide)) {
                         return this.#environment.get(provider.provide);
@@ -146,14 +150,18 @@ export class Container {
                     }
                     throw new DependencyResolutionError(`LUTRE_ARGS_005: Arguments ${provider.provide.name} requires runtime Arguments before Application initialization.`);
                 }
-                case 'class':
-                    return this.#instantiate(provider.useClass, lineage);
+                case 'class': {
+                    const value = this.#instantiate(provider.useClass, lineage);
+                    this.#hooks.created?.(provider, value);
+                    return value;
+                }
                 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.');
                     }
+                    this.#hooks.created?.(provider, value);
                     return value;
                 }
                 case 'conditional': {
@@ -163,7 +171,9 @@ export class Container {
                     if (!implementation) {
                         throw new DependencyResolutionError(`No conditional Provider matches ${provider.select.key}=${String(selected)}`);
                     }
-                    return this.#instantiate(implementation, lineage);
+                    const value = this.#instantiate(implementation, lineage);
+                    this.#hooks.created?.(provider, value);
+                    return value;
                 }
             }
         }

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>;
 }