@workglow/storage 0.2.27 → 0.2.29

package/dist/browser.js

@@ -414,6 +414,205 @@ class BaseTabularStorage {
     this.destroy();
   }
 }
+// src/tabular/BaseSqlTabularStorage.ts
+class BaseSqlTabularStorage extends BaseTabularStorage {
+  table;
+  _pkColsCache = new Map;
+  _valColsCache = new Map;
+  _pkColListCache = new Map;
+  _valColListCache = new Map;
+  constructor(table = "tabular_store", schema, primaryKeyNames, indexes = [], clientProvidedKeys = "if-missing") {
+    super(schema, primaryKeyNames, indexes, clientProvidedKeys);
+    this.table = table;
+    this.validateTableAndSchema();
+  }
+  constructPrimaryKeyColumns($delimiter = "") {
+    let cached = this._pkColsCache.get($delimiter);
+    if (cached === undefined) {
+      cached = Object.entries(this.primaryKeySchema.properties).map(([key, typeDef]) => {
+        const sqlType = this.mapTypeToSQL(typeDef);
+        return `${$delimiter}${key}${$delimiter} ${sqlType} NOT NULL`;
+      }).join(", ");
+      this._pkColsCache.set($delimiter, cached);
+    }
+    return cached;
+  }
+  constructValueColumns($delimiter = "") {
+    let cached = this._valColsCache.get($delimiter);
+    if (cached === undefined) {
+      const requiredSet = new Set(this.valueSchema.required ?? []);
+      const cols = Object.entries(this.valueSchema.properties).map(([key, typeDef]) => {
+        const sqlType = this.mapTypeToSQL(typeDef);
+        const isRequired = requiredSet.has(key);
+        const nullable = !isRequired || this.isNullable(typeDef);
+        return `${$delimiter}${key}${$delimiter} ${sqlType}${nullable ? " NULL" : " NOT NULL"}`;
+      }).join(", ");
+      cached = cols.length > 0 ? `, ${cols}` : "";
+      this._valColsCache.set($delimiter, cached);
+    }
+    return cached;
+  }
+  isNullable(typeDef) {
+    if (typeof typeDef === "boolean")
+      return typeDef;
+    if (typeDef.type === "null") {
+      return true;
+    }
+    if (Array.isArray(typeDef.type)) {
+      return typeDef.type.includes("null");
+    }
+    if (typeDef.anyOf && Array.isArray(typeDef.anyOf)) {
+      return typeDef.anyOf.some((type) => type.type === "null");
+    }
+    if (typeDef.oneOf && Array.isArray(typeDef.oneOf)) {
+      return typeDef.oneOf.some((type) => type.type === "null");
+    }
+    return false;
+  }
+  primaryKeyColumnList($delimiter = "") {
+    let cached = this._pkColListCache.get($delimiter);
+    if (cached === undefined) {
+      cached = $delimiter + this.primaryKeyColumns().join(`${$delimiter}, ${$delimiter}`) + $delimiter;
+      this._pkColListCache.set($delimiter, cached);
+    }
+    return cached;
+  }
+  valueColumnList($delimiter = "") {
+    let cached = this._valColListCache.get($delimiter);
+    if (cached === undefined) {
+      cached = $delimiter + this.valueColumns().join(`${$delimiter}, ${$delimiter}`) + $delimiter;
+      this._valColListCache.set($delimiter, cached);
+    }
+    return cached;
+  }
+  getNonNullType(typeDef) {
+    if (typeof typeDef === "boolean")
+      return typeDef;
+    if (typeDef.anyOf && Array.isArray(typeDef.anyOf)) {
+      const nonNullType = typeDef.anyOf.find((t) => t.type !== "null");
+      if (nonNullType) {
+        return nonNullType;
+      }
+    }
+    if (typeDef.oneOf && Array.isArray(typeDef.oneOf)) {
+      const nonNullType = typeDef.oneOf.find((t) => t.type !== "null");
+      if (nonNullType) {
+        return nonNullType;
+      }
+    }
+    return typeDef;
+  }
+  getValueAsOrderedArray(value) {
+    const orderedParams = [];
+    const valueAsRecord = value;
+    const requiredSet = new Set(this.valueSchema.required ?? []);
+    for (const key in this.valueSchema.properties) {
+      if (Object.prototype.hasOwnProperty.call(valueAsRecord, key)) {
+        const val = valueAsRecord[key];
+        if (val === undefined && !requiredSet.has(key)) {
+          orderedParams.push(null);
+        } else {
+          orderedParams.push(this.jsToSqlValue(key, val));
+        }
+      } else {
+        if (requiredSet.has(key)) {
+          throw new Error(`Missing required value field: ${key}`);
+        }
+        orderedParams.push(null);
+      }
+    }
+    return orderedParams;
+  }
+  getPrimaryKeyAsOrderedArray(key) {
+    const orderedParams = [];
+    const keyObj = key;
+    for (const k of Object.keys(this.primaryKeySchema.properties)) {
+      if (k in keyObj) {
+        const value = keyObj[k];
+        if (value === null) {
+          throw new Error(`Primary key field ${k} cannot be null`);
+        }
+        orderedParams.push(this.jsToSqlValue(k, value));
+      } else {
+        throw new Error(`Missing required primary key field: ${k}`);
+      }
+    }
+    return orderedParams;
+  }
+  jsToSqlValue(column, value) {
+    const typeDef = this.schema.properties[column];
+    if (!typeDef) {
+      return value;
+    }
+    if (value === null && this.isNullable(typeDef)) {
+      return null;
+    }
+    const actualType = this.getNonNullType(typeDef);
+    if (typeof actualType === "boolean") {
+      return value;
+    }
+    if (actualType.contentEncoding === "blob") {
+      if (value instanceof Uint8Array) {
+        return value;
+      }
+      if (typeof Buffer !== "undefined" && value instanceof Buffer) {
+        return new Uint8Array(value);
+      }
+      if (Array.isArray(value)) {
+        return new Uint8Array(value);
+      }
+      return value;
+    } else if (value instanceof Date) {
+      return value.toISOString();
+    } else {
+      return value;
+    }
+  }
+  sqlToJsValue(column, value) {
+    const typeDef = this.schema.properties[column];
+    if (!typeDef) {
+      return value;
+    }
+    if (value === null && this.isNullable(typeDef)) {
+      return null;
+    }
+    const actualType = this.getNonNullType(typeDef);
+    if (typeof actualType === "boolean") {
+      return value;
+    }
+    if (actualType.contentEncoding === "blob") {
+      if (typeof Buffer !== "undefined" && value instanceof Buffer) {
+        return new Uint8Array(value);
+      }
+      if (value instanceof Uint8Array) {
+        return value;
+      }
+      return value;
+    } else {
+      return value;
+    }
+  }
+  validateTableAndSchema() {
+    if (!/^[a-zA-Z][a-zA-Z0-9_]*$/.test(this.table)) {
+      throw new Error("Table name must start with a letter and contain only letters, digits, and underscores, got: " + this.table);
+    }
+    const validateSchemaKeys = (schema) => {
+      for (const key in schema.properties) {
+        if (!/^[a-zA-Z][a-zA-Z0-9_]*$/.test(key)) {
+          throw new Error("Schema keys must start with a letter and contain only letters, digits, and underscores, got: " + key);
+        }
+      }
+    };
+    validateSchemaKeys(this.primaryKeySchema);
+    validateSchemaKeys(this.valueSchema);
+    const primaryKeys = new Set(Object.keys(this.primaryKeySchema.properties));
+    const valueKeys = Object.keys(this.valueSchema.properties);
+    const duplicates = valueKeys.filter((key) => primaryKeys.has(key));
+    if (duplicates.length > 0) {
+      throw new Error(`Duplicate keys found in schemas: ${duplicates.join(", ")}`);
+    }
+  }
+}
 // src/tabular/CachedTabularStorage.ts
 import { createServiceToken as createServiceToken3, getLogger } from "@workglow/util";
 
@@ -1272,28 +1471,9 @@ registerInputCompactor("storage:tabular", (value, _format, registry) => {
   }
   return;
 });
-// src/util/traced.ts
-import { getTelemetryProvider, SpanStatusCode } from "@workglow/util";
-async function traced(spanName, storageName, fn) {
-  const telemetry = getTelemetryProvider();
-  if (!telemetry.isEnabled)
-    return fn();
-  const span = telemetry.startSpan(spanName, {
-    attributes: { "workglow.storage.name": storageName }
-  });
-  try {
-    const result = await fn();
-    span.setStatus(SpanStatusCode.OK);
-    return result;
-  } catch (err) {
-    span.setStatus(SpanStatusCode.ERROR, err instanceof Error ? err.message : String(err));
-    throw err;
-  } finally {
-    span.end();
-  }
-}
-
 // src/tabular/TelemetryTabularStorage.ts
+import { traced } from "@workglow/util";
+
 class TelemetryTabularStorage {
   storageName;
   inner;
@@ -1500,6 +1680,8 @@ class InMemoryKvStorage extends KvViaTabularStorage {
   }
 }
 // src/kv/TelemetryKvStorage.ts
