@loutrejs/loutre 0.8.1 → 0.9.0

package/dist/http/extension.js

@@ -403,24 +403,25 @@ function assertValidHttpRouteDefinition(route, segments) {
         }
     }
 }
-function createHttpExtensionRuntime(executions, applicationRuntime) {
+function createHttpExtensionRuntime(bindings, applicationRuntime) {
     const ingress = new IngressGate();
     const activeResponseStreams = new Set();
     const handlers = new Map();
-    for (const execution of executions) {
+    for (const { execution, resolve } of bindings) {
         handlers.set(execution.id, runInInjectionContext({
             consumer: {
                 kind: 'execution',
                 id: `http:${execution.id}`,
                 name: execution.id,
             },
-            resolve: (token) => applicationRuntime.resolve(token, execution.id),
+            resolve: (token, consumer) => resolve(token, { consumer }),
         }, () => execution.compiled.factory()));
     }
-    const routes = executions
-        .flatMap((execution) => execution.compiled.routes.map((route) => ({
+    const routes = bindings
+        .flatMap(({ execution, resolve }) => execution.compiled.routes.map((route) => ({
         executionId: execution.id,
         route,
+        resolve,
     })))
         .toSorted((left, right) => compareHttpPathSpecificity(left.route.segments, right.route.segments));
     return {
@@ -600,7 +601,7 @@ function createHttpExtensionRuntime(executions, applicationRuntime) {
                 const dispatch = () => composeLayers({
                     context,
                     layers: match.route.middlewares,
-                    resolve: (token, source) => applicationRuntime.resolve(token, source),
+                    resolve: match.resolve,
                     terminal: async (middlewareContext) => {
                         const handlerName = `${match.executionId}.${match.route.name}`;
                         const handlerOperation = applicationRuntime.beginOperation?.({

package/dist/message-port/extension.js

@@ -82,18 +82,18 @@ function snapshotMessagePortRoutes(routes) {
         }),
     ])));
 }
-function createMessagePortRuntime(executions, applicationRuntime) {
+function createMessagePortRuntime(bindings, applicationRuntime) {
     const routes = new Map();
     const ingress = new IngressGate();
     const activeStreams = new Set();
-    for (const execution of executions) {
+    for (const { execution, resolve } of bindings) {
         const handlers = runInInjectionContext({
             consumer: {
                 kind: 'execution',
                 id: `message-port:${execution.id}`,
                 name: execution.id,
             },
-            resolve: (token) => applicationRuntime.resolve(token, execution.id),
+            resolve: (token, consumer) => resolve(token, { consumer }),
         }, () => execution.compiled.factory());
         for (const [method, definition] of Object.entries(execution.compiled.routes)) {
             const handler = handlers[method];

package/dist/runtime/di.d.ts

@@ -1,4 +1,4 @@
-import { type ArgsClass, type EnvClass, type ProviderDescriptor, type TokenLike } from '../core/index.js';
+import { type ArgsClass, type EnvClass, type DependencyResolutionContext, type ProviderDescriptor, type TokenLike } from '../core/index.js';
 import { Logger } from './logger.js';
 export declare class DependencyResolutionError extends Error {
     constructor(message: string);
@@ -8,6 +8,7 @@ export interface ContainerHooks {
 }
 export interface ContainerOptions {
     readonly logger?: Logger;
+    readonly dependencies?: ReadonlyMap<TokenLike, readonly TokenLike[]>;
     readonly hooks?: ContainerHooks;
     readonly environment?: ReadonlyMap<EnvClass, object>;
     readonly arguments?: ReadonlyMap<ArgsClass, object>;
@@ -17,6 +18,7 @@ export declare class Container {
     constructor(providers: readonly ProviderDescriptor[], options?: Logger | ContainerOptions);
     bindEnvironment(environment: EnvClass, value: object): void;
     bindArguments(argumentsContract: ArgsClass, value: object): void;
-    resolve<T>(token: TokenLike<T>, source?: string): T;
+    resolve<T>(token: TokenLike<T>, context?: string | DependencyResolutionContext): T;
     get<T>(token: TokenLike<T>): T;
 }
+export declare function assertDeclaredDependency(consumer: string, token: TokenLike, dependencies: readonly TokenLike[]): void;

package/dist/runtime/di.js

@@ -11,12 +11,15 @@ export class Container {
     #providers = new Map();
     #applicationCache = new Map();
     #logger;
+    #dependencies;
     #hooks;
     #environment = new Map();
     #arguments = new Map();
     constructor(providers, options = {}) {
         this.#logger =
             options instanceof Logger ? options : (options.logger ?? new Logger());
+        this.#dependencies =
+            options instanceof Logger ? undefined : options.dependencies;
         this.#hooks = options instanceof Logger ? {} : (options.hooks ?? {});
         if (!(options instanceof Logger)) {
             for (const [environment, value] of options.environment ?? []) {
@@ -66,8 +69,9 @@ export class Container {
         }
         this.#arguments.set(argumentsContract, value);
     }
-    resolve(token, source) {
-        return this.#resolve(token, source);
+    resolve(token, context) {
+        const resolution = typeof context === 'string' ? { source: context } : context;
+        return this.#resolve(token, resolution?.source, [], resolution?.consumer);
     }
     get(token) {
         const provider = this.#providers.get(token);
@@ -100,7 +104,7 @@ export class Container {
         }
         throw new DependencyResolutionError(`LUTRE_DI_NOT_INITIALIZED: ${tokenName(token)} has not been constructed by Application initialization.`);
     }
-    #resolve(token, source, lineage = []) {
+    #resolve(token, source, lineage = [], inquirer) {
         const cycleStart = lineage.indexOf(token);
         if (cycleStart >= 0) {
             const cycle = [...lineage.slice(cycleStart), token]
@@ -123,16 +127,16 @@ export class Container {
         }
         const nextLineage = [...lineage, token];
         if (provider.scope !== 'application') {
-            return this.#create(provider, nextLineage);
+            return this.#create(provider, nextLineage, inquirer);
         }
         if (this.#applicationCache.has(token)) {
             return this.#applicationCache.get(token);
         }
-        const instance = this.#create(provider, nextLineage);
+        const instance = this.#create(provider, nextLineage, inquirer);
         this.#applicationCache.set(token, instance);
         return instance;
     }
-    #create(provider, lineage) {
+    #create(provider, lineage, inquirer) {
         try {
             return match(provider)
                 .with({ kind: 'value' }, (candidate) => {
@@ -152,13 +156,16 @@ export class Container {
                 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);
+                const value = this.#instantiate(candidate.useClass, lineage, candidate, inquirer);
                 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);
+                const dependencies = candidate.inject.map((token) => this.#resolveDependency(token, candidate, lineage));
+                const value = runInInjectionContext({
+                    consumer: candidate.provide,
+                    ...(inquirer === undefined ? {} : { inquirer }),
+                }, () => 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.');
                 }
@@ -166,13 +173,13 @@ export class Container {
                 return value;
             })
                 .with({ kind: 'conditional' }, (candidate) => {
-                const input = this.#resolve(candidate.select.contract, tokenName(candidate.provide), lineage);
+                const input = this.#resolveDependency(candidate.select.contract, candidate, 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);
+                const value = this.#instantiate(implementation, lineage, candidate, inquirer);
                 this.#hooks.created?.(candidate, value);
                 return value;
             })
@@ -185,13 +192,20 @@ export class Container {
             throw error;
         }
     }
-    #instantiate(target, lineage) {
+    #resolveDependency(token, provider, lineage, source = tokenName(provider.provide)) {
+        if (this.#dependencies) {
+            assertDeclaredDependency(tokenName(provider.provide), token, this.#dependencies.get(provider.provide) ?? []);
+        }
+        return this.#resolve(token, source, lineage, provider.provide);
+    }
+    #instantiate(target, lineage, provider, inquirer) {
         if (target.length > 0) {
             throw new DependencyResolutionError(`LUTRE_DI_CONSTRUCTOR: ${target.name} has required constructor parameters. Declare framework dependencies with constructor default parameters using inject().`);
         }
         return runInInjectionContext({
-            consumer: target,
-            resolve: (token) => this.#resolve(token, target.name, lineage),
+            consumer: provider.provide,
+            ...(inquirer === undefined ? {} : { inquirer }),
+            resolve: (token) => this.#resolveDependency(token, provider, lineage, target.name),
         }, () => new target());
     }
 }
@@ -204,3 +218,8 @@ function isThenable(value) {
         'then' in value &&
         typeof value.then === 'function');
 }
+export function assertDeclaredDependency(consumer, token, dependencies) {
+    if (!dependencies.includes(token)) {
+        throw new DependencyResolutionError(`LUTRE_DI_UNDECLARED_DEPENDENCY: ${consumer} requested ${tokenName(token)}, but it is not declared in the canonical Application Model. Declare dependencies unconditionally; construction metadata and runtime values must not add dependencies.`);
+    }
+}

package/dist/runtime/engine.d.ts

@@ -1,3 +1,4 @@
 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;
+export declare function assertSupportedBunVersion(): void;

package/dist/runtime/engine.js

@@ -31,7 +31,21 @@ export function detectRuntimeEngine() {
 }
 export function assertRuntimeEngine(expected) {
     const actual = detectRuntimeEngine();
-    if (actual === expected)
+    if (actual === expected) {
+        assertSupportedBunVersion();
         return;
+    }
     throw new Error(`LUTRE_RUNTIME_MISMATCH: Expected ${runtimeLabels[expected]}, detected ${runtimeLabels[actual]}.`);
 }
+export function assertSupportedBunVersion() {
+    if (detectRuntimeEngine() !== 'bun')
+        return;
+    const globals = globalThis;
+    const version = globals.Bun?.version ?? globals.process?.versions?.bun;
+    const release = version?.match(/^(\d+)\.(\d+)\.(\d+)(?:\+[\w.-]+)?$/);
+    if (release &&
+        (Number(release[1]) > 1 ||
+            (Number(release[1]) === 1 && Number(release[2]) >= 4)))
+        return;
+    throw new Error(`LUTRE_RUNTIME_VERSION: Bun ${version ?? 'unknown'} is not supported. Bun >=1.4.0 (stable) is required.`);
+}

package/dist/runtime/index.d.ts

@@ -4,7 +4,7 @@ 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 { assertRuntimeEngine, assertSupportedBunVersion, 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';
@@ -13,3 +13,7 @@ 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';
+export { ProcessShutdownHooks } from './shutdown-hooks.js';
+export type { ProcessShutdownHooksOptions, ProcessSignalSource, ShutdownSignal, } from './shutdown-hooks.js';
+export { ApplicationShutdownError, RuntimeShutdown } from './shutdown.js';
+export type { RuntimeShutdownOptions } from './shutdown.js';

package/dist/runtime/index.js

@@ -1,9 +1,11 @@
 export { checkRuntimeSupport, MissingRuntimeSupportError, } from './capability.js';
 export { Container, DependencyResolutionError } from './di.js';
 export { normalizeUnknownError } from './error.js';
-export { assertRuntimeEngine, detectRuntimeEngine } from './engine.js';
+export { assertRuntimeEngine, assertSupportedBunVersion, 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';
+export { ProcessShutdownHooks } from './shutdown-hooks.js';
+export { ApplicationShutdownError, RuntimeShutdown } from './shutdown.js';

package/dist/runtime/kernel.d.ts

@@ -1,4 +1,4 @@
-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 { RuntimeCapabilityRegistry, type ApplicationModel, type ExecutionExtension, type ExecutionExtensionRuntime, type ExecutionKernelRuntime, type ExecutionRuntimeBinding, 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 {
@@ -16,7 +16,7 @@ export declare class ApplicationKernelRuntime implements ExecutionKernelRuntime
     readonly capabilities: RuntimeCapabilityRegistry;
     constructor(model: ApplicationModel, options?: ApplicationKernelRuntimeOptions);
     initialize(): Promise<void>;
-    resolve<TValue>(token: TokenLike<TValue>, source?: string): TValue;
+    executionBindings<TCompiled>(extension: ExecutionExtension<any, TCompiled, any, any, any>): readonly ExecutionRuntimeBinding<TCompiled>[];
     get<TValue>(token: TokenLike<TValue>): TValue;
     extensionRuntime<TRuntime extends ExecutionExtensionRuntime>(extension: ExecutionExtension<any, any, any, any, TRuntime>): TRuntime;
     beginExecution(metadata?: RuntimeExecutionMetadata, invocation?: RuntimeInvocationRegistration): ExecutionLease;

package/dist/runtime/kernel.js

@@ -1,5 +1,6 @@
+import { ApplicationShutdownError } from './shutdown.js';
 import { assertValidApplicationModel, loadArgs, loadEnv, RuntimeCapabilityRegistry, tokenName, } from '../core/index.js';
-import { Container } from './di.js';
+import { Container, assertDeclaredDependency } from './di.js';
 import { ExecutionTracker } from './execution-tracker.js';
 import { Logger } from './logger.js';
 const defaultForceShutdownTimeoutMs = 5_000;
@@ -10,6 +11,7 @@ export class ApplicationKernelRuntime {
     #extensionRuntimes = new Map();
     #providerInstances = new Map();
     #providerNodes = new Map();
+    #executionBindings = new Map();
     #initializedModuleIds = new Set();
     #executions = new ExecutionTracker();
     #extensionDrainOperations = new Map();
@@ -39,10 +41,31 @@ export class ApplicationKernelRuntime {
         }
         this.container = new Container(model.providers, {
             logger: options.logger ?? new Logger(),
+            dependencies: new Map([...this.#providerNodes.values()].map((node) => [
+                node.token,
+                node.dependencies,
+            ])),
             hooks: {
                 created: (provider, value) => this.#notifyProviderCreated(provider, value),
             },
         });
+        for (const { extension, executions } of this.model.extensions) {
+            this.#executionBindings.set(extension.identity, Object.freeze(executions.map((execution) => {
+                const resolve = (token, context) => {
+                    if (this.#state === 'created' || this.#state === 'stopped') {
+                        throw applicationStateError(this.#state);
+                    }
+                    assertDeclaredDependency(execution.id, token, execution.dependencies);
+                    return this.container.resolve(token, {
+                        source: execution.id,
+                        ...(typeof context === 'string'
+                            ? { source: context }
+                            : context),
+                    });
+                };
+                return Object.freeze({ execution, resolve });
+            })));
+        }
     }
     initialize() {
         if (this.#state === 'running')
@@ -68,7 +91,7 @@ export class ApplicationKernelRuntime {
             await this.#initializeProviders();
             for (const modelExtension of this.model.extensions) {
                 const runtime = await modelExtension.extension.createRuntime({
-                    executions: modelExtension.executions,
+                    executions: this.executionBindings(modelExtension.extension),
                     capabilities: this.capabilities,
                     applicationRuntime: this,
                 });
@@ -141,11 +164,12 @@ export class ApplicationKernelRuntime {
             await this.#runHook(lifecycleHookOf(this.model, module.id, 'onApplicationBootstrap'));
         }
     }
-    resolve(token, source) {
-        if (this.#state === 'created' || this.#state === 'stopped') {
-            throw applicationStateError(this.#state);
+    executionBindings(extension) {
+        const bindings = this.#executionBindings.get(extension.identity);
+        if (!bindings) {
+            throw new Error(`LUTRE_EXTENSION_RUNTIME_MISSING: ${extension.name} is not declared in the Application Model.`);
         }
-        return this.container.resolve(token, source);
+        return bindings;
     }
     get(token) {
         if (this.#state !== 'running')
@@ -259,12 +283,20 @@ export class ApplicationKernelRuntime {
             }
             catch (error) {
                 errors.push(error);
-                throw new AggregateError(errors, 'Application shutdown did not reach a safe cleanup boundary.', { cause: error });
+                throw new ApplicationShutdownError(errors, 'Application shutdown did not reach a safe cleanup boundary.', {
+                    cause: error,
+                    safeCleanupBoundaryReached: false,
+                    retryAfter: this.#waitForShutdownProgress(),
+                });
             }
         }
         if (timedOutDrains.some(({ isPending }) => isPending())) {
             const cause = errors.find((error) => error instanceof ExtensionDrainTimeoutError);
-            throw new AggregateError(errors, 'Application shutdown did not reach a safe cleanup boundary.', { cause });
+            throw new ApplicationShutdownError(errors, 'Application shutdown did not reach a safe cleanup boundary.', {
+                cause,
+                safeCleanupBoundaryReached: false,
+                retryAfter: this.#waitForShutdownProgress(),
+            });
         }
         for (const { extension } of [...this.model.extensions].toReversed()) {
             const runtime = this.#extensionRuntimes.get(extension.identity);
@@ -276,9 +308,15 @@ export class ApplicationKernelRuntime {
         this.#state = 'stopped';
         await closeInstrumentation(this.#instrumentation);
         if (errors.length > 0) {
-            throw new AggregateError(errors, 'Application shutdown failed.');
+            throw new ApplicationShutdownError(errors, 'Application shutdown failed.', { safeCleanupBoundaryReached: true });
         }
     }
+    async #waitForShutdownProgress() {
+        await Promise.allSettled([
+            this.#executions.waitForIdle(),
+            ...[...this.#extensionDrainOperations.values()].map(({ result }) => result),
+        ]);
+    }
     #startExtensionDrain(extension, runtime) {
         const existing = this.#extensionDrainOperations.get(extension.identity);
         if (existing)

package/dist/runtime/shutdown-hooks.d.ts

@@ -0,0 +1,16 @@
+export type ShutdownSignal = 'SIGINT' | 'SIGTERM';
+export interface ProcessSignalSource {
+    once(signal: ShutdownSignal, handler: () => void): unknown;
+    off(signal: ShutdownSignal, handler: () => void): unknown;
+}
+export interface ProcessShutdownHooksOptions {
+    readonly source: ProcessSignalSource;
+    readonly close: (signal: ShutdownSignal) => Promise<void>;
+    readonly onError: (error: unknown, signal: ShutdownSignal) => void;
+}
+export declare class ProcessShutdownHooks {
+    #private;
+    constructor(options: ProcessShutdownHooksOptions);
+    setEnabled(enabled: boolean): void;
+    dispose(): void;
+}

package/dist/runtime/shutdown-hooks.js

@@ -0,0 +1,69 @@
+import { ApplicationShutdownError } from './shutdown.js';
+export class ProcessShutdownHooks {
+    #handlers = new Map();
+    #options;
+    #disposed = false;
+    constructor(options) {
+        this.#options = options;
+    }
+    setEnabled(enabled) {
+        if (this.#disposed)
+            return;
+        if (!enabled) {
+            this.#removeHandlers();
+            return;
+        }
+        if (this.#handlers.size > 0)
+            return;
+        for (const signal of ['SIGINT', 'SIGTERM']) {
+            const handler = () => {
+                if (this.#disposed)
+                    return;
+                this.dispose();
+                void this.#close(signal);
+            };
+            this.#handlers.set(signal, handler);
+            this.#options.source.once(signal, handler);
+        }
+    }
+    dispose() {
+        this.#disposed = true;
+        this.#removeHandlers();
+    }
+    #removeHandlers() {
+        for (const [signal, handler] of this.#handlers) {
+            this.#options.source.off(signal, handler);
+        }
+        this.#handlers.clear();
+    }
+    async #close(signal) {
+        for (;;) {
+            try {
+                await this.#options.close(signal);
+                return;
+            }
+            catch (error) {
+                this.#reportError(error, signal);
+                if (!(error instanceof ApplicationShutdownError) ||
+                    error.safeCleanupBoundaryReached ||
+                    !error.retryAfter)
+                    return;
+                try {
+                    await error.retryAfter;
+                }
+                catch (retryError) {
+                    this.#reportError(retryError, signal);
+                    return;
+                }
+            }
+        }
+    }
+    #reportError(error, signal) {
+        try {
+            this.#options.onError(error, signal);
+        }
+        catch (reportingError) {
+            console.error('Runtime shutdown error reporter failed', error, reportingError);
+        }
+    }
+}

package/dist/runtime/shutdown.d.ts

@@ -0,0 +1,20 @@
+export declare class ApplicationShutdownError extends AggregateError {
+    readonly safeCleanupBoundaryReached: boolean;
+    readonly retryAfter: Promise<void> | undefined;
+    constructor(errors: readonly unknown[], message: string, options: ErrorOptions & {
+        readonly safeCleanupBoundaryReached: boolean;
+        readonly retryAfter?: Promise<void>;
+    });
+}
+export interface RuntimeShutdownOptions {
+    readonly message: string;
+    readonly beginClose: () => Promise<void>;
+    readonly closeApplication: (signal?: string) => Promise<void>;
+    readonly closeResources: (safeCleanupBoundaryReached: boolean, resourceClosing: Promise<void>) => Promise<void>;
+}
+export declare class RuntimeShutdown {
+    #private;
+    constructor(options: RuntimeShutdownOptions);
+    get started(): boolean;
+    close(signal?: string): Promise<void>;
+}

package/dist/runtime/shutdown.js

@@ -0,0 +1,71 @@
+export class ApplicationShutdownError extends AggregateError {
+    safeCleanupBoundaryReached;
+    retryAfter;
+    constructor(errors, message, options) {
+        super(errors, message, options);
+        this.name = 'ApplicationShutdownError';
+        this.safeCleanupBoundaryReached = options.safeCleanupBoundaryReached;
+        this.retryAfter = options.retryAfter;
+    }
+}
+export class RuntimeShutdown {
+    #options;
+    #started = false;
+    #closed = false;
+    #closing;
+    constructor(options) {
+        this.#options = options;
+    }
+    get started() {
+        return this.#started;
+    }
+    close(signal) {
+        if (this.#closed)
+            return Promise.resolve();
+        if (this.#closing)
+            return this.#closing;
+        this.#started = true;
+        this.#closing = this.#close(signal).catch((error) => {
+            this.#closing = undefined;
+            throw error;
+        });
+        return this.#closing;
+    }
+    async #close(signal) {
+        const errors = [];
+        let resourceClosing = Promise.resolve();
+        try {
+            resourceClosing = this.#options.beginClose();
+            void resourceClosing.catch(() => undefined);
+        }
+        catch (error) {
+            errors.push(error);
+        }
+        let safeCleanupBoundaryReached = false;
+        let retryAfter;
+        try {
+            await this.#options.closeApplication(signal);
+            safeCleanupBoundaryReached = true;
+        }
+        catch (error) {
+            errors.push(error);
+            safeCleanupBoundaryReached =
+                error instanceof ApplicationShutdownError &&
+                    error.safeCleanupBoundaryReached;
+            if (error instanceof ApplicationShutdownError)
+                retryAfter = error.retryAfter;
+        }
+        try {
+            await this.#options.closeResources(safeCleanupBoundaryReached, resourceClosing);
+        }
+        catch (error) {
+            errors.push(error);
+        }
+        if (errors.length > 0)
+            throw new ApplicationShutdownError(errors, this.#options.message, {
+                safeCleanupBoundaryReached,
+                ...(retryAfter === undefined ? {} : { retryAfter }),
+            });
+        this.#closed = true;
+    }
+}

package/dist/tasks/extension.js

@@ -228,14 +228,14 @@ export function consume(declaration) {
         task: declaration.task,
     });
 }
-function createTasksRuntime(executions, applicationRuntime) {
+function createTasksRuntime(bindings, applicationRuntime) {
     const runtimes = new Map();
     const runtimeExecutionIds = new Map();
     const triggers = [];
-    for (const execution of executions) {
+    for (const { execution, resolve } of bindings) {
         const compiled = execution.compiled;
         if (compiled.type !== 'task') {
-            triggers.push(compiled);
+            triggers.push({ execution, resolve });
             continue;
         }
         const runtime = runInInjectionContext({
@@ -244,7 +244,7 @@ function createTasksRuntime(executions, applicationRuntime) {
                 id: `task:${compiled.name}`,
                 name: compiled.name,
             },
-            resolve: (dependency) => applicationRuntime.resolve(dependency, execution.id),
+            resolve: (dependency, consumer) => resolve(dependency, { consumer }),
         }, () => compiled.factory());
         runtimes.set(compiled.taskExecutionId, runtime);
         runtimeExecutionIds.set(compiled.taskExecutionId, execution.id);
@@ -344,10 +344,11 @@ function createTasksRuntime(executions, applicationRuntime) {
         const started = [];
         const startup = (async () => {
             try {
-                for (const trigger of triggers) {
+                for (const { execution, resolve } of triggers) {
+                    const trigger = execution.compiled;
                     if (trigger.type === 'task')
                         continue;
-                    const handle = await startTrigger(trigger, run, applicationRuntime);
+                    const handle = await startTrigger(trigger, run, resolve);
                     started.push(handle);
                     if (state !== 'running') {
                         throw tasksStateError(state);
@@ -406,11 +407,11 @@ function createTasksRuntime(executions, applicationRuntime) {
         },
     };
 }
-async function startTrigger(trigger, run, applicationRuntime) {
+async function startTrigger(trigger, run, resolve) {
     return match(trigger)
         .with({ type: 'cron' }, (candidate) => startCronTrigger(candidate, run))
         .with({ type: 'fixed-delay' }, (candidate) => startFixedDelayTrigger(candidate, run))
-        .with({ type: 'queue-consumer' }, (candidate) => startQueueTrigger(candidate, run, applicationRuntime))
+        .with({ type: 'queue-consumer' }, (candidate) => startQueueTrigger(candidate, run, resolve))
         .exhaustive();
 }
 function startCronTrigger(trigger, run) {
@@ -486,8 +487,8 @@ function startFixedDelayTrigger(trigger, run) {
         },
     };
 }
-async function startQueueTrigger(trigger, run, applicationRuntime) {
-    const driver = applicationRuntime.resolve(trigger.queueDriver);
+async function startQueueTrigger(trigger, run, resolve) {
+    const driver = resolve(trigger.queueDriver);
     if (!driver || typeof driver.start !== 'function') {
         throw new Error(`LUTRE_QUEUE_DRIVER_INVALID: Queue ${trigger.queueName} driver is invalid.`);
     }