@bluelibs/runner 5.4.0 → 5.5.0

package/dist/types/models/middleware/InterceptorRegistry.d.ts

@@ -1,4 +1,10 @@
 import { TaskMiddlewareInterceptor, ResourceMiddlewareInterceptor } from "./types";
+export type InterceptorOwnerSnapshot = {
+    globalTaskInterceptorOwnerIds: readonly string[];
+    globalResourceInterceptorOwnerIds: readonly string[];
+    perTaskMiddlewareInterceptorOwnerIds: Readonly<Record<string, readonly string[]>>;
+    perResourceMiddlewareInterceptorOwnerIds: Readonly<Record<string, readonly string[]>>;
+};
 /**
  * Centralized registry for all interceptor types.
  * Manages storage and retrieval of global and per-middleware interceptors.
@@ -24,19 +30,19 @@ export declare class InterceptorRegistry {
     /**
      * Adds a global task interceptor
      */
-    addGlobalTaskInterceptor(interceptor: TaskMiddlewareInterceptor): void;
+    addGlobalTaskInterceptor(interceptor: TaskMiddlewareInterceptor, ownerResourceId?: string): void;
     /**
      * Adds a global resource interceptor
      */
-    addGlobalResourceInterceptor(interceptor: ResourceMiddlewareInterceptor): void;
+    addGlobalResourceInterceptor(interceptor: ResourceMiddlewareInterceptor, ownerResourceId?: string): void;
     /**
      * Adds an interceptor for a specific task middleware instance
      */
-    addTaskMiddlewareInterceptor(middlewareId: string, interceptor: TaskMiddlewareInterceptor): void;
+    addTaskMiddlewareInterceptor(middlewareId: string, interceptor: TaskMiddlewareInterceptor, ownerResourceId?: string): void;
     /**
      * Adds an interceptor for a specific resource middleware instance
      */
-    addResourceMiddlewareInterceptor(middlewareId: string, interceptor: ResourceMiddlewareInterceptor): void;
+    addResourceMiddlewareInterceptor(middlewareId: string, interceptor: ResourceMiddlewareInterceptor, ownerResourceId?: string): void;
     /**
      * Gets all global task interceptors
      */
@@ -53,4 +59,7 @@ export declare class InterceptorRegistry {
      * Gets interceptors for a specific resource middleware
      */
     getResourceMiddlewareInterceptors(middlewareId: string): readonly ResourceMiddlewareInterceptor[];
+    getOwnerSnapshot(): InterceptorOwnerSnapshot;
+    private extractOwnerIds;
+    private extractOwnerIdsMap;
 }

package/dist/types/models/middleware/ResourceMiddlewareComposer.d.ts

@@ -31,4 +31,5 @@ export declare class ResourceMiddlewareComposer {
      * Wraps a middleware runner with its specific interceptors in onion style
      */
     private wrapWithInterceptors;
+    private reportUnhandledResourceInitError;
 }

package/dist/types/models/middleware/ValidationHelper.d.ts

@@ -1,3 +1,4 @@
+import type { IValidationSchema } from "../../defs";
 /**
  * Centralized validation logic for inputs and results across tasks and resources.
  * Provides consistent error handling and messaging.
@@ -7,14 +8,10 @@ export declare class ValidationHelper {
      * Validates input using the provided schema
      * @throws ValidationError if validation fails
      */
-    static validateInput<T>(value: any, schema: {
-        parse: (v: any) => T;
-    } | undefined, id: string, type: "Task" | "Resource"): T;
+    static validateInput<T>(value: unknown, schema: IValidationSchema<T> | undefined, id: string, type: "Task" | "Resource"): T;
     /**
      * Validates result using the provided schema
      * @throws ValidationError if validation fails
      */
-    static validateResult<T>(value: any, schema: {
-        parse: (v: any) => T;
-    } | undefined, id: string, type: "Task" | "Resource"): T;
+    static validateResult<T>(value: unknown, schema: IValidationSchema<T> | undefined, id: string, type: "Task" | "Resource"): T;
 }

package/dist/types/models/utils/disposeOrder.d.ts

@@ -1,7 +1,11 @@
 import { ResourceStoreElementType } from "../../types/storeTypes";
+type DisposeOrderOptions = {
+    preferInitOrderFastPath?: boolean;
+};
 /**
  * Returns initialized resources sorted in dispose order (dependents first).
  * Uses the recorded init-order when complete, otherwise falls back to a
  * topological sort derived from the resource dependency graph.
  */
-export declare function getResourcesInDisposeOrder(resources: Map<string, ResourceStoreElementType>, initializedResourceIds: readonly string[]): ResourceStoreElementType[];
+export declare function getResourcesInDisposeOrder(resources: Map<string, ResourceStoreElementType>, initializedResourceIds: readonly string[], options?: DisposeOrderOptions): ResourceStoreElementType[];
+export {};

package/dist/types/models/utils/resourceDependencyIds.d.ts

