@bluelibs/runner 5.1.0 → 5.2.1

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

@@ -0,0 +1,146 @@
+import type { IEventDefinition } from "../../../../types/event";
+import type { IDurableStore } from "./store";
+import type { IDurableQueue } from "./queue";
+import type { IEventBus } from "./bus";
+import type { IDurableContext } from "./context";
+import type { Schedule } from "../types";
+import type { DurableAuditEmitter } from "../audit";
+export interface DurableTask<TInput = unknown, TResult = unknown> {
+    id: string;
+    run(input: TInput, ...args: any[]): Promise<TResult>;
+}
+export interface ITaskExecutor {
+    run<TInput, TResult>(task: DurableTask<TInput, TResult>, input?: TInput): Promise<TResult>;
+}
+export interface ScheduleConfig<TInput = unknown> {
+    id: string;
+    task: DurableTask<TInput, unknown>;
+    cron?: string;
+    interval?: number;
+    input: TInput;
+}
+export interface DurableServiceConfig {
+    store: IDurableStore;
+    queue?: IDurableQueue;
+    eventBus?: IEventBus;
+    taskExecutor?: ITaskExecutor;
+    determinism?: {
+        /**
+         * Internal step IDs for `sleep()`/`emit()`/`waitForSignal()` default to call-order based IDs.
+         * In production this can be a replay/versioning footgun when refactors change call order.
+         *
+         * - "allow" (default): do nothing
+         * - "warn": emit a warning on first implicit internal step per kind
+         * - "error": throw when an implicit internal step id would be used
+         */
+        implicitInternalStepIds?: "allow" | "warn" | "error";
+    };
+    /**
+     * Unique identifier for this worker instance.
+     * Used for distributed timer coordination to ensure only one worker processes each timer.
+     * If not provided, a random UUID is generated.
+     */
+    workerId?: string;
+    /**
+     * Runs a callback with the given durable context available.
+     * In Runner environments this is typically implemented via AsyncLocalStorage
+     * so tasks can call `durable.use()`.
+     */
+    contextProvider?: <R>(context: IDurableContext, fn: () => Promise<R> | R) => Promise<R> | R;
+    /**
+     * Resolves tasks by id for resuming/recovering executions.
+     * Useful in Runner environments where tasks are registered in the Store registry.
+     */
+    taskResolver?: (taskId: string) => DurableTask<any, any> | undefined;
+    audit?: {
+        enabled?: boolean;
+        emitter?: DurableAuditEmitter;
+    };
+    polling?: {
+        enabled?: boolean;
+        interval?: number;
+        /** Time-to-live for timer claims in milliseconds. Default: 30000. */
+        claimTtlMs?: number;
+    };
+    execution?: {
+        maxAttempts?: number;
+        timeout?: number;
+        /**
+         * When a queue is configured, `startExecution()` persists the execution and then enqueues it.
+         * If enqueue fails (eg. broker outage), the execution would otherwise remain "pending" forever.
+         *
+         * This delay arms a small store-backed timer as a failsafe so workers can retry resuming it
+         * via the poller. Default: 10000 (10s). Set to 0 to disable.
+         */
+        kickoffFailsafeDelayMs?: number;
+    };
+    schedules?: ScheduleConfig[];
+    tasks?: Array<DurableTask<any, any>>;
+}
+export interface ExecuteOptions {
+    timeout?: number;
+    priority?: number;
+    waitPollIntervalMs?: number;
+    /**
+     * Optional workflow-level idempotency key.
+     * When supported by the store, multiple concurrent callers using the same key will receive the same executionId.
+     */
+    idempotencyKey?: string;
+}
+export interface ScheduleOptions {
+    id?: string;
+    at?: Date;
+    delay?: number;
+    cron?: string;
+    interval?: number;
+}
+export interface IDurableService {
+    startExecution<TInput>(task: DurableTask<TInput, unknown>, input?: TInput, options?: ExecuteOptions): Promise<string>;
+    /**
+     * Request cancellation for an execution.
+     * Cancellation is cooperative: it marks the execution as cancelled and unblocks waiters,
+     * but cannot preempt arbitrary in-process async work.
+     */
+    cancelExecution(executionId: string, reason?: string): Promise<void>;
+    wait<TResult>(executionId: string, options?: {
+        timeout?: number;
+        waitPollIntervalMs?: number;
+    }): Promise<TResult>;
+    execute<TInput, TResult>(task: DurableTask<TInput, TResult>, input?: TInput, options?: ExecuteOptions): Promise<TResult>;
+    /**
+     * A stricter alternative to `execute()` that rejects tasks whose result type
+     * includes `undefined` (including `void`, `unknown`, and `any`).
+     *
+     * This mirrors the runtime contract where `wait()`/`execute()` treat
+     * "completed without result" as an error.
+     */
+    executeStrict<TInput, TResult>(task: undefined extends TResult ? never : DurableTask<TInput, TResult>, input?: TInput, options?: ExecuteOptions): Promise<TResult>;
+    schedule<TInput>(task: DurableTask<TInput, unknown>, input: TInput | undefined, options: ScheduleOptions): Promise<string>;
+    /**
+     * Idempotently create (or update) a recurring schedule (cron/interval) with a stable id.
+     * Safe to call concurrently from multiple processes.
+     */
+    ensureSchedule<TInput>(task: DurableTask<TInput, unknown>, input: TInput | undefined, options: ScheduleOptions & {
+        id: string;
+    }): Promise<string>;
+    recover(): Promise<void>;
+    start(): void;
+    stop(): Promise<void>;
+    pauseSchedule(scheduleId: string): Promise<void>;
+    resumeSchedule(scheduleId: string): Promise<void>;
+    getSchedule(scheduleId: string): Promise<Schedule | null>;
+    listSchedules(): Promise<Schedule[]>;
+    updateSchedule(scheduleId: string, updates: {
+        cron?: string;
+        interval?: number;
+        input?: unknown;
+    }): Promise<void>;
+    removeSchedule(scheduleId: string): Promise<void>;
+    /**
+     * Deliver a signal payload to a waiting workflow execution and resume it.
+     */
+    signal<TPayload>(executionId: string, signal: IEventDefinition<TPayload>, payload: TPayload): Promise<void>;
+}
+export interface IDurableExecutionProcessor {
+    processExecution(executionId: string): Promise<void>;
+}

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

