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

package/dist/pg/index.cjs

@@ -35,6 +35,7 @@ __export(pg_exports, {
   durableStepCheckpoints: () => durableStepCheckpoints,
   durableWorkflowRuns: () => durableWorkflowRuns,
   ensureDrizzlePgDurableSchema: () => ensureDrizzlePgDurableSchema,
+  rowsOf: () => rowsOf,
   toDrizzleSql: () => toDrizzleSql
 });
 module.exports = __toCommonJS(pg_exports);
@@ -124,6 +125,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")`,
@@ -142,10 +144,42 @@ __name(ensureDrizzlePgDurableSchema, "ensureDrizzlePgDurableSchema");
 
 // src/pg/drizzle-pg-state-store.ts
 var import_nestjs_durable_core = require("@dudousxd/nestjs-durable-core");
-var import_drizzle_orm3 = require("drizzle-orm");
+var import_drizzle_orm4 = require("drizzle-orm");
 
-// src/pg/schema.ts
+// src/pg/executor.ts
 var import_drizzle_orm2 = require("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(import_drizzle_orm2.sql.raw(text2.slice(last, match.index)), import_drizzle_orm2.sql`${params[index2]}`);
+    last = (match.index ?? 0) + match[0].length;
+  }
+  chunks.push(import_drizzle_orm2.sql.raw(text2.slice(last)));
+  return import_drizzle_orm2.sql.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
+var import_drizzle_orm3 = require("drizzle-orm");
 var import_pg_core = require("drizzle-orm/pg-core");
 var DEFAULT_NAMESPACE = "default";
 var tstz = /* @__PURE__ */ __name((name) => (0, import_pg_core.timestamp)(name, {
@@ -220,7 +254,9 @@ var durableStepCheckpoints = (0, import_pg_core.pgTable)(
         t.runId,
         t.seq
       ]
-    })
+    }),
+    // A run detail reads one fan at a time: checkpointStats / queryCheckpoints by group, seq-paged.
+    (0, import_pg_core.index)("durable_step_checkpoints_group_idx").on(t.runId, t.parallelGroup, t.seq)
   ]
 );
 var durableRunAttributes = (0, import_pg_core.pgTable)("durable_run_attributes", {
@@ -302,22 +338,22 @@ var durablePgSchema = {
   durableSchedules
 };
 function durablePgManagedTables() {
-  return Object.values(durablePgSchema).map((table) => (0, import_drizzle_orm2.getTableName)(table));
+  return Object.values(durablePgSchema).map((table) => (0, import_drizzle_orm3.getTableName)(table));
 }
 __name(durablePgManagedTables, "durablePgManagedTables");
 
 // src/pg/drizzle-pg-state-store.ts
 function anyOf(conditions) {
   const present = conditions.filter((c) => c !== void 0);
-  return present.length ? (0, import_drizzle_orm3.or)(...present) : import_drizzle_orm3.sql`1 = 0`;
+  return present.length ? (0, import_drizzle_orm4.or)(...present) : import_drizzle_orm4.sql`1 = 0`;
 }
 __name(anyOf, "anyOf");
 function namespaceFilter(namespace) {
-  return namespace === void 0 ? void 0 : (0, import_drizzle_orm3.eq)(durableWorkflowRuns.namespace, namespace);
+  return namespace === void 0 ? void 0 : (0, import_drizzle_orm4.eq)(durableWorkflowRuns.namespace, namespace);
 }
 __name(namespaceFilter, "namespaceFilter");
 function hasTag(tag) {
-  return import_drizzle_orm3.sql`${durableWorkflowRuns.tags} @> ${JSON.stringify([
+  return import_drizzle_orm4.sql`${durableWorkflowRuns.tags} @> ${JSON.stringify([
     tag
   ])}::jsonb`;
 }
@@ -355,7 +391,7 @@ var DrizzlePgStateStore = class _DrizzlePgStateStore {
   }
   async tryAdmitSingleton(runId, tag, workflow, limit, retryWakeAt) {
     return this.db.transaction(async (tx) => {
-      const where = (0, import_drizzle_orm3.and)((0, import_drizzle_orm3.eq)(durableWorkflowRuns.workflow, workflow), (0, import_drizzle_orm3.inArray)(durableWorkflowRuns.status, import_nestjs_durable_core.SINGLETON_ACTIVE_STATUSES), this.scope());
+      const where = (0, import_drizzle_orm4.and)((0, import_drizzle_orm4.eq)(durableWorkflowRuns.workflow, workflow), (0, import_drizzle_orm4.inArray)(durableWorkflowRuns.status, import_nestjs_durable_core.SINGLETON_ACTIVE_STATUSES), this.scope());
       await tx.update(durableWorkflowRuns).set({
         workflow
       }).where(where);
@@ -364,12 +400,12 @@ var DrizzlePgStateStore = class _DrizzlePgStateStore {
       const tags = (0, import_nestjs_durable_core.singletonAdmissionTags)(runs, runId, tag, workflow, limit);
       if (!tags) {
         const patch = (0, import_nestjs_durable_core.singletonAdmissionDenialPatch)(runs, runId, tag, workflow, retryWakeAt);
-        if (patch) await tx.update(durableWorkflowRuns).set(toRunPatch(patch)).where((0, import_drizzle_orm3.eq)(durableWorkflowRuns.id, runId));
+        if (patch) await tx.update(durableWorkflowRuns).set(toRunPatch(patch)).where((0, import_drizzle_orm4.eq)(durableWorkflowRuns.id, runId));
         return false;
       }
       await tx.update(durableWorkflowRuns).set({
         tags
-      }).where((0, import_drizzle_orm3.eq)(durableWorkflowRuns.id, runId));
+      }).where((0, import_drizzle_orm4.eq)(durableWorkflowRuns.id, runId));
       return true;
     });
   }
@@ -385,12 +421,28 @@ var DrizzlePgStateStore = class _DrizzlePgStateStore {
     const reindex = "searchAttributes" in patch;
     if (!Object.keys(row).length && !reindex) return;
     await this.db.transaction(async (tx) => {
-      if (Object.keys(row).length) await tx.update(durableWorkflowRuns).set(row).where((0, import_drizzle_orm3.eq)(durableWorkflowRuns.id, runId));
+      if (Object.keys(row).length) await tx.update(durableWorkflowRuns).set(row).where((0, import_drizzle_orm4.eq)(durableWorkflowRuns.id, runId));
       if (reindex) await reindexAttributes(tx, runId, patch.searchAttributes);
     });
   }
+  async updateRunIf(runId, expectedStatuses, inputPatch) {
+    if (expectedStatuses.length === 0) return false;
+    const patch = inputPatch.status && import_nestjs_durable_core.TERMINAL_RUN_STATUSES.includes(inputPatch.status) ? await (0, import_nestjs_durable_core.clearTerminalSingletonAdmission)(runId, inputPatch, (id) => this.withScope({}).getRun(id)) : inputPatch;
+    const row = toRunPatch(patch);
+    const reindex = "searchAttributes" in patch;
+    const matches = (0, import_drizzle_orm4.and)((0, import_drizzle_orm4.eq)(durableWorkflowRuns.id, runId), (0, import_drizzle_orm4.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((0, import_drizzle_orm3.and)((0, import_drizzle_orm3.eq)(durableWorkflowRuns.id, runId), this.scope())).limit(1);
+    const rows = await this.db.select().from(durableWorkflowRuns).where((0, import_drizzle_orm4.and)((0, import_drizzle_orm4.eq)(durableWorkflowRuns.id, runId), this.scope())).limit(1);
     return rows[0] ? fromRunRow(rows[0]) : null;
   }
   async deleteRun(runId) {
@@ -420,7 +472,7 @@ var DrizzlePgStateStore = class _DrizzlePgStateStore {
         const cutoff = new Date(nowMs - (0, import_nestjs_durable_core.parseDuration)(policy.maxAge));
         const rows = await tx.select({
           id: durableWorkflowRuns.id
-        }).from(durableWorkflowRuns).where((0, import_drizzle_orm3.and)(...scoped, (0, import_drizzle_orm3.lt)(durableWorkflowRuns.updatedAt, cutoff))).orderBy((0, import_drizzle_orm3.asc)(durableWorkflowRuns.updatedAt)).limit(limit).for("update", {
+        }).from(durableWorkflowRuns).where((0, import_drizzle_orm4.and)(...scoped, (0, import_drizzle_orm4.lt)(durableWorkflowRuns.updatedAt, cutoff))).orderBy((0, import_drizzle_orm4.asc)(durableWorkflowRuns.updatedAt)).limit(limit).for("update", {
           skipLocked: true
         });
         for (const r of rows) ids.add(r.id);
@@ -428,7 +480,7 @@ var DrizzlePgStateStore = class _DrizzlePgStateStore {
       if (policy.maxCount != null && ids.size < limit) {
         const rows = await tx.select({
           id: durableWorkflowRuns.id
-        }).from(durableWorkflowRuns).where((0, import_drizzle_orm3.and)(...scoped)).orderBy((0, import_drizzle_orm3.desc)(durableWorkflowRuns.updatedAt), (0, import_drizzle_orm3.desc)(durableWorkflowRuns.id)).limit(limit).offset(policy.maxCount).for("update", {
+        }).from(durableWorkflowRuns).where((0, import_drizzle_orm4.and)(...scoped)).orderBy((0, import_drizzle_orm4.desc)(durableWorkflowRuns.updatedAt), (0, import_drizzle_orm4.desc)(durableWorkflowRuns.id)).limit(limit).offset(policy.maxCount).for("update", {
           skipLocked: true
         });
         for (const r of rows) {
@@ -445,7 +497,7 @@ var DrizzlePgStateStore = class _DrizzlePgStateStore {
     });
   }
   async getCheckpoint(runId, seq) {
-    const rows = await this.db.select().from(durableStepCheckpoints).where((0, import_drizzle_orm3.and)((0, import_drizzle_orm3.eq)(durableStepCheckpoints.runId, runId), (0, import_drizzle_orm3.eq)(durableStepCheckpoints.seq, seq))).limit(1);
+    const rows = await this.db.select().from(durableStepCheckpoints).where((0, import_drizzle_orm4.and)((0, import_drizzle_orm4.eq)(durableStepCheckpoints.runId, runId), (0, import_drizzle_orm4.eq)(durableStepCheckpoints.seq, seq))).limit(1);
     return rows[0] ? fromCheckpointRow(rows[0]) : null;
   }
   async saveCheckpoint(checkpoint) {
@@ -453,11 +505,35 @@ var DrizzlePgStateStore = class _DrizzlePgStateStore {
   }
   async saveCheckpointIfPending(checkpoint) {
     const { runId, seq, ...set } = toCheckpointRow(checkpoint);
-    const rows = await this.db.update(durableStepCheckpoints).set(set).where((0, import_drizzle_orm3.and)((0, import_drizzle_orm3.eq)(durableStepCheckpoints.runId, runId), (0, import_drizzle_orm3.eq)(durableStepCheckpoints.seq, seq), (0, import_drizzle_orm3.eq)(durableStepCheckpoints.status, "pending"))).returning({
+    const rows = await this.db.update(durableStepCheckpoints).set(set).where((0, import_drizzle_orm4.and)((0, import_drizzle_orm4.eq)(durableStepCheckpoints.runId, runId), (0, import_drizzle_orm4.eq)(durableStepCheckpoints.seq, seq), (0, import_drizzle_orm4.eq)(durableStepCheckpoints.status, "pending"))).returning({
       seq: durableStepCheckpoints.seq
     });
     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,
@@ -466,20 +542,28 @@ var DrizzlePgStateStore = class _DrizzlePgStateStore {
   }
   /** Crash recovery. Namespace-scoped: a worker re-drives only its own tenant's runs. */
   async listIncompleteRuns(namespace) {
-    const rows = await this.db.select().from(durableWorkflowRuns).where((0, import_drizzle_orm3.and)((0, import_drizzle_orm3.inArray)(durableWorkflowRuns.status, [
+    const rows = await this.db.select().from(durableWorkflowRuns).where((0, import_drizzle_orm4.and)((0, import_drizzle_orm4.inArray)(durableWorkflowRuns.status, [
       "running",
       "cancelling"
     ]), 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((0, import_drizzle_orm4.and)((0, import_drizzle_orm4.inArray)(durableWorkflowRuns.status, [
+      "running",
+      "cancelling"
+    ]), (0, import_drizzle_orm4.or)((0, import_drizzle_orm4.isNull)(durableWorkflowRuns.lockedUntil), (0, import_drizzle_orm4.lte)(durableWorkflowRuns.lockedUntil, new Date(nowMs))), namespaceFilter(namespace), this.scope())).orderBy((0, import_drizzle_orm4.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) {
-    const rows = await this.db.select().from(durableWorkflowRuns).where((0, import_drizzle_orm3.and)((0, import_drizzle_orm3.eq)(durableWorkflowRuns.status, "pending"), namespaceFilter(namespace), this.scope())).orderBy((0, import_drizzle_orm3.asc)(durableWorkflowRuns.createdAt)).limit(limit);
+    const rows = await this.db.select().from(durableWorkflowRuns).where((0, import_drizzle_orm4.and)((0, import_drizzle_orm4.eq)(durableWorkflowRuns.status, "pending"), namespaceFilter(namespace), this.scope())).orderBy((0, import_drizzle_orm4.asc)(durableWorkflowRuns.createdAt)).limit(limit);
     return rows.map(fromRunRow);
   }
   async listDueTimers(nowMs, namespace, limit) {
-    const query = this.db.select().from(durableWorkflowRuns).where((0, import_drizzle_orm3.and)((0, import_drizzle_orm3.eq)(durableWorkflowRuns.status, "suspended"), (0, import_drizzle_orm3.isNotNull)(durableWorkflowRuns.wakeAt), (0, import_drizzle_orm3.lte)(durableWorkflowRuns.wakeAt, new Date(nowMs)), namespaceFilter(namespace), this.scope())).orderBy((0, import_drizzle_orm3.asc)(durableWorkflowRuns.wakeAt));
+    const query = this.db.select().from(durableWorkflowRuns).where((0, import_drizzle_orm4.and)((0, import_drizzle_orm4.eq)(durableWorkflowRuns.status, "suspended"), (0, import_drizzle_orm4.isNotNull)(durableWorkflowRuns.wakeAt), (0, import_drizzle_orm4.lte)(durableWorkflowRuns.wakeAt, new Date(nowMs)), namespaceFilter(namespace), this.scope())).orderBy((0, import_drizzle_orm4.asc)(durableWorkflowRuns.wakeAt));
     const rows = limit !== void 0 ? await query.limit(limit) : await query;
     return rows.map(fromRunRow);
   }
@@ -487,7 +571,7 @@ var DrizzlePgStateStore = class _DrizzlePgStateStore {
     const rows = await this.db.update(durableWorkflowRuns).set({
       lockedBy: owner,
       lockedUntil: new Date(leaseUntilMs)
-    }).where((0, import_drizzle_orm3.and)((0, import_drizzle_orm3.eq)(durableWorkflowRuns.id, runId), (0, import_drizzle_orm3.or)((0, import_drizzle_orm3.isNull)(durableWorkflowRuns.lockedUntil), (0, import_drizzle_orm3.lte)(durableWorkflowRuns.lockedUntil, new Date(nowMs))))).returning({
+    }).where((0, import_drizzle_orm4.and)((0, import_drizzle_orm4.eq)(durableWorkflowRuns.id, runId), (0, import_drizzle_orm4.or)((0, import_drizzle_orm4.isNull)(durableWorkflowRuns.lockedUntil), (0, import_drizzle_orm4.lte)(durableWorkflowRuns.lockedUntil, new Date(nowMs))))).returning({
       id: durableWorkflowRuns.id
     });
     return rows.length === 1;
@@ -496,12 +580,12 @@ var DrizzlePgStateStore = class _DrizzlePgStateStore {
     await this.db.update(durableWorkflowRuns).set({
       lockedBy: null,
       lockedUntil: null
-    }).where((0, import_drizzle_orm3.eq)(durableWorkflowRuns.id, runId));
+    }).where((0, import_drizzle_orm4.eq)(durableWorkflowRuns.id, runId));
   }
   async renewRunLock(runId, owner, leaseUntilMs) {
     const rows = await this.db.update(durableWorkflowRuns).set({
       lockedUntil: new Date(leaseUntilMs)
-    }).where((0, import_drizzle_orm3.and)((0, import_drizzle_orm3.eq)(durableWorkflowRuns.id, runId), (0, import_drizzle_orm3.eq)(durableWorkflowRuns.lockedBy, owner))).returning({
+    }).where((0, import_drizzle_orm4.and)((0, import_drizzle_orm4.eq)(durableWorkflowRuns.id, runId), (0, import_drizzle_orm4.eq)(durableWorkflowRuns.lockedBy, owner))).returning({
       id: durableWorkflowRuns.id
     });
     return rows.length === 1;
@@ -510,17 +594,17 @@ var DrizzlePgStateStore = class _DrizzlePgStateStore {
   runFilters(query) {
     return [
       this.scope(),
-      query.workflow ? (0, import_drizzle_orm3.eq)(durableWorkflowRuns.workflow, query.workflow) : void 0,
-      query.workflows ? query.workflows.length ? (0, import_drizzle_orm3.inArray)(durableWorkflowRuns.workflow, query.workflows) : import_drizzle_orm3.sql`1 = 0` : void 0,
+      query.workflow ? (0, import_drizzle_orm4.eq)(durableWorkflowRuns.workflow, query.workflow) : void 0,
+      query.workflows ? query.workflows.length ? (0, import_drizzle_orm4.inArray)(durableWorkflowRuns.workflow, query.workflows) : import_drizzle_orm4.sql`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 ? (0, import_drizzle_orm3.inArray)(durableWorkflowRuns.namespace, query.namespaces) : import_drizzle_orm3.sql`1 = 0` : void 0,
+      query.namespaces ? query.namespaces.length ? (0, import_drizzle_orm4.inArray)(durableWorkflowRuns.namespace, query.namespaces) : import_drizzle_orm4.sql`1 = 0` : void 0,
       // `null` selects the unattributed bucket; a value never matches a NULL origin.
-      query.origin === null ? (0, import_drizzle_orm3.isNull)(durableWorkflowRuns.origin) : query.origin !== void 0 ? (0, import_drizzle_orm3.eq)(durableWorkflowRuns.origin, query.origin) : void 0,
-      query.origins ? anyOf(query.origins.map((o) => o === null ? (0, import_drizzle_orm3.isNull)(durableWorkflowRuns.origin) : (0, import_drizzle_orm3.eq)(durableWorkflowRuns.origin, o))) : void 0,
-      query.status ? (0, import_drizzle_orm3.eq)(durableWorkflowRuns.status, query.status) : void 0,
-      query.statuses ? query.statuses.length ? (0, import_drizzle_orm3.inArray)(durableWorkflowRuns.status, query.statuses) : import_drizzle_orm3.sql`1 = 0` : void 0,
+      query.origin === null ? (0, import_drizzle_orm4.isNull)(durableWorkflowRuns.origin) : query.origin !== void 0 ? (0, import_drizzle_orm4.eq)(durableWorkflowRuns.origin, query.origin) : void 0,
+      query.origins ? anyOf(query.origins.map((o) => o === null ? (0, import_drizzle_orm4.isNull)(durableWorkflowRuns.origin) : (0, import_drizzle_orm4.eq)(durableWorkflowRuns.origin, o))) : void 0,
+      query.status ? (0, import_drizzle_orm4.eq)(durableWorkflowRuns.status, query.status) : void 0,
+      query.statuses ? query.statuses.length ? (0, import_drizzle_orm4.inArray)(durableWorkflowRuns.status, query.statuses) : import_drizzle_orm4.sql`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).
@@ -529,7 +613,7 @@ var DrizzlePgStateStore = class _DrizzlePgStateStore {
   }
   async listRuns(query) {
     const filters = this.runFilters(query);
-    const base = this.db.select().from(durableWorkflowRuns).where(filters.length ? (0, import_drizzle_orm3.and)(...filters) : void 0).orderBy((0, import_drizzle_orm3.desc)(durableWorkflowRuns.createdAt), (0, import_drizzle_orm3.desc)(durableWorkflowRuns.id)).$dynamic();
+    const base = this.db.select().from(durableWorkflowRuns).where(filters.length ? (0, import_drizzle_orm4.and)(...filters) : void 0).orderBy((0, import_drizzle_orm4.desc)(durableWorkflowRuns.createdAt), (0, import_drizzle_orm4.desc)(durableWorkflowRuns.id)).$dynamic();
     if (query.limit != null) base.limit(query.limit);
     if (query.offset != null) base.offset(query.offset);
     const rows = await base;
@@ -538,8 +622,8 @@ var DrizzlePgStateStore = class _DrizzlePgStateStore {
   async countRuns(query) {
     const filters = this.runFilters(query);
     const rows = await this.db.select({
-      count: import_drizzle_orm3.sql`count(*)`.mapWith(Number)
-    }).from(durableWorkflowRuns).where(filters.length ? (0, import_drizzle_orm3.and)(...filters) : void 0);
+      count: import_drizzle_orm4.sql`count(*)`.mapWith(Number)
+    }).from(durableWorkflowRuns).where(filters.length ? (0, import_drizzle_orm4.and)(...filters) : void 0);
     return rows[0]?.count ?? 0;
   }
   async runFacets(query) {
@@ -547,8 +631,8 @@ var DrizzlePgStateStore = class _DrizzlePgStateStore {
     const rows = await this.db.select({
       status: durableWorkflowRuns.status,
       origin: durableWorkflowRuns.origin,
-      count: import_drizzle_orm3.sql`count(*)`.mapWith(Number)
-    }).from(durableWorkflowRuns).where(filters.length ? (0, import_drizzle_orm3.and)(...filters) : void 0).groupBy(durableWorkflowRuns.status, durableWorkflowRuns.origin);
+      count: import_drizzle_orm4.sql`count(*)`.mapWith(Number)
+    }).from(durableWorkflowRuns).where(filters.length ? (0, import_drizzle_orm4.and)(...filters) : void 0).groupBy(durableWorkflowRuns.status, durableWorkflowRuns.origin);
     return (0, import_nestjs_durable_core.mergeRunFacetRows)(rows.map((r) => ({
       status: r.status,
       origin: r.origin,
@@ -569,8 +653,8 @@ var DrizzlePgStateStore = class _DrizzlePgStateStore {
     const filters = this.runFilters(query);
     const rows = await this.db.select({
       value: column,
-      count: import_drizzle_orm3.sql`count(*)`.mapWith(Number)
-    }).from(durableWorkflowRuns).where(filters.length ? (0, import_drizzle_orm3.and)(...filters) : void 0).groupBy(column);
+      count: import_drizzle_orm4.sql`count(*)`.mapWith(Number)
+    }).from(durableWorkflowRuns).where(filters.length ? (0, import_drizzle_orm4.and)(...filters) : void 0).groupBy(column);
     return (0, import_nestjs_durable_core.mergeRunValueFacetRows)(rows.map((r) => ({
       value: r.value ?? null,
       count: r.count
@@ -580,10 +664,10 @@ 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 = (0, import_nestjs_durable_core.attributePredicateOperands)(f).map(({ column, comparator, operand }) => import_drizzle_orm3.sql`${column === "numValue" ? durableRunAttributes.numValue : durableRunAttributes.strValue} ${import_drizzle_orm3.sql.raw(comparator)} ${operand}`);
-    return (0, import_drizzle_orm3.exists)(this.db.select({
-      one: import_drizzle_orm3.sql`1`
-    }).from(durableRunAttributes).where((0, import_drizzle_orm3.and)((0, import_drizzle_orm3.eq)(durableRunAttributes.runId, durableWorkflowRuns.id), (0, import_drizzle_orm3.eq)(durableRunAttributes.key, f.key), anyOf(comparisons))));
+    const comparisons = (0, import_nestjs_durable_core.attributePredicateOperands)(f).map(({ column, comparator, operand }) => import_drizzle_orm4.sql`${column === "numValue" ? durableRunAttributes.numValue : durableRunAttributes.strValue} ${import_drizzle_orm4.sql.raw(comparator)} ${operand}`);
+    return (0, import_drizzle_orm4.exists)(this.db.select({
+      one: import_drizzle_orm4.sql`1`
+    }).from(durableRunAttributes).where((0, import_drizzle_orm4.and)((0, import_drizzle_orm4.eq)(durableRunAttributes.runId, durableWorkflowRuns.id), (0, import_drizzle_orm4.eq)(durableRunAttributes.key, f.key), anyOf(comparisons))));
   }
   // ---- persisted schedules ----------------------------------------------------------------------
   async saveSchedule(record) {
@@ -594,52 +678,99 @@ var DrizzlePgStateStore = class _DrizzlePgStateStore {
     });
   }
   async getSchedule(id) {
-    const rows = await this.db.select().from(durableSchedules).where((0, import_drizzle_orm3.eq)(durableSchedules.id, id)).limit(1);
+    const rows = await this.db.select().from(durableSchedules).where((0, import_drizzle_orm4.eq)(durableSchedules.id, id)).limit(1);
     return rows[0] ? fromScheduleRow(rows[0]) : null;
   }
   /** A single conditional `UPDATE … RETURNING`: the compare-and-set on `next_fire_at` is atomic. */
   async updateSchedule(id, patch, expectedNextFireAt) {
     const set = toSchedulePatch(patch);
     if (!Object.keys(set).length) return await this.getSchedule(id) !== null;
-    const rows = await this.db.update(durableSchedules).set(set).where((0, import_drizzle_orm3.and)((0, import_drizzle_orm3.eq)(durableSchedules.id, id), expectedNextFireAt === void 0 ? void 0 : expectedNextFireAt === null ? (0, import_drizzle_orm3.isNull)(durableSchedules.nextFireAt) : (0, import_drizzle_orm3.eq)(durableSchedules.nextFireAt, new Date(expectedNextFireAt)))).returning({
+    const rows = await this.db.update(durableSchedules).set(set).where((0, import_drizzle_orm4.and)((0, import_drizzle_orm4.eq)(durableSchedules.id, id), expectedNextFireAt === void 0 ? void 0 : expectedNextFireAt === null ? (0, import_drizzle_orm4.isNull)(durableSchedules.nextFireAt) : (0, import_drizzle_orm4.eq)(durableSchedules.nextFireAt, new Date(expectedNextFireAt)))).returning({
       id: durableSchedules.id
     });
     return rows.length > 0;
   }
   async deleteSchedule(id) {
-    const rows = await this.db.delete(durableSchedules).where((0, import_drizzle_orm3.eq)(durableSchedules.id, id)).returning({
+    const rows = await this.db.delete(durableSchedules).where((0, import_drizzle_orm4.eq)(durableSchedules.id, id)).returning({
       id: durableSchedules.id
     });
     return rows.length > 0;
   }
   async listSchedules(query) {
-    const base = this.db.select().from(durableSchedules).where((0, import_drizzle_orm3.and)(query.namespace !== void 0 ? (0, import_drizzle_orm3.eq)(durableSchedules.namespace, query.namespace) : void 0, query.workflow !== void 0 ? (0, import_drizzle_orm3.eq)(durableSchedules.workflow, query.workflow) : void 0, query.paused !== void 0 ? (0, import_drizzle_orm3.eq)(durableSchedules.paused, query.paused) : void 0, query.tag !== void 0 ? import_drizzle_orm3.sql`${durableSchedules.tags} @> ${JSON.stringify([
+    const base = this.db.select().from(durableSchedules).where((0, import_drizzle_orm4.and)(query.namespace !== void 0 ? (0, import_drizzle_orm4.eq)(durableSchedules.namespace, query.namespace) : void 0, query.workflow !== void 0 ? (0, import_drizzle_orm4.eq)(durableSchedules.workflow, query.workflow) : void 0, query.paused !== void 0 ? (0, import_drizzle_orm4.eq)(durableSchedules.paused, query.paused) : void 0, query.tag !== void 0 ? import_drizzle_orm4.sql`${durableSchedules.tags} @> ${JSON.stringify([
       query.tag
-    ])}::jsonb` : void 0, query.dueBy !== void 0 ? (0, import_drizzle_orm3.and)((0, import_drizzle_orm3.eq)(durableSchedules.paused, false), (0, import_drizzle_orm3.lte)(durableSchedules.nextFireAt, new Date(query.dueBy))) : void 0)).orderBy(import_drizzle_orm3.sql`${durableSchedules.nextFireAt} ASC NULLS LAST`, (0, import_drizzle_orm3.asc)(durableSchedules.id)).$dynamic();
+    ])}::jsonb` : void 0, query.dueBy !== void 0 ? (0, import_drizzle_orm4.and)((0, import_drizzle_orm4.eq)(durableSchedules.paused, false), (0, import_drizzle_orm4.lte)(durableSchedules.nextFireAt, new Date(query.dueBy))) : void 0)).orderBy(import_drizzle_orm4.sql`${durableSchedules.nextFireAt} ASC NULLS LAST`, (0, import_drizzle_orm4.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);
   }
   async listCheckpoints(runId) {
-    const rows = await this.db.select().from(durableStepCheckpoints).where((0, import_drizzle_orm3.eq)(durableStepCheckpoints.runId, runId)).orderBy((0, import_drizzle_orm3.asc)(durableStepCheckpoints.seq));
+    const rows = await this.db.select().from(durableStepCheckpoints).where((0, import_drizzle_orm4.eq)(durableStepCheckpoints.runId, runId)).orderBy((0, import_drizzle_orm4.asc)(durableStepCheckpoints.seq));
     return rows.map(fromCheckpointRow);
   }
   async getLatestCheckpointByName(runId, name) {
-    const rows = await this.db.select().from(durableStepCheckpoints).where((0, import_drizzle_orm3.and)((0, import_drizzle_orm3.eq)(durableStepCheckpoints.runId, runId), (0, import_drizzle_orm3.eq)(durableStepCheckpoints.name, name))).orderBy((0, import_drizzle_orm3.desc)(durableStepCheckpoints.seq)).limit(1);
+    const rows = await this.db.select().from(durableStepCheckpoints).where((0, import_drizzle_orm4.and)((0, import_drizzle_orm4.eq)(durableStepCheckpoints.runId, runId), (0, import_drizzle_orm4.eq)(durableStepCheckpoints.name, name))).orderBy((0, import_drizzle_orm4.desc)(durableStepCheckpoints.seq)).limit(1);
     return rows[0] ? fromCheckpointRow(rows[0]) : void 0;
   }
   async countCheckpoints(runId, fromSeq, toSeq, statuses) {
     if (statuses.length === 0) return 0;
     const rows = await this.db.select({
-      count: import_drizzle_orm3.sql`count(*)`.mapWith(Number)
-    }).from(durableStepCheckpoints).where((0, import_drizzle_orm3.and)((0, import_drizzle_orm3.eq)(durableStepCheckpoints.runId, runId), (0, import_drizzle_orm3.gte)(durableStepCheckpoints.seq, fromSeq), (0, import_drizzle_orm3.lte)(durableStepCheckpoints.seq, toSeq), (0, import_drizzle_orm3.inArray)(durableStepCheckpoints.status, statuses)));
+      count: import_drizzle_orm4.sql`count(*)`.mapWith(Number)
+    }).from(durableStepCheckpoints).where((0, import_drizzle_orm4.and)((0, import_drizzle_orm4.eq)(durableStepCheckpoints.runId, runId), (0, import_drizzle_orm4.gte)(durableStepCheckpoints.seq, fromSeq), (0, import_drizzle_orm4.lte)(durableStepCheckpoints.seq, toSeq), (0, import_drizzle_orm4.inArray)(durableStepCheckpoints.status, statuses)));
     return rows[0]?.count ?? 0;
   }
   async listCheckpointsByNamePrefix(runId, prefixes) {
     if (prefixes.length === 0) return [];
-    const rows = await this.db.select().from(durableStepCheckpoints).where((0, import_drizzle_orm3.and)((0, import_drizzle_orm3.eq)(durableStepCheckpoints.runId, runId), (0, import_drizzle_orm3.or)(...prefixes.map((p) => (0, import_drizzle_orm3.like)(durableStepCheckpoints.name, `${escapeLike(p)}%`))))).orderBy((0, import_drizzle_orm3.asc)(durableStepCheckpoints.seq));
+    const rows = await this.db.select().from(durableStepCheckpoints).where((0, import_drizzle_orm4.and)((0, import_drizzle_orm4.eq)(durableStepCheckpoints.runId, runId), (0, import_drizzle_orm4.or)(...prefixes.map((p) => (0, import_drizzle_orm4.like)(durableStepCheckpoints.name, `${escapeLike(p)}%`))))).orderBy((0, import_drizzle_orm4.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 = import_drizzle_orm4.sql`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: import_drizzle_orm4.sql`count(*)`.mapWith(Number),
+      minSeq: import_drizzle_orm4.sql`min(${c.seq})`.mapWith(Number),
+      maxSeq: import_drizzle_orm4.sql`max(${c.seq})`.mapWith(Number),
+      minName: import_drizzle_orm4.sql`min(${c.name})`,
+      maxName: import_drizzle_orm4.sql`max(${c.name})`,
+      minEnqueuedAt: import_drizzle_orm4.sql`min(coalesce(${c.enqueuedAt}, ${c.startedAt}))`.mapWith(c.startedAt),
+      minStartedAt: import_drizzle_orm4.sql`min(${c.startedAt})`.mapWith(c.startedAt),
+      maxStartedAt: import_drizzle_orm4.sql`max(${c.startedAt})`.mapWith(c.startedAt),
+      maxFinishedAt: import_drizzle_orm4.sql`max(${c.finishedAt})`.mapWith(c.finishedAt),
+      sumAttempts: import_drizzle_orm4.sql`sum(${c.attempts})`.mapWith(Number)
+    }).from(c).where((0, import_drizzle_orm4.and)((0, import_drizzle_orm4.eq)(c.runId, runId), opts?.group !== void 0 ? (0, import_drizzle_orm4.eq)(c.parallelGroup, opts.group) : void 0)).groupBy(c.parallelGroup, c.status, import_drizzle_orm4.sql`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((0, import_drizzle_orm4.and)(
+      (0, import_drizzle_orm4.eq)(c.runId, runId),
+      query.group !== void 0 ? (0, import_drizzle_orm4.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 ? (0, import_drizzle_orm4.or)((0, import_drizzle_orm4.isNull)(c.parallelGroup), (0, import_drizzle_orm4.notInArray)(c.parallelGroup, query.excludeGroups)) : void 0,
+      query.statuses ? (0, import_drizzle_orm4.inArray)(c.status, query.statuses) : void 0,
+      query.namePrefixes ? (0, import_drizzle_orm4.or)(...query.namePrefixes.map((p) => (0, import_drizzle_orm4.like)(c.name, `${escapeLike(p)}%`))) : void 0
+    )).orderBy((0, import_drizzle_orm4.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,
@@ -655,12 +786,12 @@ var DrizzlePgStateStore = class _DrizzlePgStateStore {
     });
   }
   async takeSignalWaiter(token) {
-    const rows = await this.db.delete(durableSignalWaiters).where((0, import_drizzle_orm3.eq)(durableSignalWaiters.token, token)).returning();
+    const rows = await this.db.delete(durableSignalWaiters).where((0, import_drizzle_orm4.eq)(durableSignalWaiters.token, token)).returning();
     const row = rows[0];
     return row ? fromWaiterRow(row) : null;
   }
   async listSignalWaiters(prefix) {
-    const rows = await this.db.select().from(durableSignalWaiters).where((0, import_drizzle_orm3.like)(durableSignalWaiters.token, `${escapeLike(prefix)}%`));
+    const rows = await this.db.select().from(durableSignalWaiters).where((0, import_drizzle_orm4.like)(durableSignalWaiters.token, `${escapeLike(prefix)}%`));
     return rows.map(fromWaiterRow);
   }
   async registerChildWaits(entries) {
@@ -690,23 +821,23 @@ var DrizzlePgStateStore = class _DrizzlePgStateStore {
   }
   async compactCheckpoints(runId, fromSeq, toSeq, into) {
     await this.db.transaction(async (tx) => {
-      await tx.delete(durableStepCheckpoints).where((0, import_drizzle_orm3.and)((0, import_drizzle_orm3.eq)(durableStepCheckpoints.runId, runId), (0, import_drizzle_orm3.gte)(durableStepCheckpoints.seq, fromSeq), (0, import_drizzle_orm3.lte)(durableStepCheckpoints.seq, toSeq)));
+      await tx.delete(durableStepCheckpoints).where((0, import_drizzle_orm4.and)((0, import_drizzle_orm4.eq)(durableStepCheckpoints.runId, runId), (0, import_drizzle_orm4.gte)(durableStepCheckpoints.seq, fromSeq), (0, import_drizzle_orm4.lte)(durableStepCheckpoints.seq, toSeq)));
       await upsertCheckpoint(tx, into);
     });
   }
   async listSignalWaitersByRun(runIds) {
     if (runIds.length === 0) return [];
-    const rows = await this.db.select().from(durableSignalWaiters).where((0, import_drizzle_orm3.inArray)(durableSignalWaiters.runId, runIds));
+    const rows = await this.db.select().from(durableSignalWaiters).where((0, import_drizzle_orm4.inArray)(durableSignalWaiters.runId, runIds));
     return rows.map(fromWaiterRow);
   }
   async hasSignalWaiter(runId, tokenPrefix) {
     const rows = await this.db.select({
       token: durableSignalWaiters.token
-    }).from(durableSignalWaiters).where((0, import_drizzle_orm3.and)((0, import_drizzle_orm3.eq)(durableSignalWaiters.runId, runId), (0, import_drizzle_orm3.like)(durableSignalWaiters.token, `${escapeLike(tokenPrefix)}%`))).limit(1);
+    }).from(durableSignalWaiters).where((0, import_drizzle_orm4.and)((0, import_drizzle_orm4.eq)(durableSignalWaiters.runId, runId), (0, import_drizzle_orm4.like)(durableSignalWaiters.token, `${escapeLike(tokenPrefix)}%`))).limit(1);
     return rows.length > 0;
   }
   async removeSignalWaiter(waiter) {
-    await this.db.delete(durableSignalWaiters).where((0, import_drizzle_orm3.and)((0, import_drizzle_orm3.eq)(durableSignalWaiters.token, waiter.token), (0, import_drizzle_orm3.eq)(durableSignalWaiters.runId, waiter.runId), (0, import_drizzle_orm3.eq)(durableSignalWaiters.seq, waiter.seq)));
+    await this.db.delete(durableSignalWaiters).where((0, import_drizzle_orm4.and)((0, import_drizzle_orm4.eq)(durableSignalWaiters.token, waiter.token), (0, import_drizzle_orm4.eq)(durableSignalWaiters.runId, waiter.runId), (0, import_drizzle_orm4.eq)(durableSignalWaiters.seq, waiter.seq)));
   }
   async bufferSignal(token, payload) {
     await this.db.insert(durableBufferedSignals).values({
@@ -717,10 +848,10 @@ var DrizzlePgStateStore = class _DrizzlePgStateStore {
   async takeBufferedSignal(token) {
     const oldest = this.db.select({
       id: durableBufferedSignals.id
-    }).from(durableBufferedSignals).where((0, import_drizzle_orm3.eq)(durableBufferedSignals.token, token)).orderBy((0, import_drizzle_orm3.asc)(durableBufferedSignals.id)).limit(1).for("update", {
+    }).from(durableBufferedSignals).where((0, import_drizzle_orm4.eq)(durableBufferedSignals.token, token)).orderBy((0, import_drizzle_orm4.asc)(durableBufferedSignals.id)).limit(1).for("update", {
       skipLocked: true
     });
-    const rows = await this.db.delete(durableBufferedSignals).where((0, import_drizzle_orm3.inArray)(durableBufferedSignals.id, oldest)).returning({
+    const rows = await this.db.delete(durableBufferedSignals).where((0, import_drizzle_orm4.inArray)(durableBufferedSignals.id, oldest)).returning({
       payload: durableBufferedSignals.payload
     });
     const row = rows[0];
@@ -737,7 +868,7 @@ var DrizzlePgStateStore = class _DrizzlePgStateStore {
     });
   }
   async listBufferedEvents(name, limit) {
-    const rows = await this.db.select().from(durableBufferedEvents).where((0, import_drizzle_orm3.eq)(durableBufferedEvents.name, name)).orderBy((0, import_drizzle_orm3.asc)(durableBufferedEvents.publishedAt), (0, import_drizzle_orm3.asc)(durableBufferedEvents.id)).limit(limit);
+    const rows = await this.db.select().from(durableBufferedEvents).where((0, import_drizzle_orm4.eq)(durableBufferedEvents.name, name)).orderBy((0, import_drizzle_orm4.asc)(durableBufferedEvents.publishedAt), (0, import_drizzle_orm4.asc)(durableBufferedEvents.id)).limit(limit);
     return rows.map((r) => ({
       id: r.id,
       payload: r.payload ?? void 0,
@@ -745,7 +876,7 @@ var DrizzlePgStateStore = class _DrizzlePgStateStore {
     }));
   }
   async removeBufferedEvent(id) {
-    const rows = await this.db.delete(durableBufferedEvents).where((0, import_drizzle_orm3.eq)(durableBufferedEvents.id, id)).returning({
+    const rows = await this.db.delete(durableBufferedEvents).where((0, import_drizzle_orm4.eq)(durableBufferedEvents.id, id)).returning({
       id: durableBufferedEvents.id
     });
     return rows.length === 1;
@@ -755,6 +886,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 import_drizzle_orm4.sql`(${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 import_drizzle_orm4.sql`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 ${import_drizzle_orm4.sql.join(values, import_drizzle_orm4.sql`, `)}) 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({
@@ -767,16 +933,16 @@ async function upsertCheckpoint(db, cp) {
 }
 __name(upsertCheckpoint, "upsertCheckpoint");
 async function reindexAttributes(db, runId, attributes) {
-  await db.delete(durableRunAttributes).where((0, import_drizzle_orm3.eq)(durableRunAttributes.runId, runId));
+  await db.delete(durableRunAttributes).where((0, import_drizzle_orm4.eq)(durableRunAttributes.runId, runId));
   const rows = (0, import_nestjs_durable_core.normalizeAttributeRows)(runId, attributes);
   if (rows.length) await db.insert(durableRunAttributes).values(rows);
 }
 __name(reindexAttributes, "reindexAttributes");
 async function deleteRunsCascade(db, runIds) {
-  await db.delete(durableStepCheckpoints).where((0, import_drizzle_orm3.inArray)(durableStepCheckpoints.runId, runIds));
-  await db.delete(durableSignalWaiters).where((0, import_drizzle_orm3.inArray)(durableSignalWaiters.runId, runIds));
-  await db.delete(durableRunAttributes).where((0, import_drizzle_orm3.inArray)(durableRunAttributes.runId, runIds));
-  await db.delete(durableWorkflowRuns).where((0, import_drizzle_orm3.inArray)(durableWorkflowRuns.id, runIds));
+  await db.delete(durableStepCheckpoints).where((0, import_drizzle_orm4.inArray)(durableStepCheckpoints.runId, runIds));
+  await db.delete(durableSignalWaiters).where((0, import_drizzle_orm4.inArray)(durableSignalWaiters.runId, runIds));
+  await db.delete(durableRunAttributes).where((0, import_drizzle_orm4.inArray)(durableRunAttributes.runId, runIds));
+  await db.delete(durableWorkflowRuns).where((0, import_drizzle_orm4.inArray)(durableWorkflowRuns.id, runIds));
 }
 __name(deleteRunsCascade, "deleteRunsCascade");
 function fromWaiterRow(row) {
@@ -950,44 +1116,12 @@ function fromScheduleRow(row) {
 }
 __name(fromScheduleRow, "fromScheduleRow");
 function excludedSet(table, only) {
-  return Object.fromEntries(Object.entries((0, import_drizzle_orm3.getTableColumns)(table)).filter(([key]) => !only || only.includes(key)).map(([key, column]) => [
+  return Object.fromEntries(Object.entries((0, import_drizzle_orm4.getTableColumns)(table)).filter(([key]) => !only || only.includes(key)).map(([key, column]) => [
     key,
-    import_drizzle_orm3.sql.raw(`excluded."${column.name}"`)
+    import_drizzle_orm4.sql.raw(`excluded."${column.name}"`)
   ]));
 }
 __name(excludedSet, "excludedSet");
-
-// src/pg/executor.ts
-var import_drizzle_orm4 = require("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(import_drizzle_orm4.sql.raw(text2.slice(last, match.index)), import_drizzle_orm4.sql`${params[index2]}`);
-    last = (match.index ?? 0) + match[0].length;
-  }
-  chunks.push(import_drizzle_orm4.sql.raw(text2.slice(last)));
-  return import_drizzle_orm4.sql.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");
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   DEFAULT_NAMESPACE,
@@ -1004,6 +1138,7 @@ __name(drizzlePgExecutor, "drizzlePgExecutor");
   durableStepCheckpoints,
   durableWorkflowRuns,
   ensureDrizzlePgDurableSchema,
+  rowsOf,
   toDrizzleSql
 });
 //# sourceMappingURL=index.cjs.map