@@ -0,0 +1 @@
+export declare function getResourceDependencyIds(rawDependencies: unknown): string[];

package/dist/types/node/durable/bus/MemoryEventBus.d.ts

@@ -1,7 +1,16 @@
 import type { BusEvent, BusEventHandler, IEventBus } from "../core/interfaces/bus";
+import { Logger } from "../../../models/Logger";
+export interface MemoryEventBusConfig {
+    logger?: Logger;
+    onHandlerError?: (error: unknown) => void | Promise<void>;
+}
 export declare class MemoryEventBus implements IEventBus {
     private handlers;
+    private readonly logger;
+    private readonly onHandlerError?;
+    constructor(config?: MemoryEventBusConfig);
+    private reportHandlerError;
     publish(channel: string, event: BusEvent): Promise<void>;
     subscribe(channel: string, handler: BusEventHandler): Promise<void>;
-    unsubscribe(channel: string): Promise<void>;
+    unsubscribe(channel: string, handler?: BusEventHandler): Promise<void>;
 }

package/dist/types/node/durable/bus/NoopEventBus.d.ts

@@ -2,5 +2,5 @@ import type { BusEvent, BusEventHandler, IEventBus } from "../core/interfaces/bu
 export declare class NoopEventBus implements IEventBus {
     publish(_channel: string, _event: BusEvent): Promise<void>;
     subscribe(_channel: string, _handler: BusEventHandler): Promise<void>;
-    unsubscribe(_channel: string): Promise<void>;
+    unsubscribe(_channel: string, _handler?: BusEventHandler): Promise<void>;
 }

package/dist/types/node/durable/bus/RedisEventBus.d.ts

@@ -1,7 +1,10 @@
 import type { BusEvent, BusEventHandler, IEventBus } from "../core/interfaces/bus";