@@ -0,0 +1,66 @@
+import type { Execution, ExecutionStatus, StepResult, Timer, Schedule } from "../types";
+import type { DurableAuditEntry } from "../audit";
+export interface ListExecutionsOptions {
+    status?: ExecutionStatus[];
+    taskId?: string;
+    limit?: number;
+    offset?: number;
+}
+export interface IDurableStore {
+    saveExecution(execution: Execution): Promise<void>;
+    getExecution(id: string): Promise<Execution | null>;
+    updateExecution(id: string, updates: Partial<Execution>): Promise<void>;
+    listIncompleteExecutions(): Promise<Execution[]>;
+    /**
+     * Optional execution-level idempotency mapping.
+     * If supported, allows `startExecution(..., { idempotencyKey })` to dedupe workflow starts.
+     */
+    getExecutionIdByIdempotencyKey?(params: {
+        taskId: string;
+        idempotencyKey: string;
+    }): Promise<string | null>;
+    setExecutionIdByIdempotencyKey?(params: {
+        taskId: string;
+        idempotencyKey: string;
+        executionId: string;
+    }): Promise<boolean>;
+    listExecutions?(options?: ListExecutionsOptions): Promise<Execution[]>;
+    listStepResults?(executionId: string): Promise<StepResult[]>;
+    appendAuditEntry?(entry: DurableAuditEntry): Promise<void>;
+    listAuditEntries?(executionId: string, options?: {
+        limit?: number;
+        offset?: number;
+    }): Promise<DurableAuditEntry[]>;
+    retryRollback?(executionId: string): Promise<void>;
+    skipStep?(executionId: string, stepId: string): Promise<void>;
+    forceFail?(executionId: string, error: {
+        message: string;
+        stack?: string;
+    }): Promise<void>;
+    editStepResult?(executionId: string, stepId: string, newResult: unknown): Promise<void>;
+    getStepResult(executionId: string, stepId: string): Promise<StepResult | null>;
+    saveStepResult(result: StepResult): Promise<void>;
+    createTimer(timer: Timer): Promise<void>;
+    getReadyTimers(now?: Date): Promise<Timer[]>;
+    markTimerFired(timerId: string): Promise<void>;
+    /**
+     * Atomically claim a timer for processing. Returns true if claimed, false if already claimed.
+     * Used for distributed timer coordination to ensure only one worker processes each timer.
+     * @param timerId The ID of the timer to claim
+     * @param workerId A unique identifier for the worker claiming the timer
+     * @param ttlMs Time-to-live in milliseconds for the claim (in case worker dies)
+     */
+    claimTimer?(timerId: string, workerId: string, ttlMs: number): Promise<boolean>;
+    deleteTimer(timerId: string): Promise<void>;
+    createSchedule(schedule: Schedule): Promise<void>;
+    getSchedule(id: string): Promise<Schedule | null>;
+    updateSchedule(id: string, updates: Partial<Schedule>): Promise<void>;
+    deleteSchedule(id: string): Promise<void>;
+    listSchedules(): Promise<Schedule[]>;
+    listActiveSchedules(): Promise<Schedule[]>;
+    listStuckExecutions?(): Promise<Execution[]>;
+    init?(): Promise<void>;
+    dispose?(): Promise<void>;
+    acquireLock?(resource: string, ttlMs: number): Promise<string | null>;
+    releaseLock?(resource: string, lockId: string): Promise<void>;
+}

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

