@dudousxd/nestjs-durable-store-drizzle 0.17.0 → 0.18.1

package/dist/index.d.ts

@@ -1,4 +1,4 @@
-import { StateStore, WorkflowRun, StepCheckpoint, RunQuery, RunFacetQuery, RunFacetRow, RunValueAxis, RunValueFacetOptions, RunValueFacetRow, SignalWaiter } from '@dudousxd/nestjs-durable-core';
+import { StateStore, WorkflowRun, RetentionPolicy, StepCheckpoint, RunQuery, RunFacetQuery, RunFacetRow, RunValueAxis, RunValueFacetOptions, RunValueFacetRow, ScheduleRecord, ScheduleQuery, SignalWaiter } from '@dudousxd/nestjs-durable-core';
 import * as drizzle_orm_sqlite_core from 'drizzle-orm/sqlite-core';
 import { BaseSQLiteDatabase } from 'drizzle-orm/sqlite-core';
 
@@ -11,13 +11,16 @@ type DrizzleSqlite = BaseSQLiteDatabase<'sync' | 'async', unknown>;
 declare class DrizzleStateStore implements StateStore {
     private readonly db;
     constructor(db: DrizzleSqlite);
+    tryAdmitSingleton(runId: string, tag: string, workflow: string, limit: number, retryWakeAt?: number): Promise<boolean>;
     createRun(run: WorkflowRun): Promise<void>;
-    updateRun(runId: string, patch: Partial<WorkflowRun>): Promise<void>;
+    updateRun(runId: string, inputPatch: Partial<WorkflowRun>): Promise<void>;
     /** Rewrite a run's normalized attribute rows: delete the old set, insert the current one. Mirrors
      *  the in-memory store's reindex so the side-table always reflects the run's live searchAttributes. */
     private reindexAttributes;
     getRun(runId: string): Promise<WorkflowRun | null>;
     deleteRun(runId: string): Promise<void>;
+    deleteRuns(runIds: string[]): Promise<void>;
+    pruneTerminalRuns(policy: RetentionPolicy, nowMs: number, limit: number): Promise<number>;
     getCheckpoint(runId: string, seq: number): Promise<StepCheckpoint | null>;
     saveCheckpoint(checkpoint: StepCheckpoint): Promise<void>;
     transaction<T>(work: (tx: {
@@ -39,6 +42,7 @@ declare class DrizzleStateStore implements StateStore {
      *  them, so a facet count and the page it labels are always taken over the same set. */
     private runFilters;
     listRuns(query: RunQuery): Promise<WorkflowRun[]>;
+    countRuns(query: Omit<RunQuery, 'limit' | 'offset'>): Promise<number>;
     /** `GROUP BY status, origin` over the same predicates {@link listRuns} pages — one aggregate, so a
      *  console can show whole-set counts next to a bounded page instead of downloading every run to
      *  count them in the browser. */
@@ -53,6 +57,11 @@ declare class DrizzleStateStore implements StateStore {
      *  contract): EXISTS already requires the key row to be present, so EXISTS(... <> ...) is exactly
      *  ne-with-present. Numeric operands compare `num_value`, everything else `str_value`. */
     private attributeExists;
+    saveSchedule(record: ScheduleRecord): Promise<void>;
+    getSchedule(id: string): Promise<ScheduleRecord | null>;
+    updateSchedule(id: string, patch: Partial<Omit<ScheduleRecord, 'id' | 'createdAt'>>, expectedNextFireAt?: number | null): Promise<boolean>;
+    deleteSchedule(id: string): Promise<boolean>;
+    listSchedules(query: ScheduleQuery): Promise<ScheduleRecord[]>;
     listCheckpoints(runId: string): Promise<StepCheckpoint[]>;
     getLatestCheckpointByName(runId: string, name: string): Promise<StepCheckpoint | undefined>;
     listCheckpointsByNamePrefix(runId: string, prefixes: string[]): Promise<StepCheckpoint[]>;
@@ -1042,6 +1051,203 @@ declare const bufferedEvents: drizzle_orm_sqlite_core.SQLiteTableWithColumns<{
     };
     dialect: "sqlite";
 }>;
+/**
+ * Persisted schedules (`engine.schedules`). `spec`/`state` are JSON documents the engine owns; the
+ * store only filters on the columns. `next_fire_at` is epoch ms, NULL when it never fires again.
+ *
+ * MIGRATION (you own this adapter's migrations): `drizzle-kit generate` picks the table up from
+ * `durableSchema`; by hand it is the `durable_schedules` CREATE TABLE + index in the package docs.
+ * Only needed if you use persisted schedules.
+ */
+declare const durableSchedules: drizzle_orm_sqlite_core.SQLiteTableWithColumns<{
+    name: "durable_schedules";
+    schema: undefined;
+    columns: {
+        id: drizzle_orm_sqlite_core.SQLiteColumn<{
+            name: "id";
+            tableName: "durable_schedules";
+            dataType: "string";
+            columnType: "SQLiteText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: true;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            length: number | undefined;
+        }>;
+        namespace: drizzle_orm_sqlite_core.SQLiteColumn<{
+            name: "namespace";
+            tableName: "durable_schedules";
+            dataType: "string";
+            columnType: "SQLiteText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            length: number | undefined;
+        }>;
+        workflow: drizzle_orm_sqlite_core.SQLiteColumn<{
+            name: "workflow";
+            tableName: "durable_schedules";
+            dataType: "string";
+            columnType: "SQLiteText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            length: number | undefined;
+        }>;
+        paused: drizzle_orm_sqlite_core.SQLiteColumn<{
+            name: "paused";
+            tableName: "durable_schedules";
+            dataType: "boolean";
+            columnType: "SQLiteBoolean";
+            data: boolean;
+            driverParam: number;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        nextFireAt: drizzle_orm_sqlite_core.SQLiteColumn<{
+            name: "next_fire_at";
+            tableName: "durable_schedules";
+            dataType: "number";
+            columnType: "SQLiteInteger";
+            data: number;
+            driverParam: number;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        tags: drizzle_orm_sqlite_core.SQLiteColumn<{
+            name: "tags";
+            tableName: "durable_schedules";
+            dataType: "json";
+            columnType: "SQLiteTextJson";
+            data: string[];
+            driverParam: string;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            $type: string[];
+        }>;
+        spec: drizzle_orm_sqlite_core.SQLiteColumn<{
+            name: "spec";
+            tableName: "durable_schedules";
+            dataType: "json";
+            columnType: "SQLiteTextJson";
+            data: Record<string, unknown>;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            $type: Record<string, unknown>;
+        }>;
+        state: drizzle_orm_sqlite_core.SQLiteColumn<{
+            name: "state";
+            tableName: "durable_schedules";
+            dataType: "json";
+            columnType: "SQLiteTextJson";
+            data: Record<string, unknown>;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            $type: Record<string, unknown>;
+        }>;
+        createdAt: drizzle_orm_sqlite_core.SQLiteColumn<{
+            name: "created_at";
+            tableName: "durable_schedules";
+            dataType: "number";
+            columnType: "SQLiteInteger";
+            data: number;
+            driverParam: number;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        updatedAt: drizzle_orm_sqlite_core.SQLiteColumn<{
+            name: "updated_at";
+            tableName: "durable_schedules";
+            dataType: "number";
+            columnType: "SQLiteInteger";
+            data: number;
+            driverParam: number;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+    };
+    dialect: "sqlite";
+}>;
 declare const durableSchema: {
     workflowRuns: drizzle_orm_sqlite_core.SQLiteTableWithColumns<{
         name: "durable_workflow_runs";
@@ -2004,6 +2210,195 @@ declare const durableSchema: {
         };
         dialect: "sqlite";
     }>;
+    durableSchedules: drizzle_orm_sqlite_core.SQLiteTableWithColumns<{
+        name: "durable_schedules";
+        schema: undefined;
+        columns: {
+            id: drizzle_orm_sqlite_core.SQLiteColumn<{
+                name: "id";
+                tableName: "durable_schedules";
+                dataType: "string";
+                columnType: "SQLiteText";
+                data: string;
+                driverParam: string;
+                notNull: true;
+                hasDefault: false;
+                isPrimaryKey: true;
+                isAutoincrement: false;
+                hasRuntimeDefault: false;
+                enumValues: [string, ...string[]];
+                baseColumn: never;
+                identity: undefined;
+                generated: undefined;
+            }, {}, {
+                length: number | undefined;
+            }>;
+            namespace: drizzle_orm_sqlite_core.SQLiteColumn<{
+                name: "namespace";
+                tableName: "durable_schedules";
+                dataType: "string";
+                columnType: "SQLiteText";
+                data: string;
+                driverParam: string;
+                notNull: true;
+                hasDefault: true;
+                isPrimaryKey: false;
+                isAutoincrement: false;
+                hasRuntimeDefault: false;
+                enumValues: [string, ...string[]];
+                baseColumn: never;
+                identity: undefined;
+                generated: undefined;
+            }, {}, {
+                length: number | undefined;
+            }>;
+            workflow: drizzle_orm_sqlite_core.SQLiteColumn<{
+                name: "workflow";
+                tableName: "durable_schedules";
+                dataType: "string";
+                columnType: "SQLiteText";
+                data: string;
+                driverParam: string;
+                notNull: true;
+                hasDefault: false;
+                isPrimaryKey: false;
+                isAutoincrement: false;
+                hasRuntimeDefault: false;
+                enumValues: [string, ...string[]];
+                baseColumn: never;
+                identity: undefined;
+                generated: undefined;
+            }, {}, {
+                length: number | undefined;
+            }>;
+            paused: drizzle_orm_sqlite_core.SQLiteColumn<{
+                name: "paused";
+                tableName: "durable_schedules";
+                dataType: "boolean";
+                columnType: "SQLiteBoolean";
+                data: boolean;
+                driverParam: number;
+                notNull: true;
+                hasDefault: true;
+                isPrimaryKey: false;
+                isAutoincrement: false;
+                hasRuntimeDefault: false;
+                enumValues: undefined;
+                baseColumn: never;
+                identity: undefined;
+                generated: undefined;
+            }, {}, {}>;
+            nextFireAt: drizzle_orm_sqlite_core.SQLiteColumn<{
+                name: "next_fire_at";
+                tableName: "durable_schedules";
+                dataType: "number";
+                columnType: "SQLiteInteger";
+                data: number;
+                driverParam: number;
+                notNull: false;
+                hasDefault: false;
+                isPrimaryKey: false;
+                isAutoincrement: false;
+                hasRuntimeDefault: false;
+                enumValues: undefined;
+                baseColumn: never;
+                identity: undefined;
+                generated: undefined;
+            }, {}, {}>;
+            tags: drizzle_orm_sqlite_core.SQLiteColumn<{
+                name: "tags";
+                tableName: "durable_schedules";
+                dataType: "json";
+                columnType: "SQLiteTextJson";
+                data: string[];
+                driverParam: string;
+                notNull: false;
+                hasDefault: false;
+                isPrimaryKey: false;
+                isAutoincrement: false;
+                hasRuntimeDefault: false;
+                enumValues: undefined;
+                baseColumn: never;
+                identity: undefined;
+                generated: undefined;
+            }, {}, {
+                $type: string[];
+            }>;
+            spec: drizzle_orm_sqlite_core.SQLiteColumn<{
+                name: "spec";
+                tableName: "durable_schedules";
+                dataType: "json";
+                columnType: "SQLiteTextJson";
+                data: Record<string, unknown>;
+                driverParam: string;
+                notNull: true;
+                hasDefault: false;
+                isPrimaryKey: false;
+                isAutoincrement: false;
+                hasRuntimeDefault: false;
+                enumValues: undefined;
+                baseColumn: never;
+                identity: undefined;
+                generated: undefined;
+            }, {}, {
+                $type: Record<string, unknown>;
+            }>;
+            state: drizzle_orm_sqlite_core.SQLiteColumn<{
+                name: "state";
+                tableName: "durable_schedules";
+                dataType: "json";
+                columnType: "SQLiteTextJson";
+                data: Record<string, unknown>;
+                driverParam: string;
+                notNull: true;
+                hasDefault: false;
+                isPrimaryKey: false;
+                isAutoincrement: false;
+                hasRuntimeDefault: false;
+                enumValues: undefined;
+                baseColumn: never;
+                identity: undefined;
+                generated: undefined;
+            }, {}, {
+                $type: Record<string, unknown>;
+            }>;
+            createdAt: drizzle_orm_sqlite_core.SQLiteColumn<{
+                name: "created_at";
+                tableName: "durable_schedules";
+                dataType: "number";
+                columnType: "SQLiteInteger";
+                data: number;
+                driverParam: number;
+                notNull: true;
+                hasDefault: false;
+                isPrimaryKey: false;
+                isAutoincrement: false;
+                hasRuntimeDefault: false;
+                enumValues: undefined;
+                baseColumn: never;
+                identity: undefined;
+                generated: undefined;
+            }, {}, {}>;
+            updatedAt: drizzle_orm_sqlite_core.SQLiteColumn<{
+                name: "updated_at";
+                tableName: "durable_schedules";
+                dataType: "number";
+                columnType: "SQLiteInteger";
+                data: number;
+                driverParam: number;
+                notNull: true;
+                hasDefault: false;
+                isPrimaryKey: false;
+                isAutoincrement: false;
+                hasRuntimeDefault: false;
+                enumValues: undefined;
+                baseColumn: never;
+                identity: undefined;
+                generated: undefined;
+            }, {}, {}>;
+        };
+        dialect: "sqlite";
+    }>;
 };
 /**
  * Tables this store creates and manages (you run the migrations — see the package README — but
@@ -2021,4 +2416,4 @@ declare const durableSchema: {
  */
 declare function durableManagedTables(): string[];
 
-export { DEFAULT_NAMESPACE, DrizzleStateStore, bufferedEvents, bufferedSignals, durableManagedTables, durableSchema, runAttributes, signalWaiters, stepCheckpoints, workflowRuns };
+export { DEFAULT_NAMESPACE, DrizzleStateStore, bufferedEvents, bufferedSignals, durableManagedTables, durableSchedules, durableSchema, runAttributes, signalWaiters, stepCheckpoints, workflowRuns };

package/dist/index.js

@@ -2,8 +2,8 @@ var __defProp = Object.defineProperty;
 var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
 
 // src/drizzle-state-store.ts
-import { RUN_VALUE_FACET_SCAN, attributePredicateOperands, axisIsRunColumn, mergeRunFacetRows, mergeRunValueFacetRows, normalizeAttributeRows, runValueFacetsFromRuns } from "@dudousxd/nestjs-durable-core";
-import { and, asc, desc, eq, exists, inArray, isNotNull, isNull, like, lte, or, sql } from "drizzle-orm";
+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, inArray, isNotNull, isNull, like, lt, lte, or, sql } from "drizzle-orm";
 
 // src/schema.ts
 import { getTableName } from "drizzle-orm";
@@ -160,13 +160,41 @@ var bufferedEvents = sqliteTable("durable_buffered_events", {
   }),
   publishedAt: integer("published_at").notNull()
 });
+var durableSchedules = sqliteTable(
+  "durable_schedules",
+  {
+    id: text("id").primaryKey(),
+    namespace: text("namespace").notNull().default(DEFAULT_NAMESPACE),
+    workflow: text("workflow").notNull(),
+    paused: integer("paused", {
+      mode: "boolean"
+    }).notNull().default(false),
+    nextFireAt: integer("next_fire_at"),
+    tags: text("tags", {
+      mode: "json"
+    }).$type(),
+    spec: text("spec", {
+      mode: "json"
+    }).$type().notNull(),
+    state: text("state", {
+      mode: "json"
+    }).$type().notNull(),
+    createdAt: integer("created_at").notNull(),
+    updatedAt: integer("updated_at").notNull()
+  },
+  // The poll's "due by T" scan: `paused = 0 AND next_fire_at <= T ORDER BY next_fire_at`.
+  (t) => [
+    index("durable_schedules_due_idx").on(t.paused, t.nextFireAt)
+  ]
+);
 var durableSchema = {
   workflowRuns,
   stepCheckpoints,
   runAttributes,
   signalWaiters,
   bufferedSignals,
-  bufferedEvents
+  bufferedEvents,
+  durableSchedules
 };
 function durableManagedTables() {
   return Object.values(durableSchema).map((table) => getTableName(table));
@@ -193,11 +221,39 @@ var DrizzleStateStore = class {
   constructor(db) {
     this.db = db;
   }
+  async tryAdmitSingleton(runId, tag, workflow, limit, retryWakeAt) {
+    return this.db.transaction((tx) => {
+      const where = and(eq(workflowRuns.workflow, workflow), inArray(workflowRuns.status, SINGLETON_ACTIVE_STATUSES));
+      const claim = /* @__PURE__ */ __name((rows) => {
+        const runs = rows.map(fromRunRow);
+        const tags = singletonAdmissionTags(runs, runId, tag, workflow, limit);
+        if (!tags) {
+          const patch = singletonAdmissionDenialPatch(runs, runId, tag, workflow, retryWakeAt);
+          if (!patch) return false;
+          const parked = tx.update(workflowRuns).set(toRunPatch(patch)).where(eq(workflowRuns.id, runId)).run();
+          return parked instanceof Promise ? parked.then(() => false) : false;
+        }
+        const written = tx.update(workflowRuns).set({
+          tags
+        }).where(eq(workflowRuns.id, runId)).run();
+        return written instanceof Promise ? written.then(() => true) : true;
+      }, "claim");
+      const read = /* @__PURE__ */ __name(() => {
+        const rows = tx.select().from(workflowRuns).where(where).all();
+        return rows instanceof Promise ? rows.then(claim) : claim(rows);
+      }, "read");
+      const locked = tx.update(workflowRuns).set({
+        workflow
+      }).where(where).run();
+      return locked instanceof Promise ? locked.then(read) : read();
+    });
+  }
   async createRun(run) {
     await this.db.insert(workflowRuns).values(toRunRow(run));
     await this.reindexAttributes(run.id, run.searchAttributes);
   }
-  async updateRun(runId, patch) {
+  async updateRun(runId, inputPatch) {
+    const patch = inputPatch.status && TERMINAL_RUN_STATUSES.includes(inputPatch.status) ? await clearTerminalSingletonAdmission(runId, inputPatch, (id) => this.getRun(id)) : inputPatch;
     const row = toRunPatch(patch);
     if (Object.keys(row).length) await this.db.update(workflowRuns).set(row).where(eq(workflowRuns.id, runId));
     if ("searchAttributes" in patch) await this.reindexAttributes(runId, patch.searchAttributes);
@@ -219,6 +275,44 @@ var DrizzleStateStore = class {
     await this.db.delete(runAttributes).where(eq(runAttributes.runId, runId));
     await this.db.delete(workflowRuns).where(eq(workflowRuns.id, runId));
   }
+  async deleteRuns(runIds) {
+    if (runIds.length === 0) return;
+    await this.db.delete(stepCheckpoints).where(inArray(stepCheckpoints.runId, runIds));
+    await this.db.delete(signalWaiters).where(inArray(signalWaiters.runId, runIds));
+    await this.db.delete(runAttributes).where(inArray(runAttributes.runId, runIds));
+    await this.db.delete(workflowRuns).where(inArray(workflowRuns.id, runIds));
+  }
+  async pruneTerminalRuns(policy, nowMs, limit) {
+    const statuses = policy.statuses.filter((s) => TERMINAL_RUN_STATUSES.includes(s));
+    if (statuses.length === 0 || limit <= 0) return 0;
+    if (policy.maxAge == null && policy.maxCount == null) return 0;
+    const scoped = this.runFilters({
+      ...policy.scope ?? {},
+      statuses
+    });
+    const ids = /* @__PURE__ */ new Set();
+    if (policy.maxAge != null) {
+      const cutoff = nowMs - parseDuration(policy.maxAge);
+      const rows = await this.db.select({
+        id: workflowRuns.id
+      }).from(workflowRuns).where(and(...scoped, lt(workflowRuns.updatedAt, cutoff))).orderBy(asc(workflowRuns.updatedAt)).limit(limit);
+      for (const r of rows) ids.add(r.id);
+    }
+    if (policy.maxCount != null && ids.size < limit) {
+      const rows = await this.db.select({
+        id: workflowRuns.id
+      }).from(workflowRuns).where(and(...scoped)).orderBy(desc(workflowRuns.updatedAt), desc(workflowRuns.id)).limit(limit).offset(policy.maxCount);
+      for (const r of rows) {
+        if (ids.size >= limit) break;
+        ids.add(r.id);
+      }
+    }
+    const doomed = [
+      ...ids
+    ].slice(0, limit);
+    await this.deleteRuns(doomed);
+    return doomed.length;
+  }
   async getCheckpoint(runId, seq) {
     const rows = await this.db.select().from(stepCheckpoints).where(and(eq(stepCheckpoints.runId, runId), eq(stepCheckpoints.seq, seq))).limit(1);
     return rows[0] ? fromCheckpointRow(rows[0]) : null;
@@ -330,6 +424,13 @@ var DrizzleStateStore = class {
     const rows = await this.db.select().from(workflowRuns).where(filters.length ? and(...filters) : void 0).orderBy(desc(workflowRuns.createdAt)).limit(query.limit ?? -1).offset(query.offset ?? 0);
     return rows.map(fromRunRow);
   }
+  async countRuns(query) {
+    const filters = this.runFilters(query);
+    const rows = await this.db.select({
+      count: sql`count(*)`
+    }).from(workflowRuns).where(filters.length ? and(...filters) : void 0);
+    return Number(rows[0]?.count ?? 0);
+  }
   /** `GROUP BY status, origin` over the same predicates {@link listRuns} pages — one aggregate, so a
   *  console can show whole-set counts next to a bounded page instead of downloading every run to
   *  count them in the browser. */
@@ -379,6 +480,36 @@ var DrizzleStateStore = class {
       one: sql`1`
     }).from(runAttributes).where(and(eq(runAttributes.runId, workflowRuns.id), eq(runAttributes.key, f.key), anyOf(comparisons))));
   }
+  // ---- persisted schedules ----------------------------------------------------------------------
+  async saveSchedule(record) {
+    const row = toScheduleRow(record);
+    await this.db.insert(durableSchedules).values(row).onConflictDoUpdate({
+      target: durableSchedules.id,
+      set: row
+    });
+  }
+  async getSchedule(id) {
+    const rows = await this.db.select().from(durableSchedules).where(eq(durableSchedules.id, id)).limit(1);
+    return rows[0] ? fromScheduleRow(rows[0]) : null;
+  }
+  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(and(eq(durableSchedules.id, id), expectedNextFireAt === void 0 ? void 0 : expectedNextFireAt === null ? isNull(durableSchedules.nextFireAt) : eq(durableSchedules.nextFireAt, expectedNextFireAt))).returning({
+      id: durableSchedules.id
+    });
+    return rows.length > 0;
+  }
+  async deleteSchedule(id) {
+    const rows = await this.db.delete(durableSchedules).where(eq(durableSchedules.id, id)).returning({
+      id: durableSchedules.id
+    });
+    return rows.length > 0;
+  }
+  async listSchedules(query) {
+    const rows = await 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 ? like(durableSchedules.tags, `%"${query.tag}"%`) : void 0, query.dueBy !== void 0 ? and(eq(durableSchedules.paused, false), lte(durableSchedules.nextFireAt, query.dueBy)) : void 0)).orderBy(sql`${durableSchedules.nextFireAt} IS NULL`, asc(durableSchedules.nextFireAt), asc(durableSchedules.id)).limit(query.limit ?? -1).offset(query.offset ?? 0);
+    return rows.map(fromScheduleRow);
+  }
   async listCheckpoints(runId) {
     const rows = await this.db.select().from(stepCheckpoints).where(eq(stepCheckpoints.runId, runId)).orderBy(asc(stepCheckpoints.seq));
     return rows.map(fromCheckpointRow);
@@ -591,12 +722,58 @@ function fromCheckpointRow(row) {
   };
 }
 __name(fromCheckpointRow, "fromCheckpointRow");
+function toScheduleRow(r) {
+  return {
+    id: r.id,
+    namespace: r.namespace,
+    workflow: r.workflow,
+    paused: r.paused,
+    nextFireAt: r.nextFireAt,
+    tags: r.tags ?? null,
+    spec: r.spec,
+    state: r.state,
+    createdAt: r.createdAt.getTime(),
+    updatedAt: r.updatedAt.getTime()
+  };
+}
+__name(toScheduleRow, "toScheduleRow");
+function toSchedulePatch(patch) {
+  const set = {};
+  if ("namespace" in patch && patch.namespace !== void 0) set.namespace = patch.namespace;
+  if ("workflow" in patch && patch.workflow !== void 0) set.workflow = patch.workflow;
+  if ("paused" in patch && patch.paused !== void 0) set.paused = patch.paused;
+  if ("nextFireAt" in patch) set.nextFireAt = patch.nextFireAt ?? null;
+  if ("tags" in patch) set.tags = patch.tags ?? null;
+  if ("spec" in patch && patch.spec !== void 0) set.spec = patch.spec;
+  if ("state" in patch && patch.state !== void 0) set.state = patch.state;
+  if ("updatedAt" in patch && patch.updatedAt !== void 0) set.updatedAt = patch.updatedAt.getTime();
+  return set;
+}
+__name(toSchedulePatch, "toSchedulePatch");
+function fromScheduleRow(row) {
+  return {
+    id: row.id,
+    namespace: row.namespace,
+    workflow: row.workflow,
+    paused: row.paused,
+    nextFireAt: row.nextFireAt ?? null,
+    ...row.tags ? {
+      tags: row.tags
+    } : {},
+    spec: row.spec ?? {},
+    state: row.state ?? {},
+    createdAt: new Date(row.createdAt),
+    updatedAt: new Date(row.updatedAt)
+  };
+}
+__name(fromScheduleRow, "fromScheduleRow");
 export {
   DEFAULT_NAMESPACE,
   DrizzleStateStore,
   bufferedEvents,
   bufferedSignals,
   durableManagedTables,
+  durableSchedules,
   durableSchema,
   runAttributes,
   signalWaiters,