@coji/durably 0.0.1 → 0.1.0

package/dist/index.js

@@ -1,16 +1,891 @@
-// src/index.ts
-function createClient(_options) {
-  throw new Error(
-    "durably is not yet implemented. This is a placeholder package. See https://github.com/coji/durably for updates."
-  );
+// src/durably.ts
+import { Kysely } from "kysely";
+
+// src/events.ts
+function createEventEmitter() {
+  const listeners = /* @__PURE__ */ new Map();
+  let sequence = 0;
+  let errorHandler = null;
+  return {
+    on(type, listener) {
+      if (!listeners.has(type)) {
+        listeners.set(type, /* @__PURE__ */ new Set());
+      }
+      const typeListeners = listeners.get(type);
+      typeListeners?.add(listener);
+      return () => {
+        typeListeners?.delete(listener);
+      };
+    },
+    onError(handler) {
+      errorHandler = handler;
+    },
+    emit(event) {
+      sequence++;
+      const fullEvent = {
+        ...event,
+        timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+        sequence
+      };
+      const typeListeners = listeners.get(event.type);
+      if (!typeListeners) {
+        return;
+      }
+      for (const listener of typeListeners) {
+        try {
+          listener(fullEvent);
+        } catch (error) {
+          if (errorHandler) {
+            errorHandler(
+              error instanceof Error ? error : new Error(String(error)),
+              fullEvent
+            );
+          }
+        }
+      }
+    }
+  };
 }
-function defineJob(_name, _handler) {
-  throw new Error(
-    "durably is not yet implemented. This is a placeholder package. See https://github.com/coji/durably for updates."
-  );
+
+// src/job.ts
+function createJobRegistry() {
+  const jobs = /* @__PURE__ */ new Map();
+  return {
+    register(job) {
+      if (jobs.has(job.name)) {
+        throw new Error(`Job "${job.name}" is already registered`);
+      }
+      jobs.set(job.name, job);
+    },
+    get(name) {
+      return jobs.get(name);
+    },
+    has(name) {
+      return jobs.has(name);
+    }
+  };
+}
+function createJobHandle(definition, fn, storage, _eventEmitter, registry) {
+  registry.register({
+    name: definition.name,
+    inputSchema: definition.input,
+    outputSchema: definition.output,
+    fn
+  });
+  return {
+    name: definition.name,
+    async trigger(input, options) {
+      const parseResult = definition.input.safeParse(input);
+      if (!parseResult.success) {
+        throw new Error(`Invalid input: ${parseResult.error.message}`);
+      }
+      const run = await storage.createRun({
+        jobName: definition.name,
+        payload: parseResult.data,
+        idempotencyKey: options?.idempotencyKey,
+        concurrencyKey: options?.concurrencyKey
+      });
+      return run;
+    },
+    async triggerAndWait(input, options) {
+      const run = await this.trigger(input, options);
+      return new Promise((resolve, reject) => {
+        let timeoutId;
+        let resolved = false;
+        const cleanup = () => {
+          if (resolved) return;
+          resolved = true;
+          unsubscribeComplete();
+          unsubscribeFail();
+          if (timeoutId) {
+            clearTimeout(timeoutId);
+          }
+        };
+        const unsubscribeComplete = _eventEmitter.on(
+          "run:complete",
+          (event) => {
+            if (event.runId === run.id && !resolved) {
+              cleanup();
+              resolve({
+                id: run.id,
+                output: event.output
+              });
+            }
+          }
+        );
+        const unsubscribeFail = _eventEmitter.on("run:fail", (event) => {
+          if (event.runId === run.id && !resolved) {
+            cleanup();
+            reject(new Error(event.error));
+          }
+        });
+        storage.getRun(run.id).then((currentRun) => {
+          if (resolved || !currentRun) return;
+          if (currentRun.status === "completed") {
+            cleanup();
+            resolve({
+              id: run.id,
+              output: currentRun.output
+            });
+          } else if (currentRun.status === "failed") {
+            cleanup();
+            reject(new Error(currentRun.error || "Run failed"));
+          }
+        });
+        if (options?.timeout !== void 0) {
+          timeoutId = setTimeout(() => {
+            if (!resolved) {
+              cleanup();
+              reject(
+                new Error(`triggerAndWait timeout after ${options.timeout}ms`)
+              );
+            }
+          }, options.timeout);
+        }
+      });
+    },
+    async batchTrigger(inputs) {
+      if (inputs.length === 0) {
+        return [];
+      }
+      const normalized = inputs.map((item) => {
+        if (item && typeof item === "object" && "input" in item) {
+          return item;
+        }
+        return { input: item, options: void 0 };
+      });
+      const validated = [];
+      for (let i = 0; i < normalized.length; i++) {
+        const parseResult = definition.input.safeParse(normalized[i].input);
+        if (!parseResult.success) {
+          throw new Error(
+            `Invalid input at index ${i}: ${parseResult.error.message}`
+          );
+        }
+        validated.push({
+          payload: parseResult.data,
+          options: normalized[i].options
+        });
+      }
+      const runs = await storage.batchCreateRuns(
+        validated.map((v) => ({
+          jobName: definition.name,
+          payload: v.payload,
+          idempotencyKey: v.options?.idempotencyKey,
+          concurrencyKey: v.options?.concurrencyKey
+        }))
+      );
+      return runs;
+    },
+    async getRun(id) {
+      const run = await storage.getRun(id);
+      if (!run || run.jobName !== definition.name) {
+        return null;
+      }
+      return run;
+    },
+    async getRuns(filter) {
+      const runs = await storage.getRuns({
+        ...filter,
+        jobName: definition.name
+      });
+      return runs;
+    }
+  };
+}
+
+// src/migrations.ts
+var migrations = [
+  {
+    version: 1,
+    up: async (db) => {
+      await db.schema.createTable("durably_runs").ifNotExists().addColumn("id", "text", (col) => col.primaryKey()).addColumn("job_name", "text", (col) => col.notNull()).addColumn("payload", "text", (col) => col.notNull()).addColumn("status", "text", (col) => col.notNull()).addColumn("idempotency_key", "text").addColumn("concurrency_key", "text").addColumn(
+        "current_step_index",
+        "integer",
+        (col) => col.notNull().defaultTo(0)
+      ).addColumn("progress", "text").addColumn("output", "text").addColumn("error", "text").addColumn("heartbeat_at", "text", (col) => col.notNull()).addColumn("created_at", "text", (col) => col.notNull()).addColumn("updated_at", "text", (col) => col.notNull()).execute();
+      await db.schema.createIndex("idx_durably_runs_job_idempotency").ifNotExists().on("durably_runs").columns(["job_name", "idempotency_key"]).unique().execute();
+      await db.schema.createIndex("idx_durably_runs_status_concurrency").ifNotExists().on("durably_runs").columns(["status", "concurrency_key"]).execute();
+      await db.schema.createIndex("idx_durably_runs_status_created").ifNotExists().on("durably_runs").columns(["status", "created_at"]).execute();
+      await db.schema.createTable("durably_steps").ifNotExists().addColumn("id", "text", (col) => col.primaryKey()).addColumn("run_id", "text", (col) => col.notNull()).addColumn("name", "text", (col) => col.notNull()).addColumn("index", "integer", (col) => col.notNull()).addColumn("status", "text", (col) => col.notNull()).addColumn("output", "text").addColumn("error", "text").addColumn("started_at", "text", (col) => col.notNull()).addColumn("completed_at", "text").execute();
+      await db.schema.createIndex("idx_durably_steps_run_index").ifNotExists().on("durably_steps").columns(["run_id", "index"]).execute();
+      await db.schema.createTable("durably_logs").ifNotExists().addColumn("id", "text", (col) => col.primaryKey()).addColumn("run_id", "text", (col) => col.notNull()).addColumn("step_name", "text").addColumn("level", "text", (col) => col.notNull()).addColumn("message", "text", (col) => col.notNull()).addColumn("data", "text").addColumn("created_at", "text", (col) => col.notNull()).execute();
+      await db.schema.createIndex("idx_durably_logs_run_created").ifNotExists().on("durably_logs").columns(["run_id", "created_at"]).execute();
+      await db.schema.createTable("durably_schema_versions").ifNotExists().addColumn("version", "integer", (col) => col.primaryKey()).addColumn("applied_at", "text", (col) => col.notNull()).execute();
+    }
+  }
+];
+async function getCurrentVersion(db) {
+  try {
+    const result = await db.selectFrom("durably_schema_versions").select("version").orderBy("version", "desc").limit(1).executeTakeFirst();
+    return result?.version ?? 0;
+  } catch {
+    return 0;
+  }
+}
+async function runMigrations(db) {
+  const currentVersion = await getCurrentVersion(db);
+  for (const migration of migrations) {
+    if (migration.version > currentVersion) {
+      await migration.up(db);
+      await db.insertInto("durably_schema_versions").values({
+        version: migration.version,
+        applied_at: (/* @__PURE__ */ new Date()).toISOString()
+      }).execute();
+    }
+  }
+}
+
+// src/storage.ts
+import { ulid } from "ulidx";
+function rowToRun(row) {
+  return {
+    id: row.id,
+    jobName: row.job_name,
+    payload: JSON.parse(row.payload),
+    status: row.status,
+    idempotencyKey: row.idempotency_key,
+    concurrencyKey: row.concurrency_key,
+    currentStepIndex: row.current_step_index,
+    progress: row.progress ? JSON.parse(row.progress) : null,
+    output: row.output ? JSON.parse(row.output) : null,
+    error: row.error,
+    heartbeatAt: row.heartbeat_at,
+    createdAt: row.created_at,
+    updatedAt: row.updated_at
+  };
+}
+function rowToStep(row) {
+  return {
+    id: row.id,
+    runId: row.run_id,
+    name: row.name,
+    index: row.index,
+    status: row.status,
+    output: row.output ? JSON.parse(row.output) : null,
+    error: row.error,
+    startedAt: row.started_at,
+    completedAt: row.completed_at
+  };
+}
+function rowToLog(row) {
+  return {
+    id: row.id,
+    runId: row.run_id,
+    stepName: row.step_name,
+    level: row.level,
+    message: row.message,
+    data: row.data ? JSON.parse(row.data) : null,
+    createdAt: row.created_at
+  };
+}
+function createKyselyStorage(db) {
+  return {
+    async createRun(input) {
+      const now = (/* @__PURE__ */ new Date()).toISOString();
+      if (input.idempotencyKey) {
+        const existing = await db.selectFrom("durably_runs").selectAll().where("job_name", "=", input.jobName).where("idempotency_key", "=", input.idempotencyKey).executeTakeFirst();
+        if (existing) {
+          return rowToRun(existing);
+        }
+      }
+      const id = ulid();
+      const run = {
+        id,
+        job_name: input.jobName,
+        payload: JSON.stringify(input.payload),
+        status: "pending",
+        idempotency_key: input.idempotencyKey ?? null,
+        concurrency_key: input.concurrencyKey ?? null,
+        current_step_index: 0,
+        progress: null,
+        output: null,
+        error: null,
+        heartbeat_at: now,
+        created_at: now,
+        updated_at: now
+      };
+      await db.insertInto("durably_runs").values(run).execute();
+      return rowToRun(run);
+    },
+    async batchCreateRuns(inputs) {
+      if (inputs.length === 0) {
+        return [];
+      }
+      return await db.transaction().execute(async (trx) => {
+        const now = (/* @__PURE__ */ new Date()).toISOString();
+        const runs = [];
+        for (const input of inputs) {
+          if (input.idempotencyKey) {
+            const existing = await trx.selectFrom("durably_runs").selectAll().where("job_name", "=", input.jobName).where("idempotency_key", "=", input.idempotencyKey).executeTakeFirst();
+            if (existing) {
+              runs.push(existing);
+              continue;
+            }
+          }
+          const id = ulid();
+          runs.push({
+            id,
+            job_name: input.jobName,
+            payload: JSON.stringify(input.payload),
+            status: "pending",
+            idempotency_key: input.idempotencyKey ?? null,
+            concurrency_key: input.concurrencyKey ?? null,
+            current_step_index: 0,
+            progress: null,
+            output: null,
+            error: null,
+            heartbeat_at: now,
+            created_at: now,
+            updated_at: now
+          });
+        }
+        const newRuns = runs.filter((r) => r.created_at === now);
+        if (newRuns.length > 0) {
+          await trx.insertInto("durably_runs").values(newRuns).execute();
+        }
+        return runs.map(rowToRun);
+      });
+    },
+    async updateRun(runId, data) {
+      const now = (/* @__PURE__ */ new Date()).toISOString();
+      const updates = {
+        updated_at: now
+      };
+      if (data.status !== void 0) updates.status = data.status;
+      if (data.currentStepIndex !== void 0)
+        updates.current_step_index = data.currentStepIndex;
+      if (data.progress !== void 0)
+        updates.progress = data.progress ? JSON.stringify(data.progress) : null;
+      if (data.output !== void 0)
+        updates.output = JSON.stringify(data.output);
+      if (data.error !== void 0) updates.error = data.error;
+      if (data.heartbeatAt !== void 0)
+        updates.heartbeat_at = data.heartbeatAt;
+      await db.updateTable("durably_runs").set(updates).where("id", "=", runId).execute();
+    },
+    async deleteRun(runId) {
+      await db.deleteFrom("durably_logs").where("run_id", "=", runId).execute();
+      await db.deleteFrom("durably_steps").where("run_id", "=", runId).execute();
+      await db.deleteFrom("durably_runs").where("id", "=", runId).execute();
+    },
+    async getRun(runId) {
+      const row = await db.selectFrom("durably_runs").selectAll().where("id", "=", runId).executeTakeFirst();
+      return row ? rowToRun(row) : null;
+    },
+    async getRuns(filter) {
+      let query = db.selectFrom("durably_runs").selectAll();
+      if (filter?.status) {
+        query = query.where("status", "=", filter.status);
+      }
+      if (filter?.jobName) {
+        query = query.where("job_name", "=", filter.jobName);
+      }
+      query = query.orderBy("created_at", "desc");
+      if (filter?.limit !== void 0) {
+        query = query.limit(filter.limit);
+      }
+      if (filter?.offset !== void 0) {
+        if (filter.limit === void 0) {
+          query = query.limit(-1);
+        }
+        query = query.offset(filter.offset);
+      }
+      const rows = await query.execute();
+      return rows.map(rowToRun);
+    },
+    async getNextPendingRun(excludeConcurrencyKeys) {
+      let query = db.selectFrom("durably_runs").selectAll().where("status", "=", "pending").orderBy("created_at", "asc").limit(1);
+      if (excludeConcurrencyKeys.length > 0) {
+        query = query.where(
+          (eb) => eb.or([
+            eb("concurrency_key", "is", null),
+            eb("concurrency_key", "not in", excludeConcurrencyKeys)
+          ])
+        );
+      }
+      const row = await query.executeTakeFirst();
+      return row ? rowToRun(row) : null;
+    },
+    async createStep(input) {
+      const completedAt = (/* @__PURE__ */ new Date()).toISOString();
+      const id = ulid();
+      const step = {
+        id,
+        run_id: input.runId,
+        name: input.name,
+        index: input.index,
+        status: input.status,
+        output: input.output !== void 0 ? JSON.stringify(input.output) : null,
+        error: input.error ?? null,
+        started_at: input.startedAt,
+        completed_at: completedAt
+      };
+      await db.insertInto("durably_steps").values(step).execute();
+      return rowToStep(step);
+    },
+    async getSteps(runId) {
+      const rows = await db.selectFrom("durably_steps").selectAll().where("run_id", "=", runId).orderBy("index", "asc").execute();
+      return rows.map(rowToStep);
+    },
+    async getCompletedStep(runId, name) {
+      const row = await db.selectFrom("durably_steps").selectAll().where("run_id", "=", runId).where("name", "=", name).where("status", "=", "completed").executeTakeFirst();
+      return row ? rowToStep(row) : null;
+    },
+    async createLog(input) {
+      const now = (/* @__PURE__ */ new Date()).toISOString();
+      const id = ulid();
+      const log = {
+        id,
+        run_id: input.runId,
+        step_name: input.stepName,
+        level: input.level,
+        message: input.message,
+        data: input.data !== void 0 ? JSON.stringify(input.data) : null,
+        created_at: now
+      };
+      await db.insertInto("durably_logs").values(log).execute();
+      return rowToLog(log);
+    },
+    async getLogs(runId) {
+      const rows = await db.selectFrom("durably_logs").selectAll().where("run_id", "=", runId).orderBy("created_at", "asc").execute();
+      return rows.map(rowToLog);
+    }
+  };
+}
+
+// src/errors.ts
+var CancelledError = class extends Error {
+  constructor(runId) {
+    super(`Run was cancelled: ${runId}`);
+    this.name = "CancelledError";
+  }
+};
+
+// src/context.ts
+function createJobContext(run, jobName, storage, eventEmitter) {
+  let stepIndex = run.currentStepIndex;
+  let currentStepName = null;
+  return {
+    get runId() {
+      return run.id;
+    },
+    async run(name, fn) {
+      const currentRun = await storage.getRun(run.id);
+      if (currentRun?.status === "cancelled") {
+        throw new CancelledError(run.id);
+      }
+      const existingStep = await storage.getCompletedStep(run.id, name);
+      if (existingStep) {
+        stepIndex++;
+        return existingStep.output;
+      }
+      currentStepName = name;
+      const startedAt = (/* @__PURE__ */ new Date()).toISOString();
+      const startTime = Date.now();
+      eventEmitter.emit({
+        type: "step:start",
+        runId: run.id,
+        jobName,
+        stepName: name,
+        stepIndex
+      });
+      try {
+        const result = await fn();
+        await storage.createStep({
+          runId: run.id,
+          name,
+          index: stepIndex,
+          status: "completed",
+          output: result,
+          startedAt
+        });
+        stepIndex++;
+        await storage.updateRun(run.id, { currentStepIndex: stepIndex });
+        eventEmitter.emit({
+          type: "step:complete",
+          runId: run.id,
+          jobName,
+          stepName: name,
+          stepIndex: stepIndex - 1,
+          output: result,
+          duration: Date.now() - startTime
+        });
+        return result;
+      } catch (error) {
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        await storage.createStep({
+          runId: run.id,
+          name,
+          index: stepIndex,
+          status: "failed",
+          error: errorMessage,
+          startedAt
+        });
+        eventEmitter.emit({
+          type: "step:fail",
+          runId: run.id,
+          jobName,
+          stepName: name,
+          stepIndex,
+          error: errorMessage
+        });
+        throw error;
+      } finally {
+        currentStepName = null;
+      }
+    },
+    progress(current, total, message) {
+      storage.updateRun(run.id, {
+        progress: { current, total, message }
+      });
+    },
+    log: {
+      info(message, data) {
+        eventEmitter.emit({
+          type: "log:write",
+          runId: run.id,
+          stepName: currentStepName,
+          level: "info",
+          message,
+          data
+        });
+      },
+      warn(message, data) {
+        eventEmitter.emit({
+          type: "log:write",
+          runId: run.id,
+          stepName: currentStepName,
+          level: "warn",
+          message,
+          data
+        });
+      },
+      error(message, data) {
+        eventEmitter.emit({
+          type: "log:write",
+          runId: run.id,
+          stepName: currentStepName,
+          level: "error",
+          message,
+          data
+        });
+      }
+    }
+  };
+}
+
+// src/worker.ts
+function createWorker(config, storage, eventEmitter, jobRegistry) {
+  let running = false;
+  let currentRunPromise = null;
+  let pollingTimeout = null;
+  let stopResolver = null;
+  let heartbeatInterval = null;
+  let currentRunId = null;
+  async function recoverStaleRuns() {
+    const staleThreshold = new Date(
+      Date.now() - config.staleThreshold
+    ).toISOString();
+    const runningRuns = await storage.getRuns({ status: "running" });
+    for (const run of runningRuns) {
+      if (run.heartbeatAt < staleThreshold) {
+        await storage.updateRun(run.id, {
+          status: "pending"
+        });
+      }
+    }
+  }
+  async function updateHeartbeat() {
+    if (currentRunId) {
+      await storage.updateRun(currentRunId, {
+        heartbeatAt: (/* @__PURE__ */ new Date()).toISOString()
+      });
+    }
+  }
+  function getErrorMessage(error) {
+    return error instanceof Error ? error.message : String(error);
+  }
+  async function handleRunSuccess(runId, jobName, output, startTime) {
+    const currentRun = await storage.getRun(runId);
+    if (currentRun?.status === "cancelled") {
+      return;
+    }
+    await storage.updateRun(runId, {
+      status: "completed",
+      output
+    });
+    eventEmitter.emit({
+      type: "run:complete",
+      runId,
+      jobName,
+      output,
+      duration: Date.now() - startTime
+    });
+  }
+  async function handleRunFailure(runId, jobName, error) {
+    if (error instanceof CancelledError) {
+      return;
+    }
+    const currentRun = await storage.getRun(runId);
+    if (currentRun?.status === "cancelled") {
+      return;
+    }
+    const errorMessage = getErrorMessage(error);
+    const steps = await storage.getSteps(runId);
+    const failedStep = steps.find((s) => s.status === "failed");
+    await storage.updateRun(runId, {
+      status: "failed",
+      error: errorMessage
+    });
+    eventEmitter.emit({
+      type: "run:fail",
+      runId,
+      jobName,
+      error: errorMessage,
+      failedStepName: failedStep?.name ?? "unknown"
+    });
+  }
+  async function executeRun(run, job) {
+    currentRunId = run.id;
+    heartbeatInterval = setInterval(() => {
+      updateHeartbeat().catch((error) => {
+        eventEmitter.emit({
+          type: "worker:error",
+          error: error instanceof Error ? error.message : String(error),
+          context: "heartbeat",
+          runId: run.id
+        });
+      });
+    }, config.heartbeatInterval);
+    eventEmitter.emit({
+      type: "run:start",
+      runId: run.id,
+      jobName: run.jobName,
+      payload: run.payload
+    });
+    const startTime = Date.now();
+    try {
+      const context = createJobContext(run, run.jobName, storage, eventEmitter);
+      const output = await job.fn(context, run.payload);
+      if (job.outputSchema) {
+        const parseResult = job.outputSchema.safeParse(output);
+        if (!parseResult.success) {
+          throw new Error(`Invalid output: ${parseResult.error.message}`);
+        }
+      }
+      await handleRunSuccess(run.id, run.jobName, output, startTime);
+    } catch (error) {
+      await handleRunFailure(run.id, run.jobName, error);
+    } finally {
+      if (heartbeatInterval) {
+        clearInterval(heartbeatInterval);
+        heartbeatInterval = null;
+      }
+      currentRunId = null;
+    }
+  }
+  async function processNextRun() {
+    const runningRuns = await storage.getRuns({ status: "running" });
+    const excludeConcurrencyKeys = runningRuns.filter(
+      (r) => r.concurrencyKey !== null
+    ).map((r) => r.concurrencyKey);
+    const run = await storage.getNextPendingRun(excludeConcurrencyKeys);
+    if (!run) {
+      return false;
+    }
+    const job = jobRegistry.get(run.jobName);
+    if (!job) {
+      await storage.updateRun(run.id, {
+        status: "failed",
+        error: `Unknown job: ${run.jobName}`
+      });
+      return true;
+    }
+    await storage.updateRun(run.id, {
+      status: "running",
+      heartbeatAt: (/* @__PURE__ */ new Date()).toISOString()
+    });
+    await executeRun(run, job);
+    return true;
+  }
+  async function poll() {
+    if (!running) {
+      return;
+    }
+    const doWork = async () => {
+      await recoverStaleRuns();
+      await processNextRun();
+    };
+    try {
+      currentRunPromise = doWork();
+      await currentRunPromise;
+    } finally {
+      currentRunPromise = null;
+    }
+    if (running) {
+      pollingTimeout = setTimeout(() => poll(), config.pollingInterval);
+    } else if (stopResolver) {
+      stopResolver();
+      stopResolver = null;
+    }
+  }
+  return {
+    get isRunning() {
+      return running;
+    },
+    start() {
+      if (running) {
+        return;
+      }
+      running = true;
+      poll();
+    },
+    async stop() {
+      if (!running) {
+        return;
+      }
+      running = false;
+      if (pollingTimeout) {
+        clearTimeout(pollingTimeout);
+        pollingTimeout = null;
+      }
+      if (heartbeatInterval) {
+        clearInterval(heartbeatInterval);
+        heartbeatInterval = null;
+      }
+      if (currentRunPromise) {
+        return new Promise((resolve) => {
+          stopResolver = resolve;
+        });
+      }
+    }
+  };
+}
+
+// src/durably.ts
+var DEFAULTS = {
+  pollingInterval: 1e3,
+  heartbeatInterval: 5e3,
+  staleThreshold: 3e4
+};
+function createDurably(options) {
+  const config = {
+    pollingInterval: options.pollingInterval ?? DEFAULTS.pollingInterval,
+    heartbeatInterval: options.heartbeatInterval ?? DEFAULTS.heartbeatInterval,
+    staleThreshold: options.staleThreshold ?? DEFAULTS.staleThreshold
+  };
+  const db = new Kysely({ dialect: options.dialect });
+  const storage = createKyselyStorage(db);
+  const eventEmitter = createEventEmitter();
+  const jobRegistry = createJobRegistry();
+  const worker = createWorker(config, storage, eventEmitter, jobRegistry);
+  let migrating = null;
+  let migrated = false;
+  const durably = {
+    db,
+    storage,
+    on: eventEmitter.on,
+    emit: eventEmitter.emit,
+    onError: eventEmitter.onError,
+    start: worker.start,
+    stop: worker.stop,
+    defineJob(definition, fn) {
+      return createJobHandle(definition, fn, storage, eventEmitter, jobRegistry);
+    },
+    getRun: storage.getRun,
+    getRuns: storage.getRuns,
+    use(plugin) {
+      plugin.install(durably);
+    },
+    async retry(runId) {
+      const run = await storage.getRun(runId);
+      if (!run) {
+        throw new Error(`Run not found: ${runId}`);
+      }
+      if (run.status === "completed") {
+        throw new Error(`Cannot retry completed run: ${runId}`);
+      }
+      if (run.status === "pending") {
+        throw new Error(`Cannot retry pending run: ${runId}`);
+      }
+      if (run.status === "running") {
+        throw new Error(`Cannot retry running run: ${runId}`);
+      }
+      await storage.updateRun(runId, {
+        status: "pending",
+        error: null
+      });
+    },
+    async cancel(runId) {
+      const run = await storage.getRun(runId);
+      if (!run) {
+        throw new Error(`Run not found: ${runId}`);
+      }
+      if (run.status === "completed") {
+        throw new Error(`Cannot cancel completed run: ${runId}`);
+      }
+      if (run.status === "failed") {
+        throw new Error(`Cannot cancel failed run: ${runId}`);
+      }
+      if (run.status === "cancelled") {
+        throw new Error(`Cannot cancel already cancelled run: ${runId}`);
+      }
+      await storage.updateRun(runId, {
+        status: "cancelled"
+      });
+    },
+    async deleteRun(runId) {
+      const run = await storage.getRun(runId);
+      if (!run) {
+        throw new Error(`Run not found: ${runId}`);
+      }
+      if (run.status === "pending") {
+        throw new Error(`Cannot delete pending run: ${runId}`);
+      }
+      if (run.status === "running") {
+        throw new Error(`Cannot delete running run: ${runId}`);
+      }
+      await storage.deleteRun(runId);
+    },
+    async migrate() {
+      if (migrated) {
+        return;
+      }
+      if (migrating) {
+        return migrating;
+      }
+      migrating = runMigrations(db).then(() => {
+        migrated = true;
+      }).finally(() => {
+        migrating = null;
+      });
+      return migrating;
+    }
+  };
+  return durably;
+}
+
+// src/plugins/log-persistence.ts
+function withLogPersistence() {
+  return {
+    name: "log-persistence",
+    install(durably) {
+      durably.on("log:write", async (event) => {
+        await durably.storage.createLog({
+          runId: event.runId,
+          stepName: event.stepName,
+          level: event.level,
+          message: event.message,
+          data: event.data
+        });
+      });
+    }
+  };
 }
 export {
-  createClient,
-  defineJob
+  CancelledError,
+  createDurably,
+  withLogPersistence
 };
 //# sourceMappingURL=index.js.map