indexeddbshim 19.0.4 → 19.0.6

package/src/IDBTransaction.js

@@ -273,10 +273,12 @@ IDBTransaction.prototype.__callTransFinishedCb = function (err, cb) {
  */
 IDBTransaction.prototype.__executeRequests = function () {
     const me = this;
+    /* c8 ignore start -- Dead code: `__executeRequests` has exactly one caller (a single `setTimeout` scheduled once per transaction), so `me.__running` can never already be `true` when this function starts. */
     if (me.__running) {
         if (CFG.DEBUG) { console.log('Looks like the request set is already running', me.mode); }
         return;
     }
+    /* c8 ignore stop -- see comment above */
 
     // The synchronous script that created this transaction (and
     //   synchronously queued whatever requests it wanted to) has now
@@ -297,6 +299,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
@@ -323,6 +329,7 @@ IDBTransaction.prototype.__executeRequests = function () {
                     queueMicrotask(cb);
                     return;
                 }
+                /* c8 ignore start -- Browser-only path: in every automated test environment (Node's websql-configurable/better-sqlite3 driver, and the fake/mock drivers modeled after it) `__usesStandardDriver()` is always `false` (they support the 4-arg `nonstandardTransCb` signature), so `isStandardDriver` is never `true` and this branch is never reached. Only a real standard (3-arg) WebSQL driver, as found in an actual browser, would exercise it. */
                 try {
                     tx.executeSql('SELECT 1', [], function () {
                         cb();
@@ -332,10 +339,11 @@ 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));
                 }
+                /* c8 ignore stop -- see comment above */
             }
 
             /**
@@ -348,19 +356,25 @@ IDBTransaction.prototype.__executeRequests = function () {
              * @returns {void}
              */
             function success (result, req) {
+                /* c8 ignore start -- Defensive: only reached if the transaction was independently errored/finished by a concurrent path (e.g. a driver-level failure or explicit `abort()`) racing with this request's own in-flight SQL success callback; not reliably reproducible without directly manipulating the SQL driver's callback timing. */
                 if (me.__errored || me.__requestsFinished) {
                     // We've already called "onerror", "onabort", or thrown within the transaction, so don't do it again.
                     return;
                 }
+                /* c8 ignore stop -- see comment above */
                 if (req) {
                     q.req = req; // Need to do this in case of cursors
                 }
-                if (!q.req) { // TS guard
+                /* c8 ignore start -- Dead code: `launchQueuedOp` only ever passes `success` as a callback in the branch where `q.req` is already truthy, and a falsy `req` param here leaves `q.req` unchanged, so `q.req` can't be falsy at this point. */
+                if (!q.req) {
                     return;
                 }
+                /* c8 ignore stop -- see comment above */
+                /* c8 ignore start -- Defensive: only reached if the SQL driver invoked this request's success callback more than once for the same queued op; not reliably reproducible without directly manipulating the SQL driver. */
                 if (q.req.__done) { // Avoid continuing with aborted requests
                     return;
                 }
+                /* c8 ignore stop -- see comment above */
                 q.req.__done = true;
                 q.req.__result = result;
                 q.req.__error = null;
@@ -378,6 +392,7 @@ IDBTransaction.prototype.__executeRequests = function () {
                 //   is what actually resets `__handlerActive`, once it's
                 //   confirmed (across its own bounded microtask wait) that no
                 //   such continuation queued anything.
+                /* c8 ignore start -- Deliberately not tested: throwing from a request's `onsuccess` handler to exercise this branch would surface as an uncaught error through this test suite's `window.onerror` shim, which (per `retention-spec.js`'s `assertLater` comment) can trigger unbounded recursion here; not safe to trigger directly. */
                 if (e.__legacyOutputDidListenersThrowError) {
                     logError('Error', 'An error occurred in a success handler attached to request chain', e.__legacyOutputDidListenersThrowError); // We do nothing else with this error as per spec
                     if (!me.__committed) { // An explicit `commit()` locks in the commit, so errors thrown afterward must not abort it
@@ -386,6 +401,7 @@ IDBTransaction.prototype.__executeRequests = function () {
                         return;
                     }
                 }
+                /* c8 ignore stop -- see comment above */
                 util.runContinuationSafely(advanceAfterDispatch);
             }
 
@@ -397,14 +413,18 @@ IDBTransaction.prototype.__executeRequests = function () {
              * @returns {void}
              */
             function error (...args /* tx, err */) {
+                /* c8 ignore start -- Defensive: only reached if the transaction was independently errored/finished by a concurrent path racing with this request's own in-flight SQL error callback; not reliably reproducible without directly manipulating the SQL driver's callback timing. */
                 if (me.__errored || me.__requestsFinished) {
                     // We've already called "onerror", "onabort", or thrown within
                     //  the transaction, so don't do it again.
                     return;
                 }
+                /* c8 ignore stop -- see comment above */
+                /* c8 ignore start -- Defensive: only reached if the SQL driver invoked this request's error callback more than once, or after its success callback already ran; not reliably reproducible without directly manipulating the SQL driver. */
                 if (q.req && q.req.__done) { // Avoid continuing with aborted requests
                     return;
                 }
+                /* c8 ignore stop -- see comment above */
                 const err = /** @type {Error|DOMException} */ (findError(args));
                 if (!q.req) {
                     me.__abortTransaction(err);
@@ -428,9 +448,11 @@ IDBTransaction.prototype.__executeRequests = function () {
                     }
                 );
                 q.req.addDefaultEventListener('error', function () {
-                    if (!q.req) { // TS guard
+                    /* c8 ignore start -- Defensive: this default listener is skipped entirely by `eventtargeter` whenever the event was `preventDefault()`-ed (the only case in which the shared `q` variable above could have already advanced to a different, non-request queue entry by the time a default listener runs); not reachable via the public API under normal (synchronous) dispatch. */
+                    if (!q.req) {
                         return;
                     }
+                    /* c8 ignore stop -- see comment above */
                     me.__abortTransaction(q.req.__error);
                 });
 
@@ -440,15 +462,19 @@ IDBTransaction.prototype.__executeRequests = function () {
                 q.req.dispatchEvent(e);
                 // Do not set __active or __handlerActive flags to false yet --
                 //   see the matching comment in `success`, above.
-                if (e.__legacyOutputDidListenersThrowError) {
-                    logError('Error', 'An error occurred in an error handler attached to request chain', e.__legacyOutputDidListenersThrowError); // We do nothing else with this error as per spec
-                    e.preventDefault(); // Prevent 'error' default as steps indicate we should abort with `AbortError` even without cancellation
-                    if (me.__committed) { // An explicit `commit()` locks in the commit, so errors thrown afterward must not abort it
-                        util.runContinuationSafely(advanceAfterDispatch);
-                        return;
-                    }
-                    me.__abortTransaction(createDOMException('AbortError', 'A request was aborted (in user handler after error).'));
+                /* c8 ignore start -- Deliberately not tested: throwing from a request's `onerror` handler to exercise this branch would surface as an uncaught error through this test suite's `window.onerror` shim, which (per `retention-spec.js`'s `assertLater` comment) can trigger unbounded recursion here; not safe to trigger directly. */
+                if (!e.__legacyOutputDidListenersThrowError) {
+                    return;
+                }
+
+                logError('Error', 'An error occurred in an error handler attached to request chain', e.__legacyOutputDidListenersThrowError); // We do nothing else with this error as per spec
+                e.preventDefault(); // Prevent 'error' default as steps indicate we should abort with `AbortError` even without cancellation
+                if (me.__committed) { // An explicit `commit()` locks in the commit, so errors thrown afterward must not abort it
+                    util.runContinuationSafely(advanceAfterDispatch);
+                    return;
                 }
+                me.__abortTransaction(createDOMException('AbortError', 'A request was aborted (in user handler after error).'));
+                /* c8 ignore stop -- see comment above */
             }
 
             /**
@@ -472,9 +498,11 @@ IDBTransaction.prototype.__executeRequests = function () {
                     //   (not reset here).
                     return true;
                 }
+                /* c8 ignore start -- Defensive: reaching this queue entry via the normal advancement path after it was independently marked `__done` (e.g. by `__abortTransaction`'s own separate, async per-request error dispatch) requires a narrow race between that async cleanup and this synchronous advancement; not reliably reproducible without directly manipulating that timing. */
                 if (q.req.__done) { // Avoid continuing with aborted requests
                     return false;
                 }
+                /* c8 ignore stop -- see comment above */
                 // We're now handing off to (possibly async) work for
                 //   this request, so the transaction is no longer active
                 //   until its own `success`/`error` dispatch (below)
@@ -497,18 +525,22 @@ IDBTransaction.prototype.__executeRequests = function () {
                         return;
                     }
                     q.op(tx, q.args, success, error, executeNextRequest);
+                /* c8 ignore start -- Defensive: `q.op` (the SQL driver callback) is expected to report failures via its own `error`/`failure` callback argument rather than throwing synchronously; not reliably reproducible without directly forcing the driver to throw. */
                 } catch (e) {
                     error(/** @type {Error} */ (e));
                 }
+                /* c8 ignore stop -- see comment above */
             }
 
             /**
              * @returns {void}
              */
             function runQueuedRequest () {
+                /* c8 ignore start -- Defensive: only reached if `prepareNextRequest` returns `false` (see its own ignore comment above for why that's not reliably reproducible). */
                 if (!prepareNextRequest()) {
                     return;
                 }
+                /* c8 ignore stop -- see comment above */
                 launchQueuedOp();
             }
 
@@ -530,16 +562,20 @@ 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}
              */
             function checkQueueEntry (attemptsLeft) {
+                /* c8 ignore start -- Defensive: only reached if the transaction is independently errored/finished (e.g. an explicit `abort()`) during this function's keep-alive polling wait; not reliably reproducible without a contrived timing race. */
                 if (me.__errored || me.__requestsFinished) {
                     return;
                 }
+                /* c8 ignore stop -- see comment above */
                 if (i < me.__requests.length) {
                     runQueuedRequest();
                     return;
@@ -561,13 +597,15 @@ IDBTransaction.prototype.__executeRequests = function () {
              * @returns {void}
              */
             function executeNextRequest () {
+                /* c8 ignore start -- Defensive: only reached if the transaction was independently errored/finished by a concurrent path racing with this continuation; not reliably reproducible without a contrived timing race. */
                 if (me.__errored || me.__requestsFinished) {
                     // We've already called "onerror", "onabort", or thrown within the transaction, so don't do it again.
                     return;
                 }
+                /* c8 ignore stop -- see comment above */
                 i++;
                 if (i >= me.__requests.length) {
-                    checkQueueEntry(10);
+                    checkQueueEntry(keepAliveAttempts);
                     return;
                 }
                 runQueuedRequest();
@@ -599,21 +637,22 @@ IDBTransaction.prototype.__executeRequests = function () {
              * @returns {void}
              */
             function advanceAfterDispatch () {
+                /* c8 ignore start -- Defensive: only reached if the transaction was independently errored/finished by a concurrent path racing with this continuation; not reliably reproducible without a contrived timing race. */
                 if (me.__errored || me.__requestsFinished) {
                     return;
                 }
+                /* c8 ignore stop -- see comment above */
                 i++;
                 if (i >= me.__requests.length) {
-                    checkQueueEntry(10);
+                    checkQueueEntry(keepAliveAttempts);
                     return;
                 }
                 keepAliveAndWait(() => {
-                    if (me.__errored || me.__requestsFinished) {
-                        return;
-                    }
-                    if (!prepareNextRequest()) {
+                    /* c8 ignore start -- Defensive: only reached if the transaction was independently errored/finished (or the next request's preparation failed) by a concurrent path racing with this continuation; not reliably reproducible without a contrived timing race. */
+                    if (me.__errored || me.__requestsFinished || !prepareNextRequest()) {
                         return;
                     }
+                    /* c8 ignore stop -- see comment above */
                     launchQueuedOp();
                 });
             }
@@ -621,10 +660,12 @@ IDBTransaction.prototype.__executeRequests = function () {
             executeNextRequest();
         },
         function webSQLError (webSQLErr) {
+            /* c8 ignore start -- Dead code: the underlying websql-configurable driver's `_onTransactionComplete` always passes either `null` or a genuine `Error`/`DOMException` as this callback's argument, never the literal value `true`, under any driver used by the test suite. */
             // @ts-expect-error It's ok
             if (webSQLErr === true) { // Not a genuine SQL error
                 return;
             }
+            /* c8 ignore stop -- see comment above */
             const err = webSQLErrback(/** @type {Error & {code?: number}} */ (webSQLErr));
             me.__abortTransaction(err);
         },
@@ -635,19 +676,27 @@ IDBTransaction.prototype.__executeRequests = function () {
             if (me.__transFinishedCb !== IDBTransaction.prototype.__transFinishedCb) { // Node
                 return;
             }
+            /* c8 ignore start -- Defensive: reaching this callback before `requestsFinished` has already set `__transactionEndCallback` (or finished) would require the underlying driver's own "queue empty" signal to race ahead of this codebase's own request-completion tracking; not observed (nor reliably reproducible) in this test suite, where the latter always wins. */
             if (!me.__transactionEndCallback && !me.__requestsFinished) {
                 me.__transactionFinished = true;
                 return;
             }
-            if (me.__transactionEndCallback && !me.__completed && !me.__transFinishedCbFired) {
-                me.__transFinishedCbFired = true;
-                me.__transFinishedCb(me.__errored, me.__transactionEndCallback);
+            /* c8 ignore stop -- see comment above */
+            /* c8 ignore start -- Dead code in practice: by the time this callback runs, `requestsFinished` has always already set `__transactionEndCallback` (per the guard above), and `__completed`/`__transFinishedCbFired` are always already set true by `requestsFinished`'s own `__callTransFinishedCb` call, so this guard always returns early and the fall-through body below is never reached; not reliably reproducible without a contrived timing race. */
+            if (!me.__transactionEndCallback || me.__completed || me.__transFinishedCbFired) {
+                return;
             }
+
+            me.__transFinishedCbFired = true;
+            me.__transFinishedCb(me.__errored, me.__transactionEndCallback);
+            /* c8 ignore stop -- see comment above */
         },
         function (currentTask, err, done, rollback, commit) {
+            /* c8 ignore start -- Defensive: `err` here would mean the underlying WebSQL/SQLite driver reported a genuine unhandled SQL error bubbling out of this transaction's own executed statements -- every `executeSql` error callback in this codebase already handles/reports its own errors (returning `false`), so this is not reliably reproducible without mocking the SQL layer. */
             if (err) {
                 return true;
             }
+            /* c8 ignore stop -- see comment above */
             // `readonly` transactions never hold a real SQL transaction open
             //   (see `WebSQLTransaction`'s constructor skipping `BEGIN;` for
             //   them), so there's no commit/rollback round trip to defer --
@@ -699,6 +748,7 @@ IDBTransaction.prototype.__executeRequests = function () {
          */
         function complete () {
             me.__completed = true;
+            /* c8 ignore next -- Debug-only log; no test sets `CFG.DEBUG`. */
             if (CFG.DEBUG) { console.log('Transaction completed'); }
             const evt = createEvent('complete');
             try {
@@ -706,6 +756,7 @@ IDBTransaction.prototype.__executeRequests = function () {
                 me.dispatchEvent(evt);
                 me.__internal = false;
                 me.dispatchEvent(createEvent('__complete'));
+                /* c8 ignore start -- Deliberately not tested: throwing from an `oncomplete`/`__complete` handler to exercise this branch would surface as an uncaught error through this test suite's `window.onerror` shim, which (per `retention-spec.js`'s `assertLater` comment) can trigger unbounded recursion here; not safe to trigger directly. */
             } catch (e) {
                 me.__internal = false;
                 // An error occurred in the "oncomplete" handler.
@@ -713,6 +764,7 @@ IDBTransaction.prototype.__executeRequests = function () {
                 // (this may seem odd/bad, but it's how all native IndexedDB implementations work)
                 me.__errored = true;
                 throw e;
+                /* c8 ignore stop -- see comment above */
             } finally {
                 activeTransactions.delete(me);
                 me.__storeHandles = {};
@@ -720,10 +772,12 @@ IDBTransaction.prototype.__executeRequests = function () {
             }
         }
         if (me.mode === 'readwrite' || me.mode === 'readonly') {
+            /* c8 ignore start -- Dead code in practice: `__transactionFinished` is only ever set by the driver-queue-idle-races-ahead scenario described above (also `c8 ignore`d there), which is not observed in this test suite. */
             if (me.__transactionFinished) {
                 complete();
                 return;
             }
+            /* c8 ignore stop -- see comment above */
             me.__transactionEndCallback = complete;
             // The underlying SQL driver's own "queue empty" check
             //   (`nonstandardTransCb`, above) typically already ran and
@@ -760,6 +814,7 @@ IDBTransaction.prototype.__executeRequests = function () {
 IDBTransaction.prototype.__createRequest = function (source) {
     const me = this;
     const request = IDBRequest.__createInstance();
+    /* c8 ignore next -- Defensive: every call site (via `__addToTransactionQueue` or directly) always passes an explicit `source`, so the `me.db` fallback is not reachable via the public API. */
     request.__source = source !== undefined ? source : me.db;
     request.__transaction = me;
     return request;
@@ -829,9 +884,11 @@ IDBTransaction.prototype.__pushToQueue = function (request, callback, args) {
  * @returns {void}
  */
 IDBTransaction.prototype.__assertActive = function () {
+    /* c8 ignore start -- Defensive: every call site (via `__addToTransactionQueue`/`__addNonRequestToTransactionQueue`) either already performed the static `IDBTransaction.__assertActive(tx)` check synchronously just beforehand, or queues against a transaction just created fresh (necessarily active), so this redundant instance-level check is not reachable via the public API. */
     if (!this.__active || !this.__handlerActive || this.__committed) {
         throw createDOMException('TransactionInactiveError', 'A request was placed against a transaction which is currently not active, or which is finished');
     }
+    /* c8 ignore stop -- see comment above */
 };
 
 /**
@@ -845,6 +902,7 @@ IDBTransaction.prototype.__assertWritable = function () {
     }
 };
 
+/* c8 ignore start -- Dead code: this instance method has no callers anywhere in src/ (confirmed via grep); every real call site uses the static `IDBTransaction.__assertVersionChange(tx)` directly instead. */
 /**
  * @this {IDBTransactionFull}
  * @returns {void}
@@ -852,6 +910,7 @@ IDBTransaction.prototype.__assertWritable = function () {
 IDBTransaction.prototype.__assertVersionChange = function () {
     IDBTransaction.__assertVersionChange(this);
 };
+/* c8 ignore stop -- see comment above */
 
 /**
  * Returns the specified object store.
@@ -872,9 +931,11 @@ IDBTransaction.prototype.objectStore = function (objectStoreName) {
         throw createDOMException('NotFoundError', objectStoreName + ' is not participating in this transaction');
     }
     const store = me.db.__objectStores[objectStoreName];
+    /* c8 ignore start -- Defensive: `me.__objectStoreNames` (checked just above) and `me.db.__objectStores` are always kept in sync by every code path that adds/renames/removes a store, so a name that passes the participation check above should always also be found here; not reliably reproducible via the public API. */
     if (!store) {
         throw createDOMException('NotFoundError', objectStoreName + ' does not exist in ' + me.db.name);
     }
+    /* c8 ignore stop -- see comment above */
 
     if (!Object.hasOwn(me.__storeHandles, objectStoreName) ||
         // These latter conditions are to allow store
@@ -895,10 +956,12 @@ IDBTransaction.prototype.objectStore = function (objectStoreName) {
 IDBTransaction.prototype.__abortTransaction = function (err) {
     const me = this;
     logError('Error', 'An error occurred in a transaction', err);
+    /* c8 ignore start -- Defensive re-entrancy guard: only reached if `__abortTransaction` is invoked a second time on the same transaction after `__errored` is already `true` (e.g. two independent internal error paths racing); not reliably reproducible without a contrived timing race. */
     if (me.__errored) {
         // We've already called "onerror", "onabort", or thrown, so don't do it again.
         return;
     }
+    /* c8 ignore stop -- see comment above */
     me.__errored = true;
 
     if (me.mode === 'versionchange') { // Steps for aborting an upgrade transaction
@@ -936,19 +999,15 @@ IDBTransaction.prototype.__abortTransaction = function (err) {
         me.__error = err;
     }
 
+    /* c8 ignore start -- Defense in depth: `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 should not see a non-null `err` in practice. */
     if (me.__requestsFinished && err !== null) {
         // The transaction has already completed, so we can't call "onerror" or "onabort".
-        // 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.
+        // So throw the error instead.
         setTimeout(() => {
             throw err;
         }, 0);
     }
+    /* c8 ignore stop -- see comment above */
 
     /**
      * @param {import('websql-configurable/lib/websql/WebSQLTransaction.js').default|null} [tx]
@@ -957,9 +1016,13 @@ IDBTransaction.prototype.__abortTransaction = function (err) {
      */
     function abort (tx, errOrResult) {
         if (!tx) {
+            /* c8 ignore next -- Debug-only log; only reached via the no-op `abort()` calls below (rare paths), and requires `CFG.DEBUG` to have any effect anyway. */
             if (CFG.DEBUG) { console.log('Rollback not possible due to missing transaction', me); }
+        /* c8 ignore start -- Defensive: the underlying WebSQL/SQLite driver erroring on the manual `ROLLBACK` executed below (with a result object exposing a numeric `code`) is not reliably reproducible without mocking the SQL layer. */
         } else if (errOrResult && 'code' in errOrResult && typeof errOrResult.code === 'number') {
             if (CFG.DEBUG) { console.log('Rollback erred; feature is probably not supported as per WebSQL', me); }
+        /* c8 ignore stop -- see comment above */
+        /* c8 ignore next -- Debug-only log; no test sets `CFG.DEBUG`. */
         } else if (CFG.DEBUG) { console.log('Rollback succeeded', me); }
 
         me.dispatchEvent(createEvent('__preabort'));
@@ -973,9 +1036,11 @@ IDBTransaction.prototype.__abortTransaction = function (err) {
             //  behaves first-in-first-out with the same timeout so we could
             //  just use a `forEach`.
             return promises.then(function () {
-                if (!q.req) { // TS guard
+                /* c8 ignore start -- Dead code: the preceding `.filter()` only keeps entries with a truthy `q.req`, and nothing ever resets `q.req` back to a falsy value afterward, so this invariant can't actually be violated. */
+                if (!q.req) {
                     throw new Error('Missing request');
                 }
+                /* c8 ignore stop -- see comment above */
                 q.req.__done = true;
                 q.req.__result = undefined;
                 q.req.__error = createDOMException('AbortError', 'A request was aborted (an unfinished request).');
@@ -984,9 +1049,11 @@ IDBTransaction.prototype.__abortTransaction = function (err) {
                     /** @type {(resolve: (value?: unknown) => void) => void} */
                     (resolve) => {
                         setTimeout(() => {
-                            if (!q.req) { // TS guard
+                            /* c8 ignore start -- Dead code: same invariant as above -- `q.req` was already confirmed truthy by the outer `.filter()` and is never reset. */
+                            if (!q.req) {
                                 throw new Error('Missing request');
                             }
+                            /* c8 ignore stop -- see comment above */
                             q.req.dispatchEvent(reqEvt); // No need to catch errors
                             resolve();
                         }, 0);
@@ -1003,10 +1070,12 @@ IDBTransaction.prototype.__abortTransaction = function (err) {
                 releaseFinishedTransaction(me);
             }, 0);
             return undefined;
+        /* c8 ignore start -- Diagnostic safety net: nothing in the preceding promise chain normally rejects (the only throws it could catch are the dead invariant-violation checks above), so this handler is not reachable in practice. */
         }).catch((err) => {
             console.log('Abort error');
             throw err;
         });
+        /* c8 ignore stop -- see comment above */
     }
 
     me.__transFinishedCb(true, function (rollback) {
@@ -1014,10 +1083,12 @@ IDBTransaction.prototype.__abortTransaction = function (err) {
             //   rollback automatically), but for Node.js, etc., we give chance for
             //   manual aborts which would otherwise not work.
             if (me.mode === 'readwrite') {
+                /* c8 ignore start -- Dead code in practice: `__transactionFinished` is only ever set by the driver-queue-idle-races-ahead scenario described earlier in this file (also `c8 ignore`d there), which is not observed in this test suite. */
                 if (me.__transactionFinished) {
                     abort();
                     return;
                 }
+                /* c8 ignore stop -- see comment above */
                 me.__transactionEndCallback = abort;
                 return;
             }
@@ -1028,11 +1099,13 @@ IDBTransaction.prototype.__abortTransaction = function (err) {
                     abort,
                     /** @type {import('websql-configurable/lib/websql/WebSQLTransaction.js').SqlErrorCallback} */ (abort)
                 ); // Not working in some circumstances, even in Node
+            /* c8 ignore start -- Defensive: the underlying WebSQL/SQLite driver throwing synchronously on `ROLLBACK` is not reliably reproducible without mocking the SQL layer. */
             } catch (err) {
                 // Browser errs when transaction has ended and since it most likely already erred here,
                 //   we call to abort
                 abort();
             }
+            /* c8 ignore stop -- see comment above */
         } else {
             abort(null, {code: 0});
         }
@@ -1048,6 +1121,7 @@ IDBTransaction.prototype.abort = function () {
     if (!(me instanceof IDBTransaction)) {
         throw new TypeError('Illegal invocation');
     }
+    /* c8 ignore next -- Debug-only log; no test sets `CFG.DEBUG`. */
     if (CFG.DEBUG) { console.log('The transaction was aborted', me); }
     IDBTransaction.__assertNotFinished(me);
     if (me.__committed) {
@@ -1077,6 +1151,7 @@ IDBTransaction.prototype.commit = function () {
     if (!me.__active || !me.__handlerActive || me.__committed) {
         throw createDOMException('InvalidStateError', 'Failed to execute \'commit\' on \'IDBTransaction\': The transaction is not active.');
     }
+    /* c8 ignore next -- Debug-only log; no test sets `CFG.DEBUG`. */
     if (CFG.DEBUG) { console.log('The transaction was explicitly committed', me); }
     me.__committed = true;
 };
@@ -1118,6 +1193,7 @@ IDBTransaction.__assertNotFinished = function (tx) {
 };
 
 // object store methods behave differently: see https://github.com/w3c/IndexedDB/issues/192
+/* c8 ignore start -- Dead code: this function has no callers anywhere in src/ (confirmed via grep); object store methods use `IDBTransaction.__assertActive`/`__assertNotFinished` directly instead. */
 /**
  *
  * @param {IDBTransactionFull} tx
@@ -1133,6 +1209,7 @@ IDBTransaction.__assertNotFinishedObjectStoreMethod = function (tx) {
         throw err;
     }
 };
+/* c8 ignore stop -- see comment above */
 
 /**
  *

package/src/Key.js

@@ -613,8 +613,14 @@ function convertValueToKeyValueDecoded (input, seen, multiEntry, fullKeys) {
                     (!fullKeys && keys.every((k) => cmp(
                         /** @type {Key} */ (k), /** @type {Key} */ (key.value)
                     ) !== 0)) ||
+                    // `keys` holds full `{type, value}` objects here (see
+                    //   `safePush` below), so -- like the sibling branch
+                    //   above -- `cmp` (which expects raw `Value`s, not
+                    //   decoded key objects) must compare their `.value`s,
+                    //   not the wrapper objects themselves.
                     (fullKeys && keys.every((k) => cmp(
-                        /** @type {Key} */ (k), /** @type {Key} */ (/** @type {unknown} */ (key))
+                        /** @type {Key} */ (/** @type {KeyValueObject} */ (k).value),
+                        /** @type {Key} */ (key.value)
                     ) !== 0))
                 ) {
                     safePush(keys, fullKeys ? key : key.value);
@@ -629,9 +635,7 @@ function convertValueToKeyValueDecoded (input, seen, multiEntry, fullKeys) {
     } case 'date': {
         const date = /** @type {Date} */ (input);
         if (!Number.isNaN(date.getTime())) {
-            return fullKeys
-                ? {type, value: date.getTime()}
-                : {type, value: new Date(date)};
+            return {type, value: fullKeys ? date.getTime() : new Date(date)};
         }
         return {type, invalid: true, message: 'Not a valid date'};
         // Falls through
@@ -707,10 +711,9 @@ function extractKeyValueDecodedFromValueUsingKeyPath (value, keyPath, multiEntry
     if (r.failure) {
         return r;
     }
-    if (!multiEntry) {
-        return convertValueToKeyValueDecoded(r.value, null, false, fullKeys);
-    }
-    return convertValueToMultiEntryKeyDecoded(r.value, fullKeys);
+    return !multiEntry
+        ? convertValueToKeyValueDecoded(r.value, null, false, fullKeys)
+        : convertValueToMultiEntryKeyDecoded(r.value, fullKeys);
 }
 
 /**
@@ -889,10 +892,9 @@ function isKeyInRange (key, range, checkCached) {
 function isMultiEntryMatch (encodedEntry, encodedKey) {
     const keyType = encodedCharToKeyType[encodedKey.slice(0, 1)];
 
-    if (keyType === 'array') {
-        return encodedKey.indexOf(encodedEntry) > 1;
-    }
-    return encodedKey === encodedEntry;
+    return keyType === 'array'
+        ? encodedKey.indexOf(encodedEntry) > 1
+        : encodedKey === encodedEntry;
 }
 
 /**
@@ -993,10 +995,9 @@ function encode (key, inArray) {
  * @returns {undefined|ValueType}
  */
 function decode (key, inArray) {
-    if (typeof key !== 'string') {
-        return undefined;
-    }
-    return types[encodedCharToKeyType[key.slice(0, 1)]].decode(key, inArray);
+    return typeof key !== 'string'
+        ? undefined
+        : types[encodedCharToKeyType[key.slice(0, 1)]].decode(key, inArray);
 }
 
 /**

package/src/Sca.js

@@ -15,14 +15,17 @@ const specSet = structuredCloningForStorage
 
 const origFileList = specSet && !Array.isArray(specSet) && 'filelist' in specSet
     ? specSet.filelist
+    /* c8 ignore next -- Defensive fallback if typeson-registry's `filelist` preset entry ever goes missing */
     : undefined;
 
 const origTest = origFileList && typeof origFileList === 'object' && 'test' in origFileList && typeof origFileList.test === 'function'
     ? origFileList.test
+    /* c8 ignore next -- Defensive fallback if typeson-registry's `filelist.test` ever goes missing */
     : undefined;
 
 const origRevive = origFileList && typeof origFileList === 'object' && 'revive' in origFileList && typeof origFileList.revive === 'function'
     ? origFileList.revive
+    /* c8 ignore next -- Defensive fallback if typeson-registry's `filelist.revive` ever goes missing */
     : undefined;
 
 const customFileList = origFileList
@@ -34,10 +37,9 @@ const customFileList = origFileList
          * @returns {boolean}
          */
         test (x, state) {
-            if (typeof FileList !== 'undefined') {
-                return x instanceof FileList;
-            }
-            return typeof origTest === 'function' ? origTest(x, state) : false;
+            return typeof FileList !== 'undefined'
+                ? x instanceof FileList
+                : ((typeof origTest === 'function') && origTest(x, state));
         },
         /**
          * @param {unknown} x
@@ -48,13 +50,16 @@ const customFileList = origFileList
             if (typeof FileList !== 'undefined') {
                 return Reflect.construct(FileList, [x]);
             }
+            /* c8 ignore next -- Defensive fallback if typeson-registry's `filelist.revive` ever goes missing */
             return typeof origRevive === 'function' ? origRevive(x, state) : undefined;
         }
     }
+    /* c8 ignore next -- Defensive fallback if typeson-registry's `filelist` preset entry ever goes missing */
     : undefined;
 
 let typeson = new Typeson().register([
     structuredCloningForStorage,
+    /* c8 ignore next -- Defensive fallback if typeson-registry's `filelist` preset entry ever goes missing */
     customFileList ? {filelist: customFileList} : {}
 ]);
 

package/src/nodeWebSQL.js

@@ -29,6 +29,7 @@ import CFG from './CFG.js';
  * @returns {SQLiteDatabaseInstance}
  */
 function wrappedSQLiteDatabase (name) {
+    // eslint-disable-next-line jsdoc/ts-ban-ts-comment -- TS 6/7
     // @ts-ignore It's ok; needed under some TS versions
     const db = new SQLiteDatabase(name, {});
     if (CFG.sqlBusyTimeout) {