indexeddbshim 17.3.2 → 17.3.4

package/dist/indexeddbshim-noninvasive.js

@@ -1,4 +1,4 @@
-/*! indexeddbshim - v17.3.2 - 8/24/2026 */
+/*! indexeddbshim - v17.3.4 - 8/25/2026 */
 
 (function (global, factory) {
   typeof exports === 'object' && typeof module !== 'undefined' ? module.exports = factory() :
@@ -3549,6 +3549,32 @@
   }
 
   var _templateObject, _templateObject2;
+  /**
+   * @param {unknown[]} arr
+   * @param {number} index
+   * @param {unknown} val
+   * @returns {void}
+   */
+  var setArrayValue = function setArrayValue(arr, index, val) {
+    if (Reflect.has(Array.prototype, index)) {
+      Object.defineProperty(arr, index, {
+        value: val,
+        enumerable: true,
+        writable: true,
+        configurable: true
+      });
+    } else {
+      arr[index] = val;
+    }
+  };
+  /**
+   * @param {unknown[]} arr
+   * @param {unknown} val
+   * @returns {void}
+   */
+  var safePush = function safePush(arr, val) {
+    return setArrayValue(arr, arr.length, val);
+  };
 
   /**
    * @typedef {NodeJS.TypedArray|DataView} ArrayBufferView
@@ -3812,6 +3838,7 @@
        * @returns {string}
        */
       encode: function encode(key) {
+        /** @type {(string|null)[]} */
         var encoded = [];
         var _iterator = _createForOfIteratorHelper(key.entries()),
           _step;
@@ -3821,14 +3848,14 @@
               i = _step$value[0],
               item = _step$value[1];
             var encodedItem = _encode(item, true); // encode the array item
-            encoded[i] = encodedItem;
+            setArrayValue(encoded, i, encodedItem);
           }
         } catch (err) {
           _iterator.e(err);
         } finally {
           _iterator.f();
         }
-        encoded.push(keyTypeToEncodedChar.invalid + '-'); // append an extra item, so empty arrays sort correctly
+        safePush(encoded, keyTypeToEncodedChar.invalid + '-'); // append an extra item, so empty arrays sort correctly
         var encodedKey = JSON.stringify(encoded);
         if (CFG.escapeNULForSQLiteStatements === false) {
           encodedKey = encodedKey.replaceAll(String.raw(_templateObject || (_templateObject = _taggedTemplateLiteral(["\0"], ["\\u0000"]))), '\0');
@@ -3849,7 +3876,7 @@
         for (var i = 0; i < decoded.length; i++) {
           var item = decoded[i];
           var decodedItem = _decode(item, true); // decode the item
-          decoded[i] = decodedItem;
+          setArrayValue(decoded, i, decodedItem);
         }
         return decoded;
       }
@@ -4147,7 +4174,7 @@
           // May throw (from binary)
           var arr = /** @type {Array<any>} */input;
           var len = arr.length;
-          seen.push(input);
+          safePush(seen, input);
 
           /** @type {(KeyValueObject|Value)[]} */
           var keys = [];
