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

package/dist/pg/index.d.cts

@@ -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, RunStatus, RetentionPolicy, StepCheckpoint, StoreTransaction, RunQuery, RunFacetQuery, RunFacetRow, RunValueAxis, RunValueFacetOptions, RunValueFacetRow, ScheduleRecord, ScheduleQuery, CheckpointStat, CheckpointQuery, SignalWaiter, ChildWait } from '@dudousxd/nestjs-durable-core';
+import { StateStore, WorkflowRun, RunStatus, RetentionPolicy, StepCheckpoint, StoreTransaction, OwnedLeaseReclaim, RunQuery, RunFacetQuery, RunFacetRow, RunValueAxis, RunValueFacetOptions, RunValueFacetRow, ScheduleRecord, ScheduleQuery, CheckpointStat, CheckpointQuery, SignalWaiter, ChildWait } from '@dudousxd/nestjs-durable-core';
 import { SQL } from 'drizzle-orm';
 
 /**
@@ -22,12 +22,40 @@ import { SQL } from 'drizzle-orm';
  * an existing database heals on the next boot exactly like the MikroORM / TypeORM auto-schema does.
  */
 declare const DURABLE_PG_DDL: readonly string[];
+/**
+ * Where {@link ensureDrizzlePgDurableSchema} reports a schema repair it actually applied. `console`
+ * (the default) satisfies it, and so does NestJS's `Logger`, so an app can route the warning into
+ * its own log stream.
+ */
+interface DurableSchemaLogger {
+    warn(message: string): void;
+}
+interface EnsureDrizzlePgDurableSchemaOptions {
+    /** Sink for the schema-repair warning. Defaults to `console`. */
+    logger?: DurableSchemaLogger | undefined;
+}
+/**
+ * The warning logged when the boot-time check changed an EXISTING durable schema: created a table
+ * that was missing next to ones that exist, added a column, or created an index. Never logged when
+ * the schema was already current, and never on a fresh install (no durable table existed, so
+ * creating them all is the expected first boot, not a drift).
+ *
+ * The discriminator matters more than the wording: a warning on every boot would be filtered as
+ * noise, and a silent repair hides a drizzle-kit-managed schema that has drifted from the library.
+ */
+declare function drizzlePgSchemaRepairWarning(repairs: readonly string[]): string;
 /**
  * Idempotently create the durable tables + indexes on `db` (any drizzle Postgres driver). Runs in one
  * transaction under a `pg_advisory_xact_lock`, so N pods booting together heal the schema once and
  * the rest see it done. Only ever touches the `durable_*` tables.
+ *
+ * The DDL is all `IF NOT EXISTS`, which does not say whether it created anything, so the current
+ * durable tables, columns and indexes are read from the catalog first (inside the lock) and each
+ * statement that will create something is recorded. When anything was created on an EXISTING durable
+ * schema, ONE warning listing it goes to `options.logger` (default `console`) after the transaction
+ * commits; see {@link drizzlePgSchemaRepairWarning}. A current schema and a fresh install log nothing.
  */
-declare function ensureDrizzlePgDurableSchema(db: PgDatabase<any, any, any>): Promise<void>;
+declare function ensureDrizzlePgDurableSchema(db: PgDatabase<any, any, any>, options?: EnsureDrizzlePgDurableSchemaOptions): Promise<void>;
 
 /**
  * Any drizzle Postgres database — `drizzle-orm/node-postgres`, `drizzle-orm/postgres-js`,
@@ -45,6 +73,12 @@ interface DrizzlePgStateStoreOptions {
     scope?: {
         namespace?: string | undefined;
     } | undefined;
+    /**
+     * Where `ensureSchema()` (the boot-time auto-schema) reports a schema repair it actually applied
+     * — a missing table or index it had to create. Defaults to `console`. NestJS's `Logger`
+     * satisfies it.
+     */
+    schemaLogger?: DurableSchemaLogger | undefined;
 }
 /**
  * Drizzle `StateStore` for **PostgreSQL**. Pass any drizzle Postgres db (see {@link DrizzlePgDatabase});
@@ -91,13 +125,13 @@ declare class DrizzlePgStateStore implements StateStore {
     transaction<T>(work: (tx: StoreTransaction) => Promise<T>): Promise<T>;
     /** Crash recovery. Namespace-scoped: a worker re-drives only its own tenant's runs. */
     listIncompleteRuns(namespace?: string): Promise<WorkflowRun[]>;