@@ -0,0 +1,29 @@
+import type { IDurableStore } from "../interfaces/store";
+import type { DurableAuditEntryInput, DurableAuditEmitter } from "../audit";
+export interface AuditConfig {
+    /**
+     * When enabled, attempts to persist audit entries to the store (if supported).
+     * This is separate from event emission via `emitter`.
+     */
+    enabled?: boolean;
+    /**
+     * Optional emitter for streaming audit entries (e.g. Runner events, logging, mirroring).
+     * Emissions must be best-effort and never affect workflow correctness.
+     */
+    emitter?: DurableAuditEmitter;
+}
+/**
+ * Durable audit trail sink.
+ *
+ * Used across the durable subsystem (service/managers/context) to record lifecycle
+ * events in a best-effort way. Persistence and emission are explicitly non-critical:
+ * failures must never affect workflow correctness (the store remains the source of truth).
+ */
+export declare class AuditLogger {
+    private readonly config;
+    private readonly store;
+    constructor(config: AuditConfig, store: IDurableStore);
+    log(params: DurableAuditEntryInput & {
+        at?: Date;
+    }): Promise<void>;
+}

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

@@ -0,0 +1,48 @@
+import type { IDurableStore } from "../interfaces/store";
+import type { IDurableQueue } from "../interfaces/queue";
+import type { IEventBus } from "../interfaces/bus";
+import type { DurableServiceConfig, DurableTask, ExecuteOptions, ITaskExecutor } from "../interfaces/service";
+import { type Execution } from "../types";
+import type { TaskRegistry } from "./TaskRegistry";
+import type { AuditLogger } from "./AuditLogger";
+import type { WaitManager } from "./WaitManager";
+export interface ExecutionManagerConfig {
+    store: IDurableStore;
+    queue?: IDurableQueue;
+    eventBus?: IEventBus;
+    taskExecutor?: ITaskExecutor;
+    contextProvider?: DurableServiceConfig["contextProvider"];
+    audit?: DurableServiceConfig["audit"];
+    determinism?: DurableServiceConfig["determinism"];
+    execution?: {
+        maxAttempts?: number;
+        timeout?: number;
+        kickoffFailsafeDelayMs?: number;
+    };
+}
+/**
+ * Runs durable executions (the "workflow engine" for attempts).
+ *
+ * Responsibilities:
+ * - persist new executions (including optional idempotency keys)
+ * - enqueue work (queue mode) or run directly (embedded mode)
+ * - execute a workflow attempt via `taskExecutor.run(...)`
+ * - inject a per-attempt `DurableContext` (via `contextProvider` / ALS wrapper)
+ * - interpret `SuspensionSignal` as "pause + reschedule" rather than failure
+ * - update execution status/result/error and notify waiters (`WaitManager`)
+ */
+export declare class ExecutionManager {
+    private readonly config;
+    private readonly taskRegistry;
+    private readonly auditLogger;
+    private readonly waitManager;
+    constructor(config: ExecutionManagerConfig, taskRegistry: TaskRegistry, auditLogger: AuditLogger, waitManager: WaitManager);
+    startExecution<TInput>(task: DurableTask<TInput, unknown>, input?: TInput, options?: ExecuteOptions): Promise<string>;
+    cancelExecution(executionId: string, reason?: string): Promise<void>;
+    execute<TInput, TResult>(task: DurableTask<TInput, TResult>, input?: TInput, options?: ExecuteOptions): Promise<TResult>;
+    executeStrict<TInput, TResult>(task: undefined extends TResult ? never : DurableTask<TInput, TResult>, input?: TInput, options?: ExecuteOptions): Promise<TResult>;
+    processExecution(executionId: string): Promise<void>;
+    kickoffExecution(executionId: string): Promise<void>;
+    notifyExecutionFinished(execution: Execution): Promise<void>;
+    private runExecutionAttempt;
+}

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

