@workglow/storage 0.2.26 → 0.2.27

package/dist/node.js

@@ -1577,6 +1577,7 @@ var IN_MEMORY_QUEUE_STORAGE = createServiceToken9("jobqueue.storage.inMemory");
 
 class InMemoryQueueStorage {
   queueName;
+  scope = "process";
   prefixValues;
   events = new EventEmitter3;
   constructor(queueName, options) {
@@ -1786,6 +1787,9 @@ class TelemetryQueueStorage {
     this.storageName = storageName;
     this.inner = inner;
   }
+  get scope() {
+    return this.inner.scope;
+  }
   add(job) {
     return traced("workglow.storage.queue.add", this.storageName, () => this.inner.add(job));
   }
@@ -1836,13 +1840,15 @@ class TelemetryQueueStorage {
   }
 }
 // src/queue-limiter/InMemoryRateLimiterStorage.ts
-import { createServiceToken as createServiceToken10, sleep as sleep2 } from "@workglow/util";
+import { createServiceToken as createServiceToken10, sleep as sleep2, uuid4 as uuid43 } from "@workglow/util";
 var IN_MEMORY_RATE_LIMITER_STORAGE = createServiceToken10("ratelimiter.storage.inMemory");
 
 class InMemoryRateLimiterStorage {
+  scope = "process";
   prefixValues;
   executions = new Map;
   nextAvailableTimes = new Map;
+  reserveChains = new Map;
   constructor(options) {
     this.prefixValues = options?.prefixValues ?? {};
   }
@@ -1851,11 +1857,67 @@ class InMemoryRateLimiterStorage {
     return prefixPart ? `${prefixPart}|${queueName}` : queueName;
   }
   async setupDatabase() {}
+  async withKeyLock(key, fn) {
+    const previous = this.reserveChains.get(key) ?? Promise.resolve();
+    let release;
+    const next = new Promise((resolve) => {
+      release = resolve;
+    });
+    this.reserveChains.set(key, next);
+    try {
+      await previous;
+      return await fn();
+    } finally {
+      release(undefined);
+      if (this.reserveChains.get(key) === next) {
+        this.reserveChains.delete(key);
+      }
+    }
+  }
+  async tryReserveExecution(queueName, maxExecutions, windowMs) {
+    const key = this.makeKey(queueName);
+    return this.withKeyLock(key, () => {
+      const now = Date.now();
+      const windowStart = new Date(now - windowMs);
+      const executions = this.executions.get(key) ?? [];
+      const live = executions.filter((e) => e.executedAt > windowStart);
+      if (live.length >= maxExecutions) {
+        if (live.length !== executions.length) {
+          this.executions.set(key, live);
+        }
+        return null;
+      }
+      const next = this.nextAvailableTimes.get(key);
+      if (next && next.getTime() > now) {
+        return null;
+      }
+      const id = uuid43();
+      live.push({ id, queueName, executedAt: new Date(now) });
+      this.executions.set(key, live);
+      return id;
+    });
+  }
+  async releaseExecution(queueName, token) {
+    if (token === null || token === undefined)
+      return;
+    const key = this.makeKey(queueName);
+    await this.withKeyLock(key, () => {
+      const executions = this.executions.get(key);
+      if (!executions || executions.length === 0)
+        return;
+      const idx = executions.findIndex((e) => e.id === token);
+      if (idx === -1)
+        return;
+      executions.splice(idx, 1);
+      this.executions.set(key, executions);
+    });
+  }
   async recordExecution(queueName) {
     await sleep2(0);
     const key = this.makeKey(queueName);
     const executions = this.executions.get(key) ?? [];
     executions.push({
+      id: uuid43(),
       queueName,
       executedAt: new Date
     });
@@ -2443,7 +2505,7 @@ import {
   getLogger as getLogger3,
   makeFingerprint as makeFingerprint5,
   sleep as sleep3,
-  uuid4 as uuid43
+  uuid4 as uuid44
 } from "@workglow/util";
 import { mkdir, readdir, readFile, rm, writeFile } from "node:fs/promises";
 import path from "node:path";
@@ -2471,7 +2533,7 @@ class FsFolderTabularStorage extends BaseTabularStorage {
     if (strategy === "autoincrement") {
       return ++this.autoIncrementCounter;
     } else {
-      return uuid43();
+      return uuid44();
     }
   }
   async put(entity) {
@@ -3423,7 +3485,7 @@ class PostgresTabularStorage extends BaseSqlTabularStorage {
 }
 // src/tabular/SqliteTabularStorage.ts
 import { Sqlite } from "@workglow/storage/sqlite";
-import { createServiceToken as createServiceToken14, uuid4 as uuid44 } from "@workglow/util";
+import { createServiceToken as createServiceToken14, uuid4 as uuid45 } from "@workglow/util";
 var SQLITE_TABULAR_REPOSITORY = createServiceToken14("storage.tabularRepository.sqlite");
 
 class SqliteTabularStorage extends BaseSqlTabularStorage {
@@ -3601,7 +3663,7 @@ class SqliteTabularStorage extends BaseSqlTabularStorage {
   }
   generateKeyValue(columnName, strategy) {
     if (strategy === "uuid") {
-      return uuid44();
+      return uuid45();
     }
     throw new Error(`SQLite autoincrement keys are generated by the database, not client-side. Column: ${columnName}`);
   }
@@ -4641,13 +4703,15 @@ class SupabaseKvStorage extends KvViaTabularStorage {
   }
 }
 // src/queue/PostgresQueueStorage.ts
-import { createServiceToken as createServiceToken21, makeFingerprint as makeFingerprint6, uuid4 as uuid45 } from "@workglow/util";
+import { createHash } from "node:crypto";
+import { createServiceToken as createServiceToken21, getLogger as getLogger4, makeFingerprint as makeFingerprint6, uuid4 as uuid46 } from "@workglow/util";
 var POSTGRES_QUEUE_STORAGE = createServiceToken21("jobqueue.storage.postgres");
 var SAFE_IDENTIFIER = /^[a-zA-Z][a-zA-Z0-9_]*$/;
 
 class PostgresQueueStorage {
   db;
   queueName;
+  scope = "cluster";
   prefixes;
   prefixValues;
   tableName;
@@ -4744,14 +4808,46 @@ class PostgresQueueStorage {
         ON ${this.tableName} (${prefixIndexPrefix}queue, status, run_after)`;
     await this.db.query(sql);
     sql = `
-      CREATE INDEX IF NOT EXISTS jobs_fingerprint${indexSuffix}_unique_idx 
+      CREATE INDEX IF NOT EXISTS jobs_fingerprint${indexSuffix}_unique_idx
         ON ${this.tableName} (${prefixIndexPrefix}queue, fingerprint, status)`;
     await this.db.query(sql);
+    const fnName = `${this.tableName}_notify`;
+    const trgName = `${this.tableName}_notify_trg`;
+    try {
+      await this.db.query(`
+        CREATE OR REPLACE FUNCTION ${fnName}() RETURNS trigger AS $fn$
+        DECLARE
+          channel TEXT := 'wglw_q_' || md5('${this.tableName}' || COALESCE(NEW.queue, OLD.queue));
+          payload TEXT;
+        BEGIN
+          payload := json_build_object(
+            'op', TG_OP,
+            'id', COALESCE(NEW.id, OLD.id),
+            'queue', COALESCE(NEW.queue, OLD.queue),
+            'status', COALESCE(NEW.status::text, OLD.status::text)
+          )::text;
+          PERFORM pg_notify(channel, payload);
+          RETURN NULL;
+        END;
+        $fn$ LANGUAGE plpgsql;
+      `);
+      await this.db.query(`DROP TRIGGER IF EXISTS ${trgName} ON ${this.tableName}`);
+      await this.db.query(`
+        CREATE TRIGGER ${trgName}
+          AFTER INSERT OR UPDATE ON ${this.tableName}
+          FOR EACH ROW EXECUTE FUNCTION ${fnName}();
+      `);
+    } catch {}
+  }
+  notifyChannelName() {
+    const tableAndQueue = `${this.tableName}${this.queueName}`;
+    const hash = createHash("md5").update(tableAndQueue).digest("hex");
+    return `wglw_q_${hash}`;
   }
   async add(job) {
     const now = new Date().toISOString();
     job.queue = this.queueName;
-    job.job_run_id = job.job_run_id ?? uuid45();
+    job.job_run_id = job.job_run_id ?? uuid46();
     job.fingerprint = await makeFingerprint6(job.input);
     job.status = JobStatus.PENDING;
     job.progress = 0;
@@ -4990,17 +5086,138 @@ class PostgresQueueStorage {
        AND completed_at <= $3${prefixConditions}`, [this.queueName, status, cutoffDate, ...prefixParams]);
   }
   subscribeToChanges(callback, options) {
-    throw new Error("subscribeToChanges is not supported for PostgresQueueStorage");
+    const poolMaybe = this.db;
+    if (typeof poolMaybe.connect !== "function") {
+      throw new Error("PostgresQueueStorage.subscribeToChanges requires a pg.Pool (got a single-connection wrapper)");
+    }
+    const pool = poolMaybe;
+    const channel = this.notifyChannelName();
+    const effectivePrefixFilter = options?.prefixFilter === undefined ? this.prefixes.length > 0 ? this.prefixValues : null : Object.keys(options.prefixFilter).length === 0 ? null : options.prefixFilter;
+    let unsubscribed = false;
+    let activeClient = null;
+    let reconnectTimer = null;
+    let backoffMs = 250;
+    const dispatch = (change) => {
+      try {
+        callback(change);
+      } catch (err) {
+        getLogger4().debug("PostgresQueueStorage subscribe callback threw", {
+          channel,
+          changeType: change.type,
+          error: err
+        });
+      }
+    };
+    const matchesPrefix = (change, filter) => {
+      const row = change.new ?? change.old;
+      if (!row)
+        return false;
+      for (const [k, v] of Object.entries(filter)) {
+        if (row[k] !== v)
+          return false;
+      }
+      return true;
+    };
+    const hydrate = async (id) => {
+      try {
+        return await this.get(id);
+      } catch {
+        return;
+      }
+    };
+    const handleNotification = (msg) => {
+      if (msg.channel !== channel || !msg.payload)
+        return;
+      let parsed;
+      try {
+        parsed = JSON.parse(msg.payload);
+      } catch {
+        return;
+      }
+      (async () => {
+        const op = parsed.op;
+        const fallback = {
+          id: parsed.id,
+          queue: parsed.queue,
+          status: parsed.status
+        };
+        const fullRow = op === "DELETE" ? undefined : await hydrate(parsed.id);
+        const change = {
+          type: op === "INSERT" ? "INSERT" : op === "DELETE" ? "DELETE" : "UPDATE",
+          new: op === "DELETE" ? undefined : fullRow ?? fallback,
+          old: op === "DELETE" ? fallback : undefined
+        };
+        if (effectivePrefixFilter && !matchesPrefix(change, effectivePrefixFilter))
+          return;
+        dispatch(change);
+      })();
+    };
+    const connect = async () => {
+      if (unsubscribed)
+        return;
+      try {
+        const client = await pool.connect();
+        if (unsubscribed) {
+          client.release();
+          return;
+        }
+        activeClient = client;
+        client.on("notification", handleNotification);
+        client.on("error", () => scheduleReconnect());
+        await client.query(`LISTEN ${channel}`);
+        backoffMs = 250;
+        dispatch({ type: "RESYNC" });
+      } catch {
+        scheduleReconnect();
+      }
+    };
+    const scheduleReconnect = () => {
+      if (unsubscribed || reconnectTimer)
+        return;
+      const c = activeClient;
+      activeClient = null;
+      try {
+        c?.removeAllListeners?.("notification");
+        c?.removeAllListeners?.("error");
+        c?.release();
+      } catch {}
+      const delay = Math.min(backoffMs, 30000);
+      backoffMs = Math.min(backoffMs * 2, 30000);
+      reconnectTimer = setTimeout(() => {
+        reconnectTimer = null;
+        connect();
+      }, delay);
+    };
+    connect();
+    return () => {
+      unsubscribed = true;
+      if (reconnectTimer) {
+        clearTimeout(reconnectTimer);
+        reconnectTimer = null;
+      }
+      const c = activeClient;
+      activeClient = null;
+      if (c) {
+        c.query(`UNLISTEN ${channel}`).catch(() => {}).finally(() => {
+          try {
+            c.removeAllListeners?.("notification");
+            c.removeAllListeners?.("error");
+            c.release();
+          } catch {}
+        });
+      }
+    };
   }
 }
 // src/queue/SqliteQueueStorage.ts
-import { createServiceToken as createServiceToken22, makeFingerprint as makeFingerprint7, sleep as sleep4, uuid4 as uuid46 } from "@workglow/util";
+import { createServiceToken as createServiceToken22, makeFingerprint as makeFingerprint7, sleep as sleep4, uuid4 as uuid47 } from "@workglow/util";
 var SQLITE_QUEUE_STORAGE = createServiceToken22("jobqueue.storage.sqlite");
 
 class SqliteQueueStorage {
   db;
   queueName;
   options;
+  scope = "process";
   prefixes;
   prefixValues;
   tableName;
@@ -5077,7 +5294,7 @@ class SqliteQueueStorage {
   }
   async add(job) {
     const now = new Date().toISOString();
-    job.job_run_id = job.job_run_id ?? uuid46();
+    job.job_run_id = job.job_run_id ?? uuid47();
     job.queue = this.queueName;
     job.fingerprint = await makeFingerprint7(job.input);
     job.status = JobStatus.PENDING;
@@ -5344,11 +5561,12 @@ class SqliteQueueStorage {
   }
 }
 // src/queue/SupabaseQueueStorage.ts
-import { createServiceToken as createServiceToken23, deepEqual as deepEqual2, makeFingerprint as makeFingerprint8, uuid4 as uuid47 } from "@workglow/util";
+import { createServiceToken as createServiceToken23, deepEqual as deepEqual2, makeFingerprint as makeFingerprint8, uuid4 as uuid48 } from "@workglow/util";
 var SUPABASE_QUEUE_STORAGE = createServiceToken23("jobqueue.storage.supabase");
 
 class SupabaseQueueStorage {
   queueName;
+  scope = "cluster";
   client;
   prefixes;
   prefixValues;
@@ -5473,7 +5691,7 @@ class SupabaseQueueStorage {
   async add(job) {
     const now = new Date().toISOString();
     job.queue = this.queueName;
-    job.job_run_id = job.job_run_id ?? uuid47();
+    job.job_run_id = job.job_run_id ?? uuid48();
     job.fingerprint = await makeFingerprint8(job.input);
     job.status = JobStatus.PENDING;
     job.progress = 0;
@@ -5876,6 +6094,7 @@ var POSTGRES_RATE_LIMITER_STORAGE = createServiceToken24("ratelimiter.storage.po
 
 class PostgresRateLimiterStorage {
   db;
+  scope = "cluster";
   prefixes;
   prefixValues;
   executionTableName;
@@ -5942,6 +6161,80 @@ class PostgresRateLimiterStorage {
       )
     `);
   }
+  async tryReserveExecution(queueName, maxExecutions, windowMs) {
+    const prefixColumnNames = this.getPrefixColumnNames();
+    const prefixParamValues = this.getPrefixParamValues();
+    const prefixCount = prefixColumnNames.length;
+    const queueParam = `$${prefixCount + 1}`;
+    const windowStartParam = `$${prefixCount + 2}`;
+    const lockKeyParts = [`'${this.executionTableName}'`];
+    for (let i = 0;i < prefixCount; i++) {
+      lockKeyParts.push(`$${i + 1}::text`);
+    }
+    lockKeyParts.push(`${queueParam}::text`);
+    const lockKeyExpr = `hashtextextended(${lockKeyParts.join(" || '|' || ")}, 0)`;
+    const prefixWhere = prefixCount > 0 ? " AND " + prefixColumnNames.map((p, i) => `${p} = $${i + 1}`).join(" AND ") : "";
+    const prefixInsertCols = prefixCount > 0 ? prefixColumnNames.join(", ") + ", " : "";
+    const prefixInsertPlaceholders = prefixCount > 0 ? prefixColumnNames.map((_, i) => `$${i + 1}`).join(", ") + ", " : "";
+    const windowStart = new Date(Date.now() - windowMs).toISOString();
+    const supportsConnect = typeof this.db.connect === "function";
+    if (!supportsConnect) {
+      const dbAny = this.db;
+      const ctorName = dbAny.constructor?.name;
+      const looksLikePGlite = typeof dbAny.exec === "function" && dbAny.waitReady !== undefined;
+      const looksLikePGLitePool = ctorName === "PGLitePool";
+      if (!looksLikePGlite && !looksLikePGLitePool) {
+        throw new Error(`PostgresRateLimiterStorage.tryReserveExecution requires a pg.Pool with connect() or a known single-connection wrapper (PGLitePool, PGlite); got ${ctorName ?? typeof this.db}. A multi-connection pool without connect() would dispatch the advisory lock and the INSERT to different sessions, breaking atomicity.`);
+      }
+    }
+    const conn = supportsConnect ? await this.db.connect() : { query: this.db.query.bind(this.db), release: () => {} };
+    try {
+      await conn.query("BEGIN");
+      try {
+        await conn.query(`SELECT pg_advisory_xact_lock(${lockKeyExpr})`, [...prefixParamValues, queueName]);
+        const countResult = await conn.query(`
+          SELECT COUNT(*)::int AS n
+          FROM ${this.executionTableName}
+          WHERE queue_name = ${queueParam} AND executed_at > ${windowStartParam}${prefixWhere}
+          `, [...prefixParamValues, queueName, windowStart]);
+        const n = countResult.rows[0]?.n ?? 0;
+        if (n >= maxExecutions) {
+          await conn.query("COMMIT");
+          return null;
+        }
+        const naResult = await conn.query(`
+          SELECT next_available_at
+          FROM ${this.nextAvailableTableName}
+          WHERE queue_name = ${queueParam}${prefixWhere}
+          `, [...prefixParamValues, queueName]);
+        const nextAvailableAt = naResult.rows[0]?.next_available_at ?? null;
+        if (nextAvailableAt && new Date(nextAvailableAt).getTime() > Date.now()) {
+          await conn.query("COMMIT");
+          return null;
+        }
+        const insertResult = await conn.query(`
+          INSERT INTO ${this.executionTableName} (${prefixInsertCols}queue_name)
+          VALUES (${prefixInsertPlaceholders}${queueParam})
+          RETURNING id
+          `, [...prefixParamValues, queueName]);
+        await conn.query("COMMIT");
+        return insertResult.rows[0]?.id ?? null;
+      } catch (err) {
+        try {
+          await conn.query("ROLLBACK");
+        } catch {}
+        throw err;
+      }
+    } finally {
+      conn.release();
+    }
+  }
+  async releaseExecution(queueName, token) {
+    if (token === null || token === undefined)
+      return;
+    const { conditions: prefixConditions, params: prefixParams } = this.buildPrefixWhereClause(3);
+    await this.db.query(`DELETE FROM ${this.executionTableName} WHERE id = $1 AND queue_name = $2${prefixConditions}`, [token, queueName, ...prefixParams]);
+  }
   async recordExecution(queueName) {
     const prefixColumnNames = this.getPrefixColumnNames();
     const prefixColumnsInsert = prefixColumnNames.length > 0 ? prefixColumnNames.join(", ") + ", " : "";
@@ -6014,6 +6307,7 @@ var SQLITE_RATE_LIMITER_STORAGE = createServiceToken25("ratelimiter.storage.sqli
 
 class SqliteRateLimiterStorage {
   db;
+  scope = "process";
   prefixes;
   prefixValues;
   executionTableName;
@@ -6077,6 +6371,55 @@ class SqliteRateLimiterStorage {
       );
     `);
   }
+  async tryReserveExecution(queueName, maxExecutions, windowMs) {
+    const prefixColumnNames = this.getPrefixColumnNames();
+    const prefixParamValues = this.getPrefixParamValues();
+    const prefixConditions = this.buildPrefixWhereClause();
+    const prefixColumnsInsert = prefixColumnNames.length > 0 ? prefixColumnNames.join(", ") + ", " : "";
+    const prefixPlaceholders = prefixColumnNames.length > 0 ? prefixColumnNames.map(() => "?").join(", ") + ", " : "";
+    const windowStart = toSQLiteTimestamp(new Date(Date.now() - windowMs));
+    let insertedId = null;
+    const txn = this.db.transaction(() => {
+      const countStmt = this.db.prepare(`
+        SELECT COUNT(*) AS count
+        FROM ${this.executionTableName}
+        WHERE queue_name = ? AND executed_at > ?${prefixConditions}
+      `);
+      const countRow = countStmt.get(queueName, windowStart, ...prefixParamValues);
+      if ((countRow?.count ?? 0) >= maxExecutions) {
+        return;
+      }
+      const naStmt = this.db.prepare(`
+        SELECT next_available_at
+        FROM ${this.nextAvailableTableName}
+        WHERE queue_name = ?${prefixConditions}
+      `);
+      const naRow = naStmt.get(queueName, ...prefixParamValues);
+      if (naRow?.next_available_at) {
+        const nextAvailable = new Date(naRow.next_available_at + "Z").getTime();
+        if (nextAvailable > Date.now()) {
+          return;
+        }
+      }
+      const insertStmt = this.db.prepare(`
+        INSERT INTO ${this.executionTableName} (${prefixColumnsInsert}queue_name)
+        VALUES (${prefixPlaceholders}?)
+      `);
+      const info = insertStmt.run(...prefixParamValues, queueName);
+      insertedId = info.lastInsertRowid;
+    });
+    txn();
+    if (insertedId == null)
+      return null;
+    return typeof insertedId === "bigint" ? Number(insertedId) : insertedId;
+  }
+  async releaseExecution(queueName, token) {
+    if (token === null || token === undefined)
+      return;
+    const prefixConditions = this.buildPrefixWhereClause();
+    const prefixParams = this.getPrefixParamValues();
+    this.db.prepare(`DELETE FROM ${this.executionTableName} WHERE id = ? AND queue_name = ?${prefixConditions}`).run(token, queueName, ...prefixParams);
+  }
   async recordExecution(queueName) {
     const prefixColumnNames = this.getPrefixColumnNames();
     const prefixColumnsInsert = prefixColumnNames.length > 0 ? prefixColumnNames.join(", ") + ", " : "";
@@ -6152,6 +6495,7 @@ import { createServiceToken as createServiceToken26 } from "@workglow/util";
 var SUPABASE_RATE_LIMITER_STORAGE = createServiceToken26("ratelimiter.storage.supabase");
 
 class SupabaseRateLimiterStorage {
+  scope = "cluster";
   client;
   prefixes;
   prefixValues;
@@ -6234,6 +6578,75 @@ class SupabaseRateLimiterStorage {
     if (nextTableError && nextTableError.code !== "42P07") {
       throw nextTableError;
     }
+    const fnName = this.atomicReserveFunctionName();
+    const prefixSig = this.prefixes.map((p) => `${p.name} ${this.getPrefixColumnType(p.type)}`).join(", ");
+    const prefixSigPrefix = prefixSig ? prefixSig + ", " : "";
+    const prefixWhere = this.prefixes.length > 0 ? " AND " + this.prefixes.map((p) => `${p.name} = _${p.name}`).join(" AND ") : "";
+    const prefixInsertCols = this.prefixes.length > 0 ? this.prefixes.map((p) => p.name).join(", ") + ", " : "";
+    const prefixInsertVals = this.prefixes.length > 0 ? this.prefixes.map((p) => `_${p.name}`).join(", ") + ", " : "";
+    const lockKeyParts = [`'${this.executionTableName}'`, ...this.prefixes.map((p) => `_${p.name}::text`), `_queue_name::text`];
+    const lockKeyExpr = `hashtextextended(${lockKeyParts.join(" || '|' || ")}, 0)`;
+    const createFnSql = `
+      CREATE OR REPLACE FUNCTION ${fnName}(
+        ${prefixSigPrefix}_queue_name TEXT, _window_start TIMESTAMPTZ, _max_exec INT
+      ) RETURNS BIGINT AS $fn$
+      DECLARE
+        _count INT;
+        _next TIMESTAMPTZ;
+        _new_id BIGINT;
+      BEGIN
+        PERFORM pg_advisory_xact_lock(${lockKeyExpr});
+        SELECT COUNT(*) INTO _count FROM ${this.executionTableName}
+          WHERE queue_name = _queue_name AND executed_at > _window_start${prefixWhere};
+        IF _count >= _max_exec THEN RETURN NULL; END IF;
+        SELECT next_available_at INTO _next FROM ${this.nextAvailableTableName}
+          WHERE queue_name = _queue_name${prefixWhere};
+        IF _next IS NOT NULL AND _next > NOW() THEN RETURN NULL; END IF;
+        INSERT INTO ${this.executionTableName} (${prefixInsertCols}queue_name)
+          VALUES (${prefixInsertVals}_queue_name)
+          RETURNING id INTO _new_id;
+        RETURN _new_id;
+      END;
+      $fn$ LANGUAGE plpgsql;
+    `;
+    const { error: fnError } = await this.client.rpc("exec_sql", { query: createFnSql });
+    if (fnError) {
+      throw fnError;
+    }
+  }
+  atomicReserveFunctionName() {
+    return `${this.executionTableName}_try_reserve`.slice(0, 63);
+  }
+  async tryReserveExecution(queueName, maxExecutions, windowMs) {
+    const args = {
+      _queue_name: queueName,
+      _window_start: new Date(Date.now() - windowMs).toISOString(),
+      _max_exec: maxExecutions
+    };
+    for (const p of this.prefixes) {
+      args[`_${p.name}`] = this.prefixValues[p.name];
+    }
+    const { data, error } = await this.client.rpc(this.atomicReserveFunctionName(), args);
+    if (error)
+      throw error;
+    if (data === null || data === undefined)
+      return null;
+    if (Array.isArray(data)) {
+      if (data.length === 0)
+        return null;
+      const first = Object.values(data[0])[0];
+      return first ?? null;
+    }
+    return data;
+  }
+  async releaseExecution(queueName, token) {
+    if (token === null || token === undefined)
+      return;
+    let del = this.client.from(this.executionTableName).delete().eq("id", token).eq("queue_name", queueName);
+    del = this.applyPrefixFilters(del);
+    const { error: delError } = await del;
+    if (delError)
+      throw delError;
   }
   async recordExecution(queueName) {
     const prefixInsertValues = this.getPrefixInsertValues();
@@ -6999,7 +7412,7 @@ class SqliteAiVectorStorage extends SqliteTabularStorage {
 import { createServiceToken as createServiceToken28 } from "@workglow/util";
 
 // src/tabular/IndexedDbTabularStorage.ts
-import { createServiceToken as createServiceToken27, deepEqual as deepEqual4, makeFingerprint as makeFingerprint9, uuid4 as uuid48 } from "@workglow/util";
+import { createServiceToken as createServiceToken27, deepEqual as deepEqual4, makeFingerprint as makeFingerprint9, uuid4 as uuid49 } from "@workglow/util";
 
 // src/util/IndexedDbTable.ts
 import { deepEqual as deepEqual3 } from "@workglow/util";
@@ -7390,7 +7803,7 @@ class IndexedDbTabularStorage extends BaseTabularStorage {
   }
   generateKeyValue(columnName, strategy) {
     if (strategy === "uuid") {
-      return uuid48();
+      return uuid49();
     }
     throw new Error(`IndexedDB autoincrement keys are generated by the database, not client-side. Column: ${columnName}`);
   }
@@ -7963,13 +8376,15 @@ class IndexedDbTabularStorage extends BaseTabularStorage {
         }
         let matches = true;
         for (const [col, crit] of Object.entries(criteria)) {
-          if (!isSearchCondition(crit))
-            continue;
           const pos = keyPathPositions.get(col);
           if (pos === undefined)
             continue;
+          if (pos < prefix.length)
+            continue;
           const valFromKey = Array.isArray(key) ? key[pos] : key;
-          if (!compareWithOperator(valFromKey, crit.operator, crit.value)) {
+          const op = isSearchCondition(crit) ? crit.operator : "=";
+          const val = isSearchCondition(crit) ? crit.value : crit;
+          if (!compareWithOperator(valFromKey, op, val)) {
             matches = false;
             break;
           }
@@ -8061,6 +8476,7 @@ import { createServiceToken as createServiceToken29 } from "@workglow/util";
 var INDEXED_DB_RATE_LIMITER_STORAGE = createServiceToken29("ratelimiter.storage.indexedDb");
 
 class IndexedDbRateLimiterStorage {
+  scope = "process";
   executionDb;
   nextAvailableDb;
   executionTableName;
@@ -8129,6 +8545,72 @@ class IndexedDbRateLimiterStorage {
     ];
     this.nextAvailableDb = await ensureIndexedDbTable(this.nextAvailableTableName, buildKeyPath(["queue_name"]).join("_"), nextAvailableIndexes, this.migrationOptions);
   }
+  async tryReserveExecution(queueName, maxExecutions, windowMs) {
+    const nextIso = await this.getNextAvailableTime(queueName);
+    if (nextIso && new Date(nextIso).getTime() > Date.now()) {
+      return null;
+    }
+    const execDb = await this.getExecutionDb();
+    const prefixKeyValues = this.getPrefixKeyValues();
+    const windowStartIso = new Date(Date.now() - windowMs).toISOString();
+    const execTx = execDb.transaction(this.executionTableName, "readwrite");
+    const execStore = execTx.objectStore(this.executionTableName);
+    const insertedId = crypto.randomUUID();
+    return new Promise((resolve, reject) => {
+      let liveCount = 0;
+      let didInsert = false;
+      const liveRange = IDBKeyRange.bound([...prefixKeyValues, queueName, windowStartIso], [...prefixKeyValues, queueName, "￿"], true, false);
+      const cursorReq = execStore.index("queue_executed_at").openCursor(liveRange);
+      cursorReq.onsuccess = (event) => {
+        const cursor = event.target.result;
+        if (cursor) {
+          const record2 = cursor.value;
+          if (this.matchesPrefixes(record2)) {
+            liveCount++;
+          }
+          cursor.continue();
+          return;
+        }
+        if (liveCount >= maxExecutions) {
+          execTx.abort();
+          return;
+        }
+        const record = {
+          id: insertedId,
+          queue_name: queueName,
+          executed_at: new Date().toISOString()
+        };
+        for (const [k, v] of Object.entries(this.prefixValues)) {
+          record[k] = v;
+        }
+        const addReq = execStore.add(record);
+        didInsert = true;
+        addReq.onerror = () => {
+          try {
+            execTx.abort();
+          } catch {}
+          reject(addReq.error);
+        };
+      };
+      cursorReq.onerror = () => reject(cursorReq.error);
+      execTx.oncomplete = () => resolve(didInsert ? insertedId : null);
+      execTx.onerror = () => reject(execTx.error);
+      execTx.onabort = () => resolve(null);
+    });
+  }
+  async releaseExecution(queueName, token) {
+    if (token === null || token === undefined)
+      return;
+    const db = await this.getExecutionDb();
+    const tx = db.transaction(this.executionTableName, "readwrite");
+    const store = tx.objectStore(this.executionTableName);
+    return new Promise((resolve, reject) => {
+      const req = store.delete(token);
+      req.onerror = () => reject(req.error);
+      tx.oncomplete = () => resolve();
+      tx.onerror = () => reject(tx.error);
+    });
+  }
   async recordExecution(queueName) {
     const db = await this.getExecutionDb();
     const tx = db.transaction(this.executionTableName, "readwrite");
@@ -8278,11 +8760,12 @@ class IndexedDbRateLimiterStorage {
   }
 }
 // src/queue/IndexedDbQueueStorage.ts
-import { createServiceToken as createServiceToken30, deepEqual as deepEqual5, makeFingerprint as makeFingerprint10, uuid4 as uuid49 } from "@workglow/util";
+import { createServiceToken as createServiceToken30, deepEqual as deepEqual5, makeFingerprint as makeFingerprint10, uuid4 as uuid410 } from "@workglow/util";
 var INDEXED_DB_QUEUE_STORAGE = createServiceToken30("jobqueue.storage.indexedDb");
 
 class IndexedDbQueueStorage {
   queueName;
+  scope = "process";
   db;
   tableName;
   migrationOptions;
@@ -8359,8 +8842,8 @@ class IndexedDbQueueStorage {
     const db = await this.getDb();
     const now = new Date().toISOString();
     const jobWithPrefixes = job;
-    jobWithPrefixes.id = jobWithPrefixes.id ?? uuid49();
-    jobWithPrefixes.job_run_id = jobWithPrefixes.job_run_id ?? uuid49();
+    jobWithPrefixes.id = jobWithPrefixes.id ?? uuid410();
+    jobWithPrefixes.job_run_id = jobWithPrefixes.job_run_id ?? uuid410();
     jobWithPrefixes.queue = this.queueName;
     jobWithPrefixes.fingerprint = await makeFingerprint10(jobWithPrefixes.input);
     jobWithPrefixes.status = JobStatus.PENDING;
@@ -8857,10 +9340,204 @@ class IndexedDbQueueStorage {
     }
   }
 }
-// src/vector/IndexedDbVectorStorage.ts
+// src/tabular/SharedInMemoryTabularStorage.ts
 import { createServiceToken as createServiceToken31 } from "@workglow/util";
+var SHARED_IN_MEMORY_TABULAR_REPOSITORY = createServiceToken31("storage.tabularRepository.sharedInMemory");
+var SYNC_TIMEOUT = 1000;
+var MAX_PENDING_MESSAGES = 1000;
+
+class SharedInMemoryTabularStorage extends BaseTabularStorage {
+  channel = null;
+  channelName;
+  inMemoryRepo;
+  isInitialized = false;
+  syncInProgress = false;
+  pendingMessages = [];
+  constructor(channelName = "tabular_store", schema, primaryKeyNames, indexes = [], clientProvidedKeys = "if-missing") {
+    super(schema, primaryKeyNames, indexes, clientProvidedKeys);
+    this.channelName = channelName;
+    this.inMemoryRepo = new InMemoryTabularStorage(schema, primaryKeyNames, indexes, clientProvidedKeys);
+    this.setupEventForwarding();
+    this.initializeBroadcastChannel();
+  }
+  isBroadcastChannelAvailable() {
+    return typeof BroadcastChannel !== "undefined";
+  }
+  initializeBroadcastChannel() {
+    if (!this.isBroadcastChannelAvailable()) {
+      console.warn("BroadcastChannel is not available. Tab synchronization will not work.");
+      return;
+    }
+    try {
+      this.channel = new BroadcastChannel(this.channelName);
+      this.channel.onmessage = (event) => {
+        this.handleBroadcastMessage(event.data);
+      };
+      this.syncFromOtherTabs();
+    } catch (error) {
+      console.error("Failed to initialize BroadcastChannel:", error);
+    }
+  }
+  setupEventForwarding() {
+    this.inMemoryRepo.on("put", (entity) => {
+      this.events.emit("put", entity);
+    });
+    this.inMemoryRepo.on("get", (key, entity) => {
+      this.events.emit("get", key, entity);
+    });
+    this.inMemoryRepo.on("query", (key, entities) => {
+      this.events.emit("query", key, entities);
+    });
+    this.inMemoryRepo.on("delete", (key) => {
+      this.events.emit("delete", key);
+    });
+    this.inMemoryRepo.on("clearall", () => {
+      this.events.emit("clearall");
+    });
+  }
+  async handleBroadcastMessage(message) {
+    if (this.syncInProgress && message.type !== "SYNC_RESPONSE") {
+      if (this.pendingMessages.length < MAX_PENDING_MESSAGES) {
+        this.pendingMessages.push(message);
+      }
+      return;
+    }
+    switch (message.type) {
+      case "SYNC_REQUEST":
+        const all = await this.inMemoryRepo.getAll();
+        if (this.channel && all) {
+          this.channel.postMessage({
+            type: "SYNC_RESPONSE",
+            data: all
+          });
+        }
+        break;
+      case "SYNC_RESPONSE":
+        if (message.data && Array.isArray(message.data)) {
+          await this.copyDataFromArray(message.data);
+        }
+        this.syncInProgress = false;
+        await this.drainPendingMessages();
+        break;
+      case "PUT":
+        await this.inMemoryRepo.put(message.entity);
+        break;
+      case "PUT_BULK":
+        await this.inMemoryRepo.putBulk(message.entities);
+        break;
+      case "DELETE":
+        await this.inMemoryRepo.delete(message.key);
+        break;
+      case "DELETE_ALL":
+        await this.inMemoryRepo.deleteAll();
+        break;
+      case "DELETE_SEARCH":
+        await this.inMemoryRepo.deleteSearch(message.criteria);
+        break;
+    }
+  }
+  async drainPendingMessages() {
+    while (!this.syncInProgress && this.pendingMessages.length > 0) {
+      const messages = this.pendingMessages;
+      this.pendingMessages = [];
+      for (const message of messages) {
+        await this.handleBroadcastMessage(message);
+        if (this.syncInProgress) {
+          break;
+        }
+      }
+    }
+  }
+  syncFromOtherTabs() {
+    if (!this.channel)
+      return;
+    this.syncInProgress = true;
+    this.channel.postMessage({ type: "SYNC_REQUEST" });
+    setTimeout(() => {
+      if (this.syncInProgress) {
+        this.syncInProgress = false;
+        this.drainPendingMessages().catch((error) => {
+          console.error("Failed to drain pending messages after sync timeout", error);
+        });
+      }
+    }, SYNC_TIMEOUT);
+  }
+  async copyDataFromArray(entities) {
+    if (entities.length === 0)
+      return;
+    await this.inMemoryRepo.deleteAll();
+    await this.inMemoryRepo.putBulk(entities);
+  }
+  broadcast(message) {
+    if (this.channel) {
+      this.channel.postMessage(message);
+    }
+  }
+  async setupDatabase() {
+    if (this.isInitialized)
+      return;
+    this.isInitialized = true;
+    await this.syncFromOtherTabs();
+  }
+  async put(value) {
+    const result = await this.inMemoryRepo.put(value);
+    this.broadcast({ type: "PUT", entity: result });
+    return result;
+  }
+  async putBulk(values) {
+    const result = await this.inMemoryRepo.putBulk(values);
+    this.broadcast({ type: "PUT_BULK", entities: result });
+    return result;
+  }
+  async get(key) {
+    return await this.inMemoryRepo.get(key);
+  }
+  async delete(value) {
+    await this.inMemoryRepo.delete(value);
+    const { key } = this.separateKeyValueFromCombined(value);
+    this.broadcast({ type: "DELETE", key });
+  }
+  async deleteAll() {
+    await this.inMemoryRepo.deleteAll();
+    this.broadcast({ type: "DELETE_ALL" });
+  }
+  async getAll(options) {
+    return await this.inMemoryRepo.getAll(options);
+  }
+  async size() {
+    return await this.inMemoryRepo.size();
+  }
+  async getBulk(offset, limit) {
+    return await this.inMemoryRepo.getBulk(offset, limit);
+  }
+  async query(criteria, options) {
+    return await this.inMemoryRepo.query(criteria, options);
+  }
+  async queryIndex(criteria, options) {
+    return await this.inMemoryRepo.queryIndex(criteria, options);
+  }
+  async deleteSearch(criteria) {
+    await this.inMemoryRepo.deleteSearch(criteria);
+    this.broadcast({
+      type: "DELETE_SEARCH",
+      criteria
+    });
+  }
+  subscribeToChanges(callback, options) {
+    return this.inMemoryRepo.subscribeToChanges(callback, options);
+  }
+  destroy() {
+    if (this.channel) {
+      this.channel.close();
+      this.channel = null;
+    }
+    this.inMemoryRepo.destroy();
+  }
+}
+// src/vector/IndexedDbVectorStorage.ts
+import { createServiceToken as createServiceToken32 } from "@workglow/util";
 import { cosineSimilarity as cosineSimilarity5 } from "@workglow/util/schema";
-var IDB_VECTOR_REPOSITORY = createServiceToken31("storage.vectorRepository.indexedDb");
+var IDB_VECTOR_REPOSITORY = createServiceToken32("storage.vectorRepository.indexedDb");
 function matchesFilter4(metadata, filter) {
   for (const [key, value] of Object.entries(filter)) {
     if (metadata[key] !== value) {
@@ -8988,6 +9665,7 @@ export {
   SqliteQueueStorage,
   SqliteKvStorage,
   SqliteAiVectorStorage,
+  SharedInMemoryTabularStorage,
   SUPABASE_TABULAR_REPOSITORY,
   SUPABASE_RATE_LIMITER_STORAGE,
   SUPABASE_QUEUE_STORAGE,
@@ -8996,6 +9674,7 @@ export {
   SQLITE_RATE_LIMITER_STORAGE,
   SQLITE_QUEUE_STORAGE,
   SQLITE_KV_REPOSITORY,
+  SHARED_IN_MEMORY_TABULAR_REPOSITORY,
   RATE_LIMITER_STORAGE,
   QUEUE_STORAGE,
   PostgresVectorStorage,
@@ -9050,4 +9729,4 @@ export {
   BaseTabularStorage
 };
 
-//# debugId=FEAE1DAF1DC5CDCE64756E2164756E21
+//# debugId=7AF69C59EB644D3464756E2164756E21