@workglow/indexeddb 0.2.31 → 0.2.32

package/dist/job-queue/node.js

@@ -1,319 +1,330 @@
 // src/job-queue/IndexedDbQueueStorage.ts
-import { createServiceToken, deepEqual as deepEqual2, makeFingerprint, uuid4 } from "@workglow/util";
+import { createServiceToken, deepEqual, makeFingerprint, uuid4 } from "@workglow/util";
 import { HybridSubscriptionManager } from "@workglow/storage";
 
-// src/storage/IndexedDbTable.ts
-import { deepEqual } from "@workglow/util";
-var METADATA_STORE_NAME = "__schema_metadata__";
-async function saveSchemaMetadata(db, tableName, snapshot) {
+// src/storage/openIdb.ts
+function openIdb(dbName, options = {}) {
   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 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();
-      };
+    const req = indexedDB.open(dbName, options.version);
+    req.onsuccess = () => {
+      const db = req.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);
+    req.onupgradeneeded = (ev) => options.onUpgradeNeeded?.(ev);
+    req.onerror = () => {
+      const err = req.error;
+      if (err && err.name === "VersionError") {
+        reject(new Error(`IndexedDB ${dbName} exists at a higher version than ${options.version ?? "current"}`));
+        return;
       }
+      reject(err);
     };
-    openRequest.onblocked = () => {
-      reject(new Error(`Database ${tableName} is blocked. Close all other tabs using this database.`));
-    };
+    req.onblocked = () => reject(new Error(`IndexedDB ${dbName} is blocked — close other tabs using this database.`));
   });
 }