-    listOrphanedRuns(nowMs: number, limit: number, namespace?: string): Promise<WorkflowRun[]>;
+    listOrphanedRuns(nowMs: number, limit: number, namespace?: string, ownedBy?: OwnedLeaseReclaim): Promise<WorkflowRun[]>;
     /** FIFO pick-up, served by `durable_workflow_runs_namespace_status_idx`. The engine then leases
      *  each run with {@link tryLockRun}; the listing itself takes no locks (it runs outside a tx). */
     listPendingRuns(limit: number, namespace?: string): Promise<WorkflowRun[]>;
     listDueTimers(nowMs: number, namespace?: string, limit?: number): Promise<WorkflowRun[]>;
     tryLockRun(runId: string, owner: string, leaseUntilMs: number, nowMs: number): Promise<boolean>;
-    releaseRunLock(runId: string): Promise<void>;
+    releaseRunLock(runId: string, owner?: string): Promise<void>;
     renewRunLock(runId: string, owner: string, leaseUntilMs: number): Promise<boolean>;
     /** The predicates every run query shares — {@link listRuns} pages them, the facets group them. */
     private runFilters;
@@ -2397,4 +2431,4 @@ declare const durablePgSchema: {
  */
 declare function durablePgManagedTables(): string[];
 
-export { DEFAULT_NAMESPACE, DURABLE_PG_DDL, type DrizzlePgDatabase, type DrizzlePgSqlExecutor, DrizzlePgStateStore, type DrizzlePgStateStoreOptions, drizzlePgExecutor, durableBufferedEvents, durableBufferedSignals, durablePgManagedTables, durablePgSchema, durableRunAttributes, durableSchedules, durableSignalWaiters, durableStepCheckpoints, durableWorkflowRuns, ensureDrizzlePgDurableSchema, rowsOf, toDrizzleSql };
+export { DEFAULT_NAMESPACE, DURABLE_PG_DDL, type DrizzlePgDatabase, type DrizzlePgSqlExecutor, DrizzlePgStateStore, type DrizzlePgStateStoreOptions, type DurableSchemaLogger, type EnsureDrizzlePgDurableSchemaOptions, drizzlePgExecutor, drizzlePgSchemaRepairWarning, durableBufferedEvents, durableBufferedSignals, durablePgManagedTables, durablePgSchema, durableRunAttributes, durableSchedules, durableSignalWaiters, durableStepCheckpoints, durableWorkflowRuns, ensureDrizzlePgDurableSchema, rowsOf, toDrizzleSql };

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, RunStatus, RetentionPolicy, StepCheckpoint, StoreTransaction, RunQuery, RunFacetQuery, RunFacetRow, RunValueAxis, RunValueFacetOptions, RunValueFacetRow, ScheduleRecord, ScheduleQuery, CheckpointStat, CheckpointQuery, SignalWaiter, ChildWait } from '@dudousxd/nestjs-durable-core';
+import { StateStore, WorkflowRun, RunStatus, RetentionPolicy, StepCheckpoint, StoreTransaction, OwnedLeaseReclaim, RunQuery, RunFacetQuery, RunFacetRow, RunValueAxis, RunValueFacetOptions, RunValueFacetRow, ScheduleRecord, ScheduleQuery, CheckpointStat, CheckpointQuery, SignalWaiter, ChildWait } from '@dudousxd/nestjs-durable-core';
 import { SQL } from 'drizzle-orm';
 
 /**
@@ -22,12 +22,40 @@ import { SQL } from 'drizzle-orm';
  * an existing database heals on the next boot exactly like the MikroORM / TypeORM auto-schema does.
  */
 declare const DURABLE_PG_DDL: readonly string[];