@@ -4182,7 +4209,7 @@
                 }) || fullKeys && keys.every(function (k) {
                   return cmp(k, key) !== 0;
                 })) {
-                  keys.push(fullKeys ? key : key.value);
+                  safePush(keys, fullKeys ? key : key.value);
                 }
               } catch (err) {
                 if (!multiEntry) {
@@ -4342,7 +4369,7 @@
         if (key.failure) {
           return true;
         }
-        result.push(key.value);
+        safePush(result, key.value);
         return false;
       }) ? {
         failure: true
@@ -4403,11 +4430,21 @@
     identifiers.forEach(function (identifier) {
       var hop = Object.hasOwn(value, identifier);
       if (!hop) {
-        value[identifier] = {};
+        Object.defineProperty(value, identifier, {
+          value: {},
+          enumerable: true,
+          writable: true,
+          configurable: true
+        });
       }
       value = value[identifier];
     });
-    value[(/** @type {string} */last)] = key; // key is already a `keyValue` in our processing so no need to convert
+    Object.defineProperty(value, /** @type {string} */last, {
+      value: key,
+      enumerable: true,
+      writable: true,
+      configurable: true
+    }); // key is already a `keyValue` in our processing so no need to convert
   }
 
   /**
@@ -4485,6 +4522,7 @@
    * @returns {Key[]}
    */
   function findMultiEntryMatches(keyEntry, range) {
+    /** @type {unknown[]} */
     var matches = [];
     if (Array.isArray(keyEntry)) {
       var _iterator4 = _createForOfIteratorHelper(keyEntry),
@@ -4501,13 +4539,13 @@
             } else {
               var nested = findMultiEntryMatches(key, range);
               if (nested.length > 0) {
-                matches.push(key);
+                safePush(matches, key);
               }
               continue;
             }
           }
           if (isNullish(range) || isKeyInRange(key, range, true)) {
-            matches.push(key);
+            safePush(matches, key);
           }
         }
       } catch (err) {
@@ -4516,7 +4554,7 @@
         _iterator4.f();
       }
     } else if (isNullish(range) || isKeyInRange(keyEntry, range, true)) {
-      matches.push(keyEntry);
+      safePush(matches, keyEntry);
     }
     return matches;
   }
@@ -4538,12 +4576,13 @@
         }
       case 'array':
         {
+          /** @type {ValueType[]} */
           var array = [];
           var len = value.length;
           var index = 0;
           while (index < len) {
             var entry = convertKeyToValue(value[index]);
-            array[index] = entry;
+            setArrayValue(array, index, entry);
             index++;
           }
           return array;
@@ -5303,6 +5342,7 @@
   }
 
   var uniqueID = 0;
+  var activeTransactions = new Set();
   var listeners$1 = ['onabort', 'oncomplete', 'onerror'];
   var readonlyProperties$4 = ['objectStoreNames', 'mode', 'durability', 'db', 'error'];
 
@@ -5434,6 +5474,7 @@
       me.__mode = mode;
       me.__durability = durability;
       me.__db = db;
+      activeTransactions.add(me);
       me.__error = null;
       // @ts-expect-error Part of `ShimEventTarget`
       me.__setOptions({
@@ -5946,6 +5987,7 @@
           me.__errored = true;
           throw e;
         } finally {
+          activeTransactions.delete(me);
           me.__storeHandles = {};
         }
       }
@@ -6152,13 +6194,19 @@
       });
     }
     me.__active = false; // Setting here and in requestsFinished for https://github.com/w3c/IndexedDB/issues/87
-
+    activeTransactions.delete(me);
     if (err !== null) {
       me.__error = err;
     }