@@ -0,0 +1,48 @@
+import type { IDurableStore } from "../interfaces/store";
+import type { IDurableQueue } from "../interfaces/queue";
+import { type Timer } from "../types";
+import type { AuditLogger } from "./AuditLogger";
+import type { TaskRegistry } from "./TaskRegistry";
+import type { ScheduleManager } from "./ScheduleManager";
+export interface PollingConfig {
+    enabled?: boolean;
+    interval?: number;
+    claimTtlMs?: number;
+}
+export interface PollingManagerCallbacks {
+    processExecution: (executionId: string) => Promise<void>;
+    kickoffExecution: (executionId: string) => Promise<void>;
+}
+/**
+ * Timer/tick driver for durable workflows.
+ *
+ * The durable store is the source of truth, but time needs an active driver:
+ * `PollingManager` periodically scans ready timers and performs the appropriate action:
+ *
+ * - complete `sleep()` steps by marking their step result as completed
+ * - resume executions after signal timeouts / scheduled kickoffs / retries
+ * - coordinate multi-worker polling via optional `store.claimTimer(...)`
+ *
+ * In production topologies you typically enable polling on worker nodes only.
+ */
+export declare class PollingManager {
+    private readonly workerId;
+    private readonly config;
+    private readonly store;
+    private readonly queue;
+    private readonly maxAttempts;
+    private readonly defaultTimeout;
+    private readonly taskRegistry;
+    private readonly auditLogger;
+    private readonly scheduleManager;
+    private readonly callbacks;
+    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);
+    start(): void;
+    stop(): Promise<void>;
+    private poll;
+    /** @internal - public for testing */
+    handleTimer(timer: Timer): Promise<void>;
+}

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

@@ -0,0 +1,33 @@
+import type { IDurableStore } from "../interfaces/store";
+import type { DurableTask, ScheduleOptions } from "../interfaces/service";
+import { type Schedule } from "../types";
+import type { TaskRegistry } from "./TaskRegistry";
+/**
+ * Creates and maintains durable schedules.
+ *
+ * A schedule is persisted in the store and translated into durable timers that
+ * `PollingManager` will later process to kick off executions. This keeps scheduling
+ * crash-safe and horizontally scalable: schedules aren't owned by in-memory timers.
+ */
+export declare class ScheduleManager {
+    private readonly store;
+    private readonly taskRegistry;
+    constructor(store: IDurableStore, taskRegistry: TaskRegistry);
+    ensureSchedule<TInput>(task: DurableTask<TInput, unknown>, input: TInput | undefined, options: ScheduleOptions & {
+        id: string;
+    }): Promise<string>;
+    schedule<TInput>(task: DurableTask<TInput, unknown>, input: TInput | undefined, options: ScheduleOptions): Promise<string>;
+    reschedule(schedule: Schedule, options?: {
+        lastRunAt?: Date;
+    }): Promise<void>;
+    pause(id: string): Promise<void>;
+    resume(id: string): Promise<void>;
+    get(id: string): Promise<Schedule | null>;
+    list(): Promise<Schedule[]>;
+    update(id: string, updates: {
+        cron?: string;
+        interval?: number;
+        input?: unknown;
+    }): Promise<void>;
+    remove(id: string): Promise<void>;
+}

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

