@dudousxd/nestjs-durable-store-drizzle 0.20.0 → 0.22.0

package/dist/pg/index.d.ts

@@ -1,6 +1,6 @@
 import * as drizzle_orm_pg_core from 'drizzle-orm/pg-core';
 import { PgDatabase } from 'drizzle-orm/pg-core';
-import { StateStore, WorkflowRun, RetentionPolicy, StepCheckpoint, StoreTransaction, RunQuery, RunFacetQuery, RunFacetRow, RunValueAxis, RunValueFacetOptions, RunValueFacetRow, ScheduleRecord, ScheduleQuery, SignalWaiter, ChildWait } from '@dudousxd/nestjs-durable-core';
+import { StateStore, WorkflowRun, RunStatus, RetentionPolicy, StepCheckpoint, StoreTransaction, RunQuery, RunFacetQuery, RunFacetRow, RunValueAxis, RunValueFacetOptions, RunValueFacetRow, ScheduleRecord, ScheduleQuery, CheckpointStat, CheckpointQuery, SignalWaiter, ChildWait } from '@dudousxd/nestjs-durable-core';
 import { SQL } from 'drizzle-orm';
 
 /**
@@ -79,6 +79,7 @@ declare class DrizzlePgStateStore implements StateStore {
     tryAdmitSingleton(runId: string, tag: string, workflow: string, limit: number, retryWakeAt?: number): Promise<boolean>;
     createRun(run: WorkflowRun): Promise<void>;
     updateRun(runId: string, inputPatch: Partial<WorkflowRun>): Promise<void>;
+    updateRunIf(runId: string, expectedStatuses: RunStatus[], inputPatch: Partial<WorkflowRun>): Promise<boolean>;
     getRun(runId: string): Promise<WorkflowRun | null>;
     deleteRun(runId: string): Promise<void>;
     deleteRuns(runIds: string[]): Promise<void>;
@@ -86,9 +87,11 @@ declare class DrizzlePgStateStore implements StateStore {
     getCheckpoint(runId: string, seq: number): Promise<StepCheckpoint | null>;
     saveCheckpoint(checkpoint: StepCheckpoint): Promise<void>;
     saveCheckpointIfPending(checkpoint: StepCheckpoint): Promise<boolean>;
+    saveCheckpointsIfPending(checkpoints: StepCheckpoint[]): Promise<boolean[]>;
     transaction<T>(work: (tx: StoreTransaction) => Promise<T>): Promise<T>;
     /** Crash recovery. Namespace-scoped: a worker re-drives only its own tenant's runs. */
     listIncompleteRuns(namespace?: string): Promise<WorkflowRun[]>;
+    listOrphanedRuns(nowMs: number, limit: number, namespace?: string): Promise<WorkflowRun[]>;
     /** FIFO pick-up, served by `durable_workflow_runs_namespace_status_idx`. The engine then leases
      *  each run with {@link tryLockRun}; the listing itself takes no locks (it runs outside a tx). */
     listPendingRuns(limit: number, namespace?: string): Promise<WorkflowRun[]>;