+import { traced as traced2 } from "@workglow/util";
+
 class TelemetryKvStorage {
   storageName;
   inner;
@@ -1508,25 +1690,25 @@ class TelemetryKvStorage {
     this.inner = inner;
   }
   put(key, value) {
-    return traced("workglow.storage.kv.put", this.storageName, () => this.inner.put(key, value));
+    return traced2("workglow.storage.kv.put", this.storageName, () => this.inner.put(key, value));
   }
   putBulk(items) {
-    return traced("workglow.storage.kv.putBulk", this.storageName, () => this.inner.putBulk(items));
+    return traced2("workglow.storage.kv.putBulk", this.storageName, () => this.inner.putBulk(items));
   }
   get(key) {
-    return traced("workglow.storage.kv.get", this.storageName, () => this.inner.get(key));
+    return traced2("workglow.storage.kv.get", this.storageName, () => this.inner.get(key));
   }
   delete(key) {
-    return traced("workglow.storage.kv.delete", this.storageName, () => this.inner.delete(key));
+    return traced2("workglow.storage.kv.delete", this.storageName, () => this.inner.delete(key));
   }
   getAll() {
-    return traced("workglow.storage.kv.getAll", this.storageName, () => this.inner.getAll());
+    return traced2("workglow.storage.kv.getAll", this.storageName, () => this.inner.getAll());
   }
   deleteAll() {
-    return traced("workglow.storage.kv.deleteAll", this.storageName, () => this.inner.deleteAll());
+    return traced2("workglow.storage.kv.deleteAll", this.storageName, () => this.inner.deleteAll());
   }
   size() {
-    return traced("workglow.storage.kv.size", this.storageName, () => this.inner.size());
+    return traced2("workglow.storage.kv.size", this.storageName, () => this.inner.size());
   }
   getObjectAsIdString(object) {
     return this.inner.getObjectAsIdString(object);
@@ -1547,456 +1729,47 @@ class TelemetryKvStorage {
     return this.inner.waitOn(name);
   }
 }
-// src/queue/InMemoryQueueStorage.ts
-import {
-  createServiceToken as createServiceToken9,
-  EventEmitter as EventEmitter3,
-  getLogger as getLogger2,
-  makeFingerprint as makeFingerprint4,
-  sleep,
-  uuid4 as uuid42
-} from "@workglow/util";
-
-// src/queue/IQueueStorage.ts
-import { createServiceToken as createServiceToken8 } from "@workglow/util";
-var QUEUE_STORAGE = createServiceToken8("jobqueue.storage");
-var JobStatus = {
-  PENDING: "PENDING",
-  PROCESSING: "PROCESSING",
-  COMPLETED: "COMPLETED",
-  ABORTING: "ABORTING",
-  FAILED: "FAILED",
-  DISABLED: "DISABLED"
-};
-
-// src/queue/InMemoryQueueStorage.ts
-var IN_MEMORY_QUEUE_STORAGE = createServiceToken9("jobqueue.storage.inMemory");
-
-class InMemoryQueueStorage {
-  queueName;
-  scope = "process";
-  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;
-      }
+// src/util/HybridSubscriptionManager.ts
+class HybridSubscriptionManager {
+  subscribers = new Set;
+  lastKnownState = new Map;
+  initialized = false;
+  channel = null;
+  backupPollingIntervalId = null;
+  fetchState;
+  compareItems;
+  payloadFactory;
+  options;
+  hasBroadcastChannel;
+  constructor(channelName, fetchState, compareItems, payloadFactory, options) {
+    this.fetchState = fetchState;
+    this.compareItems = compareItems;
+    this.payloadFactory = payloadFactory;
+    this.options = {
+      defaultIntervalMs: options?.defaultIntervalMs ?? 1000,
+      backupPollingIntervalMs: options?.backupPollingIntervalMs ?? 5000,
+      useBroadcastChannel: options?.useBroadcastChannel ?? true,
+      broadcastChannelName: options?.broadcastChannelName ?? channelName
+    };
+    this.hasBroadcastChannel = this.options.useBroadcastChannel && typeof BroadcastChannel !== "undefined";
+    if (this.hasBroadcastChannel) {
+      this.initializeBroadcastChannel();
     }
-    return true;
   }
-  pendingQueue() {
-    const now = new Date().toISOString();
-    return this.jobQueue.filter((job) => this.matchesPrefixes(job)).filter((job) => job.status === JobStatus.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();
-    const jobWithPrefixes = job;
-    jobWithPrefixes.id = jobWithPrefixes.id ?? uuid42();
-    jobWithPrefixes.job_run_id = jobWithPrefixes.job_run_id ?? uuid42();
-    jobWithPrefixes.queue = this.queueName;
-    jobWithPrefixes.fingerprint = await makeFingerprint4(jobWithPrefixes.input);
-    jobWithPrefixes.status = JobStatus.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);
-    const job = this.jobQueue.find((j) => j.id === id);
-    if (job && this.matchesPrefixes(job)) {
-      return job;
+  initializeBroadcastChannel() {
+    try {
+      this.channel = new BroadcastChannel(this.options.broadcastChannelName);
+      this.channel.onmessage = (event) => {
+        this.handleBroadcastMessage(event.data);
+      };
+    } catch (error) {
+      console.error("Failed to initialize BroadcastChannel:", error);
+      this.channel = null;
     }
-    return;
   }
-  async peek(status = JobStatus.PENDING, num = 100) {
-    await sleep(0);
-    num = Number(num) || 100;
-    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(workerId) {
-    await sleep(0);
-    const top = this.pendingQueue();
-    const job = top[0];
-    if (job) {
-      const oldJob = { ...job };
-      job.status = JobStatus.PROCESSING;
-      job.last_ran_at = new Date().toISOString();
-      job.worker_id = workerId;
-      this.events.emit("change", { type: "UPDATE", old: oldJob, new: job });
-      return job;
-    }
-  }
-  async size(status = JobStatus.PENDING) {
-    await sleep(0);
-    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 && this.matchesPrefixes(j));
-    if (!job) {
-      const jobWithAnyPrefix = this.jobQueue.find((j) => j.id === id);
-      getLogger2().warn("Job not found for progress update", {
-        id,
-        reason: jobWithAnyPrefix ? "prefix_mismatch" : "missing",
-        existingStatus: jobWithAnyPrefix?.status,
-        queueName: this.queueName,
-        prefixValues: this.prefixValues
-      });
-      return;
-    }
-    if (job.status === JobStatus.COMPLETED || job.status === JobStatus.FAILED) {
-      getLogger2().warn("Job already completed or failed for progress update", {
-        id,
-        status: job.status,
-        completedAt: job.completed_at,
-        error: job.error
-      });
-      return;
-    }
-    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);
-    const jobWithPrefixes = job;
-    const index = this.jobQueue.findIndex((j) => j.id === job.id && this.matchesPrefixes(j));
-    if (index !== -1) {
-      const existing = this.jobQueue[index];
-      const currentAttempts = existing?.run_attempts ?? 0;
-      jobWithPrefixes.run_attempts = currentAttempts + 1;
-      for (const [key, value] of Object.entries(this.prefixValues)) {
-        jobWithPrefixes[key] = value;
-      }
-      this.jobQueue[index] = jobWithPrefixes;
-      this.events.emit("change", { type: "UPDATE", old: existing, new: jobWithPrefixes });
-    }
-  }
-  async release(id) {
-    await sleep(0);
-    const job = this.jobQueue.find((j) => j.id === id && this.matchesPrefixes(j));
-    if (job) {
-      const oldJob = { ...job };
-      job.status = JobStatus.PENDING;
-      job.worker_id = null;
-      job.progress = 0;
-      job.progress_message = "";
-      job.progress_details = null;
-      this.events.emit("change", { type: "UPDATE", old: oldJob, new: job });
-    }
-  }
-  async abort(id) {
-    await sleep(0);
-    const job = this.jobQueue.find((j) => j.id === id && this.matchesPrefixes(j));
-    if (job) {
-      const oldJob = { ...job };
-      job.status = JobStatus.ABORTING;
-      this.events.emit("change", { type: "UPDATE", old: oldJob, new: job });
-    }
-  }
-  async getByRunId(runId) {
-    await sleep(0);
-    return this.jobQueue.filter((job) => this.matchesPrefixes(job) && job.job_run_id === runId);
-  }
-  async deleteAll() {
-    await sleep(0);
-    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) => this.matchesPrefixes(j) && j.fingerprint === fingerprint && j.status === JobStatus.COMPLETED)?.output ?? null;
-  }
-  async delete(id) {
-    await sleep(0);
-    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();
-    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/queue/TelemetryQueueStorage.ts
-class TelemetryQueueStorage {
-  storageName;
-  inner;
-  constructor(storageName, inner) {
-    this.storageName = storageName;
-    this.inner = inner;
-  }
-  get scope() {
-    return this.inner.scope;
-  }
-  add(job) {
-    return traced("workglow.storage.queue.add", this.storageName, () => this.inner.add(job));
-  }
-  get(id) {
-    return traced("workglow.storage.queue.get", this.storageName, () => this.inner.get(id));
-  }
-  next(workerId) {
-    return traced("workglow.storage.queue.next", this.storageName, () => this.inner.next(workerId));
-  }
-  peek(status, num) {
-    return traced("workglow.storage.queue.peek", this.storageName, () => this.inner.peek(status, num));
-  }
-  size(status) {
-    return traced("workglow.storage.queue.size", this.storageName, () => this.inner.size(status));
-  }
-  complete(job) {
-    return traced("workglow.storage.queue.complete", this.storageName, () => this.inner.complete(job));
-  }
-  release(id) {
-    return traced("workglow.storage.queue.release", this.storageName, () => this.inner.release(id));
-  }
-  deleteAll() {
-    return traced("workglow.storage.queue.deleteAll", this.storageName, () => this.inner.deleteAll());
-  }
-  outputForInput(input) {
-    return traced("workglow.storage.queue.outputForInput", this.storageName, () => this.inner.outputForInput(input));
-  }
-  abort(id) {
-    return traced("workglow.storage.queue.abort", this.storageName, () => this.inner.abort(id));
-  }
-  getByRunId(runId) {
-    return traced("workglow.storage.queue.getByRunId", this.storageName, () => this.inner.getByRunId(runId));
-  }
-  saveProgress(id, progress, message, details) {
-    return traced("workglow.storage.queue.saveProgress", this.storageName, () => this.inner.saveProgress(id, progress, message, details));
-  }
-  delete(id) {
-    return traced("workglow.storage.queue.delete", this.storageName, () => this.inner.delete(id));
-  }
-  deleteJobsByStatusAndAge(status, olderThanMs) {
-    return traced("workglow.storage.queue.deleteJobsByStatusAndAge", this.storageName, () => this.inner.deleteJobsByStatusAndAge(status, olderThanMs));
-  }
-  setupDatabase() {
-    return this.inner.setupDatabase();
-  }
-  subscribeToChanges(callback, options) {
-    return this.inner.subscribeToChanges(callback, options);
-  }
-}
-// src/queue-limiter/InMemoryRateLimiterStorage.ts
-import { createServiceToken as createServiceToken10, sleep as sleep2, uuid4 as uuid43 } from "@workglow/util";
-var IN_MEMORY_RATE_LIMITER_STORAGE = createServiceToken10("ratelimiter.storage.inMemory");
-
-class InMemoryRateLimiterStorage {
-  scope = "process";
-  prefixValues;
-  executions = new Map;
-  nextAvailableTimes = new Map;
-  reserveChains = new Map;
-  constructor(options) {
-    this.prefixValues = options?.prefixValues ?? {};
-  }
-  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 withKeyLock(key, fn) {
-    const previous = this.reserveChains.get(key) ?? Promise.resolve();
-    let release;
-    const next = new Promise((resolve) => {
-      release = resolve;
-    });
-    this.reserveChains.set(key, next);
-    try {
-      await previous;
-      return await fn();
-    } finally {
-      release(undefined);
-      if (this.reserveChains.get(key) === next) {
-        this.reserveChains.delete(key);
-      }
-    }
-  }
-  async tryReserveExecution(queueName, maxExecutions, windowMs) {
-    const key = this.makeKey(queueName);
-    return this.withKeyLock(key, () => {
-      const now = Date.now();
-      const windowStart = new Date(now - windowMs);
-      const executions = this.executions.get(key) ?? [];
-      const live = executions.filter((e) => e.executedAt > windowStart);
-      if (live.length >= maxExecutions) {
-        if (live.length !== executions.length) {
-          this.executions.set(key, live);
-        }
-        return null;
-      }
-      const next = this.nextAvailableTimes.get(key);
-      if (next && next.getTime() > now) {
-        return null;
-      }
-      const id = uuid43();
-      live.push({ id, queueName, executedAt: new Date(now) });
-      this.executions.set(key, live);
-      return id;
-    });
-  }
-  async releaseExecution(queueName, token) {
-    if (token === null || token === undefined)
-      return;
-    const key = this.makeKey(queueName);
-    await this.withKeyLock(key, () => {
-      const executions = this.executions.get(key);
-      if (!executions || executions.length === 0)
-        return;
-      const idx = executions.findIndex((e) => e.id === token);
-      if (idx === -1)
-        return;
-      executions.splice(idx, 1);
-      this.executions.set(key, executions);
-    });
-  }
-  async recordExecution(queueName) {
-    await sleep2(0);
-    const key = this.makeKey(queueName);
-    const executions = this.executions.get(key) ?? [];
-    executions.push({
-      id: uuid43(),
-      queueName,
-      executedAt: new Date
-    });
-    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/queue-limiter/IRateLimiterStorage.ts
-import { createServiceToken as createServiceToken11 } from "@workglow/util";
-var RATE_LIMITER_STORAGE = createServiceToken11("ratelimiter.storage");
-// src/util/HybridSubscriptionManager.ts
-class HybridSubscriptionManager {
-  subscribers = new Set;
-  lastKnownState = new Map;
-  initialized = false;
-  channel = null;
-  backupPollingIntervalId = null;
-  fetchState;
-  compareItems;
-  payloadFactory;
-  options;
-  hasBroadcastChannel;
-  constructor(channelName, fetchState, compareItems, payloadFactory, options) {
-    this.fetchState = fetchState;
-    this.compareItems = compareItems;
-    this.payloadFactory = payloadFactory;
-    this.options = {
-      defaultIntervalMs: options?.defaultIntervalMs ?? 1000,
-      backupPollingIntervalMs: options?.backupPollingIntervalMs ?? 5000,
-      useBroadcastChannel: options?.useBroadcastChannel ?? true,
-      broadcastChannelName: options?.broadcastChannelName ?? channelName
-    };
-    this.hasBroadcastChannel = this.options.useBroadcastChannel && typeof BroadcastChannel !== "undefined";
-    if (this.hasBroadcastChannel) {
-      this.initializeBroadcastChannel();
-    }
-  }
-  initializeBroadcastChannel() {
-    try {
-      this.channel = new BroadcastChannel(this.options.broadcastChannelName);
-      this.channel.onmessage = (event) => {
-        this.handleBroadcastMessage(event.data);
-      };
-    } catch (error) {
-      console.error("Failed to initialize BroadcastChannel:", error);
-      this.channel = null;
-    }
-  }
-  async handleBroadcastMessage(message) {
-    if (message.type === "CHANGE") {
-      await this.pollAndNotify();
+  async handleBroadcastMessage(message) {
+    if (message.type === "CHANGE") {
+      await this.pollAndNotify();
     }
   }
   notifyLocalChange() {
@@ -2353,6 +2126,8 @@ class InMemoryVectorStorage extends InMemoryTabularStorage {
   }
 }
 // src/vector/TelemetryVectorStorage.ts
+import { traced as traced3 } from "@workglow/util";
+
 class TelemetryVectorStorage extends TelemetryTabularStorage {
   vectorInner;
   constructor(storageName, inner) {
@@ -2363,13 +2138,13 @@ class TelemetryVectorStorage extends TelemetryTabularStorage {
     return this.vectorInner.getVectorDimensions();
   }
   similaritySearch(query, options) {
-    return traced("workglow.storage.vector.similaritySearch", this.storageName, () => this.vectorInner.similaritySearch(query, options));
+    return traced3("workglow.storage.vector.similaritySearch", this.storageName, () => this.vectorInner.similaritySearch(query, options));
   }
   hybridSearch(query, options) {
     if (!this.vectorInner.hybridSearch) {
       throw new Error("hybridSearch is not supported by the underlying storage implementation");
     }
-    return traced("workglow.storage.vector.hybridSearch", this.storageName, () => this.vectorInner.hybridSearch(query, options));
+    return traced3("workglow.storage.vector.hybridSearch", this.storageName, () => this.vectorInner.hybridSearch(query, options));
   }
 }
 // src/credentials/EncryptedKvCredentialStore.ts
@@ -2495,3750 +2270,201 @@ class LazyEncryptedCredentialStore {
     return this.inner.deleteAll();
   }
 }
-// src/tabular/IndexedDbTabularStorage.ts
-import { createServiceToken as createServiceToken12, deepEqual as deepEqual2, makeFingerprint as makeFingerprint5, uuid4 as uuid44 } from "@workglow/util";
+// src/tabular/SharedInMemoryTabularStorage.ts
+import { createServiceToken as createServiceToken8 } from "@workglow/util";
+var SHARED_IN_MEMORY_TABULAR_REPOSITORY = createServiceToken8("storage.tabularRepository.sharedInMemory");
+var SYNC_TIMEOUT = 1000;
+var MAX_PENDING_MESSAGES = 1000;
 
-// src/util/IndexedDbTable.ts
-import { deepEqual } from "@workglow/util";
-var METADATA_STORE_NAME = "__schema_metadata__";
-async function saveSchemaMetadata(db, tableName, snapshot) {
-  return new Promise((resolve, reject) => {
+class SharedInMemoryTabularStorage extends BaseTabularStorage {
+  channel = null;
+  channelName;
+  inMemoryRepo;
+  isInitialized = false;
+  syncInProgress = false;
+  pendingMessages = [];
+  constructor(channelName = "tabular_store", schema, primaryKeyNames, indexes = [], clientProvidedKeys = "if-missing") {
+    super(schema, primaryKeyNames, indexes, clientProvidedKeys);
+    this.channelName = channelName;
+    this.inMemoryRepo = new InMemoryTabularStorage(schema, primaryKeyNames, indexes, clientProvidedKeys);
+    this.setupEventForwarding();
+    this.initializeBroadcastChannel();
+  }
+  isBroadcastChannelAvailable() {
+    return typeof BroadcastChannel !== "undefined";
+  }
+  initializeBroadcastChannel() {
+    if (!this.isBroadcastChannelAvailable()) {
+      console.warn("BroadcastChannel is not available. Tab synchronization will not work.");
+      return;
+    }
     try {
-      const transaction = db.transaction(METADATA_STORE_NAME, "readwrite");
-      const store = transaction.objectStore(METADATA_STORE_NAME);
-      const request = store.put({ ...snapshot, tableName }, tableName);
-      request.onsuccess = () => resolve();
-      request.onerror = () => reject(request.error);
-      transaction.onerror = () => reject(transaction.error);
-    } catch (err) {
-      resolve();
-    }
-  });
-}
-async function openIndexedDbTable(tableName, version, upgradeNeededCallback) {
-  return new Promise((resolve, reject) => {
-    const openRequest = indexedDB.open(tableName, version);
-    openRequest.onsuccess = (event) => {
-      const db = event.target.result;
-      db.onversionchange = () => {
-        db.close();
+      this.channel = new BroadcastChannel(this.channelName);
+      this.channel.onmessage = (event) => {
+        this.handleBroadcastMessage(event.data);
       };
-      resolve(db);
-    };
-    openRequest.onupgradeneeded = (event) => {
-      if (upgradeNeededCallback) {
-        upgradeNeededCallback(event);
-      }
-    };
-    openRequest.onerror = () => {
-      const error = openRequest.error;
-      if (error && error.name === "VersionError") {
-        reject(new Error(`Database ${tableName} exists at a higher version. Cannot open at version ${version || "current"}.`));
-      } else {
-        reject(error);
-      }
-    };
-    openRequest.onblocked = () => {
-      reject(new Error(`Database ${tableName} is blocked. Close all other tabs using this database.`));
-    };
-  });
-}
-async function deleteIndexedDbTable(tableName) {
-  return new Promise((resolve, reject) => {
-    const deleteRequest = indexedDB.deleteDatabase(tableName);
-    deleteRequest.onsuccess = () => resolve();
-    deleteRequest.onerror = () => reject(deleteRequest.error);
-    deleteRequest.onblocked = () => {
-      reject(new Error(`Cannot delete database ${tableName}. Close all other tabs using this database.`));
-    };
-  });
-}
-function compareSchemas(store, expectedPrimaryKey, expectedIndexes) {
-  const diff = {
-    indexesToAdd: [],
-    indexesToRemove: [],
-    indexesToModify: [],
-    primaryKeyChanged: false,
-    needsObjectStoreRecreation: false
-  };
-  const actualKeyPath = store.keyPath;
-  const normalizedExpected = Array.isArray(expectedPrimaryKey) ? expectedPrimaryKey : expectedPrimaryKey;
-  const normalizedActual = Array.isArray(actualKeyPath) ? actualKeyPath : actualKeyPath;
-  if (!deepEqual(normalizedExpected, normalizedActual)) {
-    diff.primaryKeyChanged = true;
-    diff.needsObjectStoreRecreation = true;
-    return diff;
-  }
-  const existingIndexes = new Map;
-  for (let i = 0;i < store.indexNames.length; i++) {
-    const indexName = store.indexNames[i];
-    existingIndexes.set(indexName, store.index(indexName));
-  }
-  for (const expectedIdx of expectedIndexes) {
-    const existingIdx = existingIndexes.get(expectedIdx.name);
-    if (!existingIdx) {
-      diff.indexesToAdd.push(expectedIdx);
-    } else {
-      const expectedKeyPath = Array.isArray(expectedIdx.keyPath) ? expectedIdx.keyPath : [expectedIdx.keyPath];
-      const actualKeyPath2 = Array.isArray(existingIdx.keyPath) ? existingIdx.keyPath : [existingIdx.keyPath];
-      const keyPathChanged = !deepEqual(expectedKeyPath, actualKeyPath2);
-      const uniqueChanged = existingIdx.unique !== (expectedIdx.options?.unique ?? false);
-      const multiEntryChanged = existingIdx.multiEntry !== (expectedIdx.options?.multiEntry ?? false);
-      if (keyPathChanged || uniqueChanged || multiEntryChanged) {
-        diff.indexesToModify.push(expectedIdx);
-      }
-      existingIndexes.delete(expectedIdx.name);
+      this.syncFromOtherTabs();
+    } catch (error) {
+      console.error("Failed to initialize BroadcastChannel:", error);
     }
   }
-  diff.indexesToRemove = Array.from(existingIndexes.keys());
-  return diff;
-}
-async function readAllData(store) {
-  return new Promise((resolve, reject) => {
-    const request = store.getAll();
-    request.onsuccess = () => resolve(request.result || []);
-    request.onerror = () => reject(request.error);
-  });
-}
-async function performIncrementalMigration(db, tableName, diff, options = {}) {
-  const currentVersion = db.version;
-  const newVersion = currentVersion + 1;
-  db.close();
-  options.onMigrationProgress?.(`Migrating ${tableName} from version ${currentVersion} to ${newVersion}...`, 0);
-  return openIndexedDbTable(tableName, newVersion, (event) => {
-    const transaction = event.target.transaction;
-    const store = transaction.objectStore(tableName);
-    for (const indexName of diff.indexesToRemove) {
-      options.onMigrationProgress?.(`Removing index: ${indexName}`, 0.2);
-      store.deleteIndex(indexName);
-    }
-    for (const indexDef of diff.indexesToModify) {
-      options.onMigrationProgress?.(`Updating index: ${indexDef.name}`, 0.4);
-      if (store.indexNames.contains(indexDef.name)) {
-        store.deleteIndex(indexDef.name);
+  setupEventForwarding() {
+    this.inMemoryRepo.on("put", (entity) => {
+      this.events.emit("put", entity);
+    });
+    this.inMemoryRepo.on("get", (key, entity) => {
+      this.events.emit("get", key, entity);
+    });
+    this.inMemoryRepo.on("query", (key, entities) => {
+      this.events.emit("query", key, entities);
+    });
+    this.inMemoryRepo.on("delete", (key) => {
+      this.events.emit("delete", key);
+    });
+    this.inMemoryRepo.on("clearall", () => {
+      this.events.emit("clearall");
+    });
+  }
+  async handleBroadcastMessage(message) {
+    if (this.syncInProgress && message.type !== "SYNC_RESPONSE") {
+      if (this.pendingMessages.length < MAX_PENDING_MESSAGES) {
+        this.pendingMessages.push(message);
       }
-      store.createIndex(indexDef.name, indexDef.keyPath, indexDef.options);
-    }
-    for (const indexDef of diff.indexesToAdd) {
-      options.onMigrationProgress?.(`Adding index: ${indexDef.name}`, 0.6);
-      store.createIndex(indexDef.name, indexDef.keyPath, indexDef.options);
+      return;
     }
-    options.onMigrationProgress?.(`Migration complete`, 1);
-  });
-}
-async function performDestructiveMigration(db, tableName, primaryKey, expectedIndexes, options = {}, autoIncrement = false) {
-  if (!options.allowDestructiveMigration) {
-    throw new Error(`Destructive migration required for ${tableName} but not allowed. ` + `Primary key has changed. Set allowDestructiveMigration=true to proceed with data loss, ` + `or provide a dataTransformer to migrate data.`);
-  }
-  const currentVersion = db.version;
-  const newVersion = currentVersion + 1;
-  options.onMigrationProgress?.(`Performing destructive migration of ${tableName}. Reading existing data...`, 0);
-  let existingData = [];
-  try {
-    const transaction = db.transaction(tableName, "readonly");
-    const store = transaction.objectStore(tableName);
-    existingData = await readAllData(store);
-    options.onMigrationProgress?.(`Read ${existingData.length} records`, 0.3);
-  } catch (err) {
-    options.onMigrationWarning?.(`Failed to read existing data during migration: ${err}`, err);
-  }
-  db.close();
-  if (options.dataTransformer && existingData.length > 0) {
-    options.onMigrationProgress?.(`Transforming ${existingData.length} records...`, 0.4);
-    try {
-      const transformed = [];
-      for (let i = 0;i < existingData.length; i++) {
-        const record = existingData[i];
-        const transformedRecord = await options.dataTransformer(record);
-        if (transformedRecord !== undefined && transformedRecord !== null) {
-          transformed.push(transformedRecord);
-        }
-        if (i % 100 === 0) {
-          options.onMigrationProgress?.(`Transformed ${i}/${existingData.length} records`, 0.4 + i / existingData.length * 0.3);
+    switch (message.type) {
+      case "SYNC_REQUEST":
+        const all = await this.inMemoryRepo.getAll();
+        if (this.channel && all) {
+          this.channel.postMessage({
+            type: "SYNC_RESPONSE",
+            data: all
+          });
         }
-      }
-      existingData = transformed;
-      options.onMigrationProgress?.(`Transformation complete: ${existingData.length} records`, 0.7);
-    } catch (err) {
-      options.onMigrationWarning?.(`Data transformation failed: ${err}. Some data may be lost.`, err);
-      existingData = [];
-    }
-  }
-  options.onMigrationProgress?.(`Recreating object store...`, 0.75);
-  const newDb = await openIndexedDbTable(tableName, newVersion, (event) => {
-    const db2 = event.target.result;
-    if (db2.objectStoreNames.contains(tableName)) {
-      db2.deleteObjectStore(tableName);
-    }
-    const store = db2.createObjectStore(tableName, { keyPath: primaryKey, autoIncrement });
-    for (const idx of expectedIndexes) {
-      store.createIndex(idx.name, idx.keyPath, idx.options);
-    }
-    if (existingData.length > 0) {
-      options.onMigrationProgress?.(`Restoring ${existingData.length} records...`, 0.8);
-      for (const record of existingData) {
-        try {
-          store.put(record);
-        } catch (err) {
-          options.onMigrationWarning?.(`Failed to restore record: ${err}`, err);
+        break;
+      case "SYNC_RESPONSE":
+        if (message.data && Array.isArray(message.data)) {
+          await this.copyDataFromArray(message.data);
         }
-      }
-    }
-  });
-  options.onMigrationProgress?.(`Destructive migration complete`, 1);
-  return newDb;
-}
-async function createNewDatabase(tableName, primaryKey, expectedIndexes, options = {}, autoIncrement = false) {
-  options.onMigrationProgress?.(`Creating new database: ${tableName}`, 0);
-  try {
-    await deleteIndexedDbTable(tableName);
-    await new Promise((resolve) => setTimeout(resolve, 50));
-  } catch (err) {}
-  const version = 1;
-  const db = await openIndexedDbTable(tableName, version, (event) => {
-    const db2 = event.target.result;
-    if (!db2.objectStoreNames.contains(METADATA_STORE_NAME)) {
-      db2.createObjectStore(METADATA_STORE_NAME, { keyPath: "tableName" });
-    }
-    const store = db2.createObjectStore(tableName, { keyPath: primaryKey, autoIncrement });
-    for (const idx of expectedIndexes) {
-      store.createIndex(idx.name, idx.keyPath, idx.options);
-    }
-  });
-  const snapshot = {
-    version: db.version,
-    primaryKey,
-    indexes: expectedIndexes,
-    recordCount: 0,
-    timestamp: Date.now()
-  };
-  await saveSchemaMetadata(db, tableName, snapshot);
-  options.onMigrationProgress?.(`Database created successfully`, 1);
-  return db;
-}
-async function ensureIndexedDbTable(tableName, primaryKey, expectedIndexes = [], options = {}, autoIncrement = false) {
-  try {
-    let db;
-    let wasJustCreated = false;
-    try {
-      db = await openIndexedDbTable(tableName);
-      if (db.version === 1 && !db.objectStoreNames.contains(tableName)) {
-        wasJustCreated = true;
-        db.close();
-      }
-    } catch (err) {
-      options.onMigrationProgress?.(`Database ${tableName} does not exist or has version conflict, creating...`, 0);
-      return await createNewDatabase(tableName, primaryKey, expectedIndexes, options, autoIncrement);
+        this.syncInProgress = false;
+        await this.drainPendingMessages();
+        break;
+      case "PUT":
+        await this.inMemoryRepo.put(message.entity);
+        break;
+      case "PUT_BULK":
+        await this.inMemoryRepo.putBulk(message.entities);
+        break;
+      case "DELETE":
+        await this.inMemoryRepo.delete(message.key);
+        break;
+      case "DELETE_ALL":
+        await this.inMemoryRepo.deleteAll();
+        break;
+      case "DELETE_SEARCH":
+        await this.inMemoryRepo.deleteSearch(message.criteria);
+        break;
     }
-    if (wasJustCreated) {
-      options.onMigrationProgress?.(`Creating new database: ${tableName}`, 0);
-      try {
-        await deleteIndexedDbTable(tableName);
-        await new Promise((resolve) => setTimeout(resolve, 50));
-      } catch (err) {}
-      db = await openIndexedDbTable(tableName, 1, (event) => {
-        const db2 = event.target.result;
-        if (!db2.objectStoreNames.contains(METADATA_STORE_NAME)) {
-          db2.createObjectStore(METADATA_STORE_NAME, { keyPath: "tableName" });
-        }
-        const store2 = db2.createObjectStore(tableName, { keyPath: primaryKey, autoIncrement });
-        for (const idx of expectedIndexes) {
-          store2.createIndex(idx.name, idx.keyPath, idx.options);
-        }
-      });
-      const snapshot2 = {
-        version: db.version,
-        primaryKey,
-        indexes: expectedIndexes,
-        recordCount: 0,
-        timestamp: Date.now()
-      };
-      await saveSchemaMetadata(db, tableName, snapshot2);
-      options.onMigrationProgress?.(`Database created successfully`, 1);
-      return db;
-    }
-    if (!db.objectStoreNames.contains(METADATA_STORE_NAME)) {
-      const currentVersion = db.version;
-      db.close();
-      db = await openIndexedDbTable(tableName, currentVersion + 1, (event) => {
-        const db2 = event.target.result;
-        if (!db2.objectStoreNames.contains(METADATA_STORE_NAME)) {
-          db2.createObjectStore(METADATA_STORE_NAME, { keyPath: "tableName" });
+  }
+  async drainPendingMessages() {
+    while (!this.syncInProgress && this.pendingMessages.length > 0) {
+      const messages = this.pendingMessages;
+      this.pendingMessages = [];
+      for (const message of messages) {
+        await this.handleBroadcastMessage(message);
+        if (this.syncInProgress) {
+          break;
         }
-      });
+      }
     }
-    if (!db.objectStoreNames.contains(tableName)) {
-      options.onMigrationProgress?.(`Object store ${tableName} does not exist, creating...`, 0);
-      db.close();
-      return await createNewDatabase(tableName, primaryKey, expectedIndexes, options, autoIncrement);
-    }
-    const transaction = db.transaction(tableName, "readonly");
-    const store = transaction.objectStore(tableName);
-    const diff = compareSchemas(store, primaryKey, expectedIndexes);
-    await new Promise((resolve) => {
-      transaction.oncomplete = () => resolve();
-      transaction.onerror = () => resolve();
-    });
-    const needsMigration = diff.indexesToAdd.length > 0 || diff.indexesToRemove.length > 0 || diff.indexesToModify.length > 0 || diff.needsObjectStoreRecreation;
-    if (!needsMigration) {
-      options.onMigrationProgress?.(`Schema for ${tableName} is up to date`, 1);
-      const snapshot2 = {
-        version: db.version,
-        primaryKey,
-        indexes: expectedIndexes,
-        timestamp: Date.now()
-      };
-      await saveSchemaMetadata(db, tableName, snapshot2);
-      return db;
-    }
-    if (diff.needsObjectStoreRecreation) {
-      options.onMigrationProgress?.(`Schema change requires object store recreation for ${tableName}`, 0);
-      db = await performDestructiveMigration(db, tableName, primaryKey, expectedIndexes, options, autoIncrement);
-    } else {
-      options.onMigrationProgress?.(`Performing incremental migration for ${tableName}`, 0);
-      db = await performIncrementalMigration(db, tableName, diff, options);
-    }
-    const snapshot = {
-      version: db.version,
-      primaryKey,
-      indexes: expectedIndexes,
-      timestamp: Date.now()
-    };
-    await saveSchemaMetadata(db, tableName, snapshot);
-    return db;
-  } catch (err) {
-    options.onMigrationWarning?.(`Migration failed for ${tableName}: ${err}`, err);
-    throw err;
-  }
-}
-async function dropIndexedDbTable(tableName) {
-  return deleteIndexedDbTable(tableName);
-}
-
-// src/tabular/IndexedDbTabularStorage.ts
-var IDB_TABULAR_REPOSITORY = createServiceToken12("storage.tabularRepository.indexedDb");
-function compareEntitiesForChange(a, b) {
-  const au = a?.updated_at;
-  const bu = b?.updated_at;
-  if (typeof au === "string" && typeof bu === "string") {
-    return au === bu;
-  }
-  return deepEqual2(a, b);
-}
-
-class IndexedDbTabularStorage extends BaseTabularStorage {
-  table;
-  db;
-  setupPromise = null;
-  migrationOptions;
-  hybridManager = null;
-  hybridOptions;
-  cursorSafeIndexes;
-  constructor(table = "tabular_store", schema, primaryKeyNames, indexes = [], migrationOptions = {}, clientProvidedKeys = "if-missing") {
-    super(schema, primaryKeyNames, indexes, clientProvidedKeys);
-    this.table = table;
-    this.migrationOptions = migrationOptions;
-    this.hybridOptions = {
-      useBroadcastChannel: migrationOptions.useBroadcastChannel ?? true,
-      backupPollingIntervalMs: migrationOptions.backupPollingIntervalMs ?? 5000
-    };
-  }
-  async getDb() {
-    if (this.db)
-      return this.db;
-    await this.setupDatabase();
-    return this.db;
   }
-  async setupDatabase() {
-    if (this.db)
-      return;
-    if (this.setupPromise) {
-      await this.setupPromise;
+  syncFromOtherTabs() {
+    if (!this.channel)
       return;
-    }
-    this.setupPromise = this.performSetup();
-    try {
-      this.db = await this.setupPromise;
-    } finally {
-      this.setupPromise = null;
-    }
-  }
-  async performSetup() {
-    const pkColumns = super.primaryKeyColumns();
-    const expectedIndexes = [];
-    for (const spec of this.indexes) {
-      const columns = spec;
-      if (columns.length <= pkColumns.length) {
-        const isPkPrefix = columns.every((col, idx) => col === pkColumns[idx]);
-        if (isPkPrefix)
-          continue;
+    this.syncInProgress = true;
+    this.channel.postMessage({ type: "SYNC_REQUEST" });
+    setTimeout(() => {
+      if (this.syncInProgress) {
+        this.syncInProgress = false;
+        this.drainPendingMessages().catch((error) => {
+          console.error("Failed to drain pending messages after sync timeout", error);
+        });
       }
-      const columnNames = columns.map((col) => String(col));
-      const indexName = columnNames.join("_");
-      expectedIndexes.push({
-        name: indexName,
-        keyPath: columnNames.length === 1 ? columnNames[0] : columnNames,
-        options: { unique: false }
-      });
-    }
-    const primaryKey = pkColumns.length === 1 ? pkColumns[0] : pkColumns;
-    const useAutoIncrement = this.hasAutoGeneratedKey() && this.autoGeneratedKeyStrategy === "autoincrement" && pkColumns.length === 1;
-    return await ensureIndexedDbTable(this.table, primaryKey, expectedIndexes, this.migrationOptions, useAutoIncrement);
+    }, SYNC_TIMEOUT);
   }
-  generateKeyValue(columnName, strategy) {
-    if (strategy === "uuid") {
-      return uuid44();
-    }
-    throw new Error(`IndexedDB autoincrement keys are generated by the database, not client-side. Column: ${columnName}`);
-  }
-  async put(record) {
-    const db = await this.getDb();
-    let recordToStore = record;
-    if (this.hasAutoGeneratedKey() && this.autoGeneratedKeyName) {
-      const keyName = String(this.autoGeneratedKeyName);
-      const clientProvidedValue = record[keyName];
-      const hasClientValue = clientProvidedValue !== undefined && clientProvidedValue !== null;
-      if (this.autoGeneratedKeyStrategy === "uuid") {
-        let shouldGenerate = false;
-        if (this.clientProvidedKeys === "never") {
-          shouldGenerate = true;
-        } else if (this.clientProvidedKeys === "always") {
-          if (!hasClientValue) {
-            throw new Error(`Auto-generated key "${keyName}" is required when clientProvidedKeys is "always"`);
-          }
-          shouldGenerate = false;
-        } else {
-          shouldGenerate = !hasClientValue;
-        }
-        if (shouldGenerate) {
-          const generatedValue = this.generateKeyValue(keyName, "uuid");
-          recordToStore = { ...record, [keyName]: generatedValue };
-        }
-      } else if (this.autoGeneratedKeyStrategy === "autoincrement") {
-        if (this.clientProvidedKeys === "always" && !hasClientValue) {
-          throw new Error(`Auto-generated key "${keyName}" is required when clientProvidedKeys is "always"`);
-        }
-        if (this.clientProvidedKeys === "never") {
-          const { [keyName]: _, ...rest } = record;
-          recordToStore = rest;
-        }
-      }
+  async copyDataFromArray(entities) {
+    if (entities.length === 0)
+      return;
+    await this.inMemoryRepo.deleteAll();
+    await this.inMemoryRepo.putBulk(entities);
+  }
+  broadcast(message) {
+    if (this.channel) {
+      this.channel.postMessage(message);
     }
-    return new Promise((resolve, reject) => {
-      const transaction = db.transaction(this.table, "readwrite");
-      const store = transaction.objectStore(this.table);
-      const request = store.put(recordToStore);
-      request.onerror = () => {
-        reject(request.error);
-      };
-      request.onsuccess = () => {
-        if (this.hasAutoGeneratedKey() && this.autoGeneratedKeyName && this.autoGeneratedKeyStrategy === "autoincrement") {
-          const keyName = String(this.autoGeneratedKeyName);
-          if (recordToStore[keyName] === undefined) {
-            recordToStore = { ...recordToStore, [keyName]: request.result };
-          }
-        }
-        this.events.emit("put", recordToStore);
-        resolve(recordToStore);
-      };
-      transaction.oncomplete = () => {
-        this.hybridManager?.notifyLocalChange();
-      };
-    });
   }
-  async putBulk(records) {
-    return await Promise.all(records.map((record) => this.put(record)));
+  async setupDatabase() {
+    if (this.isInitialized)
+      return;
+    this.isInitialized = true;
+    await this.syncFromOtherTabs();
   }
-  getPrimaryKeyAsOrderedArray(key) {
-    return super.getPrimaryKeyAsOrderedArray(key).map((value) => typeof value === "bigint" ? value.toString() : value);
+  async put(value) {
+    const result = await this.inMemoryRepo.put(value);
+    this.broadcast({ type: "PUT", entity: result });
+    return result;
   }
-  getIndexedKey(key) {
-    const keys = super.getPrimaryKeyAsOrderedArray(key).map((value) => typeof value === "bigint" ? value.toString() : value);
-    return keys.length === 1 ? keys[0] : keys;
+  async putBulk(values) {
+    const result = await this.inMemoryRepo.putBulk(values);
+    this.broadcast({ type: "PUT_BULK", entities: result });
+    return result;
   }
   async get(key) {
-    const db = await this.getDb();
-    return new Promise((resolve, reject) => {
-      const transaction = db.transaction(this.table, "readonly");
-      const store = transaction.objectStore(this.table);
-      const request = store.get(this.getIndexedKey(key));
-      request.onerror = () => reject(request.error);
-      request.onsuccess = () => {
-        if (!request.result) {
-          this.events.emit("get", key, undefined);
-          resolve(undefined);
-          return;
-        }
-        this.events.emit("get", key, request.result);
-        resolve(request.result);
-      };
-    });
-  }
-  async getAll(options) {
-    this.validateGetAllOptions(options);
-    const db = await this.getDb();
-    const transaction = db.transaction(this.table, "readonly");
-    const store = transaction.objectStore(this.table);
-    const request = store.getAll();
-    return new Promise((resolve, reject) => {
-      request.onerror = () => reject(request.error);
-      request.onsuccess = () => {
-        let values = request.result;
-        if (values.length === 0) {
-          resolve(undefined);
-          return;
-        }
-        if (options?.orderBy && options.orderBy.length > 0) {
-          values.sort((a, b) => {
-            for (const { column, direction } of options.orderBy) {
-              const aVal = a[column];
-              const bVal = b[column];
-              if (aVal == null && bVal == null)
-                continue;
-              if (aVal == null)
-                return direction === "ASC" ? -1 : 1;
-              if (bVal == null)
-                return direction === "ASC" ? 1 : -1;
-              if (aVal < bVal)
-                return direction === "ASC" ? -1 : 1;
-              if (aVal > bVal)
-                return direction === "ASC" ? 1 : -1;
-            }
-            return 0;
-          });
-        }
-        if (options?.offset !== undefined) {
-          values = values.slice(options.offset);
-        }
-        if (options?.limit !== undefined) {
-          values = values.slice(0, options.limit);
-        }
-        resolve(values.length > 0 ? values : undefined);
-      };
-    });
+    return await this.inMemoryRepo.get(key);
   }
-  async delete(key) {
-    const db = await this.getDb();
-    return new Promise((resolve, reject) => {
-      const transaction = db.transaction(this.table, "readwrite");
-      const store = transaction.objectStore(this.table);
-      const request = store.delete(this.getIndexedKey(key));
-      request.onerror = () => reject(request.error);
-      request.onsuccess = () => {
-        this.events.emit("delete", key);
-        resolve();
-      };
-      transaction.oncomplete = () => {
-        this.hybridManager?.notifyLocalChange();
-      };
-    });
+  async delete(value) {
+    await this.inMemoryRepo.delete(value);
+    const { key } = this.separateKeyValueFromCombined(value);
+    this.broadcast({ type: "DELETE", key });
   }
   async deleteAll() {
-    const db = await this.getDb();
-    return new Promise((resolve, reject) => {
-      const transaction = db.transaction(this.table, "readwrite");
-      const store = transaction.objectStore(this.table);
-      const request = store.clear();
-      request.onerror = () => reject(request.error);
-      request.onsuccess = () => {
-        this.events.emit("clearall");
-        resolve();
-      };
-      transaction.oncomplete = () => {
-        this.hybridManager?.notifyLocalChange();
-      };
-    });
-  }
-  async size() {
-    const db = await this.getDb();
-    return new Promise((resolve, reject) => {
-      const transaction = db.transaction(this.table, "readonly");
-      const store = transaction.objectStore(this.table);
-      const request = store.count();
-      request.onerror = () => reject(request.error);
-      request.onsuccess = () => resolve(request.result);
-    });
-  }
-  getCursorSafeIndexes() {
-    if (this.cursorSafeIndexes)
-      return this.cursorSafeIndexes;
-    const required = new Set(this.schema.required ?? []);
-    this.cursorSafeIndexes = this.indexes.filter((columns) => columns.every((column) => required.has(String(column))));
-    return this.cursorSafeIndexes;
+    await this.inMemoryRepo.deleteAll();
+    this.broadcast({ type: "DELETE_ALL" });
   }
-  createIndexedRange(store, criteria) {
-    const criteriaColumns = Object.keys(criteria);
-    if (criteriaColumns.length === 0)
-      return;
-    let best;
-    for (const indexColumns of this.getCursorSafeIndexes()) {
-      const prefixValues = [];
-      for (const column of indexColumns) {
-        const value = this.getEqualityCriterionValue(criteria, column);
-        if (value === undefined)
-          break;
-        prefixValues.push(value);
-      }
-      if (prefixValues.length === 0)
-        continue;
-      const indexedPrefix = indexColumns.slice(0, prefixValues.length);
-      const coversCriteria = criteriaColumns.every((column) => indexedPrefix.includes(column));
-      const better = !best || coversCriteria && !best.coversCriteria || coversCriteria === best.coversCriteria && prefixValues.length > best.prefixValues.length;
-      if (better) {
-        best = {
-          indexName: indexColumns.map((column) => String(column)).join("_"),
-          prefixValues,
-          fullMatch: prefixValues.length === indexColumns.length,
-          coversCriteria
-        };
-      }
-    }
-    if (!best)
-      return;
-    const range = best.fullMatch ? IDBKeyRange.only(best.prefixValues.length === 1 ? best.prefixValues[0] : best.prefixValues) : IDBKeyRange.bound(best.prefixValues, [...best.prefixValues, []]);
-    return {
-      source: store.index(best.indexName),
-      range,
-      coversCriteria: best.coversCriteria
-    };
+  async getAll(options) {
+    return await this.inMemoryRepo.getAll(options);
   }
-  async count(criteria) {
-    if (!criteria || Object.keys(criteria).length === 0) {
-      return await this.size();
-    }
-    this.validateQueryParams(criteria);
-    const db = await this.getDb();
-    return new Promise((resolve, reject) => {
-      const transaction = db.transaction(this.table, "readonly");
-      const store = transaction.objectStore(this.table);
-      const plan = this.createIndexedRange(store, criteria);
-      if (plan?.coversCriteria) {
-        const request2 = plan.source.count(plan.range);
-        request2.onerror = () => reject(request2.error);
-        request2.onsuccess = () => resolve(request2.result);
-        return;
-      }
-      const source = plan?.source ?? store;
-      const range = plan?.range;
-      let count = 0;
-      const request = source.openCursor(range);
-      request.onerror = () => reject(request.error);
-      request.onsuccess = () => {
-        const cursor = request.result;
-        if (!cursor) {
-          resolve(count);
-          return;
-        }
-        if (this.matchesCriteria(cursor.value, criteria)) {
-          count += 1;
-        }
-        cursor.continue();
-      };
-    });
+  async size() {
+    return await this.inMemoryRepo.size();
   }
   async getBulk(offset, limit) {
-    if (offset < 0) {
-      throw new RangeError(`offset must be non-negative, got ${offset}`);
-    }
-    if (limit <= 0) {
-      return;
-    }
-    const db = await this.getDb();
-    return new Promise((resolve, reject) => {
-      const transaction = db.transaction(this.table, "readonly");
-      const store = transaction.objectStore(this.table);
-      const request = store.openCursor();
-      const entities = [];
-      let skipped = false;
-      request.onerror = () => reject(request.error);
-      request.onsuccess = () => {
-        const cursor = request.result;
-        if (cursor) {
-          if (!skipped && offset > 0) {
-            skipped = true;
-            cursor.advance(offset);
-            return;
-          }
-          entities.push(cursor.value);
-          if (entities.length === limit) {
-            resolve(entities);
-            return;
-          }
-          cursor.continue();
-        } else {
-          resolve(entities.length > 0 ? entities : undefined);
-        }
-      };
-    });
-  }
-  matchesCriteria(record, criteria) {
-    for (const column of Object.keys(criteria)) {
-      const criterion = criteria[column];
-      const recordValue = record[column];
-      let operator = "=";
-      let value;
-      if (isSearchCondition(criterion)) {
-        operator = criterion.operator;
-        value = criterion.value;
-      } else {
-        value = criterion;
-      }
-      if (operator !== "=" && (recordValue === null || recordValue === undefined)) {
-        return false;
-      }
-      switch (operator) {
-        case "=":
-          if (recordValue !== value)
-            return false;
-          break;
-        case "<":
-          if (!(recordValue < value))
-            return false;
-          break;
-        case "<=":
-          if (!(recordValue <= value))
-            return false;
-          break;
-        case ">":
-          if (!(recordValue > value))
-            return false;
-          break;
-        case ">=":
-          if (!(recordValue >= value))
-            return false;
-          break;
-        default:
-          return false;
-      }
-    }
-    return true;
-  }
-  async deleteSearch(criteria) {
-    const criteriaKeys = Object.keys(criteria);
-    if (criteriaKeys.length === 0) {
-      return;
-    }
-    const db = await this.getDb();
-    return new Promise(async (resolve, reject) => {
-      try {
-        const transaction = db.transaction(this.table, "readwrite");
-        const store = transaction.objectStore(this.table);
-        transaction.oncomplete = () => {
-          this.events.emit("delete", criteriaKeys[0]);
-          this.hybridManager?.notifyLocalChange();
-          resolve();
-        };
-        transaction.onerror = () => {
-          reject(transaction.error);
-        };
-        const getAllRequest = store.getAll();
-        getAllRequest.onsuccess = () => {
-          const allRecords = getAllRequest.result;
-          const recordsToDelete = allRecords.filter((record) => this.matchesCriteria(record, criteria));
-          if (recordsToDelete.length === 0) {
-            return;
-          }
-          for (const record of recordsToDelete) {
-            const primaryKey = this.primaryKeyColumns().reduce((key, col) => {
-              key[col] = record[col];
-              return key;
-            }, {});
-            const request = store.delete(this.getIndexedKey(primaryKey));
-            request.onerror = () => {
-              console.error("Error deleting record:", request.error);
-            };
-          }
-        };
-        getAllRequest.onerror = () => {
-          reject(getAllRequest.error);
-        };
-      } catch (error) {
-        reject(error);
-      }
-    });
-  }
-  getEqualityCriterionValue(criteria, column) {
-    const criterion = criteria[column];
-    if (criterion === undefined)
-      return;
-    if (isSearchCondition(criterion)) {
-      return criterion.operator === "=" ? criterion.value : undefined;
-    }
-    return criterion;
-  }
-  compareByOrder(a, b, options) {
-    if (!options?.orderBy)
-      return 0;
-    for (const { column, direction } of options.orderBy) {
-      const aVal = a[column];
-      const bVal = b[column];
-      if (aVal == null && bVal == null)
-        continue;
-      if (aVal == null)
-        return direction === "ASC" ? -1 : 1;
-      if (bVal == null)
-        return direction === "ASC" ? 1 : -1;
-      if (aVal < bVal)
-        return direction === "ASC" ? -1 : 1;
-      if (aVal > bVal)
-        return direction === "ASC" ? 1 : -1;
-    }
-    return 0;
-  }
-  createIndexedQuery(store, criteria, options) {
-    const orderBy = options?.orderBy ?? [];
-    let best;
-    for (const indexColumns of this.getCursorSafeIndexes()) {
-      const prefixValues = [];
-      for (const column of indexColumns) {
-        const value = this.getEqualityCriterionValue(criteria, column);
-        if (value === undefined)
-          break;
-        prefixValues.push(value);
-      }
-      if (prefixValues.length === 0)
-        continue;
-      const remainingColumns = indexColumns.slice(prefixValues.length);
-      let redundantOrderPrefixLength = 0;
-      while (redundantOrderPrefixLength < orderBy.length && redundantOrderPrefixLength < prefixValues.length && orderBy[redundantOrderPrefixLength]?.column === indexColumns[redundantOrderPrefixLength]) {
-        redundantOrderPrefixLength++;
-      }
-      const normalizedOrderBy = orderBy.slice(redundantOrderPrefixLength);
-      const satisfiesOrder = normalizedOrderBy.length === 0 || normalizedOrderBy.length <= remainingColumns.length && normalizedOrderBy.every((order, index) => order.column === remainingColumns[index]) && orderBy.every((order) => order.direction === orderBy[0]?.direction);
-      if (!satisfiesOrder && best)
-        continue;
-      if (!best || satisfiesOrder && !best.satisfiesOrder || prefixValues.length > best.prefixValues.length) {
-        best = {
-          indexName: indexColumns.map((column) => String(column)).join("_"),
-          prefixValues,
-          fullMatch: prefixValues.length === indexColumns.length,
-          satisfiesOrder,
-          direction: orderBy[0]?.direction === "DESC" ? "prev" : "next"
-        };
-      }
-    }
-    const appliedLimit = Boolean(best?.satisfiesOrder && options?.limit !== undefined);
-    const appliedOffset = Boolean(best?.satisfiesOrder && options?.offset !== undefined);
-    if (!best) {
-      return {
-        source: store,
-        range: undefined,
-        direction: orderBy[0]?.direction === "DESC" ? "prev" : "next",
-        satisfiesOrder: false,
-        appliedLimit: false,
-        appliedOffset: false,
-        skipRemaining: 0
-      };
-    }
-    const source = store.index(best.indexName);
-    const keyRange = best.fullMatch ? IDBKeyRange.only(best.prefixValues.length === 1 ? best.prefixValues[0] : best.prefixValues) : IDBKeyRange.bound(best.prefixValues, [...best.prefixValues, []]);
-    return {
-      source,
-      range: keyRange,
-      direction: best.direction,
-      satisfiesOrder: best.satisfiesOrder,
-      appliedLimit,
-      appliedOffset,
-      skipRemaining: appliedOffset ? options?.offset ?? 0 : 0
-    };
+    return await this.inMemoryRepo.getBulk(offset, limit);
   }
   async query(criteria, options) {
-    this.validateQueryParams(criteria, options);
-    const db = await this.getDb();
-    return new Promise((resolve, reject) => {
-      const transaction = db.transaction(this.table, "readonly");
-      const store = transaction.objectStore(this.table);
-      const indexedQuery = this.createIndexedQuery(store, criteria, options);
-      const results = [];
-      const request = indexedQuery.source.openCursor(indexedQuery.range, indexedQuery.direction);
-      request.onsuccess = () => {
-        const cursor = request.result;
-        if (!cursor) {
-          let finalResults = results;
-          if (!indexedQuery.satisfiesOrder && options?.orderBy && options.orderBy.length > 0) {
-            finalResults = [...finalResults].sort((a, b) => this.compareByOrder(a, b, options));
-          }
-          if (!indexedQuery.appliedOffset && options?.offset !== undefined) {
-            finalResults = finalResults.slice(options.offset);
-          }
-          if (!indexedQuery.appliedLimit && options?.limit !== undefined) {
-            finalResults = finalResults.slice(0, options.limit);
-          }
-          const result = finalResults.length > 0 ? finalResults : undefined;
-          this.events.emit("query", criteria, result);
-          resolve(result);
-          return;
-        }
-        const record = cursor.value;
-        if (this.matchesCriteria(record, criteria)) {
-          if (indexedQuery.skipRemaining > 0) {
-            indexedQuery.skipRemaining -= 1;
-          } else {
-            results.push(record);
-            if (indexedQuery.appliedLimit && results.length === options?.limit) {
-              const result = results.length > 0 ? results : undefined;
-              this.events.emit("query", criteria, result);
-              resolve(result);
-              return;
-            }
-          }
-        }
-        cursor.continue();
-      };
-      request.onerror = () => reject(request.error);
-    });
+    return await this.inMemoryRepo.query(criteria, options);
   }
   async queryIndex(criteria, options) {
-    this.validateSelect(options);
-    this.validateQueryParams(criteria, options);
-    const registered = this.indexes.map((cols) => {
-      const cs = Array.isArray(cols) ? cols : [cols];
-      return { name: cs.join("_"), keyPath: cs };
-    });
-    const picked = pickCoveringIndex({
-      table: this.table,
-      indexes: registered,
-      criteriaColumns: Object.keys(criteria),
-      orderByColumns: (options.orderBy ?? []).map((o) => ({
-        column: String(o.column),
-        direction: o.direction
-      })),
-      selectColumns: options.select.map(String),
-      primaryKeyColumns: this.primaryKeyColumns().map(String)
-    });
-    const db = await this.getDb();
-    return new Promise((resolve, reject) => {
-      const tx = db.transaction(this.table, "readonly");
-      const store = tx.objectStore(this.table);
-      const idx = store.index(picked.name);
-      const prefix = [];
-      for (const col of picked.keyPath) {
-        const c = criteria[col];
-        if (c === undefined && !(col in criteria))
-          break;
-        if (isSearchCondition(c)) {
-          if (c.operator !== "=")
-            break;
-          prefix.push(c.value);
-        } else {
-          prefix.push(c);
-        }
-      }
-      const range = prefix.length === 0 ? undefined : prefix.length === picked.keyPath.length ? IDBKeyRange.only(prefix.length === 1 ? prefix[0] : prefix) : IDBKeyRange.bound(prefix, [...prefix, []]);
-      const direction = picked.reverseDirection ? "prev" : "next";
-      const request = idx.openKeyCursor(range, direction);
-      const out = [];
-      let toSkip = options.offset ?? 0;
-      const keyPathPositions = new Map;
-      picked.keyPath.forEach((col, i) => keyPathPositions.set(col, i));
-      const pkCols = this.primaryKeyColumns().map(String);
-      const pkPositions = new Map;
-      pkCols.forEach((col, i) => pkPositions.set(col, i));
-      request.onsuccess = () => {
-        const cursor = request.result;
-        if (!cursor) {
-          resolve(out);
-          return;
-        }
-        const key = cursor.key;
-        const row = {};
-        for (const col of options.select) {
-          const colStr = String(col);
-          const pos = keyPathPositions.get(colStr);
-          if (pos !== undefined) {
-            row[colStr] = Array.isArray(key) ? key[pos] : key;
-          } else {
-            if (pkCols.length === 1 && colStr === pkCols[0]) {
-              row[colStr] = cursor.primaryKey;
-            } else {
-              const pkPos = pkPositions.get(colStr);
-              if (pkPos !== undefined) {
-                row[colStr] = Array.isArray(cursor.primaryKey) ? cursor.primaryKey[pkPos] : cursor.primaryKey;
-              }
-            }
-          }
-        }
-        let matches = true;
-        for (const [col, crit] of Object.entries(criteria)) {
-          const pos = keyPathPositions.get(col);
-          if (pos === undefined)
-            continue;
-          if (pos < prefix.length)
-            continue;
-          const valFromKey = Array.isArray(key) ? key[pos] : key;
-          const op = isSearchCondition(crit) ? crit.operator : "=";
-          const val = isSearchCondition(crit) ? crit.value : crit;
-          if (!compareWithOperator(valFromKey, op, val)) {
-            matches = false;
-            break;
-          }
-        }
-        if (matches) {
-          if (toSkip > 0) {
-            toSkip -= 1;
-          } else {
-            out.push(row);
-            if (options.limit !== undefined && out.length >= options.limit) {
-              resolve(out);
-              return;
-            }
-          }
-        }
-        cursor.continue();
-      };
-      request.onerror = () => reject(request.error);
-    });
+    return await this.inMemoryRepo.queryIndex(criteria, options);
   }
-  getHybridManager() {
-    if (!this.hybridManager) {
-      const channelName = `indexeddb-tabular-${this.table}`;
-      this.hybridManager = new HybridSubscriptionManager(channelName, async () => {
-        const entities = await this.getAll() || [];
-        const map = new Map;
-        for (const entity of entities) {
-          const { key } = this.separateKeyValueFromCombined(entity);
-          const fingerprint = await makeFingerprint5(key);
-          map.set(fingerprint, entity);
-        }
-        return map;
-      }, compareEntitiesForChange, {
-        insert: (item) => ({ type: "INSERT", new: item }),
-        update: (oldItem, newItem) => ({ type: "UPDATE", old: oldItem, new: newItem }),
-        delete: (item) => ({ type: "DELETE", old: item })
-      }, {
-        defaultIntervalMs: 1000,
-        useBroadcastChannel: this.hybridOptions.useBroadcastChannel,
-        backupPollingIntervalMs: this.hybridOptions.backupPollingIntervalMs
-      });
-    }
-    return this.hybridManager;
+  async deleteSearch(criteria) {
+    await this.inMemoryRepo.deleteSearch(criteria);
+    this.broadcast({
+      type: "DELETE_SEARCH",
+      criteria
+    });
   }
   subscribeToChanges(callback, options) {
-    const intervalMs = options?.pollingIntervalMs ?? 1000;
-    const manager = this.getHybridManager();
-    return manager.subscribe(callback, { intervalMs });
+    return this.inMemoryRepo.subscribeToChanges(callback, options);
   }
   destroy() {
-    if (this.hybridManager) {
-      this.hybridManager.destroy();
-      this.hybridManager = null;
-    }
-    this.db?.close();
-  }
-}
-function compareWithOperator(a, op, b) {
-  const av = a;
-  const bv = b;
-  switch (op) {
-    case "=":
-      return av === bv;
-    case "<":
-      return av !== null && av !== undefined && av < bv;
-    case "<=":
-      return av !== null && av !== undefined && av <= bv;
-    case ">":
-      return av !== null && av !== undefined && av > bv;
-    case ">=":
-      return av !== null && av !== undefined && av >= bv;
-  }
-}
-// src/tabular/SharedInMemoryTabularStorage.ts
-import { createServiceToken as createServiceToken13 } from "@workglow/util";
-var SHARED_IN_MEMORY_TABULAR_REPOSITORY = createServiceToken13("storage.tabularRepository.sharedInMemory");
-var SYNC_TIMEOUT = 1000;
-var MAX_PENDING_MESSAGES = 1000;
-
-class SharedInMemoryTabularStorage extends BaseTabularStorage {
-  channel = null;
-  channelName;
-  inMemoryRepo;
-  isInitialized = false;
-  syncInProgress = false;
-  pendingMessages = [];
-  constructor(channelName = "tabular_store", schema, primaryKeyNames, indexes = [], clientProvidedKeys = "if-missing") {
-    super(schema, primaryKeyNames, indexes, clientProvidedKeys);
-    this.channelName = channelName;
-    this.inMemoryRepo = new InMemoryTabularStorage(schema, primaryKeyNames, indexes, clientProvidedKeys);
-    this.setupEventForwarding();
-    this.initializeBroadcastChannel();
-  }
-  isBroadcastChannelAvailable() {
-    return typeof BroadcastChannel !== "undefined";
-  }
-  initializeBroadcastChannel() {
-    if (!this.isBroadcastChannelAvailable()) {
-      console.warn("BroadcastChannel is not available. Tab synchronization will not work.");
-      return;
-    }
-    try {
-      this.channel = new BroadcastChannel(this.channelName);
-      this.channel.onmessage = (event) => {
-        this.handleBroadcastMessage(event.data);
-      };
-      this.syncFromOtherTabs();
-    } catch (error) {
-      console.error("Failed to initialize BroadcastChannel:", error);
-    }
-  }
-  setupEventForwarding() {
-    this.inMemoryRepo.on("put", (entity) => {
-      this.events.emit("put", entity);
-    });
-    this.inMemoryRepo.on("get", (key, entity) => {
-      this.events.emit("get", key, entity);
-    });
-    this.inMemoryRepo.on("query", (key, entities) => {
-      this.events.emit("query", key, entities);
-    });
-    this.inMemoryRepo.on("delete", (key) => {
-      this.events.emit("delete", key);
-    });
-    this.inMemoryRepo.on("clearall", () => {
-      this.events.emit("clearall");
-    });
-  }
-  async handleBroadcastMessage(message) {
-    if (this.syncInProgress && message.type !== "SYNC_RESPONSE") {
-      if (this.pendingMessages.length < MAX_PENDING_MESSAGES) {
-        this.pendingMessages.push(message);
-      }
-      return;
-    }
-    switch (message.type) {
-      case "SYNC_REQUEST":
-        const all = await this.inMemoryRepo.getAll();
-        if (this.channel && all) {
-          this.channel.postMessage({
-            type: "SYNC_RESPONSE",
-            data: all
-          });
-        }
-        break;
-      case "SYNC_RESPONSE":
-        if (message.data && Array.isArray(message.data)) {
-          await this.copyDataFromArray(message.data);
-        }
-        this.syncInProgress = false;
-        await this.drainPendingMessages();
-        break;
-      case "PUT":
-        await this.inMemoryRepo.put(message.entity);
-        break;
-      case "PUT_BULK":
-        await this.inMemoryRepo.putBulk(message.entities);
-        break;
-      case "DELETE":
-        await this.inMemoryRepo.delete(message.key);
-        break;
-      case "DELETE_ALL":
-        await this.inMemoryRepo.deleteAll();
-        break;
-      case "DELETE_SEARCH":
-        await this.inMemoryRepo.deleteSearch(message.criteria);
-        break;
-    }
-  }
-  async drainPendingMessages() {
-    while (!this.syncInProgress && this.pendingMessages.length > 0) {
-      const messages = this.pendingMessages;
-      this.pendingMessages = [];
-      for (const message of messages) {
-        await this.handleBroadcastMessage(message);
-        if (this.syncInProgress) {
-          break;
-        }
-      }
-    }
-  }
-  syncFromOtherTabs() {
-    if (!this.channel)
-      return;
-    this.syncInProgress = true;
-    this.channel.postMessage({ type: "SYNC_REQUEST" });
-    setTimeout(() => {
-      if (this.syncInProgress) {
-        this.syncInProgress = false;
-        this.drainPendingMessages().catch((error) => {
-          console.error("Failed to drain pending messages after sync timeout", error);
-        });
-      }
-    }, SYNC_TIMEOUT);
-  }
-  async copyDataFromArray(entities) {
-    if (entities.length === 0)
-      return;
-    await this.inMemoryRepo.deleteAll();
-    await this.inMemoryRepo.putBulk(entities);
-  }
-  broadcast(message) {
-    if (this.channel) {
-      this.channel.postMessage(message);
-    }
-  }
-  async setupDatabase() {
-    if (this.isInitialized)
-      return;
-    this.isInitialized = true;
-    await this.syncFromOtherTabs();
-  }
-  async put(value) {
-    const result = await this.inMemoryRepo.put(value);
-    this.broadcast({ type: "PUT", entity: result });
-    return result;
-  }
-  async putBulk(values) {
-    const result = await this.inMemoryRepo.putBulk(values);
-    this.broadcast({ type: "PUT_BULK", entities: result });
-    return result;
-  }
-  async get(key) {
-    return await this.inMemoryRepo.get(key);
-  }
-  async delete(value) {
-    await this.inMemoryRepo.delete(value);
-    const { key } = this.separateKeyValueFromCombined(value);
-    this.broadcast({ type: "DELETE", key });
-  }
-  async deleteAll() {
-    await this.inMemoryRepo.deleteAll();
-    this.broadcast({ type: "DELETE_ALL" });
-  }
-  async getAll(options) {
-    return await this.inMemoryRepo.getAll(options);
-  }
-  async size() {
-    return await this.inMemoryRepo.size();
-  }
-  async getBulk(offset, limit) {
-    return await this.inMemoryRepo.getBulk(offset, limit);
-  }
-  async query(criteria, options) {
-    return await this.inMemoryRepo.query(criteria, options);
-  }
-  async queryIndex(criteria, options) {
-    return await this.inMemoryRepo.queryIndex(criteria, options);
-  }
-  async deleteSearch(criteria) {
-    await this.inMemoryRepo.deleteSearch(criteria);
-    this.broadcast({
-      type: "DELETE_SEARCH",
-      criteria
-    });
-  }
-  subscribeToChanges(callback, options) {
-    return this.inMemoryRepo.subscribeToChanges(callback, options);
-  }
-  destroy() {
-    if (this.channel) {
-      this.channel.close();
-      this.channel = null;
+    if (this.channel) {
+      this.channel.close();
+      this.channel = null;
     }
     this.inMemoryRepo.destroy();
   }
 }
-// src/tabular/SupabaseTabularStorage.ts
-import { createServiceToken as createServiceToken14 } from "@workglow/util";
-
-// src/tabular/BaseSqlTabularStorage.ts
-class BaseSqlTabularStorage extends BaseTabularStorage {
-  table;
-  _pkColsCache = new Map;
-  _valColsCache = new Map;
-  _pkColListCache = new Map;
-  _valColListCache = new Map;
-  constructor(table = "tabular_store", schema, primaryKeyNames, indexes = [], clientProvidedKeys = "if-missing") {
-    super(schema, primaryKeyNames, indexes, clientProvidedKeys);
-    this.table = table;
-    this.validateTableAndSchema();
-  }
-  constructPrimaryKeyColumns($delimiter = "") {
-    let cached = this._pkColsCache.get($delimiter);
-    if (cached === undefined) {
-      cached = Object.entries(this.primaryKeySchema.properties).map(([key, typeDef]) => {
-        const sqlType = this.mapTypeToSQL(typeDef);
-        return `${$delimiter}${key}${$delimiter} ${sqlType} NOT NULL`;
-      }).join(", ");
-      this._pkColsCache.set($delimiter, cached);
-    }
-    return cached;
-  }
-  constructValueColumns($delimiter = "") {
-    let cached = this._valColsCache.get($delimiter);
-    if (cached === undefined) {
-      const requiredSet = new Set(this.valueSchema.required ?? []);
-      const cols = Object.entries(this.valueSchema.properties).map(([key, typeDef]) => {
-        const sqlType = this.mapTypeToSQL(typeDef);
-        const isRequired = requiredSet.has(key);
-        const nullable = !isRequired || this.isNullable(typeDef);
-        return `${$delimiter}${key}${$delimiter} ${sqlType}${nullable ? " NULL" : " NOT NULL"}`;
-      }).join(", ");
-      cached = cols.length > 0 ? `, ${cols}` : "";
-      this._valColsCache.set($delimiter, cached);
-    }
-    return cached;
-  }
-  isNullable(typeDef) {
-    if (typeof typeDef === "boolean")
-      return typeDef;
-    if (typeDef.type === "null") {
-      return true;
-    }
-    if (Array.isArray(typeDef.type)) {
-      return typeDef.type.includes("null");
-    }
-    if (typeDef.anyOf && Array.isArray(typeDef.anyOf)) {
-      return typeDef.anyOf.some((type) => type.type === "null");
-    }
-    if (typeDef.oneOf && Array.isArray(typeDef.oneOf)) {
-      return typeDef.oneOf.some((type) => type.type === "null");
-    }
-    return false;
-  }
-  primaryKeyColumnList($delimiter = "") {
-    let cached = this._pkColListCache.get($delimiter);
-    if (cached === undefined) {
-      cached = $delimiter + this.primaryKeyColumns().join(`${$delimiter}, ${$delimiter}`) + $delimiter;
-      this._pkColListCache.set($delimiter, cached);
-    }
-    return cached;
-  }
-  valueColumnList($delimiter = "") {
-    let cached = this._valColListCache.get($delimiter);
-    if (cached === undefined) {
-      cached = $delimiter + this.valueColumns().join(`${$delimiter}, ${$delimiter}`) + $delimiter;
-      this._valColListCache.set($delimiter, cached);
-    }
-    return cached;
-  }
-  getNonNullType(typeDef) {
-    if (typeof typeDef === "boolean")
-      return typeDef;
-    if (typeDef.anyOf && Array.isArray(typeDef.anyOf)) {
-      const nonNullType = typeDef.anyOf.find((t) => t.type !== "null");
-      if (nonNullType) {
-        return nonNullType;
-      }
-    }
-    if (typeDef.oneOf && Array.isArray(typeDef.oneOf)) {
-      const nonNullType = typeDef.oneOf.find((t) => t.type !== "null");
-      if (nonNullType) {
-        return nonNullType;
-      }
-    }
-    return typeDef;
-  }
-  getValueAsOrderedArray(value) {
-    const orderedParams = [];
-    const valueAsRecord = value;
-    const requiredSet = new Set(this.valueSchema.required ?? []);
-    for (const key in this.valueSchema.properties) {
-      if (Object.prototype.hasOwnProperty.call(valueAsRecord, key)) {
-        const val = valueAsRecord[key];
-        if (val === undefined && !requiredSet.has(key)) {
-          orderedParams.push(null);
-        } else {
-          orderedParams.push(this.jsToSqlValue(key, val));
-        }
-      } else {
-        if (requiredSet.has(key)) {
-          throw new Error(`Missing required value field: ${key}`);
-        }
-        orderedParams.push(null);
-      }
-    }
-    return orderedParams;
-  }
-  getPrimaryKeyAsOrderedArray(key) {
-    const orderedParams = [];
-    const keyObj = key;
-    for (const k of Object.keys(this.primaryKeySchema.properties)) {
-      if (k in keyObj) {
-        const value = keyObj[k];
-        if (value === null) {
-          throw new Error(`Primary key field ${k} cannot be null`);
-        }
-        orderedParams.push(this.jsToSqlValue(k, value));
-      } else {
-        throw new Error(`Missing required primary key field: ${k}`);
-      }
-    }
-    return orderedParams;
-  }
-  jsToSqlValue(column, value) {
-    const typeDef = this.schema.properties[column];
-    if (!typeDef) {
-      return value;
-    }
-    if (value === null && this.isNullable(typeDef)) {
-      return null;
-    }
-    const actualType = this.getNonNullType(typeDef);
-    if (typeof actualType === "boolean") {
-      return value;
-    }
-    if (actualType.contentEncoding === "blob") {
-      if (value instanceof Uint8Array) {
-        return value;
-      }
-      if (typeof Buffer !== "undefined" && value instanceof Buffer) {
-        return new Uint8Array(value);
-      }
-      if (Array.isArray(value)) {
-        return new Uint8Array(value);
-      }
-      return value;
-    } else if (value instanceof Date) {
-      return value.toISOString();
-    } else {
-      return value;
-    }
-  }
-  sqlToJsValue(column, value) {
-    const typeDef = this.schema.properties[column];
-    if (!typeDef) {
-      return value;
-    }
-    if (value === null && this.isNullable(typeDef)) {
-      return null;
-    }
-    const actualType = this.getNonNullType(typeDef);
-    if (typeof actualType === "boolean") {
-      return value;
-    }
-    if (actualType.contentEncoding === "blob") {
-      if (typeof Buffer !== "undefined" && value instanceof Buffer) {
-        return new Uint8Array(value);
-      }
-      if (value instanceof Uint8Array) {
-        return value;
-      }
-      return value;
-    } else {
-      return value;
-    }
-  }
-  validateTableAndSchema() {
-    if (!/^[a-zA-Z][a-zA-Z0-9_]*$/.test(this.table)) {
-      throw new Error("Table name must start with a letter and contain only letters, digits, and underscores, got: " + this.table);
-    }
-    const validateSchemaKeys = (schema) => {
-      for (const key in schema.properties) {
-        if (!/^[a-zA-Z][a-zA-Z0-9_]*$/.test(key)) {
-          throw new Error("Schema keys must start with a letter and contain only letters, digits, and underscores, got: " + key);
-        }
-      }
-    };
-    validateSchemaKeys(this.primaryKeySchema);
-    validateSchemaKeys(this.valueSchema);
-    const primaryKeys = new Set(Object.keys(this.primaryKeySchema.properties));
-    const valueKeys = Object.keys(this.valueSchema.properties);
-    const duplicates = valueKeys.filter((key) => primaryKeys.has(key));
-    if (duplicates.length > 0) {
-      throw new Error(`Duplicate keys found in schemas: ${duplicates.join(", ")}`);
-    }
-  }
-}
-
-// src/tabular/SupabaseTabularStorage.ts
-var SUPABASE_TABULAR_REPOSITORY = createServiceToken14("storage.tabularRepository.supabase");
-
-class SupabaseTabularStorage extends BaseSqlTabularStorage {
-  client;
-  realtimeChannel = null;
-  constructor(client, table = "tabular_store", schema, primaryKeyNames, indexes = [], clientProvidedKeys = "if-missing") {
-    super(table, schema, primaryKeyNames, indexes, clientProvidedKeys);
-    this.client = client;
-  }
-  async setupDatabase() {
-    const sql = `
-      CREATE TABLE IF NOT EXISTS "${this.table}" (
-        ${this.constructPrimaryKeyColumns('"')} ${this.constructValueColumns('"')},
-        PRIMARY KEY (${this.primaryKeyColumnList()}) 
-      )
-    `;
-    const { error } = await this.client.rpc("exec_sql", { query: sql });
-    if (error && !error.message.includes("already exists")) {
-      throw error;
-    }
-    const pkColumns = this.primaryKeyColumns();
-    const createdIndexes = new Set;
-    for (const columns of this.indexes) {
-      if (columns.length <= pkColumns.length) {
-        const isPkPrefix = columns.every((col, idx) => col === pkColumns[idx]);
-        if (isPkPrefix)
-          continue;
-      }
-      const indexName = `${this.table}_${columns.join("_")}`;
-      const columnList = columns.map((col) => `"${String(col)}"`).join(", ");
-      const columnKey = columns.join(",");
-      if (createdIndexes.has(columnKey))
-        continue;
-      const isRedundant = Array.from(createdIndexes).some((existing) => {
-        const existingCols = existing.split(",");
-        return existingCols.length >= columns.length && columns.every((col, idx) => col === existingCols[idx]);
-      });
-      if (!isRedundant) {
-        const indexSql = `CREATE INDEX IF NOT EXISTS "${indexName}" ON "${this.table}" (${columnList})`;
-        const { error: indexError } = await this.client.rpc("exec_sql", { query: indexSql });
-        if (indexError && !indexError.message.includes("already exists")) {
-          console.warn(`Failed to create index ${indexName}:`, indexError);
-        }
-        createdIndexes.add(columnKey);
-      }
-    }
-  }
-  mapTypeToSQL(typeDef) {
-    const actualType = this.getNonNullType(typeDef);
-    if (typeof actualType === "boolean") {
-      return "TEXT /* boolean schema */";
-    }
-    if (actualType.contentEncoding === "blob")
-      return "BYTEA";
-    switch (actualType.type) {
-      case "string":
-        if (actualType.format === "date-time")
-          return "TIMESTAMP";
-        if (actualType.format === "date")
-          return "DATE";
-        if (actualType.format === "email")
-          return "VARCHAR(255)";
-        if (actualType.format === "uri")
-          return "VARCHAR(2048)";
-        if (actualType.format === "uuid")
-          return "UUID";
-        if (typeof actualType.maxLength === "number") {
-          return `VARCHAR(${actualType.maxLength})`;
-        }
-        return "TEXT";
-      case "number":
-      case "integer":
-        if (actualType.multipleOf === 1 || actualType.type === "integer") {
-          if (typeof actualType.minimum === "number") {
-            if (actualType.minimum >= 0) {
-              if (typeof actualType.maximum === "number") {
-                if (actualType.maximum <= 32767)
-                  return "SMALLINT";
-                if (actualType.maximum <= 2147483647)
-                  return "INTEGER";
-              }
-              return "BIGINT";
-            }
-          }
-          return "INTEGER";
-        }
-        if (actualType.format === "float")
-          return "REAL";
-        if (actualType.format === "double")
-          return "DOUBLE PRECISION";
-        if (typeof actualType.multipleOf === "number") {
-          const decimalPlaces = String(actualType.multipleOf).split(".")[1]?.length || 0;
-          if (decimalPlaces > 0) {
-            return `NUMERIC(38, ${decimalPlaces})`;
-          }
-        }
-        return "NUMERIC";
-      case "boolean":
-        return "BOOLEAN";
-      case "array":
-        if (actualType.items && typeof actualType.items === "object" && !Array.isArray(actualType.items)) {
-          const itemType = this.mapTypeToSQL(actualType.items);
-          const supportedArrayElementTypes = [
-            "TEXT",
-            "VARCHAR",
-            "CHAR",
-            "INTEGER",
-            "SMALLINT",
-            "BIGINT",
-            "REAL",
-            "DOUBLE PRECISION",
-            "NUMERIC",
-            "BOOLEAN",
-            "UUID",
-            "DATE",
-            "TIMESTAMP"
-          ];
-          const isSupported = supportedArrayElementTypes.some((type) => itemType === type || itemType.startsWith(type + "(") && type !== "VARCHAR");
-          if (isSupported) {
-            return `${itemType}[]`;
-          } else {
-            return "JSONB /* complex array */";
-          }
-        }
-        return "JSONB /* generic array */";
-      case "object":
-        return "JSONB /* object */";
-      default:
-        return "TEXT /* unknown type */";
-    }
-  }
-  constructPrimaryKeyColumns($delimiter = "") {
-    const cols = Object.entries(this.primaryKeySchema.properties).map(([key, typeDef]) => {
-      if (this.isAutoGeneratedKey(key)) {
-        if (this.autoGeneratedKeyStrategy === "autoincrement") {
-          const sqlType2 = this.mapTypeToSQL(typeDef);
-          const isSmallInt = sqlType2.includes("SMALLINT");
-          const isBigInt = sqlType2.includes("BIGINT");
-          const serialType = isBigInt ? "BIGSERIAL" : isSmallInt ? "SMALLSERIAL" : "SERIAL";
-          return `${$delimiter}${key}${$delimiter} ${serialType}`;
-        } else if (this.autoGeneratedKeyStrategy === "uuid") {
-          return `${$delimiter}${key}${$delimiter} UUID DEFAULT gen_random_uuid()`;
-        }
-      }
-      const sqlType = this.mapTypeToSQL(typeDef);
-      let constraints = "NOT NULL";
-      if (this.shouldBeUnsigned(typeDef)) {
-        constraints += ` CHECK (${$delimiter}${key}${$delimiter} >= 0)`;
-      }
-      return `${$delimiter}${key}${$delimiter} ${sqlType} ${constraints}`;
-    }).join(", ");
-    return cols;
-  }
-  constructValueColumns($delimiter = "") {
-    const delimiter = $delimiter || '"';
-    const requiredSet = new Set(this.valueSchema.required ?? []);
-    const cols = Object.entries(this.valueSchema.properties).map(([key, typeDef]) => {
-      const sqlType = this.mapTypeToSQL(typeDef);
-      const isRequired = requiredSet.has(key);
-      const nullable = !isRequired || this.isNullable(typeDef);
-      let constraints = nullable ? "NULL" : "NOT NULL";
-      if (this.shouldBeUnsigned(typeDef)) {
-        constraints += ` CHECK (${delimiter}${key}${delimiter} >= 0)`;
-      }
-      return `${delimiter}${key}${delimiter} ${sqlType} ${constraints}`;
-    }).join(", ");
-    if (cols.length > 0) {
-      return `, ${cols}`;
-    } else {
-      return "";
-    }
-  }
-  sqlToJsValue(column, value) {
-    const typeDef = this.schema.properties[column];
-    if (typeDef) {
-      if (value === null && this.isNullable(typeDef)) {
-        return null;
-      }
-      const actualType = this.getNonNullType(typeDef);
-      if (typeof actualType !== "boolean" && (actualType.type === "number" || actualType.type === "integer")) {
-        if (typeof value === "number")
-          return value;
-        if (typeof value === "string") {
-          const parsed = Number(value);
-          if (!isNaN(parsed))
-            return parsed;
-        }
-      }
-    }
-    return super.sqlToJsValue(column, value);
-  }
-  shouldBeUnsigned(typeDef) {
-    const actualType = this.getNonNullType(typeDef);
-    if (typeof actualType === "boolean") {
-      return false;
-    }
-    if ((actualType.type === "number" || actualType.type === "integer") && typeof actualType.minimum === "number" && actualType.minimum >= 0) {
-      return true;
-    }
-    return false;
-  }
-  async put(entity) {
-    let entityToInsert = { ...entity };
-    if (this.hasAutoGeneratedKey() && this.autoGeneratedKeyName) {
-      const keyName = String(this.autoGeneratedKeyName);
-      const entityRecord = entity;
-      const clientProvidedValue = entityRecord[keyName];
-      const hasClientValue = clientProvidedValue !== undefined && clientProvidedValue !== null;
-      let shouldOmitKey = false;
-      if (this.clientProvidedKeys === "never") {
-        shouldOmitKey = true;
-      } else if (this.clientProvidedKeys === "always") {
-        if (!hasClientValue) {
-          throw new Error(`Auto-generated key "${keyName}" is required when clientProvidedKeys is "always"`);
-        }
-        shouldOmitKey = false;
-      } else {
-        shouldOmitKey = !hasClientValue;
-      }
-      if (shouldOmitKey) {
-        delete entityToInsert[keyName];
-      }
-    }
-    const normalizedEntity = { ...entityToInsert };
-    const requiredSet = new Set(this.valueSchema.required ?? []);
-    for (const key in this.valueSchema.properties) {
-      if (!(key in normalizedEntity) || normalizedEntity[key] === undefined) {
-        if (!requiredSet.has(key)) {
-          normalizedEntity[key] = null;
-        }
-      }
-    }
-    const { data, error } = await this.client.from(this.table).upsert(normalizedEntity, { onConflict: this.primaryKeyColumnList() }).select().single();
-    if (error)
-      throw error;
-    const updatedEntity = data;
-    const updatedRecord = updatedEntity;
-    for (const key in this.schema.properties) {
-      updatedRecord[key] = this.sqlToJsValue(key, updatedRecord[key]);
-    }
-    this.events.emit("put", updatedEntity);
-    return updatedEntity;
-  }
-  async putBulk(entities) {
-    if (entities.length === 0)
-      return [];
-    return await Promise.all(entities.map((entity) => this.put(entity)));
-  }
-  async get(key) {
-    let query = this.client.from(this.table).select("*");
-    const keyRecord = key;
-    for (const pkName of this.primaryKeyNames) {
-      query = query.eq(String(pkName), keyRecord[String(pkName)]);
-    }
-    const { data, error } = await query.single();
-    if (error) {
-      if (error.code === "PGRST116") {
-        this.events.emit("get", key, undefined);
-        return;
-      }
-      throw error;
-    }
-    const val = data;
-    if (val) {
-      const valRecord = val;
-      for (const key2 in this.schema.properties) {
-        valRecord[key2] = this.sqlToJsValue(key2, valRecord[key2]);
-      }
-    }
-    this.events.emit("get", key, val);
-    return val;
-  }
-  async delete(value) {
-    const { key } = this.separateKeyValueFromCombined(value);
-    let query = this.client.from(this.table).delete();
-    const deleteKeyRecord = key;
-    for (const pkName of this.primaryKeyNames) {
-      query = query.eq(String(pkName), deleteKeyRecord[String(pkName)]);
-    }
-    const { error } = await query;
-    if (error)
-      throw error;
-    this.events.emit("delete", key);
-  }
-  async getAll(options) {
-    this.validateGetAllOptions(options);
-    let query = this.client.from(this.table).select("*");
-    if (options?.orderBy) {
-      for (const { column, direction } of options.orderBy) {
-        query = query.order(String(column), { ascending: direction === "ASC" });
-      }
-    }
-    if (options?.offset !== undefined || options?.limit !== undefined) {
-      const start = options?.offset ?? 0;
-      if (options?.limit !== undefined) {
-        query = query.range(start, start + options.limit - 1);
-      } else if (options?.offset !== undefined) {
-        query = query.range(start, start + 999999);
-      }
-    }
-    const { data, error } = await query;
-    if (error)
-      throw error;
-    if (data && data.length) {
-      for (const row of data) {
-        const record = row;
-        for (const key in this.schema.properties) {
-          record[key] = this.sqlToJsValue(key, record[key]);
-        }
-      }
-      return data;
-    }
-    return;
-  }
-  async deleteAll() {
-    const firstPkColumn = this.primaryKeyNames[0];
-    const { error } = await this.client.from(this.table).delete().neq(String(firstPkColumn), null);
-    if (error)
-      throw error;
-    this.events.emit("clearall");
-  }
-  async size() {
-    const { count, error } = await this.client.from(this.table).select("*", { count: "exact", head: true });
-    if (error)
-      throw error;
-    return count ?? 0;
-  }
-  async getBulk(offset, limit) {
-    let query = this.client.from(this.table).select("*");
-    for (const pkName of this.primaryKeyNames) {
-      query = query.order(String(pkName));
-    }
-    const { data, error } = await query.range(offset, offset + limit - 1);
-    if (error)
-      throw error;
-    if (!data || data.length === 0) {
-      return;
-    }
-    for (const row of data) {
-      const record = row;
-      for (const key in this.schema.properties) {
-        record[key] = this.sqlToJsValue(key, record[key]);
-      }
-    }
-    return data;
-  }
-  applyCriteriaToFilter(query, criteria) {
-    let q = query;
-    for (const column of Object.keys(criteria)) {
-      const criterion = criteria[column];
-      let operator = "=";
-      let value;
-      if (isSearchCondition(criterion)) {
-        operator = criterion.operator;
-        value = criterion.value;
-      } else {
-        value = criterion;
-      }
-      switch (operator) {
-        case "=":
-          q = q.eq(String(column), value);
-          break;
-        case "<":
-          q = q.lt(String(column), value);
-          break;
-        case "<=":
-          q = q.lte(String(column), value);
-          break;
-        case ">":
-          q = q.gt(String(column), value);
-          break;
-        case ">=":
-          q = q.gte(String(column), value);
-          break;
-      }
-    }
-    return q;
-  }
-  async count(criteria) {
-    if (!criteria || Object.keys(criteria).length === 0) {
-      return await this.size();
-    }
-    this.validateQueryParams(criteria);
-    const query = this.applyCriteriaToFilter(this.client.from(this.table).select("*", { count: "exact", head: true }), criteria);
-    const { count, error } = await query;
-    if (error)
-      throw error;
-    return count ?? 0;
-  }
-  async deleteSearch(criteria) {
-    const criteriaKeys = Object.keys(criteria);
-    if (criteriaKeys.length === 0) {
-      return;
-    }
-    let query = this.client.from(this.table).delete();
-    for (const column of criteriaKeys) {
-      if (!(column in this.schema.properties)) {
-        throw new Error(`Schema must have a ${String(column)} field to use deleteSearch`);
-      }
-      const criterion = criteria[column];
-      let operator = "=";
-      let value;
-      if (isSearchCondition(criterion)) {
-        operator = criterion.operator;
-        value = criterion.value;
-      } else {
-        value = criterion;
-      }
-      switch (operator) {
-        case "=":
-          query = query.eq(String(column), value);
-          break;
-        case "<":
-          query = query.lt(String(column), value);
-          break;
-        case "<=":
-          query = query.lte(String(column), value);
-          break;
-        case ">":
-          query = query.gt(String(column), value);
-          break;
-        case ">=":
-          query = query.gte(String(column), value);
-          break;
-      }
-    }
-    const { error } = await query;
-    if (error)
-      throw error;
-    this.events.emit("delete", criteriaKeys[0]);
-  }
-  async query(criteria, options) {
-    this.validateQueryParams(criteria, options);
-    let query = this.applyCriteriaToFilter(this.client.from(this.table).select("*"), criteria);
-    if (options?.orderBy) {
-      for (const { column, direction } of options.orderBy) {
-        query = query.order(String(column), { ascending: direction === "ASC" });
-      }
-    }
-    if (options?.offset !== undefined || options?.limit !== undefined) {
-      const start = options?.offset ?? 0;
-      if (options?.limit !== undefined) {
-        query = query.range(start, start + options.limit - 1);
-      } else if (options?.offset !== undefined) {
-        query = query.range(start, start + 999999);
-      }
-    } else if (options?.limit !== undefined) {
-      query = query.limit(options.limit);
-    }
-    const { data, error } = await query;
-    if (error)
-      throw error;
-    if (data && data.length > 0) {
-      for (const row of data) {
-        const record = row;
-        for (const key in this.schema.properties) {
-          record[key] = this.sqlToJsValue(key, record[key]);
-        }
-      }
-      this.events.emit("query", criteria, data);
-      return data;
-    }
-    this.events.emit("query", criteria, undefined);
-    return;
-  }
-  async queryIndex(criteria, options) {
-    this.validateSelect(options);
-    this.validateQueryParams(criteria, options);
-    const registered = this.indexes.map((cols, i) => {
-      const cs = Array.isArray(cols) ? cols : [cols];
-      return { name: `idx_${i}`, keyPath: cs };
-    });
-    pickCoveringIndex({
-      table: this.table,
-      indexes: registered,
-      criteriaColumns: Object.keys(criteria),
-      orderByColumns: (options.orderBy ?? []).map((o) => ({
-        column: String(o.column),
-        direction: o.direction
-      })),
-      selectColumns: options.select.map(String),
-      primaryKeyColumns: this.primaryKeyNames.map(String)
-    });
-    const colList = options.select.map(String).join(",");
-    let q = this.applyCriteriaToFilter(this.client.from(this.table).select(colList), criteria);
-    if (options.orderBy) {
-      for (const { column, direction } of options.orderBy) {
-        q = q.order(String(column), { ascending: direction === "ASC" });
-      }
-    }
-    if (options.offset !== undefined && options.limit === undefined) {
-      throw new StorageValidationError("queryIndex with offset requires limit (no implicit cap)");
-    }
-    if (options.offset !== undefined || options.limit !== undefined) {
-      const start = options.offset ?? 0;
-      if (options.limit !== undefined) {
-        q = q.range(start, start + options.limit - 1);
-      }
-    }
-    const { data, error } = await q;
-    if (error)
-      throw error;
-    if (!data)
-      return [];
-    const rows = data;
-    const sel = new Set(options.select.map(String));
-    for (const row of rows) {
-      for (const key of Object.keys(row)) {
-        if (sel.has(key)) {
-          row[key] = this.sqlToJsValue(key, row[key]);
-        }
-      }
-    }
-    return rows;
-  }
-  convertRealtimeRow(row) {
-    const entity = { ...row };
-    const record = entity;
-    for (const key in this.schema.properties) {
-      record[key] = this.sqlToJsValue(key, row[key]);
-    }
-    return entity;
-  }
-  subscribeToChanges(callback, options) {
-    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/IndexedDbKvStorage.ts
-import { createServiceToken as createServiceToken15 } from "@workglow/util";
-var IDB_KV_REPOSITORY = createServiceToken15("storage.kvRepository.indexedDb");
-
-class IndexedDbKvStorage extends KvViaTabularStorage {
-  dbName;
-  tabularRepository;
-  constructor(dbName, keySchema = { type: "string" }, valueSchema = {}) {
-    super(keySchema, valueSchema);
-    this.dbName = dbName;
-    this.tabularRepository = new IndexedDbTabularStorage(dbName, DefaultKeyValueSchema, DefaultKeyValueKey);
-  }
-}
-// src/kv/SupabaseKvStorage.ts
-import { createServiceToken as createServiceToken16 } from "@workglow/util";
-var SUPABASE_KV_REPOSITORY = createServiceToken16("storage.kvRepository.supabase");
-
-class SupabaseKvStorage extends KvViaTabularStorage {
-  client;
-  tableName;
-  tabularRepository;
-  constructor(client, tableName, keySchema = { type: "string" }, valueSchema = {}, tabularRepository) {
-    super(keySchema, valueSchema);
-    this.client = client;
-    this.tableName = tableName;
-    this.tabularRepository = tabularRepository ?? new SupabaseTabularStorage(client, tableName, DefaultKeyValueSchema, DefaultKeyValueKey);
-  }
-}
-// src/queue/IndexedDbQueueStorage.ts
-import { createServiceToken as createServiceToken17, deepEqual as deepEqual3, makeFingerprint as makeFingerprint6, uuid4 as uuid45 } from "@workglow/util";
-var INDEXED_DB_QUEUE_STORAGE = createServiceToken17("jobqueue.storage.indexedDb");
-
-class IndexedDbQueueStorage {
-  queueName;
-  scope = "process";
-  db;
-  tableName;
-  migrationOptions;
-  prefixes;
-  prefixValues;
-  hybridManager = null;
-  hybridOptions;
-  constructor(queueName, options = {}) {
-    this.queueName = queueName;
-    this.migrationOptions = options;
-    this.prefixes = options.prefixes ?? [];
-    this.prefixValues = options.prefixValues ?? {};
-    this.hybridOptions = {
-      useBroadcastChannel: options.useBroadcastChannel ?? true,
-      backupPollingIntervalMs: options.backupPollingIntervalMs ?? 5000
-    };
-    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)
-      return this.db;
-    await this.setupDatabase();
-    return this.db;
-  }
-  async setupDatabase() {
-    const prefixColumnNames = this.getPrefixColumnNames();
-    const buildKeyPath = (basePath) => {
-      return [...prefixColumnNames, ...basePath];
-    };
-    const expectedIndexes = [
-      {
-        name: "queue_status",
-        keyPath: buildKeyPath(["queue", "status"]),
-        options: { unique: false }
-      },
-      {
-        name: "queue_status_run_after",
-        keyPath: buildKeyPath(["queue", "status", "run_after"]),
-        options: { unique: false }
-      },
-      {
-        name: "queue_job_run_id",
-        keyPath: buildKeyPath(["queue", "job_run_id"]),
-        options: { unique: false }
-      },
-      {
-        name: "queue_fingerprint_status",
-        keyPath: buildKeyPath(["queue", "fingerprint", "status"]),
-        options: { unique: false }
-      }
-    ];
-    this.db = await ensureIndexedDbTable(this.tableName, "id", expectedIndexes, this.migrationOptions);
-  }
-  async add(job) {
-    const db = await this.getDb();
-    const now = new Date().toISOString();
-    const jobWithPrefixes = job;
-    jobWithPrefixes.id = jobWithPrefixes.id ?? uuid45();
-    jobWithPrefixes.job_run_id = jobWithPrefixes.job_run_id ?? uuid45();
-    jobWithPrefixes.queue = this.queueName;
-    jobWithPrefixes.fingerprint = await makeFingerprint6(jobWithPrefixes.input);
-    jobWithPrefixes.status = JobStatus.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(jobWithPrefixes);
-      tx.oncomplete = () => {
-        this.hybridManager?.notifyLocalChange();
-        resolve(jobWithPrefixes.id);
-      };
-      tx.onerror = () => reject(tx.error);
-      request.onerror = () => reject(request.error);
-    });
-  }
-  async get(id) {
-    const db = await this.getDb();
-    const tx = db.transaction(this.tableName, "readonly");
-    const store = tx.objectStore(this.tableName);
-    const request = store.get(id);
-    return new Promise((resolve, reject) => {
-      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);
-    });
-  }
-  async peek(status = JobStatus.PENDING, num = 100) {
-    const db = await this.getDb();
-    const tx = db.transaction(this.tableName, "readonly");
-    const store = tx.objectStore(this.tableName);
-    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([...prefixKeyValues, this.queueName, status, ""], [...prefixKeyValues, this.queueName, status, "￿"]);
-      const cursorRequest = index.openCursor(keyRange);
-      const handleCursor = (e) => {
-        const cursor = e.target.result;
-        if (!cursor || ret.size >= num) {
-          resolve(Array.from(ret.values()));
-          return;
-        }
-        const job = cursor.value;
-        if (this.matchesPrefixes(job)) {
-          ret.set(cursor.value.id, cursor.value);
-        }
-        cursor.continue();
-      };
-      cursorRequest.onsuccess = handleCursor;
-      cursorRequest.onerror = () => reject(cursorRequest.error);
-      tx.onerror = () => reject(tx.error);
-    });
-  }
-  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("queue_status_run_after");
-    const now = new Date().toISOString();
-    const prefixKeyValues = this.getPrefixKeyValues();
-    const claimToken = workerId;
-    const jobToReturn = await new Promise((resolve, reject) => {
-      const cursorRequest = index.openCursor(IDBKeyRange.bound([...prefixKeyValues, this.queueName, JobStatus.PENDING, ""], [...prefixKeyValues, this.queueName, JobStatus.PENDING, now], false, false));
-      let claimedJob;
-      let cursorStopped = false;
-      cursorRequest.onsuccess = (e) => {
-        const cursor = e.target.result;
-        if (!cursor) {
-          return;
-        }
-        if (cursorStopped) {
-          return;
-        }
-        const job = cursor.value;
-        if (job.queue !== this.queueName || job.status !== JobStatus.PENDING || !this.matchesPrefixes(job)) {
-          cursor.continue();
-          return;
-        }
-        job.status = JobStatus.PROCESSING;
-        job.last_ran_at = now;
-        job.worker_id = claimToken;
-        try {
-          const updateRequest = store.put(job);
-          updateRequest.onsuccess = () => {
-            claimedJob = job;
-            cursorStopped = true;
-          };
-          updateRequest.onerror = (err) => {
-            console.error("Failed to update job status:", err);
-            cursor.continue();
-          };
-        } catch (err) {
-          console.error("Error updating job:", err);
-          cursor.continue();
-        }
-      };
-      cursorRequest.onerror = () => reject(cursorRequest.error);
-      tx.oncomplete = () => {
-        if (claimedJob) {
-          this.hybridManager?.notifyLocalChange();
-        }
-        resolve(claimedJob);
-      };
-      tx.onerror = () => reject(tx.error);
-    });
-    if (!jobToReturn) {
-      return;
-    }
-    const verifiedJob = await this.get(jobToReturn.id);
-    if (!verifiedJob) {
-      return;
-    }
-    if (verifiedJob.worker_id !== claimToken) {
-      return;
-    }
-    if (verifiedJob.status !== JobStatus.PROCESSING) {
-      return;
-    }
-    return verifiedJob;
-  }
-  async size(status = JobStatus.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("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);
-    });
-  }
-  async complete(job) {
-    const db = await this.getDb();
-    const tx = db.transaction(this.tableName, "readwrite");
-    const store = tx.objectStore(this.tableName);
-    return new Promise((resolve, reject) => {
-      const getReq = store.get(job.id);
-      getReq.onsuccess = () => {
-        const existing = getReq.result;
-        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;
-        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);
-      };
-      getReq.onerror = () => reject(getReq.error);
-      tx.oncomplete = () => {
-        this.hybridManager?.notifyLocalChange();
-        resolve();
-      };
-      tx.onerror = () => reject(tx.error);
-    });
-  }
-  async release(id) {
-    const job = await this.get(id);
-    if (!job)
-      return;
-    job.status = JobStatus.PENDING;
-    job.worker_id = null;
-    job.progress = 0;
-    job.progress_message = "";
-    job.progress_details = null;
-    await this.put(job);
-  }
-  async abort(id) {
-    const job = await this.get(id);
-    if (!job)
-      return;
-    job.status = JobStatus.ABORTING;
-    await this.complete(job);
-  }
-  async getByRunId(job_run_id) {
-    const db = await this.getDb();
-    const tx = db.transaction(this.tableName, "readonly");
-    const store = tx.objectStore(this.tableName);
-    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 = () => {
-        const results = (request.result || []).filter((job) => this.matchesPrefixes(job));
-        resolve(results);
-      };
-      request.onerror = () => reject(request.error);
-      tx.onerror = () => reject(tx.error);
-    });
-  }
-  async deleteAll() {
-    const db = await this.getDb();
-    const tx = db.transaction(this.tableName, "readwrite");
-    const store = tx.objectStore(this.tableName);
-    const index = store.index("queue_status");
-    const prefixKeyValues = this.getPrefixKeyValues();
-    return new Promise((resolve, reject) => {
-      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 = () => {
-        this.hybridManager?.notifyLocalChange();
-        resolve();
-      };
-      tx.onerror = () => reject(tx.error);
-      request.onerror = () => reject(request.error);
-    });
-  }
-  async outputForInput(input) {
-    const fingerprint = await makeFingerprint6(input);
-    const db = await this.getDb();
-    const tx = db.transaction(this.tableName, "readonly");
-    const store = tx.objectStore(this.tableName);
-    const index = store.index("queue_fingerprint_status");
-    const prefixKeyValues = this.getPrefixKeyValues();
-    const request = index.get([
-      ...prefixKeyValues,
-      this.queueName,
-      fingerprint,
-      JobStatus.COMPLETED
-    ]);
-    return new Promise((resolve, reject) => {
-      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);
-    });
-  }
-  async saveProgress(id, progress, message, details) {
-    const job = await this.get(id);
-    if (!job)
-      throw new Error(`Job ${id} not found`);
-    job.progress = progress;
-    job.progress_message = message;
-    job.progress_details = details;
-    await this.put(job);
-  }
-  async put(job) {
-    const db = await this.getDb();
-    const tx = db.transaction(this.tableName, "readwrite");
-    const store = tx.objectStore(this.tableName);
-    job.queue = this.queueName;
-    const jobWithPrefixes = job;
-    for (const [key, value] of Object.entries(this.prefixValues)) {
-      jobWithPrefixes[key] = value;
-    }
-    return new Promise((resolve, reject) => {
-      const putReq = store.put(jobWithPrefixes);
-      putReq.onerror = () => reject(putReq.error);
-      tx.oncomplete = () => {
-        this.hybridManager?.notifyLocalChange();
-        resolve();
-      };
-      tx.onerror = () => reject(tx.error);
-    });
-  }
-  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);
-    const request = store.delete(id);
-    return new Promise((resolve, reject) => {
-      request.onsuccess = () => resolve();
-      request.onerror = () => reject(request.error);
-      tx.oncomplete = () => {
-        this.hybridManager?.notifyLocalChange();
-      };
-      tx.onerror = () => reject(tx.error);
-    });
-  }
-  async deleteJobsByStatusAndAge(status, olderThanMs) {
-    const db = await this.getDb();
-    const tx = db.transaction(this.tableName, "readwrite");
-    const store = tx.objectStore(this.tableName);
-    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(keyRange);
-      request.onsuccess = (event) => {
-        const cursor = event.target.result;
-        if (cursor) {
-          const job = cursor.value;
-          if (job.queue === this.queueName && this.matchesPrefixes(job) && job.status === status && job.completed_at && job.completed_at <= cutoffDate) {
-            cursor.delete();
-          }
-          cursor.continue();
-        }
-      };
-      tx.oncomplete = () => {
-        this.hybridManager?.notifyLocalChange();
-        resolve();
-      };
-      tx.onerror = () => reject(tx.error);
-      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;
-  }
-  getHybridManager() {
-    if (!this.hybridManager) {
-      const channelName = `indexeddb-queue-${this.tableName}-${this.queueName}`;
-      this.hybridManager = new HybridSubscriptionManager(channelName, async () => {
-        const jobs = await this.getAllJobs();
-        return new Map(jobs.map((j) => [j.id, j]));
-      }, (a, b) => deepEqual3(a, b), {
-        insert: (item) => ({ type: "INSERT", new: item }),
-        update: (oldItem, newItem) => ({ type: "UPDATE", old: oldItem, new: newItem }),
-        delete: (item) => ({ type: "DELETE", old: item })
-      }, {
-        defaultIntervalMs: 1000,
-        useBroadcastChannel: this.hybridOptions.useBroadcastChannel,
-        backupPollingIntervalMs: this.hybridOptions.backupPollingIntervalMs
-      });
-    }
-    return this.hybridManager;
-  }
-  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 (!deepEqual3(old, 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.getHybridManager();
-    return manager.subscribe(callback, { intervalMs });
-  }
-  destroy() {
-    if (this.hybridManager) {
-      this.hybridManager.destroy();
-      this.hybridManager = null;
-    }
-  }
-}
-// src/queue/SupabaseQueueStorage.ts
-import { createServiceToken as createServiceToken18, deepEqual as deepEqual4, makeFingerprint as makeFingerprint7, uuid4 as uuid46 } from "@workglow/util";
-var SUPABASE_QUEUE_STORAGE = createServiceToken18("jobqueue.storage.supabase");
-
-class SupabaseQueueStorage {
-  queueName;
-  scope = "cluster";
-  client;
-  prefixes;
-  prefixValues;
-  tableName;
-  realtimeChannel = null;
-  pollingManager = null;
-  constructor(client, queueName, options) {
-    this.queueName = queueName;
-    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.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;
-  }
-  buildPrefixWhereSql() {
-    if (this.prefixes.length === 0) {
-      return "";
-    }
-    const conditions = this.prefixes.map((p) => {
-      const value = this.prefixValues[p.name];
-      if (p.type === "uuid") {
-        const validated = this.validateSqlValue(String(value), `prefix "${p.name}"`);
-        return `${p.name} = '${this.escapeSqlString(validated)}'`;
-      }
-      const numValue = Number(value ?? 0);
-      if (!Number.isFinite(numValue)) {
-        throw new Error(`Invalid numeric prefix value for "${p.name}": ${value}`);
-      }
-      return `${p.name} = ${numValue}`;
-    }).join(" AND ");
-    return " AND " + conditions;
-  }
-  static SAFE_SQL_VALUE_RE = /^[a-zA-Z0-9_\-.:]+$/;
-  validateSqlValue(value, context) {
-    if (!SupabaseQueueStorage.SAFE_SQL_VALUE_RE.test(value)) {
-      throw new Error(`Unsafe value for ${context}: "${value}". Values must match /^[a-zA-Z0-9_\\-.:]+$/.`);
-    }
-    return value;
-  }
-  escapeSqlString(value) {
-    return value.replace(/'/g, "''");
-  }
-  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,
-      output jsonb,
-      run_attempts integer default 0,
-      max_retries integer default 20,
-      run_after timestamp with time zone DEFAULT now(),
-      last_ran_at timestamp with time zone,
-      created_at timestamp with time zone DEFAULT now(),
-      deadline_at timestamp with time zone,
-      completed_at timestamp with time zone,
-      error text,
-      error_code text,
-      progress real DEFAULT 0,
-      progress_message text DEFAULT '',
-      progress_details jsonb,
-      worker_id text
-    )`;
-    const { error: tableError } = await this.client.rpc("exec_sql", { query: createTableSql });
-    if (tableError) {
-      if (tableError.code !== "42P07") {
-        throw tableError;
-      }
-    }
-    const indexes = [
-      `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) {
-      await this.client.rpc("exec_sql", { query: indexSql });
-    }
-  }
-  async add(job) {
-    const now = new Date().toISOString();
-    job.queue = this.queueName;
-    job.job_run_id = job.job_run_id ?? uuid46();
-    job.fingerprint = await makeFingerprint7(job.input);
-    job.status = JobStatus.PENDING;
-    job.progress = 0;
-    job.progress_message = "";
-    job.progress_details = null;
-    job.created_at = now;
-    job.run_after = now;
-    const prefixInsertValues = this.getPrefixInsertValues();
-    const { data, error } = await this.client.from(this.tableName).insert({
-      ...prefixInsertValues,
-      queue: job.queue,
-      fingerprint: job.fingerprint,
-      input: job.input,
-      run_after: job.run_after,
-      created_at: job.created_at,
-      deadline_at: job.deadline_at,
-      max_retries: job.max_retries,
-      job_run_id: job.job_run_id,
-      progress: job.progress,
-      progress_message: job.progress_message,
-      progress_details: job.progress_details
-    }).select("id").single();
-    if (error)
-      throw error;
-    if (!data)
-      throw new Error("Failed to add to queue");
-    job.id = data.id;
-    return job.id;
-  }
-  async get(id) {
-    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;
-      throw error;
-    }
-    return data;
-  }
-  async peek(status = JobStatus.PENDING, num = 100) {
-    num = Number(num) || 100;
-    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(workerId) {
-    const prefixConditions = this.buildPrefixWhereSql();
-    const validatedQueueName = this.validateSqlValue(this.queueName, "queueName");
-    const validatedWorkerId = this.validateSqlValue(workerId, "workerId");
-    const escapedQueueName = this.escapeSqlString(validatedQueueName);
-    const escapedWorkerId = this.escapeSqlString(validatedWorkerId);
-    const sql = `
-      UPDATE ${this.tableName}
-      SET status = '${JobStatus.PROCESSING}', last_ran_at = NOW() AT TIME ZONE 'UTC', worker_id = '${escapedWorkerId}'
-      WHERE id = (
-        SELECT id
-        FROM ${this.tableName}
-        WHERE queue = '${escapedQueueName}'
-        AND status = '${JobStatus.PENDING}'
-        ${prefixConditions}
-        AND run_after <= NOW() AT TIME ZONE 'UTC'
-        ORDER BY run_after ASC
-        FOR UPDATE SKIP LOCKED
-        LIMIT 1
-      )
-      RETURNING *`;
-    const { data, error } = await this.client.rpc("exec_sql", { query: sql });
-    if (error)
-      throw error;
-    if (!data || !Array.isArray(data) || data.length === 0) {
-      return;
-    }
-    return data[0];
-  }
-  async size(status = JobStatus.PENDING) {
-    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 === JobStatus.DISABLED) {
-      let query2 = this.client.from(this.tableName).update({
-        status: jobDetails.status,
-        progress: 100,
-        progress_message: "",
-        progress_details: null,
-        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;
-    }
-    let getQuery = this.client.from(this.tableName).select("run_attempts, max_retries").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 currentAttempts = current?.run_attempts ?? 0;
-    const maxRetries = current?.max_retries ?? jobDetails.max_retries ?? 10;
-    const nextAttempts = currentAttempts + 1;
-    if (jobDetails.status === JobStatus.PENDING) {
-      if (nextAttempts > maxRetries) {
-        let failQuery = this.client.from(this.tableName).update({
-          status: JobStatus.FAILED,
-          error: "Max retries reached",
-          error_code: "MAX_RETRIES_REACHED",
-          progress: 100,
-          progress_message: "",
-          progress_details: null,
-          completed_at: now,
-          last_ran_at: now
-        }).eq("id", jobDetails.id).eq("queue", this.queueName);
-        failQuery = this.applyPrefixFilters(failQuery);
-        const { error: failError } = await failQuery;
-        if (failError)
-          throw failError;
-        return;
-      }
-      let query2 = this.client.from(this.tableName).update({
-        error: jobDetails.error ?? null,
-        error_code: jobDetails.error_code ?? null,
-        status: jobDetails.status,
-        run_after: jobDetails.run_after,
-        progress: 0,
-        progress_message: "",
-        progress_details: null,
-        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 === JobStatus.COMPLETED || jobDetails.status === JobStatus.FAILED) {
-      let query2 = this.client.from(this.tableName).update({
-        output: jobDetails.output ?? null,
-        error: jobDetails.error ?? null,
-        error_code: jobDetails.error_code ?? null,
-        status: jobDetails.status,
-        progress: 100,
-        progress_message: "",
-        progress_details: null,
-        run_attempts: nextAttempts,
-        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;
-    }
-    let query = this.client.from(this.tableName).update({
-      status: jobDetails.status,
-      output: jobDetails.output ?? null,
-      error: jobDetails.error ?? null,
-      error_code: jobDetails.error_code ?? null,
-      run_after: jobDetails.run_after ?? null,
-      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 release(jobId) {
-    let query = this.client.from(this.tableName).update({
-      status: JobStatus.PENDING,
-      worker_id: null,
-      progress: 0,
-      progress_message: "",
-      progress_details: null
-    }).eq("id", jobId).eq("queue", this.queueName);
-    query = this.applyPrefixFilters(query);
-    const { error } = await query;
-    if (error)
-      throw error;
-  }
-  async deleteAll() {
-    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);
-    let query = this.client.from(this.tableName).select("output").eq("fingerprint", fingerprint).eq("queue", this.queueName).eq("status", JobStatus.COMPLETED);
-    query = this.applyPrefixFilters(query);
-    const { data, error } = await query.single();
-    if (error) {
-      if (error.code === "PGRST116")
-        return null;
-      throw error;
-    }
-    return data?.output ?? null;
-  }
-  async abort(jobId) {
-    let query = this.client.from(this.tableName).update({ status: JobStatus.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) {
-    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) {
-    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) {
-    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();
-    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) => deepEqual4(a, 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 (!deepEqual4(old, 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/queue-limiter/IndexedDbRateLimiterStorage.ts
-import { createServiceToken as createServiceToken19 } from "@workglow/util";
-var INDEXED_DB_RATE_LIMITER_STORAGE = createServiceToken19("ratelimiter.storage.indexedDb");
-
-class IndexedDbRateLimiterStorage {
-  scope = "process";
-  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 tryReserveExecution(queueName, maxExecutions, windowMs) {
-    const nextIso = await this.getNextAvailableTime(queueName);
-    if (nextIso && new Date(nextIso).getTime() > Date.now()) {
-      return null;
-    }
-    const execDb = await this.getExecutionDb();
-    const prefixKeyValues = this.getPrefixKeyValues();
-    const windowStartIso = new Date(Date.now() - windowMs).toISOString();
-    const execTx = execDb.transaction(this.executionTableName, "readwrite");
-    const execStore = execTx.objectStore(this.executionTableName);
-    const insertedId = crypto.randomUUID();
-    return new Promise((resolve, reject) => {
-      let liveCount = 0;
-      let didInsert = false;
-      const liveRange = IDBKeyRange.bound([...prefixKeyValues, queueName, windowStartIso], [...prefixKeyValues, queueName, "￿"], true, false);
-      const cursorReq = execStore.index("queue_executed_at").openCursor(liveRange);
-      cursorReq.onsuccess = (event) => {
-        const cursor = event.target.result;
-        if (cursor) {
-          const record2 = cursor.value;
-          if (this.matchesPrefixes(record2)) {
-            liveCount++;
-          }
-          cursor.continue();
-          return;
-        }
-        if (liveCount >= maxExecutions) {
-          execTx.abort();
-          return;
-        }
-        const record = {
-          id: insertedId,
-          queue_name: queueName,
-          executed_at: new Date().toISOString()
-        };
-        for (const [k, v] of Object.entries(this.prefixValues)) {
-          record[k] = v;
-        }
-        const addReq = execStore.add(record);
-        didInsert = true;
-        addReq.onerror = () => {
-          try {
-            execTx.abort();
-          } catch {}
-          reject(addReq.error);
-        };
-      };
-      cursorReq.onerror = () => reject(cursorReq.error);
-      execTx.oncomplete = () => resolve(didInsert ? insertedId : null);
-      execTx.onerror = () => reject(execTx.error);
-      execTx.onabort = () => resolve(null);
-    });
-  }
-  async releaseExecution(queueName, token) {
-    if (token === null || token === undefined)
-      return;
-    const db = await this.getExecutionDb();
-    const tx = db.transaction(this.executionTableName, "readwrite");
-    const store = tx.objectStore(this.executionTableName);
-    return new Promise((resolve, reject) => {
-      const req = store.delete(token);
-      req.onerror = () => reject(req.error);
-      tx.oncomplete = () => resolve();
-      tx.onerror = () => reject(tx.error);
-    });
-  }
-  async recordExecution(queueName) {
-    const db = await this.getExecutionDb();
-    const tx = db.transaction(this.executionTableName, "readwrite");
-    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/queue-limiter/SupabaseRateLimiterStorage.ts
-import { createServiceToken as createServiceToken20 } from "@workglow/util";
-var SUPABASE_RATE_LIMITER_STORAGE = createServiceToken20("ratelimiter.storage.supabase");
-
-class SupabaseRateLimiterStorage {
-  scope = "cluster";
-  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;
-    }
-    const fnName = this.atomicReserveFunctionName();
-    const prefixSig = this.prefixes.map((p) => `${p.name} ${this.getPrefixColumnType(p.type)}`).join(", ");
-    const prefixSigPrefix = prefixSig ? prefixSig + ", " : "";
-    const prefixWhere = this.prefixes.length > 0 ? " AND " + this.prefixes.map((p) => `${p.name} = _${p.name}`).join(" AND ") : "";
-    const prefixInsertCols = this.prefixes.length > 0 ? this.prefixes.map((p) => p.name).join(", ") + ", " : "";
-    const prefixInsertVals = this.prefixes.length > 0 ? this.prefixes.map((p) => `_${p.name}`).join(", ") + ", " : "";
-    const lockKeyParts = [`'${this.executionTableName}'`, ...this.prefixes.map((p) => `_${p.name}::text`), `_queue_name::text`];
-    const lockKeyExpr = `hashtextextended(${lockKeyParts.join(" || '|' || ")}, 0)`;
-    const createFnSql = `
-      CREATE OR REPLACE FUNCTION ${fnName}(
-        ${prefixSigPrefix}_queue_name TEXT, _window_start TIMESTAMPTZ, _max_exec INT
-      ) RETURNS BIGINT AS $fn$
-      DECLARE
-        _count INT;
-        _next TIMESTAMPTZ;
-        _new_id BIGINT;
-      BEGIN
-        PERFORM pg_advisory_xact_lock(${lockKeyExpr});
-        SELECT COUNT(*) INTO _count FROM ${this.executionTableName}
-          WHERE queue_name = _queue_name AND executed_at > _window_start${prefixWhere};
-        IF _count >= _max_exec THEN RETURN NULL; END IF;
-        SELECT next_available_at INTO _next FROM ${this.nextAvailableTableName}
-          WHERE queue_name = _queue_name${prefixWhere};
-        IF _next IS NOT NULL AND _next > NOW() THEN RETURN NULL; END IF;
-        INSERT INTO ${this.executionTableName} (${prefixInsertCols}queue_name)
-          VALUES (${prefixInsertVals}_queue_name)
-          RETURNING id INTO _new_id;
-        RETURN _new_id;
-      END;
-      $fn$ LANGUAGE plpgsql;
-    `;
-    const { error: fnError } = await this.client.rpc("exec_sql", { query: createFnSql });
-    if (fnError) {
-      throw fnError;
-    }
-  }
-  atomicReserveFunctionName() {
-    return `${this.executionTableName}_try_reserve`.slice(0, 63);
-  }
-  async tryReserveExecution(queueName, maxExecutions, windowMs) {
-    const args = {
-      _queue_name: queueName,
-      _window_start: new Date(Date.now() - windowMs).toISOString(),
-      _max_exec: maxExecutions
-    };
-    for (const p of this.prefixes) {
-      args[`_${p.name}`] = this.prefixValues[p.name];
-    }
-    const { data, error } = await this.client.rpc(this.atomicReserveFunctionName(), args);
-    if (error)
-      throw error;
-    if (data === null || data === undefined)
-      return null;
-    if (Array.isArray(data)) {
-      if (data.length === 0)
-        return null;
-      const first = Object.values(data[0])[0];
-      return first ?? null;
-    }
-    return data;
-  }
-  async releaseExecution(queueName, token) {
-    if (token === null || token === undefined)
-      return;
-    let del = this.client.from(this.executionTableName).delete().eq("id", token).eq("queue_name", queueName);
-    del = this.applyPrefixFilters(del);
-    const { error: delError } = await del;
-    if (delError)
-      throw delError;
-  }
-  async recordExecution(queueName) {
-    const prefixInsertValues = this.getPrefixInsertValues();
-    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/vector/IndexedDbVectorStorage.ts
-import { createServiceToken as createServiceToken21 } from "@workglow/util";
-import { cosineSimilarity as cosineSimilarity2 } from "@workglow/util/schema";
-var IDB_VECTOR_REPOSITORY = createServiceToken21("storage.vectorRepository.indexedDb");
-function matchesFilter2(metadata, filter) {
-  for (const [key, value] of Object.entries(filter)) {
-    if (metadata[key] !== value) {
-      return false;
-    }
-  }
-  return true;
-}
-function textRelevance2(text, query) {
-  const textLower = text.toLowerCase();
-  const queryLower = query.toLowerCase();
-  const queryWords = queryLower.split(/\s+/).filter((w) => w.length > 0);
-  if (queryWords.length === 0) {
-    return 0;
-  }
-  let matches = 0;
-  for (const word of queryWords) {
-    if (textLower.includes(word)) {
-      matches++;
-    }
-  }
-  return matches / queryWords.length;
-}
-
-class IndexedDbVectorStorage extends IndexedDbTabularStorage {
-  vectorDimensions;
-  vectorPropertyName;
-  metadataPropertyName;
-  constructor(table = "vectors", schema, primaryKeyNames, indexes = [], dimensions, _vectorCtor = Float32Array, migrationOptions = {}, clientProvidedKeys = "if-missing") {
-    super(table, schema, primaryKeyNames, indexes, migrationOptions, clientProvidedKeys);
-    this.vectorDimensions = dimensions;
-    const vectorProp = getVectorProperty(schema);
-    if (!vectorProp) {
-      throw new Error("Schema must have a property with type array and format TypedArray");
-    }
-    this.vectorPropertyName = vectorProp;
-    this.metadataPropertyName = getMetadataProperty(schema);
-  }
-  getVectorDimensions() {
-    return this.vectorDimensions;
-  }
-  async similaritySearch(query, options = {}) {
-    const { topK = 10, filter, scoreThreshold = 0 } = options;
-    const results = [];
-    const allEntities = await this.getAll() || [];
-    for (const entity of allEntities) {
-      const vector = entity[this.vectorPropertyName];
-      const metadata = this.metadataPropertyName ? entity[this.metadataPropertyName] : {};
-      if (filter && !matchesFilter2(metadata, filter)) {
-        continue;
-      }
-      const score = cosineSimilarity2(query, vector);
-      if (score < scoreThreshold) {
-        continue;
-      }
-      results.push({
-        ...entity,
-        score
-      });
-    }
-    results.sort((a, b) => b.score - a.score);
-    const topResults = results.slice(0, topK);
-    return topResults;
-  }
-  async hybridSearch(query, options) {
-    const { topK = 10, filter, scoreThreshold = 0, textQuery, vectorWeight = 0.7 } = options;
-    if (!textQuery || textQuery.trim().length === 0) {
-      return this.similaritySearch(query, { topK, filter, scoreThreshold });
-    }
-    const results = [];
-    const allEntities = await this.getAll() || [];
-    for (const entity of allEntities) {
-      const vector = entity[this.vectorPropertyName];
-      const metadata = this.metadataPropertyName ? entity[this.metadataPropertyName] : {};
-      if (filter && !matchesFilter2(metadata, filter)) {
-        continue;
-      }
-      const vectorScore = cosineSimilarity2(query, vector);
-      const metadataText = Object.values(metadata).join(" ").toLowerCase();
-      const textScore = textRelevance2(metadataText, textQuery);
-      const combinedScore = vectorWeight * vectorScore + (1 - vectorWeight) * textScore;
-      if (combinedScore < scoreThreshold) {
-        continue;
-      }
-      results.push({
-        ...entity,
-        score: combinedScore
-      });
-    }
-    results.sort((a, b) => b.score - a.score);
-    const topResults = results.slice(0, topK);
-    return topResults;
-  }
-}
 export {
-  traced,
   registerTabularRepository,
   pickCoveringIndex,
   isSearchCondition,
@@ -6246,18 +2472,11 @@ export {
   getTabularRepository,
   getMetadataProperty,
   getGlobalTabularRepositories,
-  ensureIndexedDbTable,
-  dropIndexedDbTable,
   TelemetryVectorStorage,
   TelemetryTabularStorage,
-  TelemetryQueueStorage,
   TelemetryKvStorage,
   TABULAR_REPOSITORY,
   TABULAR_REPOSITORIES,
-  SupabaseTabularStorage,
-  SupabaseRateLimiterStorage,
-  SupabaseQueueStorage,
-  SupabaseKvStorage,
   StorageValidationError,
   StorageUnsupportedError,
   StorageInvalidLimitError,
@@ -6265,13 +2484,7 @@ export {
   StorageError,
   StorageEmptyCriteriaError,
   SharedInMemoryTabularStorage,
-  SUPABASE_TABULAR_REPOSITORY,
-  SUPABASE_RATE_LIMITER_STORAGE,
-  SUPABASE_QUEUE_STORAGE,
-  SUPABASE_KV_REPOSITORY,
   SHARED_IN_MEMORY_TABULAR_REPOSITORY,
-  RATE_LIMITER_STORAGE,
-  QUEUE_STORAGE,
   PollingSubscriptionManager,
   MEMORY_TABULAR_REPOSITORY,
   MEMORY_KV_REPOSITORY,
@@ -6279,24 +2492,9 @@ export {
   KvViaTabularStorage,
   KvStorage,
   KV_REPOSITORY,
-  JobStatus,
-  IndexedDbVectorStorage,
-  IndexedDbTabularStorage,
-  IndexedDbRateLimiterStorage,
-  IndexedDbQueueStorage,
-  IndexedDbKvStorage,
   InMemoryVectorStorage,
   InMemoryTabularStorage,
-  InMemoryRateLimiterStorage,
-  InMemoryQueueStorage,
   InMemoryKvStorage,
-  IN_MEMORY_RATE_LIMITER_STORAGE,
-  IN_MEMORY_QUEUE_STORAGE,
-  INDEXED_DB_RATE_LIMITER_STORAGE,
-  INDEXED_DB_QUEUE_STORAGE,
-  IDB_VECTOR_REPOSITORY,
-  IDB_TABULAR_REPOSITORY,
-  IDB_KV_REPOSITORY,
   HybridSubscriptionManager,
   HuggingFaceTabularStorage,
   HF_TABULAR_REPOSITORY,
@@ -6306,7 +2504,8 @@ export {
   CoveringIndexMissingError,
   CachedTabularStorage,
   CACHED_TABULAR_REPOSITORY,
-  BaseTabularStorage
+  BaseTabularStorage,
+  BaseSqlTabularStorage
 };
 
-//# debugId=E2D716C3197417F164756E2164756E21
+//# debugId=23715A15DDE7420E64756E2164756E21