@loutrejs/loutre 0.5.0 → 0.6.0

package/dist/runtime/di.js

@@ -1,4 +1,4 @@
-import { asModuleInstance, childPipelineOf, isArgsClass, isEnvClass, layerDefinitionOf, normalizeProvider, runInInjectionContext, tokenName, } from '../core/index.js';
+import { isArgsClass, isEnvClass, runInInjectionContext, tokenName, } from '../core/index.js';
 import { Logger } from './logger.js';
 export class DependencyResolutionError extends Error {
     constructor(message) {
@@ -6,59 +6,15 @@ export class DependencyResolutionError extends Error {
         this.name = 'DependencyResolutionError';
     }
 }
-class GraphProbeBoundary extends Error {
-    source;
-    constructor(source) {
-        super(`Graph Probe reached runtime-dependent value: ${source}`);
-        this.source = source;
-        this.name = 'GraphProbeBoundary';
-    }
-}
-export function collectRuntimeModuleGraph(roots) {
-    const modules = [];
-    const providers = [];
-    const environmentProviders = new Set();
-    const visited = new Set();
-    const visit = (moduleLike) => {
-        const module = asModuleInstance(moduleLike);
-        if (visited.has(module))
-            return;
-        visited.add(module);
-        for (const imported of module.definition.imports ?? [])
-            visit(imported);
-        modules.push(module);
-        for (const declaration of module.definition.providers ?? []) {
-            const provider = normalizeProvider(declaration);
-            if (provider.kind === 'environment') {
-                if (environmentProviders.has(provider.provide))
-                    continue;
-                environmentProviders.add(provider.provide);
-            }
-            providers.push(provider);
-        }
-    };
-    for (const root of roots)
-        visit(root);
-    return { modules, providers };
-}
 export class Container {
     #providers = new Map();
     #applicationCache = new Map();
-    #implementationCache = new Map();
-    #implementationConsumers = new Map();
-    #taskCache = new Map();
-    #taskConsumers = new Map();
-    #layerCache = new Map();
     #logger;
-    #recorder;
     #environment = new Map();
     #arguments = new Map();
-    #probe;
     constructor(providers, options = {}) {
         this.#logger =
             options instanceof Logger ? options : (options.logger ?? new Logger());
-        this.#recorder = options instanceof Logger ? undefined : options.recorder;
-        this.#probe = options instanceof Logger ? false : (options.probe ?? false);
         if (!(options instanceof Logger)) {
             for (const [environment, value] of options.environment ?? []) {
                 this.#environment.set(environment, value);
@@ -107,8 +63,8 @@ export class Container {
         }
         this.#arguments.set(argumentsContract, value);
     }
-    resolve(token) {
-        return this.#resolve(token);
+    resolve(token, source) {
+        return this.#resolve(token, source);
     }
     get(token) {
         const provider = this.#providers.get(token);
@@ -141,112 +97,6 @@ export class Container {
         }
         throw new DependencyResolutionError(`LUTRE_DI_NOT_INITIALIZED: ${tokenName(token)} has not been constructed by Application initialization.`);
     }
-    probeClass(target) {
-        try {
-            return this.#instantiate(target, [target]);
-        }
-        catch (error) {
-            if (isGraphProbeBoundary(error)) {
-                return createOpaqueProbeValue(target.name);
-            }
-            throw error;
-        }
-    }
-    prepareImplementation(implementation) {
-        if (this.#implementationCache.has(implementation))
-            return;
-        let consumer = this.#implementationConsumers.get(implementation);
-        if (!consumer) {
-            consumer = {
-                kind: 'implementation-consumer',
-                id: `runtime-implementation:${this.#implementationConsumers.size + 1}`,
-                name: implementation.name,
-            };
-            this.#implementationConsumers.set(implementation, consumer);
-        }
-        this.#constructImplementation(implementation, consumer, true);
-    }
-    implementationRuntime(implementation) {
-        const cached = this.#implementationCache.get(implementation);
-        if (!cached) {
-            throw new DependencyResolutionError(`LUTRE_IMPL_NOT_PREPARED: Implementation ${implementation.name} is not prepared during application construction.`);
-        }
-        return cached;
-    }
-    prepareTask(task) {
-        if (this.#taskCache.has(task))
-            return;
-        let consumer = this.#taskConsumers.get(task);
-        if (!consumer) {
-            consumer = {
-                kind: 'task-consumer',
-                id: `runtime-task:${this.#taskConsumers.size + 1}`,
-                name: task.name,
-            };
-            this.#taskConsumers.set(task, consumer);
-        }
-        this.#constructTask(task, consumer, true);
-    }
-    taskRuntime(task) {
-        const cached = this.#taskCache.get(task);
-        if (!cached) {
-            throw new DependencyResolutionError(`LUTRE_TASK_NOT_PREPARED: Task ${task.name} is not prepared during application construction.`);
-        }
-        return cached;
-    }
-    probeTask(task, consumer) {
-        try {
-            this.#constructTask(task, consumer, false);
-        }
-        catch (error) {
-            if (isGraphProbeBoundary(error))
-                return;
-            throw error;
-        }
-    }
-    probeImplementation(implementation, consumer) {
-        try {
-            return this.#constructImplementation(implementation, consumer, false);
-        }
-        catch (error) {
-            if (isGraphProbeBoundary(error)) {
-                return createOpaqueProbeValue(implementation.name);
-            }
-            throw error;
-        }
-    }
-    preparePipeline(pipeline) {
-        for (const item of pipeline) {
-            if (item.kind !== 'layer')
-                continue;
-            const definition = layerDefinitionOf(item);
-            this.#constructLayer(definition, {
-                kind: 'layer-consumer',
-                id: `runtime-layer:${definition.name}`,
-                name: definition.name,
-            }, true);
-            const child = childPipelineOf(item);
-            if (child)
-                this.preparePipeline(child);
-        }
-    }
-    layerRuntime(layer) {
-        const cached = this.#layerCache.get(layer);
-        if (!cached) {
-            throw new DependencyResolutionError(`LUTRE_LAYER_NOT_PREPARED: Layer ${layer.name} is not prepared during application construction.`);
-        }
-        return cached;
-    }
-    probeLayer(layer, consumer) {
-        try {
-            this.#constructLayer(layer, consumer, false);
-        }
-        catch (error) {
-            if (isGraphProbeBoundary(error))
-                return;
-            throw error;
-        }
-    }
     #resolve(token, source, lineage = []) {
         const cycleStart = lineage.indexOf(token);
         if (cycleStart >= 0) {
@@ -272,9 +122,9 @@ export class Container {
         if (provider.scope !== 'application') {
             return this.#create(provider, nextLineage);
         }
-        const cached = this.#applicationCache.get(token);
-        if (this.#applicationCache.has(token))
-            return cached;
+        if (this.#applicationCache.has(token)) {
+            return this.#applicationCache.get(token);
+        }
         const instance = this.#create(provider, nextLineage);
         this.#applicationCache.set(token, instance);
         return instance;
@@ -288,17 +138,13 @@ export class Container {
                     if (this.#environment.has(provider.provide)) {
                         return this.#environment.get(provider.provide);
                     }
-                    if (this.#probe)
-                        return createOpaqueProbeValue(provider.provide.name);
                     throw new DependencyResolutionError(`LUTRE_ENV_005: Environment ${provider.provide.name} requires a runtime Environment source before Application initialization.`);
                 }
                 case 'arguments': {
                     if (this.#arguments.has(provider.provide)) {
                         return this.#arguments.get(provider.provide);
                     }
-                    if (this.#probe)
-                        return createOpaqueProbeValue(provider.provide.name);
-                    throw new DependencyResolutionError(`LUTRE_ARGS_005: Arguments ${provider.provide.name} requires a runtime Arguments source before Application initialization.`);
+                    throw new DependencyResolutionError(`LUTRE_ARGS_005: Arguments ${provider.provide.name} requires runtime Arguments before Application initialization.`);
                 }
                 case 'class':
                     return this.#instantiate(provider.useClass, lineage);
@@ -311,8 +157,6 @@ export class Container {
                     return value;
                 }
                 case 'conditional': {
-                    if (this.#probe)
-                        return Object.create(null);
                     const input = this.#resolve(provider.select.contract, tokenName(provider.provide), lineage);
                     const selected = input[provider.select.key];
                     const implementation = provider.mapping[selected];
@@ -327,9 +171,6 @@ export class Container {
             if (provider.scope === 'application') {
                 this.#applicationCache.delete(provider.provide);
             }
-            if (this.#probe && isGraphProbeBoundary(error)) {
-                return createOpaqueProbeValue(tokenName(provider.provide));
-            }
             throw error;
         }
     }
@@ -340,133 +181,15 @@ export class Container {
         return runInInjectionContext({
             consumer: target,
             resolve: (token) => this.#resolve(token, target.name, lineage),
-            ...(this.#recorder === undefined
-                ? {}
-                : {
-                    record: (consumer, dependency) => this.#recorder.record(consumer, dependency),
-                }),
         }, () => new target());
     }
-    #constructLayer(layer, consumer, cache) {
-        const cached = this.#layerCache.get(layer);
-        if (cache && cached)
-            return cached;
-        const runtime = runInInjectionContext({
-            consumer,
-            resolve: (token) => this.#resolve(token, layer.name),
-            ...(this.#recorder === undefined
-                ? {}
-                : {
-                    record: (recordedConsumer, dependency) => this.#recorder.record(recordedConsumer, dependency),
-                }),
-        }, () => layer.factory());
-        if (isThenable(runtime)) {
-            throw new DependencyResolutionError(`LUTRE_LAYER_ASYNC_FACTORY: Layer ${layer.name} factory must be synchronous.`);
-        }
-        if (typeof runtime !== 'function') {
-            throw new DependencyResolutionError(`LUTRE_LAYER_FACTORY_RESULT: Layer ${layer.name} factory must return a runtime function.`);
-        }
-        const normalized = runtime;
-        if (cache)
-            this.#layerCache.set(layer, normalized);
-        return normalized;
-    }
-    #constructImplementation(implementation, consumer, cache) {
-        const cached = this.#implementationCache.get(implementation);
-        if (cache && cached)
-            return cached;
-        const runtime = runInInjectionContext({
-            consumer,
-            resolve: (token) => this.#resolve(token, implementation.name),
-            ...(this.#recorder === undefined
-                ? {}
-                : {
-                    record: (recordedConsumer, dependency) => this.#recorder.record(recordedConsumer, dependency),
-                }),
-        }, () => implementation.factory());
-        if (isThenable(runtime)) {
-            throw new DependencyResolutionError(`LUTRE_IMPL_ASYNC_FACTORY: Implementation ${implementation.name} factory must be synchronous.`);
-        }
-        if (typeof runtime !== 'object' ||
-            runtime === null ||
-            Array.isArray(runtime)) {
-            throw new DependencyResolutionError(`LUTRE_IMPL_FACTORY_RESULT: Implementation ${implementation.name} factory must return a non-null object.`);
-        }
-        const normalized = runtime;
-        for (const procedure of implementation.procedures) {
-            if (typeof normalized[procedure] !== 'function') {
-                throw new DependencyResolutionError(`LUTRE_IMPL_004: Implementation ${implementation.name} does not implement callable procedure ${procedure}.`);
-            }
-        }
-        if (cache)
-            this.#implementationCache.set(implementation, normalized);
-        return normalized;
-    }
-    #constructTask(task, consumer, cache) {
-        const cached = this.#taskCache.get(task);
-        if (cache && cached)
-            return cached;
-        const runtime = runInInjectionContext({
-            consumer,
-            resolve: (token) => this.#resolve(token, task.name),
-            ...(this.#recorder === undefined
-                ? {}
-                : {
-                    record: (recordedConsumer, dependency) => this.#recorder.record(recordedConsumer, dependency),
-                }),
-        }, () => task.factory());
-        if (isThenable(runtime)) {
-            throw new DependencyResolutionError(`LUTRE_TASK_ASYNC_FACTORY: Task ${task.name} factory must be synchronous.`);
-        }
-        if (typeof runtime !== 'function') {
-            throw new DependencyResolutionError(`LUTRE_TASK_FACTORY_RESULT: Task ${task.name} factory must return a runtime function.`);
-        }
-        const normalized = runtime;
-        if (cache)
-            this.#taskCache.set(task, normalized);
-        return normalized;
-    }
 }
 function isRuntimeInputProvider(provider) {
     return provider.kind === 'environment' || provider.kind === 'arguments';
 }
-function isGraphProbeBoundary(error) {
-    return error instanceof GraphProbeBoundary;
-}
-function createOpaqueProbeValue(source) {
-    const boundary = (operation) => new GraphProbeBoundary(`${source}.${String(operation)}`);
-    return new Proxy(Object.create(null), {
-        get(_target, key) {
-            throw boundary(key);
-        },
-        set(_target, key) {
-            throw boundary(key);
-        },
-        has(_target, key) {
-            throw boundary(key);
-        },
-        ownKeys() {
-            throw boundary('*');
-        },
-        getOwnPropertyDescriptor(_target, key) {
-            throw boundary(key);
-        },
-        defineProperty(_target, key) {
-            throw boundary(key);
-        },
-        deleteProperty(_target, key) {
-            throw boundary(key);
-        },
-        getPrototypeOf() {
-            throw boundary('[[Prototype]]');
-        },
-        setPrototypeOf() {
-            throw boundary('[[Prototype]]');
-        },
-    });
-}
 function isThenable(value) {
     return (((typeof value === 'object' && value !== null) ||
         typeof value === 'function') &&
+        'then' in value &&
         typeof value.then === 'function');
 }

package/dist/runtime/execution-tracker.d.ts

@@ -0,0 +1,8 @@
+import type { ExecutionLease } from '../core/index.js';
+export declare class ExecutionTracker {
+    #private;
+    get size(): number;
+    begin(): ExecutionLease;
+    abortAll(reason: unknown): void;
+    waitForIdle(timeoutMs?: number): Promise<void>;
+}

package/dist/runtime/execution-tracker.js

@@ -0,0 +1,54 @@
+export class ExecutionTracker {
+    #active = new Set();
+    #idleWaiters = new Set();
+    get size() {
+        return this.#active.size;
+    }
+    begin() {
+        const controller = new AbortController();
+        const lease = {
+            controller,
+            signal: controller.signal,
+            completed: false,
+            abort: (reason) => controller.abort(reason),
+            complete: () => {
+                if (lease.completed)
+                    return;
+                lease.completed = true;
+                if (!controller.signal.aborted)
+                    controller.abort();
+                this.#active.delete(lease);
+                if (this.#active.size !== 0)
+                    return;
+                for (const resolve of this.#idleWaiters)
+                    resolve();
+                this.#idleWaiters.clear();
+            },
+        };
+        this.#active.add(lease);
+        return lease;
+    }
+    abortAll(reason) {
+        for (const execution of this.#active)
+            execution.abort(reason);
+    }
+    waitForIdle(timeoutMs) {
+        if (this.#active.size === 0)
+            return Promise.resolve();
+        return new Promise((resolve, reject) => {
+            let timer;
+            const resolveWhenIdle = () => {
+                if (timer !== undefined)
+                    clearTimeout(timer);
+                resolve();
+            };
+            this.#idleWaiters.add(resolveWhenIdle);
+            if (timeoutMs === undefined)
+                return;
+            timer = setTimeout(() => {
+                this.#idleWaiters.delete(resolveWhenIdle);
+                reject(new Error(`LUTRE_APPLICATION_FORCE_SHUTDOWN_TIMEOUT: ${this.#active.size} active execution(s) did not complete within ${timeoutMs}ms.`));
+            }, timeoutMs);
+        });
+    }
+}

package/dist/runtime/index.d.ts

@@ -1,9 +1,15 @@
-export * from './application.js';
-export * from './capability.js';
-export * from './di.js';
-export * from './error.js';
-export * from './engine.js';
-export * from './logger.js';
-export * from './pipeline.js';
-export * from './node-capabilities.js';
-export * from './server-url.js';
+export { checkRuntimeSupport, MissingRuntimeSupportError, } from './capability.js';
+export type { RuntimeCapabilityId, RuntimeSupportCheck, RuntimeSupportProfile, } from './capability.js';
+export { Container, DependencyResolutionError } from './di.js';
+export type { ContainerOptions } from './di.js';
+export { normalizeUnknownError } from './error.js';
+export type { NormalizedApplicationError } from './error.js';
+export { assertRuntimeEngine, detectRuntimeEngine } from './engine.js';
+export type { RuntimeEngine } from './engine.js';
+export { ConsoleLoggerBackend, JsonConsoleLoggerBackend, Logger, SilentLogger, } from './logger.js';
+export type { ConsoleLoggerBackendOptions, LoggerBackend, LogLevel, LogRecord, } from './logger.js';
+export { ApplicationKernelRuntime } from './kernel.js';
+export type { ApplicationKernelRuntimeOptions } from './kernel.js';
+export { nodeRuntimeSupport } from './node-capabilities.js';
+export { canRetryOnNextPort, initialServerPort } from './server-port.js';
+export { serverUrl } from './server-url.js';

package/dist/runtime/index.js

@@ -1,9 +1,9 @@
-export * from './application.js';
-export * from './capability.js';
-export * from './di.js';
-export * from './error.js';
-export * from './engine.js';
-export * from './logger.js';
-export * from './pipeline.js';
-export * from './node-capabilities.js';
-export * from './server-url.js';
+export { checkRuntimeSupport, MissingRuntimeSupportError, } from './capability.js';
+export { Container, DependencyResolutionError } from './di.js';
+export { normalizeUnknownError } from './error.js';
+export { assertRuntimeEngine, detectRuntimeEngine } from './engine.js';
+export { ConsoleLoggerBackend, JsonConsoleLoggerBackend, Logger, SilentLogger, } from './logger.js';
+export { ApplicationKernelRuntime } from './kernel.js';
+export { nodeRuntimeSupport } from './node-capabilities.js';
+export { canRetryOnNextPort, initialServerPort } from './server-port.js';
+export { serverUrl } from './server-url.js';

package/dist/runtime/ingress-gate.d.ts

@@ -0,0 +1,7 @@
+export declare class IngressGate {
+    #private;
+    get isAccepting(): boolean;
+    enter(): (() => void) | undefined;
+    stopAccepting(): void;
+    waitForIdle(): Promise<void>;
+}

package/dist/runtime/ingress-gate.js

@@ -0,0 +1,33 @@
+export class IngressGate {
+    #accepting = true;
+    #pending = 0;
+    #idleWaiters = new Set();
+    get isAccepting() {
+        return this.#accepting;
+    }
+    enter() {
+        if (!this.#accepting)
+            return undefined;
+        this.#pending += 1;
+        let completed = false;
+        return () => {
+            if (completed)
+                return;
+            completed = true;
+            this.#pending -= 1;
+            if (this.#pending !== 0)
+                return;
+            for (const resolve of this.#idleWaiters)
+                resolve();
+            this.#idleWaiters.clear();
+        };
+    }
+    stopAccepting() {
+        this.#accepting = false;
+    }
+    waitForIdle() {
+        return this.#pending === 0
+            ? Promise.resolve()
+            : new Promise((resolve) => this.#idleWaiters.add(resolve));
+    }
+}

package/dist/runtime/kernel.d.ts

@@ -0,0 +1,23 @@
+import { RuntimeCapabilityRegistry, type ApplicationModel, type ExecutionExtension, type ExecutionExtensionRuntime, type ExecutionKernelRuntime, type ExecutionLease, type RuntimeCapabilityBinding, type TokenLike } from '../core/index.js';
+import { Container } from './di.js';
+import { Logger } from './logger.js';
+export interface ApplicationKernelRuntimeOptions {
+    readonly capabilities?: readonly RuntimeCapabilityBinding[];
+    readonly logger?: Logger;
+    readonly environmentSource?: unknown;
+    readonly argumentsSource?: unknown;
+    readonly forceShutdownTimeoutMs?: number;
+}
+export declare class ApplicationKernelRuntime implements ExecutionKernelRuntime {
+    #private;
+    readonly model: ApplicationModel;
+    readonly container: Container;
+    readonly capabilities: RuntimeCapabilityRegistry;
+    constructor(model: ApplicationModel, options?: ApplicationKernelRuntimeOptions);
+    initialize(): Promise<void>;
+    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;
+    shutdown(signal?: string): Promise<void>;
+}