@@ -118,6 +121,14 @@ declare class DrizzlePgStateStore implements StateStore {
     getLatestCheckpointByName(runId: string, name: string): Promise<StepCheckpoint | undefined>;
     countCheckpoints(runId: string, fromSeq: number, toSeq: number, statuses: StepCheckpoint['status'][]): Promise<number>;
     listCheckpointsByNamePrefix(runId: string, prefixes: string[]): Promise<StepCheckpoint[]>;
+    /** {@link StateStore.checkpointStats}: one `GROUP BY parallel_group, status, name_kind` over the
+     *  run's checkpoints, so a wide fan comes back as a few bucket rows instead of every member. */
+    checkpointStats(runId: string, opts?: {
+        group?: string | undefined;
+    }): Promise<CheckpointStat[]>;
+    /** {@link StateStore.queryCheckpoints}: the run's checkpoints narrowed in SQL, in `seq` order and
+     *  paged there, so reading one page of a wide fan never loads the rest of it. */
+    queryCheckpoints(runId: string, query: CheckpointQuery): Promise<StepCheckpoint[]>;
     putSignalWaiter(waiter: SignalWaiter): Promise<void>;
     takeSignalWaiter(token: string): Promise<SignalWaiter | null>;
     listSignalWaiters(prefix: string): Promise<SignalWaiter[]>;
@@ -159,6 +170,8 @@ interface DrizzlePgSqlExecutor {
 /** Turn a `$1`-placeholder SQL string + params into a parameterized drizzle `SQL` object, so it runs
  *  through whatever driver the drizzle db wraps (node-postgres, postgres-js, PGlite, Neon, …). */
 declare function toDrizzleSql(text: string, params?: unknown[]): SQL;
+/** node-postgres / PGlite hand back `{ rows }`; postgres-js hands back the row array itself. */
+declare function rowsOf<T>(result: unknown): T[];
 /**
  * Build a `DbTransport` executor from your drizzle Postgres db — the broker-less, DBOS-style
  * transport (remote steps as rows, claimed with `SELECT … FOR UPDATE SKIP LOCKED`) on the SAME
@@ -2384,4 +2397,4 @@ declare const durablePgSchema: {
  */
 declare function durablePgManagedTables(): string[];
 
-export { DEFAULT_NAMESPACE, DURABLE_PG_DDL, type DrizzlePgDatabase, type DrizzlePgSqlExecutor, DrizzlePgStateStore, type DrizzlePgStateStoreOptions, drizzlePgExecutor, durableBufferedEvents, durableBufferedSignals, durablePgManagedTables, durablePgSchema, durableRunAttributes, durableSchedules, durableSignalWaiters, durableStepCheckpoints, durableWorkflowRuns, ensureDrizzlePgDurableSchema, toDrizzleSql };
+export { DEFAULT_NAMESPACE, DURABLE_PG_DDL, type DrizzlePgDatabase, type DrizzlePgSqlExecutor, DrizzlePgStateStore, type DrizzlePgStateStoreOptions, drizzlePgExecutor, durableBufferedEvents, durableBufferedSignals, durablePgManagedTables, durablePgSchema, durableRunAttributes, durableSchedules, durableSignalWaiters, durableStepCheckpoints, durableWorkflowRuns, ensureDrizzlePgDurableSchema, rowsOf, toDrizzleSql };

package/dist/pg/index.js

@@ -86,6 +86,7 @@ var DURABLE_PG_DDL = [
   `CREATE INDEX IF NOT EXISTS "durable_workflow_runs_namespace_status_idx" ON "durable_workflow_runs" USING btree ("namespace","status","created_at")`,
   `CREATE INDEX IF NOT EXISTS "durable_runs_tags_gin_idx" ON "durable_workflow_runs" USING gin ("tags" jsonb_path_ops)`,
   `CREATE INDEX IF NOT EXISTS "durable_runs_status_updated_idx" ON "durable_workflow_runs" USING btree ("status","updated_at")`,
+  `CREATE INDEX IF NOT EXISTS "durable_step_checkpoints_group_idx" ON "durable_step_checkpoints" USING btree ("run_id","parallel_group","seq")`,
   `CREATE INDEX IF NOT EXISTS "durable_run_attributes_num_idx" ON "durable_run_attributes" USING btree ("key","num_value")`,
   `CREATE INDEX IF NOT EXISTS "durable_run_attributes_str_idx" ON "durable_run_attributes" USING btree ("key","str_value")`,
   `CREATE INDEX IF NOT EXISTS "durable_signal_waiters_run_id_idx" ON "durable_signal_waiters" USING btree ("run_id")`,
@@ -104,7 +105,39 @@ __name(ensureDrizzlePgDurableSchema, "ensureDrizzlePgDurableSchema");
 
 // src/pg/drizzle-pg-state-store.ts
 import { RUN_VALUE_FACET_SCAN, SINGLETON_ACTIVE_STATUSES, TERMINAL_RUN_STATUSES, attributePredicateOperands, axisIsRunColumn, clearTerminalSingletonAdmission, mergeRunFacetRows, mergeRunValueFacetRows, normalizeAttributeRows, parseDuration, runValueFacetsFromRuns, singletonAdmissionDenialPatch, singletonAdmissionTags } from "@dudousxd/nestjs-durable-core";
-import { and, asc, desc, eq, exists, getTableColumns, gte, inArray, isNotNull, isNull, like, lt, lte, or, sql as sql2 } from "drizzle-orm";
+import { and, asc, desc, eq, exists, getTableColumns, gte, inArray, isNotNull, isNull, like, lt, lte, notInArray, or, sql as sql3 } from "drizzle-orm";
+
+// src/pg/executor.ts
+import { sql as sql2 } from "drizzle-orm";
+function toDrizzleSql(text2, params = []) {
+  const chunks = [];
+  let last = 0;
+  for (const match of text2.matchAll(/\$(\d+)/g)) {
+    const index2 = Number(match[1]) - 1;
+    if (index2 < 0 || index2 >= params.length) throw new Error(`placeholder ${match[0]} has no bound parameter`);
+    chunks.push(sql2.raw(text2.slice(last, match.index)), sql2`${params[index2]}`);
+    last = (match.index ?? 0) + match[0].length;
+  }
+  chunks.push(sql2.raw(text2.slice(last)));
+  return sql2.join(chunks);
+}
+__name(toDrizzleSql, "toDrizzleSql");
+function rowsOf(result) {
+  if (Array.isArray(result)) return result;
+  return result?.rows ?? [];
+}
+__name(rowsOf, "rowsOf");
+function drizzlePgExecutor(db) {
+  return {
+    dialect: "postgres",
+    escapeId: /* @__PURE__ */ __name((id) => `"${id.replace(/"/g, '""')}"`, "escapeId"),
+    query: /* @__PURE__ */ __name(async (text2, params) => rowsOf(await db.execute(toDrizzleSql(text2, params))), "query"),
+    transaction: /* @__PURE__ */ __name((fn) => db.transaction((tx) => fn({
+      query: /* @__PURE__ */ __name(async (text2, params) => rowsOf(await tx.execute(toDrizzleSql(text2, params))), "query")
+    })), "transaction")
+  };
+}
+__name(drizzlePgExecutor, "drizzlePgExecutor");
 
 // src/pg/schema.ts
 import { getTableName } from "drizzle-orm";
@@ -182,7 +215,9 @@ var durableStepCheckpoints = pgTable(
         t.runId,
         t.seq
       ]
-    })
+    }),
+    // A run detail reads one fan at a time: checkpointStats / queryCheckpoints by group, seq-paged.
+    index("durable_step_checkpoints_group_idx").on(t.runId, t.parallelGroup, t.seq)
   ]
 );
 var durableRunAttributes = pgTable("durable_run_attributes", {
@@ -271,7 +306,7 @@ __name(durablePgManagedTables, "durablePgManagedTables");
 // src/pg/drizzle-pg-state-store.ts
 function anyOf(conditions) {
   const present = conditions.filter((c) => c !== void 0);
-  return present.length ? or(...present) : sql2`1 = 0`;
+  return present.length ? or(...present) : sql3`1 = 0`;
 }
 __name(anyOf, "anyOf");
 function namespaceFilter(namespace) {
@@ -279,7 +314,7 @@ function namespaceFilter(namespace) {
 }
 __name(namespaceFilter, "namespaceFilter");
 function hasTag(tag) {
-  return sql2`${durableWorkflowRuns.tags} @> ${JSON.stringify([
+  return sql3`${durableWorkflowRuns.tags} @> ${JSON.stringify([
     tag
   ])}::jsonb`;
 }
@@ -351,6 +386,22 @@ var DrizzlePgStateStore = class _DrizzlePgStateStore {
       if (reindex) await reindexAttributes(tx, runId, patch.searchAttributes);
     });
   }
+  async updateRunIf(runId, expectedStatuses, inputPatch) {
+    if (expectedStatuses.length === 0) return false;
+    const patch = inputPatch.status && TERMINAL_RUN_STATUSES.includes(inputPatch.status) ? await clearTerminalSingletonAdmission(runId, inputPatch, (id) => this.withScope({}).getRun(id)) : inputPatch;
+    const row = toRunPatch(patch);
+    const reindex = "searchAttributes" in patch;
+    const matches = and(eq(durableWorkflowRuns.id, runId), inArray(durableWorkflowRuns.status, expectedStatuses));
+    return this.db.transaction(async (tx) => {
+      const applied = Object.keys(row).length ? (await tx.update(durableWorkflowRuns).set(row).where(matches).returning({
+        id: durableWorkflowRuns.id
+      })).length === 1 : (await tx.select({
+        id: durableWorkflowRuns.id
+      }).from(durableWorkflowRuns).where(matches).for("update")).length === 1;
+      if (applied && reindex) await reindexAttributes(tx, runId, patch.searchAttributes);
+      return applied;
+    });
+  }
   async getRun(runId) {
     const rows = await this.db.select().from(durableWorkflowRuns).where(and(eq(durableWorkflowRuns.id, runId), this.scope())).limit(1);
     return rows[0] ? fromRunRow(rows[0]) : null;
@@ -420,6 +471,30 @@ var DrizzlePgStateStore = class _DrizzlePgStateStore {
     });
     return rows.length === 1;
   }
+  async saveCheckpointsIfPending(checkpoints) {
+    const wrote = checkpoints.map(() => false);
+    if (checkpoints.length === 0) return wrote;
+    await this.db.transaction(async (tx) => {
+      for (const round of distinctRounds(checkpoints)) {
+        for (let at = 0; at < round.length; at += CHECKPOINT_BATCH_ROWS) {
+          const chunk = round.slice(at, at + CHECKPOINT_BATCH_ROWS);
+          const updated = rowsOf(await tx.execute(updateIfPendingFrom(chunk.map((i) => checkpoints[i]))));
+          const byKey = new Map(chunk.map((i) => [
+            rowKey(checkpoints[i]),
+            i
+          ]));
+          for (const row of updated) {
+            const i = byKey.get(rowKey({
+              runId: row.run_id,
+              seq: Number(row.seq)
+            }));
+            if (i !== void 0) wrote[i] = true;
+          }
+        }
+      }
+    });
+    return wrote;
+  }
   async transaction(work) {
     return this.db.transaction(async (tx) => work({
       raw: tx,
@@ -434,6 +509,14 @@ var DrizzlePgStateStore = class _DrizzlePgStateStore {
     ]), namespaceFilter(namespace), this.scope()));
     return rows.map(fromRunRow);
   }
+  async listOrphanedRuns(nowMs, limit, namespace) {
+    if (limit <= 0) return [];
+    const rows = await this.db.select().from(durableWorkflowRuns).where(and(inArray(durableWorkflowRuns.status, [
+      "running",
+      "cancelling"
+    ]), or(isNull(durableWorkflowRuns.lockedUntil), lte(durableWorkflowRuns.lockedUntil, new Date(nowMs))), namespaceFilter(namespace), this.scope())).orderBy(asc(durableWorkflowRuns.createdAt)).limit(limit);
+    return rows.map(fromRunRow);
+  }
   /** FIFO pick-up, served by `durable_workflow_runs_namespace_status_idx`. The engine then leases
   *  each run with {@link tryLockRun}; the listing itself takes no locks (it runs outside a tx). */
   async listPendingRuns(limit, namespace) {
@@ -473,16 +556,16 @@ var DrizzlePgStateStore = class _DrizzlePgStateStore {
     return [
       this.scope(),
       query.workflow ? eq(durableWorkflowRuns.workflow, query.workflow) : void 0,
-      query.workflows ? query.workflows.length ? inArray(durableWorkflowRuns.workflow, query.workflows) : sql2`1 = 0` : void 0,
+      query.workflows ? query.workflows.length ? inArray(durableWorkflowRuns.workflow, query.workflows) : sql3`1 = 0` : void 0,
       // The tenant boundary. Also the engine's execution-timeout sweep path
       // (`listRuns({ workflow, status, namespace })`) — unscoped, it would cancel another tenant's runs.
       namespaceFilter(query.namespace),
-      query.namespaces ? query.namespaces.length ? inArray(durableWorkflowRuns.namespace, query.namespaces) : sql2`1 = 0` : void 0,
+      query.namespaces ? query.namespaces.length ? inArray(durableWorkflowRuns.namespace, query.namespaces) : sql3`1 = 0` : void 0,
       // `null` selects the unattributed bucket; a value never matches a NULL origin.
       query.origin === null ? isNull(durableWorkflowRuns.origin) : query.origin !== void 0 ? eq(durableWorkflowRuns.origin, query.origin) : void 0,
       query.origins ? anyOf(query.origins.map((o) => o === null ? isNull(durableWorkflowRuns.origin) : eq(durableWorkflowRuns.origin, o))) : void 0,
       query.status ? eq(durableWorkflowRuns.status, query.status) : void 0,
-      query.statuses ? query.statuses.length ? inArray(durableWorkflowRuns.status, query.statuses) : sql2`1 = 0` : void 0,
+      query.statuses ? query.statuses.length ? inArray(durableWorkflowRuns.status, query.statuses) : sql3`1 = 0` : void 0,
       query.tag ? hasTag(query.tag) : void 0,
       query.tags ? anyOf(query.tags.map(hasTag)) : void 0,
       // One EXISTS per attribute predicate against the normalized side table (ANDed).
@@ -500,7 +583,7 @@ var DrizzlePgStateStore = class _DrizzlePgStateStore {
   async countRuns(query) {
     const filters = this.runFilters(query);
     const rows = await this.db.select({
-      count: sql2`count(*)`.mapWith(Number)
+      count: sql3`count(*)`.mapWith(Number)
     }).from(durableWorkflowRuns).where(filters.length ? and(...filters) : void 0);
     return rows[0]?.count ?? 0;
   }
@@ -509,7 +592,7 @@ var DrizzlePgStateStore = class _DrizzlePgStateStore {
     const rows = await this.db.select({
       status: durableWorkflowRuns.status,
       origin: durableWorkflowRuns.origin,
-      count: sql2`count(*)`.mapWith(Number)
+      count: sql3`count(*)`.mapWith(Number)
     }).from(durableWorkflowRuns).where(filters.length ? and(...filters) : void 0).groupBy(durableWorkflowRuns.status, durableWorkflowRuns.origin);
     return mergeRunFacetRows(rows.map((r) => ({
       status: r.status,
@@ -531,7 +614,7 @@ var DrizzlePgStateStore = class _DrizzlePgStateStore {
     const filters = this.runFilters(query);
     const rows = await this.db.select({
       value: column,
-      count: sql2`count(*)`.mapWith(Number)
+      count: sql3`count(*)`.mapWith(Number)
     }).from(durableWorkflowRuns).where(filters.length ? and(...filters) : void 0).groupBy(column);
     return mergeRunValueFacetRows(rows.map((r) => ({
       value: r.value ?? null,
@@ -542,9 +625,9 @@ var DrizzlePgStateStore = class _DrizzlePgStateStore {
   *  excludes runs lacking the key (EXISTS requires the row). Numbers compare `num_value`, strings
   *  and booleans `str_value`; an `in` set ORs its members inside the one EXISTS. */
   attributeExists(f) {
-    const comparisons = attributePredicateOperands(f).map(({ column, comparator, operand }) => sql2`${column === "numValue" ? durableRunAttributes.numValue : durableRunAttributes.strValue} ${sql2.raw(comparator)} ${operand}`);
+    const comparisons = attributePredicateOperands(f).map(({ column, comparator, operand }) => sql3`${column === "numValue" ? durableRunAttributes.numValue : durableRunAttributes.strValue} ${sql3.raw(comparator)} ${operand}`);
     return exists(this.db.select({
-      one: sql2`1`
+      one: sql3`1`
     }).from(durableRunAttributes).where(and(eq(durableRunAttributes.runId, durableWorkflowRuns.id), eq(durableRunAttributes.key, f.key), anyOf(comparisons))));
   }
   // ---- persisted schedules ----------------------------------------------------------------------
@@ -575,9 +658,9 @@ var DrizzlePgStateStore = class _DrizzlePgStateStore {
     return rows.length > 0;
   }
   async listSchedules(query) {
-    const base = this.db.select().from(durableSchedules).where(and(query.namespace !== void 0 ? eq(durableSchedules.namespace, query.namespace) : void 0, query.workflow !== void 0 ? eq(durableSchedules.workflow, query.workflow) : void 0, query.paused !== void 0 ? eq(durableSchedules.paused, query.paused) : void 0, query.tag !== void 0 ? sql2`${durableSchedules.tags} @> ${JSON.stringify([
+    const base = this.db.select().from(durableSchedules).where(and(query.namespace !== void 0 ? eq(durableSchedules.namespace, query.namespace) : void 0, query.workflow !== void 0 ? eq(durableSchedules.workflow, query.workflow) : void 0, query.paused !== void 0 ? eq(durableSchedules.paused, query.paused) : void 0, query.tag !== void 0 ? sql3`${durableSchedules.tags} @> ${JSON.stringify([
       query.tag
-    ])}::jsonb` : void 0, query.dueBy !== void 0 ? and(eq(durableSchedules.paused, false), lte(durableSchedules.nextFireAt, new Date(query.dueBy))) : void 0)).orderBy(sql2`${durableSchedules.nextFireAt} ASC NULLS LAST`, asc(durableSchedules.id)).$dynamic();
+    ])}::jsonb` : void 0, query.dueBy !== void 0 ? and(eq(durableSchedules.paused, false), lte(durableSchedules.nextFireAt, new Date(query.dueBy))) : void 0)).orderBy(sql3`${durableSchedules.nextFireAt} ASC NULLS LAST`, asc(durableSchedules.id)).$dynamic();
     if (query.limit != null) base.limit(query.limit);
     if (query.offset != null) base.offset(query.offset);
     return (await base).map(fromScheduleRow);
@@ -593,7 +676,7 @@ var DrizzlePgStateStore = class _DrizzlePgStateStore {
   async countCheckpoints(runId, fromSeq, toSeq, statuses) {
     if (statuses.length === 0) return 0;
     const rows = await this.db.select({
-      count: sql2`count(*)`.mapWith(Number)
+      count: sql3`count(*)`.mapWith(Number)
     }).from(durableStepCheckpoints).where(and(eq(durableStepCheckpoints.runId, runId), gte(durableStepCheckpoints.seq, fromSeq), lte(durableStepCheckpoints.seq, toSeq), inArray(durableStepCheckpoints.status, statuses)));
     return rows[0]?.count ?? 0;
   }
@@ -602,6 +685,53 @@ var DrizzlePgStateStore = class _DrizzlePgStateStore {
     const rows = await this.db.select().from(durableStepCheckpoints).where(and(eq(durableStepCheckpoints.runId, runId), or(...prefixes.map((p) => like(durableStepCheckpoints.name, `${escapeLike(p)}%`))))).orderBy(asc(durableStepCheckpoints.seq));
     return rows.map(fromCheckpointRow);
   }
+  /** {@link StateStore.checkpointStats}: one `GROUP BY parallel_group, status, name_kind` over the
+  *  run's checkpoints, so a wide fan comes back as a few bucket rows instead of every member. */
+  async checkpointStats(runId, opts) {
+    const c = durableStepCheckpoints;
+    const nameKind = sql3`CASE
+      WHEN ${c.name} LIKE 'signal:child:%' THEN 'child'
+      WHEN ${c.name} LIKE 'fan:%' THEN 'folded'
+      WHEN ${c.name} LIKE 'spawn:%' THEN 'spawn'
+      ELSE 'step' END`.as("name_kind");
+    const rows = await this.db.select({
+      group: c.parallelGroup,
+      status: c.status,
+      nameKind,
+      count: sql3`count(*)`.mapWith(Number),
+      minSeq: sql3`min(${c.seq})`.mapWith(Number),
+      maxSeq: sql3`max(${c.seq})`.mapWith(Number),
+      minName: sql3`min(${c.name})`,
+      maxName: sql3`max(${c.name})`,
+      minEnqueuedAt: sql3`min(coalesce(${c.enqueuedAt}, ${c.startedAt}))`.mapWith(c.startedAt),
+      minStartedAt: sql3`min(${c.startedAt})`.mapWith(c.startedAt),
+      maxStartedAt: sql3`max(${c.startedAt})`.mapWith(c.startedAt),
+      maxFinishedAt: sql3`max(${c.finishedAt})`.mapWith(c.finishedAt),
+      sumAttempts: sql3`sum(${c.attempts})`.mapWith(Number)
+    }).from(c).where(and(eq(c.runId, runId), opts?.group !== void 0 ? eq(c.parallelGroup, opts.group) : void 0)).groupBy(c.parallelGroup, c.status, sql3`name_kind`);
+    return rows.map((r) => ({
+      ...r,
+      group: r.group ?? null,
+      status: r.status
+    }));
+  }
+  /** {@link StateStore.queryCheckpoints}: the run's checkpoints narrowed in SQL, in `seq` order and
+  *  paged there, so reading one page of a wide fan never loads the rest of it. */
+  async queryCheckpoints(runId, query) {
+    if (query.statuses?.length === 0 || query.namePrefixes?.length === 0) return [];
+    const c = durableStepCheckpoints;
+    const base = this.db.select().from(c).where(and(
+      eq(c.runId, runId),
+      query.group !== void 0 ? eq(c.parallelGroup, query.group) : void 0,
+      // `NOT IN` is never true for a NULL group, so ungrouped rows are kept explicitly.
+      query.excludeGroups?.length ? or(isNull(c.parallelGroup), notInArray(c.parallelGroup, query.excludeGroups)) : void 0,
+      query.statuses ? inArray(c.status, query.statuses) : void 0,
+      query.namePrefixes ? or(...query.namePrefixes.map((p) => like(c.name, `${escapeLike(p)}%`))) : void 0
+    )).orderBy(asc(c.seq)).$dynamic();
+    if (query.limit != null) base.limit(query.limit);
+    if (query.offset != null) base.offset(query.offset);
+    return (await base).map(fromCheckpointRow);
+  }
   async putSignalWaiter(waiter) {
     const set = {
       runId: waiter.runId,
@@ -717,6 +847,41 @@ function escapeLike(value) {
   return value.replace(/[\\%_]/g, (c) => `\\${c}`);
 }
 __name(escapeLike, "escapeLike");
+var CHECKPOINT_BATCH_ROWS = 500;
+var rowKey = /* @__PURE__ */ __name((cp) => `${cp.seq}:${cp.runId}`, "rowKey");
+function distinctRounds(checkpoints) {
+  const rounds = [];
+  const seen = /* @__PURE__ */ new Map();
+  checkpoints.forEach((cp, i) => {
+    const key = rowKey(cp);
+    const round = seen.get(key) ?? 0;
+    seen.set(key, round + 1);
+    const indexes = rounds[round] ?? [];
+    rounds[round] = indexes;
+    indexes.push(i);
+  });
+  return rounds;
+}
+__name(distinctRounds, "distinctRounds");
+function updateIfPendingFrom(checkpoints) {
+  const json = /* @__PURE__ */ __name((v) => v == null ? null : JSON.stringify(v), "json");
+  const ts = /* @__PURE__ */ __name((v) => v == null ? null : v.toISOString(), "ts");
+  const values = checkpoints.map((cp) => {
+    const r = toCheckpointRow(cp);
+    return sql3`(${r.runId}::text, ${r.seq}::integer, ${r.name}::text, ${r.kind}::text, ${r.stepId}::text, ${r.status}::text, ${json(r.input)}::jsonb, ${json(r.output)}::jsonb, ${json(r.error)}::jsonb, ${json(r.events)}::jsonb, ${r.attempts}::integer, ${r.workerGroup}::text, ${r.parallelGroup}::text, ${ts(r.wakeAt)}::timestamptz, ${ts(r.enqueuedAt)}::timestamptz, ${ts(r.startedAt)}::timestamptz, ${ts(r.finishedAt)}::timestamptz)`;
+  });
+  return sql3`UPDATE ${durableStepCheckpoints} AS c SET
+    name = v.name, kind = v.kind, step_id = v.step_id, status = v.status, input = v.input,
+    output = v.output, error = v.error, events = v.events, attempts = v.attempts,
+    worker_group = v.worker_group, parallel_group = v.parallel_group, wake_at = v.wake_at,
+    enqueued_at = v.enqueued_at, started_at = v.started_at, finished_at = v.finished_at
+  FROM (VALUES ${sql3.join(values, sql3`, `)}) AS v(run_id, seq, name, kind, step_id, status, input,
+    output, error, events, attempts, worker_group, parallel_group, wake_at, enqueued_at, started_at,
+    finished_at)
+  WHERE c.run_id = v.run_id AND c.seq = v.seq AND c.status = 'pending'
+  RETURNING c.run_id, c.seq`;
+}
+__name(updateIfPendingFrom, "updateIfPendingFrom");
 async function upsertCheckpoint(db, cp) {
   const row = toCheckpointRow(cp);
   await db.insert(durableStepCheckpoints).values(row).onConflictDoUpdate({
@@ -914,42 +1079,10 @@ __name(fromScheduleRow, "fromScheduleRow");
 function excludedSet(table, only) {
   return Object.fromEntries(Object.entries(getTableColumns(table)).filter(([key]) => !only || only.includes(key)).map(([key, column]) => [
     key,
-    sql2.raw(`excluded."${column.name}"`)
+    sql3.raw(`excluded."${column.name}"`)
   ]));
 }
 __name(excludedSet, "excludedSet");
-
-// src/pg/executor.ts
-import { sql as sql3 } from "drizzle-orm";
-function toDrizzleSql(text2, params = []) {
-  const chunks = [];
-  let last = 0;
-  for (const match of text2.matchAll(/\$(\d+)/g)) {
-    const index2 = Number(match[1]) - 1;
-    if (index2 < 0 || index2 >= params.length) throw new Error(`placeholder ${match[0]} has no bound parameter`);
-    chunks.push(sql3.raw(text2.slice(last, match.index)), sql3`${params[index2]}`);
-    last = (match.index ?? 0) + match[0].length;
-  }
-  chunks.push(sql3.raw(text2.slice(last)));
-  return sql3.join(chunks);
-}
-__name(toDrizzleSql, "toDrizzleSql");
-function rowsOf(result) {
-  if (Array.isArray(result)) return result;
-  return result?.rows ?? [];
-}
-__name(rowsOf, "rowsOf");
-function drizzlePgExecutor(db) {
-  return {
-    dialect: "postgres",
-    escapeId: /* @__PURE__ */ __name((id) => `"${id.replace(/"/g, '""')}"`, "escapeId"),
-    query: /* @__PURE__ */ __name(async (text2, params) => rowsOf(await db.execute(toDrizzleSql(text2, params))), "query"),
-    transaction: /* @__PURE__ */ __name((fn) => db.transaction((tx) => fn({
-      query: /* @__PURE__ */ __name(async (text2, params) => rowsOf(await tx.execute(toDrizzleSql(text2, params))), "query")
-    })), "transaction")
-  };
-}
-__name(drizzlePgExecutor, "drizzlePgExecutor");
 export {
   DEFAULT_NAMESPACE,
   DURABLE_PG_DDL,
@@ -965,6 +1098,7 @@ export {
   durableStepCheckpoints,
   durableWorkflowRuns,
   ensureDrizzlePgDurableSchema,
+  rowsOf,
   toDrizzleSql
 };
 //# sourceMappingURL=index.js.map