@coji/durably 0.12.0 → 0.14.0

package/README.md

@@ -1,6 +1,6 @@
 # @coji/durably
 
-Step-oriented resumable batch execution for Node.js and browsers using SQLite.
+Steps that survive crashes. SQLite to PostgreSQL.
 
 **[Documentation](https://coji.github.io/durably/)** | **[GitHub](https://github.com/coji/durably)** | **[Live Demo](https://durably-demo.vercel.app)**
 
@@ -9,10 +9,14 @@ Step-oriented resumable batch execution for Node.js and browsers using SQLite.
 ## Installation
 
 ```bash
-npm install @coji/durably kysely zod better-sqlite3
+# libSQL (recommended default)
+npm install @coji/durably kysely zod @libsql/client @libsql/kysely-libsql
+
+# PostgreSQL (multi-worker)
+npm install @coji/durably kysely zod pg
 ```
 
-See the [Quick Start](https://coji.github.io/durably/guide/quick-start) for other SQLite backends (libsql, SQLocal for browsers).
+See [Choosing a Database](https://coji.github.io/durably/guide/databases) for all backends.
 
 ## Quick Start
 

package/dist/{chunk-UCUP6NMJ.js → chunk-L42OCQEV.js}

@@ -3,8 +3,8 @@ function withLogPersistence() {
   return {
     name: "log-persistence",
     install(durably) {
-      durably.on("log:write", async (event) => {
-        await durably.storage.createLog({
+      durably.on("log:write", (event) => {
+        void durably.storage.createLog({
           runId: event.runId,
           stepName: event.stepName,
           level: event.level,
@@ -19,4 +19,4 @@ function withLogPersistence() {
 export {
   withLogPersistence
 };
-//# sourceMappingURL=chunk-UCUP6NMJ.js.map
+//# sourceMappingURL=chunk-L42OCQEV.js.map

package/dist/chunk-L42OCQEV.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/plugins/log-persistence.ts"],"sourcesContent":["import type { DurablyPlugin } from '../durably'\n\n/**\n * Plugin that persists log events to the database.\n * Uses fire-and-forget writes — log persistence is best-effort.\n */\nexport function withLogPersistence(): DurablyPlugin {\n  return {\n    name: 'log-persistence',\n    install(durably) {\n      durably.on('log:write', (event) => {\n        void durably.storage.createLog({\n          runId: event.runId,\n          stepName: event.stepName,\n          level: event.level,\n          message: event.message,\n          data: event.data,\n        })\n      })\n    },\n  }\n}\n"],"mappings":";AAMO,SAAS,qBAAoC;AAClD,SAAO;AAAA,IACL,MAAM;AAAA,IACN,QAAQ,SAAS;AACf,cAAQ,GAAG,aAAa,CAAC,UAAU;AACjC,aAAK,QAAQ,QAAQ,UAAU;AAAA,UAC7B,OAAO,MAAM;AAAA,UACb,UAAU,MAAM;AAAA,UAChB,OAAO,MAAM;AAAA,UACb,SAAS,MAAM;AAAA,UACf,MAAM,MAAM;AAAA,QACd,CAAC;AAAA,MACH,CAAC;AAAA,IACH;AAAA,EACF;AACF;","names":[]}

package/dist/{index-hM7-oiyj.d.ts → index-CDCdrLgw.d.ts}

@@ -20,13 +20,23 @@ interface RunTriggerEvent extends BaseEvent {
     labels: Record<string, string>;
 }
 /**
- * Run start event
+ * Run leased event
  */
-interface RunStartEvent extends BaseEvent {
-    type: 'run:start';
+interface RunLeasedEvent extends BaseEvent {
+    type: 'run:leased';
     runId: string;
     jobName: string;
     input: unknown;
+    leaseOwner: string;
+    leaseExpiresAt: string;
+    labels: Record<string, string>;
+}
+interface RunLeaseRenewedEvent extends BaseEvent {
+    type: 'run:lease-renewed';
+    runId: string;
+    jobName: string;
+    leaseOwner: string;
+    leaseExpiresAt: string;
     labels: Record<string, string>;
 }
 /**
@@ -72,7 +82,7 @@ interface RunDeleteEvent extends BaseEvent {
 /**
  * Progress data reported by step.progress()
  */
-interface ProgressData {
+interface ProgressData$1 {
     current: number;
     total?: number;
     message?: string;
@@ -84,7 +94,7 @@ interface RunProgressEvent extends BaseEvent {
     type: 'run:progress';
     runId: string;
     jobName: string;
-    progress: ProgressData;
+    progress: ProgressData$1;
     labels: Record<string, string>;
 }
 /**
@@ -163,7 +173,7 @@ interface WorkerErrorEvent extends BaseEvent {
 /**
  * All event types as discriminated union
  */
-type DurablyEvent = RunTriggerEvent | RunStartEvent | RunCompleteEvent | RunFailEvent | RunCancelEvent | RunDeleteEvent | RunProgressEvent | StepStartEvent | StepCompleteEvent | StepFailEvent | StepCancelEvent | LogWriteEvent | WorkerErrorEvent;
+type DurablyEvent = RunTriggerEvent | RunLeasedEvent | RunLeaseRenewedEvent | RunCompleteEvent | RunFailEvent | RunCancelEvent | RunDeleteEvent | RunProgressEvent | StepStartEvent | StepCompleteEvent | StepFailEvent | StepCancelEvent | LogWriteEvent | WorkerErrorEvent;
 /**
  * Event types for type-safe event names
  */
@@ -181,7 +191,7 @@ type EventInput<T extends EventType> = Omit<EventByType<T>, 'timestamp' | 'seque
 /**
  * All possible event inputs as a union (properly distributed)
  */
-type AnyEventInput = EventInput<'run:trigger'> | EventInput<'run:start'> | EventInput<'run:complete'> | EventInput<'run:fail'> | EventInput<'run:cancel'> | EventInput<'run:delete'> | EventInput<'run:progress'> | EventInput<'step:start'> | EventInput<'step:complete'> | EventInput<'step:fail'> | EventInput<'step:cancel'> | EventInput<'log:write'> | EventInput<'worker:error'>;
+type AnyEventInput = EventInput<'run:trigger'> | EventInput<'run:leased'> | EventInput<'run:lease-renewed'> | EventInput<'run:complete'> | EventInput<'run:fail'> | EventInput<'run:cancel'> | EventInput<'run:delete'> | EventInput<'run:progress'> | EventInput<'step:start'> | EventInput<'step:complete'> | EventInput<'step:fail'> | EventInput<'step:cancel'> | EventInput<'log:write'> | EventInput<'worker:error'>;
 /**
  * Event listener function
  */
@@ -202,15 +212,18 @@ interface RunsTable {
     id: string;
     job_name: string;
     input: string;
-    status: 'pending' | 'running' | 'completed' | 'failed' | 'cancelled';
+    status: 'pending' | 'leased' | 'completed' | 'failed' | 'cancelled';
     idempotency_key: string | null;
     concurrency_key: string | null;
     current_step_index: number;
+    completed_step_count: number;
     progress: string | null;
     output: string | null;
     error: string | null;
     labels: string;
-    heartbeat_at: string;
+    lease_owner: string | null;
+    lease_expires_at: string | null;
+    lease_generation: number;
     started_at: string | null;
     completed_at: string | null;
     created_at: string;
@@ -236,17 +249,24 @@ interface LogsTable {
     data: string | null;
     created_at: string;
 }
+interface RunLabelsTable {
+    run_id: string;
+    key: string;
+    value: string;
+}
 interface SchemaVersionsTable {
     version: number;
     applied_at: string;
 }
 interface Database {
     durably_runs: RunsTable;
+    durably_run_labels: RunLabelsTable;
     durably_steps: StepsTable;
     durably_logs: LogsTable;
     durably_schema_versions: SchemaVersionsTable;
 }
 
+type RunStatus = 'pending' | 'leased' | 'completed' | 'failed' | 'cancelled';
 /**
  * Run data for creating a new run
  */
@@ -264,11 +284,11 @@ interface Run<TLabels extends Record<string, string> = Record<string, string>> {
     id: string;
     jobName: string;
     input: unknown;
-    status: 'pending' | 'running' | 'completed' | 'failed' | 'cancelled';
+    status: RunStatus;
     idempotencyKey: string | null;
     concurrencyKey: string | null;
     currentStepIndex: number;
-    stepCount: number;
+    completedStepCount: number;
     progress: {
         current: number;
         total?: number;
@@ -277,34 +297,19 @@ interface Run<TLabels extends Record<string, string> = Record<string, string>> {
     output: unknown | null;
     error: string | null;
     labels: TLabels;
-    heartbeatAt: string;
+    leaseOwner: string | null;
+    leaseExpiresAt: string | null;
+    leaseGeneration: number;
     startedAt: string | null;
     completedAt: string | null;
     createdAt: string;
     updatedAt: string;
 }
-/**
- * Run update data
- */
-interface UpdateRunInput {
-    status?: 'pending' | 'running' | 'completed' | 'failed' | 'cancelled';
-    currentStepIndex?: number;
-    progress?: {
-        current: number;
-        total?: number;
-        message?: string;
-    } | null;
-    output?: unknown;
-    error?: string | null;
-    heartbeatAt?: string;
-    startedAt?: string;
-    completedAt?: string;
-}
 /**
  * Run filter options
  */
 interface RunFilter<TLabels extends Record<string, string> = Record<string, string>> {
-    status?: 'pending' | 'running' | 'completed' | 'failed' | 'cancelled';
+    status?: RunStatus;
     /** Filter by job name(s). Pass a string for one, or an array for multiple (OR). */
     jobName?: string | string[];
     /** Filter by labels (all specified labels must match) */
@@ -317,10 +322,9 @@ interface RunFilter<TLabels extends Record<string, string> = Record<string, stri
     offset?: number;
 }
 /**
- * Step data for creating a new step
+ * Step data for persisting a step checkpoint
  */
 interface CreateStepInput {
-    runId: string;
     name: string;
     index: number;
     status: 'completed' | 'failed' | 'cancelled';
@@ -364,33 +368,73 @@ interface Log {
     data: unknown | null;
     createdAt: string;
 }
+interface ProgressData {
+    current: number;
+    total?: number;
+    message?: string;
+}
+type DatabaseBackend = 'generic' | 'postgres';
 /**
- * A client-safe subset of Run, excluding internal fields like
- * heartbeatAt, idempotencyKey, concurrencyKey, and updatedAt.
- */
-type ClientRun<TLabels extends Record<string, string> = Record<string, string>> = Omit<Run<TLabels>, 'idempotencyKey' | 'concurrencyKey' | 'heartbeatAt' | 'updatedAt'>;
-/**
- * Project a full Run to a ClientRun by stripping internal fields.
+ * Data for updating a run
  */
-declare function toClientRun<TLabels extends Record<string, string> = Record<string, string>>(run: Run<TLabels>): ClientRun<TLabels>;
+interface UpdateRunData {
+    status?: RunStatus;
+    currentStepIndex?: number;
+    progress?: ProgressData | null;
+    output?: unknown;
+    error?: string | null;
+    leaseOwner?: string | null;
+    leaseExpiresAt?: string | null;
+    startedAt?: string;
+    completedAt?: string;
+}
 /**
- * Storage interface for database operations
+ * Unified storage interface used by the runtime.
  */
-interface Storage {
-    createRun(input: CreateRunInput): Promise<Run>;
-    batchCreateRuns(inputs: CreateRunInput[]): Promise<Run[]>;
-    updateRun(runId: string, data: UpdateRunInput): Promise<void>;
+interface Store<TLabels extends Record<string, string> = Record<string, string>> {
+    enqueue(input: CreateRunInput<TLabels>): Promise<Run<TLabels>>;
+    enqueueMany(inputs: CreateRunInput<TLabels>[]): Promise<Run<TLabels>[]>;
+    getRun<T extends Run<TLabels> = Run<TLabels>>(runId: string): Promise<T | null>;
+    getRuns<T extends Run<TLabels> = Run<TLabels>>(filter?: RunFilter<TLabels>): Promise<T[]>;
+    updateRun(runId: string, data: UpdateRunData): Promise<void>;
     deleteRun(runId: string): Promise<void>;
-    getRun<T extends Run = Run>(runId: string): Promise<T | null>;
-    getRuns<T extends Run = Run>(filter?: RunFilter): Promise<T[]>;
-    claimNextPendingRun(excludeConcurrencyKeys: string[]): Promise<Run | null>;
-    createStep(input: CreateStepInput): Promise<Step>;
-    deleteSteps(runId: string): Promise<void>;
+    claimNext(workerId: string, now: string, leaseMs: number): Promise<Run<TLabels> | null>;
+    renewLease(runId: string, leaseGeneration: number, now: string, leaseMs: number): Promise<boolean>;
+    releaseExpiredLeases(now: string): Promise<number>;
+    completeRun(runId: string, leaseGeneration: number, output: unknown, completedAt: string): Promise<boolean>;
+    failRun(runId: string, leaseGeneration: number, error: string, completedAt: string): Promise<boolean>;
+    cancelRun(runId: string, now: string): Promise<boolean>;
+    /**
+     * Atomically persist a step checkpoint, guarded by lease generation.
+     * Inserts the step record and advances currentStepIndex (for completed
+     * steps only) in a single transaction. Returns null if the generation
+     * does not match (lease was lost).
+     */
+    persistStep(runId: string, leaseGeneration: number, input: CreateStepInput): Promise<Step | null>;
     getSteps(runId: string): Promise<Step[]>;
     getCompletedStep(runId: string, name: string): Promise<Step | null>;
+    deleteSteps(runId: string): Promise<void>;
+    updateProgress(runId: string, leaseGeneration: number, progress: ProgressData | null): Promise<void>;
+    purgeRuns(options: {
+        olderThan: string;
+        limit?: number;
+    }): Promise<number>;
     createLog(input: CreateLogInput): Promise<Log>;
     getLogs(runId: string): Promise<Log[]>;
 }
+/**
+ * A client-safe subset of Run, excluding internal fields like
+ * leaseOwner, leaseExpiresAt, idempotencyKey, concurrencyKey, and updatedAt.
+ */
+type ClientRun<TLabels extends Record<string, string> = Record<string, string>> = Omit<Run<TLabels>, 'idempotencyKey' | 'concurrencyKey' | 'leaseOwner' | 'leaseExpiresAt' | 'leaseGeneration' | 'updatedAt'>;
+/**
+ * Project a full Run to a ClientRun by stripping internal fields.
+ */
+declare function toClientRun<TLabels extends Record<string, string> = Record<string, string>>(run: Run<TLabels>): ClientRun<TLabels>;
+/**
+ * Create a Kysely-based Store implementation
+ */
+declare function createKyselyStore(db: Kysely<Database>, backend?: DatabaseBackend): Store<Record<string, string>>;
 
 /**
  * Step context passed to the job function
@@ -400,6 +444,18 @@ interface StepContext {
      * The ID of the current run
      */
     readonly runId: string;
+    /**
+     * AbortSignal for cooperative cancellation or lease-loss handling.
+     */
+    readonly signal: AbortSignal;
+    /**
+     * Whether this execution should stop cooperatively.
+     */
+    isAborted(): boolean;
+    /**
+     * Throw if execution has been cancelled or lease ownership was lost.
+     */
+    throwIfAborted(): void;
     /**
      * Execute a step with automatic persistence and replay
      */
@@ -432,7 +488,7 @@ interface TriggerAndWaitOptions<TLabels extends Record<string, string> = Record<
     /** Timeout in milliseconds */
     timeout?: number;
     /** Called when step.progress() is invoked during execution */
-    onProgress?: (progress: ProgressData) => void | Promise<void>;
+    onProgress?: (progress: ProgressData$1) => void | Promise<void>;
     /** Called when step.log is invoked during execution */
     onLog?: (log: LogData) => void | Promise<void>;
 }
@@ -550,10 +606,15 @@ declare function defineJob<TName extends string, TInputSchema extends z.ZodType,
  */
 interface DurablyOptions<TLabels extends Record<string, string> = Record<string, string>, TJobs extends Record<string, JobDefinition<string, any, any>> = Record<string, never>> {
     dialect: Dialect;
-    pollingInterval?: number;
-    heartbeatInterval?: number;
-    staleThreshold?: number;
-    cleanupSteps?: boolean;
+    /**
+     * Browser-local singleton key used to detect multiple runtimes against the same local database in one tab.
+     * When omitted, Durably will use browser-local dialect metadata if available.
+     */
+    singletonKey?: string;
+    pollingIntervalMs?: number;
+    leaseRenewIntervalMs?: number;
+    leaseMs?: number;
+    preserveSteps?: boolean;
     /**
      * Zod schema for labels. When provided:
      * - Labels are type-checked at compile time
@@ -571,6 +632,12 @@ interface DurablyOptions<TLabels extends Record<string, string> = Record<string,
      * ```
      */
     jobs?: TJobs;
+    /**
+     * Auto-delete terminal runs older than the specified duration.
+     * Only runs in terminal states (completed, failed, cancelled) are purged.
+     * @example '30d' (30 days), '24h' (24 hours), '60m' (60 minutes)
+     */
+    retainRuns?: string;
 }
 /**
  * Plugin interface for extending Durably
@@ -617,7 +684,7 @@ interface Durably<TJobs extends Record<string, JobHandle<string, unknown, unknow
     /**
      * Storage layer for database operations
      */
-    readonly storage: Storage;
+    readonly storage: Store<TLabels>;
     /**
      * Register an event listener
      * @returns Unsubscribe function
@@ -645,10 +712,25 @@ interface Durably<TJobs extends Record<string, JobHandle<string, unknown, unknow
      * ```
      */
     register<TNewJobs extends Record<string, JobDefinition<string, any, any>>>(jobDefs: TNewJobs): Durably<TJobs & TransformToHandles<TNewJobs, TLabels>, TLabels>;
+    /**
+     * Process a single claimable run.
+     */
+    processOne(options?: {
+        workerId?: string;
+    }): Promise<boolean>;
+    /**
+     * Process runs until the queue appears idle.
+     */
+    processUntilIdle(options?: {
+        workerId?: string;
+        maxRuns?: number;
+    }): Promise<number>;
     /**
      * Start the worker polling loop
      */
-    start(): void;
+    start(options?: {
+        workerId?: string;
+    }): void;
     /**
      * Stop the worker after current run completes
      */
@@ -668,6 +750,15 @@ interface Durably<TJobs extends Record<string, JobHandle<string, unknown, unknow
      * @throws Error if run is pending or running, or does not exist
      */
     deleteRun(runId: string): Promise<void>;
+    /**
+     * Delete terminal runs older than the specified cutoff.
+     * Only runs in terminal states (completed, failed, cancelled) are purged.
+     * @returns Number of deleted runs
+     */
+    purgeRuns(options: {
+        olderThan: Date;
+        limit?: number;
+    }): Promise<number>;
     /**
      * Get a run by ID
      * @example
@@ -718,8 +809,9 @@ declare function createDurably<TLabels extends Record<string, string> = Record<s
 declare function createDurably<TLabels extends Record<string, string> = Record<string, string>>(options: DurablyOptions<TLabels>): Durably<Record<string, never>, TLabels>;
 
 /**
- * Plugin that persists log events to the database
+ * Plugin that persists log events to the database.
+ * Uses fire-and-forget writes — log persistence is best-effort.
  */
 declare function withLogPersistence(): DurablyPlugin;
 
-export { type StepsTable as A, type BatchTriggerInput as B, type ClientRun as C, type Durably as D, type ErrorHandler as E, type TriggerAndWaitResult as F, type TriggerOptions as G, createDurably as H, defineJob as I, type JobDefinition as J, toClientRun as K, type Log as L, withLogPersistence as M, type ProgressData as P, type Run as R, type SchemaVersionsTable as S, type TriggerAndWaitOptions as T, type WorkerErrorEvent as W, type RunFilter as a, type Database as b, type DurablyEvent as c, type DurablyOptions as d, type DurablyPlugin as e, type EventType as f, type JobHandle as g, type JobInput as h, type JobOutput as i, type LogData as j, type LogWriteEvent as k, type LogsTable as l, type RunCancelEvent as m, type RunCompleteEvent as n, type RunDeleteEvent as o, type RunFailEvent as p, type RunProgressEvent as q, type RunStartEvent as r, type RunTriggerEvent as s, type RunsTable as t, type Step as u, type StepCancelEvent as v, type StepCompleteEvent as w, type StepContext as x, type StepFailEvent as y, type StepStartEvent as z };
+export { type StepFailEvent as A, type BatchTriggerInput as B, type ClientRun as C, type Durably as D, type ErrorHandler as E, type StepStartEvent as F, type StepsTable as G, type Store as H, type TriggerAndWaitResult as I, type JobDefinition as J, type TriggerOptions as K, type Log as L, createDurably as M, createKyselyStore as N, defineJob as O, type ProgressData$1 as P, toClientRun as Q, type Run as R, type SchemaVersionsTable as S, type TriggerAndWaitOptions as T, type UpdateRunData as U, withLogPersistence as V, type WorkerErrorEvent as W, type RunFilter as a, type Database as b, type DurablyEvent as c, type DurablyOptions as d, type DurablyPlugin as e, type EventType as f, type JobHandle as g, type JobInput as h, type JobOutput as i, type LogData as j, type LogWriteEvent as k, type LogsTable as l, type RunCancelEvent as m, type RunCompleteEvent as n, type RunDeleteEvent as o, type RunFailEvent as p, type RunLeaseRenewedEvent as q, type RunLeasedEvent as r, type RunProgressEvent as s, type RunStatus as t, type RunTriggerEvent as u, type RunsTable as v, type Step as w, type StepCancelEvent as x, type StepCompleteEvent as y, type StepContext as z };

package/dist/index.d.ts

@@ -1,5 +1,5 @@
-import { R as Run, a as RunFilter, D as Durably } from './index-hM7-oiyj.js';
-export { B as BatchTriggerInput, C as ClientRun, b as Database, c as DurablyEvent, d as DurablyOptions, e as DurablyPlugin, E as ErrorHandler, f as EventType, J as JobDefinition, g as JobHandle, h as JobInput, i as JobOutput, L as Log, j as LogData, k as LogWriteEvent, l as LogsTable, P as ProgressData, m as RunCancelEvent, n as RunCompleteEvent, o as RunDeleteEvent, p as RunFailEvent, q as RunProgressEvent, r as RunStartEvent, s as RunTriggerEvent, t as RunsTable, S as SchemaVersionsTable, u as Step, v as StepCancelEvent, w as StepCompleteEvent, x as StepContext, y as StepFailEvent, z as StepStartEvent, A as StepsTable, T as TriggerAndWaitOptions, F as TriggerAndWaitResult, G as TriggerOptions, W as WorkerErrorEvent, H as createDurably, I as defineJob, K as toClientRun, M as withLogPersistence } from './index-hM7-oiyj.js';
+import { R as Run, a as RunFilter, D as Durably } from './index-CDCdrLgw.js';
+export { B as BatchTriggerInput, C as ClientRun, b as Database, c as DurablyEvent, d as DurablyOptions, e as DurablyPlugin, E as ErrorHandler, f as EventType, J as JobDefinition, g as JobHandle, h as JobInput, i as JobOutput, L as Log, j as LogData, k as LogWriteEvent, l as LogsTable, P as ProgressData, m as RunCancelEvent, n as RunCompleteEvent, o as RunDeleteEvent, p as RunFailEvent, q as RunLeaseRenewedEvent, r as RunLeasedEvent, s as RunProgressEvent, t as RunStatus, u as RunTriggerEvent, v as RunsTable, S as SchemaVersionsTable, w as Step, x as StepCancelEvent, y as StepCompleteEvent, z as StepContext, A as StepFailEvent, F as StepStartEvent, G as StepsTable, H as Store, T as TriggerAndWaitOptions, I as TriggerAndWaitResult, K as TriggerOptions, U as UpdateRunData, W as WorkerErrorEvent, M as createDurably, N as createKyselyStore, O as defineJob, Q as toClientRun, V as withLogPersistence } from './index-CDCdrLgw.js';
 import 'kysely';
 import 'zod';
 
@@ -11,6 +11,32 @@ import 'zod';
 declare class CancelledError extends Error {
     constructor(runId: string);
 }
+/**
+ * Error thrown when a worker loses lease ownership during execution.
+ */
+declare class LeaseLostError extends Error {
+    constructor(runId: string);
+}
+/**
+ * Base class for errors that map to specific HTTP status codes.
+ * Used by the HTTP handler to return appropriate responses.
+ */
+declare class DurablyError extends Error {
+    readonly statusCode: number;
+    constructor(message: string, statusCode: number);
+}
+/** 404 — Resource not found */
+declare class NotFoundError extends DurablyError {
+    constructor(message: string);
+}
+/** 400 — Invalid input or request */
+declare class ValidationError extends DurablyError {
+    constructor(message: string);
+}
+/** 409 — Operation conflicts with current state */
+declare class ConflictError extends DurablyError {
+    constructor(message: string);
+}
 
 /**
  * Run operation types for onRunAccess
@@ -101,4 +127,4 @@ interface CreateDurablyHandlerOptions<TContext = undefined, TLabels extends Reco
  */
 declare function createDurablyHandler<TContext = undefined, TLabels extends Record<string, string> = Record<string, string>>(durably: Durably<any, TLabels>, options?: CreateDurablyHandlerOptions<TContext, TLabels>): DurablyHandler;
 
-export { type AuthConfig, CancelledError, type CreateDurablyHandlerOptions, Durably, type DurablyHandler, Run, RunFilter, type RunOperation, type RunsSubscribeFilter, type TriggerRequest, type TriggerResponse, createDurablyHandler };
+export { type AuthConfig, CancelledError, ConflictError, type CreateDurablyHandlerOptions, Durably, DurablyError, type DurablyHandler, LeaseLostError, NotFoundError, Run, RunFilter, type RunOperation, type RunsSubscribeFilter, type TriggerRequest, type TriggerResponse, ValidationError, createDurablyHandler };