@@ -0,0 +1,25 @@
+import type { IDurableStore } from "../interfaces/store";
+import type { IDurableQueue } from "../interfaces/queue";
+import type { IEventDefinition } from "../../../../types/event";
+import type { AuditLogger } from "./AuditLogger";
+export interface SignalHandlerCallbacks {
+    processExecution: (executionId: string) => Promise<void>;
+}
+/**
+ * Delivers external signals to durable executions waiting in `DurableContext.waitForSignal()`.
+ *
+ * Signal delivery is store-centric:
+ * - find the earliest waiting signal step for the given `signalId`
+ * - persist a "completed" signal payload into the step result
+ * - optionally clean up timeout timers
+ * - trigger execution resumption (queue message or direct processing)
+ */
+export declare class SignalHandler {
+    private readonly store;
+    private readonly auditLogger;
+    private readonly queue;
+    private readonly maxAttempts;
+    private readonly callbacks;
+    constructor(store: IDurableStore, auditLogger: AuditLogger, queue: IDurableQueue | undefined, maxAttempts: number, callbacks: SignalHandlerCallbacks);
+    signal<TPayload>(executionId: string, signal: IEventDefinition<TPayload>, payload: TPayload): Promise<void>;
+}

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

@@ -0,0 +1,16 @@
+import type { DurableTask } from "../interfaces/service";
+/**
+ * In-memory durable task registry.
+ *
+ * Durable executions persist only a `taskId` in the store, so the runtime needs a way
+ * to resolve `taskId -> DurableTask` when resuming. This registry holds tasks that
+ * were registered on the current process and optionally delegates to an external
+ * resolver for tasks defined elsewhere (useful for modular apps).
+ */
+export declare class TaskRegistry {
+    private readonly externalResolver?;
+    private readonly tasks;
+    constructor(externalResolver?: ((taskId: string) => DurableTask<any, any> | undefined) | undefined);
+    register<TInput, TResult>(task: DurableTask<TInput, TResult>): void;
+    find(taskId: string): DurableTask<any, any> | undefined;
+}

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

@@ -0,0 +1,26 @@
+import type { IDurableStore } from "../interfaces/store";
+import type { IEventBus } from "../interfaces/bus";
+export interface WaitConfig {
+    defaultTimeout?: number;
+    defaultPollIntervalMs?: number;
+}
+/**
+ * Waits for an execution to reach a terminal state and returns/throws accordingly.
+ *
+ * Strategy:
+ * - if an event bus is configured, subscribe to `execution:<executionId>` for low-latency completion
+ * - otherwise (or on bus issues) fall back to polling the store
+ *
+ * The durable store remains the source of truth; this manager is purely a convenience layer
+ * for callers that want `await durable.wait(...)` / `await durable.execute(...)`.
+ */
+export declare class WaitManager {
+    private readonly store;
+    private readonly eventBus?;
+    private readonly config?;
+    constructor(store: IDurableStore, eventBus?: IEventBus | undefined, config?: WaitConfig | undefined);
+    waitForResult<TResult>(executionId: string, options?: {
+        timeout?: number;
+        waitPollIntervalMs?: number;
+    }): Promise<TResult>;
+}

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

@@ -0,0 +1,7 @@
+export { TaskRegistry } from "./TaskRegistry";
+export { AuditLogger, type AuditConfig } from "./AuditLogger";
+export { WaitManager, type WaitConfig } from "./WaitManager";
+export { ScheduleManager } from "./ScheduleManager";
+export { SignalHandler, type SignalHandlerCallbacks } from "./SignalHandler";
+export { ExecutionManager, type ExecutionManagerConfig, } from "./ExecutionManager";
+export { PollingManager, type PollingConfig, type PollingManagerCallbacks, } from "./PollingManager";

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

