@workglow/storage 0.0.57 → 0.0.59

package/dist/browser.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,41 +672,146 @@ 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/tabular/IndexedDbTabularRepository.ts
+// 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/IndexedDbTabularRepository.ts
+import { createServiceToken as createServiceToken10 } from "@workglow/util";
 
 // src/util/IndexedDbTable.ts
 var METADATA_STORE_NAME = "__schema_metadata__";
@@ -1000,7 +1151,7 @@ async function dropIndexedDbTable(tableName) {
 }
 
 // src/tabular/IndexedDbTabularRepository.ts
-var IDB_TABULAR_REPOSITORY = createServiceToken8("storage.tabularRepository.indexedDb");
+var IDB_TABULAR_REPOSITORY = createServiceToken10("storage.tabularRepository.indexedDb");
 
 class IndexedDbTabularRepository extends TabularRepository {
   table;
@@ -1335,8 +1486,8 @@ class IndexedDbTabularRepository extends TabularRepository {
   }
 }
 // src/tabular/SharedInMemoryTabularRepository.ts
-import { createServiceToken as createServiceToken9 } from "@workglow/util";
-var SHARED_IN_MEMORY_TABULAR_REPOSITORY = createServiceToken9("storage.tabularRepository.sharedInMemory");
+import { createServiceToken as createServiceToken11 } from "@workglow/util";
+var SHARED_IN_MEMORY_TABULAR_REPOSITORY = createServiceToken11("storage.tabularRepository.sharedInMemory");
 
 class SharedInMemoryTabularRepository extends TabularRepository {
   channel = null;
@@ -1506,7 +1657,7 @@ class SharedInMemoryTabularRepository extends TabularRepository {
   }
 }
 // src/tabular/SupabaseTabularRepository.ts
-import { createServiceToken as createServiceToken10 } from "@workglow/util";
+import { createServiceToken as createServiceToken12 } from "@workglow/util";
 
 // src/tabular/BaseSqlTabularRepository.ts
 class BaseSqlTabularRepository extends TabularRepository {
@@ -1692,10 +1843,11 @@ class BaseSqlTabularRepository extends TabularRepository {
 }
 
 // src/tabular/SupabaseTabularRepository.ts
-var SUPABASE_TABULAR_REPOSITORY = createServiceToken10("storage.tabularRepository.supabase");
+var SUPABASE_TABULAR_REPOSITORY = createServiceToken12("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;
@@ -2068,10 +2220,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/IndexedDbKvRepository.ts
-import { createServiceToken as createServiceToken11 } from "@workglow/util";
-var IDB_KV_REPOSITORY = createServiceToken11("storage.kvRepository.indexedDb");
+import { createServiceToken as createServiceToken13 } from "@workglow/util";
+var IDB_KV_REPOSITORY = createServiceToken13("storage.kvRepository.indexedDb");
 
 class IndexedDbKvRepository extends KvViaTabularRepository {
   dbName;
@@ -2083,8 +2269,8 @@ class IndexedDbKvRepository extends KvViaTabularRepository {
   }
 }
 // src/kv/SupabaseKvRepository.ts
-import { createServiceToken as createServiceToken12 } from "@workglow/util";
-var SUPABASE_KV_REPOSITORY = createServiceToken12("storage.kvRepository.supabase");
+import { createServiceToken as createServiceToken14 } from "@workglow/util";
+var SUPABASE_KV_REPOSITORY = createServiceToken14("storage.kvRepository.supabase");
 
 class SupabaseKvRepository extends KvViaTabularRepository {
   client;
@@ -2098,18 +2284,160 @@ class SupabaseKvRepository extends KvViaTabularRepository {
   }
 }
 // src/queue/IndexedDbQueueStorage.ts
-import { createServiceToken as createServiceToken13, makeFingerprint as makeFingerprint5, uuid4 as uuid42 } from "@workglow/util";
-var INDEXED_DB_QUEUE_STORAGE = createServiceToken13("jobqueue.storage.indexedDb");
+import { createServiceToken as createServiceToken15, 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/IndexedDbQueueStorage.ts
+var INDEXED_DB_QUEUE_STORAGE = createServiceToken15("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)
@@ -2118,25 +2446,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 }
       }
     ];
@@ -2145,21 +2477,25 @@ class IndexedDbQueueStorage {
   async add(job) {
     const db = await this.getDb();
     const now = new Date().toISOString();
-    job.id = job.id ?? uuid42();
-    job.job_run_id = job.job_run_id ?? uuid42();
-    job.queue = this.queueName;
-    job.fingerprint = await makeFingerprint5(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 ?? uuid42();
+    jobWithPrefixes.job_run_id = jobWithPrefixes.job_run_id ?? uuid42();
+    jobWithPrefixes.queue = this.queueName;
+    jobWithPrefixes.fingerprint = await makeFingerprint5(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);
     });
@@ -2170,7 +2506,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);
     });
