@loutrejs/loutre 0.5.0 → 0.7.0

package/dist/runtime/kernel.js

@@ -0,0 +1,447 @@
+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';
+const defaultForceShutdownTimeoutMs = 5_000;
+export class ApplicationKernelRuntime {
+    model;
+    container;
+    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() {
+        if (this.#state === 'running')
+            return Promise.resolve();
+        if (this.#initialization)
+            return this.#initialization;
+        if (this.#state === 'draining' || this.#state === 'stopped') {
+            return Promise.reject(applicationStateError(this.#state));
+        }
+        const initialization = this.#initialize().finally(() => {
+            if (this.#initialization === initialization) {
+                this.#initialization = undefined;
+            }
+        });
+        this.#initialization = initialization;
+        return initialization;
+    }
+    async #initialize() {
+        this.#state = 'initializing';
+        try {
+            this.#validateCapabilities();
+            await this.#bindRuntimeInputs();
+            await this.#initializeProviders();
+            for (const modelExtension of this.model.extensions) {
+                const runtime = await modelExtension.extension.createRuntime({
+                    executions: modelExtension.executions,
+                    capabilities: this.capabilities,
+                    applicationRuntime: this,
+                });
+                this.#extensionRuntimes.set(modelExtension.extension.identity, runtime);
+            }
+            this.#state = 'running';
+        }
+        catch (error) {
+            const cleanupErrors = await this.#rollbackInitialization();
+            this.#state = 'stopped';
+            if (cleanupErrors.length > 0) {
+                throw new AggregateError([error, ...cleanupErrors], 'Application initialization failed and cleanup also failed.', { cause: error });
+            }
+            throw error;
+        }
+    }
+    #validateCapabilities() {
+        const missing = new Map();
+        for (const execution of this.model.executions) {
+            for (const capability of execution.capabilities) {
+                if (this.capabilities.has(capability))
+                    continue;
+                const consumers = missing.get(capability.id) ?? [];
+                consumers.push(execution.id);
+                missing.set(capability.id, consumers);
+            }
+        }
+        if (missing.size === 0)
+            return;
+        const details = [...missing]
+            .map(([id, consumers]) => `${id} (${consumers.join(', ')})`)
+            .join(', ');
+        throw new Error(`LUTRE_CAPABILITY_MISSING: ${details}`);
+    }
+    async #bindRuntimeInputs() {
+        for (const provider of this.model.providers) {
+            if (provider.kind !== 'environment')
+                continue;
+            if (this.#environmentSource === undefined) {
+                throw new Error(`LUTRE_ENV_SOURCE_MISSING: ${provider.provide.name} requires an Environment source.`);
+            }
+            this.container.bindEnvironment(provider.provide, await loadEnv(provider.provide, this.#environmentSource));
+        }
+        if (this.model.arguments) {
+            this.container.bindArguments(this.model.arguments, await loadArgs(this.model.arguments, this.#argumentsSource));
+        }
+    }
+    async #initializeProviders() {
+        for (const module of moduleNodes(this.model)) {
+            const instances = [];
+            this.#providerInstances.set(module.id, instances);
+            for (const providerNode of providerNodesOfModule(this.model, module.id)) {
+                const provider = providerNode.provider;
+                if (provider.scope !== 'application' ||
+                    provider.kind === 'environment' ||
+                    provider.kind === 'arguments') {
+                    continue;
+                }
+                const instance = this.container.resolve(provider.provide);
+                instances.push(instance);
+                await callLifecycle(instance, 'onModuleInit');
+            }
+            this.#initializedModuleIds.add(module.id);
+            await this.#runHook(lifecycleHookOf(this.model, module.id, 'onModuleInit'));
+        }
+        for (const module of moduleNodes(this.model)) {
+            for (const instance of this.#providerInstances.get(module.id) ?? []) {
+                await callLifecycle(instance, 'onApplicationBootstrap');
+            }
+            await this.#runHook(lifecycleHookOf(this.model, module.id, 'onApplicationBootstrap'));
+        }
+    }
+    resolve(token, source) {
+        if (this.#state === 'created' || this.#state === 'stopped') {
+            throw applicationStateError(this.#state);
+        }
+        return this.container.resolve(token, source);
+    }
+    get(token) {
+        if (this.#state !== 'running')
+            throw applicationStateError(this.#state);
+        return this.container.get(token);
+    }
+    extensionRuntime(extension) {
+        const runtime = this.#extensionRuntimes.get(extension.identity);
+        if (!runtime) {
+            throw new Error(`LUTRE_EXTENSION_RUNTIME_MISSING: ${extension.name} is not initialized.`);
+        }
+        return runtime;
+    }
+    beginExecution(metadata, invocation) {
+        if (this.#state !== 'running')
+            throw applicationStateError(this.#state);
+        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')
+            return Promise.resolve();
+        if (this.#shutdown)
+            return this.#shutdown;
+        const shutdown = this.#shutdownApplication(signal).finally(() => {
+            if (this.#shutdown === shutdown)
+                this.#shutdown = undefined;
+        });
+        this.#shutdown = shutdown;
+        return shutdown;
+    }
+    async #shutdownApplication(signal) {
+        if (this.#initialization)
+            await this.#initialization.catch(() => undefined);
+        if (this.#state === 'created') {
+            this.#state = 'stopped';
+            await closeInstrumentation(this.#instrumentation);
+            return;
+        }
+        if (this.#state === 'stopped')
+            return;
+        this.#state = 'draining';
+        const errors = [];
+        const drainOperations = [];
+        for (const { extension } of this.model.extensions) {
+            const runtime = this.#extensionRuntimes.get(extension.identity);
+            if (!runtime?.drain)
+                continue;
+            const operation = this.#startExtensionDrain(extension, runtime);
+            drainOperations.push({
+                result: withTimeout(() => operation.result, this.#forceShutdownTimeoutMs, () => new ExtensionDrainTimeoutError(`LUTRE_EXTENSION_DRAIN_TIMEOUT: Extension ${extension.name} did not drain within ${this.#forceShutdownTimeoutMs}ms.`)),
+                isPending: () => operation.pending,
+            });
+        }
+        const drainResults = await Promise.allSettled(drainOperations.map(({ result }) => result));
+        let drainFailed = false;
+        const timedOutDrains = [];
+        for (const [index, result] of drainResults.entries()) {
+            if (result.status === 'fulfilled')
+                continue;
+            drainFailed = true;
+            if (result.reason instanceof ExtensionDrainTimeoutError) {
+                timedOutDrains.push(drainOperations[index]);
+            }
+            errors.push(result.reason);
+        }
+        if (this.#executions.size > 0) {
+            if (drainFailed) {
+                const reason = new Error('LUTRE_APPLICATION_FORCE_SHUTDOWN: Extension drain failed.');
+                this.#executions.abortAll(reason);
+            }
+            try {
+                await this.#executions.waitForIdle(this.#forceShutdownTimeoutMs);
+            }
+            catch (error) {
+                errors.push(error);
+                throw new AggregateError(errors, 'Application shutdown did not reach a safe cleanup boundary.', { cause: error });
+            }
+        }
+        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 });
+        }
+        for (const { extension } of [...this.model.extensions].toReversed()) {
+            const runtime = this.#extensionRuntimes.get(extension.identity);
+            if (runtime?.close)
+                await collectError(() => runtime.close(), errors);
+        }
+        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.');
+        }
+    }
+    #startExtensionDrain(extension, runtime) {
+        const existing = this.#extensionDrainOperations.get(extension.identity);
+        if (existing)
+            return existing;
+        const operation = {
+            result: startOperation(() => runtime.drain({ timeoutMs: this.#forceShutdownTimeoutMs })),
+            pending: true,
+        };
+        this.#extensionDrainOperations.set(extension.identity, operation);
+        void operation.result.then(() => {
+            operation.pending = false;
+        }, () => {
+            operation.pending = false;
+            if (this.#extensionDrainOperations.get(extension.identity) === operation) {
+                this.#extensionDrainOperations.delete(extension.identity);
+            }
+        });
+        return operation;
+    }
+    async #cleanupProviders(signal, errors) {
+        const modules = moduleNodes(this.model).toReversed();
+        for (const module of modules) {
+            for (const instance of (this.#providerInstances.get(module.id) ?? []).toReversed()) {
+                await collectError(() => callLifecycle(instance, 'onModuleDestroy'), errors);
+            }
+            await collectError(() => this.#runCleanupHook(module.id, 'onModuleDestroy'), errors);
+        }
+        for (const module of modules) {
+            for (const instance of (this.#providerInstances.get(module.id) ?? []).toReversed()) {
+                await collectError(() => callLifecycle(instance, 'beforeApplicationShutdown', signal), errors);
+            }
+            await collectError(() => this.#runCleanupHook(module.id, 'beforeApplicationShutdown'), errors);
+        }
+        for (const module of modules) {
+            for (const instance of (this.#providerInstances.get(module.id) ?? []).toReversed()) {
+                await collectError(() => callLifecycle(instance, 'onApplicationShutdown', signal), errors);
+            }
+            await collectError(() => this.#runCleanupHook(module.id, 'onApplicationShutdown'), errors);
+        }
+    }
+    async #rollbackInitialization() {
+        const errors = [];
+        for (const runtime of [...this.#extensionRuntimes.values()].toReversed()) {
+            if (runtime.close)
+                await collectError(() => runtime.close(), errors);
+        }
+        for (const module of moduleNodes(this.model).toReversed()) {
+            await collectError(() => this.#runCleanupHook(module.id, 'onModuleDestroy'), errors);
+            for (const instance of (this.#providerInstances.get(module.id) ?? []).toReversed()) {
+                await collectError(() => callLifecycle(instance, 'onModuleDestroy'), errors);
+            }
+        }
+        await closeInstrumentation(this.#instrumentation);
+        return errors;
+    }
+    async #runHook(hook) {
+        if (!hook)
+            return;
+        const dependencies = hook.inject.map((token) => this.container.resolve(token));
+        await hook.run(...dependencies);
+    }
+    async #runCleanupHook(moduleId, phase) {
+        if (!this.#initializedModuleIds.has(moduleId))
+            return;
+        await this.#runHook(lifecycleHookOf(this.model, moduleId, phase));
+    }
+}
+function moduleNodes(model) {
+    return model.nodes.filter((node) => node.kind === 'module');
+}
+function providerNodesOfModule(model, moduleId) {
+    return model.nodes.filter((node) => node.kind === 'provider' && node.moduleId === moduleId);
+}
+function lifecycleHookOf(model, moduleId, phase) {
+    return model.nodes.find((node) => node.kind === 'lifecycle' &&
+        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 {
+        return await Promise.race([
+            Promise.resolve(operation()),
+            new Promise((_, reject) => {
+                timer = setTimeout(() => reject(createTimeoutError()), timeoutMs);
+            }),
+        ]);
+    }
+    finally {
+        if (timer !== undefined)
+            clearTimeout(timer);
+    }
+}
+function startOperation(operation) {
+    try {
+        return Promise.resolve(operation());
+    }
+    catch (error) {
+        return Promise.reject(error);
+    }
+}
+class ExtensionDrainTimeoutError extends Error {
+}
+async function collectError(operation, errors) {
+    try {
+        await operation();
+    }
+    catch (error) {
+        errors.push(error);
+    }
+}
+async function callLifecycle(instance, method, signal) {
+    if (!instance ||
+        (typeof instance !== 'object' && typeof instance !== 'function')) {
+        return;
+    }
+    const candidate = instance[method];
+    if (typeof candidate !== 'function')
+        return;
+    await Reflect.apply(candidate, instance, signal === undefined ? [] : [signal]);
+}
+function applicationStateError(state) {
+    return new Error(`LUTRE_APPLICATION_STATE: Application is ${state} and cannot perform this operation.`);
+}

package/dist/runtime/logger.d.ts

@@ -1,3 +1,4 @@
+import { frameworkProvidedTokenBrand } from '../core/token-internal.js';
 export type LogLevel = 'debug' | 'info' | 'warn' | 'error';
 export interface LogRecord {
     readonly timestamp: string;
@@ -24,6 +25,7 @@ export declare class Logger {
     #private;
     readonly backend: LoggerBackend;
     readonly context: Readonly<Record<string, unknown>>;
+    static readonly [frameworkProvidedTokenBrand] = true;
     constructor(backend?: LoggerBackend, context?: Readonly<Record<string, unknown>>);
     child(context: Readonly<Record<string, unknown>>): Logger;
     debug(message: string, context?: Readonly<Record<string, unknown>>): void;

package/dist/runtime/logger.js

@@ -1,3 +1,4 @@
+import { frameworkProvidedTokenBrand } from '../core/token-internal.js';
 export class ConsoleLoggerBackend {
     #colors;
     #prefix;
@@ -20,6 +21,7 @@ class SilentLoggerBackend {
 export class Logger {
     backend;
     context;
+    static [frameworkProvidedTokenBrand] = true;
     constructor(backend = new ConsoleLoggerBackend(), context = {}) {
         this.backend = backend;
         this.context = context;

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

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

package/dist/runtime/node-capabilities.js

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

package/dist/runtime/server-port.d.ts

@@ -0,0 +1,2 @@
+export declare function initialServerPort(requestedPort: number | undefined): number;
+export declare function canRetryOnNextPort(error: unknown, port: number): boolean;

package/dist/runtime/server-port.js

@@ -0,0 +1,11 @@
+export function initialServerPort(requestedPort) {
+    return requestedPort ?? 3000;
+}
+export function canRetryOnNextPort(error, port) {
+    return port < 65_535 && isAddressInUseError(error);
+}
+function isAddressInUseError(error) {
+    return (error instanceof Error &&
+        'code' in error &&
+        error.code === 'EADDRINUSE');
+}

package/dist/tasks/extension.d.ts

@@ -0,0 +1,144 @@
+import { type ExecutionDefinition, type ProviderDescriptor, type SchemaOutput, type StandardSchemaV1, type Token } from '../core/index.js';
+export type TaskRuntime<TInput, TOutput> = [TInput] extends [void] ? () => TOutput | Promise<TOutput> : (input: TInput) => TOutput | Promise<TOutput>;
+export interface TaskDefinitionData<TInput = unknown, TOutput = unknown> {
+    readonly type: 'task';
+    readonly name: string;
+    readonly factory: () => TaskRuntime<TInput, TOutput>;
+    readonly '~input'?: TInput;
+    readonly '~output'?: TOutput;
+}
+export type TaskInput<TTask> = TTask extends TaskDefinitionData<infer TInput, any> ? TInput : never;
+export type TaskOutput<TTask> = TTask extends TaskDefinitionData<any, infer TOutput> ? TOutput : never;
+export type TaskArguments<TTask> = [TaskInput<TTask>] extends [void] ? readonly [] : readonly [input: TaskInput<TTask>];
+declare const taskExecutionIdentityKey: unique symbol;
+declare const queueDriverToken: unique symbol;
+export interface TaskExecutionIdentity {
+    readonly [taskExecutionIdentityKey]: symbol;
+}
+type AnyTaskDefinition = ExecutionDefinition & TaskExecutionIdentity & {
+    readonly type: 'task';
+    readonly name: string;
+    readonly factory: () => Function;
+};
+type VoidTaskConstraint<TTask> = [TaskInput<TTask>] extends [void] ? unknown : never;
+export type CronOverlap = 'allow' | 'skip';
+export interface CronTriggerDefinitionData<TTask extends AnyTaskDefinition = AnyTaskDefinition> {
+    readonly type: 'cron';
+    readonly name: string;
+    readonly expression: string;
+    readonly timezone: string;
+    readonly overlap: CronOverlap;
+    readonly task: TTask;
+}
+export interface FixedDelayTriggerDefinitionData<TTask extends AnyTaskDefinition = AnyTaskDefinition> {
+    readonly type: 'fixed-delay';
+    readonly name: string;
+    readonly delay: number;
+    readonly immediate: boolean;
+    readonly task: TTask;
+}
+export interface QueueDescriptor<TSchema extends StandardSchemaV1 = StandardSchemaV1, TName extends string = string> {
+    readonly kind: 'queue';
+    readonly name: TName;
+    readonly payload: TSchema;
+    readonly [queueDriverToken]: Token<QueueConsumerDriver>;
+}
+export type QueuePayload<TQueue> = TQueue extends QueueDescriptor<infer TSchema, any> ? SchemaOutput<TSchema> : never;
+export interface QueueConsumerHandle {
+    stop(): Promise<void>;
+}
+export interface QueueConsumerDriver {
+    start(options: {
+        consume(payload: unknown): Promise<void>;
+    }): Promise<QueueConsumerHandle>;
+}
+export interface QueueConsumerTriggerDefinitionData<TQueue extends QueueDescriptor<any> = QueueDescriptor<any>, TTask extends AnyTaskDefinition = AnyTaskDefinition> {
+    readonly type: 'queue-consumer';
+    readonly name: string;
+    readonly queue: TQueue;
+    readonly task: TTask;
+}
+export type TriggerDefinitionData = CronTriggerDefinitionData | FixedDelayTriggerDefinitionData | QueueConsumerTriggerDefinitionData;
+type TasksDefinitionData = (TaskDefinitionData & TaskExecutionIdentity) | TriggerDefinitionData;
+export interface TasksCompiledTask {
+    readonly type: 'task';
+    readonly taskExecutionId: symbol;
+    readonly name: string;
+    readonly factory: () => (...arguments_: any[]) => any;
+}
+export interface TasksCompiledCronTrigger {
+    readonly type: 'cron';
+    readonly name: string;
+    readonly expression: string;
+    readonly timezone: string;
+    readonly overlap: CronOverlap;
+    readonly taskExecutionId: symbol;
+    readonly taskName: string;
+}
+export interface TasksCompiledFixedDelayTrigger {
+    readonly type: 'fixed-delay';
+    readonly name: string;
+    readonly delay: number;
+    readonly immediate: boolean;
+    readonly taskExecutionId: symbol;
+    readonly taskName: string;
+}
+export interface TasksCompiledQueueConsumerTrigger {
+    readonly type: 'queue-consumer';
+    readonly name: string;
+    readonly queueName: string;
+    readonly queuePayload: StandardSchemaV1;
+    readonly queueDriver: Token<QueueConsumerDriver>;
+    readonly taskExecutionId: symbol;
+    readonly taskName: string;
+}
+export type TasksCompiledExecution = TasksCompiledTask | TasksCompiledCronTrigger | TasksCompiledFixedDelayTrigger | TasksCompiledQueueConsumerTrigger;
+export interface TasksExtensionRuntime {
+    run<TInput, TOutput>(taskExecutionId: symbol, taskName: string, ...arguments_: [TInput] extends [void] ? readonly [] : readonly [input: TInput]): Promise<TOutput>;
+    startTriggers(): Promise<void>;
+    stopTriggers(): Promise<void>;
+    drain(): Promise<void>;
+    close(): Promise<void>;
+}
+export interface TasksHostApi {
+    run<TInput, TOutput>(task: TaskDefinitionData<TInput, TOutput> & ExecutionDefinition & TaskExecutionIdentity, ...arguments_: [TInput] extends [void] ? readonly [] : readonly [input: TInput]): Promise<TOutput>;
+    start(): Promise<void>;
+    stop(): Promise<void>;
+}
+export declare const tasksExtension: import("../core/extension.js").ExecutionExtension<TasksDefinitionData & ExecutionDefinition<import("../core/extension.js").AnyExecutionExtension>, TasksCompiledExecution, "tasks", TasksHostApi, TasksExtensionRuntime>;
+export type TaskDefinition<TInput = unknown, TOutput = unknown> = TaskDefinitionData<TInput, TOutput> & ExecutionDefinition<typeof tasksExtension> & TaskExecutionIdentity;
+export type CronTriggerDefinition<TTask extends TaskDefinition<void, any> = TaskDefinition<void, any>> = CronTriggerDefinitionData<TTask> & ExecutionDefinition<typeof tasksExtension>;
+export type FixedDelayTriggerDefinition<TTask extends TaskDefinition<void, any> = TaskDefinition<void, any>> = FixedDelayTriggerDefinitionData<TTask> & ExecutionDefinition<typeof tasksExtension>;
+export type QueueConsumerTriggerDefinition<TQueue extends QueueDescriptor<any> = QueueDescriptor<any>, TTask extends AnyTaskDefinition = TaskDefinition<any, any>> = QueueConsumerTriggerDefinitionData<TQueue, TTask> & ExecutionDefinition<typeof tasksExtension>;
+export type TriggerDefinition = CronTriggerDefinition | FixedDelayTriggerDefinition | QueueConsumerTriggerDefinition;
+export declare function task<TInput = void, TOutput = void>(definition: {
+    readonly name: string;
+    readonly factory: () => TaskRuntime<TInput, TOutput>;
+}): TaskDefinition<TInput, TOutput>;
+export declare function cron<const TTask extends AnyTaskDefinition>(declaration: {
+    readonly name: string;
+    readonly expression: string;
+    readonly timezone: string;
+    readonly overlap?: CronOverlap;
+    readonly task: TTask;
+} & VoidTaskConstraint<TTask>): CronTriggerDefinition<TTask & TaskDefinition<void, any>>;
+export declare function fixedDelay<const TTask extends AnyTaskDefinition>(declaration: {
+    readonly name: string;
+    readonly delay: number;
+    readonly immediate?: boolean;
+    readonly task: TTask;
+} & VoidTaskConstraint<TTask>): FixedDelayTriggerDefinition<TTask & TaskDefinition<void, any>>;
+export declare function queue<const TSchema extends StandardSchemaV1, const TName extends string = string>(declaration: {
+    readonly name: TName;
+    readonly payload: TSchema;
+}): QueueDescriptor<TSchema, TName>;
+export declare function bindQueueDriver(descriptor: QueueDescriptor, driver: QueueConsumerDriver): ProviderDescriptor;
+type ConsumerTaskConstraint<TQueue, TTask> = [TaskInput<TTask>] extends [
+    QueuePayload<TQueue>
+] ? [QueuePayload<TQueue>] extends [TaskInput<TTask>] ? unknown : never : never;
+export declare function consume<const TQueue extends QueueDescriptor<any>, const TTask extends AnyTaskDefinition>(declaration: {
+    readonly name: string;
+    readonly queue: TQueue;
+    readonly task: TTask;
+} & ConsumerTaskConstraint<TQueue, TTask>): QueueConsumerTriggerDefinition<TQueue, TTask & TaskDefinition<QueuePayload<TQueue>, any>>;
+export {};