+/**
+ * Where {@link ensureDrizzlePgDurableSchema} reports a schema repair it actually applied. `console`
+ * (the default) satisfies it, and so does NestJS's `Logger`, so an app can route the warning into
+ * its own log stream.
+ */
+interface DurableSchemaLogger {
+    warn(message: string): void;
+}
+interface EnsureDrizzlePgDurableSchemaOptions {
+    /** Sink for the schema-repair warning. Defaults to `console`. */
+    logger?: DurableSchemaLogger | undefined;
+}
+/**
+ * The warning logged when the boot-time check changed an EXISTING durable schema: created a table
+ * that was missing next to ones that exist, added a column, or created an index. Never logged when
+ * the schema was already current, and never on a fresh install (no durable table existed, so
+ * creating them all is the expected first boot, not a drift).
+ *
+ * The discriminator matters more than the wording: a warning on every boot would be filtered as
+ * noise, and a silent repair hides a drizzle-kit-managed schema that has drifted from the library.
+ */
+declare function drizzlePgSchemaRepairWarning(repairs: readonly string[]): string;
 /**
  * Idempotently create the durable tables + indexes on `db` (any drizzle Postgres driver). Runs in one
  * transaction under a `pg_advisory_xact_lock`, so N pods booting together heal the schema once and
  * the rest see it done. Only ever touches the `durable_*` tables.
+ *
+ * The DDL is all `IF NOT EXISTS`, which does not say whether it created anything, so the current
+ * durable tables, columns and indexes are read from the catalog first (inside the lock) and each
+ * statement that will create something is recorded. When anything was created on an EXISTING durable
+ * schema, ONE warning listing it goes to `options.logger` (default `console`) after the transaction
+ * commits; see {@link drizzlePgSchemaRepairWarning}. A current schema and a fresh install log nothing.
  */
-declare function ensureDrizzlePgDurableSchema(db: PgDatabase<any, any, any>): Promise<void>;
+declare function ensureDrizzlePgDurableSchema(db: PgDatabase<any, any, any>, options?: EnsureDrizzlePgDurableSchemaOptions): Promise<void>;
 
 /**
  * Any drizzle Postgres database — `drizzle-orm/node-postgres`, `drizzle-orm/postgres-js`,
@@ -45,6 +73,12 @@ interface DrizzlePgStateStoreOptions {
     scope?: {
         namespace?: string | undefined;
     } | undefined;
+    /**
+     * Where `ensureSchema()` (the boot-time auto-schema) reports a schema repair it actually applied
+     * — a missing table or index it had to create. Defaults to `console`. NestJS's `Logger`
+     * satisfies it.
+     */
+    schemaLogger?: DurableSchemaLogger | undefined;
 }
 /**
  * Drizzle `StateStore` for **PostgreSQL**. Pass any drizzle Postgres db (see {@link DrizzlePgDatabase});
@@ -91,13 +125,13 @@ declare class DrizzlePgStateStore implements StateStore {
     transaction<T>(work: (tx: StoreTransaction) => Promise<T>): Promise<T>;
     /** Crash recovery. Namespace-scoped: a worker re-drives only its own tenant's runs. */
     listIncompleteRuns(namespace?: string): Promise<WorkflowRun[]>;
-    listOrphanedRuns(nowMs: number, limit: number, namespace?: string): Promise<WorkflowRun[]>;
+    listOrphanedRuns(nowMs: number, limit: number, namespace?: string, ownedBy?: OwnedLeaseReclaim): Promise<WorkflowRun[]>;
     /** FIFO pick-up, served by `durable_workflow_runs_namespace_status_idx`. The engine then leases
      *  each run with {@link tryLockRun}; the listing itself takes no locks (it runs outside a tx). */
     listPendingRuns(limit: number, namespace?: string): Promise<WorkflowRun[]>;
     listDueTimers(nowMs: number, namespace?: string, limit?: number): Promise<WorkflowRun[]>;
     tryLockRun(runId: string, owner: string, leaseUntilMs: number, nowMs: number): Promise<boolean>;
