@fullstackhouse/open-mercato-durable-work 0.1.0

package/dist/core/store.js

@@ -0,0 +1,516 @@
+import {
+  LOCK_KEY_INDEX,
+  NO_ORG,
+  TABLE
+} from "./schema.js";
+import { LockKeyHeldError } from "./errors.js";
+const COLUMNS = `
+  id, tenant_id, organization_id, kind, status, created_by, created_at, updated_at,
+  input, checkpoint, meta,
+  idempotency_key, lock_key, subject_type, subject_id, progress_job_id,
+  lease_owner, lease_epoch, lease_expires_at, heartbeat_at,
+  queue_name, queue_job_id, continuation_seq, redrives, next_run_at, pending_since,
+  redrives_since_commit, consecutive_failures, interruptions, mirror_attempts, last_committed_at,
+  started_at, finished_at, parked_at, cancel_requested_at, cancelled_by,
+  error_class, error_code, error_message, domain_mirrored_at,
+  processed_count, total_count`;
+const num = (value) => typeof value === "number" ? value : Number(value ?? 0);
+const date = (value) => value == null ? null : value instanceof Date ? value : new Date(String(value));
+function mapRow(row) {
+  return {
+    id: String(row.id),
+    tenantId: String(row.tenant_id),
+    organizationId: row.organization_id == null ? null : String(row.organization_id),
+    kind: String(row.kind),
+    status: String(row.status),
+    createdBy: row.created_by == null ? null : String(row.created_by),
+    createdAt: date(row.created_at),
+    updatedAt: date(row.updated_at),
+    input: row.input ?? null,
+    checkpoint: row.checkpoint ?? null,
+    meta: row.meta ?? null,
+    idempotencyKey: row.idempotency_key == null ? null : String(row.idempotency_key),
+    lockKey: row.lock_key == null ? null : String(row.lock_key),
+    subjectType: row.subject_type == null ? null : String(row.subject_type),
+    subjectId: row.subject_id == null ? null : String(row.subject_id),
+    progressJobId: row.progress_job_id == null ? null : String(row.progress_job_id),
+    leaseOwner: row.lease_owner == null ? null : String(row.lease_owner),
+    leaseEpoch: num(row.lease_epoch),
+    leaseExpiresAt: date(row.lease_expires_at),
+    heartbeatAt: date(row.heartbeat_at),
+    queueName: row.queue_name == null ? null : String(row.queue_name),
+    queueJobId: row.queue_job_id == null ? null : String(row.queue_job_id),
+    continuationSeq: num(row.continuation_seq),
+    redrives: num(row.redrives),
+    nextRunAt: date(row.next_run_at),
+    pendingSince: date(row.pending_since),
+    redrivesSinceCommit: num(row.redrives_since_commit),
+    consecutiveFailures: num(row.consecutive_failures),
+    interruptions: num(row.interruptions),
+    mirrorAttempts: num(row.mirror_attempts),
+    lastCommittedAt: date(row.last_committed_at),
+    startedAt: date(row.started_at),
+    finishedAt: date(row.finished_at),
+    parkedAt: date(row.parked_at),
+    cancelRequestedAt: date(row.cancel_requested_at),
+    cancelledBy: row.cancelled_by == null ? null : String(row.cancelled_by),
+    errorClass: row.error_class == null ? null : String(row.error_class),
+    errorCode: row.error_code == null ? null : String(row.error_code),
+    errorMessage: row.error_message == null ? null : String(row.error_message),
+    domainMirroredAt: date(row.domain_mirrored_at),
+    processedCount: num(row.processed_count),
+    totalCount: row.total_count == null ? null : num(row.total_count)
+  };
+}
+const one = (result) => result.rows.length ? mapRow(result.rows[0]) : null;
+const SCOPE = `tenant_id = $2 and (organization_id = $3 or ($3::uuid is null and organization_id is null))`;
+function isUniqueViolation(error, index) {
+  const e = error;
+  if (!e || e.code !== "23505") return false;
+  if (typeof e.constraint === "string") return e.constraint === index;
+  return typeof e.message === "string" && e.message.includes(index);
+}
+async function insertJob(sql, id, scope, input, queueName) {
+  const params = [
+    id,
+    scope.tenantId,
+    scope.organizationId,
+    input.kind,
+    input.input ?? null,
+    input.meta ?? null,
+    input.idempotencyKey ?? null,
+    input.lockKey ?? null,
+    input.subject?.type ?? null,
+    input.subject?.id ?? null,
+    input.progressJobId ?? null,
+    input.createdBy ?? null,
+    queueName,
+    input.totalCount ?? null
+  ];
+  if (input.idempotencyKey) {
+    const existing = await findByIdempotencyKey(sql, scope, input.idempotencyKey);
+    if (existing) return { job: existing, created: false };
+  }
+  if (input.lockKey) {
+    const holder = await findLiveByLockKey(sql, scope, input.lockKey);
+    if (holder) throw new LockKeyHeldError(input.lockKey, holder.id);
+  }
+  try {
+    const inserted = await sql.query(
+      `insert into ${TABLE} (
+         id, tenant_id, organization_id, kind, status,
+         input, meta, idempotency_key, lock_key, subject_type, subject_id, progress_job_id,
+         created_by, queue_name, total_count, pending_since, created_at, updated_at
+       ) values (
+         $1, $2, $3, $4, 'pending',
+         $5::jsonb, $6::jsonb, $7, $8, $9, $10, $11,
+         $12, $13, $14, now(), now(), now()
+       ) returning ${COLUMNS}`,
+      params
+    );
+    return { job: mapRow(inserted.rows[0]), created: true };
+  } catch (error) {
+    if (input.lockKey && isUniqueViolation(error, LOCK_KEY_INDEX)) {
+      throw new LockKeyHeldError(input.lockKey);
+    }
+    throw error;
+  }
+}
+async function findByIdempotencyKey(sql, scope, key) {
+  return one(await sql.query(`select ${COLUMNS} from ${TABLE} where tenant_id = $1 and idempotency_key = $2`, [scope.tenantId, key]));
+}
+async function findLiveByLockKey(sql, scope, lockKey) {
+  return one(
+    await sql.query(
+      `select ${COLUMNS} from ${TABLE}
+        where lock_key = $1 and tenant_id = $2
+          and coalesce(organization_id, '${NO_ORG}'::uuid) = coalesce($3::uuid, '${NO_ORG}'::uuid)
+          and status in ('pending','running')
+        limit 1`,
+      [lockKey, scope.tenantId, scope.organizationId]
+    )
+  );
+}
+async function getJob(sql, id, scope) {
+  return one(await sql.query(`select ${COLUMNS} from ${TABLE} where id = $1 and ${SCOPE}`, [id, scope.tenantId, scope.organizationId]));
+}
+async function claim(sql, id, scope, delivery, owner, ttlMs) {
+  return one(
+    await sql.query(
+      `update ${TABLE}
+          set status = 'running',
+              lease_owner = $4,
+              lease_epoch = lease_epoch + 1,
+              lease_expires_at = now() + ($5::bigint * interval '1 millisecond'),
+              heartbeat_at = now(),
+              pending_since = null,
+              next_run_at = null,
+              started_at = coalesce(started_at, now()),
+              updated_at = now()
+        where id = $1 and ${SCOPE}
+          and status in ('pending','running')
+          and continuation_seq = $6 and redrives = $7
+          and (lease_expires_at is null or lease_expires_at < now())
+      returning ${COLUMNS}`,
+      [id, scope.tenantId, scope.organizationId, owner, ttlMs, delivery.seq, delivery.redrives]
+    )
+  );
+}
+async function heartbeat(sql, lease, patch = {}) {
+  const result = await sql.query(
+    `update ${TABLE}
+        set lease_expires_at = now() + ($4::bigint * interval '1 millisecond'),
+            heartbeat_at = now(),
+            processed_count = coalesce($5::int, processed_count),
+            total_count = case when $6::boolean then $7::int else total_count end,
+            consecutive_failures  = case when $8::boolean then 0 else consecutive_failures end,
+            redrives_since_commit = case when $8::boolean then 0 else redrives_since_commit end,
+            last_committed_at     = case when $8::boolean then now() else last_committed_at end
+      where id = $1 and status = 'running' and lease_owner = $2 and lease_epoch = $3
+    returning cancel_requested_at`,
+    [
+      lease.jobId,
+      lease.owner,
+      lease.epoch,
+      lease.ttlMs,
+      patch.processedCount ?? null,
+      // `totalCount: null` is a meaningful value ("unknown"), so presence and value are
+      // carried separately rather than collapsing both onto SQL NULL.
+      Object.prototype.hasOwnProperty.call(patch, "totalCount"),
+      patch.totalCount ?? null,
+      patch.committed === true
+    ]
+  );
+  if (!result.rows.length) return null;
+  return { cancelRequested: result.rows[0].cancel_requested_at != null };
+}
+async function assertLease(tx, lease) {
+  const result = await tx.query(
+    `select 1 from ${TABLE}
+      where id = $1 and status = 'running' and lease_owner = $2 and lease_epoch = $3
+      for update`,
+    [lease.jobId, lease.owner, lease.epoch]
+  );
+  return result.rows.length > 0;
+}
+async function writeCheckpoint(tx, lease, checkpoint, patch = {}) {
+  const result = await tx.query(
+    `update ${TABLE}
+        set checkpoint = $4::jsonb,
+            lease_expires_at = now() + ($5::bigint * interval '1 millisecond'),
+            heartbeat_at = now(),
+            processed_count = coalesce($6::int, processed_count),
+            total_count = case when $7::boolean then $8::int else total_count end,
+            consecutive_failures = 0,
+            redrives_since_commit = 0,
+            last_committed_at = now(),
+            updated_at = now()
+      where id = $1 and status = 'running' and lease_owner = $2 and lease_epoch = $3
+    returning id`,
+    [
+      lease.jobId,
+      lease.owner,
+      lease.epoch,
+      checkpoint ?? null,
+      lease.ttlMs,
+      patch.processedCount ?? null,
+      Object.prototype.hasOwnProperty.call(patch, "totalCount"),
+      patch.totalCount ?? null
+    ]
+  );
+  return result.rows.length > 0;
+}
+async function yieldSlice(sql, lease, opts) {
+  const result = await sql.query(
+    `update ${TABLE}
+        set status = 'pending',
+            continuation_seq = continuation_seq + 1,
+            interruptions = interruptions + case when $4::boolean then 1 else 0 end,
+            lease_owner = null,
+            lease_expires_at = now(),
+            pending_since = now(),
+            next_run_at = now(),
+            updated_at = now()
+      where id = $1 and status = 'running' and lease_owner = $2 and lease_epoch = $3
+    returning continuation_seq, redrives`,
+    [lease.jobId, lease.owner, lease.epoch, opts.interrupted]
+  );
+  if (!result.rows.length) return null;
+  return { seq: num(result.rows[0].continuation_seq), redrives: num(result.rows[0].redrives) };
+}
+async function failSlice(sql, lease, error, opts) {
+  const result = await sql.query(
+    `update ${TABLE}
+        set lease_owner = null,
+            lease_expires_at = now(),
+            next_run_at = case when $4::bigint is null then null else now() + ($4::bigint * interval '1 millisecond') end,
+            consecutive_failures = consecutive_failures + 1,
+            error_class = $5,
+            error_message = $6,
+            error_code = case
+              when $7::boolean then 'unrecoverable'
+              when consecutive_failures + 1 >= $8::int then 'retry_exhausted'
+              else $9 end,
+            updated_at = now()
+      where id = $1 and status = 'running' and lease_owner = $2 and lease_epoch = $3
+    returning consecutive_failures, error_code`,
+    [
+      lease.jobId,
+      lease.owner,
+      lease.epoch,
+      opts.nextAttemptDelayMs,
+      error.class,
+      error.message,
+      error.class === "unrecoverable",
+      opts.maxConsecutiveFailures,
+      error.code
+    ]
+  );
+  if (!result.rows.length) return null;
+  const code = result.rows[0].error_code;
+  const verdict = code === "unrecoverable" || code === "retry_exhausted" ? code : null;
+  return { consecutiveFailures: num(result.rows[0].consecutive_failures), verdict };
+}
+async function releaseLease(sql, lease, opts) {
+  return one(
+    await sql.query(
+      `update ${TABLE}
+          set lease_owner = null,
+              lease_expires_at = now(),
+              next_run_at = case when $4::bigint is null then null else now() + ($4::bigint * interval '1 millisecond') end,
+              updated_at = now()
+        where id = $1 and status = 'running' and lease_owner = $2 and lease_epoch = $3
+      returning ${COLUMNS}`,
+      [lease.jobId, lease.owner, lease.epoch, opts.nextAttemptDelayMs]
+    )
+  );
+}
+async function completeCas(tx, lease, patch = {}) {
+  return one(
+    await tx.query(
+      `update ${TABLE}
+          set status = 'completed', finished_at = now(), lease_owner = null, lease_expires_at = now(),
+              next_run_at = null, error_class = null, error_code = null, error_message = null,
+              processed_count = coalesce($3::int, processed_count),
+              total_count = coalesce($4::int, total_count),
+              updated_at = now()
+        where id = $1 and status = 'running' and lease_epoch = $2
+      returning ${COLUMNS}`,
+      [lease.jobId, lease.epoch, patch.processedCount ?? null, patch.totalCount ?? null]
+    )
+  );
+}
+async function failTerminalCas(tx, lease, verdict) {
+  return one(
+    await tx.query(
+      `update ${TABLE}
+          set status = 'failed', finished_at = now(), lease_owner = null, lease_expires_at = now(),
+              next_run_at = null, error_code = $3, error_class = $4,
+              error_message = coalesce($5, error_message), updated_at = now()
+        where id = $1 and status = 'running' and lease_epoch = $2
+      returning ${COLUMNS}`,
+      [lease.jobId, lease.epoch, verdict.code, verdict.class, verdict.message]
+    )
+  );
+}
+async function cancelCas(tx, lease) {
+  return one(
+    await tx.query(
+      `update ${TABLE}
+          set status = 'cancelled', finished_at = now(), lease_owner = null, lease_expires_at = now(),
+              next_run_at = null, updated_at = now()
+        where id = $1 and status = 'running' and lease_epoch = $2
+      returning ${COLUMNS}`,
+      [lease.jobId, lease.epoch]
+    )
+  );
+}
+async function markMirrored(tx, id) {
+  await tx.query(`update ${TABLE} set domain_mirrored_at = now() where id = $1`, [id]);
+}
+async function bumpMirrorAttempts(sql, id) {
+  const result = await sql.query(
+    `update ${TABLE} set mirror_attempts = mirror_attempts + 1, updated_at = now() where id = $1 returning mirror_attempts`,
+    [id]
+  );
+  return result.rows.length ? num(result.rows[0].mirror_attempts) : 0;
+}
+async function requestCancel(sql, id, scope, by) {
+  return one(
+    await sql.query(
+      `update ${TABLE}
+          set cancel_requested_at = coalesce(cancel_requested_at, now()), cancelled_by = coalesce(cancelled_by, $4), updated_at = now()
+        where id = $1 and ${SCOPE} and status in ('pending','running')
+      returning ${COLUMNS}`,
+      [id, scope.tenantId, scope.organizationId, by]
+    )
+  );
+}
+async function cancelPending(tx, id) {
+  return one(
+    await tx.query(
+      `update ${TABLE}
+          set status = 'cancelled', finished_at = now(), lease_owner = null, lease_expires_at = now(),
+              next_run_at = null, pending_since = null, updated_at = now()
+        where id = $1 and status = 'pending' and cancel_requested_at is not null
+      returning ${COLUMNS}`,
+      [id]
+    )
+  );
+}
+const REDRIVE_CORE = `status = 'pending', lease_owner = null, lease_epoch = lease_epoch + 1,
+  lease_expires_at = now(), redrives = redrives + 1, pending_since = now(), updated_at = now()`;
+async function takeOrphan(sql, id, opts) {
+  return one(
+    await sql.query(
+      `update ${TABLE}
+          set ${REDRIVE_CORE}, redrives_since_commit = redrives_since_commit + 1,
+              next_run_at = now() + ($4::bigint * interval '1 millisecond')
+        where id = $1 and status = 'running'
+          and lease_expires_at < now() - ($2::bigint * interval '1 millisecond')
+          and (next_run_at is null or next_run_at < now() - ($3::bigint * interval '1 millisecond'))
+          and cancel_requested_at is null
+          and (error_code is null or error_code not in ('unrecoverable','retry_exhausted'))
+      returning ${COLUMNS}`,
+      [id, opts.graceMs, opts.pendingTtlMs, opts.backoffMs]
+    )
+  );
+}
+async function redrivePending(sql, id, opts) {
+  return one(
+    await sql.query(
+      `update ${TABLE}
+          set ${REDRIVE_CORE}, redrives_since_commit = redrives_since_commit + 1, next_run_at = now()
+        where id = $1 and status = 'pending'
+          and cancel_requested_at is null
+          and greatest(pending_since, coalesce(next_run_at, pending_since)) < now() - ($2::bigint * interval '1 millisecond')
+      returning ${COLUMNS}`,
+      [id, opts.pendingTtlMs]
+    )
+  );
+}
+async function park(sql, id, reason, message) {
+  return one(
+    await sql.query(
+      `update ${TABLE}
+          set status = 'failed', parked_at = now(), finished_at = now(),
+              lease_owner = null, lease_expires_at = now(), next_run_at = null, pending_since = null,
+              error_code = $2, error_class = coalesce(error_class, 'terminal'),
+              error_message = coalesce($3, error_message), updated_at = now()
+        where id = $1 and status in ('pending','running')
+      returning ${COLUMNS}`,
+      [id, reason, message]
+    )
+  );
+}
+async function operatorRedrive(tx, id, scope, opts) {
+  return one(
+    await tx.query(
+      `update ${TABLE}
+          set ${REDRIVE_CORE}, redrives_since_commit = 0, consecutive_failures = 0, mirror_attempts = 0,
+              parked_at = null, error_code = null, error_class = null, finished_at = null,
+              domain_mirrored_at = null, cancel_requested_at = null, cancelled_by = null, next_run_at = now()
+        where id = $1 and ${SCOPE}
+          and ($6::boolean or error_code is distinct from 'unrecoverable')
+          and (status = 'failed'
+            or (status = 'running'
+                and lease_expires_at < now() - ($4::bigint * interval '1 millisecond')
+                and (next_run_at is null or next_run_at < now() - ($5::bigint * interval '1 millisecond'))))
+      returning ${COLUMNS}`,
+      [id, scope.tenantId, scope.organizationId, opts.graceMs, opts.pendingTtlMs, opts.force]
+    )
+  );
+}
+async function recordEnqueue(sql, id, queueJobId, queueName) {
+  await sql.query(`update ${TABLE} set queue_job_id = $2, queue_name = $3 where id = $1`, [id, queueJobId, queueName]);
+}
+const SKIP_LOCKED = "for update skip locked";
+async function selectCancelling(tx, limit, tenantId) {
+  const result = await tx.query(
+    `select ${COLUMNS} from ${TABLE}
+      where cancel_requested_at is not null and status in ('pending','running')
+        and ($2::uuid is null or tenant_id = $2)
+      order by cancel_requested_at asc limit $1 ${SKIP_LOCKED}`,
+    [limit, tenantId ?? null]
+  );
+  return result.rows.map(mapRow);
+}
+async function selectOrphans(tx, opts) {
+  const result = await tx.query(
+    `select ${COLUMNS} from ${TABLE}
+      where status = 'running'
+        and lease_expires_at < now() - ($1::bigint * interval '1 millisecond')
+        and (next_run_at is null or next_run_at < now() - ($2::bigint * interval '1 millisecond'))
+        and cancel_requested_at is null
+        and ($4::uuid is null or tenant_id = $4)
+      order by lease_expires_at asc limit $3 ${SKIP_LOCKED}`,
+    [opts.graceMs, opts.pendingTtlMs, opts.limit, opts.tenantId ?? null]
+  );
+  return result.rows.map(mapRow);
+}
+async function selectStalePending(tx, opts) {
+  const result = await tx.query(
+    `select ${COLUMNS} from ${TABLE}
+      where status = 'pending'
+        and cancel_requested_at is null
+        and greatest(pending_since, coalesce(next_run_at, pending_since)) < now() - ($1::bigint * interval '1 millisecond')
+        and ($3::uuid is null or tenant_id = $3)
+      order by pending_since asc limit $2 ${SKIP_LOCKED}`,
+    [opts.pendingTtlMs, opts.limit, opts.tenantId ?? null]
+  );
+  return result.rows.map(mapRow);
+}
+async function listJobs(sql, scope, filter = {}) {
+  const page = Math.max(1, filter.page ?? 1);
+  const pageSize = Math.min(200, Math.max(1, filter.pageSize ?? 20));
+  const where = ["tenant_id = $1 and (organization_id = $2 or ($2::uuid is null and organization_id is null))"];
+  const params = [scope.tenantId, scope.organizationId];
+  const push = (clause2, value) => {
+    params.push(value);
+    where.push(clause2.replace("$?", `$${params.length}`));
+  };
+  if (filter.kind) push("kind = $?", filter.kind);
+  if (filter.status) push("status = $?", filter.status);
+  if (filter.subject) {
+    push("subject_type = $?", filter.subject.type);
+    push("subject_id = $?", filter.subject.id);
+  }
+  const clause = where.join(" and ");
+  const total = await sql.query(`select count(*)::int as n from ${TABLE} where ${clause}`, params);
+  const items = await sql.query(
+    `select ${COLUMNS} from ${TABLE} where ${clause} order by created_at desc limit ${pageSize} offset ${(page - 1) * pageSize}`,
+    params
+  );
+  return { items: items.rows.map(mapRow), total: num(total.rows[0]?.n) };
+}
+export {
+  assertLease,
+  bumpMirrorAttempts,
+  cancelCas,
+  cancelPending,
+  claim,
+  completeCas,
+  failSlice,
+  failTerminalCas,
+  findByIdempotencyKey,
+  findLiveByLockKey,
+  getJob,
+  heartbeat,
+  insertJob,
+  listJobs,
+  mapRow,
+  markMirrored,
+  operatorRedrive,
+  park,
+  recordEnqueue,
+  redrivePending,
+  releaseLease,
+  requestCancel,
+  selectCancelling,
+  selectOrphans,
+  selectStalePending,
+  takeOrphan,
+  writeCheckpoint,
+  yieldSlice
+};
+//# sourceMappingURL=store.js.map

