@workglow/storage 0.0.57 → 0.0.59

package/dist/node.js

@@ -106,6 +106,9 @@ class TabularRepository {
   waitOn(name) {
     return this.events.waitOn(name);
   }
+  subscribeToChanges(_callback) {
+    throw new Error(`subscribeToChanges is not implemented for ${this.constructor.name}. ` + `Use InMemoryTabularRepository or SupabaseTabularRepository for subscription support.`);
+  }
   primaryKeyColumns() {
     const columns = [];
     for (const key of Object.keys(this.primaryKeySchema.properties)) {
@@ -273,12 +276,30 @@ class InMemoryTabularRepository extends TabularRepository {
           return false;
       }
     });
-    for (const [id, _] of entriesToDelete) {
+    for (const [id, entity] of entriesToDelete) {
       this.values.delete(id);
+      const { key } = this.separateKeyValueFromCombined(entity);
+      this.events.emit("delete", key);
     }
-    if (Array.from(entriesToDelete).length > 0) {
-      this.events.emit("delete", column);
-    }
+  }
+  subscribeToChanges(callback) {
+    const handlePut = (entity) => {
+      callback({ type: "UPDATE", new: entity });
+    };
+    const handleDelete = (_key) => {
+      callback({ type: "DELETE" });
+    };
+    const handleClearAll = () => {
+      callback({ type: "DELETE" });
+    };
+    this.events.on("put", handlePut);
+    this.events.on("delete", handleDelete);
+    this.events.on("clearall", handleClearAll);
+    return () => {
+      this.events.off("put", handlePut);
+      this.events.off("delete", handleDelete);
+      this.events.off("clearall", handleClearAll);
+    };
   }
   destroy() {
     this.values.clear();
@@ -540,7 +561,7 @@ class InMemoryKvRepository extends KvViaTabularRepository {
   }
 }
 // src/queue/InMemoryQueueStorage.ts
-import { createServiceToken as createServiceToken7, makeFingerprint as makeFingerprint4, sleep, uuid4 } from "@workglow/util";
+import { createServiceToken as createServiceToken7, EventEmitter as EventEmitter3, makeFingerprint as makeFingerprint4, sleep, uuid4 } from "@workglow/util";
 
 // src/queue/IQueueStorage.ts
 import { createServiceToken as createServiceToken6 } from "@workglow/util";
@@ -560,63 +581,88 @@ var IN_MEMORY_QUEUE_STORAGE = createServiceToken7("jobqueue.storage.inMemory");
 
 class InMemoryQueueStorage {
   queueName;
-  constructor(queueName) {
+  prefixValues;
+  events = new EventEmitter3;
+  constructor(queueName, options) {
     this.queueName = queueName;
     this.jobQueue = [];
+    this.prefixValues = options?.prefixValues ?? {};
   }
   jobQueue;
+  matchesPrefixes(job) {
+    for (const [key, value] of Object.entries(this.prefixValues)) {
+      if (job[key] !== value) {
+        return false;
+      }
+    }
+    return true;
+  }
   pendingQueue() {
     const now = new Date().toISOString();
-    return this.jobQueue.filter((job) => job.status === "PENDING" /* PENDING */).filter((job) => !job.run_after || job.run_after <= now).sort((a, b) => (a.run_after || "").localeCompare(b.run_after || ""));
+    return this.jobQueue.filter((job) => this.matchesPrefixes(job)).filter((job) => job.status === "PENDING" /* PENDING */).filter((job) => !job.run_after || job.run_after <= now).sort((a, b) => (a.run_after || "").localeCompare(b.run_after || ""));
   }
   async add(job) {
     await sleep(0);
     const now = new Date().toISOString();
-    job.id = job.id ?? uuid4();
-    job.job_run_id = job.job_run_id ?? uuid4();
-    job.queue = this.queueName;
-    job.fingerprint = await makeFingerprint4(job.input);
-    job.status = "PENDING" /* PENDING */;
-    job.progress = 0;
-    job.progress_message = "";
-    job.progress_details = null;
-    job.created_at = now;
-    job.run_after = now;
-    this.jobQueue.push(job);
-    return job.id;
+    const jobWithPrefixes = job;
+    jobWithPrefixes.id = jobWithPrefixes.id ?? uuid4();
+    jobWithPrefixes.job_run_id = jobWithPrefixes.job_run_id ?? uuid4();
+    jobWithPrefixes.queue = this.queueName;
+    jobWithPrefixes.fingerprint = await makeFingerprint4(jobWithPrefixes.input);
+    jobWithPrefixes.status = "PENDING" /* PENDING */;
+    jobWithPrefixes.progress = 0;
+    jobWithPrefixes.progress_message = "";
+    jobWithPrefixes.progress_details = null;
+    jobWithPrefixes.created_at = now;
+    jobWithPrefixes.run_after = now;
+    for (const [key, value] of Object.entries(this.prefixValues)) {
+      jobWithPrefixes[key] = value;
+    }
+    this.jobQueue.push(jobWithPrefixes);
+    this.events.emit("change", { type: "INSERT", new: jobWithPrefixes });
+    return jobWithPrefixes.id;
   }
   async get(id) {
     await sleep(0);
-    return this.jobQueue.find((j) => j.id === id);
+    const job = this.jobQueue.find((j) => j.id === id);
+    if (job && this.matchesPrefixes(job)) {
+      return job;
+    }
+    return;
   }
   async peek(status = "PENDING" /* PENDING */, num = 100) {
     await sleep(0);
     num = Number(num) || 100;
-    return this.jobQueue.sort((a, b) => (a.run_after || "").localeCompare(b.run_after || "")).filter((j) => j.status === status).slice(0, num);
+    return this.jobQueue.filter((j) => this.matchesPrefixes(j)).sort((a, b) => (a.run_after || "").localeCompare(b.run_after || "")).filter((j) => j.status === status).slice(0, num);
   }
-  async next() {
+  async next(workerId) {
     await sleep(0);
     const top = this.pendingQueue();
     const job = top[0];
     if (job) {
+      const oldJob = { ...job };
       job.status = "PROCESSING" /* PROCESSING */;
       job.last_ran_at = new Date().toISOString();
+      job.worker_id = workerId ?? null;
+      this.events.emit("change", { type: "UPDATE", old: oldJob, new: job });
       return job;
     }
   }
   async size(status = "PENDING" /* PENDING */) {
     await sleep(0);
-    return this.jobQueue.filter((j) => j.status === status).length;
+    return this.jobQueue.filter((j) => this.matchesPrefixes(j) && j.status === status).length;
   }
   async saveProgress(id, progress, message, details) {
     await sleep(0);
-    const job = this.jobQueue.find((j) => j.id === id);
+    const job = this.jobQueue.find((j) => j.id === id && this.matchesPrefixes(j));
     if (!job) {
       throw new Error(`Job ${id} not found`);
     }
+    const oldJob = { ...job };
     job.progress = progress;
     job.progress_message = message;
     job.progress_details = details;
+    this.events.emit("change", { type: "UPDATE", old: oldJob, new: job });
   }
   async complete(job) {
     await sleep(0);
@@ -626,44 +672,149 @@ class InMemoryQueueStorage {
       const currentAttempts = existing?.run_attempts ?? 0;
       job.run_attempts = currentAttempts + 1;
       this.jobQueue[index] = job;
+      this.events.emit("change", { type: "UPDATE", old: existing, new: job });
     }
   }
   async abort(id) {
     await sleep(0);
-    const job = this.jobQueue.find((j) => j.id === id);
+    const job = this.jobQueue.find((j) => j.id === id && this.matchesPrefixes(j));
     if (job) {
+      const oldJob = { ...job };
       job.status = "ABORTING" /* ABORTING */;
+      this.events.emit("change", { type: "UPDATE", old: oldJob, new: job });
     }
   }
   async getByRunId(runId) {
     await sleep(0);
-    return this.jobQueue.filter((job) => job.job_run_id === runId);
+    return this.jobQueue.filter((job) => this.matchesPrefixes(job) && job.job_run_id === runId);
   }
   async deleteAll() {
     await sleep(0);
-    this.jobQueue = [];
+    const deletedJobs = this.jobQueue.filter((job) => this.matchesPrefixes(job));
+    this.jobQueue = this.jobQueue.filter((job) => !this.matchesPrefixes(job));
+    for (const job of deletedJobs) {
+      this.events.emit("change", { type: "DELETE", old: job });
+    }
   }
   async outputForInput(input) {
     await sleep(0);
     const fingerprint = await makeFingerprint4(input);
-    return this.jobQueue.find((j) => j.fingerprint === fingerprint && j.status === "COMPLETED" /* COMPLETED */)?.output ?? null;
+    return this.jobQueue.find((j) => this.matchesPrefixes(j) && j.fingerprint === fingerprint && j.status === "COMPLETED" /* COMPLETED */)?.output ?? null;
   }
   async delete(id) {
     await sleep(0);
-    this.jobQueue = this.jobQueue.filter((job) => job.id !== id);
+    const deletedJob = this.jobQueue.find((job) => job.id === id && this.matchesPrefixes(job));
+    this.jobQueue = this.jobQueue.filter((job) => !(job.id === id && this.matchesPrefixes(job)));
+    if (deletedJob) {
+      this.events.emit("change", { type: "DELETE", old: deletedJob });
+    }
   }
   async deleteJobsByStatusAndAge(status, olderThanMs) {
     await sleep(0);
     const cutoffDate = new Date(Date.now() - olderThanMs).toISOString();
-    this.jobQueue = this.jobQueue.filter((job) => job.status !== status || !job.completed_at || job.completed_at > cutoffDate);
+    const deletedJobs = this.jobQueue.filter((job) => this.matchesPrefixes(job) && job.status === status && job.completed_at && job.completed_at <= cutoffDate);
+    this.jobQueue = this.jobQueue.filter((job) => !this.matchesPrefixes(job) || job.status !== status || !job.completed_at || job.completed_at > cutoffDate);
+    for (const job of deletedJobs) {
+      this.events.emit("change", { type: "DELETE", old: job });
+    }
+  }
+  async setupDatabase() {}
+  matchesPrefixFilter(job, prefixFilter) {
+    if (prefixFilter && Object.keys(prefixFilter).length === 0) {
+      return true;
+    }
+    const filterValues = prefixFilter ?? this.prefixValues;
+    if (Object.keys(filterValues).length === 0) {
+      return true;
+    }
+    const jobWithPrefixes = job;
+    for (const [key, value] of Object.entries(filterValues)) {
+      if (jobWithPrefixes[key] !== value) {
+        return false;
+      }
+    }
+    return true;
+  }
+  subscribeToChanges(callback, options) {
+    const prefixFilter = options?.prefixFilter;
+    const filteredCallback = (change) => {
+      const newMatches = change.new ? this.matchesPrefixFilter(change.new, prefixFilter) : false;
+      const oldMatches = change.old ? this.matchesPrefixFilter(change.old, prefixFilter) : false;
+      if (!newMatches && !oldMatches) {
+        return;
+      }
+      callback(change);
+    };
+    return this.events.subscribe("change", filteredCallback);
+  }
+}
+// src/limiter/IRateLimiterStorage.ts
+import { createServiceToken as createServiceToken8 } from "@workglow/util";
+var RATE_LIMITER_STORAGE = createServiceToken8("ratelimiter.storage");
+// src/limiter/InMemoryRateLimiterStorage.ts
+import { createServiceToken as createServiceToken9, sleep as sleep2 } from "@workglow/util";
+var IN_MEMORY_RATE_LIMITER_STORAGE = createServiceToken9("ratelimiter.storage.inMemory");
+
+class InMemoryRateLimiterStorage {
+  prefixValues;
+  executions = new Map;
+  nextAvailableTimes = new Map;
+  constructor(options) {
+    this.prefixValues = options?.prefixValues ?? {};
+  }
+  makeKey(queueName) {
+    const prefixPart = Object.entries(this.prefixValues).sort(([a], [b]) => a.localeCompare(b)).map(([k, v]) => `${k}:${v}`).join("|");
+    return prefixPart ? `${prefixPart}|${queueName}` : queueName;
   }
   async setupDatabase() {}
+  async recordExecution(queueName) {
+    await sleep2(0);
+    const key = this.makeKey(queueName);
+    const executions = this.executions.get(key) ?? [];
+    executions.push({
+      queueName,
+      executedAt: new Date
+    });
+    this.executions.set(key, executions);
+  }
+  async getExecutionCount(queueName, windowStartTime) {
+    await sleep2(0);
+    const key = this.makeKey(queueName);
+    const executions = this.executions.get(key) ?? [];
+    const windowStart = new Date(windowStartTime);
+    return executions.filter((e) => e.executedAt > windowStart).length;
+  }
+  async getOldestExecutionAtOffset(queueName, offset) {
+    await sleep2(0);
+    const key = this.makeKey(queueName);
+    const executions = this.executions.get(key) ?? [];
+    const sorted = [...executions].sort((a, b) => a.executedAt.getTime() - b.executedAt.getTime());
+    const execution = sorted[offset];
+    return execution?.executedAt.toISOString();
+  }
+  async getNextAvailableTime(queueName) {
+    await sleep2(0);
+    const key = this.makeKey(queueName);
+    const time = this.nextAvailableTimes.get(key);
+    return time?.toISOString();
+  }
+  async setNextAvailableTime(queueName, nextAvailableAt) {
+    await sleep2(0);
+    const key = this.makeKey(queueName);
+    this.nextAvailableTimes.set(key, new Date(nextAvailableAt));
+  }
+  async clear(queueName) {
+    await sleep2(0);
+    const key = this.makeKey(queueName);
+    this.executions.delete(key);
+    this.nextAvailableTimes.delete(key);
+  }
 }
 // src/tabular/FsFolderTabularRepository.ts
-import { createServiceToken as createServiceToken8, sleep as sleep2 } from "@workglow/util";
+import { createServiceToken as createServiceToken10, sleep as sleep3 } from "@workglow/util";
 import { mkdir, readdir, readFile, rm, writeFile } from "node:fs/promises";
 import path from "node:path";
-var FS_FOLDER_TABULAR_REPOSITORY = createServiceToken8("storage.tabularRepository.fsFolder");
+var FS_FOLDER_TABULAR_REPOSITORY = createServiceToken10("storage.tabularRepository.fsFolder");
 
 class FsFolderTabularRepository extends TabularRepository {
   folderPath;
@@ -688,7 +839,7 @@ class FsFolderTabularRepository extends TabularRepository {
       await writeFile(filePath, JSON.stringify(entity));
     } catch (error) {
       try {
-        await sleep2(1);
+        await sleep3(1);
         await writeFile(filePath, JSON.stringify(entity));
       } catch (error2) {
         console.error("Error writing file", filePath, error2);
@@ -772,7 +923,7 @@ class FsFolderTabularRepository extends TabularRepository {
   }
 }
 // src/tabular/PostgresTabularRepository.ts
-import { createServiceToken as createServiceToken9 } from "@workglow/util";
+import { createServiceToken as createServiceToken11 } from "@workglow/util";
 
 // src/tabular/BaseSqlTabularRepository.ts
 class BaseSqlTabularRepository extends TabularRepository {
@@ -958,7 +1109,7 @@ class BaseSqlTabularRepository extends TabularRepository {
 }
 
 // src/tabular/PostgresTabularRepository.ts
-var POSTGRES_TABULAR_REPOSITORY = createServiceToken9("storage.tabularRepository.postgres");
+var POSTGRES_TABULAR_REPOSITORY = createServiceToken11("storage.tabularRepository.postgres");
 
 class PostgresTabularRepository extends BaseSqlTabularRepository {
   db;
@@ -1316,8 +1467,8 @@ class PostgresTabularRepository extends BaseSqlTabularRepository {
 }
 // src/tabular/SqliteTabularRepository.ts
 import { Sqlite } from "@workglow/sqlite";
-import { createServiceToken as createServiceToken10 } from "@workglow/util";
-var SQLITE_TABULAR_REPOSITORY = createServiceToken10("storage.tabularRepository.sqlite");
+import { createServiceToken as createServiceToken12 } from "@workglow/util";
+var SQLITE_TABULAR_REPOSITORY = createServiceToken12("storage.tabularRepository.sqlite");
 var Database = Sqlite.Database;
 
 class SqliteTabularRepository extends BaseSqlTabularRepository {
@@ -1368,13 +1519,31 @@ class SqliteTabularRepository extends BaseSqlTabularRepository {
     return this.db;
   }
   jsToSqlValue(column, value) {
+    if (value !== null && value !== undefined && typeof value === "object") {
+      if (value instanceof Date) {
+        return super.jsToSqlValue(column, value);
+      }
+      if (value instanceof Uint8Array) {
+        return super.jsToSqlValue(column, value);
+      }
+      if (typeof Buffer !== "undefined" && value instanceof Buffer) {
+        return super.jsToSqlValue(column, value);
+      }
+      return JSON.stringify(value);
+    }
+    if (value === null) {
+      const typeDef2 = this.schema.properties[column];
+      if (typeDef2 && this.isNullable(typeDef2)) {
+        return null;
+      }
+    }
     const typeDef = this.schema.properties[column];
     if (typeDef) {
       const actualType = this.getNonNullType(typeDef);
-      if (typeof actualType !== "boolean" && actualType.type === "boolean") {
-        if (value === null && this.isNullable(typeDef)) {
-          return null;
-        }
+      const isObject = typeDef === true || typeof actualType !== "boolean" && actualType.type === "object";
+      const isArray = typeDef === true || typeof actualType !== "boolean" && actualType.type === "array";
+      const isBoolean = typeDef === true || typeof actualType !== "boolean" && actualType.type === "boolean";
+      if (isBoolean) {
         const v = value;
         if (typeof v === "boolean")
           return v ? 1 : 0;
@@ -1383,8 +1552,22 @@ class SqliteTabularRepository extends BaseSqlTabularRepository {
         if (typeof v === "string")
           return v === "1" || v.toLowerCase() === "true" ? 1 : 0;
       }
+      if ((isObject || isArray) && value !== null && typeof value === "object") {
+        if (!(value instanceof Date) && !(value instanceof Uint8Array) && (typeof Buffer === "undefined" || !(value instanceof Buffer))) {
+          if (Array.isArray(value) || Object.getPrototypeOf(value) === Object.prototype) {
+            return JSON.stringify(value);
+          }
+        }
+      }
+    }
+    const result = super.jsToSqlValue(column, value);
+    if (result !== null && typeof result === "object") {
+      const resultObj = result;
+      if (!(resultObj instanceof Uint8Array) && (typeof Buffer === "undefined" || !(resultObj instanceof Buffer))) {
+        return JSON.stringify(resultObj);
+      }
     }
-    return super.jsToSqlValue(column, value);
+    return result;
   }
   sqlToJsValue(column, value) {
     const typeDef = this.schema.properties[column];
@@ -1393,14 +1576,27 @@ class SqliteTabularRepository extends BaseSqlTabularRepository {
         return null;
       }
       const actualType = this.getNonNullType(typeDef);
-      if (typeof actualType !== "boolean" && actualType.type === "boolean") {
+      const isObject = typeDef === true || typeof actualType !== "boolean" && actualType.type === "object";
+      const isArray = typeDef === true || typeof actualType !== "boolean" && actualType.type === "array";
+      const isBoolean = typeDef === true || typeof actualType !== "boolean" && actualType.type === "boolean";
+      if (isBoolean) {
         const v = value;
         if (typeof v === "boolean")
           return v;
         if (typeof v === "number")
-          return v !== 0;
+          return v !== 0 ? true : false;
         if (typeof v === "string")
-          return v === "1" || v.toLowerCase() === "true";
+          return v === "1" || v.toLowerCase() === "true" ? true : false;
+      }
+      if (isArray || isObject) {
+        if (typeof value === "string") {
+          try {
+            return JSON.parse(value);
+          } catch (e) {
+            return value;
+          }
+        }
+        return value;
       }
     }
     return super.sqlToJsValue(column, value);
@@ -1452,6 +1648,50 @@ class SqliteTabularRepository extends BaseSqlTabularRepository {
     const primaryKeyParams = this.getPrimaryKeyAsOrderedArray(key);
     const valueParams = this.getValueAsOrderedArray(value);
     const params = [...primaryKeyParams, ...valueParams];
+    for (let i = 0;i < params.length; i++) {
+      let param = params[i];
+      if (param === undefined) {
+        params[i] = null;
+        continue;
+      }
+      if (param !== null && typeof param === "object") {
+        const paramObj = param;
+        if (paramObj instanceof Uint8Array) {
+          continue;
+        }
+        if (typeof Buffer !== "undefined" && paramObj instanceof Buffer) {
+          params[i] = new Uint8Array(paramObj);
+          continue;
+        }
+        try {
+          params[i] = JSON.stringify(paramObj);
+        } catch (e) {
+          throw new Error(`Failed to stringify param at index ${i} for column binding: ${String(e)}`);
+        }
+        continue;
+      }
+    }
+    const invalidParams = [];
+    for (let i = 0;i < params.length; i++) {
+      const param = params[i];
+      if (param === null || param === undefined || typeof param === "string" || typeof param === "number" || typeof param === "boolean" || typeof param === "bigint") {
+        continue;
+      }
+      if (typeof param === "object") {
+        const paramObj = param;
+        if (paramObj instanceof Uint8Array || typeof Buffer !== "undefined" && paramObj instanceof Buffer) {
+          continue;
+        }
+        invalidParams.push({ index: i, type: typeof param, value: param });
+      } else {
+        invalidParams.push({ index: i, type: typeof param, value: param });
+      }
+    }
+    if (invalidParams.length > 0) {
+      console.error("Invalid params detected:", invalidParams);
+      console.error("All params:", params.map((p, i) => ({ i, type: typeof p, value: p, isArray: Array.isArray(p) })));
+      throw new Error(`Invalid SQLite params detected at indices: ${invalidParams.map((p) => p.index).join(", ")}`);
+    }
     const updatedEntity = stmt.get(...params);
     for (const k in this.schema.properties) {
       updatedEntity[k] = this.sqlToJsValue(k, updatedEntity[k]);
@@ -1479,6 +1719,17 @@ class SqliteTabularRepository extends BaseSqlTabularRepository {
         const primaryKeyParams = this.getPrimaryKeyAsOrderedArray(key);
         const valueParams = this.getValueAsOrderedArray(value);
         const params = [...primaryKeyParams, ...valueParams];
+        for (let i = 0;i < params.length; i++) {
+          let param = params[i];
+          if (param === undefined) {
+            params[i] = null;
+          } else if (param !== null && typeof param === "object") {
+            const paramObj = param;
+            if (!(paramObj instanceof Uint8Array) && (typeof Buffer === "undefined" || !(paramObj instanceof Buffer))) {
+              params[i] = JSON.stringify(paramObj);
+            }
+          }
+        }
         const updatedEntity = stmt.get(...params);
         for (const k in this.schema.properties) {
           updatedEntity[k] = this.sqlToJsValue(k, updatedEntity[k]);
@@ -1594,11 +1845,12 @@ class SqliteTabularRepository extends BaseSqlTabularRepository {
   }
 }
 // src/tabular/SupabaseTabularRepository.ts
-import { createServiceToken as createServiceToken11 } from "@workglow/util";
-var SUPABASE_TABULAR_REPOSITORY = createServiceToken11("storage.tabularRepository.supabase");
+import { createServiceToken as createServiceToken13 } from "@workglow/util";
+var SUPABASE_TABULAR_REPOSITORY = createServiceToken13("storage.tabularRepository.supabase");
 
 class SupabaseTabularRepository extends BaseSqlTabularRepository {
   client;
+  realtimeChannel = null;
   constructor(client, table = "tabular_store", schema, primaryKeyNames, indexes = []) {
     super(table, schema, primaryKeyNames, indexes);
     this.client = client;
@@ -1971,10 +2223,44 @@ class SupabaseTabularRepository extends BaseSqlTabularRepository {
       throw error;
     this.events.emit("delete", column);
   }
+  convertRealtimeRow(row) {
+    const entity = { ...row };
+    for (const key in this.schema.properties) {
+      entity[key] = this.sqlToJsValue(key, row[key]);
+    }
+    return entity;
+  }
+  subscribeToChanges(callback) {
+    const channelName = `tabular-${this.table}-${Date.now()}`;
+    this.realtimeChannel = this.client.channel(channelName).on("postgres_changes", {
+      event: "*",
+      schema: "public",
+      table: this.table
+    }, (payload) => {
+      const change = {
+        type: payload.eventType.toUpperCase(),
+        old: payload.old && Object.keys(payload.old).length > 0 ? this.convertRealtimeRow(payload.old) : undefined,
+        new: payload.new && Object.keys(payload.new).length > 0 ? this.convertRealtimeRow(payload.new) : undefined
+      };
+      callback(change);
+    }).subscribe();
+    return () => {
+      if (this.realtimeChannel) {
+        this.client.removeChannel(this.realtimeChannel);
+        this.realtimeChannel = null;
+      }
+    };
+  }
+  destroy() {
+    if (this.realtimeChannel) {
+      this.client.removeChannel(this.realtimeChannel);
+      this.realtimeChannel = null;
+    }
+  }
 }
 // src/kv/FsFolderJsonKvRepository.ts
-import { createServiceToken as createServiceToken12 } from "@workglow/util";
-var FS_FOLDER_JSON_KV_REPOSITORY = createServiceToken12("storage.kvRepository.fsFolderJson");
+import { createServiceToken as createServiceToken14 } from "@workglow/util";
+var FS_FOLDER_JSON_KV_REPOSITORY = createServiceToken14("storage.kvRepository.fsFolderJson");
 
 class FsFolderJsonKvRepository extends KvViaTabularRepository {
   folderPath;
@@ -1986,10 +2272,10 @@ class FsFolderJsonKvRepository extends KvViaTabularRepository {
   }
 }
 // src/kv/FsFolderKvRepository.ts
-import { createServiceToken as createServiceToken13 } from "@workglow/util";
+import { createServiceToken as createServiceToken15 } from "@workglow/util";
 import { mkdir as mkdir2, readFile as readFile2, rm as rm2, unlink, writeFile as writeFile2 } from "fs/promises";
 import path2 from "path";
-var FS_FOLDER_KV_REPOSITORY = createServiceToken13("storage.kvRepository.fsFolder");
+var FS_FOLDER_KV_REPOSITORY = createServiceToken15("storage.kvRepository.fsFolder");
 
 class FsFolderKvRepository extends KvRepository {
   folderPath;
@@ -2066,8 +2352,8 @@ class FsFolderKvRepository extends KvRepository {
   }
 }
 // src/kv/PostgresKvRepository.ts
-import { createServiceToken as createServiceToken14 } from "@workglow/util";
-var POSTGRES_KV_REPOSITORY = createServiceToken14("storage.kvRepository.postgres");
+import { createServiceToken as createServiceToken16 } from "@workglow/util";
+var POSTGRES_KV_REPOSITORY = createServiceToken16("storage.kvRepository.postgres");
 
 class PostgresKvRepository extends KvViaTabularRepository {
   db;
@@ -2081,8 +2367,8 @@ class PostgresKvRepository extends KvViaTabularRepository {
   }
 }
 // src/kv/SqliteKvRepository.ts
-import { createServiceToken as createServiceToken15 } from "@workglow/util";
-var SQLITE_KV_REPOSITORY = createServiceToken15("storage.kvRepository.sqlite");
+import { createServiceToken as createServiceToken17 } from "@workglow/util";
+var SQLITE_KV_REPOSITORY = createServiceToken17("storage.kvRepository.sqlite");
 
 class SqliteKvRepository extends KvViaTabularRepository {
   db;
@@ -2096,8 +2382,8 @@ class SqliteKvRepository extends KvViaTabularRepository {
   }
 }
 // src/kv/SupabaseKvRepository.ts
-import { createServiceToken as createServiceToken16 } from "@workglow/util";
-var SUPABASE_KV_REPOSITORY = createServiceToken16("storage.kvRepository.supabase");
+import { createServiceToken as createServiceToken18 } from "@workglow/util";
+var SUPABASE_KV_REPOSITORY = createServiceToken18("storage.kvRepository.supabase");
 
 class SupabaseKvRepository extends KvViaTabularRepository {
   client;
@@ -2111,15 +2397,169 @@ class SupabaseKvRepository extends KvViaTabularRepository {
   }
 }
 // src/queue/PostgresQueueStorage.ts
-import { createServiceToken as createServiceToken17, makeFingerprint as makeFingerprint5, uuid4 as uuid42 } from "@workglow/util";
-var POSTGRES_QUEUE_STORAGE = createServiceToken17("jobqueue.storage.postgres");
+import { createServiceToken as createServiceToken19, makeFingerprint as makeFingerprint5, uuid4 as uuid42 } from "@workglow/util";
+
+// src/util/PollingSubscriptionManager.ts
+class PollingSubscriptionManager {
+  intervals = new Map;
+  lastKnownState = new Map;
+  initialized = false;
+  fetchState;
+  compareItems;
+  payloadFactory;
+  defaultIntervalMs;
+  constructor(fetchState, compareItems, payloadFactory, options) {
+    this.fetchState = fetchState;
+    this.compareItems = compareItems;
+    this.payloadFactory = payloadFactory;
+    this.defaultIntervalMs = options?.defaultIntervalMs ?? 1000;
+  }
+  subscribe(callback, options) {
+    const interval = options?.intervalMs ?? this.defaultIntervalMs;
+    const subscription = {
+      callback,
+      intervalMs: interval
+    };
+    let intervalGroup = this.intervals.get(interval);
+    if (!intervalGroup) {
+      const subscribers = new Set;
+      const intervalId = setInterval(() => this.poll(subscribers), interval);
+      intervalGroup = { intervalId, subscribers };
+      this.intervals.set(interval, intervalGroup);
+      if (!this.initialized) {
+        this.initialized = true;
+        this.initAndPoll(subscribers, subscription);
+      } else {
+        this.pollForNewSubscriber(subscription);
+      }
+    } else {
+      this.pollForNewSubscriber(subscription);
+    }
+    intervalGroup.subscribers.add(subscription);
+    return () => {
+      const group = this.intervals.get(interval);
+      if (group) {
+        group.subscribers.delete(subscription);
+        if (group.subscribers.size === 0) {
+          clearInterval(group.intervalId);
+          this.intervals.delete(interval);
+        }
+      }
+    };
+  }
+  async initAndPoll(subscribers, newSubscription) {
+    try {
+      this.lastKnownState = await this.fetchState();
+      for (const [, item] of this.lastKnownState) {
+        const payload = this.payloadFactory.insert(item);
+        try {
+          newSubscription.callback(payload);
+        } catch {}
+      }
+    } catch {}
+  }
+  pollForNewSubscriber(subscription) {
+    for (const [, item] of this.lastKnownState) {
+      const payload = this.payloadFactory.insert(item);
+      try {
+        subscription.callback(payload);
+      } catch {}
+    }
+  }
+  async poll(subscribers) {
+    if (subscribers.size === 0)
+      return;
+    try {
+      const currentState = await this.fetchState();
+      const changes = [];
+      for (const [key, item] of currentState) {
+        const oldItem = this.lastKnownState.get(key);
+        if (!oldItem) {
+          changes.push(this.payloadFactory.insert(item));
+        } else if (!this.compareItems(oldItem, item)) {
+          changes.push(this.payloadFactory.update(oldItem, item));
+        }
+      }
+      for (const [key, item] of this.lastKnownState) {
+        if (!currentState.has(key)) {
+          changes.push(this.payloadFactory.delete(item));
+        }
+      }
+      this.lastKnownState = currentState;
+      for (const change of changes) {
+        for (const sub of subscribers) {
+          try {
+            sub.callback(change);
+          } catch {}
+        }
+      }
+    } catch {}
+  }
+  get subscriptionCount() {
+    let count = 0;
+    for (const group of this.intervals.values()) {
+      count += group.subscribers.size;
+    }
+    return count;
+  }
+  get hasSubscriptions() {
+    return this.intervals.size > 0;
+  }
+  destroy() {
+    for (const group of this.intervals.values()) {
+      clearInterval(group.intervalId);
+    }
+    this.intervals.clear();
+    this.lastKnownState.clear();
+    this.initialized = false;
+  }
+}
+
+// src/queue/PostgresQueueStorage.ts
+var POSTGRES_QUEUE_STORAGE = createServiceToken19("jobqueue.storage.postgres");
 
 class PostgresQueueStorage {
   db;
   queueName;
-  constructor(db, queueName) {
+  prefixes;
+  prefixValues;
+  tableName;
+  pollingManager = null;
+  constructor(db, queueName, options) {
     this.db = db;
     this.queueName = queueName;
+    this.prefixes = options?.prefixes ?? [];
+    this.prefixValues = options?.prefixValues ?? {};
+    if (this.prefixes.length > 0) {
+      const prefixNames = this.prefixes.map((p) => p.name).join("_");
+      this.tableName = `job_queue_${prefixNames}`;
+    } else {
+      this.tableName = "job_queue";
+    }
+  }
+  getPrefixColumnType(type) {
+    return type === "uuid" ? "UUID" : "INTEGER";
+  }
+  buildPrefixColumnsSql() {
+    if (this.prefixes.length === 0)
+      return "";
+    return this.prefixes.map((p) => `${p.name} ${this.getPrefixColumnType(p.type)} NOT NULL`).join(`,
+      `) + `,
+      `;
+  }
+  getPrefixColumnNames() {
+    return this.prefixes.map((p) => p.name);
+  }
+  buildPrefixWhereClause(startParam) {
+    if (this.prefixes.length === 0) {
+      return { conditions: "", params: [] };
+    }
+    const conditions = this.prefixes.map((p, i) => `${p.name} = $${startParam + i}`).join(" AND ");
+    const params = this.prefixes.map((p) => this.prefixValues[p.name]);
+    return { conditions: " AND " + conditions, params };
+  }
+  getPrefixParamValues() {
+    return this.prefixes.map((p) => this.prefixValues[p.name]);
   }
   async setupDatabase() {
     let sql;
@@ -2130,10 +2570,13 @@ class PostgresQueueStorage {
       if (e.code !== "42710")
         throw e;
     }
+    const prefixColumnsSql = this.buildPrefixColumnsSql();
+    const prefixColumnNames = this.getPrefixColumnNames();
+    const prefixIndexPrefix = prefixColumnNames.length > 0 ? prefixColumnNames.join(", ") + ", " : "";
     sql = `
-    CREATE TABLE IF NOT EXISTS job_queue (
+    CREATE TABLE IF NOT EXISTS ${this.tableName} (
       id SERIAL NOT NULL,
-      fingerprint text NOT NULL,
+      ${prefixColumnsSql}fingerprint text NOT NULL,
       queue text NOT NULL,
       job_run_id text NOT NULL,
       status job_status NOT NULL default 'PENDING',
@@ -2150,20 +2593,22 @@ class PostgresQueueStorage {
       error_code text,
       progress real DEFAULT 0,
       progress_message text DEFAULT '',
-      progress_details jsonb
+      progress_details jsonb,
+      worker_id text
     )`;
     await this.db.query(sql);
+    const indexSuffix = prefixColumnNames.length > 0 ? "_" + prefixColumnNames.join("_") : "";
     sql = `
-      CREATE INDEX IF NOT EXISTS job_fetcher_idx 
-        ON job_queue (id, status, run_after)`;
+      CREATE INDEX IF NOT EXISTS job_fetcher${indexSuffix}_idx 
+        ON ${this.tableName} (${prefixIndexPrefix}id, status, run_after)`;
     await this.db.query(sql);
     sql = `
-      CREATE INDEX IF NOT EXISTS job_queue_fetcher_idx 
-        ON job_queue (queue, status, run_after)`;
+      CREATE INDEX IF NOT EXISTS job_queue_fetcher${indexSuffix}_idx 
+        ON ${this.tableName} (${prefixIndexPrefix}queue, status, run_after)`;
     await this.db.query(sql);
     sql = `
-      CREATE INDEX IF NOT EXISTS jobs_fingerprint_unique_idx 
-        ON job_queue (queue, fingerprint, status)`;
+      CREATE INDEX IF NOT EXISTS jobs_fingerprint${indexSuffix}_unique_idx 
+        ON ${this.tableName} (${prefixIndexPrefix}queue, fingerprint, status)`;
     await this.db.query(sql);
   }
   async add(job) {
@@ -2177,9 +2622,14 @@ class PostgresQueueStorage {
     job.progress_details = null;
     job.created_at = now;
     job.run_after = now;
+    const prefixColumnNames = this.getPrefixColumnNames();
+    const prefixColumnsInsert = prefixColumnNames.length > 0 ? prefixColumnNames.join(", ") + ", " : "";
+    const prefixParamValues = this.getPrefixParamValues();
+    const prefixParamPlaceholders = prefixColumnNames.length > 0 ? prefixColumnNames.map((_, i) => `$${i + 1}`).join(",") + "," : "";
+    const baseParamStart = prefixColumnNames.length + 1;
     const sql = `
-      INSERT INTO job_queue(
-        queue, 
+      INSERT INTO ${this.tableName}(
+        ${prefixColumnsInsert}queue, 
         fingerprint, 
         input, 
         run_after,
@@ -2192,9 +2642,10 @@ class PostgresQueueStorage {
         progress_details
       )
       VALUES 
-        ($1,$2,$3,$4,$5,$6,$7,$8,$9,$10,$11)
+        (${prefixParamPlaceholders}$${baseParamStart},$${baseParamStart + 1},$${baseParamStart + 2},$${baseParamStart + 3},$${baseParamStart + 4},$${baseParamStart + 5},$${baseParamStart + 6},$${baseParamStart + 7},$${baseParamStart + 8},$${baseParamStart + 9},$${baseParamStart + 10})
       RETURNING id`;
     const params = [
+      ...prefixParamValues,
       job.queue,
       job.fingerprint,
       JSON.stringify(job.input),
@@ -2214,68 +2665,75 @@ class PostgresQueueStorage {
     return job.id;
   }
   async get(id) {
+    const { conditions: prefixConditions, params: prefixParams } = this.buildPrefixWhereClause(3);
     const result = await this.db.query(`SELECT *
-        FROM job_queue
-        WHERE id = $1 AND queue = $2
+        FROM ${this.tableName}
+        WHERE id = $1 AND queue = $2${prefixConditions}
         FOR UPDATE SKIP LOCKED
-        LIMIT 1`, [id, this.queueName]);
+        LIMIT 1`, [id, this.queueName, ...prefixParams]);
     if (!result || result.rows.length === 0)
       return;
     return result.rows[0];
   }
   async peek(status = "PENDING" /* PENDING */, num = 100) {
     num = Number(num) || 100;
+    const { conditions: prefixConditions, params: prefixParams } = this.buildPrefixWhereClause(4);
     const result = await this.db.query(`
       SELECT *
-        FROM job_queue
+        FROM ${this.tableName}
         WHERE queue = $1
-        AND status = $2
+        AND status = $2${prefixConditions}
         ORDER BY run_after ASC
         LIMIT $3
-        FOR UPDATE SKIP LOCKED`, [this.queueName, status, num]);
+        FOR UPDATE SKIP LOCKED`, [this.queueName, status, num, ...prefixParams]);
     if (!result)
       return [];
     return result.rows;
   }
-  async next() {
+  async next(workerId) {
+    const { conditions: prefixConditions, params: prefixParams } = this.buildPrefixWhereClause(5);
     const result = await this.db.query(`
-      UPDATE job_queue 
-      SET status = $1, last_ran_at = NOW() AT TIME ZONE 'UTC'
+      UPDATE ${this.tableName} 
+      SET status = $1, last_ran_at = NOW() AT TIME ZONE 'UTC', worker_id = $4
       WHERE id = (
         SELECT id 
-        FROM job_queue 
+        FROM ${this.tableName} 
         WHERE queue = $2 
-        AND status = $3 
+        AND status = $3${prefixConditions}
         AND run_after <= NOW() AT TIME ZONE 'UTC'
         ORDER BY run_after ASC 
         FOR UPDATE SKIP LOCKED 
         LIMIT 1
       )
-      RETURNING *`, ["PROCESSING" /* PROCESSING */, this.queueName, "PENDING" /* PENDING */]);
+      RETURNING *`, ["PROCESSING" /* PROCESSING */, this.queueName, "PENDING" /* PENDING */, workerId ?? null, ...prefixParams]);
     return result?.rows?.[0] ?? undefined;
   }
   async size(status = "PENDING" /* PENDING */) {
+    const { conditions: prefixConditions, params: prefixParams } = this.buildPrefixWhereClause(3);
     const result = await this.db.query(`
       SELECT COUNT(*) as count
-        FROM job_queue
+        FROM ${this.tableName}
         WHERE queue = $1
-        AND status = $2`, [this.queueName, status]);
+        AND status = $2${prefixConditions}`, [this.queueName, status, ...prefixParams]);
     if (!result)
       return 0;
     return parseInt(result.rows[0].count, 10);
   }
   async complete(jobDetails) {
+    const prefixParams = this.getPrefixParamValues();
     if (jobDetails.status === "DISABLED" /* DISABLED */) {
-      await this.db.query(`UPDATE job_queue 
+      const { conditions: prefixConditions } = this.buildPrefixWhereClause(4);
+      await this.db.query(`UPDATE ${this.tableName} 
           SET 
             status = $1, 
             progress = 100,
             progress_message = '',
             progress_details = NULL,
             completed_at = NOW() AT TIME ZONE 'UTC'
-          WHERE id = $2 AND queue = $3`, [jobDetails.status, jobDetails.id, this.queueName]);
+          WHERE id = $2 AND queue = $3${prefixConditions}`, [jobDetails.status, jobDetails.id, this.queueName, ...prefixParams]);
     } else if (jobDetails.status === "PENDING" /* PENDING */) {
-      await this.db.query(`UPDATE job_queue 
+      const { conditions: prefixConditions } = this.buildPrefixWhereClause(7);
+      await this.db.query(`UPDATE ${this.tableName} 
           SET 
             error = $1, 
             error_code = $2,
@@ -2286,17 +2744,19 @@ class PostgresQueueStorage {
             progress_details = NULL,
             run_attempts = run_attempts + 1, 
             last_ran_at = NOW() AT TIME ZONE 'UTC'
-          WHERE id = $5 AND queue = $6`, [
+          WHERE id = $5 AND queue = $6${prefixConditions}`, [
         jobDetails.error,
         jobDetails.error_code,
         jobDetails.status,
         jobDetails.run_after,
         jobDetails.id,
-        this.queueName
+        this.queueName,
+        ...prefixParams
       ]);
     } else {
+      const { conditions: prefixConditions } = this.buildPrefixWhereClause(7);
       await this.db.query(`
-          UPDATE job_queue 
+          UPDATE ${this.tableName} 
             SET 
               output = $1, 
               error = $2, 
@@ -2308,86 +2768,231 @@ class PostgresQueueStorage {
               run_attempts = run_attempts + 1, 
               completed_at = NOW() AT TIME ZONE 'UTC',
               last_ran_at = NOW() AT TIME ZONE 'UTC'
-          WHERE id = $5 AND queue = $6`, [
+          WHERE id = $5 AND queue = $6${prefixConditions}`, [
         jobDetails.output ? JSON.stringify(jobDetails.output) : null,
         jobDetails.error ?? null,
         jobDetails.error_code ?? null,
         jobDetails.status,
         jobDetails.id,
-        this.queueName
+        this.queueName,
+        ...prefixParams
       ]);
     }
   }
   async deleteAll() {
+    const { conditions: prefixConditions, params: prefixParams } = this.buildPrefixWhereClause(2);
     await this.db.query(`
-      DELETE FROM job_queue
-        WHERE queue = $1`, [this.queueName]);
+      DELETE FROM ${this.tableName}
+        WHERE queue = $1${prefixConditions}`, [this.queueName, ...prefixParams]);
   }
   async outputForInput(input) {
     const fingerprint = await makeFingerprint5(input);
+    const { conditions: prefixConditions, params: prefixParams } = this.buildPrefixWhereClause(3);
     const result = await this.db.query(`
       SELECT output
-        FROM job_queue
-        WHERE fingerprint = $1 AND queue = $2 AND status = 'COMPLETED'`, [fingerprint, this.queueName]);
-    if (!result)
+        FROM ${this.tableName}
+        WHERE fingerprint = $1 AND queue = $2 AND status = 'COMPLETED'${prefixConditions}`, [fingerprint, this.queueName, ...prefixParams]);
+    if (!result || result.rows.length === 0)
       return null;
     return result.rows[0].output;
   }
   async abort(jobId) {
-    const result = await this.db.query(`
-      UPDATE job_queue 
+    const { conditions: prefixConditions, params: prefixParams } = this.buildPrefixWhereClause(3);
+    await this.db.query(`
+      UPDATE ${this.tableName} 
       SET status = 'ABORTING' 
-      WHERE id = $1 AND queue = $2`, [jobId, this.queueName]);
+      WHERE id = $1 AND queue = $2${prefixConditions}`, [jobId, this.queueName, ...prefixParams]);
   }
   async getByRunId(job_run_id) {
+    const { conditions: prefixConditions, params: prefixParams } = this.buildPrefixWhereClause(3);
     const result = await this.db.query(`
-      SELECT * FROM job_queue WHERE job_run_id = $1 AND queue = $2`, [job_run_id, this.queueName]);
+      SELECT * FROM ${this.tableName} WHERE job_run_id = $1 AND queue = $2${prefixConditions}`, [job_run_id, this.queueName, ...prefixParams]);
     if (!result)
       return [];
     return result.rows;
   }
   async saveProgress(jobId, progress, message, details) {
+    const { conditions: prefixConditions, params: prefixParams } = this.buildPrefixWhereClause(6);
     await this.db.query(`
-      UPDATE job_queue 
+      UPDATE ${this.tableName} 
       SET progress = $1,
           progress_message = $2,
           progress_details = $3
-      WHERE id = $4 AND queue = $5`, [progress, message, details ? JSON.stringify(details) : null, jobId, this.queueName]);
-  }
-  async delete(jobId) {
-    await this.db.query("DELETE FROM job_queue WHERE id = $1 AND queue = $2", [
+      WHERE id = $4 AND queue = $5${prefixConditions}`, [
+      progress,
+      message,
+      details ? JSON.stringify(details) : null,
       jobId,
-      this.queueName
+      this.queueName,
+      ...prefixParams
     ]);
   }
+  async delete(jobId) {
+    const { conditions: prefixConditions, params: prefixParams } = this.buildPrefixWhereClause(3);
+    await this.db.query(`DELETE FROM ${this.tableName} WHERE id = $1 AND queue = $2${prefixConditions}`, [jobId, this.queueName, ...prefixParams]);
+  }
   async deleteJobsByStatusAndAge(status, olderThanMs) {
     const cutoffDate = new Date(Date.now() - olderThanMs).toISOString();
-    await this.db.query(`DELETE FROM job_queue 
+    const { conditions: prefixConditions, params: prefixParams } = this.buildPrefixWhereClause(4);
+    await this.db.query(`DELETE FROM ${this.tableName} 
        WHERE queue = $1 
        AND status = $2 
        AND completed_at IS NOT NULL 
-       AND completed_at <= $3`, [this.queueName, status, cutoffDate]);
+       AND completed_at <= $3${prefixConditions}`, [this.queueName, status, cutoffDate, ...prefixParams]);
+  }
+  async getAllJobs() {
+    const { conditions: prefixConditions, params: prefixParams } = this.buildPrefixWhereClause(2);
+    const result = await this.db.query(`SELECT * FROM ${this.tableName} WHERE queue = $1${prefixConditions}`, [this.queueName, ...prefixParams]);
+    if (!result)
+      return [];
+    return result.rows;
+  }
+  async getAllJobsWithFilter(prefixFilter) {
+    const filterEntries = Object.entries(prefixFilter);
+    let query = `SELECT * FROM ${this.tableName} WHERE queue = $1`;
+    const params = [this.queueName];
+    filterEntries.forEach(([key, value], index) => {
+      query += ` AND ${key} = $${index + 2}`;
+      params.push(value);
+    });
+    const result = await this.db.query(query, params);
+    if (!result)
+      return [];
+    return result.rows;
+  }
+  isCustomPrefixFilter(prefixFilter) {
+    if (prefixFilter === undefined) {
+      return false;
+    }
+    if (Object.keys(prefixFilter).length === 0) {
+      return true;
+    }
+    const instanceKeys = Object.keys(this.prefixValues);
+    const filterKeys = Object.keys(prefixFilter);
+    if (instanceKeys.length !== filterKeys.length) {
+      return true;
+    }
+    for (const key of instanceKeys) {
+      if (this.prefixValues[key] !== prefixFilter[key]) {
+        return true;
+      }
+    }
+    return false;
+  }
+  getPollingManager() {
+    if (!this.pollingManager) {
+      this.pollingManager = new PollingSubscriptionManager(async () => {
+        const jobs = await this.getAllJobs();
+        return new Map(jobs.map((j) => [j.id, j]));
+      }, (a, b) => JSON.stringify(a) === JSON.stringify(b), {
+        insert: (item) => ({ type: "INSERT", new: item }),
+        update: (oldItem, newItem) => ({ type: "UPDATE", old: oldItem, new: newItem }),
+        delete: (item) => ({ type: "DELETE", old: item })
+      });
+    }
+    return this.pollingManager;
+  }
+  subscribeWithCustomPrefixFilter(callback, prefixFilter, intervalMs) {
+    let lastKnownJobs = new Map;
+    let cancelled = false;
+    const poll = async () => {
+      if (cancelled)
+        return;
+      try {
+        const currentJobs = await this.getAllJobsWithFilter(prefixFilter);
+        if (cancelled)
+          return;
+        const currentMap = new Map(currentJobs.map((j) => [j.id, j]));
+        for (const [id, job] of currentMap) {
+          const old = lastKnownJobs.get(id);
+          if (!old) {
+            callback({ type: "INSERT", new: job });
+          } else if (JSON.stringify(old) !== JSON.stringify(job)) {
+            callback({ type: "UPDATE", old, new: job });
+          }
+        }
+        for (const [id, job] of lastKnownJobs) {
+          if (!currentMap.has(id)) {
+            callback({ type: "DELETE", old: job });
+          }
+        }
+        lastKnownJobs = currentMap;
+      } catch {}
+    };
+    const intervalId = setInterval(poll, intervalMs);
+    poll();
+    return () => {
+      cancelled = true;
+      clearInterval(intervalId);
+    };
+  }
+  subscribeToChanges(callback, options) {
+    const intervalMs = options?.pollingIntervalMs ?? 1000;
+    if (this.isCustomPrefixFilter(options?.prefixFilter)) {
+      return this.subscribeWithCustomPrefixFilter(callback, options.prefixFilter, intervalMs);
+    }
+    const manager = this.getPollingManager();
+    return manager.subscribe(callback, { intervalMs });
   }
 }
 // src/queue/SqliteQueueStorage.ts
-import { createServiceToken as createServiceToken18, makeFingerprint as makeFingerprint6, sleep as sleep3, uuid4 as uuid43 } from "@workglow/util";
-var SQLITE_QUEUE_STORAGE = createServiceToken18("jobqueue.storage.sqlite");
+import { createServiceToken as createServiceToken20, makeFingerprint as makeFingerprint6, sleep as sleep4, uuid4 as uuid43 } from "@workglow/util";
+var SQLITE_QUEUE_STORAGE = createServiceToken20("jobqueue.storage.sqlite");
 
 class SqliteQueueStorage {
   db;
   queueName;
   options;
+  prefixes;
+  prefixValues;
+  tableName;
+  pollingManager = null;
   constructor(db, queueName, options) {
     this.db = db;
     this.queueName = queueName;
     this.options = options;
+    this.prefixes = options?.prefixes ?? [];
+    this.prefixValues = options?.prefixValues ?? {};
+    if (this.prefixes.length > 0) {
+      const prefixNames = this.prefixes.map((p) => p.name).join("_");
+      this.tableName = `job_queue_${prefixNames}`;
+    } else {
+      this.tableName = "job_queue";
+    }
+  }
+  getPrefixColumnType(type) {
+    return type === "uuid" ? "TEXT" : "INTEGER";
+  }
+  buildPrefixColumnsSql() {
+    if (this.prefixes.length === 0)
+      return "";
+    return this.prefixes.map((p) => `${p.name} ${this.getPrefixColumnType(p.type)} NOT NULL`).join(`,
+        `) + `,
+        `;
+  }
+  getPrefixColumnNames() {
+    return this.prefixes.map((p) => p.name);
+  }
+  buildPrefixWhereClause() {
+    if (this.prefixes.length === 0) {
+      return "";
+    }
+    const conditions = this.prefixes.map((p) => `${p.name} = ?`).join(" AND ");
+    return " AND " + conditions;
+  }
+  getPrefixParamValues() {
+    return this.prefixes.map((p) => this.prefixValues[p.name]);
   }
   async setupDatabase() {
-    await sleep3(0);
+    await sleep4(0);
+    const prefixColumnsSql = this.buildPrefixColumnsSql();
+    const prefixColumnNames = this.getPrefixColumnNames();
+    const prefixIndexPrefix = prefixColumnNames.length > 0 ? prefixColumnNames.join(", ") + ", " : "";
+    const indexSuffix = prefixColumnNames.length > 0 ? "_" + prefixColumnNames.join("_") : "";
     this.db.exec(`
-      CREATE TABLE IF NOT EXISTS job_queue (
+      CREATE TABLE IF NOT EXISTS ${this.tableName} (
         id INTEGER PRIMARY KEY,
-        fingerprint text NOT NULL,
+        ${prefixColumnsSql}fingerprint text NOT NULL,
         queue text NOT NULL,
         job_run_id text NOT NULL,
         status TEXT NOT NULL default 'PENDING',
@@ -2404,12 +3009,13 @@ class SqliteQueueStorage {
         error_code TEXT,
         progress REAL DEFAULT 0,
         progress_message TEXT DEFAULT '',
-        progress_details TEXT NULL
+        progress_details TEXT NULL,
+        worker_id TEXT
       );
       
-      CREATE INDEX IF NOT EXISTS job_queue_fetcher_idx ON job_queue (queue, status, run_after);
-      CREATE INDEX IF NOT EXISTS job_queue_fingerprint_idx ON job_queue (queue, fingerprint, status);
-      CREATE INDEX IF NOT EXISTS job_queue_job_run_id_idx ON job_queue (queue, job_run_id);
+      CREATE INDEX IF NOT EXISTS job_queue_fetcher${indexSuffix}_idx ON ${this.tableName} (${prefixIndexPrefix}queue, status, run_after);
+      CREATE INDEX IF NOT EXISTS job_queue_fingerprint${indexSuffix}_idx ON ${this.tableName} (${prefixIndexPrefix}queue, fingerprint, status);
+      CREATE INDEX IF NOT EXISTS job_queue_job_run_id${indexSuffix}_idx ON ${this.tableName} (${prefixIndexPrefix}queue, job_run_id);
     `);
   }
   async add(job) {
@@ -2423,9 +3029,13 @@ class SqliteQueueStorage {
     job.progress_details = null;
     job.created_at = now;
     job.run_after = now;
+    const prefixColumnNames = this.getPrefixColumnNames();
+    const prefixColumnsInsert = prefixColumnNames.length > 0 ? prefixColumnNames.join(", ") + ", " : "";
+    const prefixPlaceholders = prefixColumnNames.length > 0 ? prefixColumnNames.map(() => "?").join(", ") + ", " : "";
+    const prefixParamValues = this.getPrefixParamValues();
     const AddQuery = `
-      INSERT INTO job_queue(
-        queue, 
+      INSERT INTO ${this.tableName}(
+        ${prefixColumnsInsert}queue, 
         fingerprint, 
         input, 
         run_after, 
@@ -2437,21 +3047,23 @@ class SqliteQueueStorage {
         progress_details,
         created_at
       )
-      VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+      VALUES (${prefixPlaceholders}?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
       RETURNING id`;
     const stmt = this.db.prepare(AddQuery);
-    const result = stmt.get(job.queue, job.fingerprint, JSON.stringify(job.input), job.run_after, job.deadline_at ?? null, job.max_retries, job.job_run_id, job.progress, job.progress_message, job.progress_details ? JSON.stringify(job.progress_details) : null, job.created_at);
+    const result = stmt.get(...prefixParamValues, job.queue, job.fingerprint, JSON.stringify(job.input), job.run_after, job.deadline_at ?? null, job.max_retries, job.job_run_id, job.progress, job.progress_message, job.progress_details ? JSON.stringify(job.progress_details) : null, job.created_at);
     job.id = result?.id;
     return result?.id;
   }
   async get(id) {
+    const prefixConditions = this.buildPrefixWhereClause();
+    const prefixParams = this.getPrefixParamValues();
     const JobQuery = `
       SELECT *
-        FROM job_queue
-        WHERE id = ? AND queue = ?
+        FROM ${this.tableName}
+        WHERE id = ? AND queue = ?${prefixConditions}
         LIMIT 1`;
     const stmt = this.db.prepare(JobQuery);
-    const result = stmt.get(id, this.queueName);
+    const result = stmt.get(String(id), this.queueName, ...prefixParams);
     if (!result)
       return;
     if (result.input)
@@ -2464,15 +3076,17 @@ class SqliteQueueStorage {
   }
   async peek(status = "PENDING" /* PENDING */, num = 100) {
     num = Number(num) || 100;
+    const prefixConditions = this.buildPrefixWhereClause();
+    const prefixParams = this.getPrefixParamValues();
     const FutureJobQuery = `
       SELECT * 
-        FROM job_queue
+        FROM ${this.tableName}
         WHERE queue = ?
-        AND status = ?
+        AND status = ?${prefixConditions}
         ORDER BY run_after ASC
         LIMIT ${num}`;
     const stmt = this.db.prepare(FutureJobQuery);
-    const result = stmt.all(this.queueName, status);
+    const result = stmt.all(this.queueName, status, ...prefixParams);
     return (result || []).map((details) => {
       if (details.input)
         details.input = JSON.parse(details.input);
@@ -2484,20 +3098,24 @@ class SqliteQueueStorage {
     });
   }
   async abort(jobId) {
+    const prefixConditions = this.buildPrefixWhereClause();
+    const prefixParams = this.getPrefixParamValues();
     const AbortQuery = `
-      UPDATE job_queue
+      UPDATE ${this.tableName}
         SET status = ?  
-        WHERE id = ? AND queue = ?`;
+        WHERE id = ? AND queue = ?${prefixConditions}`;
     const stmt = this.db.prepare(AbortQuery);
-    stmt.run("ABORTING" /* ABORTING */, jobId, this.queueName);
+    stmt.run("ABORTING" /* ABORTING */, String(jobId), this.queueName, ...prefixParams);
   }
   async getByRunId(job_run_id) {
+    const prefixConditions = this.buildPrefixWhereClause();
+    const prefixParams = this.getPrefixParamValues();
     const JobsByRunIdQuery = `
       SELECT *
-        FROM job_queue
-        WHERE job_run_id = ? AND queue = ?`;
+        FROM ${this.tableName}
+        WHERE job_run_id = ? AND queue = ?${prefixConditions}`;
     const stmt = this.db.prepare(JobsByRunIdQuery);
-    const result = stmt.all(job_run_id, this.queueName);
+    const result = stmt.all(job_run_id, this.queueName, ...prefixParams);
     return (result || []).map((details) => {
       if (details.input)
         details.input = JSON.parse(details.input);
@@ -2508,22 +3126,24 @@ class SqliteQueueStorage {
       return details;
     });
   }
-  async next() {
+  async next(workerId) {
     const now = new Date().toISOString();
+    const prefixConditions = this.buildPrefixWhereClause();
+    const prefixParams = this.getPrefixParamValues();
     const stmt = this.db.prepare(`
-      UPDATE job_queue 
-      SET status = ?, last_ran_at = ?
+      UPDATE ${this.tableName} 
+      SET status = ?, last_ran_at = ?, worker_id = ?
       WHERE id = (
         SELECT id 
-        FROM job_queue 
+        FROM ${this.tableName} 
         WHERE queue = ? 
-        AND status = ? 
+        AND status = ?${prefixConditions}
         AND run_after <= ? 
         ORDER BY run_after ASC 
         LIMIT 1
       )
       RETURNING *`);
-    const result = stmt.get("PROCESSING" /* PROCESSING */, now, this.queueName, "PENDING" /* PENDING */, now);
+    const result = stmt.get("PROCESSING" /* PROCESSING */, now, workerId ?? null, this.queueName, "PENDING" /* PENDING */, ...prefixParams, now);
     if (!result)
       return;
     if (result.input)
@@ -2535,33 +3155,37 @@ class SqliteQueueStorage {
     return result;
   }
   async size(status = "PENDING" /* PENDING */) {
+    const prefixConditions = this.buildPrefixWhereClause();
+    const prefixParams = this.getPrefixParamValues();
     const sizeQuery = `
       SELECT COUNT(*) as count
-        FROM job_queue
+        FROM ${this.tableName}
         WHERE queue = ?
-        AND status = ?`;
+        AND status = ?${prefixConditions}`;
     const stmt = this.db.prepare(sizeQuery);
-    const result = stmt.get(this.queueName, status);
+    const result = stmt.get(this.queueName, status, ...prefixParams);
     return result.count;
   }
   async complete(job) {
     const now = new Date().toISOString();
+    const prefixConditions = this.buildPrefixWhereClause();
+    const prefixParams = this.getPrefixParamValues();
     let updateQuery;
     let params;
     if (job.status === "DISABLED" /* DISABLED */) {
       updateQuery = `
-          UPDATE job_queue 
+          UPDATE ${this.tableName} 
             SET 
               status = ?, 
               progress = 100, 
               progress_message = '', 
               progress_details = NULL, 
               completed_at = ?  
-            WHERE id = ? AND queue = ?`;
-      params = [job.status, now, job.id, this.queueName];
+            WHERE id = ? AND queue = ?${prefixConditions}`;
+      params = [job.status, now, job.id, this.queueName, ...prefixParams];
     } else {
       updateQuery = `
-          UPDATE job_queue 
+          UPDATE ${this.tableName} 
             SET 
               output = ?, 
               error = ?, 
@@ -2573,7 +3197,7 @@ class SqliteQueueStorage {
               last_ran_at = ?,
               completed_at = ?,
               run_attempts = run_attempts + 1
-            WHERE id = ? AND queue = ?`;
+            WHERE id = ? AND queue = ?${prefixConditions}`;
       params = [
         job.output ? JSON.stringify(job.output) : null,
         job.error ?? null,
@@ -2582,80 +3206,243 @@ class SqliteQueueStorage {
         now,
         now,
         job.id,
-        this.queueName
+        this.queueName,
+        ...prefixParams
       ];
     }
     const stmt = this.db.prepare(updateQuery);
     stmt.run(...params);
   }
   async deleteAll() {
+    const prefixConditions = this.buildPrefixWhereClause();
+    const prefixParams = this.getPrefixParamValues();
     const ClearQuery = `
-      DELETE FROM job_queue
-        WHERE queue = ?`;
+      DELETE FROM ${this.tableName}
+        WHERE queue = ?${prefixConditions}`;
     const stmt = this.db.prepare(ClearQuery);
-    stmt.run(this.queueName);
+    stmt.run(this.queueName, ...prefixParams);
   }
   async outputForInput(input) {
     const fingerprint = await makeFingerprint6(input);
+    const prefixConditions = this.buildPrefixWhereClause();
+    const prefixParams = this.getPrefixParamValues();
     const OutputQuery = `
       SELECT output
-        FROM job_queue
-        WHERE queue = ? AND fingerprint = ? AND status = ?`;
+        FROM ${this.tableName}
+        WHERE queue = ? AND fingerprint = ? AND status = ?${prefixConditions}`;
     const stmt = this.db.prepare(OutputQuery);
-    const result = stmt.get(this.queueName, fingerprint, "COMPLETED" /* COMPLETED */);
+    const result = stmt.get(this.queueName, fingerprint, "COMPLETED" /* COMPLETED */, ...prefixParams);
     return result?.output ? JSON.parse(result.output) : null;
   }
   async saveProgress(jobId, progress, message, details) {
+    const prefixConditions = this.buildPrefixWhereClause();
+    const prefixParams = this.getPrefixParamValues();
     const UpdateProgressQuery = `
-      UPDATE job_queue
+      UPDATE ${this.tableName}
         SET progress = ?,
             progress_message = ?,
             progress_details = ?
-        WHERE id = ? AND queue = ?`;
+        WHERE id = ? AND queue = ?${prefixConditions}`;
     const stmt = this.db.prepare(UpdateProgressQuery);
-    stmt.run(progress, message, JSON.stringify(details), String(jobId), this.queueName);
+    stmt.run(progress, message, JSON.stringify(details), String(jobId), this.queueName, ...prefixParams);
   }
   async delete(jobId) {
+    const prefixConditions = this.buildPrefixWhereClause();
+    const prefixParams = this.getPrefixParamValues();
     const DeleteQuery = `
-      DELETE FROM job_queue
-        WHERE id = ? AND queue = ?`;
+      DELETE FROM ${this.tableName}
+        WHERE id = ? AND queue = ?${prefixConditions}`;
     const stmt = this.db.prepare(DeleteQuery);
-    stmt.run(String(jobId), this.queueName);
+    stmt.run(String(jobId), this.queueName, ...prefixParams);
   }
   async deleteJobsByStatusAndAge(status, olderThanMs) {
     const cutoffDate = new Date(Date.now() - olderThanMs).toISOString();
+    const prefixConditions = this.buildPrefixWhereClause();
+    const prefixParams = this.getPrefixParamValues();
     const DeleteQuery = `
-      DELETE FROM job_queue
+      DELETE FROM ${this.tableName}
         WHERE queue = ?
         AND status = ?
         AND completed_at IS NOT NULL
-        AND completed_at <= ?`;
+        AND completed_at <= ?${prefixConditions}`;
     const stmt = this.db.prepare(DeleteQuery);
-    stmt.run(this.queueName, status, cutoffDate);
+    stmt.run(this.queueName, status, cutoffDate, ...prefixParams);
   }
-}
-// src/queue/SupabaseQueueStorage.ts
-import { createServiceToken as createServiceToken19, makeFingerprint as makeFingerprint7, uuid4 as uuid44 } from "@workglow/util";
-var SUPABASE_QUEUE_STORAGE = createServiceToken19("jobqueue.storage.supabase");
-
-class SupabaseQueueStorage {
-  client;
-  queueName;
-  constructor(client, queueName) {
-    this.client = client;
-    this.queueName = queueName;
+  getAllJobs() {
+    const prefixConditions = this.buildPrefixWhereClause();
+    const prefixParams = this.getPrefixParamValues();
+    const AllJobsQuery = `
+      SELECT *
+        FROM ${this.tableName}
+        WHERE queue = ?${prefixConditions}`;
+    const stmt = this.db.prepare(AllJobsQuery);
+    const result = stmt.all(this.queueName, ...prefixParams);
+    return (result || []).map((details) => {
+      if (details.input)
+        details.input = JSON.parse(details.input);
+      if (details.output)
+        details.output = JSON.parse(details.output);
+      if (details.progress_details)
+        details.progress_details = JSON.parse(details.progress_details);
+      return details;
+    });
   }
-  async setupDatabase() {
-    const createTypeSql = `CREATE TYPE job_status AS ENUM (${Object.values(JobStatus).map((v) => `'${v}'`).join(",")})`;
-    const { error: typeError } = await this.client.rpc("exec_sql", { query: createTypeSql });
-    if (typeError && typeError.code !== "42710") {
-      throw typeError;
+  getAllJobsWithFilter(prefixFilter) {
+    const filterEntries = Object.entries(prefixFilter);
+    let whereClause = "WHERE queue = ?";
+    const params = [this.queueName];
+    for (const [key, value] of filterEntries) {
+      whereClause += ` AND ${key} = ?`;
+      params.push(value);
+    }
+    const AllJobsQuery = `SELECT * FROM ${this.tableName} ${whereClause}`;
+    const stmt = this.db.prepare(AllJobsQuery);
+    const result = stmt.all(...params);
+    return (result || []).map((details) => {
+      if (details.input)
+        details.input = JSON.parse(details.input);
+      if (details.output)
+        details.output = JSON.parse(details.output);
+      if (details.progress_details)
+        details.progress_details = JSON.parse(details.progress_details);
+      return details;
+    });
+  }
+  isCustomPrefixFilter(prefixFilter) {
+    if (prefixFilter === undefined) {
+      return false;
     }
-    const createTableSql = `
-    CREATE TABLE IF NOT EXISTS job_queue (
-      id SERIAL NOT NULL,
-      fingerprint text NOT NULL,
-      queue text NOT NULL,
+    if (Object.keys(prefixFilter).length === 0) {
+      return true;
+    }
+    const instanceKeys = Object.keys(this.prefixValues);
+    const filterKeys = Object.keys(prefixFilter);
+    if (instanceKeys.length !== filterKeys.length) {
+      return true;
+    }
+    for (const key of instanceKeys) {
+      if (this.prefixValues[key] !== prefixFilter[key]) {
+        return true;
+      }
+    }
+    return false;
+  }
+  getPollingManager() {
+    if (!this.pollingManager) {
+      this.pollingManager = new PollingSubscriptionManager(async () => {
+        const jobs = this.getAllJobs();
+        return new Map(jobs.map((j) => [j.id, j]));
+      }, (a, b) => JSON.stringify(a) === JSON.stringify(b), {
+        insert: (item) => ({ type: "INSERT", new: item }),
+        update: (oldItem, newItem) => ({ type: "UPDATE", old: oldItem, new: newItem }),
+        delete: (item) => ({ type: "DELETE", old: item })
+      });
+    }
+    return this.pollingManager;
+  }
+  subscribeWithCustomPrefixFilter(callback, prefixFilter, intervalMs) {
+    let lastKnownJobs = new Map;
+    const poll = () => {
+      try {
+        const currentJobs = this.getAllJobsWithFilter(prefixFilter);
+        const currentMap = new Map(currentJobs.map((j) => [j.id, j]));
+        for (const [id, job] of currentMap) {
+          const old = lastKnownJobs.get(id);
+          if (!old) {
+            callback({ type: "INSERT", new: job });
+          } else if (JSON.stringify(old) !== JSON.stringify(job)) {
+            callback({ type: "UPDATE", old, new: job });
+          }
+        }
+        for (const [id, job] of lastKnownJobs) {
+          if (!currentMap.has(id)) {
+            callback({ type: "DELETE", old: job });
+          }
+        }
+        lastKnownJobs = currentMap;
+      } catch {}
+    };
+    const intervalId = setInterval(poll, intervalMs);
+    poll();
+    return () => {
+      clearInterval(intervalId);
+    };
+  }
+  subscribeToChanges(callback, options) {
+    const intervalMs = options?.pollingIntervalMs ?? 1000;
+    if (this.isCustomPrefixFilter(options?.prefixFilter)) {
+      return this.subscribeWithCustomPrefixFilter(callback, options.prefixFilter, intervalMs);
+    }
+    const manager = this.getPollingManager();
+    return manager.subscribe(callback, { intervalMs });
+  }
+}
+// src/queue/SupabaseQueueStorage.ts
+import { createServiceToken as createServiceToken21, makeFingerprint as makeFingerprint7, uuid4 as uuid44 } from "@workglow/util";
+var SUPABASE_QUEUE_STORAGE = createServiceToken21("jobqueue.storage.supabase");
+
+class SupabaseQueueStorage {
+  client;
+  queueName;
+  prefixes;
+  prefixValues;
+  tableName;
+  realtimeChannel = null;
+  pollingManager = null;
+  constructor(client, queueName, options) {
+    this.client = client;
+    this.queueName = queueName;
+    this.prefixes = options?.prefixes ?? [];
+    this.prefixValues = options?.prefixValues ?? {};
+    if (this.prefixes.length > 0) {
+      const prefixNames = this.prefixes.map((p) => p.name).join("_");
+      this.tableName = `job_queue_${prefixNames}`;
+    } else {
+      this.tableName = "job_queue";
+    }
+  }
+  getPrefixColumnType(type) {
+    return type === "uuid" ? "UUID" : "INTEGER";
+  }
+  buildPrefixColumnsSql() {
+    if (this.prefixes.length === 0)
+      return "";
+    return this.prefixes.map((p) => `${p.name} ${this.getPrefixColumnType(p.type)} NOT NULL`).join(`,
+      `) + `,
+      `;
+  }
+  getPrefixColumnNames() {
+    return this.prefixes.map((p) => p.name);
+  }
+  applyPrefixFilters(query) {
+    let result = query;
+    for (const prefix of this.prefixes) {
+      result = result.eq(prefix.name, this.prefixValues[prefix.name]);
+    }
+    return result;
+  }
+  getPrefixInsertValues() {
+    const values = {};
+    for (const prefix of this.prefixes) {
+      values[prefix.name] = this.prefixValues[prefix.name];
+    }
+    return values;
+  }
+  async setupDatabase() {
+    const createTypeSql = `CREATE TYPE job_status AS ENUM (${Object.values(JobStatus).map((v) => `'${v}'`).join(",")})`;
+    const { error: typeError } = await this.client.rpc("exec_sql", { query: createTypeSql });
+    if (typeError && typeError.code !== "42710") {
+      throw typeError;
+    }
+    const prefixColumnsSql = this.buildPrefixColumnsSql();
+    const prefixColumnNames = this.getPrefixColumnNames();
+    const prefixIndexPrefix = prefixColumnNames.length > 0 ? prefixColumnNames.join(", ") + ", " : "";
+    const indexSuffix = prefixColumnNames.length > 0 ? "_" + prefixColumnNames.join("_") : "";
+    const createTableSql = `
+    CREATE TABLE IF NOT EXISTS ${this.tableName} (
+      id SERIAL NOT NULL,
+      ${prefixColumnsSql}fingerprint text NOT NULL,
+      queue text NOT NULL,
       job_run_id text NOT NULL,
       status job_status NOT NULL default 'PENDING',
       input jsonb NOT NULL,
@@ -2671,7 +3458,8 @@ class SupabaseQueueStorage {
       error_code text,
       progress real DEFAULT 0,
       progress_message text DEFAULT '',
-      progress_details jsonb
+      progress_details jsonb,
+      worker_id text
     )`;
     const { error: tableError } = await this.client.rpc("exec_sql", { query: createTableSql });
     if (tableError) {
@@ -2680,12 +3468,12 @@ class SupabaseQueueStorage {
       }
     }
     const indexes = [
-      `CREATE INDEX IF NOT EXISTS job_fetcher_idx ON job_queue (id, status, run_after)`,
-      `CREATE INDEX IF NOT EXISTS job_queue_fetcher_idx ON job_queue (queue, status, run_after)`,
-      `CREATE INDEX IF NOT EXISTS jobs_fingerprint_unique_idx ON job_queue (queue, fingerprint, status)`
+      `CREATE INDEX IF NOT EXISTS job_fetcher${indexSuffix}_idx ON ${this.tableName} (${prefixIndexPrefix}id, status, run_after)`,
+      `CREATE INDEX IF NOT EXISTS job_queue_fetcher${indexSuffix}_idx ON ${this.tableName} (${prefixIndexPrefix}queue, status, run_after)`,
+      `CREATE INDEX IF NOT EXISTS jobs_fingerprint${indexSuffix}_unique_idx ON ${this.tableName} (${prefixIndexPrefix}queue, fingerprint, status)`
     ];
     for (const indexSql of indexes) {
-      const { error: indexError } = await this.client.rpc("exec_sql", { query: indexSql });
+      await this.client.rpc("exec_sql", { query: indexSql });
     }
   }
   async add(job) {
@@ -2699,7 +3487,9 @@ class SupabaseQueueStorage {
     job.progress_details = null;
     job.created_at = now;
     job.run_after = now;
-    const { data, error } = await this.client.from("job_queue").insert({
+    const prefixInsertValues = this.getPrefixInsertValues();
+    const { data, error } = await this.client.from(this.tableName).insert({
+      ...prefixInsertValues,
       queue: job.queue,
       fingerprint: job.fingerprint,
       input: job.input,
@@ -2720,7 +3510,9 @@ class SupabaseQueueStorage {
     return job.id;
   }
   async get(id) {
-    const { data, error } = await this.client.from("job_queue").select("*").eq("id", id).eq("queue", this.queueName).single();
+    let query = this.client.from(this.tableName).select("*").eq("id", id).eq("queue", this.queueName);
+    query = this.applyPrefixFilters(query);
+    const { data, error } = await query.single();
     if (error) {
       if (error.code === "PGRST116")
         return;
@@ -2730,36 +3522,53 @@ class SupabaseQueueStorage {
   }
   async peek(status = "PENDING" /* PENDING */, num = 100) {
     num = Number(num) || 100;
-    const { data, error } = await this.client.from("job_queue").select("*").eq("queue", this.queueName).eq("status", status).order("run_after", { ascending: true }).limit(num);
+    let query = this.client.from(this.tableName).select("*").eq("queue", this.queueName).eq("status", status);
+    query = this.applyPrefixFilters(query);
+    const { data, error } = await query.order("run_after", { ascending: true }).limit(num);
     if (error)
       throw error;
     return data ?? [];
   }
-  async next() {
-    const { data: jobs, error: selectError } = await this.client.from("job_queue").select("*").eq("queue", this.queueName).eq("status", "PENDING" /* PENDING */).lte("run_after", new Date().toISOString()).order("run_after", { ascending: true }).limit(1);
+  async next(workerId) {
+    let selectQuery = this.client.from(this.tableName).select("*").eq("queue", this.queueName).eq("status", "PENDING" /* PENDING */).lte("run_after", new Date().toISOString());
+    selectQuery = this.applyPrefixFilters(selectQuery);
+    const { data: jobs, error: selectError } = await selectQuery.order("run_after", { ascending: true }).limit(1);
     if (selectError)
       throw selectError;
     if (!jobs || jobs.length === 0)
       return;
     const job = jobs[0];
-    const { data: updatedJob, error: updateError } = await this.client.from("job_queue").update({
+    let updateQuery = this.client.from(this.tableName).update({
       status: "PROCESSING" /* PROCESSING */,
-      last_ran_at: new Date().toISOString()
-    }).eq("id", job.id).eq("queue", this.queueName).select().single();
+      last_ran_at: new Date().toISOString(),
+      worker_id: workerId ?? null
+    }).eq("id", job.id).eq("queue", this.queueName);
+    updateQuery = this.applyPrefixFilters(updateQuery);
+    const { data: updatedJob, error: updateError } = await updateQuery.select().single();
     if (updateError)
       throw updateError;
     return updatedJob;
   }
   async size(status = "PENDING" /* PENDING */) {
-    const { count, error } = await this.client.from("job_queue").select("*", { count: "exact", head: true }).eq("queue", this.queueName).eq("status", status);
+    let query = this.client.from(this.tableName).select("*", { count: "exact", head: true }).eq("queue", this.queueName).eq("status", status);
+    query = this.applyPrefixFilters(query);
+    const { count, error } = await query;
     if (error)
       throw error;
     return count ?? 0;
   }
+  async getAllJobs() {
+    let query = this.client.from(this.tableName).select("*").eq("queue", this.queueName);
+    query = this.applyPrefixFilters(query);
+    const { data, error } = await query;
+    if (error)
+      throw error;
+    return data ?? [];
+  }
   async complete(jobDetails) {
     const now = new Date().toISOString();
     if (jobDetails.status === "DISABLED" /* DISABLED */) {
-      const { error: error2 } = await this.client.from("job_queue").update({
+      let query2 = this.client.from(this.tableName).update({
         status: jobDetails.status,
         progress: 100,
         progress_message: "",
@@ -2767,16 +3576,20 @@ class SupabaseQueueStorage {
         completed_at: now,
         last_ran_at: now
       }).eq("id", jobDetails.id).eq("queue", this.queueName);
+      query2 = this.applyPrefixFilters(query2);
+      const { error: error2 } = await query2;
       if (error2)
         throw error2;
       return;
     }
-    const { data: current, error: getError } = await this.client.from("job_queue").select("run_attempts").eq("id", jobDetails.id).eq("queue", this.queueName).single();
+    let getQuery = this.client.from(this.tableName).select("run_attempts").eq("id", jobDetails.id).eq("queue", this.queueName);
+    getQuery = this.applyPrefixFilters(getQuery);
+    const { data: current, error: getError } = await getQuery.single();
     if (getError)
       throw getError;
     const nextAttempts = (current?.run_attempts ?? 0) + 1;
     if (jobDetails.status === "PENDING" /* PENDING */) {
-      const { error: error2 } = await this.client.from("job_queue").update({
+      let query2 = this.client.from(this.tableName).update({
         error: jobDetails.error ?? null,
         error_code: jobDetails.error_code ?? null,
         status: jobDetails.status,
@@ -2787,12 +3600,14 @@ class SupabaseQueueStorage {
         run_attempts: nextAttempts,
         last_ran_at: now
       }).eq("id", jobDetails.id).eq("queue", this.queueName);
+      query2 = this.applyPrefixFilters(query2);
+      const { error: error2 } = await query2;
       if (error2)
         throw error2;
       return;
     }
     if (jobDetails.status === "COMPLETED" /* COMPLETED */ || jobDetails.status === "FAILED" /* FAILED */) {
-      const { error: error2 } = await this.client.from("job_queue").update({
+      let query2 = this.client.from(this.tableName).update({
         output: jobDetails.output ?? null,
         error: jobDetails.error ?? null,
         error_code: jobDetails.error_code ?? null,
@@ -2804,11 +3619,13 @@ class SupabaseQueueStorage {
         completed_at: now,
         last_ran_at: now
       }).eq("id", jobDetails.id).eq("queue", this.queueName);
+      query2 = this.applyPrefixFilters(query2);
+      const { error: error2 } = await query2;
       if (error2)
         throw error2;
       return;
     }
-    const { error } = await this.client.from("job_queue").update({
+    let query = this.client.from(this.tableName).update({
       status: jobDetails.status,
       output: jobDetails.output ?? null,
       error: jobDetails.error ?? null,
@@ -2817,17 +3634,23 @@ class SupabaseQueueStorage {
       run_attempts: nextAttempts,
       last_ran_at: now
     }).eq("id", jobDetails.id).eq("queue", this.queueName);
+    query = this.applyPrefixFilters(query);
+    const { error } = await query;
     if (error)
       throw error;
   }
   async deleteAll() {
-    const { error } = await this.client.from("job_queue").delete().eq("queue", this.queueName);
+    let query = this.client.from(this.tableName).delete().eq("queue", this.queueName);
+    query = this.applyPrefixFilters(query);
+    const { error } = await query;
     if (error)
       throw error;
   }
   async outputForInput(input) {
     const fingerprint = await makeFingerprint7(input);
-    const { data, error } = await this.client.from("job_queue").select("output").eq("fingerprint", fingerprint).eq("queue", this.queueName).eq("status", "COMPLETED" /* COMPLETED */).single();
+    let query = this.client.from(this.tableName).select("output").eq("fingerprint", fingerprint).eq("queue", this.queueName).eq("status", "COMPLETED" /* COMPLETED */);
+    query = this.applyPrefixFilters(query);
+    const { data, error } = await query.single();
     if (error) {
       if (error.code === "PGRST116")
         return null;
@@ -2836,42 +3659,617 @@ class SupabaseQueueStorage {
     return data?.output ?? null;
   }
   async abort(jobId) {
-    const { error } = await this.client.from("job_queue").update({ status: "ABORTING" /* ABORTING */ }).eq("id", jobId).eq("queue", this.queueName);
+    let query = this.client.from(this.tableName).update({ status: "ABORTING" /* ABORTING */ }).eq("id", jobId).eq("queue", this.queueName);
+    query = this.applyPrefixFilters(query);
+    const { error } = await query;
     if (error)
       throw error;
   }
   async getByRunId(job_run_id) {
-    const { data, error } = await this.client.from("job_queue").select("*").eq("job_run_id", job_run_id).eq("queue", this.queueName);
+    let query = this.client.from(this.tableName).select("*").eq("job_run_id", job_run_id).eq("queue", this.queueName);
+    query = this.applyPrefixFilters(query);
+    const { data, error } = await query;
     if (error)
       throw error;
     return data ?? [];
   }
   async saveProgress(jobId, progress, message, details) {
-    const { error } = await this.client.from("job_queue").update({
+    let query = this.client.from(this.tableName).update({
       progress,
       progress_message: message,
       progress_details: details
     }).eq("id", jobId).eq("queue", this.queueName);
+    query = this.applyPrefixFilters(query);
+    const { error } = await query;
     if (error)
       throw error;
   }
   async delete(jobId) {
-    const { error } = await this.client.from("job_queue").delete().eq("id", jobId).eq("queue", this.queueName);
+    let query = this.client.from(this.tableName).delete().eq("id", jobId).eq("queue", this.queueName);
+    query = this.applyPrefixFilters(query);
+    const { error } = await query;
     if (error)
       throw error;
   }
   async deleteJobsByStatusAndAge(status, olderThanMs) {
     const cutoffDate = new Date(Date.now() - olderThanMs).toISOString();
-    const { error } = await this.client.from("job_queue").delete().eq("queue", this.queueName).eq("status", status).not("completed_at", "is", null).lte("completed_at", cutoffDate);
+    let query = this.client.from(this.tableName).delete().eq("queue", this.queueName).eq("status", status).not("completed_at", "is", null).lte("completed_at", cutoffDate);
+    query = this.applyPrefixFilters(query);
+    const { error } = await query;
+    if (error)
+      throw error;
+  }
+  matchesPrefixFilter(job, prefixFilter) {
+    if (!job)
+      return false;
+    if (job.queue !== this.queueName) {
+      return false;
+    }
+    if (prefixFilter && Object.keys(prefixFilter).length === 0) {
+      return true;
+    }
+    const filterValues = prefixFilter ?? this.prefixValues;
+    if (Object.keys(filterValues).length === 0) {
+      return true;
+    }
+    for (const [key, value] of Object.entries(filterValues)) {
+      if (job[key] !== value) {
+        return false;
+      }
+    }
+    return true;
+  }
+  isCustomPrefixFilter(prefixFilter) {
+    if (prefixFilter === undefined) {
+      return false;
+    }
+    if (Object.keys(prefixFilter).length === 0) {
+      return true;
+    }
+    const instanceKeys = Object.keys(this.prefixValues);
+    const filterKeys = Object.keys(prefixFilter);
+    if (instanceKeys.length !== filterKeys.length) {
+      return true;
+    }
+    for (const key of instanceKeys) {
+      if (this.prefixValues[key] !== prefixFilter[key]) {
+        return true;
+      }
+    }
+    return false;
+  }
+  async getAllJobsWithFilter(prefixFilter) {
+    let query = this.client.from(this.tableName).select("*").eq("queue", this.queueName);
+    for (const [key, value] of Object.entries(prefixFilter)) {
+      query = query.eq(key, value);
+    }
+    const { data, error } = await query;
     if (error)
       throw error;
+    return data ?? [];
+  }
+  subscribeToChanges(callback, options) {
+    return this.subscribeToChangesWithRealtime(callback, options?.prefixFilter);
+  }
+  subscribeToChangesWithRealtime(callback, prefixFilter) {
+    const channelName = `queue-${this.tableName}-${this.queueName}-${Date.now()}`;
+    this.realtimeChannel = this.client.channel(channelName).on("postgres_changes", {
+      event: "*",
+      schema: "public",
+      table: this.tableName,
+      filter: `queue=eq.${this.queueName}`
+    }, (payload) => {
+      const newJob = payload.new;
+      const oldJob = payload.old;
+      const newMatches = this.matchesPrefixFilter(newJob, prefixFilter);
+      const oldMatches = this.matchesPrefixFilter(oldJob, prefixFilter);
+      if (!newMatches && !oldMatches) {
+        return;
+      }
+      callback({
+        type: payload.eventType.toUpperCase(),
+        old: oldJob && Object.keys(oldJob).length > 0 ? oldJob : undefined,
+        new: newJob && Object.keys(newJob).length > 0 ? newJob : undefined
+      });
+    }).subscribe();
+    return () => {
+      if (this.realtimeChannel) {
+        this.client.removeChannel(this.realtimeChannel);
+        this.realtimeChannel = null;
+      }
+    };
+  }
+  getPollingManager() {
+    if (!this.pollingManager) {
+      this.pollingManager = new PollingSubscriptionManager(async () => {
+        const jobs = await this.getAllJobs();
+        return new Map(jobs.map((j) => [j.id, j]));
+      }, (a, b) => JSON.stringify(a) === JSON.stringify(b), {
+        insert: (item) => ({ type: "INSERT", new: item }),
+        update: (oldItem, newItem) => ({ type: "UPDATE", old: oldItem, new: newItem }),
+        delete: (item) => ({ type: "DELETE", old: item })
+      });
+    }
+    return this.pollingManager;
+  }
+  subscribeWithCustomPrefixFilterPolling(callback, prefixFilter, intervalMs) {
+    let lastKnownJobs = new Map;
+    let cancelled = false;
+    const poll = async () => {
+      if (cancelled)
+        return;
+      try {
+        const currentJobs = await this.getAllJobsWithFilter(prefixFilter);
+        if (cancelled)
+          return;
+        const currentMap = new Map(currentJobs.map((j) => [j.id, j]));
+        for (const [id, job] of currentMap) {
+          const old = lastKnownJobs.get(id);
+          if (!old) {
+            callback({ type: "INSERT", new: job });
+          } else if (JSON.stringify(old) !== JSON.stringify(job)) {
+            callback({ type: "UPDATE", old, new: job });
+          }
+        }
+        for (const [id, job] of lastKnownJobs) {
+          if (!currentMap.has(id)) {
+            callback({ type: "DELETE", old: job });
+          }
+        }
+        lastKnownJobs = currentMap;
+      } catch {}
+    };
+    const intervalId = setInterval(poll, intervalMs);
+    poll();
+    return () => {
+      cancelled = true;
+      clearInterval(intervalId);
+    };
+  }
+  subscribeToChangesWithPolling(callback, options) {
+    const intervalMs = options?.pollingIntervalMs ?? 1000;
+    if (this.isCustomPrefixFilter(options?.prefixFilter)) {
+      return this.subscribeWithCustomPrefixFilterPolling(callback, options.prefixFilter, intervalMs);
+    }
+    const manager = this.getPollingManager();
+    return manager.subscribe(callback, { intervalMs });
+  }
+}
+// src/limiter/PostgresRateLimiterStorage.ts
+import { createServiceToken as createServiceToken22 } from "@workglow/util";
+var POSTGRES_RATE_LIMITER_STORAGE = createServiceToken22("ratelimiter.storage.postgres");
+
+class PostgresRateLimiterStorage {
+  db;
+  prefixes;
+  prefixValues;
+  executionTableName;
+  nextAvailableTableName;
+  constructor(db, options) {
+    this.db = db;
+    this.prefixes = options?.prefixes ?? [];
+    this.prefixValues = options?.prefixValues ?? {};
+    if (this.prefixes.length > 0) {
+      const prefixNames = this.prefixes.map((p) => p.name).join("_");
+      this.executionTableName = `rate_limit_executions_${prefixNames}`;
+      this.nextAvailableTableName = `rate_limit_next_available_${prefixNames}`;
+    } else {
+      this.executionTableName = "rate_limit_executions";
+      this.nextAvailableTableName = "rate_limit_next_available";
+    }
+  }
+  getPrefixColumnType(type) {
+    return type === "uuid" ? "UUID" : "INTEGER";
+  }
+  buildPrefixColumnsSql() {
+    if (this.prefixes.length === 0)
+      return "";
+    return this.prefixes.map((p) => `${p.name} ${this.getPrefixColumnType(p.type)} NOT NULL`).join(`,
+        `) + `,
+        `;
+  }
+  getPrefixColumnNames() {
+    return this.prefixes.map((p) => p.name);
+  }
+  buildPrefixWhereClause(startParam) {
+    if (this.prefixes.length === 0) {
+      return { conditions: "", params: [] };
+    }
+    const conditions = this.prefixes.map((p, i) => `${p.name} = $${startParam + i}`).join(" AND ");
+    const params = this.prefixes.map((p) => this.prefixValues[p.name]);
+    return { conditions: " AND " + conditions, params };
+  }
+  getPrefixParamValues() {
+    return this.prefixes.map((p) => this.prefixValues[p.name]);
+  }
+  async setupDatabase() {
+    const prefixColumnsSql = this.buildPrefixColumnsSql();
+    const prefixColumnNames = this.getPrefixColumnNames();
+    const prefixIndexPrefix = prefixColumnNames.length > 0 ? prefixColumnNames.join(", ") + ", " : "";
+    const indexSuffix = prefixColumnNames.length > 0 ? "_" + prefixColumnNames.join("_") : "";
+    await this.db.query(`
+      CREATE TABLE IF NOT EXISTS ${this.executionTableName} (
+        id SERIAL PRIMARY KEY,
+        ${prefixColumnsSql}queue_name TEXT NOT NULL,
+        executed_at TIMESTAMP WITH TIME ZONE DEFAULT NOW()
+      )
+    `);
+    await this.db.query(`
+      CREATE INDEX IF NOT EXISTS rate_limit_exec_queue${indexSuffix}_idx 
+        ON ${this.executionTableName} (${prefixIndexPrefix}queue_name, executed_at)
+    `);
+    const primaryKeyColumns = prefixColumnNames.length > 0 ? `${prefixColumnNames.join(", ")}, queue_name` : "queue_name";
+    await this.db.query(`
+      CREATE TABLE IF NOT EXISTS ${this.nextAvailableTableName} (
+        ${prefixColumnsSql}queue_name TEXT NOT NULL,
+        next_available_at TIMESTAMP WITH TIME ZONE,
+        PRIMARY KEY (${primaryKeyColumns})
+      )
+    `);
+  }
+  async recordExecution(queueName) {
+    const prefixColumnNames = this.getPrefixColumnNames();
+    const prefixColumnsInsert = prefixColumnNames.length > 0 ? prefixColumnNames.join(", ") + ", " : "";
+    const prefixParamValues = this.getPrefixParamValues();
+    const prefixParamPlaceholders = prefixColumnNames.length > 0 ? prefixColumnNames.map((_, i) => `$${i + 1}`).join(", ") + ", " : "";
+    const queueParamNum = prefixColumnNames.length + 1;
+    await this.db.query(`
+      INSERT INTO ${this.executionTableName} (${prefixColumnsInsert}queue_name)
+      VALUES (${prefixParamPlaceholders}$${queueParamNum})
+    `, [...prefixParamValues, queueName]);
+  }
+  async getExecutionCount(queueName, windowStartTime) {
+    const { conditions: prefixConditions, params: prefixParams } = this.buildPrefixWhereClause(3);
+    const result = await this.db.query(`
+      SELECT COUNT(*) AS count
+      FROM ${this.executionTableName}
+      WHERE queue_name = $1 AND executed_at > $2${prefixConditions}
+    `, [queueName, windowStartTime, ...prefixParams]);
+    return parseInt(result.rows[0]?.count ?? "0", 10);
+  }
+  async getOldestExecutionAtOffset(queueName, offset) {
+    const { conditions: prefixConditions, params: prefixParams } = this.buildPrefixWhereClause(3);
+    const result = await this.db.query(`
+      SELECT executed_at
+      FROM ${this.executionTableName}
+      WHERE queue_name = $1${prefixConditions}
+      ORDER BY executed_at ASC
+      LIMIT 1 OFFSET $2
+    `, [queueName, offset, ...prefixParams]);
+    const executedAt = result.rows[0]?.executed_at;
+    if (!executedAt)
+      return;
+    return new Date(executedAt).toISOString();
+  }
+  async getNextAvailableTime(queueName) {
+    const { conditions: prefixConditions, params: prefixParams } = this.buildPrefixWhereClause(2);
+    const result = await this.db.query(`
+      SELECT next_available_at
+      FROM ${this.nextAvailableTableName}
+      WHERE queue_name = $1${prefixConditions}
+    `, [queueName, ...prefixParams]);
+    const nextAvailableAt = result.rows[0]?.next_available_at;
+    if (!nextAvailableAt)
+      return;
+    return new Date(nextAvailableAt).toISOString();
+  }
+  async setNextAvailableTime(queueName, nextAvailableAt) {
+    const prefixColumnNames = this.getPrefixColumnNames();
+    const prefixColumnsInsert = prefixColumnNames.length > 0 ? prefixColumnNames.join(", ") + ", " : "";
+    const prefixParamValues = this.getPrefixParamValues();
+    const prefixParamPlaceholders = prefixColumnNames.length > 0 ? prefixColumnNames.map((_, i) => `$${i + 1}`).join(", ") + ", " : "";
+    const baseParamStart = prefixColumnNames.length + 1;
+    const conflictColumns = prefixColumnNames.length > 0 ? `${prefixColumnNames.join(", ")}, queue_name` : "queue_name";
+    await this.db.query(`
+      INSERT INTO ${this.nextAvailableTableName} (${prefixColumnsInsert}queue_name, next_available_at)
+      VALUES (${prefixParamPlaceholders}$${baseParamStart}, $${baseParamStart + 1})
+      ON CONFLICT (${conflictColumns})
+      DO UPDATE SET next_available_at = EXCLUDED.next_available_at
+    `, [...prefixParamValues, queueName, nextAvailableAt]);
+  }
+  async clear(queueName) {
+    const { conditions: prefixConditions, params: prefixParams } = this.buildPrefixWhereClause(2);
+    await this.db.query(`DELETE FROM ${this.executionTableName} WHERE queue_name = $1${prefixConditions}`, [queueName, ...prefixParams]);
+    await this.db.query(`DELETE FROM ${this.nextAvailableTableName} WHERE queue_name = $1${prefixConditions}`, [queueName, ...prefixParams]);
+  }
+}
+// src/limiter/SqliteRateLimiterStorage.ts
+import { createServiceToken as createServiceToken23, sleep as sleep5, toSQLiteTimestamp } from "@workglow/util";
+var SQLITE_RATE_LIMITER_STORAGE = createServiceToken23("ratelimiter.storage.sqlite");
+
+class SqliteRateLimiterStorage {
+  db;
+  prefixes;
+  prefixValues;
+  executionTableName;
+  nextAvailableTableName;
+  constructor(db, options) {
+    this.db = db;
+    this.prefixes = options?.prefixes ?? [];
+    this.prefixValues = options?.prefixValues ?? {};
+    if (this.prefixes.length > 0) {
+      const prefixNames = this.prefixes.map((p) => p.name).join("_");
+      this.executionTableName = `rate_limit_executions_${prefixNames}`;
+      this.nextAvailableTableName = `rate_limit_next_available_${prefixNames}`;
+    } else {
+      this.executionTableName = "rate_limit_executions";
+      this.nextAvailableTableName = "rate_limit_next_available";
+    }
+  }
+  getPrefixColumnType(type) {
+    return type === "uuid" ? "TEXT" : "INTEGER";
+  }
+  buildPrefixColumnsSql() {
+    if (this.prefixes.length === 0)
+      return "";
+    return this.prefixes.map((p) => `${p.name} ${this.getPrefixColumnType(p.type)} NOT NULL`).join(`,
+        `) + `,
+        `;
+  }
+  getPrefixColumnNames() {
+    return this.prefixes.map((p) => p.name);
+  }
+  buildPrefixWhereClause() {
+    if (this.prefixes.length === 0) {
+      return "";
+    }
+    const conditions = this.prefixes.map((p) => `${p.name} = ?`).join(" AND ");
+    return " AND " + conditions;
+  }
+  getPrefixParamValues() {
+    return this.prefixes.map((p) => this.prefixValues[p.name]);
+  }
+  async setupDatabase() {
+    await sleep5(0);
+    const prefixColumnsSql = this.buildPrefixColumnsSql();
+    const prefixColumnNames = this.getPrefixColumnNames();
+    const prefixIndexPrefix = prefixColumnNames.length > 0 ? prefixColumnNames.join(", ") + ", " : "";
+    const indexSuffix = prefixColumnNames.length > 0 ? "_" + prefixColumnNames.join("_") : "";
+    this.db.exec(`
+      CREATE TABLE IF NOT EXISTS ${this.executionTableName} (
+        id INTEGER PRIMARY KEY,
+        ${prefixColumnsSql}queue_name TEXT NOT NULL,
+        executed_at TEXT DEFAULT CURRENT_TIMESTAMP
+      );
+      
+      CREATE INDEX IF NOT EXISTS rate_limit_exec_queue${indexSuffix}_idx 
+        ON ${this.executionTableName} (${prefixIndexPrefix}queue_name, executed_at);
+    `);
+    this.db.exec(`
+      CREATE TABLE IF NOT EXISTS ${this.nextAvailableTableName} (
+        ${prefixColumnsSql}queue_name TEXT PRIMARY KEY,
+        next_available_at TEXT
+      );
+    `);
+  }
+  async recordExecution(queueName) {
+    const prefixColumnNames = this.getPrefixColumnNames();
+    const prefixColumnsInsert = prefixColumnNames.length > 0 ? prefixColumnNames.join(", ") + ", " : "";
+    const prefixPlaceholders = prefixColumnNames.length > 0 ? prefixColumnNames.map(() => "?").join(", ") + ", " : "";
+    const prefixParamValues = this.getPrefixParamValues();
+    const stmt = this.db.prepare(`
+      INSERT INTO ${this.executionTableName} (${prefixColumnsInsert}queue_name)
+      VALUES (${prefixPlaceholders}?)
+    `);
+    stmt.run(...prefixParamValues, queueName);
+  }
+  async getExecutionCount(queueName, windowStartTime) {
+    const prefixConditions = this.buildPrefixWhereClause();
+    const prefixParams = this.getPrefixParamValues();
+    const thresholdTime = toSQLiteTimestamp(new Date(windowStartTime));
+    const stmt = this.db.prepare(`
+      SELECT COUNT(*) AS count
+      FROM ${this.executionTableName}
+      WHERE queue_name = ? AND executed_at > ?${prefixConditions}
+    `);
+    const result = stmt.get(queueName, thresholdTime, ...prefixParams);
+    return result?.count ?? 0;
+  }
+  async getOldestExecutionAtOffset(queueName, offset) {
+    const prefixConditions = this.buildPrefixWhereClause();
+    const prefixParams = this.getPrefixParamValues();
+    const stmt = this.db.prepare(`
+      SELECT executed_at
+      FROM ${this.executionTableName}
+      WHERE queue_name = ?${prefixConditions}
+      ORDER BY executed_at ASC
+      LIMIT 1 OFFSET ?
+    `);
+    const result = stmt.get(queueName, ...prefixParams, offset);
+    if (!result)
+      return;
+    return result.executed_at + "Z";
+  }
+  async getNextAvailableTime(queueName) {
+    const prefixConditions = this.buildPrefixWhereClause();
+    const prefixParams = this.getPrefixParamValues();
+    const stmt = this.db.prepare(`
+      SELECT next_available_at
+      FROM ${this.nextAvailableTableName}
+      WHERE queue_name = ?${prefixConditions}
+    `);
+    const result = stmt.get(queueName, ...prefixParams);
+    if (!result?.next_available_at)
+      return;
+    return result.next_available_at + "Z";
+  }
+  async setNextAvailableTime(queueName, nextAvailableAt) {
+    const prefixColumnNames = this.getPrefixColumnNames();
+    const prefixColumnsInsert = prefixColumnNames.length > 0 ? prefixColumnNames.join(", ") + ", " : "";
+    const prefixPlaceholders = prefixColumnNames.length > 0 ? prefixColumnNames.map(() => "?").join(", ") + ", " : "";
+    const prefixParamValues = this.getPrefixParamValues();
+    const stmt = this.db.prepare(`
+      INSERT INTO ${this.nextAvailableTableName} (${prefixColumnsInsert}queue_name, next_available_at)
+      VALUES (${prefixPlaceholders}?, ?)
+      ON CONFLICT(queue_name) DO UPDATE SET next_available_at = excluded.next_available_at
+    `);
+    stmt.run(...prefixParamValues, queueName, nextAvailableAt);
+  }
+  async clear(queueName) {
+    const prefixConditions = this.buildPrefixWhereClause();
+    const prefixParams = this.getPrefixParamValues();
+    this.db.prepare(`DELETE FROM ${this.executionTableName} WHERE queue_name = ?${prefixConditions}`).run(queueName, ...prefixParams);
+    this.db.prepare(`DELETE FROM ${this.nextAvailableTableName} WHERE queue_name = ?${prefixConditions}`).run(queueName, ...prefixParams);
+  }
+}
+// src/limiter/SupabaseRateLimiterStorage.ts
+import { createServiceToken as createServiceToken24 } from "@workglow/util";
+var SUPABASE_RATE_LIMITER_STORAGE = createServiceToken24("ratelimiter.storage.supabase");
+
+class SupabaseRateLimiterStorage {
+  client;
+  prefixes;
+  prefixValues;
+  executionTableName;
+  nextAvailableTableName;
+  constructor(client, options) {
+    this.client = client;
+    this.prefixes = options?.prefixes ?? [];
+    this.prefixValues = options?.prefixValues ?? {};
+    if (this.prefixes.length > 0) {
+      const prefixNames = this.prefixes.map((p) => p.name).join("_");
+      this.executionTableName = `rate_limit_executions_${prefixNames}`;
+      this.nextAvailableTableName = `rate_limit_next_available_${prefixNames}`;
+    } else {
+      this.executionTableName = "rate_limit_executions";
+      this.nextAvailableTableName = "rate_limit_next_available";
+    }
+  }
+  getPrefixColumnType(type) {
+    return type === "uuid" ? "UUID" : "INTEGER";
+  }
+  buildPrefixColumnsSql() {
+    if (this.prefixes.length === 0)
+      return "";
+    return this.prefixes.map((p) => `${p.name} ${this.getPrefixColumnType(p.type)} NOT NULL`).join(`,
+        `) + `,
+        `;
+  }
+  getPrefixColumnNames() {
+    return this.prefixes.map((p) => p.name);
+  }
+  applyPrefixFilters(query) {
+    let result = query;
+    for (const prefix of this.prefixes) {
+      result = result.eq(prefix.name, this.prefixValues[prefix.name]);
+    }
+    return result;
+  }
+  getPrefixInsertValues() {
+    const values = {};
+    for (const prefix of this.prefixes) {
+      values[prefix.name] = this.prefixValues[prefix.name];
+    }
+    return values;
+  }
+  async setupDatabase() {
+    const prefixColumnsSql = this.buildPrefixColumnsSql();
+    const prefixColumnNames = this.getPrefixColumnNames();
+    const prefixIndexPrefix = prefixColumnNames.length > 0 ? prefixColumnNames.join(", ") + ", " : "";
+    const indexSuffix = prefixColumnNames.length > 0 ? "_" + prefixColumnNames.join("_") : "";
+    const createExecTableSql = `
+      CREATE TABLE IF NOT EXISTS ${this.executionTableName} (
+        id SERIAL PRIMARY KEY,
+        ${prefixColumnsSql}queue_name TEXT NOT NULL,
+        executed_at TIMESTAMP WITH TIME ZONE DEFAULT NOW()
+      )
+    `;
+    const { error: execTableError } = await this.client.rpc("exec_sql", {
+      query: createExecTableSql
+    });
+    if (execTableError && execTableError.code !== "42P07") {
+      throw execTableError;
+    }
+    const createExecIndexSql = `
+      CREATE INDEX IF NOT EXISTS rate_limit_exec_queue${indexSuffix}_idx 
+        ON ${this.executionTableName} (${prefixIndexPrefix}queue_name, executed_at)
+    `;
+    await this.client.rpc("exec_sql", { query: createExecIndexSql });
+    const primaryKeyColumns = prefixColumnNames.length > 0 ? `${prefixColumnNames.join(", ")}, queue_name` : "queue_name";
+    const createNextTableSql = `
+      CREATE TABLE IF NOT EXISTS ${this.nextAvailableTableName} (
+        ${prefixColumnsSql}queue_name TEXT NOT NULL,
+        next_available_at TIMESTAMP WITH TIME ZONE,
+        PRIMARY KEY (${primaryKeyColumns})
+      )
+    `;
+    const { error: nextTableError } = await this.client.rpc("exec_sql", {
+      query: createNextTableSql
+    });
+    if (nextTableError && nextTableError.code !== "42P07") {
+      throw nextTableError;
+    }
+  }
+  async recordExecution(queueName) {
+    const prefixInsertValues = this.getPrefixInsertValues();
+    const { error } = await this.client.from(this.executionTableName).insert({
+      ...prefixInsertValues,
+      queue_name: queueName
+    });
+    if (error)
+      throw error;
+  }
+  async getExecutionCount(queueName, windowStartTime) {
+    let query = this.client.from(this.executionTableName).select("*", { count: "exact", head: true }).eq("queue_name", queueName).gt("executed_at", windowStartTime);
+    query = this.applyPrefixFilters(query);
+    const { count, error } = await query;
+    if (error)
+      throw error;
+    return count ?? 0;
+  }
+  async getOldestExecutionAtOffset(queueName, offset) {
+    let query = this.client.from(this.executionTableName).select("executed_at").eq("queue_name", queueName);
+    query = this.applyPrefixFilters(query);
+    const { data, error } = await query.order("executed_at", { ascending: true }).range(offset, offset);
+    if (error)
+      throw error;
+    if (!data || data.length === 0)
+      return;
+    return new Date(data[0].executed_at).toISOString();
+  }
+  async getNextAvailableTime(queueName) {
+    let query = this.client.from(this.nextAvailableTableName).select("next_available_at").eq("queue_name", queueName);
+    query = this.applyPrefixFilters(query);
+    const { data, error } = await query.single();
+    if (error) {
+      if (error.code === "PGRST116")
+        return;
+      throw error;
+    }
+    if (!data?.next_available_at)
+      return;
+    return new Date(data.next_available_at).toISOString();
+  }
+  async setNextAvailableTime(queueName, nextAvailableAt) {
+    const prefixInsertValues = this.getPrefixInsertValues();
+    const { error } = await this.client.from(this.nextAvailableTableName).upsert({
+      ...prefixInsertValues,
+      queue_name: queueName,
+      next_available_at: nextAvailableAt
+    }, {
+      onConflict: this.prefixes.length > 0 ? `${this.getPrefixColumnNames().join(",")},queue_name` : "queue_name"
+    });
+    if (error)
+      throw error;
+  }
+  async clear(queueName) {
+    let execQuery = this.client.from(this.executionTableName).delete().eq("queue_name", queueName);
+    execQuery = this.applyPrefixFilters(execQuery);
+    const { error: execError } = await execQuery;
+    if (execError)
+      throw execError;
+    let nextQuery = this.client.from(this.nextAvailableTableName).delete().eq("queue_name", queueName);
+    nextQuery = this.applyPrefixFilters(nextQuery);
+    const { error: nextError } = await nextQuery;
+    if (nextError)
+      throw nextError;
   }
 }
 // src/kv/IndexedDbKvRepository.ts
-import { createServiceToken as createServiceToken21 } from "@workglow/util";
+import { createServiceToken as createServiceToken26 } from "@workglow/util";
 
 // src/tabular/IndexedDbTabularRepository.ts
-import { createServiceToken as createServiceToken20 } from "@workglow/util";
+import { createServiceToken as createServiceToken25 } from "@workglow/util";
 
 // src/util/IndexedDbTable.ts
 var METADATA_STORE_NAME = "__schema_metadata__";
@@ -3211,7 +4609,7 @@ async function dropIndexedDbTable(tableName) {
 }
 
 // src/tabular/IndexedDbTabularRepository.ts
-var IDB_TABULAR_REPOSITORY = createServiceToken20("storage.tabularRepository.indexedDb");
+var IDB_TABULAR_REPOSITORY = createServiceToken25("storage.tabularRepository.indexedDb");
 
 class IndexedDbTabularRepository extends TabularRepository {
   table;
@@ -3547,7 +4945,7 @@ class IndexedDbTabularRepository extends TabularRepository {
 }
 
 // src/kv/IndexedDbKvRepository.ts
-var IDB_KV_REPOSITORY = createServiceToken21("storage.kvRepository.indexedDb");
+var IDB_KV_REPOSITORY = createServiceToken26("storage.kvRepository.indexedDb");
 
 class IndexedDbKvRepository extends KvViaTabularRepository {
   dbName;
@@ -3559,18 +4957,42 @@ class IndexedDbKvRepository extends KvViaTabularRepository {
   }
 }
 // src/queue/IndexedDbQueueStorage.ts
-import { createServiceToken as createServiceToken22, makeFingerprint as makeFingerprint8, uuid4 as uuid45 } from "@workglow/util";
-var INDEXED_DB_QUEUE_STORAGE = createServiceToken22("jobqueue.storage.indexedDb");
+import { createServiceToken as createServiceToken27, makeFingerprint as makeFingerprint8, uuid4 as uuid45 } from "@workglow/util";
+var INDEXED_DB_QUEUE_STORAGE = createServiceToken27("jobqueue.storage.indexedDb");
 
 class IndexedDbQueueStorage {
   queueName;
   db;
   tableName;
   migrationOptions;
-  constructor(queueName, migrationOptions = {}) {
+  prefixes;
+  prefixValues;
+  pollingManager = null;
+  constructor(queueName, options = {}) {
     this.queueName = queueName;
-    this.tableName = `jobs_${queueName}`;
-    this.migrationOptions = migrationOptions;
+    this.migrationOptions = options;
+    this.prefixes = options.prefixes ?? [];
+    this.prefixValues = options.prefixValues ?? {};
+    if (this.prefixes.length > 0) {
+      const prefixNames = this.prefixes.map((p) => p.name).join("_");
+      this.tableName = `jobs_${prefixNames}`;
+    } else {
+      this.tableName = "jobs";
+    }
+  }
+  getPrefixColumnNames() {
+    return this.prefixes.map((p) => p.name);
+  }
+  matchesPrefixes(job) {
+    for (const [key, value] of Object.entries(this.prefixValues)) {
+      if (job[key] !== value) {
+        return false;
+      }
+    }
+    return true;
+  }
+  getPrefixKeyValues() {
+    return this.prefixes.map((p) => this.prefixValues[p.name]);
   }
   async getDb() {
     if (this.db)
@@ -3579,25 +5001,29 @@ class IndexedDbQueueStorage {
     return this.db;
   }
   async setupDatabase() {
+    const prefixColumnNames = this.getPrefixColumnNames();
+    const buildKeyPath = (basePath) => {
+      return [...prefixColumnNames, ...basePath];
+    };
     const expectedIndexes = [
       {
-        name: "status",
-        keyPath: `status`,
+        name: "queue_status",
+        keyPath: buildKeyPath(["queue", "status"]),
         options: { unique: false }
       },
       {
-        name: "status_run_after",
-        keyPath: ["status", "run_after"],
+        name: "queue_status_run_after",
+        keyPath: buildKeyPath(["queue", "status", "run_after"]),
         options: { unique: false }
       },
       {
-        name: "job_run_id",
-        keyPath: `job_run_id`,
+        name: "queue_job_run_id",
+        keyPath: buildKeyPath(["queue", "job_run_id"]),
         options: { unique: false }
       },
       {
-        name: "fingerprint_status",
-        keyPath: ["fingerprint", "status"],
+        name: "queue_fingerprint_status",
+        keyPath: buildKeyPath(["queue", "fingerprint", "status"]),
         options: { unique: false }
       }
     ];
@@ -3606,21 +5032,25 @@ class IndexedDbQueueStorage {
   async add(job) {
     const db = await this.getDb();
     const now = new Date().toISOString();
-    job.id = job.id ?? uuid45();
-    job.job_run_id = job.job_run_id ?? uuid45();
-    job.queue = this.queueName;
-    job.fingerprint = await makeFingerprint8(job.input);
-    job.status = "PENDING" /* PENDING */;
-    job.progress = 0;
-    job.progress_message = "";
-    job.progress_details = null;
-    job.created_at = now;
-    job.run_after = now;
+    const jobWithPrefixes = job;
+    jobWithPrefixes.id = jobWithPrefixes.id ?? uuid45();
+    jobWithPrefixes.job_run_id = jobWithPrefixes.job_run_id ?? uuid45();
+    jobWithPrefixes.queue = this.queueName;
+    jobWithPrefixes.fingerprint = await makeFingerprint8(jobWithPrefixes.input);
+    jobWithPrefixes.status = "PENDING" /* PENDING */;
+    jobWithPrefixes.progress = 0;
+    jobWithPrefixes.progress_message = "";
+    jobWithPrefixes.progress_details = null;
+    jobWithPrefixes.created_at = now;
+    jobWithPrefixes.run_after = now;
+    for (const [key, value] of Object.entries(this.prefixValues)) {
+      jobWithPrefixes[key] = value;
+    }
     const tx = db.transaction(this.tableName, "readwrite");
     const store = tx.objectStore(this.tableName);
     return new Promise((resolve, reject) => {
-      const request = store.add(job);
-      tx.oncomplete = () => resolve(job.id);
+      const request = store.add(jobWithPrefixes);
+      tx.oncomplete = () => resolve(jobWithPrefixes.id);
       tx.onerror = () => reject(tx.error);
       request.onerror = () => reject(request.error);
     });
@@ -3631,7 +5061,14 @@ class IndexedDbQueueStorage {
     const store = tx.objectStore(this.tableName);
     const request = store.get(id);
     return new Promise((resolve, reject) => {
-      request.onsuccess = () => resolve(request.result);
+      request.onsuccess = () => {
+        const job = request.result;
+        if (job && job.queue === this.queueName && this.matchesPrefixes(job)) {
+          resolve(job);
+        } else {
+          resolve(undefined);
+        }
+      };
       request.onerror = () => reject(request.error);
       tx.onerror = () => reject(tx.error);
     });
@@ -3640,10 +5077,11 @@ class IndexedDbQueueStorage {
     const db = await this.getDb();
     const tx = db.transaction(this.tableName, "readonly");
     const store = tx.objectStore(this.tableName);
-    const index = store.index("status_run_after");
+    const index = store.index("queue_status_run_after");
+    const prefixKeyValues = this.getPrefixKeyValues();
     return new Promise((resolve, reject) => {
       const ret = new Map;
-      const keyRange = IDBKeyRange.bound([status, ""], [status, "￿"]);
+      const keyRange = IDBKeyRange.bound([...prefixKeyValues, this.queueName, status, ""], [...prefixKeyValues, this.queueName, status, "￿"]);
       const cursorRequest = index.openCursor(keyRange);
       const handleCursor = (e) => {
         const cursor = e.target.result;
@@ -3651,7 +5089,10 @@ class IndexedDbQueueStorage {
           resolve(Array.from(ret.values()));
           return;
         }
-        ret.set(cursor.value.id, cursor.value);
+        const job = cursor.value;
+        if (this.matchesPrefixes(job)) {
+          ret.set(cursor.value.id, cursor.value);
+        }
         cursor.continue();
       };
       cursorRequest.onsuccess = handleCursor;
@@ -3659,14 +5100,15 @@ class IndexedDbQueueStorage {
       tx.onerror = () => reject(tx.error);
     });
   }
-  async next() {
+  async next(workerId) {
     const db = await this.getDb();
     const tx = db.transaction(this.tableName, "readwrite");
     const store = tx.objectStore(this.tableName);
-    const index = store.index("status_run_after");
+    const index = store.index("queue_status_run_after");
     const now = new Date().toISOString();
+    const prefixKeyValues = this.getPrefixKeyValues();
     return new Promise((resolve, reject) => {
-      const cursorRequest = index.openCursor(IDBKeyRange.bound(["PENDING" /* PENDING */, ""], ["PENDING" /* PENDING */, now], false, true));
+      const cursorRequest = index.openCursor(IDBKeyRange.bound([...prefixKeyValues, this.queueName, "PENDING" /* PENDING */, ""], [...prefixKeyValues, this.queueName, "PENDING" /* PENDING */, now], false, true));
       let jobToReturn;
       cursorRequest.onsuccess = (e) => {
         const cursor = e.target.result;
@@ -3679,12 +5121,13 @@ class IndexedDbQueueStorage {
           return;
         }
         const job = cursor.value;
-        if (job.status !== "PENDING" /* PENDING */) {
+        if (job.queue !== this.queueName || job.status !== "PENDING" /* PENDING */ || !this.matchesPrefixes(job)) {
           cursor.continue();
           return;
         }
         job.status = "PROCESSING" /* PROCESSING */;
         job.last_ran_at = now;
+        job.worker_id = workerId ?? null;
         try {
           const updateRequest = store.put(job);
           updateRequest.onsuccess = () => {
@@ -3708,11 +5151,13 @@ class IndexedDbQueueStorage {
   }
   async size(status = "PENDING" /* PENDING */) {
     const db = await this.getDb();
+    const prefixKeyValues = this.getPrefixKeyValues();
     return new Promise((resolve, reject) => {
       const tx = db.transaction(this.tableName, "readonly");
       const store = tx.objectStore(this.tableName);
-      const index = store.index("status");
-      const request = index.count(status);
+      const index = store.index("queue_status");
+      const keyRange = IDBKeyRange.only([...prefixKeyValues, this.queueName, status]);
+      const request = index.count(keyRange);
       request.onsuccess = () => resolve(request.result);
       request.onerror = () => reject(request.error);
       tx.onerror = () => reject(tx.error);
@@ -3726,9 +5171,18 @@ class IndexedDbQueueStorage {
       const getReq = store.get(job.id);
       getReq.onsuccess = () => {
         const existing = getReq.result;
-        const currentAttempts = existing?.run_attempts ?? 0;
+        if (!existing || existing.queue !== this.queueName || !this.matchesPrefixes(existing)) {
+          reject(new Error(`Job ${job.id} not found or does not belong to queue ${this.queueName}`));
+          return;
+        }
+        const currentAttempts = existing.run_attempts ?? 0;
         job.run_attempts = currentAttempts + 1;
-        const putReq = store.put(job);
+        job.queue = this.queueName;
+        const jobWithPrefixes = job;
+        for (const [key, value] of Object.entries(this.prefixValues)) {
+          jobWithPrefixes[key] = value;
+        }
+        const putReq = store.put(jobWithPrefixes);
         putReq.onsuccess = () => {};
         putReq.onerror = () => reject(putReq.error);
       };
@@ -3748,10 +5202,15 @@ class IndexedDbQueueStorage {
     const db = await this.getDb();
     const tx = db.transaction(this.tableName, "readonly");
     const store = tx.objectStore(this.tableName);
-    const index = store.index("job_run_id");
-    const request = index.getAll(job_run_id);
+    const index = store.index("queue_job_run_id");
+    const prefixKeyValues = this.getPrefixKeyValues();
+    const keyRange = IDBKeyRange.only([...prefixKeyValues, this.queueName, job_run_id]);
+    const request = index.getAll(keyRange);
     return new Promise((resolve, reject) => {
-      request.onsuccess = () => resolve(request.result);
+      request.onsuccess = () => {
+        const results = (request.result || []).filter((job) => this.matchesPrefixes(job));
+        resolve(results);
+      };
       request.onerror = () => reject(request.error);
       tx.onerror = () => reject(tx.error);
     });
@@ -3760,11 +5219,31 @@ class IndexedDbQueueStorage {
     const db = await this.getDb();
     const tx = db.transaction(this.tableName, "readwrite");
     const store = tx.objectStore(this.tableName);
-    const request = store.clear();
+    const index = store.index("queue_status");
+    const prefixKeyValues = this.getPrefixKeyValues();
     return new Promise((resolve, reject) => {
-      request.onsuccess = () => resolve();
-      request.onerror = () => reject(request.error);
+      const keyRange = IDBKeyRange.bound([...prefixKeyValues, this.queueName, ""], [...prefixKeyValues, this.queueName, "￿"]);
+      const request = index.openCursor(keyRange);
+      request.onsuccess = (event) => {
+        const cursor = event.target.result;
+        if (cursor) {
+          const job = cursor.value;
+          if (job.queue === this.queueName && this.matchesPrefixes(job)) {
+            const deleteRequest = cursor.delete();
+            deleteRequest.onsuccess = () => {
+              cursor.continue();
+            };
+            deleteRequest.onerror = () => {
+              cursor.continue();
+            };
+          } else {
+            cursor.continue();
+          }
+        }
+      };
+      tx.oncomplete = () => resolve();
       tx.onerror = () => reject(tx.error);
+      request.onerror = () => reject(request.error);
     });
   }
   async outputForInput(input) {
@@ -3772,10 +5251,23 @@ class IndexedDbQueueStorage {
     const db = await this.getDb();
     const tx = db.transaction(this.tableName, "readonly");
     const store = tx.objectStore(this.tableName);
-    const index = store.index("fingerprint_status");
-    const request = index.get([fingerprint, "COMPLETED" /* COMPLETED */]);
+    const index = store.index("queue_fingerprint_status");
+    const prefixKeyValues = this.getPrefixKeyValues();
+    const request = index.get([
+      ...prefixKeyValues,
+      this.queueName,
+      fingerprint,
+      "COMPLETED" /* COMPLETED */
+    ]);
     return new Promise((resolve, reject) => {
-      request.onsuccess = () => resolve(request.result?.output ?? null);
+      request.onsuccess = () => {
+        const job = request.result;
+        if (job && this.matchesPrefixes(job)) {
+          resolve(job.output ?? null);
+        } else {
+          resolve(null);
+        }
+      };
       request.onerror = () => reject(request.error);
       tx.onerror = () => reject(tx.error);
     });
@@ -3790,6 +5282,9 @@ class IndexedDbQueueStorage {
     await this.complete(job);
   }
   async delete(id) {
+    const job = await this.get(id);
+    if (!job)
+      return;
     const db = await this.getDb();
     const tx = db.transaction(this.tableName, "readwrite");
     const store = tx.objectStore(this.tableName);
@@ -3804,15 +5299,17 @@ class IndexedDbQueueStorage {
     const db = await this.getDb();
     const tx = db.transaction(this.tableName, "readwrite");
     const store = tx.objectStore(this.tableName);
-    const index = store.index("status");
+    const index = store.index("queue_status");
     const cutoffDate = new Date(Date.now() - olderThanMs).toISOString();
+    const prefixKeyValues = this.getPrefixKeyValues();
+    const keyRange = IDBKeyRange.only([...prefixKeyValues, this.queueName, status]);
     return new Promise((resolve, reject) => {
-      const request = index.openCursor();
+      const request = index.openCursor(keyRange);
       request.onsuccess = (event) => {
         const cursor = event.target.result;
         if (cursor) {
           const job = cursor.value;
-          if (job.status === status && job.completed_at && job.completed_at <= cutoffDate) {
+          if (job.queue === this.queueName && this.matchesPrefixes(job) && job.status === status && job.completed_at && job.completed_at <= cutoffDate) {
             cursor.delete();
           }
           cursor.continue();
@@ -3823,6 +5320,363 @@ class IndexedDbQueueStorage {
       request.onerror = () => reject(request.error);
     });
   }
+  async getAllJobs() {
+    const db = await this.getDb();
+    const tx = db.transaction(this.tableName, "readonly");
+    const store = tx.objectStore(this.tableName);
+    const index = store.index("queue_status");
+    const prefixKeyValues = this.getPrefixKeyValues();
+    return new Promise((resolve, reject) => {
+      const jobs = [];
+      const keyRange = IDBKeyRange.bound([...prefixKeyValues, this.queueName, ""], [...prefixKeyValues, this.queueName, "￿"]);
+      const request = index.openCursor(keyRange);
+      request.onsuccess = (event) => {
+        const cursor = event.target.result;
+        if (cursor) {
+          const job = cursor.value;
+          if (job.queue === this.queueName && this.matchesPrefixes(job)) {
+            jobs.push(job);
+          }
+          cursor.continue();
+        }
+      };
+      tx.oncomplete = () => resolve(jobs);
+      tx.onerror = () => reject(tx.error);
+      request.onerror = () => reject(request.error);
+    });
+  }
+  async getAllJobsWithFilter(prefixFilter) {
+    const db = await this.getDb();
+    const tx = db.transaction(this.tableName, "readonly");
+    const store = tx.objectStore(this.tableName);
+    return new Promise((resolve, reject) => {
+      const jobs = [];
+      const request = store.openCursor();
+      request.onsuccess = (event) => {
+        const cursor = event.target.result;
+        if (cursor) {
+          const job = cursor.value;
+          if (job.queue !== this.queueName) {
+            cursor.continue();
+            return;
+          }
+          if (Object.keys(prefixFilter).length === 0) {
+            jobs.push(job);
+          } else {
+            let matches = true;
+            for (const [key, value] of Object.entries(prefixFilter)) {
+              if (job[key] !== value) {
+                matches = false;
+                break;
+              }
+            }
+            if (matches) {
+              jobs.push(job);
+            }
+          }
+          cursor.continue();
+        }
+      };
+      tx.oncomplete = () => resolve(jobs);
+      tx.onerror = () => reject(tx.error);
+      request.onerror = () => reject(request.error);
+    });
+  }
+  isCustomPrefixFilter(prefixFilter) {
+    if (prefixFilter === undefined) {
+      return false;
+    }
+    if (Object.keys(prefixFilter).length === 0) {
+      return true;
+    }
+    const instanceKeys = Object.keys(this.prefixValues);
+    const filterKeys = Object.keys(prefixFilter);
+    if (instanceKeys.length !== filterKeys.length) {
+      return true;
+    }
+    for (const key of instanceKeys) {
+      if (this.prefixValues[key] !== prefixFilter[key]) {
+        return true;
+      }
+    }
+    return false;
+  }
+  getPollingManager() {
+    if (!this.pollingManager) {
+      this.pollingManager = new PollingSubscriptionManager(async () => {
+        const jobs = await this.getAllJobs();
+        return new Map(jobs.map((j) => [j.id, j]));
+      }, (a, b) => JSON.stringify(a) === JSON.stringify(b), {
+        insert: (item) => ({ type: "INSERT", new: item }),
+        update: (oldItem, newItem) => ({ type: "UPDATE", old: oldItem, new: newItem }),
+        delete: (item) => ({ type: "DELETE", old: item })
+      });
+    }
+    return this.pollingManager;
+  }
+  subscribeWithCustomPrefixFilter(callback, prefixFilter, intervalMs) {
+    let lastKnownJobs = new Map;
+    let cancelled = false;
+    const poll = async () => {
+      if (cancelled)
+        return;
+      try {
+        const currentJobs = await this.getAllJobsWithFilter(prefixFilter);
+        if (cancelled)
+          return;
+        const currentMap = new Map(currentJobs.map((j) => [j.id, j]));
+        for (const [id, job] of currentMap) {
+          const old = lastKnownJobs.get(id);
+          if (!old) {
+            callback({ type: "INSERT", new: job });
+          } else if (JSON.stringify(old) !== JSON.stringify(job)) {
+            callback({ type: "UPDATE", old, new: job });
+          }
+        }
+        for (const [id, job] of lastKnownJobs) {
+          if (!currentMap.has(id)) {
+            callback({ type: "DELETE", old: job });
+          }
+        }
+        lastKnownJobs = currentMap;
+      } catch {}
+    };
+    const intervalId = setInterval(poll, intervalMs);
+    poll();
+    return () => {
+      cancelled = true;
+      clearInterval(intervalId);
+    };
+  }
+  subscribeToChanges(callback, options) {
+    const intervalMs = options?.pollingIntervalMs ?? 1000;
+    if (this.isCustomPrefixFilter(options?.prefixFilter)) {
+      return this.subscribeWithCustomPrefixFilter(callback, options.prefixFilter, intervalMs);
+    }
+    const manager = this.getPollingManager();
+    return manager.subscribe(callback, { intervalMs });
+  }
+}
+// src/limiter/IndexedDbRateLimiterStorage.ts
+import { createServiceToken as createServiceToken28 } from "@workglow/util";
+var INDEXED_DB_RATE_LIMITER_STORAGE = createServiceToken28("ratelimiter.storage.indexedDb");
+
+class IndexedDbRateLimiterStorage {
+  executionDb;
+  nextAvailableDb;
+  executionTableName;
+  nextAvailableTableName;
+  migrationOptions;
+  prefixes;
+  prefixValues;
+  constructor(options = {}) {
+    this.migrationOptions = options;
+    this.prefixes = options.prefixes ?? [];
+    this.prefixValues = options.prefixValues ?? {};
+    if (this.prefixes.length > 0) {
+      const prefixNames = this.prefixes.map((p) => p.name).join("_");
+      this.executionTableName = `rate_limit_executions_${prefixNames}`;
+      this.nextAvailableTableName = `rate_limit_next_available_${prefixNames}`;
+    } else {
+      this.executionTableName = "rate_limit_executions";
+      this.nextAvailableTableName = "rate_limit_next_available";
+    }
+  }
+  getPrefixColumnNames() {
+    return this.prefixes.map((p) => p.name);
+  }
+  matchesPrefixes(record) {
+    for (const [key, value] of Object.entries(this.prefixValues)) {
+      if (record[key] !== value) {
+        return false;
+      }
+    }
+    return true;
+  }
+  getPrefixKeyValues() {
+    return this.prefixes.map((p) => this.prefixValues[p.name]);
+  }
+  async getExecutionDb() {
+    if (this.executionDb)
+      return this.executionDb;
+    await this.setupDatabase();
+    return this.executionDb;
+  }
+  async getNextAvailableDb() {
+    if (this.nextAvailableDb)
+      return this.nextAvailableDb;
+    await this.setupDatabase();
+    return this.nextAvailableDb;
+  }
+  async setupDatabase() {
+    const prefixColumnNames = this.getPrefixColumnNames();
+    const buildKeyPath = (basePath) => {
+      return [...prefixColumnNames, ...basePath];
+    };
+    const executionIndexes = [
+      {
+        name: "queue_executed_at",
+        keyPath: buildKeyPath(["queue_name", "executed_at"]),
+        options: { unique: false }
+      }
+    ];
+    this.executionDb = await ensureIndexedDbTable(this.executionTableName, "id", executionIndexes, this.migrationOptions);
+    const nextAvailableIndexes = [
+      {
+        name: "queue_name",
+        keyPath: buildKeyPath(["queue_name"]),
+        options: { unique: true }
+      }
+    ];
+    this.nextAvailableDb = await ensureIndexedDbTable(this.nextAvailableTableName, buildKeyPath(["queue_name"]).join("_"), nextAvailableIndexes, this.migrationOptions);
+  }
+  async recordExecution(queueName) {
+    const db = await this.getExecutionDb();
+    const tx = db.transaction(this.executionTableName, "readwrite");
+    const store = tx.objectStore(this.executionTableName);
+    const record = {
+      id: crypto.randomUUID(),
+      queue_name: queueName,
+      executed_at: new Date().toISOString()
+    };
+    for (const [key, value] of Object.entries(this.prefixValues)) {
+      record[key] = value;
+    }
+    return new Promise((resolve, reject) => {
+      const request = store.add(record);
+      tx.oncomplete = () => resolve();
+      tx.onerror = () => reject(tx.error);
+      request.onerror = () => reject(request.error);
+    });
+  }
+  async getExecutionCount(queueName, windowStartTime) {
+    const db = await this.getExecutionDb();
+    const tx = db.transaction(this.executionTableName, "readonly");
+    const store = tx.objectStore(this.executionTableName);
+    const index = store.index("queue_executed_at");
+    const prefixKeyValues = this.getPrefixKeyValues();
+    return new Promise((resolve, reject) => {
+      let count = 0;
+      const keyRange = IDBKeyRange.bound([...prefixKeyValues, queueName, windowStartTime], [...prefixKeyValues, queueName, "￿"], true, false);
+      const request = index.openCursor(keyRange);
+      request.onsuccess = (event) => {
+        const cursor = event.target.result;
+        if (cursor) {
+          const record = cursor.value;
+          if (this.matchesPrefixes(record)) {
+            count++;
+          }
+          cursor.continue();
+        }
+      };
+      tx.oncomplete = () => resolve(count);
+      tx.onerror = () => reject(tx.error);
+      request.onerror = () => reject(request.error);
+    });
+  }
+  async getOldestExecutionAtOffset(queueName, offset) {
+    const db = await this.getExecutionDb();
+    const tx = db.transaction(this.executionTableName, "readonly");
+    const store = tx.objectStore(this.executionTableName);
+    const index = store.index("queue_executed_at");
+    const prefixKeyValues = this.getPrefixKeyValues();
+    return new Promise((resolve, reject) => {
+      const executions = [];
+      const keyRange = IDBKeyRange.bound([...prefixKeyValues, queueName, ""], [...prefixKeyValues, queueName, "￿"]);
+      const request = index.openCursor(keyRange);
+      request.onsuccess = (event) => {
+        const cursor = event.target.result;
+        if (cursor) {
+          const record = cursor.value;
+          if (this.matchesPrefixes(record)) {
+            executions.push(record.executed_at);
+          }
+          cursor.continue();
+        }
+      };
+      tx.oncomplete = () => {
+        executions.sort();
+        resolve(executions[offset]);
+      };
+      tx.onerror = () => reject(tx.error);
+      request.onerror = () => reject(request.error);
+    });
+  }
+  async getNextAvailableTime(queueName) {
+    const db = await this.getNextAvailableDb();
+    const tx = db.transaction(this.nextAvailableTableName, "readonly");
+    const store = tx.objectStore(this.nextAvailableTableName);
+    const prefixKeyValues = this.getPrefixKeyValues();
+    const key = [...prefixKeyValues, queueName].join("_");
+    return new Promise((resolve, reject) => {
+      const request = store.get(key);
+      request.onsuccess = () => {
+        const record = request.result;
+        if (record && this.matchesPrefixes(record)) {
+          resolve(record.next_available_at);
+        } else {
+          resolve(undefined);
+        }
+      };
+      request.onerror = () => reject(request.error);
+      tx.onerror = () => reject(tx.error);
+    });
+  }
+  async setNextAvailableTime(queueName, nextAvailableAt) {
+    const db = await this.getNextAvailableDb();
+    const tx = db.transaction(this.nextAvailableTableName, "readwrite");
+    const store = tx.objectStore(this.nextAvailableTableName);
+    const prefixKeyValues = this.getPrefixKeyValues();
+    const key = [...prefixKeyValues, queueName].join("_");
+    const record = {
+      queue_name: queueName,
+      next_available_at: nextAvailableAt
+    };
+    for (const [k, value] of Object.entries(this.prefixValues)) {
+      record[k] = value;
+    }
+    record[this.getPrefixColumnNames().concat(["queue_name"]).join("_")] = key;
+    return new Promise((resolve, reject) => {
+      const request = store.put(record);
+      tx.oncomplete = () => resolve();
+      tx.onerror = () => reject(tx.error);
+      request.onerror = () => reject(request.error);
+    });
+  }
+  async clear(queueName) {
+    const execDb = await this.getExecutionDb();
+    const execTx = execDb.transaction(this.executionTableName, "readwrite");
+    const execStore = execTx.objectStore(this.executionTableName);
+    const execIndex = execStore.index("queue_executed_at");
+    const prefixKeyValues = this.getPrefixKeyValues();
+    await new Promise((resolve, reject) => {
+      const keyRange = IDBKeyRange.bound([...prefixKeyValues, queueName, ""], [...prefixKeyValues, queueName, "￿"]);
+      const request = execIndex.openCursor(keyRange);
+      request.onsuccess = (event) => {
+        const cursor = event.target.result;
+        if (cursor) {
+          const record = cursor.value;
+          if (this.matchesPrefixes(record)) {
+            cursor.delete();
+          }
+          cursor.continue();
+        }
+      };
+      execTx.oncomplete = () => resolve();
+      execTx.onerror = () => reject(execTx.error);
+      request.onerror = () => reject(request.error);
+    });
+    const nextDb = await this.getNextAvailableDb();
+    const nextTx = nextDb.transaction(this.nextAvailableTableName, "readwrite");
+    const nextStore = nextTx.objectStore(this.nextAvailableTableName);
+    const key = [...prefixKeyValues, queueName].join("_");
+    await new Promise((resolve, reject) => {
+      const request = nextStore.delete(key);
+      nextTx.oncomplete = () => resolve();
+      nextTx.onerror = () => reject(nextTx.error);
+      request.onerror = () => reject(request.error);
+    });
+  }
 }
 export {
   ensureIndexedDbTable,
@@ -3830,22 +5684,29 @@ export {
   TabularRepository,
   TABULAR_REPOSITORY,
   SupabaseTabularRepository,
+  SupabaseRateLimiterStorage,
   SupabaseQueueStorage,
   SupabaseKvRepository,
   SqliteTabularRepository,
+  SqliteRateLimiterStorage,
   SqliteQueueStorage,
   SqliteKvRepository,
   SUPABASE_TABULAR_REPOSITORY,
+  SUPABASE_RATE_LIMITER_STORAGE,
   SUPABASE_QUEUE_STORAGE,
   SUPABASE_KV_REPOSITORY,
   SQLITE_TABULAR_REPOSITORY,
+  SQLITE_RATE_LIMITER_STORAGE,
   SQLITE_QUEUE_STORAGE,
   SQLITE_KV_REPOSITORY,
+  RATE_LIMITER_STORAGE,
   QUEUE_STORAGE,
   PostgresTabularRepository,
+  PostgresRateLimiterStorage,
   PostgresQueueStorage,
   PostgresKvRepository,
   POSTGRES_TABULAR_REPOSITORY,
+  POSTGRES_RATE_LIMITER_STORAGE,
   POSTGRES_QUEUE_STORAGE,
   POSTGRES_KV_REPOSITORY,
   MEMORY_TABULAR_REPOSITORY,
@@ -3855,12 +5716,16 @@ export {
   KV_REPOSITORY,
   JobStatus,
   IndexedDbTabularRepository,
+  IndexedDbRateLimiterStorage,
   IndexedDbQueueStorage,
   IndexedDbKvRepository,
   InMemoryTabularRepository,
+  InMemoryRateLimiterStorage,
   InMemoryQueueStorage,
   InMemoryKvRepository,
+  IN_MEMORY_RATE_LIMITER_STORAGE,
   IN_MEMORY_QUEUE_STORAGE,
+  INDEXED_DB_RATE_LIMITER_STORAGE,
   INDEXED_DB_QUEUE_STORAGE,
   IDB_TABULAR_REPOSITORY,
   IDB_KV_REPOSITORY,
@@ -3876,4 +5741,4 @@ export {
   CACHED_TABULAR_REPOSITORY
 };
 
-//# debugId=C9E5F9D56E81505C64756E2164756E21
+//# debugId=252A6E832532D65264756E2164756E21