indexeddbshim 17.3.2 → 17.3.4

package/dist/nodeSQLiteDatabase.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"nodeSQLiteDatabase.d.ts","sourceRoot":"","sources":["../src/nodeSQLiteDatabase.js"],"names":[],"mappings":";iCAyBa,CAAC,GAAG,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,KAAK,IAAI;+BAIvC,CAAC,CAAC,GAAG,EAAE,MAAM,KAAK,IAAI,CAAC,GAAC,SAAS;AAsB9C;;;;;;GAMG;AACH;SAHgB,GAAG;gBAAc,MAAM;SAF5B,MAAM,SACN;IAAC,WAAW,CAAC,EAAE,MAAM,CAAC;IAAC,KAAK,CAAC,EAAE,CAAC,GAAG,EAAE,MAAM,KAAK,IAAI,CAAC;IAAC,OAAO,CAAC,EAAE,kBAAkB,CAAA;CAAC,GAEjF,IAAI,CAmEhB;;IAxED;;;;;;OAMG;IACH;aAHgB,GAAG;oBAAc,MAAM;aAF5B,MAAM,SACN;QAAC,WAAW,CAAC,EAAE,MAAM,CAAC;QAAC,KAAK,CAAC,EAAE,CAAC,GAAG,EAAE,MAAM,KAAK,IAAI,CAAC;QAAC,OAAO,CAAC,EAAE,kBAAkB,CAAA;KAAC,EAqE7F;IAhEG,mBAAsB;IAkBtB,SA6CE;IAyBN;;;;;OAKG;IACH,cALW;QAAC,GAAG,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,OAAO,EAAE,CAAA;KAAC,EAAE,YAChC,OAAO,YACP,CAAC,GAAG,EAAE,KAAK,GAAC,IAAI,EAAE,OAAO,CAAC,EAAE,YAAY,EAAE,KAAK,IAAI,GACjD,IAAI,CAqFhB;;AA1OD;;GAEG;AACH;IACI;;;;;OAKG;IACH,mBALW,KAAK,GAAC,IAAI,GAAC,SAAS,aACpB,MAAM,GAAC,SAAS,iBAChB,MAAM,SACN,MAAM,EAAE,EAOlB;IAJG,gCAAkB;IAClB,6BAAwB;IACxB,iCAAgC;IAChC,2BAAgB;CAEvB"}
+{"version":3,"file":"nodeSQLiteDatabase.d.ts","sourceRoot":"","sources":["../src/nodeSQLiteDatabase.js"],"names":[],"mappings":";iCAyBa,CAAC,GAAG,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,KAAK,IAAI;+BAIvC,CAAC,CAAC,GAAG,EAAE,MAAM,KAAK,IAAI,CAAC,GAAC,SAAS;AAkC9C;;;;;;GAMG;AACH;SAHgB,GAAG;gBAAc,MAAM;SAF5B,MAAM,SACN;IAAC,WAAW,CAAC,EAAE,MAAM,CAAC;IAAC,KAAK,CAAC,EAAE,CAAC,GAAG,EAAE,MAAM,KAAK,IAAI,CAAC;IAAC,OAAO,CAAC,EAAE,kBAAkB,CAAA;CAAC,GAEjF,IAAI,CAmEhB;;IAxED;;;;;;OAMG;IACH;aAHgB,GAAG;oBAAc,MAAM;aAF5B,MAAM,SACN;QAAC,WAAW,CAAC,EAAE,MAAM,CAAC;QAAC,KAAK,CAAC,EAAE,CAAC,GAAG,EAAE,MAAM,KAAK,IAAI,CAAC;QAAC,OAAO,CAAC,EAAE,kBAAkB,CAAA;KAAC,EAqE7F;IAhEG,mBAAsB;IAkBtB,SA6CE;IAyBN;;;;;OAKG;IACH,cALW;QAAC,GAAG,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,OAAO,EAAE,CAAA;KAAC,EAAE,YAChC,OAAO,YACP,CAAC,GAAG,EAAE,KAAK,GAAC,IAAI,EAAE,OAAO,CAAC,EAAE,YAAY,EAAE,KAAK,IAAI,GACjD,IAAI,CA2IhB;;AA5SD;;GAEG;AACH;IACI;;;;;OAKG;IACH,mBALW,KAAK,GAAC,IAAI,GAAC,SAAS,aACpB,MAAM,GAAC,SAAS,iBAChB,MAAM,SACN,MAAM,EAAE,EAOlB;IAJG,gCAAkB;IAClB,6BAAwB;IACxB,iCAAgC;IAChC,2BAAgB;CAEvB"}

