@bluelibs/runner 5.3.0 → 5.5.0

package/dist/types/models/event/ListenerRegistry.d.ts

@@ -15,6 +15,7 @@ export declare class ListenerRegistry {
     get globalListenersCacheValid(): boolean;
     addListener(eventId: string, newListener: IListenerStorage): void;
     addGlobalListener(newListener: IListenerStorage): void;
+    removeListenerById(id: string): void;
     getListenersForEmit(eventDefinition: IEvent<any>): IListenerStorage[];
     hasListeners(eventDefinition: IEvent<any>): boolean;
     /**
@@ -26,6 +27,7 @@ export declare class ListenerRegistry {
     private invalidateCache;
     private mergeSortedListeners;
     private insertListener;
+    private removeFromListeners;
 }
 export declare function createListener(newListener: Partial<IListenerStorage>): IListenerStorage;
 export {};

package/dist/types/models/index.d.ts

@@ -1,12 +1,10 @@
-export * from "./DependencyProcessor";
 export * from "./EventManager";
 export * from "./Logger";
 export * from "./Store";
 export * from "./TaskRunner";
-export * from "./ResourceInitializer";
 export * from "./MiddlewareManager";
 export { LogPrinter } from "./LogPrinter";
-export type { PrintableLog, ColorTheme, LogLevels as LogPrinterLevels, PrintStrategy as LogPrinterPrintStrategy, } from "./LogPrinter";
+export type { PrintableLog, PrintStrategy as LogPrinterPrintStrategy, } from "./LogPrinter";
 export * from "./Semaphore";
 export * from "./Queue";
 export * from "./UnhandledError";

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

@@ -1,4 +1,4 @@
-import { IResource, DependencyMapType } from "../../defs";
+import { IResource, DependencyMapType, ResourceDependencyValuesType } from "../../defs";
 import { Store } from "../Store";
 import { InterceptorRegistry } from "./InterceptorRegistry";
 import { MiddlewareResolver } from "./MiddlewareResolver";
@@ -14,7 +14,7 @@ export declare class ResourceMiddlewareComposer {
     /**
      * Runs resource initialization with all middleware and interceptors applied
      */
-    runInit<TConfig, TValue extends Promise<any>, TDeps extends DependencyMapType, TContext>(resource: IResource<TConfig, TValue, TDeps, TContext>, config: TConfig, dependencies: any, context: TContext): Promise<TValue | undefined>;
+    runInit<TConfig, TValue extends Promise<any>, TDeps extends DependencyMapType, TContext>(resource: IResource<TConfig, TValue, TDeps, TContext>, config: TConfig, dependencies: ResourceDependencyValuesType<TDeps>, context: TContext): Promise<TValue | undefined>;
     /**
      * Creates the base resource init runner with result validation
      */
@@ -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/buildDependencyGraph.d.ts

@@ -0,0 +1,12 @@
+import type { StoreRegistry } from "../StoreRegistry";
+import type { IDependentNode } from "./findCircularDependencies";
+/**
+ * Builds a dependency graph of all registered items (tasks, resources, middlewares, hooks).
+ * Returns a flat list of dependency nodes suitable for circular-dependency detection.
+ */
+export declare function buildDependencyGraph(registry: StoreRegistry): IDependentNode[];
+/**
+ * Builds a directed graph of event emissions based on hooks listening to events
+ * and their dependencies on events (emission capability). Ignores wildcard hooks by default.
+ */
+export declare function buildEventEmissionGraph(registry: StoreRegistry): IDependentNode[];

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

@@ -0,0 +1,15 @@
+import type { Store } from "../Store";
+/**
+ * Maps a type-guard to its dependency-resolution logic.
+ */
+export interface DependencyStrategy {
+    /** Returns true if this strategy handles the given item. */
+    matches: (item: unknown) => boolean;
+    /** Returns the store map to check existence against (for optional deps). */
+    getStoreMap: (store: Store) => Map<string, unknown>;
+}
+export declare const dependencyStrategies: readonly DependencyStrategy[];
+/**
+ * Find the matching strategy for a dependency item, or undefined if none matches.
+ */
+export declare function findDependencyStrategy(item: unknown): DependencyStrategy | undefined;

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

@@ -0,0 +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[], 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.).
@@ -62,8 +32,13 @@ export declare class DurableResource implements IDurableResource {
     describe<TInput>(task: ITask<TInput, any, any, any, any, any>, input?: TInput): Promise<DurableFlowShape>;
     getWorkflows(): AnyTask[];
     private injectRecorderIntoDurableDeps;
+    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;
@@ -71,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

@@ -7,8 +7,9 @@ export type DurableResourceRuntimeConfig = RunnerDurableRuntimeConfig;
  * - `const durable = durableResource.fork("app.durable");`
  * - Register it via `durable.with({ store, queue, eventBus, ... })`
  */
-export declare const durableResource: import("../..").IResource<RunnerDurableRuntimeConfig, Promise<import("./DurableResource").DurableResource>, {
-    taskRunner: import("../..").IResource<void, Promise<import("../..").TaskRunner>, {}, any, any, import("../..").TagType[], import("../..").ResourceMiddlewareAttachmentType[]>;
-    eventManager: import("../..").IResource<void, Promise<import("../..").EventManager>, {}, any, any, import("../..").TagType[], import("../..").ResourceMiddlewareAttachmentType[]>;
-    runnerStore: import("../..").IResource<void, Promise<import("../..").Store>, {}, any, any, import("../..").TagType[], import("../..").ResourceMiddlewareAttachmentType[]>;
-}, any, import("../..").IResourceMeta, import("../..").TagType[], import("../..").ResourceMiddlewareAttachmentType[]>;
+export declare const durableResource: import("../../../defs").IResource<RunnerDurableRuntimeConfig, Promise<import("./DurableResource").DurableResource>, {
+    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).
@@ -13,9 +14,10 @@ export type MemoryDurableResourceConfig = Omit<RunnerDurableRuntimeConfig, "stor
 interface MemoryDurableResourceContext {
     runtimeConfig: RunnerDurableRuntimeConfig | null;
 }
-export declare const memoryDurableResource: import("../..").IResource<MemoryDurableResourceConfig, Promise<DurableResource>, {
-    taskRunner: import("../..").IResource<void, Promise<import("../..").TaskRunner>, {}, any, any, import("../..").TagType[], import("../..").ResourceMiddlewareAttachmentType[]>;
-    eventManager: import("../..").IResource<void, Promise<import("../..").EventManager>, {}, any, any, import("../..").TagType[], import("../..").ResourceMiddlewareAttachmentType[]>;
-    runnerStore: import("../..").IResource<void, Promise<import("../..").Store>, {}, any, any, import("../..").TagType[], import("../..").ResourceMiddlewareAttachmentType[]>;
-}, MemoryDurableResourceContext, import("../..").IResourceMeta, import("../..").TagType[], import("../..").ResourceMiddlewareAttachmentType[]>;
+export declare const memoryDurableResource: import("../../../defs").IResource<MemoryDurableResourceConfig, Promise<DurableResource>, {
+    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).
@@ -27,9 +28,10 @@ export type RedisDurableResourceConfig = Omit<RunnerDurableRuntimeConfig, "store
 interface RedisDurableResourceContext {
     runtimeConfig: RunnerDurableRuntimeConfig | null;
 }
-export declare const redisDurableResource: import("../..").IResource<RedisDurableResourceConfig, Promise<DurableResource>, {
-    taskRunner: import("../..").IResource<void, Promise<import("../..").TaskRunner>, {}, any, any, import("../..").TagType[], import("../..").ResourceMiddlewareAttachmentType[]>;
-    eventManager: import("../..").IResource<void, Promise<import("../..").EventManager>, {}, any, any, import("../..").TagType[], import("../..").ResourceMiddlewareAttachmentType[]>;
-    runnerStore: import("../..").IResource<void, Promise<import("../..").Store>, {}, any, any, import("../..").TagType[], import("../..").ResourceMiddlewareAttachmentType[]>;
-}, RedisDurableResourceContext, import("../..").IResourceMeta, import("../..").TagType[], import("../..").ResourceMiddlewareAttachmentType[]>;
+export declare const redisDurableResource: import("../../../defs").IResource<RedisDurableResourceConfig, Promise<DurableResource>, {
+    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 {};