indexeddbshim 19.0.4 → 19.0.5

package/dist/indexeddbshim-node.cjs

@@ -1,4 +1,4 @@
-/*! indexeddbshim - v19.0.4 - 9/17/2026 */
+/*! indexeddbshim - v19.0.5 - 9/17/2026 */
 
 'use strict';
 
@@ -5182,6 +5182,10 @@ IDBTransaction.prototype.__executeRequests = function () {
     let q,
       i = -1;
 
+    // On a standard driver, `keepAliveAndWait` issues a SQL query, which
+    //   is a macrotask. Otherwise it issues ten microtasks.
+    const keepAliveAttempts = isStandardDriver ? 1 : 10;
+
     /**
      * A continuation that must still be able to observe the
      *   transaction as safe to extend (e.g., re-checking whether an
@@ -5217,9 +5221,9 @@ IDBTransaction.prototype.__executeRequests = function () {
         });
       } catch (err) {
         // The driver has already finalized the transaction (or otherwise
-        //   rejected the call) -- nothing left to hold open, so fall back
-        //   to a plain microtask hop for the continuation itself.
-        queueMicrotask(cb);
+        //   rejected the call) -- nothing left to hold open. We explicitly
+        //   abort the transaction here.
+        me.__abortTransaction(/** @type {Error|DOMException} */err);
       }
     }
 
@@ -5421,9 +5425,11 @@ IDBTransaction.prototype.__executeRequests = function () {
      *   consumer of that same handler (e.g. one that resolves a
      *   promise from within `onsuccess` and only attaches `oncomplete`
      *   afterward) ever gets a turn to run, so it can miss `complete`
-     *   entirely. `readonly` requests don't hold a real SQL
-     *   transaction open, though, so there's no file-lock/connection
-     *   collision risk in waiting the same bounded amount here.
+     *   afterward) ever gets a turn to run, so it can miss `complete`
+     *   entirely. On a non-standard driver, `readonly` requests don't hold
+     *   a real SQL transaction open, so there's no file-lock/connection
+     *   collision risk. On a standard driver, the wait now issues real SQL
+     *   inside the read transaction, so this does carry a slight risk.
      * @param {number} attemptsLeft
      * @returns {void}
      */
@@ -5458,7 +5464,7 @@ IDBTransaction.prototype.__executeRequests = function () {
       }
       i++;
       if (i >= me.__requests.length) {
-        checkQueueEntry(10);
+        checkQueueEntry(keepAliveAttempts);
         return;
       }
       runQueuedRequest();
@@ -5495,7 +5501,7 @@ IDBTransaction.prototype.__executeRequests = function () {
       }
       i++;
       if (i >= me.__requests.length) {
-        checkQueueEntry(10);
+        checkQueueEntry(keepAliveAttempts);
         return;
       }
       keepAliveAndWait(() => {