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

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, SignalWaiter } from '@dudousxd/nestjs-durable-core';
+import { StateStore, WorkflowRun, RetentionPolicy, StepCheckpoint, StoreTransaction, RunQuery, RunFacetQuery, RunFacetRow, RunValueAxis, RunValueFacetOptions, RunValueFacetRow, ScheduleRecord, ScheduleQuery, SignalWaiter } from '@dudousxd/nestjs-durable-core';
 import { SQL } from 'drizzle-orm';
 
 /**
@@ -76,10 +76,12 @@ declare class DrizzlePgStateStore implements StateStore {
     ensureSchema(): Promise<void>;
     /** The read-scope predicate on the runs table (undefined when the store is unscoped). */
     private scope;
+    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>;
     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>;
@@ -96,6 +98,7 @@ declare class DrizzlePgStateStore implements StateStore {
     /** The predicates every run query shares — {@link listRuns} pages them, the facets group them. */
     private runFilters;
     listRuns(query: RunQuery): Promise<WorkflowRun[]>;
+    countRuns(query: Omit<RunQuery, 'limit' | 'offset'>): Promise<number>;
     runFacets(query: RunFacetQuery): Promise<RunFacetRow[]>;
     /** Run-table axes are an exact `GROUP BY`; the tag / attribute axes are counted over a bounded
      *  page of runs (see `RunValueFacetOptions.scan`), like the TypeORM and SQLite Drizzle adapters. */
@@ -104,6 +107,12 @@ declare class DrizzlePgStateStore implements StateStore {
      *  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. */
     private attributeExists;
+    saveSchedule(record: ScheduleRecord): Promise<void>;
+    getSchedule(id: string): Promise<ScheduleRecord | null>;
+    /** A single conditional `UPDATE … RETURNING`: the compare-and-set on `next_fire_at` is atomic. */
+    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[]>;
@@ -1076,6 +1085,189 @@ declare const durableBufferedEvents: drizzle_orm_pg_core.PgTableWithColumns<{
     };
     dialect: "pg";
 }>;
+declare const durableSchedules: drizzle_orm_pg_core.PgTableWithColumns<{
+    name: "durable_schedules";
+    schema: undefined;
+    columns: {
+        id: drizzle_orm_pg_core.PgColumn<{
+            name: "id";
+            tableName: "durable_schedules";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: true;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        namespace: drizzle_orm_pg_core.PgColumn<{
+            name: "namespace";
+            tableName: "durable_schedules";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        workflow: drizzle_orm_pg_core.PgColumn<{
+            name: "workflow";
+            tableName: "durable_schedules";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        paused: drizzle_orm_pg_core.PgColumn<{
+            name: "paused";
+            tableName: "durable_schedules";
+            dataType: "boolean";
+            columnType: "PgBoolean";
+            data: boolean;
+            driverParam: boolean;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        nextFireAt: drizzle_orm_pg_core.PgColumn<{
+            name: string;
+            tableName: "durable_schedules";
+            dataType: "date";
+            columnType: "PgTimestamp";
+            data: Date;
+            driverParam: string;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        tags: drizzle_orm_pg_core.PgColumn<{
+            name: "tags";
+            tableName: "durable_schedules";
+            dataType: "json";
+            columnType: "PgJsonb";
+            data: string[];
+            driverParam: unknown;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            $type: string[];
+        }>;
+        spec: drizzle_orm_pg_core.PgColumn<{
+            name: "spec";
+            tableName: "durable_schedules";
+            dataType: "json";
+            columnType: "PgJsonb";
+            data: Record<string, unknown>;
+            driverParam: unknown;
+            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_pg_core.PgColumn<{
+            name: "state";
+            tableName: "durable_schedules";
+            dataType: "json";
+            columnType: "PgJsonb";
+            data: Record<string, unknown>;
+            driverParam: unknown;
+            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_pg_core.PgColumn<{
+            name: string;
+            tableName: "durable_schedules";
+            dataType: "date";
+            columnType: "PgTimestamp";
+            data: Date;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        updatedAt: drizzle_orm_pg_core.PgColumn<{
+            name: string;
+            tableName: "durable_schedules";
+            dataType: "date";
+            columnType: "PgTimestamp";
+            data: Date;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+    };
+    dialect: "pg";
+}>;
 /**
  * Every durable table, keyed by the name to export it under. Spread into your drizzle-kit schema file
  * (`export const { durableWorkflowRuns, ... } = durablePgSchema;` or `export * from` the `/pg` entry)
@@ -1995,6 +2187,189 @@ declare const durablePgSchema: {
         };
         dialect: "pg";
     }>;
+    durableSchedules: drizzle_orm_pg_core.PgTableWithColumns<{
+        name: "durable_schedules";
+        schema: undefined;
+        columns: {
+            id: drizzle_orm_pg_core.PgColumn<{
+                name: "id";
+                tableName: "durable_schedules";
+                dataType: "string";
+                columnType: "PgText";
+                data: string;
+                driverParam: string;
+                notNull: true;
+                hasDefault: false;
+                isPrimaryKey: true;
+                isAutoincrement: false;
+                hasRuntimeDefault: false;
+                enumValues: [string, ...string[]];
+                baseColumn: never;
+                identity: undefined;
+                generated: undefined;
+            }, {}, {}>;
+            namespace: drizzle_orm_pg_core.PgColumn<{
+                name: "namespace";
+                tableName: "durable_schedules";
+                dataType: "string";
+                columnType: "PgText";
+                data: string;
+                driverParam: string;
+                notNull: true;
+                hasDefault: true;
+                isPrimaryKey: false;
+                isAutoincrement: false;
+                hasRuntimeDefault: false;
+                enumValues: [string, ...string[]];
+                baseColumn: never;
+                identity: undefined;
+                generated: undefined;
+            }, {}, {}>;
+            workflow: drizzle_orm_pg_core.PgColumn<{
+                name: "workflow";
+                tableName: "durable_schedules";
+                dataType: "string";
+                columnType: "PgText";
+                data: string;
+                driverParam: string;
+                notNull: true;
+                hasDefault: false;
+                isPrimaryKey: false;
+                isAutoincrement: false;
+                hasRuntimeDefault: false;
+                enumValues: [string, ...string[]];
+                baseColumn: never;
+                identity: undefined;
+                generated: undefined;
+            }, {}, {}>;
+            paused: drizzle_orm_pg_core.PgColumn<{
+                name: "paused";
+                tableName: "durable_schedules";
+                dataType: "boolean";
+                columnType: "PgBoolean";
+                data: boolean;
+                driverParam: boolean;
+                notNull: true;
+                hasDefault: true;
+                isPrimaryKey: false;
+                isAutoincrement: false;
+                hasRuntimeDefault: false;
+                enumValues: undefined;
+                baseColumn: never;
+                identity: undefined;
+                generated: undefined;
+            }, {}, {}>;
+            nextFireAt: drizzle_orm_pg_core.PgColumn<{
+                name: string;
+                tableName: "durable_schedules";
+                dataType: "date";
+                columnType: "PgTimestamp";
+                data: Date;
+                driverParam: string;
+                notNull: false;
+                hasDefault: false;
+                isPrimaryKey: false;
+                isAutoincrement: false;
+                hasRuntimeDefault: false;
+                enumValues: undefined;
+                baseColumn: never;
+                identity: undefined;
+                generated: undefined;
+            }, {}, {}>;
+            tags: drizzle_orm_pg_core.PgColumn<{
+                name: "tags";
+                tableName: "durable_schedules";
+                dataType: "json";
+                columnType: "PgJsonb";
+                data: string[];
+                driverParam: unknown;
+                notNull: false;
+                hasDefault: false;
+                isPrimaryKey: false;
+                isAutoincrement: false;
+                hasRuntimeDefault: false;
+                enumValues: undefined;
+                baseColumn: never;
+                identity: undefined;
+                generated: undefined;
+            }, {}, {
+                $type: string[];
+            }>;
+            spec: drizzle_orm_pg_core.PgColumn<{
+                name: "spec";
+                tableName: "durable_schedules";
+                dataType: "json";
+                columnType: "PgJsonb";
+                data: Record<string, unknown>;
+                driverParam: unknown;
+                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_pg_core.PgColumn<{
+                name: "state";
+                tableName: "durable_schedules";
+                dataType: "json";
+                columnType: "PgJsonb";
+                data: Record<string, unknown>;
+                driverParam: unknown;
+                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_pg_core.PgColumn<{
+                name: string;
+                tableName: "durable_schedules";
+                dataType: "date";
+                columnType: "PgTimestamp";
+                data: Date;
+                driverParam: string;
+                notNull: true;
+                hasDefault: false;
+                isPrimaryKey: false;
+                isAutoincrement: false;
+                hasRuntimeDefault: false;
+                enumValues: undefined;
+                baseColumn: never;
+                identity: undefined;
+                generated: undefined;
+            }, {}, {}>;
+            updatedAt: drizzle_orm_pg_core.PgColumn<{
+                name: string;
+                tableName: "durable_schedules";
+                dataType: "date";
+                columnType: "PgTimestamp";
+                data: Date;
+                driverParam: string;
+                notNull: true;
+                hasDefault: false;
+                isPrimaryKey: false;
+                isAutoincrement: false;
+                hasRuntimeDefault: false;
+                enumValues: undefined;
+                baseColumn: never;
+                identity: undefined;
+                generated: undefined;
+            }, {}, {}>;
+        };
+        dialect: "pg";
+    }>;
 };
 /**
  * The durable table names, derived from {@link durablePgSchema} (one list, never drifts). Feed to a
@@ -2003,4 +2378,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, 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, toDrizzleSql };

package/dist/pg/index.js

@@ -68,6 +68,18 @@ var DURABLE_PG_DDL = [
   "name" text NOT NULL,
   "payload" jsonb,
   "published_at" timestamp with time zone NOT NULL
+)`,
+  `CREATE TABLE IF NOT EXISTS "durable_schedules" (
+  "id" text PRIMARY KEY NOT NULL,
+  "namespace" text DEFAULT 'default' NOT NULL,
+  "workflow" text NOT NULL,
+  "paused" boolean DEFAULT false NOT NULL,
+  "next_fire_at" timestamp with time zone,
+  "tags" jsonb,
+  "spec" jsonb NOT NULL,
+  "state" jsonb NOT NULL,
+  "created_at" timestamp with time zone NOT NULL,
+  "updated_at" timestamp with time zone NOT NULL
 )`,
   `CREATE INDEX IF NOT EXISTS "durable_runs_status_idx" ON "durable_workflow_runs" USING btree ("status","wake_at")`,
   `CREATE INDEX IF NOT EXISTS "durable_runs_workflow_status_idx" ON "durable_workflow_runs" USING btree ("workflow","status")`,
@@ -78,7 +90,8 @@ var DURABLE_PG_DDL = [
   `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")`,
   `CREATE INDEX IF NOT EXISTS "durable_buffered_signals_token_idx" ON "durable_buffered_signals" USING btree ("token","id")`,
-  `CREATE INDEX IF NOT EXISTS "durable_buffered_events_name_published_at_idx" ON "durable_buffered_events" USING btree ("name","published_at")`
+  `CREATE INDEX IF NOT EXISTS "durable_buffered_events_name_published_at_idx" ON "durable_buffered_events" USING btree ("name","published_at")`,
+  `CREATE INDEX IF NOT EXISTS "durable_schedules_due_idx" ON "durable_schedules" USING btree ("paused","next_fire_at")`
 ];
 var SCHEMA_LOCK_KEY = "durable_schema";
 async function ensureDrizzlePgDurableSchema(db) {
@@ -90,12 +103,12 @@ async function ensureDrizzlePgDurableSchema(db) {
 __name(ensureDrizzlePgDurableSchema, "ensureDrizzlePgDurableSchema");
 
 // src/pg/drizzle-pg-state-store.ts
-import { RUN_VALUE_FACET_SCAN, TERMINAL_RUN_STATUSES, attributePredicateOperands, axisIsRunColumn, mergeRunFacetRows, mergeRunValueFacetRows, normalizeAttributeRows, parseDuration, runValueFacetsFromRuns } from "@dudousxd/nestjs-durable-core";
+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 as sql2 } from "drizzle-orm";
 
 // src/pg/schema.ts
 import { getTableName } from "drizzle-orm";
-import { bigserial, doublePrecision, index, integer, jsonb, pgTable, primaryKey, text, timestamp } from "drizzle-orm/pg-core";
+import { bigserial, boolean, doublePrecision, index, integer, jsonb, pgTable, primaryKey, text, timestamp } from "drizzle-orm/pg-core";
 var DEFAULT_NAMESPACE = "default";
 var tstz = /* @__PURE__ */ __name((name) => timestamp(name, {
   withTimezone: true,
@@ -222,13 +235,33 @@ var durableBufferedEvents = pgTable("durable_buffered_events", {
 }, (t) => [
   index("durable_buffered_events_name_published_at_idx").on(t.name, t.publishedAt)
 ]);
+var durableSchedules = pgTable(
+  "durable_schedules",
+  {
+    id: text("id").primaryKey(),
+    namespace: text("namespace").notNull().default(DEFAULT_NAMESPACE),
+    workflow: text("workflow").notNull(),
+    paused: boolean("paused").notNull().default(false),
+    nextFireAt: tstz("next_fire_at"),
+    tags: jsonb("tags").$type(),
+    spec: jsonb("spec").$type().notNull(),
+    state: jsonb("state").$type().notNull(),
+    createdAt: tstz("created_at").notNull(),
+    updatedAt: tstz("updated_at").notNull()
+  },
+  // The poll's "due by T" scan: `paused = false AND next_fire_at <= T ORDER BY next_fire_at`.
+  (t) => [
+    index("durable_schedules_due_idx").on(t.paused, t.nextFireAt)
+  ]
+);
 var durablePgSchema = {
   durableWorkflowRuns,
   durableStepCheckpoints,
   durableRunAttributes,
   durableSignalWaiters,
   durableBufferedSignals,
-  durableBufferedEvents
+  durableBufferedEvents,
+  durableSchedules
 };
 function durablePgManagedTables() {
   return Object.values(durablePgSchema).map((table) => getTableName(table));
@@ -282,13 +315,34 @@ var DrizzlePgStateStore = class _DrizzlePgStateStore {
   scope() {
     return namespaceFilter(this.scopeNamespace);
   }
+  async tryAdmitSingleton(runId, tag, workflow, limit, retryWakeAt) {
+    return this.db.transaction(async (tx) => {
+      const where = and(eq(durableWorkflowRuns.workflow, workflow), inArray(durableWorkflowRuns.status, SINGLETON_ACTIVE_STATUSES), this.scope());
+      await tx.update(durableWorkflowRuns).set({
+        workflow
+      }).where(where);
+      const rows = await tx.select().from(durableWorkflowRuns).where(where);
+      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) await tx.update(durableWorkflowRuns).set(toRunPatch(patch)).where(eq(durableWorkflowRuns.id, runId));
+        return false;
+      }
+      await tx.update(durableWorkflowRuns).set({
+        tags
+      }).where(eq(durableWorkflowRuns.id, runId));
+      return true;
+    });
+  }
   async createRun(run) {
     await this.db.transaction(async (tx) => {
       await tx.insert(durableWorkflowRuns).values(toRunRow(run));
       await reindexAttributes(tx, 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.withScope({}).getRun(id)) : inputPatch;
     const row = toRunPatch(patch);
     const reindex = "searchAttributes" in patch;
     if (!Object.keys(row).length && !reindex) return;
@@ -308,17 +362,27 @@ var DrizzlePgStateStore = class _DrizzlePgStateStore {
       ]);
     });
   }
+  async deleteRuns(runIds) {
+    if (runIds.length === 0) return;
+    await this.db.transaction(async (tx) => {
+      await deleteRunsCascade(tx, 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
+    });
     return this.db.transaction(async (tx) => {
       const ids = /* @__PURE__ */ new Set();
       if (policy.maxAge != null) {
         const cutoff = new Date(nowMs - parseDuration(policy.maxAge));
         const rows = await tx.select({
           id: durableWorkflowRuns.id
-        }).from(durableWorkflowRuns).where(and(inArray(durableWorkflowRuns.status, statuses), lt(durableWorkflowRuns.updatedAt, cutoff))).orderBy(asc(durableWorkflowRuns.updatedAt)).limit(limit).for("update", {
+        }).from(durableWorkflowRuns).where(and(...scoped, lt(durableWorkflowRuns.updatedAt, cutoff))).orderBy(asc(durableWorkflowRuns.updatedAt)).limit(limit).for("update", {
           skipLocked: true
         });
         for (const r of rows) ids.add(r.id);
@@ -326,7 +390,7 @@ var DrizzlePgStateStore = class _DrizzlePgStateStore {
       if (policy.maxCount != null && ids.size < limit) {
         const rows = await tx.select({
           id: durableWorkflowRuns.id
-        }).from(durableWorkflowRuns).where(inArray(durableWorkflowRuns.status, statuses)).orderBy(desc(durableWorkflowRuns.updatedAt), desc(durableWorkflowRuns.id)).limit(limit).offset(policy.maxCount).for("update", {
+        }).from(durableWorkflowRuns).where(and(...scoped)).orderBy(desc(durableWorkflowRuns.updatedAt), desc(durableWorkflowRuns.id)).limit(limit).offset(policy.maxCount).for("update", {
           skipLocked: true
         });
         for (const r of rows) {
@@ -425,6 +489,13 @@ var DrizzlePgStateStore = class _DrizzlePgStateStore {
     const rows = await base;
     return rows.map(fromRunRow);
   }
+  async countRuns(query) {
+    const filters = this.runFilters(query);
+    const rows = await this.db.select({
+      count: sql2`count(*)`.mapWith(Number)
+    }).from(durableWorkflowRuns).where(filters.length ? and(...filters) : void 0);
+    return rows[0]?.count ?? 0;
+  }
   async runFacets(query) {
     const filters = this.runFilters(query);
     const rows = await this.db.select({
@@ -468,6 +539,41 @@ var DrizzlePgStateStore = class _DrizzlePgStateStore {
       one: sql2`1`
     }).from(durableRunAttributes).where(and(eq(durableRunAttributes.runId, durableWorkflowRuns.id), eq(durableRunAttributes.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;
+  }
+  /** 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(and(eq(durableSchedules.id, id), expectedNextFireAt === void 0 ? void 0 : expectedNextFireAt === null ? isNull(durableSchedules.nextFireAt) : 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(eq(durableSchedules.id, id)).returning({
+      id: durableSchedules.id
+    });
+    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([
+      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();
+    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(eq(durableStepCheckpoints.runId, runId)).orderBy(asc(durableStepCheckpoints.seq));
     return rows.map(fromCheckpointRow);
@@ -703,6 +809,51 @@ 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 == null ? null : new Date(r.nextFireAt),
+    tags: r.tags ?? null,
+    spec: r.spec,
+    state: r.state,
+    createdAt: r.createdAt,
+    updatedAt: r.updatedAt
+  };
+}
+__name(toScheduleRow, "toScheduleRow");
+function toSchedulePatch(patch) {
+  const set = {};
+  if (patch.namespace !== void 0) set.namespace = patch.namespace;
+  if (patch.workflow !== void 0) set.workflow = patch.workflow;
+  if (patch.paused !== void 0) set.paused = patch.paused;
+  if ("nextFireAt" in patch) set.nextFireAt = patch.nextFireAt == null ? null : new Date(patch.nextFireAt);
+  if ("tags" in patch) set.tags = patch.tags ?? null;
+  if (patch.spec !== void 0) set.spec = patch.spec;
+  if (patch.state !== void 0) set.state = patch.state;
+  if (patch.updatedAt !== void 0) set.updatedAt = patch.updatedAt;
+  return set;
+}
+__name(toSchedulePatch, "toSchedulePatch");
+function fromScheduleRow(row) {
+  return {
+    id: row.id,
+    namespace: row.namespace,
+    workflow: row.workflow,
+    paused: row.paused,
+    nextFireAt: row.nextFireAt ? row.nextFireAt.getTime() : null,
+    ...row.tags ? {
+      tags: row.tags
+    } : {},
+    spec: row.spec ?? {},
+    state: row.state ?? {},
+    createdAt: row.createdAt,
+    updatedAt: row.updatedAt
+  };
+}
+__name(fromScheduleRow, "fromScheduleRow");
 
 // src/pg/executor.ts
 import { sql as sql3 } from "drizzle-orm";
@@ -745,6 +896,7 @@ export {
   durablePgManagedTables,
   durablePgSchema,
   durableRunAttributes,
+  durableSchedules,
   durableSignalWaiters,
   durableStepCheckpoints,
   durableWorkflowRuns,