-    if (me.__requestsFinished) {
+    if (me.__requestsFinished && err !== null) {
       // The transaction has already completed, so we can't call "onerror" or "onabort".
-      // So throw the error instead.
+      // So throw the error instead. `err` is only ever `null` here via
+      //   `IDBTransaction.prototype.abort`'s own `__abortTransaction(null)`
+      //   call, which now checks `__requestsFinished` itself first and
+      //   throws `InvalidStateError` synchronously before ever reaching
+      //   this point -- so this guard is just defense in depth against
+      //   `err` somehow being `null` some other way, not something this
+      //   path should see in practice.
       setTimeout(function () {
         throw err;
       }, 0);
@@ -6278,6 +6326,14 @@
     if (me.__committed) {
       throw createDOMException('InvalidStateError', 'The transaction has already been committed');
     }
+    if (me.__requestsFinished) {
+      // All requests have already finished and the transaction is
+      //   auto-committing (the async SQL commit round trip just hasn't
+      //   resolved yet) -- too late to abort per spec, even though
+      //   `__committed` itself isn't set until that round trip actually
+      //   finishes.
+      throw createDOMException('InvalidStateError', 'The transaction is already committing');
+    }
     me.__abortTransaction(null);
   };
 
@@ -6359,7 +6415,7 @@
    * @returns {void}
    */
   IDBTransaction.__assertActive = function (tx) {
-    if (!tx || !tx.__active || tx.__committed) {
+    if (!tx || !tx.__active || !tx.__handlerActive || tx.__committed) {
       throw createDOMException('TransactionInactiveError', 'A request was placed against a transaction which is currently not active, or which is finished');
     }
   };
@@ -6386,6 +6442,9 @@
   Object.defineProperty(IDBTransaction, 'prototype', {
     writable: false
   });
+  /* eslint-enable unicorn/no-top-level-side-effects -- Would be good */
+
+  IDBTransaction.activeTransactions = activeTransactions;
 
   var TypesonPromise = /*#__PURE__*/_createClass(function TypesonPromise(e) {
     _classCallCheck(this, TypesonPromise);
@@ -7772,7 +7831,7 @@
         }
       }
     },
-    k = {
+    D = {
       map: {
         test: function test(e) {
           return "Map" === toStringTag(e);
@@ -7785,7 +7844,7 @@
         }
       }
     },
-    D = {
+    R = {
       nan: {
         test: function test(e) {
           return Number.isNaN(e);
@@ -8134,8 +8193,8 @@
         revive: function revive() {}
       }
     }],
-    ne = [D, M, L, F],
-    ce = [Z, Y, re, K, ne, O, z, U, _, B, I, h, N, C].concat("function" == typeof Map ? k : [], "function" == typeof Set ? H : [], "function" == typeof ArrayBuffer ? p : [], "function" == typeof Uint8Array ? X : [], "function" == typeof DataView ? w : [], "undefined" != typeof crypto ? v : [], "undefined" != typeof BigInt ? [m, d] : [], "undefined" != typeof DOMException ? A : [], "undefined" != typeof QuotaExceededError ? W : [], "undefined" != typeof WebTransportError ? te : [], "undefined" != typeof DOMRect ? x : [], "undefined" != typeof DOMPoint ? S : [], "undefined" != typeof DOMQuad ? P : [], "undefined" != typeof DOMMatrix ? T : [], "undefined" != typeof AudioData ? f : [], "undefined" != typeof EncodedAudioChunk ? E : [], "undefined" != typeof EncodedVideoChunk ? j : [], "undefined" != typeof VideoFrame ? ee : []);
+    ne = [R, M, L, F],
+    ce = [Z, Y, re, K, ne, O, z, U, _, B, I, h, N, C].concat("function" == typeof Map ? D : [], "function" == typeof Set ? H : [], "function" == typeof ArrayBuffer ? p : [], "function" == typeof Uint8Array ? X : [], "function" == typeof DataView ? w : [], "undefined" != typeof crypto ? v : [], "undefined" != typeof BigInt ? [m, d] : [], "undefined" != typeof DOMException ? A : [], "undefined" != typeof QuotaExceededError ? W : [], "undefined" != typeof WebTransportError ? te : [], "undefined" != typeof DOMRect ? x : [], "undefined" != typeof DOMPoint ? S : [], "undefined" != typeof DOMQuad ? P : [], "undefined" != typeof DOMMatrix ? T : [], "undefined" != typeof AudioData ? f : [], "undefined" != typeof EncodedAudioChunk ? E : [], "undefined" != typeof EncodedVideoChunk ? j : [], "undefined" != typeof VideoFrame ? ee : []);
   var ue = ce.concat({
       checkDataCloneException: {
         test: function test(e) {
@@ -8152,11 +8211,56 @@
           return false;
         }
       }
+    }),
+    ye = ue.concat({
+      checkSharedArrayBufferException: {
+        test: function test(e) {
+          if ("SharedArrayBuffer" === {}.toString.call(e).slice(8, -1)) throw new DOMException("The object cannot be cloned.", "DataCloneError");
+          return false;
+        }
+      }
     });
 
   // See: https://stackoverflow.com/questions/42170826/categories-for-rejection-by-the-structured-cloning-algorithm
 
-  var typeson = new Typeson().register(ue);
+  // Although typeson-registry already has a FileList type in its structured cloning presets,
+  //   we need to override it so it works with our tests
+
+  var specSet = ye.flatMap(function (preset) {
+    return Array.isArray(preset) ? preset : [preset];
+  }).find(function (preset) {
+    return preset && !Array.isArray(preset) && 'filelist' in preset;
+  });
+  var origFileList = specSet && !Array.isArray(specSet) && 'filelist' in specSet ? specSet.filelist : undefined;
+  var origTest = origFileList && _typeof(origFileList) === 'object' && 'test' in origFileList && typeof origFileList.test === 'function' ? origFileList.test : undefined;
+  var origRevive = origFileList && _typeof(origFileList) === 'object' && 'revive' in origFileList && typeof origFileList.revive === 'function' ? origFileList.revive : undefined;
+  var customFileList = origFileList ? _objectSpread2(_objectSpread2({}, origFileList), {}, {
+    /**
+     * @param {unknown} x
+     * @param {import('typeson').StateObject} state
+     * @returns {boolean}
+     */
+    test: function test(x, state) {
+      if (typeof FileList !== 'undefined') {
+        return x instanceof FileList;
+      }
+      return typeof origTest === 'function' ? origTest(x, state) : false;
+    },
+    /**
+     * @param {unknown} x
+     * @param {import('typeson').StateObject} state
+     * @returns {unknown}
+     */
+    revive: function revive(x, state) {
+      if (typeof FileList !== 'undefined') {
+        return Reflect.construct(FileList, [x]);
+      }
+      return typeof origRevive === 'function' ? origRevive(x, state) : undefined;
+    }
+  }) : undefined;
+  var typeson = new Typeson().register([ye, customFileList ? {
+    filelist: customFileList
+  } : {}]);
 
   /**
    * @param {(preset: import('typeson-registry').Preset) =>
@@ -8165,7 +8269,7 @@
    */
   function register(func) {
     // eslint-disable-next-line unicorn/no-top-level-assignment-in-function -- Should be one-time cache
-    typeson = new Typeson().register(func(ue));
+    typeson = new Typeson().register(func(ye));
   }
 
   /**
@@ -11092,7 +11196,29 @@
         return new SyncPromise(function (resolve) {
           setTimeout(function () {
             entry.dispatchEvent(e); // No need to catch errors
-            resolve(undefined);
+            // Unlike a native `Promise`, `SyncPromise#then` chains
+            //   synchronously off `resolve()` (verified directly:
+            //   `SyncPromise.resolve().then(cb)` runs `cb` before
+            //   even the calling code below it finishes) -- so
+            //   resolving immediately here would let the
+            //   `connectionsClosed()` check below run before a
+            //   same-task-but-microtask-later continuation of a
+            //   `versionchange` listener above (e.g. an `await`-
+            //   based one that then calls `db.close()`, as in
+            //   `transaction-lifetime.any.js`) ever gets a turn,
+            //   incorrectly firing `blocked` even though the
+            //   connection was about to close in time. Give real
+            //   microtask-deferred continuations a small, bounded
+            //   number of turns first -- same pattern as
+            //   `IDBTransaction.js`'s `checkQueueEntry`.
+            var attemptsLeft = 10;
+            (function wait() {
+              if (attemptsLeft-- <= 0) {
+                resolve(undefined);
+                return;
+              }
+              queueMicrotask(wait);
+            })();
           }, 0);
         });
       });
@@ -11152,6 +11278,23 @@
    */
   var websqlDBCache = {};
 
+  /**
+   * Tracks databases with a creation/upgrade currently in flight but not yet
+   *   committed or aborted -- keyed by (unescaped) database name. The
+   *   `dbVersions` row in `sysdb` these entries shadow is written *before*
+   *   `upgradeneeded` is even dispatched to user code (as the success
+   *   callback of that very `INSERT`/`UPDATE`), on the same shared `sysdb`
+   *   connection `databases()` itself reads from -- so, absent this, a
+   *   `databases()` call made while an upgrade is still pending would see
+   *   the new row (or new version) immediately, rather than only once the
+   *   corresponding `versionchange` transaction has genuinely committed, as
+   *   required by `get-databases.any.js`'s "doesn't pick up changes that
+   *   haven't committed" test. `IDBFactory.prototype.databases` filters
+   *   its SQL results against this map.
+   * @type {Map<string, {oldVersion: Integer, newVersion: Integer}>}
+   */
+  var pendingVersionChanges = new Map();
+
   /** @type {import('websql-configurable/lib/websql/WebSQLDatabase.js').default} */
   var sysdb;
   var nameCounter = 0;
@@ -11425,6 +11568,7 @@
     }
     var req = IDBOpenDBRequest.__createInstance();
     var calledDbCreateError = false;
+    var isRevertingSysdb = false;
     if (CFG.autoName && name === '') {
       // eslint-disable-next-line unicorn/no-top-level-assignment-in-function -- Necessary?
       name = 'autoNamedDatabase_' + nameCounter++;
@@ -11451,9 +11595,22 @@
      * @returns {boolean}
      */
     function dbCreateError(tx, err) {
-      if (calledDbCreateError) {
+      if (calledDbCreateError || isRevertingSysdb) {
         return false;
       }
+      // Defensive cleanup: `pendingVersionChanges.set(name, ...)` (see
+      //   below) runs *before* the `dbVersions` `INSERT`/`UPDATE` it
+      //   guards is even attempted, but only `versionSet`'s own
+      //   `on__beforecomplete`/`on__preabort` handlers ever clear it --
+      //   and `versionSet` never runs at all if that `INSERT`/`UPDATE`,
+      //   or an earlier step in this same `open()` flow, fails first.
+      //   Without this, such a failure would leave the entry orphaned
+      //   forever, silently corrupting `databases()` for any *other*,
+      //   unrelated later `open()` call that happens to reuse the same
+      //   database name (common in WPT tests, e.g. generic names like
+      //   "DB1"/"TestDatabase" reused across different test files in
+      //   the same process). A no-op if no entry was ever set.
+      pendingVersionChanges.delete(name);
       var er = err ? webSQLErrback(err) : (/** @type {Error} */tx);
       calledDbCreateError = true;
       // Re: why bubbling here (and how cancelable is only really relevant for `window.onerror`) see: https://github.com/w3c/IndexedDB/issues/86
@@ -11502,36 +11659,46 @@
              */
             var sysdbFinishedCb = function sysdbFinishedCb(systx, err, cb) {
               if (err) {
-                try {
-                  systx.executeSql('ROLLBACK', [], cb, cb);
-                } catch (err) {
-                  // Browser may fail with expired transaction above so
-                  //     no choice but to manually revert
+                /**
+                 * @param {any} [errorToShow]
+                 * @returns {void}
+                 */
+                var manualRevert = function manualRevert(errorToShow) {
+                  /**
+                   * @param {string} [msg]
+                   * @throws {Error}
+                   * @returns {never}
+                   */
+                  function reportError(msg) {
+                    throw new Error('Unable to roll back upgrade transaction!' + (msg || ''));
+                  }
                   sysdb.transaction(function (systx) {
-                    /**
-                     *
-                     * @param {string} msg
-                     * @throws {Error}
-                     * @returns {never}
-                     */
-                    function reportError(msg) {
-                      throw new Error('Unable to roll back upgrade transaction!' + (msg || ''));
-                    }
-
                     // Attempt to revert
                     if (oldVersion === 0) {
-                      systx.executeSql('DELETE FROM dbVersions WHERE "name" = ?', [sqlSafeName], function () {
-                        // @ts-expect-error Force to work
-                        cb(reportError); // eslint-disable-line promise/no-callback-in-promise -- Convenient
-                      },
-                      // @ts-expect-error Force to work
-                      reportError);
+                      systx.executeSql('DELETE FROM dbVersions WHERE "name" = ?', [sqlSafeName]);
                     } else {
-                      systx.executeSql('UPDATE dbVersions SET "version" = ? WHERE "name" = ?', [oldVersion, sqlSafeName], cb,
-                      // @ts-expect-error Force to work
-                      reportError);
+                      systx.executeSql('UPDATE dbVersions SET "version" = ? WHERE "name" = ?', [oldVersion, sqlSafeName]);
                     }
+                  }, function (sqlErr) {
+                    isRevertingSysdb = false;
+                    cb(sqlErr); // eslint-disable-line promise/no-callback-in-promise -- Convenient
+                  }, function () {
+                    isRevertingSysdb = false;
+                    cb(errorToShow || reportError); // eslint-disable-line promise/no-callback-in-promise -- Convenient
                   });
+                };
+                try {
+                  systx.executeSql('ROLLBACK', [], function () {
+                    cb(); // eslint-disable-line promise/no-callback-in-promise -- Convenient
+                  }, function (tx, sqlErr) {
+                    // Browser/Node may fail with expired transaction, so manually revert
+                    manualRevert(sqlErr);
+                    return false;
+                  });
+                } catch (e) {
+                  // Browser may fail with expired transaction above so
+                  //     no choice but to manually revert
+                  manualRevert(e);
                 }
                 return;
               }
@@ -11565,22 +11732,43 @@
                   //   open/close the transaction's active-handler window itself.
                   req.transaction.__handlerActive = true;
                   req.dispatchEvent(e);
-                  // Give any same-tick microtask scheduled from within the
+                  // Give any microtask-scheduled continuation of the
                   //   `upgradeneeded` handler (e.g. a plain
-                  //   `Promise.resolve().then(...)`) a chance to run -- and still
-                  //   observe the transaction as active -- before we deactivate it
-                  //   again, per https://github.com/w3c/IndexedDB/issues/87. Only
-                  //   the flag reset itself is deferred here -- unlike
-                  //   `IDBTransaction.js`'s `advanceAfterDispatch`, `finished()`
-                  //   (this transaction's own queue-advancement/completion signal)
-                  //   still runs synchronously, at exactly its previous timing: an
-                  //   earlier attempt at deferring `finished()` too raced against
-                  //   unrelated test setup that assumed a freshly deleted/created
-                  //   database's upgrade transaction had already fully completed by
-                  //   the time this function returns.
-                  queueMicrotask(function () {
-                    req.transaction.__handlerActive = false;
-                  });
+                  //   `Promise.resolve().then(...)`, or an `await`-based
+                  //   continuation of a promise resolved from within the handler,
+                  //   such as testharness.js's own `EventWatcher`) a chance to
+                  //   run -- and still observe the transaction as active -- before
+                  //   we deactivate it again, per
+                  //   https://github.com/w3c/IndexedDB/issues/87. A single deferred
+                  //   tick isn't always enough: an `await`-based continuation can
+                  //   take more than one microtask turn to resume (e.g.
+                  //   `transaction-lifetime.any.js`'s `EventWatcher`-based
+                  //   `await eventWatcher.wait_for('upgradeneeded')`), so retry a
+                  //   small, bounded number of times first -- same pattern as
+                  //   `IDBTransaction.js`'s `checkQueueEntry` -- rather than
+                  //   resetting after only one. Only the flag reset itself is
+                  //   deferred here -- unlike `IDBTransaction.js`'s
+                  //   `advanceAfterDispatch`, `finished()` (this transaction's own
+                  //   queue-advancement/completion signal) still runs
+                  //   synchronously, at exactly its previous timing: an earlier
+                  //   attempt at deferring `finished()` too raced against unrelated
+                  //   test setup that assumed a freshly deleted/created database's
+                  //   upgrade transaction had already fully completed by the time
+                  //   this function returns.
+                  /**
+                   * @param {Integer} attemptsLeft
+                   * @returns {void}
+                   */
+                  function deferHandlerActiveReset(attemptsLeft) {
+                    if (attemptsLeft <= 0) {
+                      req.transaction.__handlerActive = false;
+                      return;
+                    }
+                    queueMicrotask(function () {
+                      deferHandlerActiveReset(attemptsLeft - 1);
+                    });
+                  }
+                  deferHandlerActiveReset(10);
                   if (e.__legacyOutputDidListenersThrowError) {
                     logError('Error', 'An error occurred in an upgradeneeded handler attached to request chain', /** @type {Error} */e.__legacyOutputDidListenersThrowError); // We do nothing else with this error as per spec
                     req.transaction.__abortTransaction(createDOMException('AbortError', 'A request was aborted.'));
@@ -11596,6 +11784,7 @@
                  * @returns {void}
                  */
                 function (ev) {
+                  pendingVersionChanges.delete(name);
                   connection.__upgradeTransaction = null;
                   /** @type {import('./IDBDatabase.js').IDBDatabaseFull} */
                   req.__result.__versionTransaction = null;
@@ -11610,6 +11799,8 @@
 
                 // eslint-disable-next-line camelcase -- Clear API
                 req.transaction.on__preabort = function () {
+                  isRevertingSysdb = true;
+                  pendingVersionChanges.delete(name);
                   connection.__upgradeTransaction = null;
                   // We ensure any cache is deleted before any request error events fire and try to reopen
                   if (useDatabaseCache) {
@@ -11626,6 +11817,7 @@
                   req.__result = undefined;
                   req.__done = false;
                   connection.close();
+                  isRevertingSysdb = true;
                   setTimeout(function () {
                     var err = createDOMException('AbortError', 'The upgrade transaction was aborted.');
                     sysdbFinishedCb(systx, err, function (reportError) {
@@ -11672,6 +11864,10 @@
                   // });
                 };
               }
+              pendingVersionChanges.set(name, {
+                oldVersion: oldVersion,
+                newVersion: version
+              });
               if (oldVersion === 0) {
                 systx.executeSql('INSERT INTO dbVersions VALUES (?,?)', [sqlSafeName, version], versionSet, dbCreateError);
               } else {
@@ -11683,7 +11879,26 @@
               }
               sysdbFinishedCb = function sysdbFinishedCb(systx, err, cb) {
                 if (err) {
-                  rollback(err, cb);
+                  rollback(err,
+                  /**
+                   * @param {Error} [reportError]
+                   * @returns {void}
+                   */
+                  function (reportError) {
+                    sysdb.transaction(function (systx) {
+                      if (oldVersion === 0) {
+                        systx.executeSql('DELETE FROM dbVersions WHERE "name" = ?', [sqlSafeName]);
+                      } else {
+                        systx.executeSql('UPDATE dbVersions SET "version" = ? WHERE "name" = ?', [oldVersion, sqlSafeName]);
+                      }
+                    }, function (sqlErr) {
+                      isRevertingSysdb = false;
+                      cb(sqlErr); // eslint-disable-line promise/no-callback-in-promise -- Convenient
+                    }, function () {
+                      isRevertingSysdb = false;
+                      cb(reportError); // eslint-disable-line promise/no-callback-in-promise -- Convenient
+                    });
+                  });
                 } else {
                   commit(cb);
                 }
@@ -11974,6 +12189,15 @@
   IDBFactory.prototype.databases = function () {
     var me = this;
     var calledDbCreateError = false;
+    // Snapshotted *now*, synchronously, at call time -- not read later
+    // from inside the SQL query's callback below, which runs on a
+    //   deferred macrotask (see `nodeSQLiteDatabase.js`'s `exec`) and so
+    //   could otherwise race against (and lose to) an in-flight upgrade's
+    //   own commit/abort handler clearing its `pendingVersionChanges`
+    //   entry in the meantime -- which would make this method incorrectly
+    //   reflect a since-committed change that hadn't committed yet when
+    //   it was actually called.
+    var pendingVersionChangesSnapshot = new Map(pendingVersionChanges);
     return new Promise(function (resolve, reject) {
       // eslint-disable-line promise/avoid-new -- Own polyfill
       if (!(me instanceof IDBFactory)) {
@@ -12003,10 +12227,29 @@
             var dbNames = [];
             for (var i = 0; i < data.rows.length; i++) {
               var _data$rows$item2 = /** @type {{name: string, version: Integer}} */data.rows.item(i),
-                name = _data$rows$item2.name,
+                encodedName = _data$rows$item2.name,
                 version = _data$rows$item2.version;
+              var name = unescapeSQLiteResponse(encodedName);
+              // A row for a database whose creation/upgrade hasn't
+              //   committed yet (see `pendingVersionChanges`) must
+              //   not reflect that in-flight change: a brand new
+              //   database (`oldVersion === 0`) isn't reported at
+              //   all until its creation commits, and an existing
+              //   database being upgraded is still reported, but
+              //   with its pre-upgrade version.
+              var pending = pendingVersionChangesSnapshot.get(name);
+              if (pending) {
+                if (pending.oldVersion === 0) {
+                  continue;
+                }
+                dbNames.push({
+                  name: name,
+                  version: pending.oldVersion
+                });
+                continue;
+              }
               dbNames.push({
-                name: unescapeSQLiteResponse(name),
+                name: name,
                 version: version
               });
             }
@@ -12426,9 +12669,26 @@
       // Key.convertValueToKey(key); // Already checked by `continue` or `continuePrimaryKey`
       sqlValues.push(/** @type {string} */_encode(key));
     } else if (continueCall && me.__key !== undefined) {
-      sql.push('AND', quotedKeyColumnName, op + ' ?');
       // Key.convertValueToKey(me.__key); // Already checked when stored
-      sqlValues.push(/** @type {string} */_encode(me.__key));
+      if (!me.__unique && me.__keyColumnName !== 'key' && me.__primaryKey !== undefined) {
+        // A plain `continue()` on a non-unique index cursor must find
+        //   the next record strictly after the (key, primaryKey) pair
+        //   this cursor last returned -- a scalar `key > lastKey` alone
+        //   would wrongly exclude a *different*, not-yet-visited record
+        //   that's still tied on key with the last one (e.g. another
+        //   record that always had that same indexed value), and would
+        //   also wrongly re-admit the *same* record forever if a
+        //   same-transaction `update()` bumped its own key back above
+        //   the threshold, since a scalar comparison can't distinguish
+        //   "some other record newly tied" from "this record moved
+        //   past its own last position." Comparing the full tuple (via
+        //   this OR) against both key and primary key resolves both.
+        sql.push('AND (', quotedKeyColumnName, op, '?', 'OR (', quotedKeyColumnName, '= ?', 'AND', quotedKey, op, '?))');
+        sqlValues.push(/** @type {string} */_encode(me.__key), /** @type {string} */_encode(me.__key), /** @type {string} */_encode(me.__primaryKey));
+      } else {
+        sql.push('AND', quotedKeyColumnName, op + ' ?');
+        sqlValues.push(/** @type {string} */_encode(me.__key));
+      }
     }
     if (!me.__count) {
       // 1. Sort by key
@@ -13058,9 +13318,15 @@
      * @returns {void}
      */
     function addToQueue(clonedValue) {
-      // We set the `invalidateCache` argument to `false` since the old value shouldn't be accessed
+      // `invalidateCache: true` so any cursor on this store (including
+      //   this one) drops its prefetched row batch, forcing its next
+      //   `continue()` to re-query live rather than serve rows snapshotted
+      //   before this update -- needed for the compound-tuple
+      //   continuation logic in `__findBasic` to see this update's
+      //   effect on ordering (see "Modify records during cursor
+      //   iteration" in idbcursor_update_index.any.js).
       // @ts-ignore -- API (not erring in TS 6)
-      IDBObjectStore.__storingRecordObjectStore(request, me.__store, false, clonedValue, false, key);
+      IDBObjectStore.__storingRecordObjectStore(request, me.__store, true, clonedValue, false, key);
     }
     if (me.__store.keyPath !== null) {
       var _me$__store$__validat = me.__store.__validateKeyAndValueAndCloneValue(valueToUpdate, undefined, true),