indexeddbshim 17.3.1 → 17.3.3

package/dist/indexeddbshim-UnicodeIdentifiers.js

@@ -1,4 +1,4 @@
-/*! indexeddbshim - v17.3.1 - 8/24/2026 */
+/*! indexeddbshim - v17.3.3 - 8/25/2026 */
 
 (function (factory) {
   typeof define === 'function' && define.amd ? define(factory) :
@@ -6161,9 +6161,15 @@
     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);
@@ -6283,6 +6289,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);
   };
 
@@ -6607,22 +6621,22 @@
             sync: true
           }, this.options), s),
           c = i.sync,
-          y = {},
-          u = [],
+          u = {},
+          y = [],
           l = [],
           p = [],
           f = !("cyclic" in i) || i.cyclic,
           d = i.encapsulateObserver,
           m = i.encapsulateError,
           finish = function finish(e) {
-            var t = Object.values(y);
+            var t = Object.values(u);
             if (i.iterateNone) return t.length ? t[0] : getJSONType(e);
             if (t.length) {
               if (i.returnTypeNames) return _toConsumableArray(new Set(t));
-              e && isPlainObject(e) && !n(e, "$types") ? e.$types = y : e = {
+              e && isPlainObject(e) && !n(e, "$types") ? e.$types = u : e = {
                 $: e,
                 $types: {
-                  $: y
+                  $: u
                 }
               };
             } else isObject(e) && n(e, "$types") && (e = {
@@ -6646,18 +6660,18 @@
                     _context2.n = 2;
                     return Promise.all(r.map(/*#__PURE__*/function () {
                       var _ref = _asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee(r) {
-                        var n, _t$splice, _t$splice2, a, _a, o, s, i, c, y, u, l, p, _t, _t2, _t3, _t4;
+                        var n, _t$splice, _t$splice2, a, _a, o, s, i, c, u, y, l, p, _t, _t2, _t3, _t4;
                         return _regenerator().w(function (_context) {
                           while (1) switch (_context.n) {
                             case 0:
-                              n = [], _t$splice = t.splice(0, 1), _t$splice2 = _slicedToArray(_t$splice, 1), a = _t$splice2[0], _a = _slicedToArray(a, 7), o = _a[0], s = _a[2], i = _a[3], c = _a[4], y = _a[5], u = _a[6], l = _encapsulate2(o, r, s, i, n, true, u), p = hasConstructorOf(l, TypesonPromise);
+                              n = [], _t$splice = t.splice(0, 1), _t$splice2 = _slicedToArray(_t$splice, 1), a = _t$splice2[0], _a = _slicedToArray(a, 7), o = _a[0], s = _a[2], i = _a[3], c = _a[4], u = _a[5], y = _a[6], l = _encapsulate2(o, r, s, i, n, true, y), p = hasConstructorOf(l, TypesonPromise);
                               if (!(o && p)) {
                                 _context.n = 2;
                                 break;
                               }
                               _t2 = setOwnEnumerable;
                               _t3 = c;
-                              _t4 = y;
+                              _t4 = u;
                               _context.n = 1;
                               return l.p;
                             case 1:
@@ -6666,7 +6680,7 @@
                               _context.n = 3;
                               break;
                             case 2:
-                              _t = (o ? setOwnEnumerable(c, y, l) : e = p ? l.p : l, _checkPromises(e, n));
+                              _t = (o ? setOwnEnumerable(c, u, l) : e = p ? l.p : l, _checkPromises(e, n));
                             case 3:
                               return _context.a(2, _t);
                           }
@@ -6745,11 +6759,11 @@
             })) : h = t, b && b(), h;
             if (null === t) return b && b(), t;
             if (o && t && "object" == _typeof(t) && !s.iterateIn && !s.iterateUnsetNumeric) {
-              var _r2 = u.indexOf(t);
-              if (-1 !== _r2) return y[e] = "#", b && b({
+              var _r2 = y.indexOf(t);
+              if (-1 !== _r2) return u[e] = "#", b && b({
                 cyclicKeypath: l[_r2]
               }), "#" + l[_r2];
-              true === o && (u.push(t), l.push(e));
+              true === o && (y.push(t), l.push(e));
             }
             var v = isPlainObject(t),
               w = a(t),
@@ -6819,14 +6833,14 @@
           },
           replace = function replace(e, t, r, n, a, o, s) {
             var i = a ? _this2.plainObjectReplacers : _this2.nonplainObjectReplacers;
-            var u = i.length;
-            for (; u--;) {
-              var _a3 = i[u];
+            var y = i.length;
+            for (; y--;) {
+              var _a3 = i[y];
               if (_a3.test(t, r)) {
                 var _i2 = _a3.type;
                 if (Object.hasOwn(_this2.revivers, _i2)) {
-                  var _t5 = y[e];
-                  y[e] = _t5 ? [_i2].concat(_t5) : _i2;
+                  var _t5 = u[e];
+                  u[e] = _t5 ? [_i2].concat(_t5) : _i2;
                 }
                 if (Object.assign(r, {
                   type: _i2,
@@ -6834,14 +6848,14 @@
                 }), (c || !_a3.replaceAsync) && !_a3.replace) return s && s({
                   typeDetected: true
                 }), _encapsulate2(e, t, f && "readonly", r, n, o, _i2);
-                var _u = void 0;
+                var _y = void 0;
                 if (s && s({
                   replacing: true
                 }), c || !_a3.replaceAsync) {
                   if (void 0 === _a3.replace) throw new TypeError("Missing replacer");
-                  _u = _a3.replace(t, r);
-                } else _u = _a3.replaceAsync(t, r);
-                return _encapsulate2(e, _u, f && "readonly", r, n, o, _i2);
+                  _y = _a3.replace(t, r);
+                } else _y = _a3.replaceAsync(t, r);
+                return _encapsulate2(e, _y, f && "readonly", r, n, o, _i2);
               }
             }
             return t;
@@ -6889,8 +6903,8 @@
         if (true === i) return finishRevival(e.$);
         if (!i || "object" != _typeof(i) || Array.isArray(i)) return finishRevival(e);
         var c = [],
-          y = Object.create(null),
-          u = {};
+          u = Object.create(null),
+          y = {};
         var l = true;
         i.$ && isPlainObject(i.$) && (e = e.$, i = i.$, l = false);
         var executeReviver = function executeReviver(e, t) {
@@ -6900,8 +6914,8 @@
               r = _ref5[0];
             if (!r) throw new Error("Unregistered type: " + e);
             if (s && !("revive" in r)) return t;
-            if (!s && r.reviveAsync) return r.reviveAsync(t, u);
-            if (r.revive) return r.revive(t, u);
+            if (!s && r.reviveAsync) return r.reviveAsync(t, y);
+            if (r.revive) return r.revive(t, y);
             throw new Error("Missing reviver");
           },
           p = [];
@@ -6946,7 +6960,7 @@
         var d;
         return hasConstructorOf(f, TypesonPromise) ? d = f.then(function () {
           return e;
-        }) : (d = function _revive(e, t, o, u, f) {
+        }) : (d = function _revive(e, t, o, y, f) {
           if (l && "$types" === e) return;
           var d = p.length,
             m = n(i, e) ? i[e] : void 0,
@@ -6967,18 +6981,18 @@
                 _t6 = _c$[1],
                 _r5 = _c$[2],
                 _a5 = _c$[3],
-                _o2 = n(y, _t6),
-                _s = _o2 ? y[_t6] : getByKeyPath(_e2, _t6);
+                _o2 = n(u, _t6),
+                _s = _o2 ? u[_t6] : getByKeyPath(_e2, _t6);
               if (!_o2 && void 0 === _s) break;
               setOwnEnumerable(_r5, _a5, _s), c.shift();
             }
           }
-          if (!m) return y[e] = t, t;
+          if (!m) return u[e] = t, t;
           if ("#" === m) {
             var _e3 = t.slice(1),
-              _r6 = n(y, _e3),
-              _a6 = _r6 ? y[_e3] : getByKeyPath(o, _e3);
-            return _r6 || void 0 !== _a6 || c.push([o, _e3, u, f]), _a6;
+              _r6 = n(u, _e3),
+              _a6 = _r6 ? u[_e3] : getByKeyPath(o, _e3);
+            return _r6 || void 0 !== _a6 || c.push([o, _e3, y, f]), _a6;
           }
           var applyType = function applyType(t) {
             var r = [].concat(m).reduce(function reducer(e, t) {
@@ -6989,8 +7003,8 @@
               return executeReviver(t, e);
             }, t);
             return hasConstructorOf(r, TypesonPromise) ? r.then(function (t) {
-              return y[e] = t, t;
-            }) : (y[e] = r, r);
+              return u[e] = t, t;
+            }) : (u[e] = r, r);
           };
           return !s && p.length > d ? TypesonPromise.all(p.slice(d)).then(function () {
             return applyType(t);
@@ -7095,8 +7109,8 @@
   });
   Undefined.__typeson__type__ = "TypesonUndefined";
   var s = ["null", "boolean", "number", "string", "array", "object"];
-  for (var i = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/", c = new Uint8Array(256), y = 0; y < 64; y++) c[i.codePointAt(y)] = y;
-  var u = function encode(e, t, r) {
+  for (var i = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/", c = new Uint8Array(256), u = 0; u < 64; u++) c[i.codePointAt(u)] = u;
+  var y = function encode(e, t, r) {
       null == r && (r = e.byteLength);
       for (var n = new Uint8Array(e, 0, r), a = n.length, o = "", s = 0; s < a; s += 3) o += i[n[s] >> 2], o += i[(3 & n[s]) << 4 | n[s + 1] >> 4], o += i[(15 & n[s + 1]) << 2 | n[s + 2] >> 6], o += i[63 & n[s + 2]];
       return a % 3 == 2 ? o = o.slice(0, -1) + "=" : a % 3 == 1 && (o = o.slice(0, -2) + "=="), o;
@@ -7109,10 +7123,10 @@
         o,
         s,
         i = .75 * e.length,
-        y = 0;
+        u = 0;
       "=" === e[e.length - 1] && (i--, "=" === e[e.length - 2] && i--);
-      for (var u = new ArrayBuffer(i, t), l = new Uint8Array(u), p = 0; p < r; p += 4) n = c[e.codePointAt(p)], a = c[e.codePointAt(p + 1)], o = c[e.codePointAt(p + 2)], s = c[e.codePointAt(p + 3)], l[y++] = n << 2 | a >> 4, l[y++] = (15 & a) << 4 | o >> 2, l[y++] = (3 & o) << 6 | 63 & s;
-      return u;
+      for (var y = new ArrayBuffer(i, t), l = new Uint8Array(y), p = 0; p < r; p += 4) n = c[e.codePointAt(p)], a = c[e.codePointAt(p + 1)], o = c[e.codePointAt(p + 2)], s = c[e.codePointAt(p + 3)], l[u++] = n << 2 | a >> 4, l[u++] = (15 & a) << 4 | o >> 2, l[u++] = (3 & o) << 6 | 63 & s;
+      return y;
     };
   var p = {
       arraybuffer: {
@@ -7125,7 +7139,7 @@
           return -1 !== r ? {
             index: r
           } : (t.buffers.push(e), {
-            s: u(e),
+            s: y(e),
             maxByteLength: e.maxByteLength,
             resizable: e.resizable
           });
@@ -7159,13 +7173,13 @@
             });
             i.push(_r0), c += _r0;
           }
-          var y = new ArrayBuffer(c);
-          var u = 0;
+          var u = new ArrayBuffer(c);
+          var y = 0;
           for (var _t9 = 0; _t9 < s; _t9++) {
-            var _r1 = new Uint8Array(y, u, i[_t9]);
+            var _r1 = new Uint8Array(u, y, i[_t9]);
             e.copyTo(_r1, {
               planeIndex: _t9
-            }), u += i[_t9];
+            }), y += i[_t9];
           }
           return {
             format: t,
@@ -7173,7 +7187,7 @@
             numberOfFrames: n,
             numberOfChannels: a,
             timestamp: o,
-            data: y
+            data: u
           };
         },
         revive: function revive(_ref11) {
@@ -7324,7 +7338,7 @@
             byteOffset: t,
             byteLength: r
           } : (n.buffers.push(e), {
-            encoded: u(e),
+            encoded: y(e),
             maxByteLength: e.maxByteLength,
             resizable: e.resizable,
             byteOffset: t,
@@ -7956,7 +7970,7 @@
           } : (n.buffers.push(e), {
             maxByteLength: e.maxByteLength,
             resizable: e.resizable,
-            encoded: u(e),
+            encoded: y(e),
             byteOffset: t,
             length: r
           });
@@ -7969,10 +7983,10 @@
             s = t.index,
             i = t.maxByteLength,
             c = t.resizable;
-          var y;
-          return "index" in t ? y = r.buffers[s] : (y = l(o, c ? {
+          var u;
+          return "index" in t ? u = r.buffers[s] : (u = l(o, c ? {
             maxByteLength: i
-          } : void 0), r.buffers.push(y)), new e(y, n, a);
+          } : void 0), r.buffers.push(u)), new e(u, n, a);
         }
       };
     }(e);
@@ -8011,12 +8025,12 @@
         replaceAsync: function replaceAsync(e) {
           return new TypesonPromise(/*#__PURE__*/function () {
             var _ref29 = _asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee6(t, r) {
-              var _r12, _n3, _a7, _o3, _s2, _i3, _c, _y, _u2, _l, _t14;
+              var _r12, _n3, _a7, _o3, _s2, _i3, _c, _u, _y2, _l, _t14;
               return _regenerator().w(function (_context6) {
                 while (1) switch (_context6.p = _context6.n) {
                   case 0:
                     _context6.p = 0;
-                    _r12 = e.format, _n3 = e.codedWidth, _a7 = e.codedHeight, _o3 = e.timestamp, _s2 = e.duration, _i3 = e.visibleRect, _c = e.displayWidth, _y = e.displayHeight, _u2 = e.colorSpace, _l = new ArrayBuffer(e.allocationSize());
+                    _r12 = e.format, _n3 = e.codedWidth, _a7 = e.codedHeight, _o3 = e.timestamp, _s2 = e.duration, _i3 = e.visibleRect, _c = e.displayWidth, _u = e.displayHeight, _y2 = e.colorSpace, _l = new ArrayBuffer(e.allocationSize());
                     _context6.n = 1;
                     return e.copyTo(_l);
                   case 1:
@@ -8033,12 +8047,12 @@
                         height: _i3.height
                       },
                       displayWidth: _c,
-                      displayHeight: _y,
+                      displayHeight: _u,
                       colorSpace: {
-                        primaries: _u2.primaries,
-                        transfer: _u2.transfer,
-                        matrix: _u2.matrix,
-                        fullRange: _u2.fullRange
+                        primaries: _y2.primaries,
+                        transfer: _y2.transfer,
+                        matrix: _y2.matrix,
+                        fullRange: _y2.fullRange
                       },
                       data: _l
                     });
@@ -8068,8 +8082,8 @@
             s = _ref30.displayWidth,
             i = _ref30.displayHeight,
             c = _ref30.colorSpace,
-            y = _ref30.data;
-          return new VideoFrame(new Uint8Array(y), {
+            u = _ref30.data;
+          return new VideoFrame(new Uint8Array(u), {
             format: e,
             codedWidth: t,
             codedHeight: r,
@@ -8141,11 +8155,11 @@
     }],
     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 : []);
-  var ye = ce.concat({
+  var ue = ce.concat({
       checkDataCloneException: {
         test: function test(e) {
           var t = {}.toString.call(e).slice(8, -1);
-          if (["symbol", "function"].includes(_typeof(e)) || ["Arguments", "Module", "Promise", "WeakMap", "WeakSet", "Event", "MessageChannel"].includes(t) || ["ArrayBuffer", "DataView", "Int8Array", "Uint8Array", "Uint8ClampedArray", "Int16Array", "Uint16Array", "Int32Array", "Uint32Array", "Float32Array", "Float64Array", "BigInt64Array", "BigUint64Array"].includes(t) && function isBufferDetached(e) {
+          if (["symbol", "function"].includes(_typeof(e)) || ["Arguments", "Module", "Promise", "WeakMap", "WeakSet", "Event", "MessageChannel", "MessagePort"].includes(t) || e && e.constructor && ["MessageChannel", "MessagePort"].includes(e.constructor.name) || ["ArrayBuffer", "DataView", "Int8Array", "Uint8Array", "Uint8ClampedArray", "Int16Array", "Uint16Array", "Int32Array", "Uint32Array", "Float32Array", "Float64Array", "BigInt64Array", "BigUint64Array"].includes(t) && function isBufferDetached(e) {
             if ("boolean" == typeof e.detached) return e.detached;
             if (0 !== e.byteLength) return false;
             try {
@@ -8161,7 +8175,7 @@
 
   // See: https://stackoverflow.com/questions/42170826/categories-for-rejection-by-the-structured-cloning-algorithm
 
-  var typeson = new Typeson().register(ye);
+  var typeson = new Typeson().register(ue);
 
   /**
    * @param {(preset: import('typeson-registry').Preset) =>
@@ -8170,7 +8184,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(ye));
+    typeson = new Typeson().register(func(ue));
   }
 
   /**
@@ -9233,6 +9247,11 @@
    *     success: (key: import('./Key.js').Key, cn?: Integer) => void,
    *     failCb: import('./Key.js').SQLFailureCallback
    *   ) => void,
+   *   __checkIndexConstraints: (
+   *     tx: WebSQLTransaction,
+   *     value: import('./Key.js').Value,
+   *     excludeKey: import('./Key.js').Key|Integer|undefined
+   *   ) => SyncPromise,
    *   __insertData: (
    *     tx: WebSQLTransaction,
    *     encoded: string,
@@ -9651,6 +9670,69 @@
     }
   };
 
+  /**
+   * Validates `value`'s unique index entries against the table's *current*
+   *   state without mutating anything -- used by `__storingRecordObjectStore`
+   *   to check a `put()`'s constraints *before* `__overwrite` deletes the
+   *   existing row for that key, so a rejected `put()` can't end up losing
+   *   the record it was trying to replace (see
+   *   `idbobjectstore-put-unique-index-constraint-is-atomic.any.js`).
+   *   `excludeKey`, when given, treats a conflicting record as a non-conflict
+   *   if it's the very record being overwritten (its own current entry would
+   *   otherwise self-conflict on every no-op `put()` of an unchanged value).
+   *   `__insertData` below still runs its own (now redundant, but harmless --
+   *   the old row is gone by then) equivalent check as its first step; this
+   *   isn't merged into it because `__insertData` also performs the actual
+   *   `INSERT`, which cannot safely run before `__overwrite`'s `DELETE` when
+   *   overwriting an existing key.
+   * @param {WebSQLTransaction} tx
+   * @param {import('./Key.js').Value} value
+   * @param {import('./Key.js').Key|Integer|undefined} excludeKey
+   * @this {IDBObjectStoreFull}
+   * @returns {SyncPromise}
+   */
+  IDBObjectStore.prototype.__checkIndexConstraints = function (tx, value, excludeKey) {
+    var me = this;
+    var indexPromises = Object.keys(me.__indexes).map(function (indexName) {
+      return new SyncPromise(function (resolve, reject) {
+        var index = me.__indexes[indexName];
+        if (index.__pendingCreate || index.__deleted || !index.unique) {
+          resolve(undefined);
+          return;
+        }
+        /**
+         * @type {import('./Key.js').KeyValueObject|
+         *   import('./Key.js').KeyPathEvaluateValue}
+         */
+        var indexKey;
+        try {
+          indexKey = extractKeyValueDecodedFromValueUsingKeyPath(value, index.keyPath, index.multiEntry);
+          if ('invalid' in indexKey && indexKey.invalid || 'failure' in indexKey && indexKey.failure) {
+            throw new Error('Go to catch');
+          }
+        } catch (err) {
+          resolve(undefined);
+          return;
+        }
+        indexKey = indexKey.value;
+        if (indexKey === undefined) {
+          resolve(undefined);
+          return;
+        }
+        var multiCheck = index.multiEntry && Array.isArray(indexKey);
+        var fetchArgs = buildFetchIndexDataSQL(true, index, indexKey, 'key', multiCheck);
+        executeFetchIndexData.apply(void 0, [null].concat(_toConsumableArray(fetchArgs), [tx, null, function success(key) {
+          if (key === undefined || excludeKey !== undefined && cmp(key, excludeKey) === 0) {
+            resolve(undefined);
+            return;
+          }
+          reject(createDOMException('ConstraintError', 'Index already contains a record equal to ' + (multiCheck ? 'one of the subkeys of' : '') + '`indexKey`'));
+        }, reject]));
+      });
+    });
+    return SyncPromise.all(indexPromises);
+  };
+
   /**
    *
    * @param {WebSQLTransaction} tx
@@ -9912,7 +9994,32 @@
             }, error);
           }
           if (!noOverwrite) {
-            store.__overwrite(tx, clonedKeyOrCurrentNumber, insert, error);
+            // Validate unique index constraints *before* `__overwrite`
+            //   deletes the existing row at this key -- otherwise a
+            //   `put()` that ends up rejected still permanently loses
+            //   the record it was trying to replace (see
+            //   `idbobjectstore-put-unique-index-constraint-is-atomic.any.js`).
+            store.__checkIndexConstraints(tx, value, clonedKeyOrCurrentNumber).then(function () {
+              store.__overwrite(tx, clonedKeyOrCurrentNumber, insert, error);
+              return undefined;
+              /**
+               * @param {Error|DOMException} err
+               * @returns {null}
+               */
+            }).catch(function (err) {
+              /**
+               * @returns {void}
+               */
+              function fail() {
+                error(err);
+              }
+              if (typeof oldCn === 'number') {
+                assignCurrentNumber(tx, store, oldCn, fail, fail);
+                return null;
+              }
+              fail();
+              return null;
+            });
             return;
           }
           insert(tx);
@@ -11004,7 +11111,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);
         });
       });
@@ -11064,6 +11193,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;
@@ -11366,6 +11512,19 @@
       if (calledDbCreateError) {
         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
@@ -11477,22 +11636,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.'));
@@ -11508,6 +11688,7 @@
                  * @returns {void}
                  */
                 function (ev) {
+                  pendingVersionChanges.delete(name);
                   connection.__upgradeTransaction = null;
                   /** @type {import('./IDBDatabase.js').IDBDatabaseFull} */
                   req.__result.__versionTransaction = null;
@@ -11522,6 +11703,7 @@
 
                 // eslint-disable-next-line camelcase -- Clear API
                 req.transaction.on__preabort = function () {
+                  pendingVersionChanges.delete(name);
                   connection.__upgradeTransaction = null;
                   // We ensure any cache is deleted before any request error events fire and try to reopen
                   if (useDatabaseCache) {
@@ -11584,6 +11766,10 @@
                   // });
                 };
               }
+              pendingVersionChanges.set(name, {
+                oldVersion: oldVersion,
+                newVersion: version
+              });
               if (oldVersion === 0) {
                 systx.executeSql('INSERT INTO dbVersions VALUES (?,?)', [sqlSafeName, version], versionSet, dbCreateError);
               } else {
@@ -11886,6 +12072,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)) {
@@ -11915,10 +12110,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
               });
             }
@@ -12063,6 +12277,14 @@
     // We must resort to this to get "get <name>" as the function `name` for
     //   proper IDL.
     var o = _defineAccessor("get", {}, prop, function () {
+      // This is defined on the *shared* prototype (see above), so,
+      //   unlike a per-instance getter, it's reachable by calling it
+      //   directly on `IDBRecord.prototype` itself (not a real
+      //   instance) -- WebIDL requires that to throw.
+      if (!(this instanceof IDBRecordAlias)) {
+        throw new TypeError('Illegal invocation');
+      }
+      // @ts-ignore `this` is a real instance past the check above (not an issue in TS7)
       return this['__' + prop];
     });
     var desc = /** @type {PropertyDescriptor} */
@@ -12330,9 +12552,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
@@ -12962,9 +13201,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),