package/dist/core/store.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/core/store.ts"],
+  "sourcesContent": ["// Every statement that may write a job row lives here, and nowhere else.\n//\n// They are hand-written SQL rather than ORM calls because each one is a compare-and-set whose\n// WHERE clause *is* the guarantee \u2014 \"only the owner of epoch N may write this row\", \"only one\n// live job per lock key\". An ORM would put a translation layer between that predicate and the\n// person reviewing it, and these predicates are exactly what has to be reviewable.\n//\n// Two rules hold throughout:\n//   1. Time is the database's. A duration crosses the boundary; a worker-computed timestamp\n//      never does. A worker five minutes ahead of Postgres would otherwise push every\n//      reconciler predicate five minutes out.\n//   2. A verdict is decided inside the statement that has the row locked, from the row's\n//      current counters \u2014 never from a value the caller read earlier.\n\nimport {\n  LOCK_KEY_INDEX,\n  NO_ORG,\n  TABLE,\n} from './schema'\nimport { LockKeyHeldError } from './errors'\nimport type {\n  DurableJob,\n  DurableJobStatus,\n  ErrorClass,\n  Lease,\n  ParkReason,\n  Scope,\n  SqlExecutor,\n  SliceVerdict,\n  StartJobInput,\n} from './types'\n\n/** Selected by every statement that returns a row, so the mapper always sees every column. */\nconst COLUMNS = `\n  id, tenant_id, organization_id, kind, status, created_by, created_at, updated_at,\n  input, checkpoint, meta,\n  idempotency_key, lock_key, subject_type, subject_id, progress_job_id,\n  lease_owner, lease_epoch, lease_expires_at, heartbeat_at,\n  queue_name, queue_job_id, continuation_seq, redrives, next_run_at, pending_since,\n  redrives_since_commit, consecutive_failures, interruptions, mirror_attempts, last_committed_at,\n  started_at, finished_at, parked_at, cancel_requested_at, cancelled_by,\n  error_class, error_code, error_message, domain_mirrored_at,\n  processed_count, total_count`\n\ntype Row = Record<string, unknown>\n\nconst num = (value: unknown): number => (typeof value === 'number' ? value : Number(value ?? 0))\nconst date = (value: unknown): Date | null => (value == null ? null : value instanceof Date ? value : new Date(String(value)))\n\nexport function mapRow(row: Row): DurableJob {\n  return {\n    id: String(row.id),\n    tenantId: String(row.tenant_id),\n    organizationId: row.organization_id == null ? null : String(row.organization_id),\n    kind: String(row.kind),\n    status: String(row.status) as DurableJobStatus,\n    createdBy: row.created_by == null ? null : String(row.created_by),\n    createdAt: date(row.created_at)!,\n    updatedAt: date(row.updated_at)!,\n\n    input: row.input ?? null,\n    checkpoint: row.checkpoint ?? null,\n    meta: (row.meta ?? null) as Record<string, unknown> | null,\n\n    idempotencyKey: row.idempotency_key == null ? null : String(row.idempotency_key),\n    lockKey: row.lock_key == null ? null : String(row.lock_key),\n    subjectType: row.subject_type == null ? null : String(row.subject_type),\n    subjectId: row.subject_id == null ? null : String(row.subject_id),\n    progressJobId: row.progress_job_id == null ? null : String(row.progress_job_id),\n\n    leaseOwner: row.lease_owner == null ? null : String(row.lease_owner),\n    leaseEpoch: num(row.lease_epoch),\n    leaseExpiresAt: date(row.lease_expires_at),\n    heartbeatAt: date(row.heartbeat_at),\n\n    queueName: row.queue_name == null ? null : String(row.queue_name),\n    queueJobId: row.queue_job_id == null ? null : String(row.queue_job_id),\n    continuationSeq: num(row.continuation_seq),\n    redrives: num(row.redrives),\n    nextRunAt: date(row.next_run_at),\n    pendingSince: date(row.pending_since),\n\n    redrivesSinceCommit: num(row.redrives_since_commit),\n    consecutiveFailures: num(row.consecutive_failures),\n    interruptions: num(row.interruptions),\n    mirrorAttempts: num(row.mirror_attempts),\n    lastCommittedAt: date(row.last_committed_at),\n\n    startedAt: date(row.started_at),\n    finishedAt: date(row.finished_at),\n    parkedAt: date(row.parked_at),\n    cancelRequestedAt: date(row.cancel_requested_at),\n    cancelledBy: row.cancelled_by == null ? null : String(row.cancelled_by),\n    errorClass: row.error_class == null ? null : (String(row.error_class) as ErrorClass),\n    errorCode: row.error_code == null ? null : String(row.error_code),\n    errorMessage: row.error_message == null ? null : String(row.error_message),\n    domainMirroredAt: date(row.domain_mirrored_at),\n\n    processedCount: num(row.processed_count),\n    totalCount: row.total_count == null ? null : num(row.total_count),\n  }\n}\n\nconst one = (result: { rows: Row[] }): DurableJob | null => (result.rows.length ? mapRow(result.rows[0]!) : null)\n\n/** Scope predicate. A null organization matches only a null organization \u2014 it is a real value\n *  (\"tenant-wide\"), not a wildcard, and treating it as one would leak jobs across orgs. */\nconst SCOPE = `tenant_id = $2 and (organization_id = $3 or ($3::uuid is null and organization_id is null))`\n\nfunction isUniqueViolation(error: unknown, index: string): boolean {\n  const e = error as { code?: unknown; constraint?: unknown; message?: unknown } | null\n  if (!e || e.code !== '23505') return false\n  if (typeof e.constraint === 'string') return e.constraint === index\n  return typeof e.message === 'string' && e.message.includes(index)\n}\n\n// ---------------------------------------------------------------------------------------\n// Creation\n// ---------------------------------------------------------------------------------------\n\nexport type InsertResult = { job: DurableJob; created: boolean }\n\n/**\n * Inserts a job, or returns the existing one when `idempotencyKey` has been used before.\n *\n * Runs on the caller's executor so it can be part of their transaction: creating the domain\n * row and the job row together is the entire point of the transactional-start guarantee, and\n * an enqueue that happens before that transaction commits is a delivery for a job that may\n * never exist.\n */\nexport async function insertJob(\n  sql: SqlExecutor,\n  id: string,\n  scope: Scope,\n  input: StartJobInput,\n  queueName: string,\n): Promise<InsertResult> {\n  const params = [\n    id,\n    scope.tenantId,\n    scope.organizationId,\n    input.kind,\n    input.input ?? null,\n    input.meta ?? null,\n    input.idempotencyKey ?? null,\n    input.lockKey ?? null,\n    input.subject?.type ?? null,\n    input.subject?.id ?? null,\n    input.progressJobId ?? null,\n    input.createdBy ?? null,\n    queueName,\n    input.totalCount ?? null,\n  ]\n\n  // Checked before the insert, not after the violation.\n  //\n  // A failed statement aborts the whole transaction in Postgres \u2014 every subsequent command is\n  // refused until it ends. So a catch that queries for the existing job, or for the lock\n  // holder, works on an autocommit connection and fails on the caller's transaction, which is\n  // exactly where `start` is supposed to be called. The unique indexes are still the\n  // authority: they close the race between this check and the insert, and a violation that\n  // survives it is raised without touching the connection again.\n  if (input.idempotencyKey) {\n    const existing = await findByIdempotencyKey(sql, scope, input.idempotencyKey)\n    if (existing) return { job: existing, created: false }\n  }\n  if (input.lockKey) {\n    const holder = await findLiveByLockKey(sql, scope, input.lockKey)\n    if (holder) throw new LockKeyHeldError(input.lockKey, holder.id)\n  }\n\n  try {\n    const inserted = await sql.query<Row>(\n      `insert into ${TABLE} (\n         id, tenant_id, organization_id, kind, status,\n         input, meta, idempotency_key, lock_key, subject_type, subject_id, progress_job_id,\n         created_by, queue_name, total_count, pending_since, created_at, updated_at\n       ) values (\n         $1, $2, $3, $4, 'pending',\n         $5::jsonb, $6::jsonb, $7, $8, $9, $10, $11,\n         $12, $13, $14, now(), now(), now()\n       ) returning ${COLUMNS}`,\n      params,\n    )\n    return { job: mapRow(inserted.rows[0]!), created: true }\n  } catch (error) {\n    // Lost the race with a concurrent start. No further query is issued here \u2014 the transaction\n    // is aborted, so any lookup would fail with \"current transaction is aborted\" and bury the\n    // real cause. The holder's id is unavailable in this narrow case; the refusal is not.\n    if (input.lockKey && isUniqueViolation(error, LOCK_KEY_INDEX)) {\n      throw new LockKeyHeldError(input.lockKey)\n    }\n    throw error\n  }\n}\n\nexport async function findByIdempotencyKey(sql: SqlExecutor, scope: Scope, key: string): Promise<DurableJob | null> {\n  return one(await sql.query<Row>(`select ${COLUMNS} from ${TABLE} where tenant_id = $1 and idempotency_key = $2`, [scope.tenantId, key]))\n}\n\nexport async function findLiveByLockKey(sql: SqlExecutor, scope: Scope, lockKey: string): Promise<DurableJob | null> {\n  return one(\n    await sql.query<Row>(\n      `select ${COLUMNS} from ${TABLE}\n        where lock_key = $1 and tenant_id = $2\n          and coalesce(organization_id, '${NO_ORG}'::uuid) = coalesce($3::uuid, '${NO_ORG}'::uuid)\n          and status in ('pending','running')\n        limit 1`,\n      [lockKey, scope.tenantId, scope.organizationId],\n    ),\n  )\n}\n\nexport async function getJob(sql: SqlExecutor, id: string, scope: Scope): Promise<DurableJob | null> {\n  return one(await sql.query<Row>(`select ${COLUMNS} from ${TABLE} where id = $1 and ${SCOPE}`, [id, scope.tenantId, scope.organizationId]))\n}\n\n// ---------------------------------------------------------------------------------------\n// The lease\n// ---------------------------------------------------------------------------------------\n\n/**\n * Accepts one delivery and takes the lease.\n *\n * Refuses unless `(continuation_seq, redrives)` still match what the delivery carries \u2014 that\n * pair is the fence against a straggling redelivery of a slice that has already moved on.\n *\n * Reads no scheduled time. `next_run_at` is written on the database's clock but every delivery\n * that carries one was scheduled by the *transport's* clock, so a `next_run_at <= now()` clause\n * would refuse a retry that arrives a few milliseconds early and lose it permanently. Stale\n * deliveries are refused by identity alone.\n *\n * Writes `next_run_at = null`: the scheduled delivery is now consumed. Without that, a worker\n * SIGKILLed mid-slice would leave a timestamp for a delivery no broker holds, and the\n * reconciler would wait out the whole pending TTL instead of the much shorter lease grace.\n */\nexport async function claim(\n  sql: SqlExecutor,\n  id: string,\n  scope: Scope,\n  delivery: { seq: number; redrives: number },\n  owner: string,\n  ttlMs: number,\n): Promise<DurableJob | null> {\n  return one(\n    await sql.query<Row>(\n      `update ${TABLE}\n          set status = 'running',\n              lease_owner = $4,\n              lease_epoch = lease_epoch + 1,\n              lease_expires_at = now() + ($5::bigint * interval '1 millisecond'),\n              heartbeat_at = now(),\n              pending_since = null,\n              next_run_at = null,\n              started_at = coalesce(started_at, now()),\n              updated_at = now()\n        where id = $1 and ${SCOPE}\n          and status in ('pending','running')\n          and continuation_seq = $6 and redrives = $7\n          and (lease_expires_at is null or lease_expires_at < now())\n      returning ${COLUMNS}`,\n      [id, scope.tenantId, scope.organizationId, owner, ttlMs, delivery.seq, delivery.redrives],\n    ),\n  )\n}\n\nexport type HeartbeatPatch = { processedCount?: number; totalCount?: number | null; committed?: boolean }\n\n/**\n * Extends the lease and optionally records progress. Returns null when the lease is gone \u2014\n * the slice must then abort, because someone else now owns the job.\n *\n * `committed: true` means the slice durably committed a unit of work. That resets both\n * budgets: a job that is making progress has not earned any of the suspicion those counters\n * represent, however many times it was interrupted getting there.\n *\n * Touches no indexed column, so it stays a HOT update. That matters at the cadence a\n * multi-day run heartbeats at.\n */\nexport async function heartbeat(\n  sql: SqlExecutor,\n  lease: Lease,\n  patch: HeartbeatPatch = {},\n): Promise<{ cancelRequested: boolean } | null> {\n  const result = await sql.query<Row>(\n    `update ${TABLE}\n        set lease_expires_at = now() + ($4::bigint * interval '1 millisecond'),\n            heartbeat_at = now(),\n            processed_count = coalesce($5::int, processed_count),\n            total_count = case when $6::boolean then $7::int else total_count end,\n            consecutive_failures  = case when $8::boolean then 0 else consecutive_failures end,\n            redrives_since_commit = case when $8::boolean then 0 else redrives_since_commit end,\n            last_committed_at     = case when $8::boolean then now() else last_committed_at end\n      where id = $1 and status = 'running' and lease_owner = $2 and lease_epoch = $3\n    returning cancel_requested_at`,\n    [\n      lease.jobId,\n      lease.owner,\n      lease.epoch,\n      lease.ttlMs,\n      patch.processedCount ?? null,\n      // `totalCount: null` is a meaningful value (\"unknown\"), so presence and value are\n      // carried separately rather than collapsing both onto SQL NULL.\n      Object.prototype.hasOwnProperty.call(patch, 'totalCount'),\n      patch.totalCount ?? null,\n      patch.committed === true,\n    ],\n  )\n  if (!result.rows.length) return null\n  return { cancelRequested: result.rows[0]!.cancel_requested_at != null }\n}\n\n/**\n * Re-asserts the lease inside the caller's transaction.\n *\n * This is what makes `fencedWrite` a fence rather than a hope: the slice's domain writes and\n * this check commit or roll back together, so a worker whose lease expired mid-transaction\n * cannot land a write that outlives its right to make one.\n */\nexport async function assertLease(tx: SqlExecutor, lease: Lease): Promise<boolean> {\n  const result = await tx.query<Row>(\n    `select 1 from ${TABLE}\n      where id = $1 and status = 'running' and lease_owner = $2 and lease_epoch = $3\n      for update`,\n    [lease.jobId, lease.owner, lease.epoch],\n  )\n  return result.rows.length > 0\n}\n\n/** Records a checkpoint under the fence, and counts as a committed unit. */\nexport async function writeCheckpoint(\n  tx: SqlExecutor,\n  lease: Lease,\n  checkpoint: unknown,\n  patch: HeartbeatPatch = {},\n): Promise<boolean> {\n  const result = await tx.query<Row>(\n    `update ${TABLE}\n        set checkpoint = $4::jsonb,\n            lease_expires_at = now() + ($5::bigint * interval '1 millisecond'),\n            heartbeat_at = now(),\n            processed_count = coalesce($6::int, processed_count),\n            total_count = case when $7::boolean then $8::int else total_count end,\n            consecutive_failures = 0,\n            redrives_since_commit = 0,\n            last_committed_at = now(),\n            updated_at = now()\n      where id = $1 and status = 'running' and lease_owner = $2 and lease_epoch = $3\n    returning id`,\n    [\n      lease.jobId,\n      lease.owner,\n      lease.epoch,\n      checkpoint ?? null,\n      lease.ttlMs,\n      patch.processedCount ?? null,\n      Object.prototype.hasOwnProperty.call(patch, 'totalCount'),\n      patch.totalCount ?? null,\n    ],\n  )\n  return result.rows.length > 0\n}\n\n/**\n * Hands the remaining work back: the slice spent its budget or was asked to stop.\n *\n * Bumps `continuation_seq`, which invalidates the current delivery id and mints the next one.\n * Spends no retry attempt and touches no failure counter \u2014 yielding is the mechanism working,\n * not failing, and counting it would eventually park a perfectly healthy long job.\n */\nexport async function yieldSlice(\n  sql: SqlExecutor,\n  lease: Lease,\n  opts: { interrupted: boolean },\n): Promise<{ seq: number; redrives: number } | null> {\n  const result = await sql.query<Row>(\n    `update ${TABLE}\n        set status = 'pending',\n            continuation_seq = continuation_seq + 1,\n            interruptions = interruptions + case when $4::boolean then 1 else 0 end,\n            lease_owner = null,\n            lease_expires_at = now(),\n            pending_since = now(),\n            next_run_at = now(),\n            updated_at = now()\n      where id = $1 and status = 'running' and lease_owner = $2 and lease_epoch = $3\n    returning continuation_seq, redrives`,\n    [lease.jobId, lease.owner, lease.epoch, opts.interrupted],\n  )\n  if (!result.rows.length) return null\n  return { seq: num(result.rows[0]!.continuation_seq), redrives: num(result.rows[0]!.redrives) }\n}\n\n/**\n * The slice threw. Stays `running` and releases the lease so the transport's next attempt can\n * claim the same `(seq, redrives)`.\n *\n * The verdict is decided *here*, from the counter this statement increments \u2014 never from a\n * value read at claim time. A committed heartbeat earlier in this same slice reset\n * `consecutive_failures` to zero, and the CASE below sees that reset, so a slice that made\n * progress cannot be failed terminally on a stale count.\n */\nexport async function failSlice(\n  sql: SqlExecutor,\n  lease: Lease,\n  error: { message: string; code: string | null; class: ErrorClass },\n  opts: { nextAttemptDelayMs: number | null; maxConsecutiveFailures: number },\n): Promise<{ consecutiveFailures: number; verdict: SliceVerdict | null } | null> {\n  const result = await sql.query<Row>(\n    `update ${TABLE}\n        set lease_owner = null,\n            lease_expires_at = now(),\n            next_run_at = case when $4::bigint is null then null else now() + ($4::bigint * interval '1 millisecond') end,\n            consecutive_failures = consecutive_failures + 1,\n            error_class = $5,\n            error_message = $6,\n            error_code = case\n              when $7::boolean then 'unrecoverable'\n              when consecutive_failures + 1 >= $8::int then 'retry_exhausted'\n              else $9 end,\n            updated_at = now()\n      where id = $1 and status = 'running' and lease_owner = $2 and lease_epoch = $3\n    returning consecutive_failures, error_code`,\n    [\n      lease.jobId,\n      lease.owner,\n      lease.epoch,\n      opts.nextAttemptDelayMs,\n      error.class,\n      error.message,\n      error.class === 'unrecoverable',\n      opts.maxConsecutiveFailures,\n      error.code,\n    ],\n  )\n  if (!result.rows.length) return null\n  const code = result.rows[0]!.error_code\n  const verdict = code === 'unrecoverable' || code === 'retry_exhausted' ? (code as SliceVerdict) : null\n  return { consecutiveFailures: num(result.rows[0]!.consecutive_failures), verdict }\n}\n\n/**\n * Releases the lease without counting anything.\n *\n * Used when a terminal transaction rolled back while this delivery still held the lease. A\n * mirror failure is not a slice failure: counting it would burn the retry budget for something\n * the work itself did not do, and would clear a cancellation the operator is still waiting on.\n */\nexport async function releaseLease(\n  sql: SqlExecutor,\n  lease: Lease,\n  opts: { nextAttemptDelayMs: number | null },\n): Promise<DurableJob | null> {\n  return one(\n    await sql.query<Row>(\n      `update ${TABLE}\n          set lease_owner = null,\n              lease_expires_at = now(),\n              next_run_at = case when $4::bigint is null then null else now() + ($4::bigint * interval '1 millisecond') end,\n              updated_at = now()\n        where id = $1 and status = 'running' and lease_owner = $2 and lease_epoch = $3\n      returning ${COLUMNS}`,\n      [lease.jobId, lease.owner, lease.epoch, opts.nextAttemptDelayMs],\n    ),\n  )\n}\n\n// ---------------------------------------------------------------------------------------\n// Terminal transitions \u2014 run inside the terminal transaction (see terminal.ts)\n// ---------------------------------------------------------------------------------------\n\n/**\n * Fenced on the epoch alone, not on the owner.\n *\n * The fence has to match both of its callers' lease states: on the ordinary failure path\n * `failSlice` has already nulled `lease_owner`, while on the retry-of-a-verdict path the\n * claim re-acquired it. The epoch is what both have in common and is what actually identifies\n * the generation of the lease.\n */\nexport async function completeCas(tx: SqlExecutor, lease: Lease, patch: { processedCount?: number; totalCount?: number | null } = {}): Promise<DurableJob | null> {\n  return one(\n    await tx.query<Row>(\n      `update ${TABLE}\n          set status = 'completed', finished_at = now(), lease_owner = null, lease_expires_at = now(),\n              next_run_at = null, error_class = null, error_code = null, error_message = null,\n              processed_count = coalesce($3::int, processed_count),\n              total_count = coalesce($4::int, total_count),\n              updated_at = now()\n        where id = $1 and status = 'running' and lease_epoch = $2\n      returning ${COLUMNS}`,\n      [lease.jobId, lease.epoch, patch.processedCount ?? null, patch.totalCount ?? null],\n    ),\n  )\n}\n\nexport async function failTerminalCas(\n  tx: SqlExecutor,\n  lease: Lease,\n  verdict: { code: string; class: ErrorClass; message: string | null },\n): Promise<DurableJob | null> {\n  return one(\n    await tx.query<Row>(\n      `update ${TABLE}\n          set status = 'failed', finished_at = now(), lease_owner = null, lease_expires_at = now(),\n              next_run_at = null, error_code = $3, error_class = $4,\n              error_message = coalesce($5, error_message), updated_at = now()\n        where id = $1 and status = 'running' and lease_epoch = $2\n      returning ${COLUMNS}`,\n      [lease.jobId, lease.epoch, verdict.code, verdict.class, verdict.message],\n    ),\n  )\n}\n\nexport async function cancelCas(tx: SqlExecutor, lease: Lease): Promise<DurableJob | null> {\n  return one(\n    await tx.query<Row>(\n      `update ${TABLE}\n          set status = 'cancelled', finished_at = now(), lease_owner = null, lease_expires_at = now(),\n              next_run_at = null, updated_at = now()\n        where id = $1 and status = 'running' and lease_epoch = $2\n      returning ${COLUMNS}`,\n      [lease.jobId, lease.epoch],\n    ),\n  )\n}\n\n/** Marks the domain mirror as landed. Called inside the same transaction as the CAS above. */\nexport async function markMirrored(tx: SqlExecutor, id: string): Promise<void> {\n  await tx.query(`update ${TABLE} set domain_mirrored_at = now() where id = $1`, [id])\n}\n\n/**\n * Counts a failed mirror attempt.\n *\n * Deliberately its own autocommit statement, never part of the transaction it is counting \u2014\n * that transaction rolled back, and a counter written inside it would roll back with it,\n * leaving a job that retries its mirror forever with nothing to show for it.\n */\nexport async function bumpMirrorAttempts(sql: SqlExecutor, id: string): Promise<number> {\n  const result = await sql.query<Row>(\n    `update ${TABLE} set mirror_attempts = mirror_attempts + 1, updated_at = now() where id = $1 returning mirror_attempts`,\n    [id],\n  )\n  return result.rows.length ? num(result.rows[0]!.mirror_attempts) : 0\n}\n\n// ---------------------------------------------------------------------------------------\n// Cancellation\n// ---------------------------------------------------------------------------------------\n\n/** Records the intent. A running slice observes it at its next heartbeat; a pending job is\n *  ended by the reconciler. Cancellation is never a write to `status` from outside. */\nexport async function requestCancel(sql: SqlExecutor, id: string, scope: Scope, by: string | null): Promise<DurableJob | null> {\n  return one(\n    await sql.query<Row>(\n      `update ${TABLE}\n          set cancel_requested_at = coalesce(cancel_requested_at, now()), cancelled_by = coalesce(cancelled_by, $4), updated_at = now()\n        where id = $1 and ${SCOPE} and status in ('pending','running')\n      returning ${COLUMNS}`,\n      [id, scope.tenantId, scope.organizationId, by],\n    ),\n  )\n}\n\n/** Ends a job that was cancelled while it was not running. Used by the reconciler's cancel\n *  query, where there is no lease to fence on \u2014 the `pending` status is the fence. */\nexport async function cancelPending(tx: SqlExecutor, id: string): Promise<DurableJob | null> {\n  return one(\n    await tx.query<Row>(\n      `update ${TABLE}\n          set status = 'cancelled', finished_at = now(), lease_owner = null, lease_expires_at = now(),\n              next_run_at = null, pending_since = null, updated_at = now()\n        where id = $1 and status = 'pending' and cancel_requested_at is not null\n      returning ${COLUMNS}`,\n      [id],\n    ),\n  )\n}\n\n// ---------------------------------------------------------------------------------------\n// The re-drive family. Three statements, one core; they differ only in predicate and budget.\n// ---------------------------------------------------------------------------------------\n\nconst REDRIVE_CORE = `status = 'pending', lease_owner = null, lease_epoch = lease_epoch + 1,\n  lease_expires_at = now(), redrives = redrives + 1, pending_since = now(), updated_at = now()`\n\n/**\n * The reconciler takes an orphan: a running job whose driver stopped heartbeating.\n *\n * Two tolerances, deliberately different. `lease_expires_at` is a database-clock fact about a\n * driver, so a short grace suffices. `next_run_at` is when the *transport* makes a delivery\n * available, not when a worker picks it up \u2014 behind a busy queue that can be minutes \u2014 so a\n * scheduled delivery gets the same generous tolerance a pending job gets. Using the short\n * grace for both would take healthy jobs whose retry is merely queued, spend their orphan\n * budget, and park them as poison after a few busy periods.\n */\nexport async function takeOrphan(\n  sql: SqlExecutor,\n  id: string,\n  opts: { graceMs: number; pendingTtlMs: number; backoffMs: number },\n): Promise<DurableJob | null> {\n  return one(\n    await sql.query<Row>(\n      `update ${TABLE}\n          set ${REDRIVE_CORE}, redrives_since_commit = redrives_since_commit + 1,\n              next_run_at = now() + ($4::bigint * interval '1 millisecond')\n        where id = $1 and status = 'running'\n          and lease_expires_at < now() - ($2::bigint * interval '1 millisecond')\n          and (next_run_at is null or next_run_at < now() - ($3::bigint * interval '1 millisecond'))\n          and cancel_requested_at is null\n          and (error_code is null or error_code not in ('unrecoverable','retry_exhausted'))\n      returning ${COLUMNS}`,\n      [id, opts.graceMs, opts.pendingTtlMs, opts.backoffMs],\n    ),\n  )\n}\n\n/** Re-drives a pending job whose delivery was never picked up \u2014 a lost hand-back or an\n *  enqueue that never reached the broker. */\nexport async function redrivePending(sql: SqlExecutor, id: string, opts: { pendingTtlMs: number }): Promise<DurableJob | null> {\n  return one(\n    await sql.query<Row>(\n      `update ${TABLE}\n          set ${REDRIVE_CORE}, redrives_since_commit = redrives_since_commit + 1, next_run_at = now()\n        where id = $1 and status = 'pending'\n          and cancel_requested_at is null\n          and greatest(pending_since, coalesce(next_run_at, pending_since)) < now() - ($2::bigint * interval '1 millisecond')\n      returning ${COLUMNS}`,\n      [id, opts.pendingTtlMs],\n    ),\n  )\n}\n\n/** Parks a job the reconciler will not re-drive again. `failed` with a reason, and re-drivable\n *  only by an operator \u2014 which is the point: something needs a human before it runs again. */\nexport async function park(sql: SqlExecutor, id: string, reason: ParkReason, message: string | null): Promise<DurableJob | null> {\n  return one(\n    await sql.query<Row>(\n      `update ${TABLE}\n          set status = 'failed', parked_at = now(), finished_at = now(),\n              lease_owner = null, lease_expires_at = now(), next_run_at = null, pending_since = null,\n              error_code = $2, error_class = coalesce(error_class, 'terminal'),\n              error_message = coalesce($3, error_message), updated_at = now()\n        where id = $1 and status in ('pending','running')\n      returning ${COLUMNS}`,\n      [id, reason, message],\n    ),\n  )\n}\n\n/**\n * The operator's way out of `failed` \u2014 parked or terminal \u2014 and the manual take of an\n * expired lease.\n *\n * Resets both budgets, because an operator asking for a re-drive is explicitly asking for more\n * attempts. Does not reset `redrives`: that is identity, not budget, and a retained transport\n * job may still carry the old pair. Clears `cancel_requested_at` too, so a job that failed\n * before its slice ever observed the cancellation is not immediately cancelled again by the\n * re-driven slice's first heartbeat \u2014 the explicit re-drive supersedes the never-honoured\n * request.\n *\n * `completed` and `cancelled` are never re-drivable: the first is done, the second was asked\n * for. Start a new job instead.\n */\nexport async function operatorRedrive(\n  tx: SqlExecutor,\n  id: string,\n  scope: Scope,\n  opts: { graceMs: number; pendingTtlMs: number; force: boolean },\n): Promise<DurableJob | null> {\n  return one(\n    await tx.query<Row>(\n      `update ${TABLE}\n          set ${REDRIVE_CORE}, redrives_since_commit = 0, consecutive_failures = 0, mirror_attempts = 0,\n              parked_at = null, error_code = null, error_class = null, finished_at = null,\n              domain_mirrored_at = null, cancel_requested_at = null, cancelled_by = null, next_run_at = now()\n        where id = $1 and ${SCOPE}\n          and ($6::boolean or error_code is distinct from 'unrecoverable')\n          and (status = 'failed'\n            or (status = 'running'\n                and lease_expires_at < now() - ($4::bigint * interval '1 millisecond')\n                and (next_run_at is null or next_run_at < now() - ($5::bigint * interval '1 millisecond'))))\n      returning ${COLUMNS}`,\n      [id, scope.tenantId, scope.organizationId, opts.graceMs, opts.pendingTtlMs, opts.force],\n    ),\n  )\n}\n\n/** Records the delivery the transport accepted, so a later cancel can remove it. */\nexport async function recordEnqueue(sql: SqlExecutor, id: string, queueJobId: string, queueName: string): Promise<void> {\n  await sql.query(`update ${TABLE} set queue_job_id = $2, queue_name = $3 where id = $1`, [id, queueJobId, queueName])\n}\n\n// ---------------------------------------------------------------------------------------\n// Reconciler candidate selection\n// ---------------------------------------------------------------------------------------\n\n/** `for update skip locked` is what lets two reconcilers run at once: each takes a disjoint\n *  slice of the candidates rather than one blocking the other or both acting on the same row. */\nconst SKIP_LOCKED = 'for update skip locked'\n\n/** The reconciler is system-wide by default. The optional tenant filter exists so a fleet can\n *  shard the loop \u2014 one worker per tenant group \u2014 rather than having every worker scan every\n *  tenant's rows and skip-lock its way past them. */\nexport async function selectCancelling(tx: SqlExecutor, limit: number, tenantId?: string): Promise<DurableJob[]> {\n  const result = await tx.query<Row>(\n    `select ${COLUMNS} from ${TABLE}\n      where cancel_requested_at is not null and status in ('pending','running')\n        and ($2::uuid is null or tenant_id = $2)\n      order by cancel_requested_at asc limit $1 ${SKIP_LOCKED}`,\n    [limit, tenantId ?? null],\n  )\n  return result.rows.map(mapRow)\n}\n\nexport async function selectOrphans(\n  tx: SqlExecutor,\n  opts: { graceMs: number; pendingTtlMs: number; limit: number; tenantId?: string },\n): Promise<DurableJob[]> {\n  const result = await tx.query<Row>(\n    `select ${COLUMNS} from ${TABLE}\n      where status = 'running'\n        and lease_expires_at < now() - ($1::bigint * interval '1 millisecond')\n        and (next_run_at is null or next_run_at < now() - ($2::bigint * interval '1 millisecond'))\n        and cancel_requested_at is null\n        and ($4::uuid is null or tenant_id = $4)\n      order by lease_expires_at asc limit $3 ${SKIP_LOCKED}`,\n    [opts.graceMs, opts.pendingTtlMs, opts.limit, opts.tenantId ?? null],\n  )\n  return result.rows.map(mapRow)\n}\n\nexport async function selectStalePending(\n  tx: SqlExecutor,\n  opts: { pendingTtlMs: number; limit: number; tenantId?: string },\n): Promise<DurableJob[]> {\n  const result = await tx.query<Row>(\n    `select ${COLUMNS} from ${TABLE}\n      where status = 'pending'\n        and cancel_requested_at is null\n        and greatest(pending_since, coalesce(next_run_at, pending_since)) < now() - ($1::bigint * interval '1 millisecond')\n        and ($3::uuid is null or tenant_id = $3)\n      order by pending_since asc limit $2 ${SKIP_LOCKED}`,\n    [opts.pendingTtlMs, opts.limit, opts.tenantId ?? null],\n  )\n  return result.rows.map(mapRow)\n}\n\n// ---------------------------------------------------------------------------------------\n// Read side\n// ---------------------------------------------------------------------------------------\n\nexport type ListFilter = {\n  kind?: string\n  status?: DurableJobStatus\n  subject?: { type: string; id: string }\n  page?: number\n  pageSize?: number\n}\n\nexport async function listJobs(sql: SqlExecutor, scope: Scope, filter: ListFilter = {}): Promise<{ items: DurableJob[]; total: number }> {\n  const page = Math.max(1, filter.page ?? 1)\n  const pageSize = Math.min(200, Math.max(1, filter.pageSize ?? 20))\n  // Written out rather than reusing SCOPE: that constant is numbered for statements whose\n  // first parameter is the job id, and renumbering it by string replacement is precisely the\n  // kind of cleverness that silently changes a predicate.\n  const where: string[] = ['tenant_id = $1 and (organization_id = $2 or ($2::uuid is null and organization_id is null))']\n  const params: unknown[] = [scope.tenantId, scope.organizationId]\n  const push = (clause: string, value: unknown) => {\n    params.push(value)\n    where.push(clause.replace('$?', `$${params.length}`))\n  }\n  if (filter.kind) push('kind = $?', filter.kind)\n  if (filter.status) push('status = $?', filter.status)\n  if (filter.subject) {\n    push('subject_type = $?', filter.subject.type)\n    push('subject_id = $?', filter.subject.id)\n  }\n  const clause = where.join(' and ')\n  const total = await sql.query<Row>(`select count(*)::int as n from ${TABLE} where ${clause}`, params)\n  const items = await sql.query<Row>(\n    `select ${COLUMNS} from ${TABLE} where ${clause} order by created_at desc limit ${pageSize} offset ${(page - 1) * pageSize}`,\n    params,\n  )\n  return { items: items.rows.map(mapRow), total: num(total.rows[0]?.n) }\n}\n"],
+  "mappings": "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",
+  "names": ["clause"]
+}