-    releaseRunLock(runId: string): Promise<void>;
+    releaseRunLock(runId: string, owner?: string): Promise<void>;
     renewRunLock(runId: string, owner: string, leaseUntilMs: number): Promise<boolean>;
     /** The predicates every run query shares — {@link listRuns} pages them, the facets group them. */
     private runFilters;
@@ -2397,4 +2431,4 @@ declare const durablePgSchema: {
  */
 declare function durablePgManagedTables(): string[];
 
-export { DEFAULT_NAMESPACE, DURABLE_PG_DDL, type DrizzlePgDatabase, type DrizzlePgSqlExecutor, DrizzlePgStateStore, type DrizzlePgStateStoreOptions, drizzlePgExecutor, durableBufferedEvents, durableBufferedSignals, durablePgManagedTables, durablePgSchema, durableRunAttributes, durableSchedules, durableSignalWaiters, durableStepCheckpoints, durableWorkflowRuns, ensureDrizzlePgDurableSchema, rowsOf, toDrizzleSql };
+export { DEFAULT_NAMESPACE, DURABLE_PG_DDL, type DrizzlePgDatabase, type DrizzlePgSqlExecutor, DrizzlePgStateStore, type DrizzlePgStateStoreOptions, type DurableSchemaLogger, type EnsureDrizzlePgDurableSchemaOptions, drizzlePgExecutor, drizzlePgSchemaRepairWarning, durableBufferedEvents, durableBufferedSignals, durablePgManagedTables, durablePgSchema, durableRunAttributes, durableSchedules, durableSignalWaiters, durableStepCheckpoints, durableWorkflowRuns, ensureDrizzlePgDurableSchema, rowsOf, toDrizzleSql };

package/dist/pg/index.js

@@ -2,7 +2,41 @@ var __defProp = Object.defineProperty;
 var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
 
 // src/pg/ddl.ts
+import { sql as sql2 } from "drizzle-orm";
+
+// src/pg/executor.ts
 import { sql } from "drizzle-orm";
+function toDrizzleSql(text2, params = []) {
+  const chunks = [];
+  let last = 0;
+  for (const match of text2.matchAll(/\$(\d+)/g)) {
+    const index2 = Number(match[1]) - 1;
+    if (index2 < 0 || index2 >= params.length) throw new Error(`placeholder ${match[0]} has no bound parameter`);
+    chunks.push(sql.raw(text2.slice(last, match.index)), sql`${params[index2]}`);
+    last = (match.index ?? 0) + match[0].length;
+  }
+  chunks.push(sql.raw(text2.slice(last)));
+  return 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/ddl.ts
 var DURABLE_PG_DDL = [
   `CREATE TABLE IF NOT EXISTS "durable_workflow_runs" (
   "id" text PRIMARY KEY NOT NULL,
@@ -95,11 +129,71 @@ var DURABLE_PG_DDL = [
   `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) {
-  await db.transaction(async (tx) => {
-    await tx.execute(sql`SELECT pg_advisory_xact_lock(hashtext(${SCHEMA_LOCK_KEY}))`);
-    for (const statement of DURABLE_PG_DDL) await tx.execute(sql.raw(statement));
+function drizzlePgSchemaRepairWarning(repairs) {
+  return [
+    `[nestjs-durable] store-drizzle repaired the durable schema at boot: ${repairs.join("; ")}.`,
+    "The database had drifted from the schema this library version expects (it was created by an",
+    "older version, or a migration left these out), so they were applied at runtime and nothing",
+    "recorded them in your migration history. To make them permanent, generate a drizzle-kit",
+    "migration from `durablePgSchema` (or apply `DURABLE_PG_DDL` in a migration). This warning",
+    "appears only when a repair was applied; a schema that is already current logs nothing."
+  ].join(" ");
+}
+__name(drizzlePgSchemaRepairWarning, "drizzlePgSchemaRepairWarning");
+function ddlTarget(statement) {
+  const table = statement.match(/^CREATE TABLE IF NOT EXISTS "([^"]+)"/i);
+  if (table?.[1]) return {
+    kind: "table",
+    table: table[1]
+  };
+  const index2 = statement.match(/^CREATE (?:UNIQUE )?INDEX (?:CONCURRENTLY )?IF NOT EXISTS "([^"]+)" ON "([^"]+)"/i);
+  if (index2?.[1] && index2[2]) return {
+    kind: "index",
+    index: index2[1],
+    table: index2[2]
+  };
+  const column = statement.match(/^ALTER TABLE "([^"]+)" ADD COLUMN IF NOT EXISTS "([^"]+)"/i);
+  if (column?.[1] && column[2]) return {
+    kind: "column",
+    table: column[1],
+    column: column[2]
+  };
+  return void 0;
+}
+__name(ddlTarget, "ddlTarget");
+async function ensureDrizzlePgDurableSchema(db, options = {}) {
+  const logger = options.logger ?? console;
+  const { repairs, freshInstall } = await db.transaction(async (tx) => {
+    await tx.execute(sql2`SELECT pg_advisory_xact_lock(hashtext(${SCHEMA_LOCK_KEY}))`);
+    const tables = new Set(rowsOf(await tx.execute(sql2.raw("SELECT tablename AS name FROM pg_tables WHERE schemaname = current_schema() AND left(tablename, 8) = 'durable_'"))).map((row) => row.name));
+    const indexes = new Set(rowsOf(await tx.execute(sql2.raw("SELECT indexname AS name FROM pg_indexes WHERE schemaname = current_schema() AND left(tablename, 8) = 'durable_'"))).map((row) => row.name));
+    const columns = new Set(rowsOf(await tx.execute(sql2.raw("SELECT table_name || '.' || column_name AS name FROM information_schema.columns WHERE table_schema = current_schema() AND left(table_name, 8) = 'durable_'"))).map((row) => row.name));
+    const created = /* @__PURE__ */ new Set();
+    const ddlTables = /* @__PURE__ */ new Set();
+    const applied = [];
+    for (const statement of DURABLE_PG_DDL) {
+      const target = ddlTarget(statement);
+      await tx.execute(sql2.raw(statement));
+      if (!target) continue;
+      if (target.kind === "table") {
+        ddlTables.add(target.table);
+        if (!tables.has(target.table)) {
+          created.add(target.table);
+          applied.push(`created table ${target.table}`);
+        }
+      } else if (created.has(target.table)) {
+      } else if (target.kind === "index" && !indexes.has(target.index)) {
+        applied.push(`created index ${target.index} on ${target.table}`);
+      } else if (target.kind === "column" && !columns.has(`${target.table}.${target.column}`)) {
+        applied.push(`added column ${target.table}.${target.column}`);
+      }
+    }
+    return {
+      repairs: applied,
+      freshInstall: created.size === ddlTables.size
+    };
   });
+  if (repairs.length > 0 && !freshInstall) logger.warn(drizzlePgSchemaRepairWarning(repairs));
 }
 __name(ensureDrizzlePgDurableSchema, "ensureDrizzlePgDurableSchema");
 
@@ -107,38 +201,6 @@ __name(ensureDrizzlePgDurableSchema, "ensureDrizzlePgDurableSchema");
 import { RUN_VALUE_FACET_SCAN, SINGLETON_ACTIVE_STATUSES, TERMINAL_RUN_STATUSES, attributePredicateOperands, axisIsRunColumn, clearTerminalSingletonAdmission, mergeRunFacetRows, mergeRunValueFacetRows, normalizeAttributeRows, parseDuration, runValueFacetsFromRuns, singletonAdmissionDenialPatch, singletonAdmissionTags } from "@dudousxd/nestjs-durable-core";
 import { and, asc, desc, eq, exists, getTableColumns, gte, inArray, isNotNull, isNull, like, lt, lte, notInArray, or, sql as sql3 } from "drizzle-orm";
 
-// src/pg/executor.ts
-import { sql as sql2 } from "drizzle-orm";
-function toDrizzleSql(text2, params = []) {
-  const chunks = [];
-  let last = 0;
-  for (const match of text2.matchAll(/\$(\d+)/g)) {
-    const index2 = Number(match[1]) - 1;
-    if (index2 < 0 || index2 >= params.length) throw new Error(`placeholder ${match[0]} has no bound parameter`);
-    chunks.push(sql2.raw(text2.slice(last, match.index)), sql2`${params[index2]}`);
-    last = (match.index ?? 0) + match[0].length;
-  }
-  chunks.push(sql2.raw(text2.slice(last)));
-  return sql2.join(chunks);
-}
-__name(toDrizzleSql, "toDrizzleSql");
-function rowsOf(result) {
-  if (Array.isArray(result)) return result;
-  return result?.rows ?? [];
-}
-__name(rowsOf, "rowsOf");
-function drizzlePgExecutor(db) {
-  return {
-    dialect: "postgres",
-    escapeId: /* @__PURE__ */ __name((id) => `"${id.replace(/"/g, '""')}"`, "escapeId"),
-    query: /* @__PURE__ */ __name(async (text2, params) => rowsOf(await db.execute(toDrizzleSql(text2, params))), "query"),
-    transaction: /* @__PURE__ */ __name((fn) => db.transaction((tx) => fn({
-      query: /* @__PURE__ */ __name(async (text2, params) => rowsOf(await tx.execute(toDrizzleSql(text2, params))), "query")
-    })), "transaction")
-  };
-}
-__name(drizzlePgExecutor, "drizzlePgExecutor");
-
 // src/pg/schema.ts
 import { getTableName } from "drizzle-orm";
 import { bigserial, boolean, doublePrecision, index, integer, jsonb, pgTable, primaryKey, text, timestamp } from "drizzle-orm/pg-core";
@@ -310,7 +372,14 @@ function anyOf(conditions) {
 }
 __name(anyOf, "anyOf");
 function namespaceFilter(namespace) {
-  return namespace === void 0 ? void 0 : eq(durableWorkflowRuns.namespace, namespace);
+  if (namespace === void 0) return void 0;
+  if (namespace === DEFAULT_NAMESPACE || namespace === "") {
+    return inArray(durableWorkflowRuns.namespace, [
+      DEFAULT_NAMESPACE,
+      ""
+    ]);
+  }
+  return eq(durableWorkflowRuns.namespace, namespace);
 }
 __name(namespaceFilter, "namespaceFilter");
 function hasTag(tag) {
@@ -344,7 +413,9 @@ var DrizzlePgStateStore = class _DrizzlePgStateStore {
   /** Idempotent CREATE TABLE / INDEX IF NOT EXISTS under an advisory lock — called on boot when the
   *  module's `autoSchema` is on. Turn `autoSchema` off if drizzle-kit owns these tables. */
   async ensureSchema() {
-    await ensureDrizzlePgDurableSchema(this.db);
+    await ensureDrizzlePgDurableSchema(this.db, {
+      logger: this.options.schemaLogger
+    });
   }
   /** The read-scope predicate on the runs table (undefined when the store is unscoped). */
   scope() {
@@ -509,12 +580,17 @@ var DrizzlePgStateStore = class _DrizzlePgStateStore {
     ]), namespaceFilter(namespace), this.scope()));
     return rows.map(fromRunRow);
   }
-  async listOrphanedRuns(nowMs, limit, namespace) {
+  async listOrphanedRuns(nowMs, limit, namespace, ownedBy) {
     if (limit <= 0) return [];
     const rows = await this.db.select().from(durableWorkflowRuns).where(and(inArray(durableWorkflowRuns.status, [
       "running",
       "cancelling"
-    ]), or(isNull(durableWorkflowRuns.lockedUntil), lte(durableWorkflowRuns.lockedUntil, new Date(nowMs))), namespaceFilter(namespace), this.scope())).orderBy(asc(durableWorkflowRuns.createdAt)).limit(limit);
+    ]), or(
+      isNull(durableWorkflowRuns.lockedUntil),
+      lte(durableWorkflowRuns.lockedUntil, new Date(nowMs)),
+      // A live lease left by a previous process with the caller's own instance id.
+      ownedBy ? and(eq(durableWorkflowRuns.lockedBy, ownedBy.owner), lt(durableWorkflowRuns.lockedUntil, new Date(ownedBy.lockedBefore))) : void 0
+    ), namespaceFilter(namespace), this.scope())).orderBy(asc(durableWorkflowRuns.createdAt)).limit(limit);
     return rows.map(fromRunRow);
   }
   /** FIFO pick-up, served by `durable_workflow_runs_namespace_status_idx`. The engine then leases
@@ -537,11 +613,11 @@ var DrizzlePgStateStore = class _DrizzlePgStateStore {
     });
     return rows.length === 1;
   }
-  async releaseRunLock(runId) {
+  async releaseRunLock(runId, owner) {
     await this.db.update(durableWorkflowRuns).set({
       lockedBy: null,
       lockedUntil: null
-    }).where(eq(durableWorkflowRuns.id, runId));
+    }).where(owner === void 0 ? eq(durableWorkflowRuns.id, runId) : and(eq(durableWorkflowRuns.id, runId), eq(durableWorkflowRuns.lockedBy, owner)));
   }
   async renewRunLock(runId, owner, leaseUntilMs) {
     const rows = await this.db.update(durableWorkflowRuns).set({
@@ -932,7 +1008,7 @@ function toRunRow(run) {
     tags: run.tags ?? null,
     searchAttributes: run.searchAttributes ?? null,
     priority: run.priority ?? null,
-    namespace: run.namespace ?? DEFAULT_NAMESPACE,
+    namespace: run.namespace || DEFAULT_NAMESPACE,
     origin: run.origin ?? null,
     createdAt: run.createdAt,
     updatedAt: run.updatedAt
@@ -955,7 +1031,7 @@ function toRunPatch(patch) {
   if ("tags" in patch) row.tags = patch.tags ?? null;
   if ("searchAttributes" in patch) row.searchAttributes = patch.searchAttributes ?? null;
   if ("priority" in patch) row.priority = patch.priority ?? null;
-  if ("namespace" in patch) row.namespace = patch.namespace ?? DEFAULT_NAMESPACE;
+  if ("namespace" in patch) row.namespace = patch.namespace || DEFAULT_NAMESPACE;
   if ("origin" in patch) row.origin = patch.origin ?? null;
   if (patch.createdAt != null) row.createdAt = patch.createdAt;
   if (patch.updatedAt != null) row.updatedAt = patch.updatedAt;
@@ -979,7 +1055,7 @@ function fromRunRow(row) {
     tags: row.tags ?? void 0,
     searchAttributes: row.searchAttributes ?? void 0,
     priority: row.priority ?? void 0,
-    namespace: row.namespace,
+    namespace: row.namespace || DEFAULT_NAMESPACE,
     origin: row.origin ?? void 0,
     createdAt: row.createdAt,
     updatedAt: row.updatedAt
@@ -1088,6 +1164,7 @@ export {
   DURABLE_PG_DDL,
   DrizzlePgStateStore,
   drizzlePgExecutor,
+  drizzlePgSchemaRepairWarning,
   durableBufferedEvents,
   durableBufferedSignals,
   durablePgManagedTables,