@@ -0,0 +1,14 @@
+import type { RunnerDurableRuntimeConfig } from "./createRunnerDurableRuntime";
+export type DurableResourceRuntimeConfig = RunnerDurableRuntimeConfig;
+/**
+ * A reusable durable resource template.
+ *
+ * Usage:
+ * - `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[]>;

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

@@ -0,0 +1,84 @@
+export declare const ExecutionStatus: {
+    readonly Pending: "pending";
+    readonly Running: "running";
+    readonly Retrying: "retrying";
+    readonly Sleeping: "sleeping";
+    readonly Completed: "completed";
+    readonly CompensationFailed: "compensation_failed";
+    readonly Failed: "failed";
+    readonly Cancelled: "cancelled";
+};
+export type ExecutionStatus = (typeof ExecutionStatus)[keyof typeof ExecutionStatus];
+export interface Execution<TInput = unknown, TResult = unknown> {
+    id: string;
+    taskId: string;
+    input: TInput | undefined;
+    status: ExecutionStatus;
+    result?: TResult;
+    error?: {
+        message: string;
+        stack?: string;
+    };
+    /** Optional cancellation metadata (cooperative cancellation). */
+    cancelledAt?: Date;
+    cancelRequestedAt?: Date;
+    attempt: number;
+    maxAttempts: number;
+    timeout?: number;
+    createdAt: Date;
+    updatedAt: Date;
+    completedAt?: Date;
+}
+export interface StepResult<T = unknown> {
+    executionId: string;
+    stepId: string;
+    result: T;
+    completedAt: Date;
+}
+export declare const TimerType: {
+    readonly Sleep: "sleep";
+    readonly Timeout: "timeout";
+    readonly Scheduled: "scheduled";
+    readonly Cron: "cron";
+    readonly Retry: "retry";
+    readonly SignalTimeout: "signal_timeout";
+};
+export type TimerType = (typeof TimerType)[keyof typeof TimerType];
+export declare const TimerStatus: {
+    readonly Pending: "pending";
+    readonly Fired: "fired";
+};
+export type TimerStatus = (typeof TimerStatus)[keyof typeof TimerStatus];
+export interface Timer {
+    id: string;
+    executionId?: string;
+    stepId?: string;
+    scheduleId?: string;
+    taskId?: string;
+    input?: unknown;
+    type: TimerType;
+    fireAt: Date;
+    status: TimerStatus;
+}
+export declare const ScheduleType: {
+    readonly Cron: "cron";
+    readonly Interval: "interval";
+};
+export type ScheduleType = (typeof ScheduleType)[keyof typeof ScheduleType];
+export declare const ScheduleStatus: {
+    readonly Active: "active";
+    readonly Paused: "paused";
+};
+export type ScheduleStatus = (typeof ScheduleStatus)[keyof typeof ScheduleStatus];
+export interface Schedule<TInput = unknown> {
+    id: string;
+    taskId: string;
+    type: ScheduleType;
+    pattern: string;
+    input: TInput | undefined;
+    status: ScheduleStatus;
+    lastRun?: Date;
+    nextRun?: Date;
+    createdAt: Date;
+    updatedAt: Date;
+}

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

@@ -0,0 +1,28 @@
+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>;
+export declare function createExecutionId(): string;
+export declare function parseSignalState(value: unknown): {
+    state: "waiting" | "completed" | "timed_out";
+    timerId?: string;
+} | null;
+/**
+ * Error thrown to consumers waiting on an execution (`DurableService.wait/execute*`).
+ *
+ * Distinguishes durable execution failures/timeouts/cancellations from ordinary
+ * 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 {
+    readonly executionId: string;
+    readonly taskId: string;
+    readonly attempt: number;
+    readonly causeInfo?: {
+        message: string;
+        stack?: string;
+    } | undefined;
+    constructor(message: string, executionId: string, taskId: string, attempt: number, causeInfo?: {
+        message: string;
+        stack?: string;
+    } | undefined);
+}

package/dist/types/node/durable/dashboard/server.d.ts

@@ -0,0 +1,20 @@
+import type { Request, Router } from "express";
+import { IDurableService } from "../core/interfaces/service";
+import { DurableOperator } from "../core/DurableOperator";
+export type DashboardMiddlewareOptions = {
+    /**
+     * Override where the dashboard UI is served from.
+     * Useful for tests or custom deployments.
+     */
+    uiDistPath?: string;
+    /**
+     * Authorization hook for operator actions (retry/skip/force/edit).
+     * Return true to allow, false to deny.
+     */
+    operatorAuth?: (req: Request) => boolean | Promise<boolean>;
+    /**
+     * Opt out of operator auth checks (not recommended).
+     */
+    dangerouslyAllowUnauthenticatedOperator?: boolean;
+};
+export declare function createDashboardMiddleware(_service: IDurableService, operator: DurableOperator, options?: DashboardMiddlewareOptions): Router;

package/dist/types/node/durable/emitters/runnerAuditEmitter.d.ts

@@ -0,0 +1,6 @@
+import type { EventManager } from "../../../models/EventManager";
+import type { DurableAuditEmitter } from "../core/audit";
+export declare function createDurableRunnerAuditEmitter(params: {
+    eventManager: EventManager;
+    source?: string;
+}): DurableAuditEmitter;