-async function deleteIndexedDbTable(tableName) {
-  return new Promise((resolve, reject) => {
-    const deleteRequest = indexedDB.deleteDatabase(tableName);
-    deleteRequest.onsuccess = () => resolve();
-    deleteRequest.onerror = () => reject(deleteRequest.error);
-    deleteRequest.onblocked = () => {
-      reject(new Error(`Cannot delete database ${tableName}. Close all other tabs using this database.`));
-    };
-  });
-}
-function compareSchemas(store, expectedPrimaryKey, expectedIndexes) {
-  const diff = {
-    indexesToAdd: [],
-    indexesToRemove: [],
-    indexesToModify: [],
-    primaryKeyChanged: false,
-    needsObjectStoreRecreation: false
-  };
-  const actualKeyPath = store.keyPath;
-  const normalizedExpected = Array.isArray(expectedPrimaryKey) ? expectedPrimaryKey : expectedPrimaryKey;
-  const normalizedActual = Array.isArray(actualKeyPath) ? actualKeyPath : actualKeyPath;
-  if (!deepEqual(normalizedExpected, normalizedActual)) {
-    diff.primaryKeyChanged = true;
-    diff.needsObjectStoreRecreation = true;
-    return diff;
-  }
-  const existingIndexes = new Map;
-  for (let i = 0;i < store.indexNames.length; i++) {
-    const indexName = store.indexNames[i];
-    existingIndexes.set(indexName, store.index(indexName));
-  }
-  for (const expectedIdx of expectedIndexes) {
-    const existingIdx = existingIndexes.get(expectedIdx.name);
-    if (!existingIdx) {
-      diff.indexesToAdd.push(expectedIdx);
-    } else {
-      const expectedKeyPath = Array.isArray(expectedIdx.keyPath) ? expectedIdx.keyPath : [expectedIdx.keyPath];
-      const actualKeyPath2 = Array.isArray(existingIdx.keyPath) ? existingIdx.keyPath : [existingIdx.keyPath];
-      const keyPathChanged = !deepEqual(expectedKeyPath, actualKeyPath2);
-      const uniqueChanged = existingIdx.unique !== (expectedIdx.options?.unique ?? false);
-      const multiEntryChanged = existingIdx.multiEntry !== (expectedIdx.options?.multiEntry ?? false);
-      if (keyPathChanged || uniqueChanged || multiEntryChanged) {
-        diff.indexesToModify.push(expectedIdx);
-      }
-      existingIndexes.delete(expectedIdx.name);
-    }
+
+// src/migrations/IndexedDbMigrationRunner.ts
+import {
+  MIGRATIONS_TABLE,
+  sortMigrations
+} from "@workglow/storage";
+function getIndexedDb() {
+  const idb = globalThis.indexedDB;
+  if (!idb) {
+    throw new Error("indexedDB is not available in this environment. Provide one via the IndexedDbMigrationRunner constructor or polyfill globalThis.indexedDB.");
   }
-  diff.indexesToRemove = Array.from(existingIndexes.keys());
-  return diff;
-}
-async function readAllData(store) {
-  return new Promise((resolve, reject) => {
-    const request = store.getAll();
-    request.onsuccess = () => resolve(request.result || []);
-    request.onerror = () => reject(request.error);
-  });
-}
-async function performIncrementalMigration(db, tableName, diff, options = {}) {
-  const currentVersion = db.version;
-  const newVersion = currentVersion + 1;
-  db.close();
-  options.onMigrationProgress?.(`Migrating ${tableName} from version ${currentVersion} to ${newVersion}...`, 0);
-  return openIndexedDbTable(tableName, newVersion, (event) => {
-    const transaction = event.target.transaction;
-    const store = transaction.objectStore(tableName);
-    for (const indexName of diff.indexesToRemove) {
-      options.onMigrationProgress?.(`Removing index: ${indexName}`, 0.2);
-      store.deleteIndex(indexName);
-    }
-    for (const indexDef of diff.indexesToModify) {
-      options.onMigrationProgress?.(`Updating index: ${indexDef.name}`, 0.4);
-      if (store.indexNames.contains(indexDef.name)) {
-        store.deleteIndex(indexDef.name);
-      }
-      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);
-  });
+  return idb;
 }
-async function performDestructiveMigration(db, tableName, primaryKey, expectedIndexes, options = {}, autoIncrement = false) {
-  if (!options.allowDestructiveMigration) {
-    throw new Error(`Destructive migration required for ${tableName} but not allowed. ` + `Primary key has changed. Set allowDestructiveMigration=true to proceed with data loss, ` + `or provide a dataTransformer to migrate data.`);
+
+class MigrationAbortedByOtherTabError extends Error {
+  constructor(dbName) {
+    super(`IndexedDB ${dbName} migration aborted: another tab requested a higher version`);
+    this.name = "MigrationAbortedByOtherTabError";
   }
-  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);
+}
+var RUN_LOCKS = new Map;
+
+class IndexedDbMigrationRunner {
+  dbName;
+  idb;
+  constructor(dbName, idb = getIndexedDb()) {
+    this.dbName = dbName;
+    this.idb = idb;
   }
-  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);
+  async probe() {
+    return new Promise((resolve, reject) => {
+      let settled = false;
+      const finalize = (db, outcome) => {
+        if (settled)
+          return;
+        settled = true;
+        if (db) {
+          try {
+            db.close();
+          } catch {}
         }
-        if (i % 100 === 0) {
-          options.onMigrationProgress?.(`Transformed ${i}/${existingData.length} records`, 0.4 + i / existingData.length * 0.3);
+        if (outcome.ok)
+          resolve(outcome.value);
+        else
+          reject(outcome.error);
+      };
+      const req = this.idb.open(this.dbName);
+      req.onupgradeneeded = () => {
+        if (settled)
+          return;
+        const u = req.result;
+        if (!u.objectStoreNames.contains(MIGRATIONS_TABLE)) {
+          u.createObjectStore(MIGRATIONS_TABLE, { keyPath: ["component", "version"] });
         }
-      }
-      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 = [];
-    }
+      };
+      req.onsuccess = () => {
+        if (settled)
+          return;
+        const db = req.result;
+        const currentVersion = db.version;
+        if (!db.objectStoreNames.contains(MIGRATIONS_TABLE)) {
+          finalize(db, { ok: true, value: { currentVersion, applied: new Set } });
+          return;
+        }
+        const tx = db.transaction(MIGRATIONS_TABLE, "readonly");
+        const store = tx.objectStore(MIGRATIONS_TABLE);
+        const getAll = store.getAll();
+        getAll.onsuccess = () => {
+          if (settled)
+            return;
+          const rows = getAll.result;
+          finalize(db, {
+            ok: true,
+            value: {
+              currentVersion,
+              applied: new Set(rows.map((r) => `${r.component}@${r.version}`))
+            }
+          });
+        };
+        getAll.onerror = () => {
+          if (settled)
+            return;
+          finalize(db, { ok: false, error: getAll.error });
+        };
+      };
+      req.onerror = () => {
+        if (settled)
+          return;
+        finalize(undefined, { ok: false, error: req.error });
+      };
+      req.onblocked = () => {
+        if (settled)
+          return;
+        finalize(undefined, {
+          ok: false,
+          error: new Error(`IndexedDB ${this.dbName} blocked while probing for bookkeeping store`)
+        });
+      };
+    });
   }
-  options.onMigrationProgress?.(`Recreating object store...`, 0.75);
-  const newDb = await openIndexedDbTable(tableName, newVersion, (event) => {
-    const db2 = event.target.result;
-    if (db2.objectStoreNames.contains(tableName)) {
-      db2.deleteObjectStore(tableName);
+  async ensureBookkeepingTable() {
+    await this.probe();
+  }
+  async appliedVersions(component) {
+    const { applied } = await this.probe();
+    const versions = new Set;
+    for (const key of applied) {
+      const at = key.lastIndexOf("@");
+      if (at < 0)
+        continue;
+      const c = key.slice(0, at);
+      const v = Number(key.slice(at + 1));
+      if (c === component && Number.isFinite(v))
+        versions.add(v);
     }
-    const store = db2.createObjectStore(tableName, { keyPath: primaryKey, autoIncrement });
-    for (const idx of expectedIndexes) {
-      store.createIndex(idx.name, idx.keyPath, idx.options);
+    return versions;
+  }
+  async run(migrations, options = {}) {
+    const prev = RUN_LOCKS.get(this.dbName) ?? Promise.resolve();
+    const next = prev.catch(() => {
+      return;
+    }).then(() => this.runLocked(migrations, options));
+    RUN_LOCKS.set(this.dbName, next);
+    try {
+      return await next;
+    } finally {
+      if (RUN_LOCKS.get(this.dbName) === next)
+        RUN_LOCKS.delete(this.dbName);
     }
-    if (existingData.length > 0) {
-      options.onMigrationProgress?.(`Restoring ${existingData.length} records...`, 0.8);
-      for (const record of existingData) {
+  }
+  async runLocked(migrations, options) {
+    const sorted = sortMigrations(migrations);
+    if (sorted.length === 0)
+      return [];
+    const { currentVersion, applied: alreadyApplied } = await this.probe();
+    const pending = sorted.filter((m) => !alreadyApplied.has(`${m.component}@${m.version}`));
+    if (pending.length === 0)
+      return [];
+    const targetVersion = currentVersion + 1;
+    const applied = [];
+    const onProgress = options.onProgress;
+    const buffered = [];
+    const emitLater = onProgress ? (ev) => buffered.push(ev) : undefined;
+    await new Promise((resolve, reject) => {
+      let settled = false;
+      let upgradeDb;
+      const finalize = (outcome) => {
+        if (settled)
+          return;
+        settled = true;
+        if (upgradeDb) {
+          try {
+            upgradeDb.close();
+          } catch {}
+        }
+        if (outcome.ok)
+          resolve();
+        else
+          reject(outcome.error);
+      };
+      const upreq = this.idb.open(this.dbName, targetVersion);
+      upreq.onupgradeneeded = (ev) => {
+        if (settled)
+          return;
         try {
-          store.put(record);
+          const db = upreq.result;
+          upgradeDb = db;
+          const tx = upreq.transaction;
+          const oldVersion = ev.oldVersion;
+          const newVersion = ev.newVersion ?? targetVersion;
+          db.onversionchange = () => {
+            try {
+              tx.abort();
+            } catch {}
+            finalize({ ok: false, error: new MigrationAbortedByOtherTabError(this.dbName) });
+          };
+          if (!db.objectStoreNames.contains(MIGRATIONS_TABLE)) {
+            db.createObjectStore(MIGRATIONS_TABLE, { keyPath: ["component", "version"] });
+          }
+          const meta = tx.objectStore(MIGRATIONS_TABLE);
+          for (const m of pending) {
+            emitLater?.({
+              component: m.component,
+              version: m.version,
+              phase: "starting",
+              description: m.description
+            });
+            const ctx = { db, tx, oldVersion, newVersion };
+            const result = m.up(ctx, (fraction) => {
+              emitLater?.({
+                component: m.component,
+                version: m.version,
+                phase: "running",
+                description: m.description,
+                fraction
+              });
+            });
+            if (result instanceof Promise) {
+              throw new Error(`IndexedDB migration "${m.component}@${m.version}" returned a Promise; ` + `IDB upgrade transactions cannot span async work.`);
+            }
+            meta.add({
+              component: m.component,
+              version: m.version,
+              description: m.description ?? null,
+              applied_at: new Date().toISOString()
+            });
+            applied.push(m);
+            emitLater?.({
+              component: m.component,
+              version: m.version,
+              phase: "completed",
+              description: m.description,
+              fraction: 1
+            });
+          }
         } catch (err) {
-          options.onMigrationWarning?.(`Failed to restore record: ${err}`, err);
+          try {
+            upreq.transaction?.abort();
+          } catch {}
+          const lastStart = [...buffered].reverse().find((e) => e.phase === "starting");
+          if (lastStart) {
+            emitLater?.({
+              component: lastStart.component,
+              version: lastStart.version,
+              phase: "failed",
+              description: lastStart.description,
+              error: err
+            });
+          }
+          finalize({ ok: false, error: err });
         }
+      };
+      upreq.onsuccess = () => {
+        if (settled)
+          return;
+        upgradeDb = upreq.result;
+        finalize({ ok: true });
+      };
+      upreq.onerror = () => {
+        if (settled)
+          return;
+        finalize({ ok: false, error: upreq.error });
+      };
+      upreq.onblocked = () => {
+        if (settled)
+          return;
+        finalize({
+          ok: false,
+          error: new Error(`IndexedDB ${this.dbName} upgrade blocked — close other tabs.`)
+        });
+      };
+    }).finally(() => {
+      if (onProgress) {
+        for (const ev of buffered)
+          onProgress(ev);
       }
-    }
-  });
-  options.onMigrationProgress?.(`Destructive migration complete`, 1);
-  return newDb;
+    });
+    return applied;
+  }
 }
-async function createNewDatabase(tableName, primaryKey, expectedIndexes, options = {}, autoIncrement = false) {
-  options.onMigrationProgress?.(`Creating new database: ${tableName}`, 0);
-  try {
-    await deleteIndexedDbTable(tableName);
-    await new Promise((resolve) => setTimeout(resolve, 50));
-  } catch (err) {}
-  const version = 1;
-  const db = await openIndexedDbTable(tableName, version, (event) => {
-    const db2 = event.target.result;
-    if (!db2.objectStoreNames.contains(METADATA_STORE_NAME)) {
-      db2.createObjectStore(METADATA_STORE_NAME, { keyPath: "tableName" });
-    }
-    const store = db2.createObjectStore(tableName, { keyPath: primaryKey, autoIncrement });
-    for (const idx of expectedIndexes) {
-      store.createIndex(idx.name, idx.keyPath, idx.options);
-    }
-  });
-  const snapshot = {
-    version: db.version,
-    primaryKey,
-    indexes: expectedIndexes,
-    recordCount: 0,
-    timestamp: Date.now()
-  };
-  await saveSchemaMetadata(db, tableName, snapshot);
-  options.onMigrationProgress?.(`Database created successfully`, 1);
-  return db;
+async function runIndexedDbMigrationGroups(groups, options = {}) {
+  const { idb, onProgress } = options;
+  const all = [];
+  for (const group of groups) {
+    const runner = idb ? new IndexedDbMigrationRunner(group.dbName, idb) : new IndexedDbMigrationRunner(group.dbName);
+    const applied = await runner.run(group.migrations, { onProgress });
+    all.push(...applied);
+  }
+  return all;
 }
-async function ensureIndexedDbTable(tableName, primaryKey, expectedIndexes = [], options = {}, autoIncrement = false) {
-  try {
-    let db;
-    let wasJustCreated = false;
-    try {
-      db = await openIndexedDbTable(tableName);
-      if (db.version === 1 && !db.objectStoreNames.contains(tableName)) {
-        wasJustCreated = true;
-        db.close();
-      }
-    } catch (err) {
-      options.onMigrationProgress?.(`Database ${tableName} does not exist or has version conflict, creating...`, 0);
-      return await createNewDatabase(tableName, primaryKey, expectedIndexes, options, autoIncrement);
-    }
-    if (wasJustCreated) {
-      options.onMigrationProgress?.(`Creating new database: ${tableName}`, 0);
-      try {
-        await deleteIndexedDbTable(tableName);
-        await new Promise((resolve) => setTimeout(resolve, 50));
-      } catch (err) {}
-      db = await openIndexedDbTable(tableName, 1, (event) => {
-        const db2 = event.target.result;
-        if (!db2.objectStoreNames.contains(METADATA_STORE_NAME)) {
-          db2.createObjectStore(METADATA_STORE_NAME, { keyPath: "tableName" });
-        }
-        const store2 = db2.createObjectStore(tableName, { keyPath: primaryKey, autoIncrement });
-        for (const idx of expectedIndexes) {
-          store2.createIndex(idx.name, idx.keyPath, idx.options);
-        }
-      });
-      const snapshot2 = {
-        version: db.version,
-        primaryKey,
-        indexes: expectedIndexes,
-        recordCount: 0,
-        timestamp: Date.now()
-      };
-      await saveSchemaMetadata(db, tableName, snapshot2);
-      options.onMigrationProgress?.(`Database created successfully`, 1);
-      return db;
-    }
-    if (!db.objectStoreNames.contains(METADATA_STORE_NAME)) {
-      const currentVersion = db.version;
-      db.close();
-      db = await openIndexedDbTable(tableName, currentVersion + 1, (event) => {
-        const db2 = event.target.result;
-        if (!db2.objectStoreNames.contains(METADATA_STORE_NAME)) {
-          db2.createObjectStore(METADATA_STORE_NAME, { keyPath: "tableName" });
+
+// src/migrations/indexedDbQueueMigrations.ts
+function indexedDbQueueMigrations(tableName, prefixes) {
+  const component = `queue:indexeddb:${tableName}`;
+  const prefixCols = prefixes.map((p) => p.name);
+  const k = (cols) => [...prefixCols, ...cols];
+  return [
+    {
+      component,
+      version: 1,
+      description: "Create queue object store + indexes",
+      up({ db }) {
+        if (!db.objectStoreNames.contains(tableName)) {
+          const store = db.createObjectStore(tableName, { keyPath: "id" });
+          store.createIndex("queue_status", k(["queue", "status"]), { unique: false });
+          store.createIndex("queue_status_run_after", k(["queue", "status", "run_after"]), {
+            unique: false
+          });
+          store.createIndex("queue_job_run_id", k(["queue", "job_run_id"]), { unique: false });
+          store.createIndex("queue_fingerprint_status", k(["queue", "fingerprint", "status"]), {
+            unique: false
+          });
         }
-      });
-    }
-    if (!db.objectStoreNames.contains(tableName)) {
-      options.onMigrationProgress?.(`Object store ${tableName} does not exist, creating...`, 0);
-      db.close();
-      return await createNewDatabase(tableName, primaryKey, expectedIndexes, options, autoIncrement);
-    }
-    const transaction = db.transaction(tableName, "readonly");
-    const store = transaction.objectStore(tableName);
-    const diff = compareSchemas(store, primaryKey, expectedIndexes);
-    await new Promise((resolve) => {
-      transaction.oncomplete = () => resolve();
-      transaction.onerror = () => resolve();
-    });
-    const needsMigration = diff.indexesToAdd.length > 0 || diff.indexesToRemove.length > 0 || diff.indexesToModify.length > 0 || diff.needsObjectStoreRecreation;
-    if (!needsMigration) {
-      options.onMigrationProgress?.(`Schema for ${tableName} is up to date`, 1);
-      const snapshot2 = {
-        version: db.version,
-        primaryKey,
-        indexes: expectedIndexes,
-        timestamp: Date.now()
-      };
-      await saveSchemaMetadata(db, tableName, snapshot2);
-      return db;
-    }
-    if (diff.needsObjectStoreRecreation) {
-      options.onMigrationProgress?.(`Schema change requires object store recreation for ${tableName}`, 0);
-      db = await performDestructiveMigration(db, tableName, primaryKey, expectedIndexes, options, autoIncrement);
-    } else {
-      options.onMigrationProgress?.(`Performing incremental migration for ${tableName}`, 0);
-      db = await performIncrementalMigration(db, tableName, diff, options);
+      }
     }
-    const snapshot = {
-      version: db.version,
-      primaryKey,
-      indexes: expectedIndexes,
-      timestamp: Date.now()
-    };
-    await saveSchemaMetadata(db, tableName, snapshot);
-    return db;
-  } catch (err) {
-    options.onMigrationWarning?.(`Migration failed for ${tableName}: ${err}`, err);
-    throw err;
-  }
+  ];
+}
+function indexedDbQueueMigrationGroup(tableName, prefixes) {
+  return {
+    dbName: tableName,
+    migrations: indexedDbQueueMigrations(tableName, prefixes)
+  };
 }
 
 // src/job-queue/IndexedDbQueueStorage.ts
@@ -325,14 +336,12 @@ class IndexedDbQueueStorage {
   scope = "process";
   db;
   tableName;
-  migrationOptions;
   prefixes;
   prefixValues;
   hybridManager = null;
   hybridOptions;
   constructor(queueName, options = {}) {
     this.queueName = queueName;
-    this.migrationOptions = options;
     this.prefixes = options.prefixes ?? [];
     this.prefixValues = options.prefixValues ?? {};
     this.hybridOptions = {
@@ -346,9 +355,6 @@ class IndexedDbQueueStorage {
       this.tableName = "jobs";
     }
   }
-  getPrefixColumnNames() {
-    return this.prefixes.map((p) => p.name);
-  }
   matchesPrefixes(job) {
     for (const [key, value] of Object.entries(this.prefixValues)) {
       if (job[key] !== value) {
@@ -363,37 +369,22 @@ class IndexedDbQueueStorage {
   async getDb() {
     if (this.db)
       return this.db;
-    await this.setupDatabase();
+    await this.migrate();
     return this.db;
   }
-  async setupDatabase() {
-    const prefixColumnNames = this.getPrefixColumnNames();
-    const buildKeyPath = (basePath) => {
-      return [...prefixColumnNames, ...basePath];
-    };
-    const expectedIndexes = [
-      {
-        name: "queue_status",
-        keyPath: buildKeyPath(["queue", "status"]),
-        options: { unique: false }
-      },
-      {
-        name: "queue_status_run_after",
-        keyPath: buildKeyPath(["queue", "status", "run_after"]),
-        options: { unique: false }
-      },
-      {
-        name: "queue_job_run_id",
-        keyPath: buildKeyPath(["queue", "job_run_id"]),
-        options: { unique: false }
-      },
-      {
-        name: "queue_fingerprint_status",
-        keyPath: buildKeyPath(["queue", "fingerprint", "status"]),
-        options: { unique: false }
-      }
-    ];
-    this.db = await ensureIndexedDbTable(this.tableName, "id", expectedIndexes, this.migrationOptions);
+  getMigrations() {
+    return indexedDbQueueMigrations(this.tableName, this.prefixes);
+  }
+  async migrate() {
+    if (this.db) {
+      try {
+        this.db.close();
+      } catch {}
+      this.db = undefined;
+    }
+    const runner = new IndexedDbMigrationRunner(this.tableName);
+    await runner.run(this.getMigrations());
+    this.db = await openIdb(this.tableName);
   }
   async add(job) {
     const db = await this.getDb();
@@ -836,7 +827,7 @@ class IndexedDbQueueStorage {
       this.hybridManager = new HybridSubscriptionManager(channelName, async () => {
         const jobs = await this.getAllJobs();
         return new Map(jobs.map((j) => [j.id, j]));
-      }, (a, b) => deepEqual2(a, b), {
+      }, (a, b) => deepEqual(a, b), {
         insert: (item) => ({ type: "INSERT", new: item }),
         update: (oldItem, newItem) => ({ type: "UPDATE", old: oldItem, new: newItem }),
         delete: (item) => ({ type: "DELETE", old: item })
@@ -863,7 +854,7 @@ class IndexedDbQueueStorage {
           const old = lastKnownJobs.get(id);
           if (!old) {
             callback({ type: "INSERT", new: job });
-          } else if (!deepEqual2(old, job)) {
+          } else if (!deepEqual(old, job)) {
             callback({ type: "UPDATE", old, new: job });
           }
         }
@@ -899,6 +890,59 @@ class IndexedDbQueueStorage {
 }
 // src/job-queue/IndexedDbRateLimiterStorage.ts
 import { createServiceToken as createServiceToken2 } from "@workglow/util";
+
+// src/migrations/indexedDbRateLimiterMigrations.ts
+function indexedDbRateLimiterExecutionMigrations(executionTableName, prefixes) {
+  const component = `rate-limiter:indexeddb:${executionTableName}`;
+  const prefixCols = prefixes.map((p) => p.name);
+  const k = (cols) => [...prefixCols, ...cols];
+  return [
+    {
+      component,
+      version: 1,
+      description: "Create rate-limiter execution object store + indexes",
+      up({ db }) {
+        if (!db.objectStoreNames.contains(executionTableName)) {
+          const store = db.createObjectStore(executionTableName, { keyPath: "id" });
+          store.createIndex("queue_executed_at", k(["queue_name", "executed_at"]), {
+            unique: false
+          });
+        }
+      }
+    }
+  ];
+}
+function indexedDbRateLimiterNextAvailableMigrations(nextAvailableTableName, prefixes) {
+  const component = `rate-limiter:indexeddb:${nextAvailableTableName}`;
+  const prefixCols = prefixes.map((p) => p.name);
+  const keyField = [...prefixCols, "queue_name"].join("_");
+  return [
+    {
+      component,
+      version: 1,
+      description: "Create rate-limiter next_available object store",
+      up({ db }) {
+        if (!db.objectStoreNames.contains(nextAvailableTableName)) {
+          db.createObjectStore(nextAvailableTableName, { keyPath: keyField });
+        }
+      }
+    }
+  ];
+}
+function indexedDbRateLimiterMigrationGroups(executionTableName, nextAvailableTableName, prefixes) {
+  return [
+    {
+      dbName: executionTableName,
+      migrations: indexedDbRateLimiterExecutionMigrations(executionTableName, prefixes)
+    },
+    {
+      dbName: nextAvailableTableName,
+      migrations: indexedDbRateLimiterNextAvailableMigrations(nextAvailableTableName, prefixes)
+    }
+  ];
+}
+
+// src/job-queue/IndexedDbRateLimiterStorage.ts
 var INDEXED_DB_RATE_LIMITER_STORAGE = createServiceToken2("ratelimiter.storage.indexedDb");
 
 class IndexedDbRateLimiterStorage {
@@ -907,11 +951,9 @@ class IndexedDbRateLimiterStorage {
   nextAvailableDb;
   executionTableName;
   nextAvailableTableName;
-  migrationOptions;
   prefixes;
   prefixValues;
   constructor(options = {}) {
-    this.migrationOptions = options;
     this.prefixes = options.prefixes ?? [];
     this.prefixValues = options.prefixValues ?? {};
     if (this.prefixes.length > 0) {
@@ -940,36 +982,34 @@ class IndexedDbRateLimiterStorage {
   async getExecutionDb() {
     if (this.executionDb)
       return this.executionDb;
-    await this.setupDatabase();
+    await this.migrate();
     return this.executionDb;
   }
   async getNextAvailableDb() {
     if (this.nextAvailableDb)
       return this.nextAvailableDb;
-    await this.setupDatabase();
+    await this.migrate();
     return this.nextAvailableDb;
   }
-  async setupDatabase() {
-    const prefixColumnNames = this.getPrefixColumnNames();
-    const buildKeyPath = (basePath) => {
-      return [...prefixColumnNames, ...basePath];
-    };
-    const executionIndexes = [
-      {
-        name: "queue_executed_at",
-        keyPath: buildKeyPath(["queue_name", "executed_at"]),
-        options: { unique: false }
-      }
-    ];
-    this.executionDb = await ensureIndexedDbTable(this.executionTableName, "id", executionIndexes, this.migrationOptions);
-    const nextAvailableIndexes = [
-      {
-        name: "queue_name",
-        keyPath: buildKeyPath(["queue_name"]),
-        options: { unique: true }
-      }
-    ];
-    this.nextAvailableDb = await ensureIndexedDbTable(this.nextAvailableTableName, buildKeyPath(["queue_name"]).join("_"), nextAvailableIndexes, this.migrationOptions);
+  getMigrations() {
+    return indexedDbRateLimiterMigrationGroups(this.executionTableName, this.nextAvailableTableName, this.prefixes);
+  }
+  async migrate() {
+    if (this.executionDb) {
+      try {
+        this.executionDb.close();
+      } catch {}
+      this.executionDb = undefined;
+    }
+    if (this.nextAvailableDb) {
+      try {
+        this.nextAvailableDb.close();
+      } catch {}
+      this.nextAvailableDb = undefined;
+    }
+    await runIndexedDbMigrationGroups(this.getMigrations());
+    this.executionDb = await openIdb(this.executionTableName);
+    this.nextAvailableDb = await openIdb(this.nextAvailableTableName);
   }
   async tryReserveExecution(queueName, maxExecutions, windowMs) {
     const nextIso = await this.getNextAvailableTime(queueName);
@@ -1186,10 +1226,18 @@ class IndexedDbRateLimiterStorage {
   }
 }
 export {
+  runIndexedDbMigrationGroups,
+  indexedDbRateLimiterNextAvailableMigrations,
+  indexedDbRateLimiterMigrationGroups,
+  indexedDbRateLimiterExecutionMigrations,
+  indexedDbQueueMigrations,
+  indexedDbQueueMigrationGroup,
+  MigrationAbortedByOtherTabError,
   IndexedDbRateLimiterStorage,
   IndexedDbQueueStorage,
+  IndexedDbMigrationRunner,
   INDEXED_DB_RATE_LIMITER_STORAGE,
   INDEXED_DB_QUEUE_STORAGE
 };
 
-//# debugId=57ACA1D439B2BC0064756E2164756E21
+//# debugId=676DC1BE327F4D4964756E2164756E21