@zucker-framework/task 1.0.0

package/dist/index.js

@@ -0,0 +1,1933 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  DurableTaskLeaseLostError: () => DurableTaskLeaseLostError,
+  DurableTaskNotClaimableError: () => DurableTaskNotClaimableError,
+  DurableTaskNotFoundError: () => DurableTaskNotFoundError,
+  DurableTaskRetryScheduledError: () => DurableTaskRetryScheduledError,
+  DurableWorkerRuntime: () => DurableWorkerRuntime,
+  ExponentialTaskRetryPolicy: () => ExponentialTaskRetryPolicy,
+  InMemoryTaskOutboxRepository: () => InMemoryTaskOutboxRepository,
+  InMemoryTaskRepository: () => InMemoryTaskRepository,
+  InvalidTaskTransitionError: () => InvalidTaskTransitionError,
+  PostgresTaskOutboxRepository: () => PostgresTaskOutboxRepository,
+  PostgresTaskRedriver: () => PostgresTaskRedriver,
+  PostgresTaskRepository: () => PostgresTaskRepository,
+  PostgresTaskSubmitter: () => PostgresTaskSubmitter,
+  PostgresTaskSummaryReader: () => PostgresTaskSummaryReader,
+  PostgresTaskTimelineReader: () => PostgresTaskTimelineReader,
+  TASK_STATUSES: () => TASK_STATUSES,
+  TASK_TIMELINE_EVENT_TYPES: () => TASK_TIMELINE_EVENT_TYPES,
+  TaskIdempotencyConflictError: () => TaskIdempotencyConflictError,
+  TaskLeaseReconciler: () => TaskLeaseReconciler,
+  TaskOutboxConflictError: () => TaskOutboxConflictError,
+  TaskOutboxDispatcher: () => TaskOutboxDispatcher,
+  TaskQueueReconciler: () => TaskQueueReconciler,
+  UnsupportedDurableTaskKindError: () => UnsupportedDurableTaskKindError,
+  assertTaskTransition: () => assertTaskTransition,
+  canTransitionTask: () => canTransitionTask,
+  createTaskFingerprint: () => createTaskFingerprint,
+  isTerminalTaskStatus: () => isTerminalTaskStatus,
+  requiresTaskLease: () => requiresTaskLease
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/task-state-machine.ts
+var TASK_STATUSES = [
+  "QUEUED",
+  "PROCESSING",
+  "WAITING_PROVIDER",
+  "RETRYING",
+  "COMPLETED",
+  "FAILED",
+  "CANCELLED"
+];
+var transitions = {
+  QUEUED: [
+    "PROCESSING",
+    "CANCELLED"
+  ],
+  PROCESSING: [
+    "WAITING_PROVIDER",
+    "RETRYING",
+    "COMPLETED",
+    "FAILED",
+    "CANCELLED"
+  ],
+  WAITING_PROVIDER: [
+    "PROCESSING",
+    "RETRYING",
+    "FAILED",
+    "CANCELLED"
+  ],
+  RETRYING: [
+    "QUEUED",
+    "FAILED",
+    "CANCELLED"
+  ],
+  COMPLETED: [],
+  FAILED: [],
+  CANCELLED: []
+};
+var InvalidTaskTransitionError = class extends Error {
+  static {
+    __name(this, "InvalidTaskTransitionError");
+  }
+  from;
+  to;
+  constructor(from, to) {
+    super(`Invalid task transition: ${from} -> ${to}`), this.from = from, this.to = to;
+    this.name = "InvalidTaskTransitionError";
+  }
+};
+function canTransitionTask(from, to) {
+  return transitions[from].includes(to);
+}
+__name(canTransitionTask, "canTransitionTask");
+function assertTaskTransition(from, to) {
+  if (!canTransitionTask(from, to)) {
+    throw new InvalidTaskTransitionError(from, to);
+  }
+}
+__name(assertTaskTransition, "assertTaskTransition");
+function isTerminalTaskStatus(status2) {
+  return status2 === "COMPLETED" || status2 === "FAILED" || status2 === "CANCELLED";
+}
+__name(isTerminalTaskStatus, "isTerminalTaskStatus");
+function requiresTaskLease(status2) {
+  return status2 === "PROCESSING" || status2 === "WAITING_PROVIDER";
+}
+__name(requiresTaskLease, "requiresTaskLease");
+
+// src/task-fingerprint.ts
+var import_node_crypto = require("crypto");
+function serialize(value, seen) {
+  if (value === null) return "null";
+  switch (typeof value) {
+    case "string":
+    case "boolean":
+      return JSON.stringify(value);
+    case "number":
+      if (!Number.isFinite(value)) {
+        throw new TypeError("Task fingerprint input cannot contain non-finite numbers");
+      }
+      return JSON.stringify(value);
+    case "undefined":
+      return void 0;
+    case "bigint":
+    case "function":
+    case "symbol":
+      throw new TypeError(`Task fingerprint input cannot contain ${typeof value}`);
+    case "object":
+      break;
+  }
+  if (value instanceof Date) return JSON.stringify(value.toISOString());
+  if (seen.has(value)) throw new TypeError("Task fingerprint input cannot contain circular references");
+  seen.add(value);
+  try {
+    if (Array.isArray(value)) {
+      return `[${value.map((entry) => serialize(entry, seen) ?? "null").join(",")}]`;
+    }
+    const prototype = Object.getPrototypeOf(value);
+    if (prototype !== Object.prototype && prototype !== null) {
+      throw new TypeError("Task fingerprint input must contain only JSON-compatible objects");
+    }
+    const entries = Object.keys(value).sort().flatMap((key) => {
+      const serialized = serialize(value[key], seen);
+      return serialized === void 0 ? [] : [
+        `${JSON.stringify(key)}:${serialized}`
+      ];
+    });
+    return `{${entries.join(",")}}`;
+  } finally {
+    seen.delete(value);
+  }
+}
+__name(serialize, "serialize");
+function createTaskFingerprint(value) {
+  const canonical = serialize(value, /* @__PURE__ */ new Set());
+  if (canonical === void 0) {
+    throw new TypeError("Task fingerprint input cannot be undefined");
+  }
+  return `sha256:${(0, import_node_crypto.createHash)("sha256").update(canonical).digest("hex")}`;
+}
+__name(createTaskFingerprint, "createTaskFingerprint");
+
+// src/task-repository.ts
+var TaskIdempotencyConflictError = class extends Error {
+  static {
+    __name(this, "TaskIdempotencyConflictError");
+  }
+  idempotencyKey;
+  constructor(idempotencyKey) {
+    super(`Idempotency key was reused with a different request: ${idempotencyKey}`), this.idempotencyKey = idempotencyKey;
+    this.name = "TaskIdempotencyConflictError";
+  }
+};
+
+// src/in-memory-task-repository.ts
+function cloneTask(task) {
+  return {
+    ...task,
+    resource: {
+      ...task.resource
+    },
+    error: task.error ? {
+      ...task.error,
+      metadata: task.error.metadata ? {
+        ...task.error.metadata
+      } : void 0
+    } : void 0,
+    availableAt: new Date(task.availableAt),
+    createdAt: new Date(task.createdAt),
+    updatedAt: new Date(task.updatedAt),
+    startedAt: task.startedAt ? new Date(task.startedAt) : void 0,
+    completedAt: task.completedAt ? new Date(task.completedAt) : void 0,
+    leaseExpiresAt: task.leaseExpiresAt ? new Date(task.leaseExpiresAt) : void 0,
+    heartbeatAt: task.heartbeatAt ? new Date(task.heartbeatAt) : void 0
+  };
+}
+__name(cloneTask, "cloneTask");
+function clampProgress(progress) {
+  return Math.max(0, Math.min(100, progress));
+}
+__name(clampProgress, "clampProgress");
+var InMemoryTaskRepository = class {
+  static {
+    __name(this, "InMemoryTaskRepository");
+  }
+  tasks = /* @__PURE__ */ new Map();
+  idempotencyIndex = /* @__PURE__ */ new Map();
+  async create(input) {
+    const existingId = this.idempotencyIndex.get(input.idempotencyKey);
+    if (existingId) {
+      const existing = this.tasks.get(existingId);
+      if (!existing) throw new Error(`Task index is corrupted for key ${input.idempotencyKey}`);
+      if (existing.idempotencyFingerprint !== input.idempotencyFingerprint) {
+        throw new TaskIdempotencyConflictError(input.idempotencyKey);
+      }
+      return {
+        task: cloneTask(existing),
+        created: false
+      };
+    }
+    if (this.tasks.has(input.id)) throw new Error(`Task already exists: ${input.id}`);
+    if (input.maxAttempts < 1) throw new RangeError("maxAttempts must be at least 1");
+    const task = {
+      id: input.id,
+      kind: input.kind,
+      resource: {
+        ...input.resource
+      },
+      userId: input.userId,
+      orderId: input.orderId,
+      status: "QUEUED",
+      progress: 0,
+      attempt: 0,
+      maxAttempts: input.maxAttempts,
+      idempotencyKey: input.idempotencyKey,
+      idempotencyFingerprint: input.idempotencyFingerprint,
+      handlerVersion: input.handlerVersion,
+      payload: input.payload,
+      availableAt: new Date(input.availableAt ?? input.now),
+      createdAt: new Date(input.now),
+      updatedAt: new Date(input.now),
+      version: 0
+    };
+    this.tasks.set(task.id, task);
+    this.idempotencyIndex.set(task.idempotencyKey, task.id);
+    return {
+      task: cloneTask(task),
+      created: true
+    };
+  }
+  async findById(id) {
+    const task = this.tasks.get(id);
+    return task ? cloneTask(task) : null;
+  }
+  async findByIdempotencyKey(key) {
+    const id = this.idempotencyIndex.get(key);
+    return id ? this.findById(id) : null;
+  }
+  async claim(input) {
+    const task = this.tasks.get(input.id);
+    if (!task || task.status !== "QUEUED" || task.availableAt.getTime() > input.now.getTime() || task.attempt >= task.maxAttempts || input.leaseExpiresAt.getTime() <= input.now.getTime()) {
+      return null;
+    }
+    task.status = "PROCESSING";
+    task.workerId = input.workerId;
+    task.leaseToken = input.leaseToken;
+    task.leaseExpiresAt = new Date(input.leaseExpiresAt);
+    task.heartbeatAt = new Date(input.now);
+    task.startedAt ??= new Date(input.now);
+    task.attempt += 1;
+    task.updatedAt = new Date(input.now);
+    task.version += 1;
+    return cloneTask(task);
+  }
+  async heartbeat(input) {
+    const task = this.tasks.get(input.id);
+    if (!task || !requiresTaskLease(task.status) || task.leaseToken !== input.leaseToken || !task.leaseExpiresAt || task.leaseExpiresAt.getTime() <= input.now.getTime() || input.leaseExpiresAt.getTime() <= input.now.getTime()) {
+      return false;
+    }
+    task.heartbeatAt = new Date(input.now);
+    task.leaseExpiresAt = new Date(input.leaseExpiresAt);
+    task.updatedAt = new Date(input.now);
+    task.version += 1;
+    return true;
+  }
+  async reportProgress(input) {
+    const task = this.tasks.get(input.id);
+    if (!task || !requiresTaskLease(task.status) || task.leaseToken !== input.leaseToken || !task.leaseExpiresAt || task.leaseExpiresAt.getTime() <= input.now.getTime()) {
+      return null;
+    }
+    task.stage = input.stage ?? task.stage;
+    task.progress = Math.max(task.progress, clampProgress(input.progress));
+    task.updatedAt = new Date(input.now);
+    task.version += 1;
+    return cloneTask(task);
+  }
+  async transition(input) {
+    const task = this.tasks.get(input.id);
+    if (!task || task.status !== input.from) return null;
+    assertTaskTransition(input.from, input.to);
+    if (input.from === "QUEUED" && input.to === "PROCESSING") return null;
+    if (requiresTaskLease(input.from)) {
+      if (!input.leaseToken || task.leaseToken !== input.leaseToken || !task.leaseExpiresAt || task.leaseExpiresAt.getTime() <= input.now.getTime()) {
+        return null;
+      }
+    }
+    task.status = input.to;
+    task.stage = input.stage ?? task.stage;
+    task.progress = input.to === "COMPLETED" ? 100 : clampProgress(input.progress ?? task.progress);
+    task.result = input.result ?? task.result;
+    task.error = input.error;
+    task.providerRequestId = input.providerRequestId ?? task.providerRequestId;
+    task.availableAt = new Date(input.availableAt ?? task.availableAt);
+    task.updatedAt = new Date(input.now);
+    task.version += 1;
+    if (input.to === "QUEUED" || input.to === "RETRYING" || isTerminalTaskStatus(input.to)) {
+      task.workerId = void 0;
+      task.leaseToken = void 0;
+      task.leaseExpiresAt = void 0;
+      task.heartbeatAt = void 0;
+    }
+    if (isTerminalTaskStatus(input.to)) task.completedAt = new Date(input.now);
+    return cloneTask(task);
+  }
+  async findExpiredLeases(input) {
+    if (input.limit < 1) return [];
+    return [
+      ...this.tasks.values()
+    ].filter((task) => requiresTaskLease(task.status) && Boolean(task.leaseExpiresAt && task.leaseExpiresAt.getTime() <= input.now.getTime())).sort((a, b) => (a.leaseExpiresAt?.getTime() ?? 0) - (b.leaseExpiresAt?.getTime() ?? 0)).slice(0, input.limit).map(cloneTask);
+  }
+  async findReadyQueued(input) {
+    if (input.limit < 1) return [];
+    return [
+      ...this.tasks.values()
+    ].filter((task) => task.status === "QUEUED" && task.availableAt.getTime() <= input.now.getTime() && task.attempt < task.maxAttempts).sort((a, b) => a.availableAt.getTime() - b.availableAt.getTime()).slice(input.offset ?? 0, (input.offset ?? 0) + input.limit).map(cloneTask);
+  }
+  async recoverExpiredLease(input) {
+    const task = this.tasks.get(input.id);
+    if (!task || !requiresTaskLease(task.status) || task.leaseToken !== input.leaseToken || !task.leaseExpiresAt || task.leaseExpiresAt.getTime() > input.now.getTime()) {
+      return null;
+    }
+    const attemptsExhausted = task.attempt >= task.maxAttempts;
+    task.status = attemptsExhausted ? "FAILED" : "QUEUED";
+    task.error = input.error;
+    task.availableAt = new Date(input.availableAt ?? input.now);
+    task.workerId = void 0;
+    task.leaseToken = void 0;
+    task.leaseExpiresAt = void 0;
+    task.heartbeatAt = void 0;
+    task.updatedAt = new Date(input.now);
+    task.version += 1;
+    if (attemptsExhausted) task.completedAt = new Date(input.now);
+    return cloneTask(task);
+  }
+  async cancel(id, now) {
+    const task = this.tasks.get(id);
+    if (!task || isTerminalTaskStatus(task.status)) return null;
+    task.status = "CANCELLED";
+    task.workerId = void 0;
+    task.leaseToken = void 0;
+    task.leaseExpiresAt = void 0;
+    task.heartbeatAt = void 0;
+    task.completedAt = new Date(now);
+    task.updatedAt = new Date(now);
+    task.version += 1;
+    return cloneTask(task);
+  }
+};
+
+// src/postgres-task-repository.ts
+var CREATE_TASK_SQL = `
+  WITH inserted AS (
+    INSERT INTO async_jobs (
+      "id", "kind", "resourceType", "resourceId", "userId", "orderId",
+      "status", "progress", "attempt", "maxAttempts", "idempotencyKey",
+      "idempotencyFingerprint", "handlerVersion", "payload", "availableAt",
+      "createdAt", "updatedAt", "version"
+    ) VALUES (
+      $1, $2, $3, $4, $5, $6,
+      'QUEUED', 0, 0, $7, $8,
+      $9, $10, $11::jsonb, $12,
+      $13, $13, 0
+    )
+    ON CONFLICT ("idempotencyKey") DO NOTHING
+    RETURNING *
+  )
+  SELECT inserted.*, TRUE AS "__created"
+  FROM inserted
+  UNION ALL
+  SELECT existing.*, FALSE AS "__created"
+  FROM async_jobs AS existing
+  WHERE existing."idempotencyKey" = $8
+    AND NOT EXISTS (SELECT 1 FROM inserted)
+  LIMIT 1
+`;
+var CLAIM_TASK_SQL = `
+  UPDATE async_jobs
+  SET
+    "status" = 'PROCESSING',
+    "workerId" = $2,
+    "leaseToken" = $3,
+    "leaseExpiresAt" = $4,
+    "heartbeatAt" = $5,
+    "startedAt" = COALESCE("startedAt", $5),
+    "attempt" = "attempt" + 1,
+    "updatedAt" = $5,
+    "version" = "version" + 1
+  WHERE "id" = $1
+    AND "status" = 'QUEUED'
+    AND "availableAt" <= $5
+    AND "attempt" < "maxAttempts"
+    AND $4 > $5
+  RETURNING *
+`;
+var HEARTBEAT_TASK_SQL = `
+  UPDATE async_jobs
+  SET
+    "heartbeatAt" = $4,
+    "leaseExpiresAt" = $3,
+    "updatedAt" = $4,
+    "version" = "version" + 1
+  WHERE "id" = $1
+    AND "status" IN ('PROCESSING', 'WAITING_PROVIDER')
+    AND "leaseToken" = $2
+    AND "leaseExpiresAt" > $4
+    AND $3 > $4
+  RETURNING "id"
+`;
+var REPORT_TASK_PROGRESS_SQL = `
+  UPDATE async_jobs
+  SET
+    "stage" = COALESCE($3::text, "stage"),
+    "progress" = GREATEST("progress", GREATEST(0, LEAST(100, $4::integer))),
+    "updatedAt" = $5,
+    "version" = "version" + 1
+  WHERE "id" = $1
+    AND "status" IN ('PROCESSING', 'WAITING_PROVIDER')
+    AND "leaseToken" = $2
+    AND "leaseExpiresAt" > $5
+  RETURNING *
+`;
+var TRANSITION_TASK_SQL = `
+  UPDATE async_jobs
+  SET
+    "status" = $3::async_job_status,
+    "stage" = COALESCE($5::text, "stage"),
+    "progress" = CASE
+      WHEN $3 = 'COMPLETED' THEN 100
+      WHEN $6::integer IS NULL THEN "progress"
+      ELSE GREATEST(0, LEAST(100, $6::integer))
+    END,
+    "result" = COALESCE($7::jsonb, "result"),
+    "errorCode" = $8::text,
+    "errorCategory" = $9::text,
+    "errorSummary" = $10::text,
+    "errorRetryable" = $11::boolean,
+    "errorMetadata" = $12::jsonb,
+    "providerRequestId" = COALESCE($13::text, "providerRequestId"),
+    "availableAt" = COALESCE($14::timestamptz, "availableAt"),
+    "workerId" = CASE WHEN $16::boolean THEN NULL ELSE "workerId" END,
+    "leaseToken" = CASE WHEN $16::boolean THEN NULL ELSE "leaseToken" END,
+    "leaseExpiresAt" = CASE WHEN $16::boolean THEN NULL ELSE "leaseExpiresAt" END,
+    "heartbeatAt" = CASE WHEN $16::boolean THEN NULL ELSE "heartbeatAt" END,
+    "completedAt" = CASE WHEN $17::boolean THEN $15::timestamptz ELSE "completedAt" END,
+    "updatedAt" = $15::timestamptz,
+    "version" = "version" + 1
+  WHERE "id" = $1
+    AND "status" = $2::async_job_status
+    AND (
+      NOT $18::boolean
+      OR (
+        $4::text IS NOT NULL
+        AND "leaseToken" = $4::text
+        AND "leaseExpiresAt" > $15::timestamptz
+      )
+    )
+  RETURNING *
+`;
+var FIND_EXPIRED_LEASES_SQL = `
+  SELECT *
+  FROM async_jobs
+  WHERE "status" IN ('PROCESSING', 'WAITING_PROVIDER')
+    AND "leaseExpiresAt" <= $1
+  ORDER BY "leaseExpiresAt" ASC
+  LIMIT $2
+`;
+var FIND_READY_QUEUED_TASKS_SQL = `
+  SELECT *
+  FROM async_jobs
+  WHERE "status" = 'QUEUED'
+    AND "availableAt" <= $1
+    AND "attempt" < "maxAttempts"
+  ORDER BY "availableAt" ASC, "createdAt" ASC
+  LIMIT $2
+  OFFSET $3
+`;
+var RECOVER_EXPIRED_LEASE_SQL = `
+  UPDATE async_jobs
+  SET
+    "status" = CASE
+      WHEN "attempt" >= "maxAttempts" THEN 'FAILED'::async_job_status
+      ELSE 'QUEUED'::async_job_status
+    END,
+    "errorCode" = $4,
+    "errorCategory" = $5,
+    "errorSummary" = $6,
+    "errorRetryable" = $7,
+    "errorMetadata" = $8::jsonb,
+    "availableAt" = COALESCE($9, $3),
+    "workerId" = NULL,
+    "leaseToken" = NULL,
+    "leaseExpiresAt" = NULL,
+    "heartbeatAt" = NULL,
+    "completedAt" = CASE
+      WHEN "attempt" >= "maxAttempts" THEN $3
+      ELSE "completedAt"
+    END,
+    "updatedAt" = $3,
+    "version" = "version" + 1
+  WHERE "id" = $1
+    AND "status" IN ('PROCESSING', 'WAITING_PROVIDER')
+    AND "leaseToken" = $2
+    AND "leaseExpiresAt" <= $3
+  RETURNING *
+`;
+var CANCEL_TASK_SQL = `
+  UPDATE async_jobs
+  SET
+    "status" = 'CANCELLED',
+    "workerId" = NULL,
+    "leaseToken" = NULL,
+    "leaseExpiresAt" = NULL,
+    "heartbeatAt" = NULL,
+    "completedAt" = $2,
+    "updatedAt" = $2,
+    "version" = "version" + 1
+  WHERE "id" = $1
+    AND "status" NOT IN ('COMPLETED', 'FAILED', 'CANCELLED')
+  RETURNING *
+`;
+function jsonParameter(value) {
+  return value === void 0 ? null : JSON.stringify(value);
+}
+__name(jsonParameter, "jsonParameter");
+function parseJson(value) {
+  if (typeof value !== "string") return value;
+  return JSON.parse(value);
+}
+__name(parseJson, "parseJson");
+function optionalDate(value) {
+  return value === null ? void 0 : new Date(value);
+}
+__name(optionalDate, "optionalDate");
+function taskStatus(value) {
+  if (TASK_STATUSES.includes(value)) return value;
+  throw new Error(`Unknown task status returned by PostgreSQL: ${value}`);
+}
+__name(taskStatus, "taskStatus");
+function taskError(row) {
+  if (!row.errorCode) return void 0;
+  return {
+    code: row.errorCode,
+    category: row.errorCategory ?? "UNKNOWN",
+    summary: row.errorSummary ?? row.errorCode,
+    retryable: row.errorRetryable ?? false,
+    metadata: row.errorMetadata ? parseJson(row.errorMetadata) : void 0
+  };
+}
+__name(taskError, "taskError");
+var PostgresTaskRepository = class {
+  static {
+    __name(this, "PostgresTaskRepository");
+  }
+  client;
+  constructor(client) {
+    this.client = client;
+  }
+  async create(input) {
+    if (input.maxAttempts < 1) throw new RangeError("maxAttempts must be at least 1");
+    const result = await this.client.query(CREATE_TASK_SQL, [
+      input.id,
+      input.kind,
+      input.resource.type,
+      input.resource.id,
+      input.userId ?? null,
+      input.orderId ?? null,
+      input.maxAttempts,
+      input.idempotencyKey,
+      input.idempotencyFingerprint,
+      input.handlerVersion,
+      jsonParameter(input.payload),
+      input.availableAt ?? input.now,
+      input.now
+    ]);
+    const row = result.rows[0];
+    if (!row) {
+      const existing = await this.findByIdempotencyKey(input.idempotencyKey);
+      if (!existing) throw new Error(`Task already exists with a different id: ${input.id}`);
+      if (existing.idempotencyFingerprint !== input.idempotencyFingerprint) {
+        throw new TaskIdempotencyConflictError(input.idempotencyKey);
+      }
+      return {
+        task: existing,
+        created: false
+      };
+    }
+    if (row.idempotencyFingerprint !== input.idempotencyFingerprint) {
+      throw new TaskIdempotencyConflictError(input.idempotencyKey);
+    }
+    return {
+      task: this.toTask(row),
+      created: row.__created
+    };
+  }
+  async findById(id) {
+    const result = await this.client.query('SELECT * FROM async_jobs WHERE "id" = $1 LIMIT 1', [
+      id
+    ]);
+    return result.rows[0] ? this.toTask(result.rows[0]) : null;
+  }
+  async findByIdempotencyKey(key) {
+    const result = await this.client.query('SELECT * FROM async_jobs WHERE "idempotencyKey" = $1 LIMIT 1', [
+      key
+    ]);
+    return result.rows[0] ? this.toTask(result.rows[0]) : null;
+  }
+  async claim(input) {
+    const result = await this.client.query(CLAIM_TASK_SQL, [
+      input.id,
+      input.workerId,
+      input.leaseToken,
+      input.leaseExpiresAt,
+      input.now
+    ]);
+    return result.rows[0] ? this.toTask(result.rows[0]) : null;
+  }
+  async heartbeat(input) {
+    const result = await this.client.query(HEARTBEAT_TASK_SQL, [
+      input.id,
+      input.leaseToken,
+      input.leaseExpiresAt,
+      input.now
+    ]);
+    return result.rows.length === 1;
+  }
+  async reportProgress(input) {
+    const result = await this.client.query(REPORT_TASK_PROGRESS_SQL, [
+      input.id,
+      input.leaseToken,
+      input.stage ?? null,
+      input.progress,
+      input.now
+    ]);
+    return result.rows[0] ? this.toTask(result.rows[0]) : null;
+  }
+  async transition(input) {
+    assertTaskTransition(input.from, input.to);
+    if (input.from === "QUEUED" && input.to === "PROCESSING") return null;
+    const clearsLease = input.to === "QUEUED" || input.to === "RETRYING" || isTerminalTaskStatus(input.to);
+    const error = input.error;
+    const result = await this.client.query(TRANSITION_TASK_SQL, [
+      input.id,
+      input.from,
+      input.to,
+      input.leaseToken ?? null,
+      input.stage ?? null,
+      input.progress ?? null,
+      jsonParameter(input.result),
+      error?.code ?? null,
+      error?.category ?? null,
+      error?.summary ?? null,
+      error?.retryable ?? null,
+      jsonParameter(error?.metadata),
+      input.providerRequestId ?? null,
+      input.availableAt ?? null,
+      input.now,
+      clearsLease,
+      isTerminalTaskStatus(input.to),
+      requiresTaskLease(input.from)
+    ]);
+    return result.rows[0] ? this.toTask(result.rows[0]) : null;
+  }
+  async findExpiredLeases(input) {
+    if (input.limit < 1) return [];
+    const result = await this.client.query(FIND_EXPIRED_LEASES_SQL, [
+      input.now,
+      input.limit
+    ]);
+    return result.rows.map((row) => this.toTask(row));
+  }
+  async findReadyQueued(input) {
+    if (input.limit < 1) return [];
+    const result = await this.client.query(FIND_READY_QUEUED_TASKS_SQL, [
+      input.now,
+      input.limit,
+      input.offset ?? 0
+    ]);
+    return result.rows.map((row) => this.toTask(row));
+  }
+  async recoverExpiredLease(input) {
+    const result = await this.client.query(RECOVER_EXPIRED_LEASE_SQL, [
+      input.id,
+      input.leaseToken,
+      input.now,
+      input.error.code,
+      input.error.category,
+      input.error.summary,
+      input.error.retryable,
+      jsonParameter(input.error.metadata),
+      input.availableAt ?? null
+    ]);
+    return result.rows[0] ? this.toTask(result.rows[0]) : null;
+  }
+  async cancel(id, now) {
+    const result = await this.client.query(CANCEL_TASK_SQL, [
+      id,
+      now
+    ]);
+    return result.rows[0] ? this.toTask(result.rows[0]) : null;
+  }
+  toTask(row) {
+    return {
+      id: row.id,
+      kind: row.kind,
+      resource: {
+        type: row.resourceType,
+        id: row.resourceId
+      },
+      userId: row.userId ?? void 0,
+      orderId: row.orderId ?? void 0,
+      status: taskStatus(row.status),
+      stage: row.stage ?? void 0,
+      progress: row.progress,
+      attempt: row.attempt,
+      maxAttempts: row.maxAttempts,
+      idempotencyKey: row.idempotencyKey,
+      idempotencyFingerprint: row.idempotencyFingerprint,
+      handlerVersion: row.handlerVersion,
+      payload: parseJson(row.payload),
+      result: row.result === null ? void 0 : parseJson(row.result),
+      error: taskError(row),
+      providerRequestId: row.providerRequestId ?? void 0,
+      workerId: row.workerId ?? void 0,
+      leaseToken: row.leaseToken ?? void 0,
+      leaseExpiresAt: optionalDate(row.leaseExpiresAt),
+      heartbeatAt: optionalDate(row.heartbeatAt),
+      availableAt: new Date(row.availableAt),
+      createdAt: new Date(row.createdAt),
+      startedAt: optionalDate(row.startedAt),
+      completedAt: optionalDate(row.completedAt),
+      updatedAt: new Date(row.updatedAt),
+      version: row.version
+    };
+  }
+};
+
+// src/postgres-task-summary-reader.ts
+var SAFE_SUMMARY_COLUMNS = `
+  "id", "kind", "resourceType", "resourceId", "status"::text AS "status",
+  "stage", "progress", "attempt", "maxAttempts", "errorCode",
+  "errorCategory", "errorRetryable", "createdAt",
+  "startedAt", "completedAt", "updatedAt", "version"
+`;
+function optionalDate2(value) {
+  return value === null ? void 0 : new Date(value);
+}
+__name(optionalDate2, "optionalDate");
+function taskStatus2(value) {
+  if (TASK_STATUSES.includes(value)) return value;
+  throw new Error(`Unknown task status returned by PostgreSQL: ${value}`);
+}
+__name(taskStatus2, "taskStatus");
+function toSummary(row) {
+  const error = row.errorCode ? {
+    code: row.errorCode,
+    category: row.errorCategory ?? "UNKNOWN",
+    summary: row.errorCode,
+    retryable: row.errorRetryable ?? false
+  } : void 0;
+  return {
+    id: row.id,
+    kind: row.kind,
+    resource: {
+      type: row.resourceType,
+      id: row.resourceId
+    },
+    status: taskStatus2(row.status),
+    stage: row.stage ?? void 0,
+    progress: row.progress,
+    attempt: row.attempt,
+    maxAttempts: row.maxAttempts,
+    error,
+    createdAt: new Date(row.createdAt),
+    startedAt: optionalDate2(row.startedAt),
+    completedAt: optionalDate2(row.completedAt),
+    updatedAt: new Date(row.updatedAt),
+    version: row.version
+  };
+}
+__name(toSummary, "toSummary");
+var PostgresTaskSummaryReader = class {
+  static {
+    __name(this, "PostgresTaskSummaryReader");
+  }
+  client;
+  constructor(client) {
+    this.client = client;
+  }
+  async findOwnedById(taskId, userId) {
+    const result = await this.client.query(`SELECT ${SAFE_SUMMARY_COLUMNS}
+       FROM async_jobs
+       WHERE "id" = $1 AND "userId" = $2
+       LIMIT 1`, [
+      taskId,
+      userId
+    ]);
+    return result.rows[0] ? toSummary(result.rows[0]) : null;
+  }
+  async listOwned(input) {
+    if (!input.userId) return [];
+    const limit = Math.max(1, Math.min(input.limit ?? 50, 100));
+    const statuses = input.statuses?.length ? [
+      ...new Set(input.statuses)
+    ] : void 0;
+    if (statuses?.some((status2) => !TASK_STATUSES.includes(status2))) {
+      throw new RangeError("statuses contains an unknown task status");
+    }
+    const statusPlaceholders = statuses?.map((_, index) => `$${index + 2}::async_job_status`).join(", ");
+    const result = statuses ? await this.client.query(`SELECT ${SAFE_SUMMARY_COLUMNS}
+           FROM async_jobs
+           WHERE "userId" = $1
+             AND "status" IN (${statusPlaceholders})
+           ORDER BY "createdAt" DESC, "id" DESC
+           LIMIT $${statuses.length + 2}`, [
+      input.userId,
+      ...statuses,
+      limit
+    ]) : await this.client.query(`SELECT ${SAFE_SUMMARY_COLUMNS}
+           FROM async_jobs
+           WHERE "userId" = $1
+           ORDER BY "createdAt" DESC, "id" DESC
+           LIMIT $2`, [
+      input.userId,
+      limit
+    ]);
+    return result.rows.map(toSummary);
+  }
+};
+
+// src/task-timeline.ts
+var TASK_TIMELINE_EVENT_TYPES = [
+  "SNAPSHOT",
+  "CREATED",
+  "CLAIMED",
+  "PROGRESS",
+  "RETRY_SCHEDULED",
+  "REQUEUED",
+  "LEASE_RECOVERED",
+  "MANUAL_REDRIVE",
+  "COMPLETED",
+  "FAILED",
+  "CANCELLED",
+  "STATUS_CHANGED"
+];
+var PUBLIC_COLUMNS = `events."id", events."taskId", events."sequence",
+  events."eventType", events."fromStatus"::text AS "fromStatus",
+  events."toStatus"::text AS "toStatus", events."stage", events."progress",
+  events."attempt", events."maxAttempts", events."errorCode",
+  events."errorCategory", events."errorRetryable",
+  events."createdAt"`;
+function status(value) {
+  if (value === null) return void 0;
+  if (TASK_STATUSES.includes(value)) return value;
+  throw new Error(`Unknown task status returned by PostgreSQL: ${value}`);
+}
+__name(status, "status");
+function requiredStatus(value) {
+  const parsed = status(value);
+  if (parsed) return parsed;
+  throw new Error("Task timeline event is missing its destination status");
+}
+__name(requiredStatus, "requiredStatus");
+function eventType(value) {
+  if (TASK_TIMELINE_EVENT_TYPES.includes(value)) {
+    return value;
+  }
+  throw new Error(`Unknown task timeline event type returned by PostgreSQL: ${value}`);
+}
+__name(eventType, "eventType");
+function toOwnedEvent(row) {
+  const error = row.errorCode ? {
+    code: row.errorCode,
+    category: row.errorCategory ?? "UNKNOWN",
+    summary: row.errorCode,
+    retryable: row.errorRetryable ?? false
+  } : void 0;
+  return {
+    id: row.id,
+    taskId: row.taskId,
+    sequence: row.sequence,
+    type: eventType(row.eventType),
+    fromStatus: status(row.fromStatus),
+    toStatus: requiredStatus(row.toStatus),
+    stage: row.stage ?? void 0,
+    progress: row.progress,
+    attempt: row.attempt,
+    maxAttempts: row.maxAttempts,
+    error,
+    createdAt: new Date(row.createdAt)
+  };
+}
+__name(toOwnedEvent, "toOwnedEvent");
+var PostgresTaskTimelineReader = class {
+  static {
+    __name(this, "PostgresTaskTimelineReader");
+  }
+  client;
+  constructor(client) {
+    this.client = client;
+  }
+  async listOwned(taskId, userId, limit = 200) {
+    if (!userId) return [];
+    const result = await this.client.query(`SELECT ${PUBLIC_COLUMNS}
+       FROM async_job_events AS events
+       INNER JOIN async_jobs AS tasks ON tasks."id" = events."taskId"
+       WHERE events."taskId" = $1 AND tasks."userId" = $2
+       ORDER BY events."sequence" ASC
+       LIMIT $3`, [
+      taskId,
+      userId,
+      this.normalizeLimit(limit)
+    ]);
+    return result.rows.map(toOwnedEvent);
+  }
+  async listByTaskId(taskId, limit = 500) {
+    const result = await this.client.query(`SELECT ${PUBLIC_COLUMNS}, events."workerId", events."providerRequestId"
+       FROM async_job_events AS events
+       WHERE events."taskId" = $1
+       ORDER BY events."sequence" ASC
+       LIMIT $2`, [
+      taskId,
+      this.normalizeLimit(limit)
+    ]);
+    return result.rows.map((row) => ({
+      ...toOwnedEvent(row),
+      workerId: row.workerId ?? void 0,
+      providerRequestId: row.providerRequestId ?? void 0
+    }));
+  }
+  normalizeLimit(limit) {
+    return Math.max(1, Math.min(Math.trunc(limit), 1e3));
+  }
+};
+
+// src/task-redriver.ts
+var PostgresTaskRedriver = class {
+  static {
+    __name(this, "PostgresTaskRedriver");
+  }
+  client;
+  constructor(client) {
+    this.client = client;
+  }
+  async redriveFailed(input) {
+    const additionalAttempts = input.additionalAttempts ?? 1;
+    if (!Number.isInteger(additionalAttempts) || additionalAttempts < 1 || additionalAttempts > 10) {
+      throw new RangeError("additionalAttempts must be an integer between 1 and 10");
+    }
+    const result = await this.client.query(`UPDATE async_jobs
+       SET "status" = 'QUEUED'::async_job_status,
+           "stage" = $2,
+           "maxAttempts" = GREATEST("maxAttempts", "attempt" + $3),
+           "result" = NULL,
+           "errorCode" = NULL,
+           "errorCategory" = NULL,
+           "errorSummary" = NULL,
+           "errorRetryable" = NULL,
+           "errorMetadata" = NULL,
+           "providerRequestId" = NULL,
+           "workerId" = NULL,
+           "leaseToken" = NULL,
+           "leaseExpiresAt" = NULL,
+           "heartbeatAt" = NULL,
+           "availableAt" = $4,
+           "completedAt" = NULL,
+           "updatedAt" = $4,
+           "version" = "version" + 1
+       WHERE "id" = $1 AND "status" = 'FAILED'::async_job_status
+       RETURNING "id", "attempt", "maxAttempts", "version", "availableAt"`, [
+      input.taskId,
+      input.stage ?? "manual-redrive",
+      additionalAttempts,
+      input.now
+    ]);
+    const row = result.rows[0];
+    return row ? {
+      taskId: row.id,
+      attempt: row.attempt,
+      maxAttempts: row.maxAttempts,
+      version: row.version,
+      availableAt: new Date(row.availableAt)
+    } : null;
+  }
+};
+
+// src/postgres-task-outbox.ts
+var import_node_util = require("util");
+
+// src/task-outbox.ts
+var TaskOutboxConflictError = class extends Error {
+  static {
+    __name(this, "TaskOutboxConflictError");
+  }
+  eventId;
+  constructor(eventId) {
+    super(`Outbox event id was reused with different content: ${eventId}`), this.eventId = eventId;
+    this.name = "TaskOutboxConflictError";
+  }
+};
+
+// src/postgres-task-outbox.ts
+var APPEND_OUTBOX_SQL = `
+  WITH inserted AS (
+    INSERT INTO async_job_outbox (
+      "id", "taskId", "topic", "payload", "status", "attempt",
+      "availableAt", "createdAt", "updatedAt"
+    ) VALUES (
+      $1, $2, $3, $4::jsonb, 'PENDING', 0,
+      $5, $6, $6
+    )
+    ON CONFLICT ("id") DO NOTHING
+    RETURNING *
+  )
+  SELECT inserted.*, TRUE AS "__created"
+  FROM inserted
+  UNION ALL
+  SELECT existing.*, FALSE AS "__created"
+  FROM async_job_outbox AS existing
+  WHERE existing."id" = $1
+    AND NOT EXISTS (SELECT 1 FROM inserted)
+  LIMIT 1
+`;
+var CLAIM_OUTBOX_SQL = `
+  WITH candidates AS (
+    SELECT "id"
+    FROM async_job_outbox
+    WHERE "availableAt" <= $4
+      AND (
+        "status" = 'PENDING'
+        OR (
+          "status" = 'PUBLISHING'
+          AND "leaseExpiresAt" <= $4
+        )
+      )
+    ORDER BY "createdAt" ASC
+    LIMIT $5
+    FOR UPDATE SKIP LOCKED
+  )
+  UPDATE async_job_outbox AS events
+  SET
+    "status" = 'PUBLISHING',
+    "workerId" = $1,
+    "leaseToken" = $2,
+    "leaseExpiresAt" = $3,
+    "attempt" = events."attempt" + 1,
+    "updatedAt" = $4
+  FROM candidates
+  WHERE events."id" = candidates."id"
+    AND $3 > $4
+  RETURNING events.*
+`;
+var MARK_OUTBOX_PUBLISHED_SQL = `
+  UPDATE async_job_outbox
+  SET
+    "status" = 'PUBLISHED',
+    "workerId" = NULL,
+    "leaseToken" = NULL,
+    "leaseExpiresAt" = NULL,
+    "publishedAt" = $3,
+    "updatedAt" = $3,
+    "lastError" = NULL
+  WHERE "id" = $1
+    AND "status" = 'PUBLISHING'
+    AND "leaseToken" = $2
+    AND "leaseExpiresAt" > $3
+  RETURNING "id"
+`;
+var RESCHEDULE_OUTBOX_SQL = `
+  UPDATE async_job_outbox
+  SET
+    "status" = 'PENDING',
+    "workerId" = NULL,
+    "leaseToken" = NULL,
+    "leaseExpiresAt" = NULL,
+    "availableAt" = $3,
+    "lastError" = $4,
+    "updatedAt" = $5
+  WHERE "id" = $1
+    AND "status" = 'PUBLISHING'
+    AND "leaseToken" = $2
+    AND "leaseExpiresAt" > $5
+  RETURNING "id"
+`;
+function parseJson2(value) {
+  if (typeof value !== "string") return value;
+  return JSON.parse(value);
+}
+__name(parseJson2, "parseJson");
+function optionalDate3(value) {
+  return value === null ? void 0 : new Date(value);
+}
+__name(optionalDate3, "optionalDate");
+var PostgresTaskOutboxRepository = class {
+  static {
+    __name(this, "PostgresTaskOutboxRepository");
+  }
+  client;
+  constructor(client) {
+    this.client = client;
+  }
+  async append(input) {
+    const result = await this.client.query(APPEND_OUTBOX_SQL, [
+      input.id,
+      input.taskId,
+      input.topic,
+      JSON.stringify(input.payload),
+      input.availableAt ?? input.now,
+      input.now
+    ]);
+    let row = result.rows[0];
+    if (!row) {
+      const existing = await this.client.query('SELECT * FROM async_job_outbox WHERE "id" = $1 LIMIT 1', [
+        input.id
+      ]);
+      row = existing.rows[0];
+      if (row) row.__created = false;
+    }
+    if (!row) throw new Error(`Outbox event could not be created: ${input.id}`);
+    if (row.taskId !== input.taskId || row.topic !== input.topic || !(0, import_node_util.isDeepStrictEqual)(parseJson2(row.payload), input.payload)) {
+      throw new TaskOutboxConflictError(input.id);
+    }
+    return {
+      record: this.toRecord(row),
+      created: row.__created
+    };
+  }
+  async claimBatch(input) {
+    if (input.limit < 1 || input.leaseExpiresAt.getTime() <= input.now.getTime()) return [];
+    const result = await this.client.query(CLAIM_OUTBOX_SQL, [
+      input.workerId,
+      input.leaseToken,
+      input.leaseExpiresAt,
+      input.now,
+      input.limit
+    ]);
+    return result.rows.map((row) => this.toRecord(row));
+  }
+  async markPublished(id, leaseToken, now) {
+    const result = await this.client.query(MARK_OUTBOX_PUBLISHED_SQL, [
+      id,
+      leaseToken,
+      now
+    ]);
+    return result.rows.length === 1;
+  }
+  async reschedule(id, leaseToken, availableAt, errorSummary, now) {
+    const result = await this.client.query(RESCHEDULE_OUTBOX_SQL, [
+      id,
+      leaseToken,
+      availableAt,
+      errorSummary,
+      now
+    ]);
+    return result.rows.length === 1;
+  }
+  toRecord(row) {
+    return {
+      id: row.id,
+      taskId: row.taskId,
+      topic: row.topic,
+      payload: parseJson2(row.payload),
+      status: row.status,
+      attempt: row.attempt,
+      availableAt: new Date(row.availableAt),
+      workerId: row.workerId ?? void 0,
+      leaseToken: row.leaseToken ?? void 0,
+      leaseExpiresAt: optionalDate3(row.leaseExpiresAt),
+      publishedAt: optionalDate3(row.publishedAt),
+      lastError: row.lastError ?? void 0,
+      createdAt: new Date(row.createdAt),
+      updatedAt: new Date(row.updatedAt)
+    };
+  }
+};
+
+// src/postgres-task-submitter.ts
+var PostgresTaskSubmitter = class {
+  static {
+    __name(this, "PostgresTaskSubmitter");
+  }
+  transactions;
+  constructor(transactions) {
+    this.transactions = transactions;
+  }
+  async submit(input, options = {}) {
+    return this.transactions.runInTransaction(async (client) => {
+      const result = await this.submitWithClient(client, input);
+      await options.transactionalWork?.(client, result);
+      return result;
+    });
+  }
+  async submitBatch(inputs, options = {}) {
+    return this.transactions.runInTransaction(async (client) => {
+      const results = [];
+      for (const input of inputs) {
+        results.push(await this.submitWithClient(client, input));
+      }
+      await options.transactionalWork?.(client, results);
+      return results;
+    });
+  }
+  async submitWithClient(client, input) {
+    const tasks = new PostgresTaskRepository(client);
+    const outbox = new PostgresTaskOutboxRepository(client);
+    const task = await tasks.create(input.task);
+    const event = await outbox.append({
+      ...input.outbox,
+      taskId: task.task.id,
+      now: input.task.now
+    });
+    return {
+      task,
+      outbox: event
+    };
+  }
+};
+
+// src/task-lease-reconciler.ts
+var leaseExpiredError = {
+  code: "WORKER_LEASE_EXPIRED",
+  category: "INTERNAL",
+  summary: "Worker heartbeat expired before the task reached a terminal state",
+  retryable: true
+};
+var TaskLeaseReconciler = class {
+  static {
+    __name(this, "TaskLeaseReconciler");
+  }
+  repository;
+  batchSize;
+  retryDelayMs;
+  now;
+  constructor(repository, options = {}) {
+    this.repository = repository;
+    this.batchSize = options.batchSize ?? 100;
+    this.retryDelayMs = options.retryDelayMs ?? 0;
+    this.now = options.now ?? (() => /* @__PURE__ */ new Date());
+    if (this.batchSize < 1) throw new RangeError("batchSize must be at least 1");
+    if (this.retryDelayMs < 0) throw new RangeError("retryDelayMs cannot be negative");
+  }
+  async runOnce() {
+    const now = this.now();
+    const expired = await this.repository.findExpiredLeases({
+      now,
+      limit: this.batchSize
+    });
+    const result = {
+      found: expired.length,
+      requeued: 0,
+      failed: 0,
+      conflicts: 0
+    };
+    for (const task of expired) {
+      if (!task.leaseToken) {
+        result.conflicts += 1;
+        continue;
+      }
+      const recovered = await this.repository.recoverExpiredLease({
+        id: task.id,
+        leaseToken: task.leaseToken,
+        now,
+        availableAt: new Date(now.getTime() + this.retryDelayMs),
+        error: leaseExpiredError
+      });
+      if (!recovered) result.conflicts += 1;
+      else if (recovered.status === "FAILED") result.failed += 1;
+      else result.requeued += 1;
+    }
+    return result;
+  }
+};
+
+// src/task-queue-reconciler.ts
+var TaskQueueReconciler = class {
+  static {
+    __name(this, "TaskQueueReconciler");
+  }
+  repository;
+  publisher;
+  batchSize;
+  now;
+  offset = 0;
+  constructor(repository, publisher, options = {}) {
+    this.repository = repository;
+    this.publisher = publisher;
+    this.batchSize = options.batchSize ?? 100;
+    this.now = options.now ?? (() => /* @__PURE__ */ new Date());
+    if (this.batchSize < 1) throw new RangeError("batchSize must be at least 1");
+  }
+  async runOnce() {
+    let tasks = await this.repository.findReadyQueued({
+      now: this.now(),
+      limit: this.batchSize,
+      offset: this.offset
+    });
+    if (tasks.length === 0 && this.offset > 0) {
+      this.offset = 0;
+      tasks = await this.repository.findReadyQueued({
+        now: this.now(),
+        limit: this.batchSize,
+        offset: 0
+      });
+    }
+    this.offset = tasks.length < this.batchSize ? 0 : this.offset + tasks.length;
+    const result = {
+      found: tasks.length,
+      ensured: 0,
+      failed: 0
+    };
+    for (const task of tasks) {
+      try {
+        await this.publisher.ensure(task);
+        result.ensured += 1;
+      } catch {
+        result.failed += 1;
+      }
+    }
+    return result;
+  }
+};
+
+// src/retry-policy.ts
+var defaultRetryableCategories = [
+  "RATE_LIMIT",
+  "NETWORK",
+  "PROVIDER_5XX",
+  "PROVIDER_TIMEOUT",
+  "INTERNAL"
+];
+var ExponentialTaskRetryPolicy = class {
+  static {
+    __name(this, "ExponentialTaskRetryPolicy");
+  }
+  baseDelayMs;
+  maxDelayMs;
+  jitterRatio;
+  retryableCategories;
+  random;
+  constructor(options = {}) {
+    this.baseDelayMs = options.baseDelayMs ?? 1e3;
+    this.maxDelayMs = options.maxDelayMs ?? 6e4;
+    this.jitterRatio = options.jitterRatio ?? 0.2;
+    this.retryableCategories = new Set(options.retryableCategories ?? defaultRetryableCategories);
+    this.random = options.random ?? Math.random;
+    if (this.baseDelayMs < 0) throw new RangeError("baseDelayMs cannot be negative");
+    if (this.maxDelayMs < this.baseDelayMs) {
+      throw new RangeError("maxDelayMs cannot be lower than baseDelayMs");
+    }
+    if (this.jitterRatio < 0 || this.jitterRatio > 1) {
+      throw new RangeError("jitterRatio must be between 0 and 1");
+    }
+  }
+  decide(context) {
+    if (context.attempt >= context.maxAttempts) {
+      return {
+        retry: false,
+        reason: "ATTEMPTS_EXHAUSTED"
+      };
+    }
+    if (!context.error.retryable || !this.retryableCategories.has(context.error.category)) {
+      return {
+        retry: false,
+        reason: "NON_RETRYABLE"
+      };
+    }
+    const exponential = Math.min(this.maxDelayMs, this.baseDelayMs * 2 ** Math.max(0, context.attempt - 1));
+    const retryAfter = Math.max(0, context.retryAfterMs ?? 0);
+    const base = Math.max(exponential, retryAfter);
+    const spread = Math.min(this.maxDelayMs, base) * this.jitterRatio;
+    const jittered = base - spread + this.random() * spread * 2;
+    return {
+      retry: true,
+      delayMs: Math.round(Math.min(this.maxDelayMs, jittered))
+    };
+  }
+};
+
+// src/durable-worker-runtime.ts
+var import_node_crypto2 = require("crypto");
+var DurableTaskNotFoundError = class extends Error {
+  static {
+    __name(this, "DurableTaskNotFoundError");
+  }
+  taskId;
+  constructor(taskId) {
+    super(`Durable task was not found: ${taskId}`), this.taskId = taskId;
+    this.name = "DurableTaskNotFoundError";
+  }
+};
+var UnsupportedDurableTaskKindError = class extends Error {
+  static {
+    __name(this, "UnsupportedDurableTaskKindError");
+  }
+  taskId;
+  kind;
+  constructor(taskId, kind) {
+    super(`No durable task handler is registered for kind: ${kind}`), this.taskId = taskId, this.kind = kind;
+    this.name = "UnsupportedDurableTaskKindError";
+  }
+};
+var DurableTaskNotClaimableError = class extends Error {
+  static {
+    __name(this, "DurableTaskNotClaimableError");
+  }
+  taskId;
+  status;
+  constructor(taskId, status2) {
+    super(`Durable task is not claimable: ${taskId} (${status2})`), this.taskId = taskId, this.status = status2;
+    this.name = "DurableTaskNotClaimableError";
+  }
+};
+var DurableTaskLeaseLostError = class extends Error {
+  static {
+    __name(this, "DurableTaskLeaseLostError");
+  }
+  taskId;
+  operation;
+  constructor(taskId, operation) {
+    super(`Durable task lease no longer owns ${operation}: ${taskId}`), this.taskId = taskId, this.operation = operation;
+    this.name = "DurableTaskLeaseLostError";
+  }
+};
+var DurableTaskRetryScheduledError = class extends Error {
+  static {
+    __name(this, "DurableTaskRetryScheduledError");
+  }
+  taskId;
+  taskError;
+  retryAt;
+  constructor(taskId, taskError2, retryAt) {
+    super(`Durable task retry was scheduled: ${taskId} (${taskError2.code})`), this.taskId = taskId, this.taskError = taskError2, this.retryAt = retryAt;
+    this.name = "DurableTaskRetryScheduledError";
+  }
+};
+var defaultHeartbeatScheduler = {
+  start(tick, intervalMs) {
+    const handle = setInterval(() => void tick(), intervalMs);
+    handle.unref?.();
+    return handle;
+  },
+  stop(handle) {
+    clearInterval(handle);
+  }
+};
+function terminalResult(task) {
+  return {
+    taskId: task.id,
+    kind: task.kind,
+    status: task.status
+  };
+}
+__name(terminalResult, "terminalResult");
+var DurableWorkerRuntime = class {
+  static {
+    __name(this, "DurableWorkerRuntime");
+  }
+  options;
+  repository;
+  retryPolicy;
+  workerId;
+  leaseDurationMs;
+  heartbeatIntervalMs;
+  maxConsecutiveHeartbeatFailures;
+  now;
+  createLeaseToken;
+  heartbeatScheduler;
+  constructor(options) {
+    this.options = options;
+    this.repository = options.repository;
+    this.retryPolicy = options.retryPolicy;
+    this.workerId = options.workerId;
+    this.leaseDurationMs = options.leaseDurationMs ?? 9e4;
+    this.heartbeatIntervalMs = options.heartbeatIntervalMs ?? 2e4;
+    this.maxConsecutiveHeartbeatFailures = options.maxConsecutiveHeartbeatFailures ?? 3;
+    this.now = options.now ?? (() => /* @__PURE__ */ new Date());
+    this.createLeaseToken = options.createLeaseToken ?? import_node_crypto2.randomUUID;
+    this.heartbeatScheduler = options.heartbeatScheduler ?? defaultHeartbeatScheduler;
+    if (!this.workerId.trim()) throw new RangeError("workerId cannot be empty");
+    if (this.leaseDurationMs < 1) throw new RangeError("leaseDurationMs must be positive");
+    if (this.heartbeatIntervalMs < 1) {
+      throw new RangeError("heartbeatIntervalMs must be positive");
+    }
+    if (this.heartbeatIntervalMs >= this.leaseDurationMs) {
+      throw new RangeError("heartbeatIntervalMs must be lower than leaseDurationMs");
+    }
+    if (this.maxConsecutiveHeartbeatFailures < 1) {
+      throw new RangeError("maxConsecutiveHeartbeatFailures must be at least 1");
+    }
+  }
+  async run(taskId) {
+    let task = await this.repository.findById(taskId);
+    if (!task) throw new DurableTaskNotFoundError(taskId);
+    if (isTerminalTaskStatus(task.status)) return terminalResult(task);
+    if (task.status === "RETRYING") {
+      const queued = await this.repository.transition({
+        id: task.id,
+        from: "RETRYING",
+        to: "QUEUED",
+        now: this.now()
+      });
+      if (!queued) {
+        const latest = await this.repository.findById(task.id);
+        if (latest && isTerminalTaskStatus(latest.status)) return terminalResult(latest);
+        throw new DurableTaskNotClaimableError(task.id, latest?.status ?? task.status);
+      }
+      task = queued;
+    }
+    if (task.status !== "QUEUED") {
+      throw new DurableTaskNotClaimableError(task.id, task.status);
+    }
+    const handler = this.options.resolveHandler(task);
+    if (!handler) throw new UnsupportedDurableTaskKindError(task.id, task.kind);
+    const leaseToken = this.createLeaseToken();
+    const claimedAt = this.now();
+    const claimed = await this.repository.claim({
+      id: task.id,
+      workerId: this.workerId,
+      leaseToken,
+      leaseExpiresAt: this.leaseExpiry(claimedAt),
+      now: claimedAt
+    });
+    if (!claimed) throw new DurableTaskNotClaimableError(task.id, task.status);
+    const controller = new AbortController();
+    let abortNotified = false;
+    let heartbeatFailures = 0;
+    let heartbeatInFlight = false;
+    const abortAttempt = /* @__PURE__ */ __name(async (operation) => {
+      if (controller.signal.aborted) return;
+      const reason = new DurableTaskLeaseLostError(claimed.id, operation);
+      controller.abort(reason);
+      if (abortNotified) return;
+      abortNotified = true;
+      try {
+        await this.options.onAbort?.(claimed, reason);
+      } catch {
+        this.options.logger?.warn?.("durable_task_abort_callback_failed", {
+          taskId: claimed.id,
+          kind: claimed.kind
+        });
+      }
+    }, "abortAttempt");
+    const renewLease = /* @__PURE__ */ __name(async () => {
+      const now = this.now();
+      return this.repository.heartbeat({
+        id: claimed.id,
+        leaseToken,
+        leaseExpiresAt: this.leaseExpiry(now),
+        now
+      });
+    }, "renewLease");
+    const heartbeat = /* @__PURE__ */ __name(async () => {
+      if (heartbeatInFlight || controller.signal.aborted) return;
+      heartbeatInFlight = true;
+      try {
+        const renewed = await renewLease();
+        if (!renewed) {
+          this.options.logger?.error?.("durable_task_lease_lost", {
+            taskId: claimed.id,
+            kind: claimed.kind
+          });
+          await abortAttempt("heartbeat");
+          return;
+        }
+        heartbeatFailures = 0;
+      } catch {
+        heartbeatFailures += 1;
+        this.options.logger?.warn?.("durable_task_heartbeat_failed", {
+          taskId: claimed.id,
+          kind: claimed.kind,
+          consecutiveFailures: heartbeatFailures
+        });
+        if (heartbeatFailures >= this.maxConsecutiveHeartbeatFailures) {
+          await abortAttempt("heartbeat");
+        }
+      } finally {
+        heartbeatInFlight = false;
+      }
+    }, "heartbeat");
+    const context = {
+      task: claimed,
+      leaseToken,
+      signal: controller.signal,
+      now: this.now,
+      assertActive: /* @__PURE__ */ __name(async () => {
+        let active;
+        try {
+          active = await renewLease();
+        } catch (error) {
+          await abortAttempt("active check");
+          throw error;
+        }
+        if (active) return;
+        await abortAttempt("active check");
+        throw new DurableTaskLeaseLostError(claimed.id, "active check");
+      }, "assertActive"),
+      reportProgress: /* @__PURE__ */ __name(async (stage, progress) => {
+        const updated = await this.repository.reportProgress({
+          id: claimed.id,
+          leaseToken,
+          stage,
+          progress,
+          now: this.now()
+        });
+        if (updated) return updated;
+        await abortAttempt("progress update");
+        throw new DurableTaskLeaseLostError(claimed.id, "progress update");
+      }, "reportProgress")
+    };
+    const heartbeatHandle = this.heartbeatScheduler.start(heartbeat, this.heartbeatIntervalMs);
+    try {
+      const result = await handler.execute(context);
+      if (controller.signal.aborted) {
+        throw controller.signal.reason instanceof Error ? controller.signal.reason : new DurableTaskLeaseLostError(claimed.id, "completion");
+      }
+      const completed = handler.complete ? await handler.complete(context, result) : Boolean(await this.repository.transition({
+        id: claimed.id,
+        from: "PROCESSING",
+        to: "COMPLETED",
+        leaseToken,
+        result,
+        now: this.now()
+      }));
+      if (!completed) return this.resolveRejectedCommit(claimed, "completion");
+      return {
+        taskId: claimed.id,
+        kind: claimed.kind,
+        status: "COMPLETED"
+      };
+    } catch (executionError) {
+      const latest = await this.findLatestBestEffort(claimed);
+      if (latest && isTerminalTaskStatus(latest.status)) {
+        if (latest.status === "CANCELLED") await handler.onCancelled?.(context);
+        return terminalResult(latest);
+      }
+      if (executionError instanceof DurableTaskRetryScheduledError) throw executionError;
+      if (controller.signal.aborted) {
+        throw controller.signal.reason instanceof Error ? controller.signal.reason : new DurableTaskLeaseLostError(claimed.id, "execution");
+      }
+      if (executionError instanceof DurableTaskLeaseLostError) throw executionError;
+      const taskError2 = this.options.classifyError(executionError, claimed);
+      const decision = this.retryPolicy.decide({
+        error: taskError2,
+        attempt: claimed.attempt,
+        maxAttempts: claimed.maxAttempts,
+        retryAfterMs: this.options.retryAfterMs?.(executionError, claimed)
+      });
+      if (decision.retry) {
+        const retryAt = new Date(this.now().getTime() + decision.delayMs);
+        const retried = handler.retry ? await handler.retry(context, taskError2, retryAt) : await this.retry(context, taskError2, retryAt);
+        if (!retried) return this.resolveRejectedCommit(claimed, "retry");
+        throw new DurableTaskRetryScheduledError(claimed.id, taskError2, retryAt);
+      }
+      const failed = handler.fail ? await handler.fail(context, taskError2) : Boolean(await this.repository.transition({
+        id: claimed.id,
+        from: "PROCESSING",
+        to: "FAILED",
+        leaseToken,
+        error: taskError2,
+        now: this.now()
+      }));
+      if (!failed) return this.resolveRejectedCommit(claimed, "failure");
+      return {
+        taskId: claimed.id,
+        kind: claimed.kind,
+        status: "FAILED"
+      };
+    } finally {
+      this.heartbeatScheduler.stop(heartbeatHandle);
+      try {
+        await handler.cleanup?.(context);
+      } catch {
+        this.options.logger?.warn?.("durable_task_cleanup_failed", {
+          taskId: claimed.id,
+          kind: claimed.kind
+        });
+      }
+    }
+  }
+  leaseExpiry(now) {
+    return new Date(now.getTime() + this.leaseDurationMs);
+  }
+  async retry(context, error, retryAt) {
+    const retrying = await this.repository.transition({
+      id: context.task.id,
+      from: "PROCESSING",
+      to: "RETRYING",
+      leaseToken: context.leaseToken,
+      error,
+      availableAt: retryAt,
+      now: this.now()
+    });
+    if (!retrying) return false;
+    return Boolean(await this.repository.transition({
+      id: context.task.id,
+      from: "RETRYING",
+      to: "QUEUED",
+      error,
+      availableAt: retryAt,
+      now: this.now()
+    }));
+  }
+  async resolveRejectedCommit(claimed, operation) {
+    const latest = await this.repository.findById(claimed.id);
+    if (latest && isTerminalTaskStatus(latest.status)) return terminalResult(latest);
+    throw new DurableTaskLeaseLostError(claimed.id, operation);
+  }
+  async findLatestBestEffort(claimed) {
+    try {
+      return await this.repository.findById(claimed.id);
+    } catch {
+      this.options.logger?.warn?.("durable_task_status_refresh_failed", {
+        taskId: claimed.id,
+        kind: claimed.kind
+      });
+      return null;
+    }
+  }
+};
+
+// src/in-memory-task-outbox.ts
+var import_node_util2 = require("util");
+function cloneRecord(record) {
+  return {
+    ...record,
+    availableAt: new Date(record.availableAt),
+    createdAt: new Date(record.createdAt),
+    updatedAt: new Date(record.updatedAt),
+    leaseExpiresAt: record.leaseExpiresAt ? new Date(record.leaseExpiresAt) : void 0,
+    publishedAt: record.publishedAt ? new Date(record.publishedAt) : void 0
+  };
+}
+__name(cloneRecord, "cloneRecord");
+var InMemoryTaskOutboxRepository = class {
+  static {
+    __name(this, "InMemoryTaskOutboxRepository");
+  }
+  records = /* @__PURE__ */ new Map();
+  async append(input) {
+    const existing = this.records.get(input.id);
+    if (existing) {
+      if (existing.taskId !== input.taskId || existing.topic !== input.topic || !(0, import_node_util2.isDeepStrictEqual)(existing.payload, input.payload)) {
+        throw new TaskOutboxConflictError(input.id);
+      }
+      return {
+        record: cloneRecord(existing),
+        created: false
+      };
+    }
+    const record = {
+      id: input.id,
+      taskId: input.taskId,
+      topic: input.topic,
+      payload: input.payload,
+      status: "PENDING",
+      attempt: 0,
+      availableAt: new Date(input.availableAt ?? input.now),
+      createdAt: new Date(input.now),
+      updatedAt: new Date(input.now)
+    };
+    this.records.set(record.id, record);
+    return {
+      record: cloneRecord(record),
+      created: true
+    };
+  }
+  async claimBatch(input) {
+    if (input.limit < 1) return [];
+    if (input.leaseExpiresAt.getTime() <= input.now.getTime()) return [];
+    const claimable = [
+      ...this.records.values()
+    ].filter((record) => {
+      if (record.availableAt.getTime() > input.now.getTime()) return false;
+      if (record.status === "PENDING") return true;
+      return record.status === "PUBLISHING" && Boolean(record.leaseExpiresAt && record.leaseExpiresAt.getTime() <= input.now.getTime());
+    }).sort((a, b) => a.createdAt.getTime() - b.createdAt.getTime()).slice(0, input.limit);
+    return claimable.map((record) => {
+      record.status = "PUBLISHING";
+      record.workerId = input.workerId;
+      record.leaseToken = input.leaseToken;
+      record.leaseExpiresAt = new Date(input.leaseExpiresAt);
+      record.attempt += 1;
+      record.updatedAt = new Date(input.now);
+      return cloneRecord(record);
+    });
+  }
+  async markPublished(id, leaseToken, now) {
+    const record = this.records.get(id);
+    if (!record || record.status !== "PUBLISHING" || record.leaseToken !== leaseToken || !record.leaseExpiresAt || record.leaseExpiresAt.getTime() <= now.getTime()) return false;
+    record.status = "PUBLISHED";
+    record.workerId = void 0;
+    record.leaseToken = void 0;
+    record.leaseExpiresAt = void 0;
+    record.publishedAt = new Date(now);
+    record.updatedAt = new Date(now);
+    record.lastError = void 0;
+    return true;
+  }
+  async reschedule(id, leaseToken, availableAt, errorSummary, now) {
+    const record = this.records.get(id);
+    if (!record || record.status !== "PUBLISHING" || record.leaseToken !== leaseToken || !record.leaseExpiresAt || record.leaseExpiresAt.getTime() <= now.getTime()) return false;
+    record.status = "PENDING";
+    record.workerId = void 0;
+    record.leaseToken = void 0;
+    record.leaseExpiresAt = void 0;
+    record.availableAt = new Date(availableAt);
+    record.updatedAt = new Date(now);
+    record.lastError = errorSummary;
+    return true;
+  }
+};
+
+// src/task-outbox-dispatcher.ts
+var TaskOutboxDispatcher = class {
+  static {
+    __name(this, "TaskOutboxDispatcher");
+  }
+  repository;
+  publisher;
+  options;
+  batchSize;
+  leaseDurationMs;
+  retryDelayMs;
+  now;
+  constructor(repository, publisher, options) {
+    this.repository = repository;
+    this.publisher = publisher;
+    this.options = options;
+    this.batchSize = options.batchSize ?? 100;
+    this.leaseDurationMs = options.leaseDurationMs ?? 3e4;
+    this.retryDelayMs = options.retryDelayMs ?? ((attempt) => Math.min(6e4, 1e3 * 2 ** (attempt - 1)));
+    this.now = options.now ?? (() => /* @__PURE__ */ new Date());
+    if (!options.workerId) throw new Error("workerId is required");
+    if (this.batchSize < 1) throw new RangeError("batchSize must be at least 1");
+    if (this.leaseDurationMs < 1) throw new RangeError("leaseDurationMs must be at least 1");
+  }
+  async runOnce() {
+    const claimedAt = this.now();
+    const leaseToken = this.options.createLeaseToken();
+    const messages = await this.repository.claimBatch({
+      workerId: this.options.workerId,
+      leaseToken,
+      leaseExpiresAt: new Date(claimedAt.getTime() + this.leaseDurationMs),
+      limit: this.batchSize,
+      now: claimedAt
+    });
+    const result = {
+      claimed: messages.length,
+      published: 0,
+      rescheduled: 0,
+      conflicts: 0
+    };
+    for (const message of messages) {
+      try {
+        await this.publisher.publish(message);
+        const marked = await this.repository.markPublished(message.id, leaseToken, this.now());
+        if (marked) result.published += 1;
+        else result.conflicts += 1;
+      } catch (error) {
+        const now = this.now();
+        const delayMs = Math.max(0, this.retryDelayMs(message.attempt));
+        const summary = error instanceof Error ? error.message : String(error);
+        const rescheduled = await this.repository.reschedule(message.id, leaseToken, new Date(now.getTime() + delayMs), summary.slice(0, 280), now);
+        if (rescheduled) result.rescheduled += 1;
+        else result.conflicts += 1;
+      }
+    }
+    return result;
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  DurableTaskLeaseLostError,
+  DurableTaskNotClaimableError,
+  DurableTaskNotFoundError,
+  DurableTaskRetryScheduledError,
+  DurableWorkerRuntime,
+  ExponentialTaskRetryPolicy,
+  InMemoryTaskOutboxRepository,
+  InMemoryTaskRepository,
+  InvalidTaskTransitionError,
+  PostgresTaskOutboxRepository,
+  PostgresTaskRedriver,
+  PostgresTaskRepository,
+  PostgresTaskSubmitter,
+  PostgresTaskSummaryReader,
+  PostgresTaskTimelineReader,
+  TASK_STATUSES,
+  TASK_TIMELINE_EVENT_TYPES,
+  TaskIdempotencyConflictError,
+  TaskLeaseReconciler,
+  TaskOutboxConflictError,
+  TaskOutboxDispatcher,
+  TaskQueueReconciler,
+  UnsupportedDurableTaskKindError,
+  assertTaskTransition,
+  canTransitionTask,
+  createTaskFingerprint,
+  isTerminalTaskStatus,
+  requiresTaskLease
+});