@@ -2179,10 +2522,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;
@@ -2190,7 +2534,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;
@@ -2198,14 +2545,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;
@@ -2218,12 +2566,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 = () => {
@@ -2247,11 +2596,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);
@@ -2265,9 +2616,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);
       };
@@ -2287,10 +2647,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);
     });
@@ -2299,11 +2664,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) {
@@ -2311,10 +2696,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);
     });
@@ -2329,6 +2727,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);
@@ -2343,15 +2744,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();
@@ -2362,17 +2765,193 @@ 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/queue/SupabaseQueueStorage.ts
-import { createServiceToken as createServiceToken14, makeFingerprint as makeFingerprint6, uuid4 as uuid43 } from "@workglow/util";
-var SUPABASE_QUEUE_STORAGE = createServiceToken14("jobqueue.storage.supabase");
+import { createServiceToken as createServiceToken16, makeFingerprint as makeFingerprint6, uuid4 as uuid43 } from "@workglow/util";
+var SUPABASE_QUEUE_STORAGE = createServiceToken16("jobqueue.storage.supabase");
 
 class SupabaseQueueStorage {
   client;
   queueName;
-  constructor(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(",")})`;
@@ -2380,10 +2959,14 @@ class SupabaseQueueStorage {
     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 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',
@@ -2400,7 +2983,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) {
@@ -2409,12 +2993,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) {
@@ -2428,7 +3012,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,
@@ -2449,7 +3035,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;
@@ -2459,36 +3047,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: "",
@@ -2496,16 +3101,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,
@@ -2516,12 +3125,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,
@@ -2533,11 +3144,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,
@@ -2546,17 +3159,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 makeFingerprint6(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;
@@ -2565,36 +3184,555 @@ 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/IndexedDbRateLimiterStorage.ts
+import { createServiceToken as createServiceToken17 } from "@workglow/util";
+var INDEXED_DB_RATE_LIMITER_STORAGE = createServiceToken17("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);
+    });
+  }
+}
+// src/limiter/SupabaseRateLimiterStorage.ts
+import { createServiceToken as createServiceToken18 } from "@workglow/util";
+var SUPABASE_RATE_LIMITER_STORAGE = createServiceToken18("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;
+  }
 }
 export {
   ensureIndexedDbTable,
@@ -2602,13 +3740,16 @@ export {
   TabularRepository,
   TABULAR_REPOSITORY,
   SupabaseTabularRepository,
+  SupabaseRateLimiterStorage,
   SupabaseQueueStorage,
   SupabaseKvRepository,
   SharedInMemoryTabularRepository,
   SUPABASE_TABULAR_REPOSITORY,
+  SUPABASE_RATE_LIMITER_STORAGE,
   SUPABASE_QUEUE_STORAGE,
   SUPABASE_KV_REPOSITORY,
   SHARED_IN_MEMORY_TABULAR_REPOSITORY,
+  RATE_LIMITER_STORAGE,
   QUEUE_STORAGE,
   MEMORY_TABULAR_REPOSITORY,
   MEMORY_KV_REPOSITORY,
@@ -2617,12 +3758,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,
@@ -2632,4 +3777,4 @@ export {
   CACHED_TABULAR_REPOSITORY
 };
 
-//# debugId=706648683071DA7B64756E2164756E21
+//# debugId=91B1809D834FE66964756E2164756E21