@workglow/storage 0.0.52

package/dist/browser.js

@@ -0,0 +1,2635 @@
+// src/tabular/CachedTabularRepository.ts
+import { createServiceToken as createServiceToken3 } from "@workglow/util";
+
+// src/tabular/InMemoryTabularRepository.ts
+import {
+  createServiceToken as createServiceToken2,
+  makeFingerprint as makeFingerprint2
+} from "@workglow/util";
+
+// src/tabular/TabularRepository.ts
+import {
+  createServiceToken,
+  EventEmitter,
+  makeFingerprint
+} from "@workglow/util";
+var TABULAR_REPOSITORY = createServiceToken("storage.tabularRepository");
+
+class TabularRepository {
+  schema;
+  primaryKeyNames;
+  events = new EventEmitter;
+  indexes;
+  primaryKeySchema;
+  valueSchema;
+  constructor(schema, primaryKeyNames, indexes = []) {
+    this.schema = schema;
+    this.primaryKeyNames = primaryKeyNames;
+    const primaryKeyProps = {};
+    const valueProps = {};
+    const primaryKeySet = new Set(primaryKeyNames);
+    for (const [key, typeDef] of Object.entries(schema.properties)) {
+      if (primaryKeySet.has(key)) {
+        primaryKeyProps[key] = Object.assign({}, typeDef);
+      } else {
+        valueProps[key] = Object.assign({}, typeDef);
+      }
+    }
+    const primaryKeyRequired = schema.required?.filter((key) => primaryKeySet.has(key)) ?? [];
+    const valueRequired = schema.required?.filter((key) => !primaryKeySet.has(key)) ?? [];
+    this.primaryKeySchema = {
+      type: "object",
+      properties: primaryKeyProps,
+      required: primaryKeyRequired,
+      additionalProperties: false
+    };
+    this.valueSchema = {
+      type: "object",
+      properties: valueProps,
+      required: valueRequired,
+      additionalProperties: false
+    };
+    const combinedColumns = [...this.primaryKeyColumns(), ...this.valueColumns()];
+    for (const column of combinedColumns) {
+      if (typeof column !== "string") {
+        throw new Error("Column names must be strings");
+      }
+      if (!/^[a-zA-Z][a-zA-Z0-9_]*$/.test(column)) {
+        throw new Error("Column names must start with a letter and contain only letters, digits, and underscores");
+      }
+    }
+    this.indexes = indexes.map((spec) => Array.isArray(spec) ? spec : [spec]);
+    this.indexes = this.filterCompoundKeys(this.primaryKeyColumns(), this.indexes);
+    for (const compoundIndex of this.indexes) {
+      for (const column of compoundIndex) {
+        if (!(column in this.primaryKeySchema.properties) && !(column in this.valueSchema.properties)) {
+          throw new Error(`Searchable column ${String(column)} is not in the primary key schema or value schema`);
+        }
+      }
+    }
+  }
+  filterCompoundKeys(primaryKey, potentialKeys) {
+    const isPrefix = (prefix, arr) => {
+      if (prefix.length > arr.length)
+        return false;
+      return prefix.every((val, index) => val === arr[index]);
+    };
+    potentialKeys.sort((a, b) => a.length - b.length);
+    let filteredKeys = [];
+    for (let i = 0;i < potentialKeys.length; i++) {
+      let key = potentialKeys[i];
+      if (isPrefix(key, primaryKey))
+        continue;
+      if (key.length === 1) {
+        filteredKeys.push(key);
+        continue;
+      }
+      let isRedundant = potentialKeys.some((otherKey, j) => j > i && isPrefix(key, otherKey));
+      if (!isRedundant) {
+        filteredKeys.push(key);
+      }
+    }
+    return filteredKeys;
+  }
+  on(name, fn) {
+    this.events.on(name, fn);
+  }
+  off(name, fn) {
+    this.events.off(name, fn);
+  }
+  once(name, fn) {
+    this.events.once(name, fn);
+  }
+  emit(name, ...args) {
+    this.events.emit(name, ...args);
+  }
+  waitOn(name) {
+    return this.events.waitOn(name);
+  }
+  primaryKeyColumns() {
+    const columns = [];
+    for (const key of Object.keys(this.primaryKeySchema.properties)) {
+      columns.push(key);
+    }
+    return columns;
+  }
+  valueColumns() {
+    const columns = [];
+    for (const key of Object.keys(this.valueSchema.properties)) {
+      columns.push(key);
+    }
+    return columns;
+  }
+  separateKeyValueFromCombined(obj) {
+    if (obj === null) {
+      console.warn("Key is null");
+      return { value: {}, key: {} };
+    }
+    if (typeof obj !== "object") {
+      console.warn("Object is not an object");
+      return { value: {}, key: {} };
+    }
+    const primaryKeyNames = this.primaryKeyColumns();
+    const valueNames = this.valueColumns();
+    const value = {};
+    const key = {};
+    for (const k of primaryKeyNames) {
+      key[k] = obj[k];
+    }
+    for (const k of valueNames) {
+      value[k] = obj[k];
+    }
+    return { value, key };
+  }
+  async getKeyAsIdString(key) {
+    return await makeFingerprint(key);
+  }
+  getPrimaryKeyAsOrderedArray(key) {
+    const orderedParams = [];
+    const keyObj = key;
+    for (const k in this.primaryKeySchema.properties) {
+      if (k in keyObj) {
+        orderedParams.push(keyObj[k]);
+      } else {
+        throw new Error(`Missing required primary key field: ${k}`);
+      }
+    }
+    return orderedParams;
+  }
+  findBestMatchingIndex(unorderedSearchKey) {
+    if (!unorderedSearchKey.length)
+      return;
+    const allKeys = [
+      this.primaryKeyColumns(),
+      ...this.indexes
+    ];
+    const searchKeySet = new Set(unorderedSearchKey);
+    const hasMatchingPrefix = (index) => {
+      return index.length > 0 && searchKeySet.has(index[0]);
+    };
+    let bestMatch;
+    let bestMatchScore = 0;
+    for (const index of allKeys) {
+      if (hasMatchingPrefix(index)) {
+        let score = 0;
+        for (const col of index) {
+          if (!searchKeySet.has(col))
+            break;
+          score++;
+        }
+        if (score > bestMatchScore) {
+          bestMatch = index;
+          bestMatchScore = score;
+        }
+      }
+    }
+    return bestMatch;
+  }
+  destroy() {}
+  async[Symbol.asyncDispose]() {
+    this.destroy();
+  }
+  [Symbol.dispose]() {
+    this.destroy();
+  }
+}
+
+// src/tabular/InMemoryTabularRepository.ts
+var MEMORY_TABULAR_REPOSITORY = createServiceToken2("storage.tabularRepository.inMemory");
+
+class InMemoryTabularRepository extends TabularRepository {
+  values = new Map;
+  constructor(schema, primaryKeyNames, indexes = []) {
+    super(schema, primaryKeyNames, indexes);
+  }
+  async setupDatabase() {}
+  async put(value) {
+    const { key } = this.separateKeyValueFromCombined(value);
+    const id = await makeFingerprint2(key);
+    this.values.set(id, value);
+    this.events.emit("put", value);
+    return value;
+  }
+  async putBulk(values) {
+    return await Promise.all(values.map(async (value) => this.put(value)));
+  }
+  async get(key) {
+    const id = await makeFingerprint2(key);
+    const out = this.values.get(id);
+    this.events.emit("get", key, out);
+    return out;
+  }
+  async search(key) {
+    const searchKeys = Object.keys(key);
+    if (searchKeys.length === 0) {
+      return;
+    }
+    const bestIndex = this.findBestMatchingIndex(searchKeys);
+    if (!bestIndex) {
+      throw new Error(`No suitable index found for the search criteria, searching for ['${searchKeys.join("', '")}'] with pk ['${this.primaryKeyNames.join("', '")}'] and indexes ['${this.indexes.join("', '")}']`);
+    }
+    const results = Array.from(this.values.values()).filter((item) => Object.entries(key).every(([k, v]) => item[k] === v));
+    if (results.length > 0) {
+      this.events.emit("search", key, results);
+      return results;
+    } else {
+      this.events.emit("search", key, undefined);
+      return;
+    }
+  }
+  async delete(value) {
+    const { key } = this.separateKeyValueFromCombined(value);
+    const id = await makeFingerprint2(key);
+    this.values.delete(id);
+    this.events.emit("delete", key);
+  }
+  async deleteAll() {
+    this.values.clear();
+    this.events.emit("clearall");
+  }
+  async getAll() {
+    const all = Array.from(this.values.values());
+    return all.length > 0 ? all : undefined;
+  }
+  async size() {
+    return this.values.size;
+  }
+  async deleteSearch(column, value, operator = "=") {
+    const entries = this.values.entries();
+    const entriesToDelete = entries.filter(([_, entity]) => {
+      const columnValue = entity[column];
+      switch (operator) {
+        case "=":
+          return columnValue === value;
+        case "<":
+          return columnValue !== null && columnValue !== undefined && columnValue < value;
+        case "<=":
+          return columnValue !== null && columnValue !== undefined && columnValue <= value;
+        case ">":
+          return columnValue !== null && columnValue !== undefined && columnValue > value;
+        case ">=":
+          return columnValue !== null && columnValue !== undefined && columnValue >= value;
+        default:
+          return false;
+      }
+    });
+    for (const [id, _] of entriesToDelete) {
+      this.values.delete(id);
+    }
+    if (Array.from(entriesToDelete).length > 0) {
+      this.events.emit("delete", column);
+    }
+  }
+  destroy() {
+    this.values.clear();
+  }
+}
+
+// src/tabular/CachedTabularRepository.ts
+var CACHED_TABULAR_REPOSITORY = createServiceToken3("storage.tabularRepository.cached");
+
+class CachedTabularRepository extends TabularRepository {
+  cache;
+  durable;
+  cacheInitialized = false;
+  constructor(durable, cache, schema, primaryKeyNames, indexes) {
+    if (!schema || !primaryKeyNames) {
+      throw new Error("Schema and primaryKeyNames must be provided when creating CachedTabularRepository");
+    }
+    super(schema, primaryKeyNames, indexes || []);
+    this.durable = durable;
+    if (cache) {
+      this.cache = cache;
+    } else {
+      this.cache = new InMemoryTabularRepository(schema, primaryKeyNames, indexes || []);
+    }
+    this.setupEventForwarding();
+  }
+  setupEventForwarding() {
+    this.cache.on("put", (entity) => {
+      this.events.emit("put", entity);
+    });
+    this.cache.on("get", (key, entity) => {
+      this.events.emit("get", key, entity);
+    });
+    this.cache.on("search", (key, entities) => {
+      this.events.emit("search", key, entities);
+    });
+    this.cache.on("delete", (key) => {
+      this.events.emit("delete", key);
+    });
+    this.cache.on("clearall", () => {
+      this.events.emit("clearall");
+    });
+  }
+  async initializeCache() {
+    if (this.cacheInitialized)
+      return;
+    try {
+      const all = await this.durable.getAll();
+      if (all && all.length > 0) {
+        await this.cache.putBulk(all);
+      }
+      this.cacheInitialized = true;
+    } catch (error) {
+      console.warn("Failed to initialize cache from durable repository:", error);
+      this.cacheInitialized = true;
+    }
+  }
+  async put(value) {
+    await this.initializeCache();
+    const result = await this.durable.put(value);
+    await this.cache.put(result);
+    return result;
+  }
+  async putBulk(values) {
+    await this.initializeCache();
+    const results = await this.durable.putBulk(values);
+    await this.cache.putBulk(results);
+    return results;
+  }
+  async get(key) {
+    await this.initializeCache();
+    let result = await this.cache.get(key);
+    if (result === undefined) {
+      result = await this.durable.get(key);
+      if (result) {
+        await this.cache.put(result);
+      }
+    }
+    return result;
+  }
+  async search(key) {
+    await this.initializeCache();
+    let results = await this.cache.search(key);
+    if (results === undefined) {
+      results = await this.durable.search(key);
+      if (results && results.length > 0) {
+        await this.cache.putBulk(results);
+      }
+    }
+    return results;
+  }
+  async delete(value) {
+    await this.initializeCache();
+    await this.durable.delete(value);
+    await this.cache.delete(value);
+  }
+  async deleteAll() {
+    await this.initializeCache();
+    await this.durable.deleteAll();
+    await this.cache.deleteAll();
+  }
+  async getAll() {
+    await this.initializeCache();
+    let results = await this.cache.getAll();
+    if (!results || results.length === 0) {
+      results = await this.durable.getAll();
+      if (results && results.length > 0) {
+        await this.cache.putBulk(results);
+      }
+    }
+    return results;
+  }
+  async size() {
+    await this.initializeCache();
+    return await this.durable.size();
+  }
+  async deleteSearch(column, value, operator = "=") {
+    await this.initializeCache();
+    await this.durable.deleteSearch(column, value, operator);
+    await this.cache.deleteSearch(column, value, operator);
+  }
+  async invalidateCache() {
+    await this.cache.deleteAll();
+    this.cacheInitialized = false;
+  }
+  async refreshCache() {
+    await this.cache.deleteAll();
+    this.cacheInitialized = false;
+    await this.initializeCache();
+  }
+  destroy() {
+    this.durable.destroy();
+    this.cache.destroy();
+  }
+}
+// src/kv/IKvRepository.ts
+var DefaultKeyValueSchema = {
+  type: "object",
+  properties: {
+    key: { type: "string" },
+    value: {}
+  },
+  additionalProperties: false
+};
+var DefaultKeyValueKey = ["key"];
+// src/kv/InMemoryKvRepository.ts
+import { createServiceToken as createServiceToken5 } from "@workglow/util";
+
+// src/kv/KvRepository.ts
+import { createServiceToken as createServiceToken4, EventEmitter as EventEmitter2, makeFingerprint as makeFingerprint3 } from "@workglow/util";
+var KV_REPOSITORY = createServiceToken4("storage.kvRepository");
+
+class KvRepository {
+  keySchema;
+  valueSchema;
+  events = new EventEmitter2;
+  constructor(keySchema = { type: "string" }, valueSchema = {}) {
+    this.keySchema = keySchema;
+    this.valueSchema = valueSchema;
+  }
+  async getObjectAsIdString(object) {
+    return await makeFingerprint3(object);
+  }
+  on(name, fn) {
+    this.events.on(name, fn);
+  }
+  off(name, fn) {
+    this.events.off(name, fn);
+  }
+  once(name, fn) {
+    this.events.once(name, fn);
+  }
+  emit(name, ...args) {
+    this.events.emit(name, ...args);
+  }
+  waitOn(name) {
+    return this.events.waitOn(name);
+  }
+}
+
+// src/kv/KvViaTabularRepository.ts
+class KvViaTabularRepository extends KvRepository {
+  async put(key, value) {
+    const schemaType = typeof this.valueSchema === "object" && this.valueSchema !== null && "type" in this.valueSchema ? this.valueSchema.type : undefined;
+    const shouldStringify = !["number", "boolean", "string", "blob"].includes(schemaType);
+    if (shouldStringify) {
+      value = JSON.stringify(value);
+    }
+    await this.tabularRepository.put({ key, value });
+  }
+  async putBulk(items) {
+    const schemaType = typeof this.valueSchema === "object" && this.valueSchema !== null && "type" in this.valueSchema ? this.valueSchema.type : undefined;
+    const shouldStringify = !["number", "boolean", "string", "blob"].includes(schemaType);
+    const entities = items.map(({ key, value }) => {
+      if (shouldStringify) {
+        value = JSON.stringify(value);
+      }
+      return { key, value };
+    });
+    await this.tabularRepository.putBulk(entities);
+  }
+  async get(key) {
+    const result = await this.tabularRepository.get({ key });
+    if (result) {
+      const schemaType = typeof this.valueSchema === "object" && this.valueSchema !== null && "type" in this.valueSchema ? this.valueSchema.type : undefined;
+      const shouldParse = !["number", "boolean", "string", "blob"].includes(schemaType);
+      if (shouldParse) {
+        try {
+          return JSON.parse(result.value);
+        } catch (e) {
+          return result.value;
+        }
+      } else {
+        return result.value;
+      }
+    } else {
+      return;
+    }
+  }
+  async delete(key) {
+    return await this.tabularRepository.delete({ key });
+  }
+  async getAll() {
+    const values = await this.tabularRepository.getAll();
+    if (values) {
+      return values.map((value) => ({
+        key: value.key,
+        value: (() => {
+          const schemaType = typeof this.valueSchema === "object" && this.valueSchema !== null && "type" in this.valueSchema ? this.valueSchema.type : undefined;
+          const shouldParse = !["number", "boolean", "string"].includes(schemaType);
+          if (shouldParse && typeof value.value === "string") {
+            try {
+              return JSON.parse(value.value);
+            } catch (e) {
+              return value.value;
+            }
+          }
+          return value.value;
+        })()
+      }));
+    }
+  }
+  async deleteAll() {
+    return await this.tabularRepository.deleteAll();
+  }
+  async size() {
+    return await this.tabularRepository.size();
+  }
+}
+
+// src/kv/InMemoryKvRepository.ts
+var MEMORY_KV_REPOSITORY = createServiceToken5("storage.kvRepository.inMemory");
+
+class InMemoryKvRepository extends KvViaTabularRepository {
+  tabularRepository;
+  constructor(keySchema = { type: "string" }, valueSchema = {}) {
+    super(keySchema, valueSchema);
+    this.tabularRepository = new InMemoryTabularRepository(DefaultKeyValueSchema, DefaultKeyValueKey);
+  }
+}
+// src/queue/InMemoryQueueStorage.ts
+import { createServiceToken as createServiceToken7, makeFingerprint as makeFingerprint4, sleep, uuid4 } from "@workglow/util";
+
+// src/queue/IQueueStorage.ts
+import { createServiceToken as createServiceToken6 } from "@workglow/util";
+var QUEUE_STORAGE = createServiceToken6("jobqueue.storage");
+var JobStatus;
+((JobStatus2) => {
+  JobStatus2["PENDING"] = "PENDING";
+  JobStatus2["PROCESSING"] = "PROCESSING";
+  JobStatus2["COMPLETED"] = "COMPLETED";
+  JobStatus2["ABORTING"] = "ABORTING";
+  JobStatus2["FAILED"] = "FAILED";
+  JobStatus2["DISABLED"] = "DISABLED";
+})(JobStatus ||= {});
+
+// src/queue/InMemoryQueueStorage.ts
+var IN_MEMORY_QUEUE_STORAGE = createServiceToken7("jobqueue.storage.inMemory");
+
+class InMemoryQueueStorage {
+  queueName;
+  constructor(queueName) {
+    this.queueName = queueName;
+    this.jobQueue = [];
+  }
+  jobQueue;
+  pendingQueue() {
+    const now = new Date().toISOString();
+    return this.jobQueue.filter((job) => job.status === "PENDING" /* PENDING */).filter((job) => !job.run_after || job.run_after <= now).sort((a, b) => (a.run_after || "").localeCompare(b.run_after || ""));
+  }
+  async add(job) {
+    await sleep(0);
+    const now = new Date().toISOString();
+    job.id = job.id ?? uuid4();
+    job.job_run_id = job.job_run_id ?? uuid4();
+    job.queue = this.queueName;
+    job.fingerprint = await makeFingerprint4(job.input);
+    job.status = "PENDING" /* PENDING */;
+    job.progress = 0;
+    job.progress_message = "";
+    job.progress_details = null;
+    job.created_at = now;
+    job.run_after = now;
+    this.jobQueue.push(job);
+    return job.id;
+  }
+  async get(id) {
+    await sleep(0);
+    return this.jobQueue.find((j) => j.id === id);
+  }
+  async peek(status = "PENDING" /* PENDING */, num = 100) {
+    await sleep(0);
+    num = Number(num) || 100;
+    return this.jobQueue.sort((a, b) => (a.run_after || "").localeCompare(b.run_after || "")).filter((j) => j.status === status).slice(0, num);
+  }
+  async next() {
+    await sleep(0);
+    const top = this.pendingQueue();
+    const job = top[0];
+    if (job) {
+      job.status = "PROCESSING" /* PROCESSING */;
+      job.last_ran_at = new Date().toISOString();
+      return job;
+    }
+  }
+  async size(status = "PENDING" /* PENDING */) {
+    await sleep(0);
+    return this.jobQueue.filter((j) => j.status === status).length;
+  }
+  async saveProgress(id, progress, message, details) {
+    await sleep(0);
+    const job = this.jobQueue.find((j) => j.id === id);
+    if (!job) {
+      throw new Error(`Job ${id} not found`);
+    }
+    job.progress = progress;
+    job.progress_message = message;
+    job.progress_details = details;
+  }
+  async complete(job) {
+    await sleep(0);
+    const index = this.jobQueue.findIndex((j) => j.id === job.id);
+    if (index !== -1) {
+      const existing = this.jobQueue[index];
+      const currentAttempts = existing?.run_attempts ?? 0;
+      job.run_attempts = currentAttempts + 1;
+      this.jobQueue[index] = job;
+    }
+  }
+  async abort(id) {
+    await sleep(0);
+    const job = this.jobQueue.find((j) => j.id === id);
+    if (job) {
+      job.status = "ABORTING" /* ABORTING */;
+    }
+  }
+  async getByRunId(runId) {
+    await sleep(0);
+    return this.jobQueue.filter((job) => job.job_run_id === runId);
+  }
+  async deleteAll() {
+    await sleep(0);
+    this.jobQueue = [];
+  }
+  async outputForInput(input) {
+    await sleep(0);
+    const fingerprint = await makeFingerprint4(input);
+    return this.jobQueue.find((j) => j.fingerprint === fingerprint && j.status === "COMPLETED" /* COMPLETED */)?.output ?? null;
+  }
+  async delete(id) {
+    await sleep(0);
+    this.jobQueue = this.jobQueue.filter((job) => job.id !== id);
+  }
+  async deleteJobsByStatusAndAge(status, olderThanMs) {
+    await sleep(0);
+    const cutoffDate = new Date(Date.now() - olderThanMs).toISOString();
+    this.jobQueue = this.jobQueue.filter((job) => job.status !== status || !job.completed_at || job.completed_at > cutoffDate);
+  }
+  async setupDatabase() {}
+}
+// src/tabular/IndexedDbTabularRepository.ts
+import { createServiceToken as createServiceToken8 } from "@workglow/util";
+
+// src/util/IndexedDbTable.ts
+var METADATA_STORE_NAME = "__schema_metadata__";
+async function saveSchemaMetadata(db, tableName, snapshot) {
+  return new Promise((resolve, reject) => {
+    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 loadSchemaMetadata(db, tableName) {
+  return new Promise((resolve) => {
+    try {
+      if (!db.objectStoreNames.contains(METADATA_STORE_NAME)) {
+        resolve(null);
+        return;
+      }
+      const transaction = db.transaction(METADATA_STORE_NAME, "readonly");
+      const store = transaction.objectStore(METADATA_STORE_NAME);
+      const request = store.get(tableName);
+      request.onsuccess = () => resolve(request.result || null);
+      request.onerror = () => resolve(null);
+      transaction.onerror = () => resolve(null);
+    } catch (err) {
+      resolve(null);
+    }
+  });
+}
+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();
+      };
+      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 (JSON.stringify(normalizedExpected) !== JSON.stringify(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 = JSON.stringify(expectedKeyPath) !== JSON.stringify(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);
+    }
+  }
+  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 db2 = event.target.result;
+    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);
+      }
+      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);
+    }
+    options.onMigrationProgress?.(`Migration complete`, 1);
+  });
+}
+async function performDestructiveMigration(db, tableName, primaryKey, expectedIndexes, options = {}) {
+  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);
+        }
+      }
+      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;
+    const transaction = event.target.transaction;
+    if (db2.objectStoreNames.contains(tableName)) {
+      db2.deleteObjectStore(tableName);
+    }
+    const store = db2.createObjectStore(tableName, { keyPath: primaryKey });
+    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);
+        }
+      }
+    }
+  });
+  options.onMigrationProgress?.(`Destructive migration complete`, 1);
+  return newDb;
+}
+async function createNewDatabase(tableName, primaryKey, expectedIndexes, options = {}) {
+  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 });
+    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 = {}) {
+  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);
+    }
+    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 });
+        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" });
+        }
+      });
+    }
+    const metadata = await loadSchemaMetadata(db, tableName);
+    if (!db.objectStoreNames.contains(tableName)) {
+      options.onMigrationProgress?.(`Object store ${tableName} does not exist, creating...`, 0);
+      db.close();
+      return await createNewDatabase(tableName, primaryKey, expectedIndexes, options);
+    }
+    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);
+    } 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/IndexedDbTabularRepository.ts
+var IDB_TABULAR_REPOSITORY = createServiceToken8("storage.tabularRepository.indexedDb");
+
+class IndexedDbTabularRepository extends TabularRepository {
+  table;
+  db;
+  migrationOptions;
+  constructor(table = "tabular_store", schema, primaryKeyNames, indexes = [], migrationOptions = {}) {
+    super(schema, primaryKeyNames, indexes);
+    this.table = table;
+    this.migrationOptions = migrationOptions;
+  }
+  async setupDatabase() {
+    if (this.db)
+      return this.db;
+    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;
+      }
+      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;
+    this.db = await ensureIndexedDbTable(this.table, primaryKey, expectedIndexes, this.migrationOptions);
+    return this.db;
+  }
+  async put(record) {
+    const db = await this.setupDatabase();
+    const { key } = this.separateKeyValueFromCombined(record);
+    return new Promise((resolve, reject) => {
+      const transaction = db.transaction(this.table, "readwrite");
+      const store = transaction.objectStore(this.table);
+      const request = store.put(record);
+      request.onerror = () => {
+        reject(request.error);
+      };
+      request.onsuccess = () => {
+        this.events.emit("put", record);
+        resolve(record);
+      };
+    });
+  }
+  async putBulk(records) {
+    const db = await this.setupDatabase();
+    return new Promise((resolve, reject) => {
+      const transaction = db.transaction(this.table, "readwrite");
+      const store = transaction.objectStore(this.table);
+      let completed = 0;
+      let hasError = false;
+      transaction.onerror = () => {
+        if (!hasError) {
+          hasError = true;
+          reject(transaction.error);
+        }
+      };
+      transaction.oncomplete = () => {
+        if (!hasError) {
+          resolve(records);
+        }
+      };
+      for (const record of records) {
+        const request = store.put(record);
+        request.onsuccess = () => {
+          this.events.emit("put", record);
+          completed++;
+        };
+        request.onerror = () => {
+          if (!hasError) {
+            hasError = true;
+            reject(request.error);
+          }
+        };
+      }
+    });
+  }
+  getPrimaryKeyAsOrderedArray(key) {
+    return super.getPrimaryKeyAsOrderedArray(key).map((value) => typeof value === "bigint" ? value.toString() : value);
+  }
+  getIndexedKey(key) {
+    const keys = super.getPrimaryKeyAsOrderedArray(key).map((value) => typeof value === "bigint" ? value.toString() : value);
+    return keys.length === 1 ? keys[0] : keys;
+  }
+  async get(key) {
+    const db = await this.setupDatabase();
+    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() {
+    const db = await this.setupDatabase();
+    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 = () => {
+        const values = request.result;
+        resolve(values.length > 0 ? values : undefined);
+      };
+    });
+  }
+  async search(key) {
+    const db = await this.setupDatabase();
+    const searchKeys = Object.keys(key);
+    if (searchKeys.length === 0) {
+      return;
+    }
+    const bestIndex = this.findBestMatchingIndex(searchKeys);
+    if (!bestIndex) {
+      throw new Error("No suitable index found for the search criteria");
+    }
+    return new Promise((resolve, reject) => {
+      const transaction = db.transaction(this.table, "readonly");
+      const store = transaction.objectStore(this.table);
+      const indexName = bestIndex.join("_");
+      const primaryKeyName = this.primaryKeyColumns().join("_");
+      const isPrimaryKey = indexName === primaryKeyName;
+      const indexValues = [];
+      for (const col of bestIndex) {
+        const val = key[col];
+        if (val === undefined)
+          break;
+        if (typeof val !== "string" && typeof val !== "number") {
+          throw new Error(`Invalid value type for indexed column ${String(col)}`);
+        }
+        indexValues.push(val);
+      }
+      if (indexValues.length > 0) {
+        const index = isPrimaryKey ? store : store.index(indexName);
+        const isPartialMatch = indexValues.length < bestIndex.length;
+        if (isPartialMatch) {
+          const allColumnsRequired = bestIndex.every((col) => {
+            const colName = String(col);
+            return this.schema.required?.includes(colName);
+          });
+          if (allColumnsRequired) {
+            const results = [];
+            const keyRange = IDBKeyRange.lowerBound(indexValues);
+            const cursorRequest = index.openCursor(keyRange);
+            cursorRequest.onsuccess = () => {
+              const cursor = cursorRequest.result;
+              if (cursor) {
+                const item = cursor.value;
+                const cursorKey = Array.isArray(cursor.key) ? cursor.key : [cursor.key];
+                const prefixMatches = indexValues.every((val, idx) => cursorKey[idx] === val);
+                if (!prefixMatches) {
+                  resolve(results.length > 0 ? results : undefined);
+                  return;
+                }
+                const matches = Object.entries(key).every(([k, v]) => item[k] === v);
+                if (matches) {
+                  results.push(item);
+                }
+                cursor.continue();
+              } else {
+                resolve(results.length > 0 ? results : undefined);
+              }
+            };
+            cursorRequest.onerror = () => {
+              reject(cursorRequest.error);
+            };
+          } else {
+            const getAllRequest = store.getAll();
+            getAllRequest.onsuccess = () => {
+              const allRecords = getAllRequest.result;
+              const results = allRecords.filter((item) => Object.entries(key).every(([k, v]) => item[k] === v));
+              resolve(results.length > 0 ? results : undefined);
+            };
+            getAllRequest.onerror = () => {
+              reject(getAllRequest.error);
+            };
+          }
+        } else {
+          const request = index.getAll(indexValues.length === 1 ? indexValues[0] : indexValues);
+          request.onsuccess = () => {
+            const results = request.result.filter((item) => Object.entries(key).every(([k, v]) => item[k] === v));
+            resolve(results.length > 0 ? results : undefined);
+          };
+          request.onerror = () => {
+            console.error("Search error:", request.error);
+            reject(request.error);
+          };
+        }
+      } else {
+        throw new Error(`No valid values provided for indexed columns: ${bestIndex.join(", ")}`);
+      }
+    });
+  }
+  async delete(key) {
+    const db = await this.setupDatabase();
+    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();
+      };
+    });
+  }
+  async deleteAll() {
+    const db = await this.setupDatabase();
+    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();
+      };
+    });
+  }
+  async size() {
+    const db = await this.setupDatabase();
+    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);
+    });
+  }
+  async deleteSearch(column, value, operator = "=") {
+    const db = await this.setupDatabase();
+    return new Promise(async (resolve, reject) => {
+      try {
+        if (operator === "=") {
+          const searchKey = { [column]: value };
+          const recordsToDelete = await this.search(searchKey);
+          if (!recordsToDelete || recordsToDelete.length === 0) {
+            this.events.emit("delete", column);
+            resolve();
+            return;
+          }
+          const transaction = db.transaction(this.table, "readwrite");
+          const store = transaction.objectStore(this.table);
+          transaction.oncomplete = () => {
+            this.events.emit("delete", column);
+            resolve();
+          };
+          transaction.onerror = () => {
+            reject(transaction.error);
+          };
+          for (const record of recordsToDelete) {
+            const primaryKey = this.primaryKeyColumns().reduce((key, column2) => {
+              key[column2] = record[column2];
+              return key;
+            }, {});
+            const request = store.delete(this.getIndexedKey(primaryKey));
+            request.onerror = () => {
+              console.error("Error deleting record:", request.error);
+            };
+          }
+        } else {
+          const transaction = db.transaction(this.table, "readwrite");
+          const store = transaction.objectStore(this.table);
+          transaction.oncomplete = () => {
+            this.events.emit("delete", column);
+            resolve();
+          };
+          transaction.onerror = () => {
+            reject(transaction.error);
+          };
+          const getAllRequest = store.getAll();
+          getAllRequest.onsuccess = () => {
+            const allRecords = getAllRequest.result;
+            const recordsToDelete = allRecords.filter((record) => {
+              const recordValue = record[column];
+              if (recordValue === null || recordValue === undefined || value === null || value === undefined) {
+                return false;
+              }
+              switch (operator) {
+                case "<":
+                  return recordValue < value;
+                case "<=":
+                  return recordValue <= value;
+                case ">":
+                  return recordValue > value;
+                case ">=":
+                  return recordValue >= value;
+                default:
+                  return false;
+              }
+            });
+            if (recordsToDelete.length === 0) {
+              return;
+            }
+            for (const record of recordsToDelete) {
+              const primaryKey = this.primaryKeyColumns().reduce((key, column2) => {
+                key[column2] = record[column2];
+                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);
+      }
+    });
+  }
+  destroy() {
+    this.db?.close();
+  }
+}
+// src/tabular/SharedInMemoryTabularRepository.ts
+import { createServiceToken as createServiceToken9 } from "@workglow/util";
+var SHARED_IN_MEMORY_TABULAR_REPOSITORY = createServiceToken9("storage.tabularRepository.sharedInMemory");
+
+class SharedInMemoryTabularRepository extends TabularRepository {
+  channel = null;
+  channelName;
+  inMemoryRepo;
+  isInitialized = false;
+  syncInProgress = false;
+  constructor(channelName = "tabular_store", schema, primaryKeyNames, indexes = []) {
+    super(schema, primaryKeyNames, indexes);
+    this.channelName = channelName;
+    this.inMemoryRepo = new InMemoryTabularRepository(schema, primaryKeyNames, indexes);
+    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("search", (key, entities) => {
+      this.events.emit("search", 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") {
+      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;
+        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.column, message.value, message.operator);
+        break;
+    }
+  }
+  syncFromOtherTabs() {
+    if (!this.channel)
+      return;
+    this.syncInProgress = true;
+    this.channel.postMessage({ type: "SYNC_REQUEST" });
+    setTimeout(() => {
+      this.syncInProgress = false;
+    }, 1000);
+  }
+  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) {
+    await this.setupDatabase();
+    const result = await this.inMemoryRepo.put(value);
+    this.broadcast({ type: "PUT", entity: value });
+    return result;
+  }
+  async putBulk(values) {
+    await this.setupDatabase();
+    const result = await this.inMemoryRepo.putBulk(values);
+    this.broadcast({ type: "PUT_BULK", entities: values });
+    return result;
+  }
+  async get(key) {
+    await this.setupDatabase();
+    return await this.inMemoryRepo.get(key);
+  }
+  async search(key) {
+    await this.setupDatabase();
+    return await this.inMemoryRepo.search(key);
+  }
+  async delete(value) {
+    await this.setupDatabase();
+    await this.inMemoryRepo.delete(value);
+    const { key } = this.separateKeyValueFromCombined(value);
+    this.broadcast({ type: "DELETE", key });
+  }
+  async deleteAll() {
+    await this.setupDatabase();
+    await this.inMemoryRepo.deleteAll();
+    this.broadcast({ type: "DELETE_ALL" });
+  }
+  async getAll() {
+    await this.setupDatabase();
+    return await this.inMemoryRepo.getAll();
+  }
+  async size() {
+    await this.setupDatabase();
+    return await this.inMemoryRepo.size();
+  }
+  async deleteSearch(column, value, operator = "=") {
+    await this.setupDatabase();
+    await this.inMemoryRepo.deleteSearch(column, value, operator);
+    this.broadcast({
+      type: "DELETE_SEARCH",
+      column: String(column),
+      value,
+      operator
+    });
+  }
+  destroy() {
+    if (this.channel) {
+      this.channel.close();
+      this.channel = null;
+    }
+  }
+}
+// src/tabular/SupabaseTabularRepository.ts
+import { createServiceToken as createServiceToken10 } from "@workglow/util";
+
+// src/tabular/BaseSqlTabularRepository.ts
+class BaseSqlTabularRepository extends TabularRepository {
+  table;
+  constructor(table = "tabular_store", schema, primaryKeyNames, indexes = []) {
+    super(schema, primaryKeyNames, indexes);
+    this.table = table;
+    this.validateTableAndSchema();
+  }
+  constructPrimaryKeyColumns($delimiter = "") {
+    const cols = Object.entries(this.primaryKeySchema.properties).map(([key, typeDef]) => {
+      const sqlType = this.mapTypeToSQL(typeDef);
+      return `${$delimiter}${key}${$delimiter} ${sqlType} NOT NULL`;
+    }).join(", ");
+    return cols;
+  }
+  constructValueColumns($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);
+      return `${$delimiter}${key}${$delimiter} ${sqlType}${nullable ? " NULL" : " NOT NULL"}`;
+    }).join(", ");
+    if (cols.length > 0) {
+      return `, ${cols}`;
+    } else {
+      return "";
+    }
+  }
+  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 = "") {
+    return $delimiter + this.primaryKeyColumns().join(`${$delimiter}, ${$delimiter}`) + $delimiter;
+  }
+  valueColumnList($delimiter = "") {
+    return $delimiter + this.valueColumns().join(`${$delimiter}, ${$delimiter}`) + $delimiter;
+  }
+  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") {
+      const v = value;
+      if (v instanceof Uint8Array) {
+        return v;
+      }
+      if (typeof Buffer !== "undefined" && v instanceof Buffer) {
+        return new Uint8Array(v);
+      }
+      if (Array.isArray(v)) {
+        return new Uint8Array(v);
+      }
+      return v;
+    } 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") {
+      const v = value;
+      if (typeof Buffer !== "undefined" && v instanceof Buffer) {
+        return new Uint8Array(v);
+      }
+      if (v instanceof Uint8Array) {
+        return v;
+      }
+      return v;
+    } 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/SupabaseTabularRepository.ts
+var SUPABASE_TABULAR_REPOSITORY = createServiceToken10("storage.tabularRepository.supabase");
+
+class SupabaseTabularRepository extends BaseSqlTabularRepository {
+  client;
+  constructor(client, table = "tabular_store", schema, primaryKeyNames, indexes = []) {
+    super(table, schema, primaryKeyNames, indexes);
+    this.client = client;
+  }
+  isSetup = true;
+  async setupDatabase() {
+    if (this.isSetup) {
+      return this.client;
+    }
+    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);
+      }
+    }
+    this.isSetup = true;
+    return this.client;
+  }
+  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]) => {
+      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")) {
+        const v = value;
+        if (typeof v === "number")
+          return v;
+        if (typeof v === "string") {
+          const parsed = Number(v);
+          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) {
+    await this.setupDatabase();
+    const normalizedEntity = { ...entity };
+    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;
+    for (const key in this.schema.properties) {
+      updatedEntity[key] = this.sqlToJsValue(key, updatedEntity[key]);
+    }
+    this.events.emit("put", updatedEntity);
+    return updatedEntity;
+  }
+  async putBulk(entities) {
+    if (entities.length === 0)
+      return [];
+    await this.setupDatabase();
+    const requiredSet = new Set(this.valueSchema.required ?? []);
+    const normalizedEntities = entities.map((entity) => {
+      const normalized = { ...entity };
+      for (const key in this.valueSchema.properties) {
+        if (!(key in normalized) || normalized[key] === undefined) {
+          if (!requiredSet.has(key)) {
+            normalized[key] = null;
+          }
+        }
+      }
+      return normalized;
+    });
+    const { data, error } = await this.client.from(this.table).upsert(normalizedEntities, { onConflict: this.primaryKeyColumnList() }).select();
+    if (error)
+      throw error;
+    const updatedEntities = data;
+    for (const entity of updatedEntities) {
+      for (const key in this.schema.properties) {
+        entity[key] = this.sqlToJsValue(key, entity[key]);
+      }
+      this.events.emit("put", entity);
+    }
+    return updatedEntities;
+  }
+  async get(key) {
+    await this.setupDatabase();
+    let query = this.client.from(this.table).select("*");
+    for (const pkName of this.primaryKeyNames) {
+      query = query.eq(String(pkName), key[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) {
+      for (const key2 in this.schema.properties) {
+        val[key2] = this.sqlToJsValue(key2, val[key2]);
+      }
+    }
+    this.events.emit("get", key, val);
+    return val;
+  }
+  async search(searchCriteria) {
+    await this.setupDatabase();
+    const searchKeys = Object.keys(searchCriteria);
+    if (searchKeys.length === 0) {
+      return;
+    }
+    const bestIndex = this.findBestMatchingIndex(searchKeys);
+    if (!bestIndex) {
+      throw new Error(`No suitable index found for the search criteria, searching for ['${searchKeys.join("', '")}'] with pk ['${this.primaryKeyNames.join("', '")}'] and indexes ['${this.indexes.join("', '")}']`);
+    }
+    const validColumns = [...this.primaryKeyColumns(), ...this.valueColumns()];
+    const invalidColumns = searchKeys.filter((key) => !validColumns.includes(key));
+    if (invalidColumns.length > 0) {
+      throw new Error(`Invalid columns in search criteria: ${invalidColumns.join(", ")}`);
+    }
+    let query = this.client.from(this.table).select("*");
+    for (const [key, value] of Object.entries(searchCriteria)) {
+      query = query.eq(key, value);
+    }
+    const { data, error } = await query;
+    if (error)
+      throw error;
+    if (data && data.length > 0) {
+      for (const row of data) {
+        for (const key in this.schema.properties) {
+          row[key] = this.sqlToJsValue(key, row[key]);
+        }
+      }
+      this.events.emit("search", searchCriteria, data);
+      return data;
+    } else {
+      this.events.emit("search", searchCriteria, undefined);
+      return;
+    }
+  }
+  async delete(value) {
+    await this.setupDatabase();
+    const { key } = this.separateKeyValueFromCombined(value);
+    let query = this.client.from(this.table).delete();
+    for (const pkName of this.primaryKeyNames) {
+      query = query.eq(String(pkName), key[pkName]);
+    }
+    const { error } = await query;
+    if (error)
+      throw error;
+    this.events.emit("delete", key);
+  }
+  async getAll() {
+    await this.setupDatabase();
+    const { data, error } = await this.client.from(this.table).select("*");
+    if (error)
+      throw error;
+    if (data && data.length) {
+      for (const row of data) {
+        for (const key in this.schema.properties) {
+          row[key] = this.sqlToJsValue(key, row[key]);
+        }
+      }
+      return data;
+    }
+    return;
+  }
+  async deleteAll() {
+    await this.setupDatabase();
+    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() {
+    await this.setupDatabase();
+    const { count, error } = await this.client.from(this.table).select("*", { count: "exact", head: true });
+    if (error)
+      throw error;
+    return count ?? 0;
+  }
+  generateWhereClause(column, operator = "=") {
+    if (!(column in this.schema.properties)) {
+      throw new Error(`Schema must have a ${String(column)} field to use deleteSearch`);
+    }
+    return `${String(column)} ${operator} $1`;
+  }
+  async deleteSearch(column, value, operator = "=") {
+    await this.setupDatabase();
+    let query = this.client.from(this.table).delete();
+    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", column);
+  }
+}
+// src/kv/IndexedDbKvRepository.ts
+import { createServiceToken as createServiceToken11 } from "@workglow/util";
+var IDB_KV_REPOSITORY = createServiceToken11("storage.kvRepository.indexedDb");
+
+class IndexedDbKvRepository extends KvViaTabularRepository {
+  dbName;
+  tabularRepository;
+  constructor(dbName, keySchema = { type: "string" }, valueSchema = {}) {
+    super(keySchema, valueSchema);
+    this.dbName = dbName;
+    this.tabularRepository = new IndexedDbTabularRepository(dbName, DefaultKeyValueSchema, DefaultKeyValueKey);
+  }
+}
+// src/kv/SupabaseKvRepository.ts
+import { createServiceToken as createServiceToken12 } from "@workglow/util";
+var SUPABASE_KV_REPOSITORY = createServiceToken12("storage.kvRepository.supabase");
+
+class SupabaseKvRepository extends KvViaTabularRepository {
+  client;
+  tableName;
+  tabularRepository;
+  constructor(client, tableName, keySchema = { type: "string" }, valueSchema = {}, tabularRepository) {
+    super(keySchema, valueSchema);
+    this.client = client;
+    this.tableName = tableName;
+    this.tabularRepository = tabularRepository ?? new SupabaseTabularRepository(client, tableName, DefaultKeyValueSchema, DefaultKeyValueKey);
+  }
+}
+// src/queue/IndexedDbQueueStorage.ts
+import { createServiceToken as createServiceToken13, makeFingerprint as makeFingerprint5, uuid4 as uuid42 } from "@workglow/util";
+var INDEXED_DB_QUEUE_STORAGE = createServiceToken13("jobqueue.storage.indexedDb");
+
+class IndexedDbQueueStorage {
+  queueName;
+  db;
+  tableName;
+  migrationOptions;
+  constructor(queueName, migrationOptions = {}) {
+    this.queueName = queueName;
+    this.tableName = `jobs_${queueName}`;
+    this.migrationOptions = migrationOptions;
+  }
+  async getDb() {
+    if (this.db)
+      return this.db;
+    await this.setupDatabase();
+    return this.db;
+  }
+  async setupDatabase() {
+    const expectedIndexes = [
+      {
+        name: "status",
+        keyPath: `status`,
+        options: { unique: false }
+      },
+      {
+        name: "status_run_after",
+        keyPath: ["status", "run_after"],
+        options: { unique: false }
+      },
+      {
+        name: "job_run_id",
+        keyPath: `job_run_id`,
+        options: { unique: false }
+      },
+      {
+        name: "fingerprint_status",
+        keyPath: ["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();
+    job.id = job.id ?? uuid42();
+    job.job_run_id = job.job_run_id ?? uuid42();
+    job.queue = this.queueName;
+    job.fingerprint = await makeFingerprint5(job.input);
+    job.status = "PENDING" /* PENDING */;
+    job.progress = 0;
+    job.progress_message = "";
+    job.progress_details = null;
+    job.created_at = now;
+    job.run_after = now;
+    const tx = db.transaction(this.tableName, "readwrite");
+    const store = tx.objectStore(this.tableName);
+    return new Promise((resolve, reject) => {
+      const request = store.add(job);
+      tx.oncomplete = () => resolve(job.id);
+      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 = () => resolve(request.result);
+      request.onerror = () => reject(request.error);
+      tx.onerror = () => reject(tx.error);
+    });
+  }
+  async peek(status = "PENDING" /* 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("status_run_after");
+    return new Promise((resolve, reject) => {
+      const ret = new Map;
+      const keyRange = IDBKeyRange.bound([status, ""], [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;
+        }
+        ret.set(cursor.value.id, cursor.value);
+        cursor.continue();
+      };
+      cursorRequest.onsuccess = handleCursor;
+      cursorRequest.onerror = () => reject(cursorRequest.error);
+      tx.onerror = () => reject(tx.error);
+    });
+  }
+  async next() {
+    const db = await this.getDb();
+    const tx = db.transaction(this.tableName, "readwrite");
+    const store = tx.objectStore(this.tableName);
+    const index = store.index("status_run_after");
+    const now = new Date().toISOString();
+    return new Promise((resolve, reject) => {
+      const cursorRequest = index.openCursor(IDBKeyRange.bound(["PENDING" /* PENDING */, ""], ["PENDING" /* PENDING */, now], false, true));
+      let jobToReturn;
+      cursorRequest.onsuccess = (e) => {
+        const cursor = e.target.result;
+        if (!cursor) {
+          if (jobToReturn) {
+            resolve(jobToReturn);
+          } else {
+            resolve(undefined);
+          }
+          return;
+        }
+        const job = cursor.value;
+        if (job.status !== "PENDING" /* PENDING */) {
+          cursor.continue();
+          return;
+        }
+        job.status = "PROCESSING" /* PROCESSING */;
+        job.last_ran_at = now;
+        try {
+          const updateRequest = store.put(job);
+          updateRequest.onsuccess = () => {
+            jobToReturn = job;
+          };
+          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 = () => {
+        resolve(jobToReturn);
+      };
+      tx.onerror = () => reject(tx.error);
+    });
+  }
+  async size(status = "PENDING" /* PENDING */) {
+    const db = await this.getDb();
+    return new Promise((resolve, reject) => {
+      const tx = db.transaction(this.tableName, "readonly");
+      const store = tx.objectStore(this.tableName);
+      const index = store.index("status");
+      const request = index.count(status);
+      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;
+        const currentAttempts = existing?.run_attempts ?? 0;
+        job.run_attempts = currentAttempts + 1;
+        const putReq = store.put(job);
+        putReq.onsuccess = () => {};
+        putReq.onerror = () => reject(putReq.error);
+      };
+      getReq.onerror = () => reject(getReq.error);
+      tx.oncomplete = () => resolve();
+      tx.onerror = () => reject(tx.error);
+    });
+  }
+  async abort(id) {
+    const job = await this.get(id);
+    if (!job)
+      return;
+    job.status = "ABORTING" /* 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("job_run_id");
+    const request = index.getAll(job_run_id);
+    return new Promise((resolve, reject) => {
+      request.onsuccess = () => resolve(request.result);
+      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 request = store.clear();
+    return new Promise((resolve, reject) => {
+      request.onsuccess = () => resolve();
+      request.onerror = () => reject(request.error);
+      tx.onerror = () => reject(tx.error);
+    });
+  }
+  async outputForInput(input) {
+    const fingerprint = await makeFingerprint5(input);
+    const db = await this.getDb();
+    const tx = db.transaction(this.tableName, "readonly");
+    const store = tx.objectStore(this.tableName);
+    const index = store.index("fingerprint_status");
+    const request = index.get([fingerprint, "COMPLETED" /* COMPLETED */]);
+    return new Promise((resolve, reject) => {
+      request.onsuccess = () => resolve(request.result?.output ?? 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.complete(job);
+  }
+  async delete(id) {
+    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.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("status");
+    const cutoffDate = new Date(Date.now() - olderThanMs).toISOString();
+    return new Promise((resolve, reject) => {
+      const request = index.openCursor();
+      request.onsuccess = (event) => {
+        const cursor = event.target.result;
+        if (cursor) {
+          const job = cursor.value;
+          if (job.status === status && job.completed_at && job.completed_at <= cutoffDate) {
+            cursor.delete();
+          }
+          cursor.continue();
+        }
+      };
+      tx.oncomplete = () => resolve();
+      tx.onerror = () => reject(tx.error);
+      request.onerror = () => reject(request.error);
+    });
+  }
+}
+// src/queue/SupabaseQueueStorage.ts
+import { createServiceToken as createServiceToken14, makeFingerprint as makeFingerprint6, uuid4 as uuid43 } from "@workglow/util";
+var SUPABASE_QUEUE_STORAGE = createServiceToken14("jobqueue.storage.supabase");
+
+class SupabaseQueueStorage {
+  client;
+  queueName;
+  constructor(client, queueName) {
+    this.client = client;
+    this.queueName = queueName;
+  }
+  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 createTableSql = `
+    CREATE TABLE IF NOT EXISTS job_queue (
+      id SERIAL NOT NULL,
+      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
+    )`;
+    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_idx ON job_queue (id, status, run_after)`,
+      `CREATE INDEX IF NOT EXISTS job_queue_fetcher_idx ON job_queue (queue, status, run_after)`,
+      `CREATE INDEX IF NOT EXISTS jobs_fingerprint_unique_idx ON job_queue (queue, fingerprint, status)`
+    ];
+    for (const indexSql of indexes) {
+      const { error: indexError } = 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 ?? uuid43();
+    job.fingerprint = await makeFingerprint6(job.input);
+    job.status = "PENDING" /* PENDING */;
+    job.progress = 0;
+    job.progress_message = "";
+    job.progress_details = null;
+    job.created_at = now;
+    job.run_after = now;
+    const { data, error } = await this.client.from("job_queue").insert({
+      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) {
+    const { data, error } = await this.client.from("job_queue").select("*").eq("id", id).eq("queue", this.queueName).single();
+    if (error) {
+      if (error.code === "PGRST116")
+        return;
+      throw error;
+    }
+    return data;
+  }
+  async peek(status = "PENDING" /* PENDING */, num = 100) {
+    num = Number(num) || 100;
+    const { data, error } = await this.client.from("job_queue").select("*").eq("queue", this.queueName).eq("status", status).order("run_after", { ascending: true }).limit(num);
+    if (error)
+      throw error;
+    return data ?? [];
+  }
+  async next() {
+    const { data: jobs, error: selectError } = await this.client.from("job_queue").select("*").eq("queue", this.queueName).eq("status", "PENDING" /* PENDING */).lte("run_after", new Date().toISOString()).order("run_after", { ascending: true }).limit(1);
+    if (selectError)
+      throw selectError;
+    if (!jobs || jobs.length === 0)
+      return;
+    const job = jobs[0];
+    const { data: updatedJob, error: updateError } = await this.client.from("job_queue").update({
+      status: "PROCESSING" /* PROCESSING */,
+      last_ran_at: new Date().toISOString()
+    }).eq("id", job.id).eq("queue", this.queueName).select().single();
+    if (updateError)
+      throw updateError;
+    return updatedJob;
+  }
+  async size(status = "PENDING" /* PENDING */) {
+    const { count, error } = await this.client.from("job_queue").select("*", { count: "exact", head: true }).eq("queue", this.queueName).eq("status", status);
+    if (error)
+      throw error;
+    return count ?? 0;
+  }
+  async complete(jobDetails) {
+    const now = new Date().toISOString();
+    if (jobDetails.status === "DISABLED" /* DISABLED */) {
+      const { error: error2 } = await this.client.from("job_queue").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);
+      if (error2)
+        throw error2;
+      return;
+    }
+    const { data: current, error: getError } = await this.client.from("job_queue").select("run_attempts").eq("id", jobDetails.id).eq("queue", this.queueName).single();
+    if (getError)
+      throw getError;
+    const nextAttempts = (current?.run_attempts ?? 0) + 1;
+    if (jobDetails.status === "PENDING" /* PENDING */) {
+      const { error: error2 } = await this.client.from("job_queue").update({
+        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);
+      if (error2)
+        throw error2;
+      return;
+    }
+    if (jobDetails.status === "COMPLETED" /* COMPLETED */ || jobDetails.status === "FAILED" /* FAILED */) {
+      const { error: error2 } = await this.client.from("job_queue").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);
+      if (error2)
+        throw error2;
+      return;
+    }
+    const { error } = await this.client.from("job_queue").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);
+    if (error)
+      throw error;
+  }
+  async deleteAll() {
+    const { error } = await this.client.from("job_queue").delete().eq("queue", this.queueName);
+    if (error)
+      throw error;
+  }
+  async outputForInput(input) {
+    const fingerprint = await makeFingerprint6(input);
+    const { data, error } = await this.client.from("job_queue").select("output").eq("fingerprint", fingerprint).eq("queue", this.queueName).eq("status", "COMPLETED" /* COMPLETED */).single();
+    if (error) {
+      if (error.code === "PGRST116")
+        return null;
+      throw error;
+    }
+    return data?.output ?? null;
+  }
+  async abort(jobId) {
+    const { error } = await this.client.from("job_queue").update({ status: "ABORTING" /* ABORTING */ }).eq("id", jobId).eq("queue", this.queueName);
+    if (error)
+      throw error;
+  }
+  async getByRunId(job_run_id) {
+    const { data, error } = await this.client.from("job_queue").select("*").eq("job_run_id", job_run_id).eq("queue", this.queueName);
+    if (error)
+      throw error;
+    return data ?? [];
+  }
+  async saveProgress(jobId, progress, message, details) {
+    const { error } = await this.client.from("job_queue").update({
+      progress,
+      progress_message: message,
+      progress_details: details
+    }).eq("id", jobId).eq("queue", this.queueName);
+    if (error)
+      throw error;
+  }
+  async delete(jobId) {
+    const { error } = await this.client.from("job_queue").delete().eq("id", jobId).eq("queue", this.queueName);
+    if (error)
+      throw error;
+  }
+  async deleteJobsByStatusAndAge(status, olderThanMs) {
+    const cutoffDate = new Date(Date.now() - olderThanMs).toISOString();
+    const { error } = await this.client.from("job_queue").delete().eq("queue", this.queueName).eq("status", status).not("completed_at", "is", null).lte("completed_at", cutoffDate);
+    if (error)
+      throw error;
+  }
+}
+export {
+  ensureIndexedDbTable,
+  dropIndexedDbTable,
+  TabularRepository,
+  TABULAR_REPOSITORY,
+  SupabaseTabularRepository,
+  SupabaseQueueStorage,
+  SupabaseKvRepository,
+  SharedInMemoryTabularRepository,
+  SUPABASE_TABULAR_REPOSITORY,
+  SUPABASE_QUEUE_STORAGE,
+  SUPABASE_KV_REPOSITORY,
+  SHARED_IN_MEMORY_TABULAR_REPOSITORY,
+  QUEUE_STORAGE,
+  MEMORY_TABULAR_REPOSITORY,
+  MEMORY_KV_REPOSITORY,
+  KvViaTabularRepository,
+  KvRepository,
+  KV_REPOSITORY,
+  JobStatus,
+  IndexedDbTabularRepository,
+  IndexedDbQueueStorage,
+  IndexedDbKvRepository,
+  InMemoryTabularRepository,
+  InMemoryQueueStorage,
+  InMemoryKvRepository,
+  IN_MEMORY_QUEUE_STORAGE,
+  INDEXED_DB_QUEUE_STORAGE,
+  IDB_TABULAR_REPOSITORY,
+  IDB_KV_REPOSITORY,
+  DefaultKeyValueSchema,
+  DefaultKeyValueKey,
+  CachedTabularRepository,
+  CACHED_TABULAR_REPOSITORY
+};
+
+//# debugId=706648683071DA7B64756E2164756E21