+import { Logger } from "../../../models/Logger";
 export interface RedisEventBusConfig {
     prefix?: string;
     redis?: RedisEventBusClient | string;
+    logger?: Logger;
+    onHandlerError?: (error: unknown) => void | Promise<void>;
 }
 export interface RedisEventBusClient {
     publish(channel: string, payload: string): Promise<unknown>;
@@ -17,7 +20,10 @@ export declare class RedisEventBus implements IEventBus {
     private prefix;
     private readonly channels;
     private readonly serializer;
-    constructor(config: RedisEventBusConfig);
+    private readonly logger;
+    private readonly onHandlerError?;
+    constructor(config?: RedisEventBusConfig);
+    private reportHandlerError;
     private k;
     private tryParse;
     private coerceTimestamp;
@@ -25,6 +31,6 @@ export declare class RedisEventBus implements IEventBus {
     private deserializeEvent;
     publish(channel: string, event: BusEvent): Promise<void>;
     subscribe(channel: string, handler: BusEventHandler): Promise<void>;
-    unsubscribe(channel: string): Promise<void>;
+    unsubscribe(channel: string, handler?: BusEventHandler): Promise<void>;
     dispose(): Promise<void>;
 }

package/dist/types/node/durable/core/CronParser.d.ts

@@ -1,15 +1,4 @@
-/**
- * Cron helper used by `ScheduleManager`.
- *
- * Prefers the optional `cron-parser` dependency when available, but provides a
- * deterministic fallback implementation so durable scheduling works even when
- * optional deps are not installed (important for the multi-platform packaging
- * and optionalDependency setup).
- */
 export declare class CronParser {
-    static getNextRun(cron: string, from?: Date): Date;
-    static isValid(cron: string): boolean;
-    private static tryGetExternalParser;
-    private static parseFallback;
-    private static getNextRunFallback;
+    static getNextRun(expression: string, from?: Date): Date;
+    static isValid(expression: string): boolean;
 }

package/dist/types/node/durable/core/DurableResource.d.ts

@@ -3,46 +3,16 @@ import type { Store } from "../../../models/Store";
 import type { IEventDefinition } from "../../../types/event";
 import type { AnyTask, ITask } from "../../../types/task";
 import type { IDurableContext } from "./interfaces/context";
+import type { IDurableResource } from "./interfaces/resource";
 import type { DurableStartAndWaitResult, ExecuteOptions, IDurableService, ScheduleOptions } from "./interfaces/service";
 import type { Schedule } from "./types";
 import type { IDurableStore } from "./interfaces/store";
 import { DurableOperator } from "./DurableOperator";
 import { type DurableFlowShape } from "./flowShape";
+export type { IDurableResource } from "./interfaces/resource";
 export interface DurableResourceConfig {
     worker?: boolean;
 }
-export interface IDurableResource extends Pick<IDurableService, "cancelExecution" | "wait" | "schedule" | "ensureSchedule" | "pauseSchedule" | "resumeSchedule" | "getSchedule" | "listSchedules" | "updateSchedule" | "removeSchedule" | "recover" | "signal"> {
-    start<TInput, TResult>(task: ITask<TInput, Promise<TResult>, any, any, any, any>, input?: TInput, options?: ExecuteOptions): Promise<string>;
-    start(task: string, input?: unknown, options?: ExecuteOptions): Promise<string>;
-    startAndWait<TInput, TResult>(task: ITask<TInput, Promise<TResult>, any, any, any, any>, input?: TInput, options?: ExecuteOptions): Promise<DurableStartAndWaitResult<TResult>>;
-    startAndWait<TResult = unknown>(task: string, input?: unknown, options?: ExecuteOptions): Promise<DurableStartAndWaitResult<TResult>>;
-    /**
-     * Reads the durable context for the currently running workflow execution.
-     * Throws if called outside of a durable execution.
-     */
-    use(): IDurableContext;
-    /**
-     * Describe a durable workflow task using real runtime dependencies.
-     *
-     * - Non-durable deps are kept as-is (so pre-step control flow can use them).
-     * - Durable deps are shimmed so `durable.use()` returns the recorder context.
-     *
-     * The task must be registered in the runtime store (ie. part of the app tree).
-     *
-     * Accepts any Runner `ITask`. Generic `TInput` is inferred from the task,
-     * or can be specified explicitly: `describe<MyInput>(task, input)`.
-     */
-    describe<TInput>(task: ITask<TInput, any, any, any, any, any>, input?: TInput): Promise<DurableFlowShape>;
-    /**
-     * Store-backed operator API to inspect and administrate executions
-     * (steps/audit/history and operator actions where supported by the store).
-     */
-    readonly operator: DurableOperator;
-    /**
-     * Returns all tasks tagged as durable workflows in the current runtime.
-     */
-    getWorkflows(): AnyTask[];
-}
 /**
  * A Runner-facing wrapper around `DurableService` that exposes a per-instance
  * context store and the public durable API (`start`, `startAndWait`, `signal`, `wait`, etc.).
@@ -65,6 +35,10 @@ export declare class DurableResource implements IDurableResource {
     private resolveDescribeInput;
     start<TInput, TResult>(task: ITask<TInput, Promise<TResult>, any, any, any, any>, input?: TInput, options?: ExecuteOptions): Promise<string>;
     start(task: string, input?: unknown, options?: ExecuteOptions): Promise<string>;
+    /** @deprecated Use start(task, input, options). */
+    startExecution<TInput, TResult>(task: ITask<TInput, Promise<TResult>, any, any, any, any>, input?: TInput, options?: ExecuteOptions): Promise<string>;
+    /** @deprecated Use start(task, input, options). */
+    startExecution(task: string, input?: unknown, options?: ExecuteOptions): Promise<string>;
     cancelExecution(executionId: string, reason?: string): Promise<void>;
     wait<TResult>(executionId: string, options?: {
         timeout?: number;
@@ -72,6 +46,14 @@ export declare class DurableResource implements IDurableResource {
     }): Promise<TResult>;
     startAndWait<TInput, TResult>(task: ITask<TInput, Promise<TResult>, any, any, any, any>, input?: TInput, options?: ExecuteOptions): Promise<DurableStartAndWaitResult<TResult>>;
     startAndWait<TResult = unknown>(task: string, input?: unknown, options?: ExecuteOptions): Promise<DurableStartAndWaitResult<TResult>>;
+    /** @deprecated Use startAndWait(task, input, options) and read `result.data`. */
+    execute<TInput, TResult>(task: ITask<TInput, Promise<TResult>, any, any, any, any>, input?: TInput, options?: ExecuteOptions): Promise<TResult>;
+    /** @deprecated Use startAndWait(task, input, options) and read `result.data`. */
+    execute<TResult = unknown>(task: string, input?: unknown, options?: ExecuteOptions): Promise<TResult>;
+    /** @deprecated Use startAndWait(task, input, options). */
+    executeStrict<TInput, TResult>(task: ITask<TInput, Promise<TResult>, any, any, any, any>, input?: TInput, options?: ExecuteOptions): Promise<DurableStartAndWaitResult<TResult>>;
+    /** @deprecated Use startAndWait(task, input, options). */
+    executeStrict<TResult = unknown>(task: string, input?: unknown, options?: ExecuteOptions): Promise<DurableStartAndWaitResult<TResult>>;
     schedule<TInput, TResult>(task: ITask<TInput, Promise<TResult>, any, any, any, any>, input: TInput | undefined, options: ScheduleOptions): Promise<string>;
     schedule(task: string, input: unknown, options: ScheduleOptions): Promise<string>;
     ensureSchedule<TInput, TResult>(task: ITask<TInput, Promise<TResult>, any, any, any, any>, input: TInput | undefined, options: ScheduleOptions & {

package/dist/types/node/durable/core/DurableService.d.ts

@@ -30,6 +30,7 @@ export declare class DurableService implements IDurableService {
     private readonly signalHandler;
     private readonly executionManager;
     private readonly pollingManager;
+    private readonly logger;
     /** Unique worker ID for distributed timer coordination */
     private readonly workerId;
     constructor(config: DurableServiceConfig);

package/dist/types/node/durable/core/DurableWorker.d.ts

@@ -1,5 +1,6 @@
 import type { IDurableQueue } from "./interfaces/queue";
 import type { IDurableExecutionProcessor } from "./interfaces/service";
+import { Logger } from "../../../models/Logger";
 /**
  * Durable queue consumer (worker process role).
  *
@@ -11,9 +12,10 @@ import type { IDurableExecutionProcessor } from "./interfaces/service";
 export declare class DurableWorker {
     private readonly service;
     private readonly queue;
-    constructor(service: IDurableExecutionProcessor, queue: IDurableQueue);
+    private readonly logger;
+    constructor(service: IDurableExecutionProcessor, queue: IDurableQueue, logger?: Logger);
     start(): Promise<void>;
     private handleMessage;
     private extractExecutionId;
 }
-export declare function initDurableWorker(service: IDurableExecutionProcessor, queue: IDurableQueue): Promise<DurableWorker>;
+export declare function initDurableWorker(service: IDurableExecutionProcessor, queue: IDurableQueue, logger?: Logger): Promise<DurableWorker>;

package/dist/types/node/durable/core/createRunnerDurableRuntime.d.ts

@@ -3,6 +3,7 @@ import { DurableResource } from "./DurableResource";
 import type { EventManager } from "../../../models/EventManager";
 import type { TaskRunner } from "../../../models/TaskRunner";
 import type { Store } from "../../../models/Store";
+import type { Logger } from "../../../models/Logger";
 export type RunnerDurableRuntimeConfig = Omit<DurableServiceConfig, "taskExecutor" | "tasks" | "taskResolver" | "contextProvider"> & {
     /**
      * Starts an embedded worker (queue consumer) in this process.
@@ -14,5 +15,6 @@ export interface RunnerDurableDeps {
     taskRunner: TaskRunner;
     eventManager: EventManager;
     runnerStore: Store;
+    logger: Logger;
 }
 export declare function createRunnerDurableRuntime(config: RunnerDurableRuntimeConfig, deps: RunnerDurableDeps): Promise<DurableResource>;

package/dist/types/node/durable/core/interfaces/bus.d.ts

@@ -7,7 +7,7 @@ export type BusEventHandler = (event: BusEvent) => Promise<void>;
 export interface IEventBus {
     publish(channel: string, event: BusEvent): Promise<void>;
     subscribe(channel: string, handler: BusEventHandler): Promise<void>;
-    unsubscribe(channel: string): Promise<void>;
+    unsubscribe(channel: string, handler?: BusEventHandler): Promise<void>;
     init?(): Promise<void>;
     dispose?(): Promise<void>;
 }

package/dist/types/node/durable/core/interfaces/resource.d.ts

@@ -0,0 +1,61 @@
+import type { AnyTask, ITask } from "../../../../types/task";
+import type { IDurableContext } from "./context";
+import type { DurableStartAndWaitResult, ExecuteOptions, IDurableService } from "./service";
+import type { DurableOperator } from "../DurableOperator";
+import type { DurableFlowShape } from "../flowShape";
+export interface IDurableResource extends Pick<IDurableService, "cancelExecution" | "wait" | "schedule" | "ensureSchedule" | "pauseSchedule" | "resumeSchedule" | "getSchedule" | "listSchedules" | "updateSchedule" | "removeSchedule" | "recover" | "signal"> {
+    /**
+     * @deprecated Use start(task, input, options).
+     */
+    startExecution<TInput, TResult>(task: ITask<TInput, Promise<TResult>, any, any, any, any>, input?: TInput, options?: ExecuteOptions): Promise<string>;
+    /**
+     * @deprecated Use start(task, input, options).
+     */
+    startExecution(task: string, input?: unknown, options?: ExecuteOptions): Promise<string>;
+    start<TInput, TResult>(task: ITask<TInput, Promise<TResult>, any, any, any, any>, input?: TInput, options?: ExecuteOptions): Promise<string>;
+    start(task: string, input?: unknown, options?: ExecuteOptions): Promise<string>;
+    startAndWait<TInput, TResult>(task: ITask<TInput, Promise<TResult>, any, any, any, any>, input?: TInput, options?: ExecuteOptions): Promise<DurableStartAndWaitResult<TResult>>;
+    startAndWait<TResult = unknown>(task: string, input?: unknown, options?: ExecuteOptions): Promise<DurableStartAndWaitResult<TResult>>;
+    /**
+     * @deprecated Use startAndWait(task, input, options) and read `result.data`.
+     */
+    execute<TInput, TResult>(task: ITask<TInput, Promise<TResult>, any, any, any, any>, input?: TInput, options?: ExecuteOptions): Promise<TResult>;
+    /**
+     * @deprecated Use startAndWait(task, input, options) and read `result.data`.
+     */
+    execute<TResult = unknown>(task: string, input?: unknown, options?: ExecuteOptions): Promise<TResult>;
+    /**
+     * @deprecated Use startAndWait(task, input, options).
+     */
+    executeStrict<TInput, TResult>(task: ITask<TInput, Promise<TResult>, any, any, any, any>, input?: TInput, options?: ExecuteOptions): Promise<DurableStartAndWaitResult<TResult>>;
+    /**
+     * @deprecated Use startAndWait(task, input, options).
+     */
+    executeStrict<TResult = unknown>(task: string, input?: unknown, options?: ExecuteOptions): Promise<DurableStartAndWaitResult<TResult>>;
+    /**
+     * Reads the durable context for the currently running workflow execution.
+     * Throws if called outside of a durable execution.
+     */
+    use(): IDurableContext;
+    /**
+     * Describe a durable workflow task using real runtime dependencies.
+     *
+     * - Non-durable deps are kept as-is (so pre-step control flow can use them).
+     * - Durable deps are shimmed so `durable.use()` returns the recorder context.
+     *
+     * The task must be registered in the runtime store (ie. part of the app tree).
+     *
+     * Accepts any Runner `ITask`. Generic `TInput` is inferred from the task,
+     * or can be specified explicitly: `describe<MyInput>(task, input)`.
+     */
+    describe<TInput>(task: ITask<TInput, any, any, any, any, any>, input?: TInput): Promise<DurableFlowShape>;
+    /**
+     * Store-backed operator API to inspect and administrate executions
+     * (steps/audit/history and operator actions where supported by the store).
+     */
+    readonly operator: DurableOperator;
+    /**
+     * Returns all tasks tagged as durable workflows in the current runtime.
+     */
+    getWorkflows(): AnyTask[];
+}

package/dist/types/node/durable/core/interfaces/service.d.ts

@@ -6,6 +6,7 @@ import type { IEventBus } from "./bus";
 import type { IDurableContext } from "./context";
 import type { Schedule } from "../types";
 import type { DurableAuditEmitter } from "../audit";
+import type { Logger } from "../../../../models/Logger";
 export interface ITaskExecutor {
     run<TInput, TResult>(task: ITask<TInput, Promise<TResult>, any, any, any, any>, input?: TInput): Promise<TResult>;
 }
@@ -20,6 +21,7 @@ export interface DurableServiceConfig {
     store: IDurableStore;
     queue?: IDurableQueue;
     eventBus?: IEventBus;
+    logger?: Logger;
     taskExecutor?: ITaskExecutor;
     determinism?: {
         /**

package/dist/types/node/durable/core/interfaces/store.d.ts

@@ -62,5 +62,10 @@ export interface IDurableStore {
     init?(): Promise<void>;
     dispose?(): Promise<void>;
     acquireLock?(resource: string, ttlMs: number): Promise<string | null>;
+    /**
+     * Renews an existing lock if and only if `lockId` still owns `resource`.
+     * Returns true when renewed, false when lock is missing/expired/re-owned.
+     */
+    renewLock?(resource: string, lockId: string, ttlMs: number): Promise<boolean>;
     releaseLock?(resource: string, lockId: string): Promise<void>;
 }

package/dist/types/node/durable/core/managers/ExecutionManager.d.ts

@@ -71,6 +71,7 @@ export declare class ExecutionManager {
     cancelExecution(executionId: string, reason?: string): Promise<void>;
     startAndWait(taskRef: string | ITask<any, Promise<any>, any, any, any, any>, input?: unknown, options?: ExecuteOptions): Promise<DurableStartAndWaitResult<unknown>>;
     processExecution(executionId: string): Promise<void>;
+    private startLockHeartbeat;
     kickoffExecution(executionId: string): Promise<void>;
     notifyExecutionFinished(execution: Execution): Promise<void>;
     private runExecutionAttempt;

package/dist/types/node/durable/core/managers/PollingManager.d.ts

@@ -4,6 +4,7 @@ import { type Timer } from "../types";
 import type { AuditLogger } from "./AuditLogger";
 import type { TaskRegistry } from "./TaskRegistry";
 import type { ScheduleManager } from "./ScheduleManager";
+import { Logger } from "../../../../models/Logger";
 export interface PollingConfig {
     enabled?: boolean;
     interval?: number;
@@ -39,7 +40,8 @@ export declare class PollingManager {
     private isRunning;
     private pollingTimer;
     private pollingWake;
-    constructor(workerId: string, config: PollingConfig, store: IDurableStore, queue: IDurableQueue | undefined, maxAttempts: number, defaultTimeout: number | undefined, taskRegistry: TaskRegistry, auditLogger: AuditLogger, scheduleManager: ScheduleManager, callbacks: PollingManagerCallbacks);
+    private readonly logger;
+    constructor(workerId: string, config: PollingConfig, store: IDurableStore, queue: IDurableQueue | undefined, maxAttempts: number, defaultTimeout: number | undefined, taskRegistry: TaskRegistry, auditLogger: AuditLogger, scheduleManager: ScheduleManager, callbacks: PollingManagerCallbacks, logger?: Logger);
     start(): void;
     stop(): Promise<void>;
     private poll;

package/dist/types/node/durable/core/resource.d.ts

@@ -8,7 +8,8 @@ export type DurableResourceRuntimeConfig = RunnerDurableRuntimeConfig;
  * - Register it via `durable.with({ store, queue, eventBus, ... })`
  */
 export declare const durableResource: import("../../../defs").IResource<RunnerDurableRuntimeConfig, Promise<import("./DurableResource").DurableResource>, {
-    taskRunner: import("../../../defs").IResource<void, Promise<import("../../../models").TaskRunner>, {}, any, any, import("../../../defs").TagType[], import("../../../defs").ResourceMiddlewareAttachmentType[]>;
-    eventManager: import("../../../defs").IResource<void, Promise<import("../../../models").EventManager>, {}, any, any, import("../../../defs").TagType[], import("../../../defs").ResourceMiddlewareAttachmentType[]>;
-    runnerStore: import("../../../defs").IResource<void, Promise<import("../../../models").Store>, {}, any, any, import("../../../defs").TagType[], import("../../../defs").ResourceMiddlewareAttachmentType[]>;
+    taskRunner: import("../../../defs").IResource<void, Promise<import("../..").TaskRunner>, {}, any, any, import("../../../defs").TagType[], import("../../../defs").ResourceMiddlewareAttachmentType[]>;
+    eventManager: import("../../../defs").IResource<void, Promise<import("../..").EventManager>, {}, any, any, import("../../../defs").TagType[], import("../../../defs").ResourceMiddlewareAttachmentType[]>;
+    runnerStore: import("../../../defs").IResource<void, Promise<import("../..").Store>, {}, any, any, import("../../../defs").TagType[], import("../../../defs").ResourceMiddlewareAttachmentType[]>;
+    logger: import("../../../defs").IResource<void, Promise<import("../..").Logger>, {}, any, any, import("../../../defs").TagType[], import("../../../defs").ResourceMiddlewareAttachmentType[]>;
 }, any, import("../../../defs").IResourceMeta, import("../../../defs").TagType[], import("../../../defs").ResourceMiddlewareAttachmentType[]>;

package/dist/types/node/durable/core/utils.d.ts

@@ -1,3 +1,4 @@
+import { RunnerError } from "../../../definers/defineError";
 export declare function isRecord(value: unknown): value is Record<string, unknown>;
 export declare function sleepMs(ms: number): Promise<void>;
 export declare function withTimeout<T>(promise: Promise<T>, timeoutMs: number, message: string): Promise<T>;
@@ -13,7 +14,16 @@ export declare function parseSignalState(value: unknown): {
  * task errors by carrying execution metadata and a (serialized) cause payload.
  * `WaitManager` is the primary producer of this error.
  */
-export declare class DurableExecutionError extends Error {
+export declare class DurableExecutionError extends RunnerError<{
+    message: string;
+    executionId: string;
+    taskId: string;
+    attempt: number;
+    causeInfo?: {
+        message: string;
+        stack?: string;
+    };
+}> {
     readonly executionId: string;
     readonly taskId: string;
     readonly attempt: number;

package/dist/types/node/durable/queue/RabbitMQQueue.d.ts

@@ -1,4 +1,5 @@
 import type { IDurableQueue, MessageHandler, QueueMessage } from "../core/interfaces/queue";
+import { Logger } from "../../../models/Logger";
 export interface RabbitMQQueueConfig {
     url?: string;
     queueName?: string;
@@ -9,6 +10,7 @@ export interface RabbitMQQueueConfig {
         messageTtl?: number;
     };
     prefetch?: number;
+    logger?: Pick<Logger, "error">;
 }
 export declare class RabbitMQQueue implements IDurableQueue {
     private connection;
@@ -19,8 +21,10 @@ export declare class RabbitMQQueue implements IDurableQueue {
     private readonly isQuorum;
     private readonly deadLetterQueue?;
     private readonly messageTtl?;
+    private readonly logger;
     private messageMap;
     constructor(config: RabbitMQQueueConfig);
+    private reportError;
     init(): Promise<void>;
     enqueue<T>(message: Omit<QueueMessage<T>, "id" | "createdAt" | "attempts">): Promise<string>;
     consume<T>(handler: MessageHandler<T>): Promise<void>;

package/dist/types/node/durable/resources/memoryDurableResource.d.ts

@@ -1,5 +1,6 @@
 import type { RunnerDurableRuntimeConfig } from "../core/createRunnerDurableRuntime";
 import type { DurableResource } from "../core/DurableResource";
+import { Logger } from "../../../models/Logger";
 export type MemoryDurableResourceConfig = Omit<RunnerDurableRuntimeConfig, "store" | "queue" | "eventBus"> & {
     /**
      * Isolation namespace (used for defaults and docs).
@@ -14,8 +15,9 @@ interface MemoryDurableResourceContext {
     runtimeConfig: RunnerDurableRuntimeConfig | null;
 }
 export declare const memoryDurableResource: import("../../../defs").IResource<MemoryDurableResourceConfig, Promise<DurableResource>, {
-    taskRunner: import("../../../defs").IResource<void, Promise<import("../../../models").TaskRunner>, {}, any, any, import("../../../defs").TagType[], import("../../../defs").ResourceMiddlewareAttachmentType[]>;
-    eventManager: import("../../../defs").IResource<void, Promise<import("../../../models").EventManager>, {}, any, any, import("../../../defs").TagType[], import("../../../defs").ResourceMiddlewareAttachmentType[]>;
-    runnerStore: import("../../../defs").IResource<void, Promise<import("../../../models").Store>, {}, any, any, import("../../../defs").TagType[], import("../../../defs").ResourceMiddlewareAttachmentType[]>;
+    taskRunner: import("../../../defs").IResource<void, Promise<import("../..").TaskRunner>, {}, any, any, import("../../../defs").TagType[], import("../../../defs").ResourceMiddlewareAttachmentType[]>;
+    eventManager: import("../../../defs").IResource<void, Promise<import("../..").EventManager>, {}, any, any, import("../../../defs").TagType[], import("../../../defs").ResourceMiddlewareAttachmentType[]>;
+    runnerStore: import("../../../defs").IResource<void, Promise<import("../..").Store>, {}, any, any, import("../../../defs").TagType[], import("../../../defs").ResourceMiddlewareAttachmentType[]>;
+    logger: import("../../../defs").IResource<void, Promise<Logger>, {}, any, any, import("../../../defs").TagType[], import("../../../defs").ResourceMiddlewareAttachmentType[]>;
 }, MemoryDurableResourceContext, import("../../../defs").IResourceMeta, import("../../../defs").TagType[], import("../../../defs").ResourceMiddlewareAttachmentType[]>;
 export {};

package/dist/types/node/durable/resources/redisDurableResource.d.ts

@@ -1,5 +1,6 @@
 import type { RunnerDurableRuntimeConfig } from "../core/createRunnerDurableRuntime";
 import type { DurableResource } from "../core/DurableResource";
+import { Logger } from "../../../models/Logger";
 export type RedisDurableResourceConfig = Omit<RunnerDurableRuntimeConfig, "store" | "queue" | "eventBus"> & {
     /**
      * Isolation namespace (used for key prefixes and queue names).
@@ -28,8 +29,9 @@ interface RedisDurableResourceContext {
     runtimeConfig: RunnerDurableRuntimeConfig | null;
 }
 export declare const redisDurableResource: import("../../../defs").IResource<RedisDurableResourceConfig, Promise<DurableResource>, {
-    taskRunner: import("../../../defs").IResource<void, Promise<import("../../../models").TaskRunner>, {}, any, any, import("../../../defs").TagType[], import("../../../defs").ResourceMiddlewareAttachmentType[]>;
-    eventManager: import("../../../defs").IResource<void, Promise<import("../../../models").EventManager>, {}, any, any, import("../../../defs").TagType[], import("../../../defs").ResourceMiddlewareAttachmentType[]>;
-    runnerStore: import("../../../defs").IResource<void, Promise<import("../../../models").Store>, {}, any, any, import("../../../defs").TagType[], import("../../../defs").ResourceMiddlewareAttachmentType[]>;
+    taskRunner: import("../../../defs").IResource<void, Promise<import("../..").TaskRunner>, {}, any, any, import("../../../defs").TagType[], import("../../../defs").ResourceMiddlewareAttachmentType[]>;
+    eventManager: import("../../../defs").IResource<void, Promise<import("../..").EventManager>, {}, any, any, import("../../../defs").TagType[], import("../../../defs").ResourceMiddlewareAttachmentType[]>;
+    runnerStore: import("../../../defs").IResource<void, Promise<import("../..").Store>, {}, any, any, import("../../../defs").TagType[], import("../../../defs").ResourceMiddlewareAttachmentType[]>;
+    logger: import("../../../defs").IResource<void, Promise<Logger>, {}, any, any, import("../../../defs").TagType[], import("../../../defs").ResourceMiddlewareAttachmentType[]>;
 }, RedisDurableResourceContext, import("../../../defs").IResourceMeta, import("../../../defs").TagType[], import("../../../defs").ResourceMiddlewareAttachmentType[]>;
 export {};

package/dist/types/node/durable/store/MemoryStore.d.ts

@@ -9,6 +9,7 @@ export declare class MemoryStore implements IDurableStore {
     private timers;
     private schedules;
     private locks;
+    private pruneExpiredLocks;
     private getIdempotencyMapKey;
     getExecutionIdByIdempotencyKey(params: {
         taskId: string;
@@ -52,5 +53,6 @@ export declare class MemoryStore implements IDurableStore {
     listSchedules(): Promise<Schedule[]>;
     listActiveSchedules(): Promise<Schedule[]>;
     acquireLock(resource: string, ttlMs: number): Promise<string | null>;
+    renewLock(resource: string, lockId: string, ttlMs: number): Promise<boolean>;
     releaseLock(resource: string, lockId: string): Promise<void>;
 }

package/dist/types/node/durable/store/RedisStore.d.ts

@@ -85,5 +85,6 @@ export declare class RedisStore implements IDurableStore {
     listActiveSchedules(): Promise<Schedule[]>;
     acquireLock(resource: string, ttlMs: number): Promise<string | null>;
     releaseLock(resource: string, lockId: string): Promise<void>;
+    renewLock(resource: string, lockId: string, ttlMs: number): Promise<boolean>;
     dispose(): Promise<void>;
 }

package/dist/types/node/exposure/allowList.d.ts

@@ -1,3 +1,4 @@
 import type { Store } from "../../models/Store";
+import type { Logger } from "../../models/Logger";
 import type { AllowListGuard } from "./types";
-export declare function createAllowListGuard(store: Store, allowOpen?: boolean): AllowListGuard;
+export declare function createAllowListGuard(store: Store, allowOpen?: boolean, logger?: Logger): AllowListGuard;

package/dist/types/node/exposure/handlers/contextWrapper.d.ts

@@ -8,11 +8,15 @@ export interface ExposureContextDeps {
     };
     serializer: SerializerLike;
 }
+interface AsyncContextHydrationOptions {
+    allowAsyncContext?: boolean;
+}
 /**
  * Builds a composed provider: first user async contexts (if any), then exposure context
  */
-export declare const withExposureContext: <T>(req: IncomingMessage, res: ServerResponse, controller: AbortController, deps: ExposureContextDeps, fn: () => Promise<T>) => Promise<T>;
+export declare const withExposureContext: <T>(req: IncomingMessage, res: ServerResponse, controller: AbortController, deps: ExposureContextDeps, fn: () => Promise<T>, options?: AsyncContextHydrationOptions) => Promise<T>;
 /**
  * Builds user async contexts (if any), without exposure context (for events)
  */
-export declare const withUserContexts: <T>(req: IncomingMessage, deps: Pick<ExposureContextDeps, "store" | "serializer">, fn: () => Promise<T>) => Promise<T>;
+export declare const withUserContexts: <T>(req: IncomingMessage, deps: Pick<ExposureContextDeps, "store" | "serializer">, fn: () => Promise<T>, options?: AsyncContextHydrationOptions) => Promise<T>;
+export {};

package/dist/types/node/exposure/handlers/errorHandlers.d.ts

@@ -19,5 +19,6 @@ export interface HandleRequestErrorOptions {
     cors?: NodeExposureHttpCorsConfig;
     serializer: SerializerLike;
     logKey: ExposureErrorLogKey;
+    requestId?: string;
 }
 export declare const handleRequestError: (options: HandleRequestErrorOptions) => void;

package/dist/types/node/exposure/handlers/eventHandler.d.ts

@@ -15,6 +15,7 @@ interface EventHandlerDeps {
             maxSize?: number;
         };
     };
+    allowAsyncContext?: (eventId: string) => boolean;
 }
 export declare const createEventHandler: (deps: EventHandlerDeps) => (req: IncomingMessage, res: ServerResponse, eventId: string) => Promise<void>;
 export {};

package/dist/types/node/exposure/handlers/taskHandler.d.ts

@@ -2,6 +2,7 @@ import type { IncomingMessage, ServerResponse } from "http";
 import type { SerializerLike } from "../../../serializer";
 import type { Authenticator, AllowListGuard } from "../types";
 import type { NodeExposureDeps, NodeExposureHttpCorsConfig } from "../resourceTypes";
+import type { MultipartLimits } from "../multipart";
 interface TaskHandlerDeps {
     store: NodeExposureDeps["store"];
     taskRunner: NodeExposureDeps["taskRunner"];
@@ -17,8 +18,9 @@ interface TaskHandlerDeps {
         json?: {
             maxSize?: number;
         };
-        multipart?: any;
+        multipart?: MultipartLimits;
     };
+    allowAsyncContext?: (taskId: string) => boolean;
 }
 export declare const createTaskHandler: (deps: TaskHandlerDeps) => (req: IncomingMessage, res: ServerResponse, taskId: string) => Promise<void>;
 export {};

package/dist/types/node/exposure/logging.d.ts

@@ -1,4 +1,5 @@
 import type { Logger } from "../../models/Logger";
 export declare function safeLogError(logger: Logger, message: string, data: Record<string, unknown>): void;
 export declare function safeLogInfo(logger: Logger, message: string, data: Record<string, unknown>): void;
+export declare function safeLogWarn(logger: Logger, message: string, data: Record<string, unknown>): void;
 export declare function errorMessage(error: unknown): string;