package/dist/nodeWebSQL.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"nodeWebSQL.d.ts","sourceRoot":"","sources":["../src/nodeWebSQL.js"],"names":[],"mappings":";qCAKa;IACR,GAAG,EAAE,GAAG,CAAC;IACT,IAAI,EAAE,CAAA,OAAO,cAAc,EAAC,WAAW,CAAC,CAAC,MAAM,CAAC,CAAA;CACjD;;;;;;;;;;;wCAYS,KAAK,IAAI,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,GAAG,KAAK,sBAAsB;AAsBrE,qHAAqI;2BAzC1G,yBAAyB"}
+{"version":3,"file":"nodeWebSQL.d.ts","sourceRoot":"","sources":["../src/nodeWebSQL.js"],"names":[],"mappings":";qCAKa;IACR,GAAG,EAAE,GAAG,CAAC;IACT,IAAI,EAAE,CAAA,OAAO,cAAc,EAAC,WAAW,CAAC,CAAC,MAAM,CAAC,CAAA;CACjD;;;;;;;;;;;wCAYS,KAAK,IAAI,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,GAAG,KAAK,sBAAsB;AA6BrE,qHAAsK;2BAhD3I,yBAAyB"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "indexeddbshim",
-  "version": "17.3.2",
+  "version": "17.3.4",
   "type": "module",
   "author": "Parashuram <code@nparashuram.com>",
   "contributors": [
@@ -172,8 +172,8 @@
     "eventtargeter": "0.12.0",
     "sync-promise-expanded": "^2.0.0",
     "typeson": "10.2.0",
-    "typeson-registry": "14.2.2",
-    "websql-configurable": "^3.0.6"
+    "typeson-registry": "14.3.0",
+    "websql-configurable": "^3.1.0"
   },
   "devDependencies": {
     "@babel/core": "^8.0.1",
@@ -214,7 +214,7 @@
     "npm-run-all": "^4.1.5",
     "open-cli": "^9.0.0",
     "rimraf": "^6.1.3",
-    "rollup": "^4.62.5",
+    "rollup": "^4.63.0",
     "rollup-plugin-filesize": "^10.0.0",
     "rollup-plugin-node-polyfills": "^0.2.1",
     "sinon": "^22.1.0",

package/src/IDBCursor.js

@@ -260,9 +260,33 @@ IDBCursor.prototype.__findBasic = function (key, primaryKey, tx, success, error,
         // Key.convertValueToKey(key); // Already checked by `continue` or `continuePrimaryKey`
         sqlValues.push(/** @type {string} */ (Key.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} */ (Key.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} */ (Key.encode(me.__key)),
+                /** @type {string} */ (Key.encode(me.__key)),
+                /** @type {string} */ (Key.encode(me.__primaryKey))
+            );
+        } else {
+            sql.push('AND', quotedKeyColumnName, op + ' ?');
+            sqlValues.push(/** @type {string} */ (Key.encode(me.__key)));
+        }
     }
 
     if (!me.__count) {
@@ -912,9 +936,15 @@ IDBCursor.prototype.update = function (valueToUpdate) {
      * @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) {
         const [evaluatedKey, clonedValue] = me.__store.__validateKeyAndValueAndCloneValue(valueToUpdate, undefined, true);

package/src/IDBFactory.js

@@ -156,7 +156,29 @@ function triggerAnyVersionChangeAndBlockedEvents (openConnections, req, oldVersi
             return new SyncPromise(function (resolve) {
                 setTimeout(() => {
                     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`.
+                    let attemptsLeft = 10;
+                    (function wait () {
+                        if (attemptsLeft-- <= 0) {
+                            resolve(undefined);
+                            return;
+                        }
+                        queueMicrotask(wait);
+                    }());
                 }, 0);
             });
         });
@@ -214,6 +236,23 @@ function triggerAnyVersionChangeAndBlockedEvents (openConnections, req, oldVersi
  */
 const 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}>}
+ */
+const pendingVersionChanges = new Map();
+
 /** @type {import('websql-configurable/lib/websql/WebSQLDatabase.js').default} */
 let sysdb;
 let nameCounter = 0;
@@ -518,6 +557,7 @@ IDBFactory.prototype.open = function (name /* , version */) {
 
     const req = IDBOpenDBRequest.__createInstance();
     let calledDbCreateError = false;
+    let isRevertingSysdb = false;
 
     if (CFG.autoName && name === '') {
         // eslint-disable-next-line unicorn/no-top-level-assignment-in-function -- Necessary?
@@ -546,9 +586,22 @@ IDBFactory.prototype.open = function (name /* , version */) {
      * @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);
         const 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
@@ -595,46 +648,63 @@ IDBFactory.prototype.open = function (name /* , version */) {
                      */
                     let sysdbFinishedCb = function (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
-                                sysdb.transaction(function (systx) {
-                                    /**
-                                     *
-                                     * @param {string} msg
-                                     * @throws {Error}
-                                     * @returns {never}
-                                     */
-                                    function reportError (msg) {
-                                        throw new Error('Unable to roll back upgrade transaction!' + (msg || ''));
+                            /**
+                             * @param {any} [errorToShow]
+                             * @returns {void}
+                             */
+                            const manualRevert = function (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) {
+                                        // Attempt to revert
+                                        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(errorToShow || reportError); // eslint-disable-line promise/no-callback-in-promise -- Convenient
                                     }
+                                );
+                            };
 
-                                    // 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
-                                        );
-                                    } else {
-                                        systx.executeSql(
-                                            'UPDATE dbVersions SET "version" = ? WHERE "name" = ?',
-                                            [
-                                                oldVersion, sqlSafeName
-                                            ],
-                                            cb,
-                                            // @ts-expect-error Force to work
-                                            reportError
-                                        );
+                            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;
                         }
@@ -668,22 +738,43 @@ IDBFactory.prototype.open = function (name /* , version */) {
                                     //   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(() => {
-                                        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(() => {
+                                            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
@@ -701,6 +792,7 @@ IDBFactory.prototype.open = function (name /* , version */) {
                                  * @returns {void}
                                  */
                                 function (ev) {
+                                    pendingVersionChanges.delete(name);
                                     connection.__upgradeTransaction = null;
                                     /** @type {import('./IDBDatabase.js').IDBDatabaseFull} */ (
                                         req.__result
@@ -716,6 +808,8 @@ IDBFactory.prototype.open = function (name /* , version */) {
 
                             // 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) {
@@ -733,6 +827,7 @@ IDBFactory.prototype.open = function (name /* , version */) {
                                 req.__done = false;
 
                                 connection.close();
+                                isRevertingSysdb = true;
                                 setTimeout(() => {
                                     const err = createDOMException('AbortError', 'The upgrade transaction was aborted.');
                                     sysdbFinishedCb(systx, err, function (reportError) {
@@ -789,6 +884,7 @@ IDBFactory.prototype.open = function (name /* , version */) {
                             };
                         }
 
+                        pendingVersionChanges.set(name, {oldVersion, newVersion: version});
                         if (oldVersion === 0) {
                             systx.executeSql('INSERT INTO dbVersions VALUES (?,?)', [sqlSafeName, version], versionSet, dbCreateError);
                         } else {
@@ -800,7 +896,36 @@ IDBFactory.prototype.open = function (name /* , version */) {
                         }
                         sysdbFinishedCb = function (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);
                             }
@@ -1102,6 +1227,15 @@ IDBFactory.prototype.cmp = function (key1, key2) {
 IDBFactory.prototype.databases = function () {
     const me = this;
     let 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.
+    const pendingVersionChangesSnapshot = new Map(pendingVersionChanges);
     return new Promise(function (resolve, reject) { // eslint-disable-line promise/avoid-new -- Own polyfill
         if (!(me instanceof IDBFactory)) {
             throw new TypeError('Illegal invocation');
@@ -1129,11 +1263,24 @@ IDBFactory.prototype.databases = function () {
                 sysReadTx.executeSql('SELECT "name", "version" FROM dbVersions', [], function (sysReadTx, data) {
                     const dbNames = [];
                     for (let i = 0; i < data.rows.length; i++) {
-                        const {name, version} = /** @type {{name: string, version: Integer}} */ (data.rows.item(i));
-                        dbNames.push({
-                            name: util.unescapeSQLiteResponse(name),
-                            version
-                        });
+                        const {name: encodedName, version} = /** @type {{name: string, version: Integer}} */ (data.rows.item(i));
+                        const name = util.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.
+                        const pending = pendingVersionChangesSnapshot.get(name);
+                        if (pending) {
+                            if (pending.oldVersion === 0) {
+                                continue;
+                            }
+                            dbNames.push({name, version: pending.oldVersion});
+                            continue;
+                        }
+                        dbNames.push({name, version});
                     }
                     resolve(dbNames);
                 }, dbGetDatabaseNamesError);

package/src/IDBTransaction.js

@@ -8,6 +8,7 @@ import IDBObjectStore from './IDBObjectStore.js';
 import CFG from './CFG.js';
 
 let uniqueID = 0;
+const activeTransactions = new Set();
 const listeners = ['onabort', 'oncomplete', 'onerror'];
 const readonlyProperties = ['objectStoreNames', 'mode', 'durability', 'db', 'error'];
 
@@ -137,6 +138,7 @@ IDBTransaction.__createInstance = function (db, storeNames, mode, durability = '
         me.__mode = mode;
         me.__durability = durability;
         me.__db = db;
+        activeTransactions.add(me);
         me.__error = null;
         // @ts-expect-error Part of `ShimEventTarget`
         me.__setOptions({
@@ -641,6 +643,7 @@ IDBTransaction.prototype.__executeRequests = function () {
                 me.__errored = true;
                 throw e;
             } finally {
+                activeTransactions.delete(me);
                 me.__storeHandles = {};
             }
         }
@@ -855,14 +858,21 @@ IDBTransaction.prototype.__abortTransaction = function (err) {
         });
     }
     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(() => {
             throw err;
         }, 0);
@@ -970,6 +980,14 @@ IDBTransaction.prototype.abort = function () {
     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);
 };
 
@@ -1050,7 +1068,7 @@ IDBTransaction.__assertNotFinishedObjectStoreMethod = function (tx) {
  * @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');
     }
 };
@@ -1081,4 +1099,6 @@ Object.defineProperty(IDBTransaction, 'prototype', {
 });
 /* eslint-enable unicorn/no-top-level-side-effects -- Would be good */
 
+IDBTransaction.activeTransactions = activeTransactions;
+
 export default IDBTransaction;