indexeddbshim 19.0.4 → 19.0.6

package/dist/indexeddbshim-noninvasive.js

@@ -1,4 +1,4 @@
-/*! indexeddbshim - v19.0.4 - 9/17/2026 */
+/*! indexeddbshim - v19.0.6 - 9/22/2026 */
 
 (function (global, factory) {
   typeof exports === 'object' && typeof module !== 'undefined' ? module.exports = factory() :
@@ -481,6 +481,7 @@
   var ShimDOMException$1 = typeof DOMException === 'undefined'
   // Todo: Better polyfill (if even needed here)
   /* eslint-disable no-shadow -- Polyfill */
+  /* c8 ignore start -- Only reachable when the global `DOMException` is absent, which it never is in this project's test environment (Node always provides it) */
   // eslint-disable-next-line @stylistic/operator-linebreak -- TS/JSDoc needs
   ?
   /**
@@ -498,9 +499,10 @@
       configurable: true
     });
     return err;
-  } : DOMException;
+  }
+  /* c8 ignore stop */ : DOMException;
 
-  /** @type {WeakMap<object, any>} */
+  /** @type {WeakMap<object, EventWithProps>} */
   var ev = new WeakMap();
   /** @type {WeakMap<object, EventWithProps>} */
   var evCfg = new WeakMap();
@@ -546,11 +548,12 @@
       obj[prop] = {
         configurable: true,
         get: function get() {
-          return Object.hasOwn(_evCfg, prop) ? _evCfg[prop] : Reflect.has(_ev, prop) ? _ev[prop] : ['bubbles', 'cancelable', 'composed'].includes(prop) ? false : undefined;
+          return Object.hasOwn(_evCfg, prop) ? _evCfg[prop] : Reflect.has(_ev, prop) ? _ev[prop] : ['bubbles', 'cancelable', 'composed'].includes(prop) ? false
+          /* c8 ignore next -- Every prop this is ever called with ('type'/'bubbles'/'cancelable'/'timeStamp'/'composed'/'detail') always ends up set on `_evCfg` or `_ev` by the time it's read, so this is unreachable */ : undefined;
         }
       };
       return obj;
-    }, /** @type {{[key: string]: any}} */{}));
+    }, /** @type {PropertyDescriptorMap} */{}));
   }
 
   /**
@@ -573,8 +576,9 @@
       throw new TypeError('Illegal invocation');
     }
     var _evCfg = getEvCfg(this);
-    var _ev = ev.get(this);
-    return Boolean(Object.hasOwn(_evCfg, 'isTrusted') ? _evCfg.isTrusted : Reflect.has(_ev, 'isTrusted') && _ev.isTrusted);
+    var _ev = /** @type {EventWithProps} */ /** @type {EventWithProps} */ev.get(this);
+    return Boolean(Object.hasOwn(_evCfg, 'isTrusted')
+    /* c8 ignore next -- Nothing currently sets `_evCfg.isTrusted` (see the commented-out assignment above); kept for when/if it's revived */ ? _evCfg.isTrusted : Reflect.has(_ev, 'isTrusted') && _ev.isTrusted);
   }
 
   /**
@@ -725,15 +729,15 @@
   //   this untyped alias, rather than `ShimEvent.prototype` directly, keeps
   //   that dynamic-augmentation pattern working without a `@ts-expect-error`
   //   on every single line below.
-  /** @type {any} */
-  var ShimEventProto = ShimEvent.prototype;
+
+  var ShimEventProto = /** @type {Record<PropertyKey, unknown>} */ /** @type {unknown} */ShimEvent.prototype;
 
   /** @this {EventWithProps} */
   ShimEventProto.preventDefault = function preventDefault() {
     if (!(this instanceof ShimEvent)) {
       throw new TypeError('Illegal invocation');
     }
-    var _ev = ev.get(this);
+    var _ev = /** @type {EventWithProps} */ /** @type {EventWithProps} */ev.get(this);
     var _evCfg = getEvCfg(this);
     if (this.cancelable && !_evCfg._passive) {
       _evCfg.defaultPrevented = true;
@@ -931,13 +935,12 @@
     return _createClass(CustomEvent);
   }(Event);
   var ShimCustomEvent = CustomEvent;
-  /** @type {any} */
-  var ShimCustomEventProto = ShimCustomEvent.prototype;
+  var ShimCustomEventProto = /** @type {Record<PropertyKey, unknown>} */ /** @type {unknown} */ShimCustomEvent.prototype;
   /**
    * @param {string} type
    * @param {boolean} [bubbles]
    * @param {boolean} [cancelable]
-   * @param {any} [detail]
+   * @param {unknown} [detail]
    * @this {EventWithProps}
    */
   ShimCustomEventProto.initCustomEvent = function initCustomEvent(type) {
@@ -949,6 +952,10 @@
       throw new TypeError('Illegal invocation');
     }
     var _evCfg = getEvCfg(this);
+    if (_evCfg._dispatched) {
+      return;
+    }
+
     // @ts-expect-error `detail` isn't part of `EventInit`, only used internally here
     // eslint-disable-next-line prefer-rest-params -- Keep signature
     initEventInternal(this, type, {
@@ -956,16 +963,13 @@
       cancelable: cancelable,
       detail: detail
     }, arguments[4]);
-    if (_evCfg._dispatched) {
-      return;
-    }
     if (detail !== undefined) {
       _evCfg.detail = detail;
     }
     // `initCustomEvent` deliberately excluded -- see the matching comment
     //   in `initEventInternal` for `initEvent`, above; the same reasoning
     //   applies here.
-    definePassthroughProps(this, ['detail'], _evCfg, ev.get(this));
+    definePassthroughProps(this, ['detail'], _evCfg, /** @type {EventWithProps} */ev.get(this));
   };
   // @ts-expect-error Not part of the class body itself
   ShimCustomEvent[Symbol.toStringTag] = 'Function';
@@ -1372,7 +1376,7 @@
         /** @type {string[]} */
         this._extraProperties.forEach(function (prop) {
           if (Reflect.has(e, prop)) {
-            /** @type {{[key: string]: any}} */eventCopy[prop] = /** @type {{[key: string]: any}} */e[prop]; // Todo: Put internal to `ShimEvent`?
+            /** @type {PropertyDescriptorMap} */eventCopy[prop] = /** @type {PropertyDescriptorMap} */e[prop]; // Todo: Put internal to `ShimEvent`?
           }
         });
       }
@@ -1451,6 +1455,7 @@
             if (child) {
               child._defaultSync = this._defaultSync;
             }
+            /* c8 ignore next -- `cfg._children` always has exactly as many entries as remaining capturing-phase steps (built from the same walk that starts this phase), so `child` is never falsy here; the `|| this` fallback is defensive only */
             return (child || this)._dispatchEvent(eventCopy, false);
           }
         case phases.AT_TARGET:
@@ -1748,7 +1753,7 @@
    *   databaseNameLengthLimit: number|false,
    *   escapeNFDForDatabaseNames: boolean,
    *   addSQLiteExtension: boolean,
-   *   memoryDatabase: string,
+   *   memoryDatabase: string|null|undefined,
    *   deleteDatabaseFiles: boolean,
    *   databaseBasePath: string,
    *   sysDatabaseBasePath: string,
@@ -1891,13 +1896,27 @@
   // Various types of in-memory databases that can auto-delete
   ['memoryDatabase',
   /**
-   * @param {string} val
+   * `null`/`undefined` are accepted (and left unvalidated against the
+   *   regex below) specifically so this can be reset back to its
+   *   unset/disabled state after being set: unlike other `CFG`
+   *   boolean-ish switches (e.g. `sqlMemoryQuota`, which is checked
+   *   with a falsy `if (CFG.sqlMemoryQuota)`), `memoryDatabase`'s own
+   *   usage sites check `typeof CFG.memoryDatabase === 'string'`, so
+   *   even the empty string counts as "on" (it's a distinct, valid
+   *   in-memory mode of its own -- an unnamed private temporary
+   *   database -- not an "off" state). Without this, once set to any
+   *   string there would be no value passable back through this same
+   *   validator that turns `useMemoryDatabase` false again.
+   * @param {string|null|undefined} val
    * @throws {TypeError}
    * @returns {void}
    */
   function (val) {
+    if (val === null || val === undefined) {
+      return;
+    }
     if (!/^(?::memory:|file::memory:(\?(?:[\0-"\$-\uD7FF\uE000-\uFFFF]|[\uD800-\uDBFF][\uDC00-\uDFFF]|[\uD800-\uDBFF](?![\uDC00-\uDFFF])|(?:[^\uD800-\uDBFF]|^)[\uDC00-\uDFFF])*)?(#(?:[\0-\t\x0B\f\x0E-\u2027\u202A-\uD7FF\uE000-\uFFFF]|[\uD800-\uDBFF][\uDC00-\uDFFF]|[\uD800-\uDBFF](?![\uDC00-\uDFFF])|(?:[^\uD800-\uDBFF]|^)[\uDC00-\uDFFF])*)?)?$/.test(/** @type {string} */val)) {
-      throw new TypeError('`memoryDatabase` must be the empty string, ":memory:", or a ' + '"file::memory:[?queryString][#hash] URL".');
+      throw new TypeError('`memoryDatabase` must be `null`/`undefined` (to reset it to disabled), the empty string, ' + '":memory:", or a "file::memory:[?queryString][#hash] URL".');
     }
   }],
   // NODE-SPECIFIC CONFIG
@@ -1951,10 +1970,7 @@
     return arg.replaceAll(/((?:[\uD800-\uDBFF](?![\uDC00-\uDFFF])))(?!(?:(?:[^\uD800-\uDBFF]|^)[\uDC00-\uDFFF]))|(^|(?:[\0-\uD7FF\uE000-\uFFFF]|[\uD800-\uDBFF][\uDC00-\uDFFF]|(?:[^\uD800-\uDBFF]|^)[\uDC00-\uDFFF]))((?:(?:[^\uD800-\uDBFF]|^)[\uDC00-\uDFFF]))/g, function (_, unmatchedHighSurrogate, precedingLow, unmatchedLowSurrogate) {
       // Could add a corresponding surrogate for compatibility with `node-sqlite3`: https://bugs.python.org/issue12569 and https://stackoverflow.com/a/6701665/271577
       //   but Chrome having problems
-      if (unmatchedHighSurrogate) {
-        return '^2' + unmatchedHighSurrogate.codePointAt().toString(16).padStart(4, '0');
-      }
-      return (precedingLow || '') + '^3' + unmatchedLowSurrogate.codePointAt().toString(16).padStart(4, '0');
+      return unmatchedHighSurrogate ? '^2' + unmatchedHighSurrogate.codePointAt().toString(16).padStart(4, '0') : (precedingLow || '') + '^3' + unmatchedLowSurrogate.codePointAt().toString(16).padStart(4, '0');
     });
   }
 
@@ -2621,7 +2637,8 @@
   function createNativeDOMException(name, message) {
     // @ts-expect-error It's ok
     // eslint-disable-next-line new-cap -- Ok
-    return new DOMException.prototype.constructor(message, name || 'DOMException');
+    return new DOMException.prototype.constructor(message, /* c8 ignore next -- Defensive fallback; every call site in this codebase always supplies a `name` */
+    name || 'DOMException');
   }
 
   // From web-platform-tests testharness.js name_code_map (though not in new spec)
@@ -2785,8 +2802,10 @@
          */
         get: function get() {
           if (!(this instanceof DOMException ||
+          // eslint-disable-next-line jsdoc/ts-ban-ts-comment -- TS 6/7
           // @ts-ignore Just checking; needed under some TS versions
           this instanceof DummyDOMException ||
+          // eslint-disable-next-line jsdoc/ts-ban-ts-comment -- TS 6/7
           // @ts-ignore Just checking; needed under some TS versions
           this instanceof Error)) {
             throw new TypeError('Illegal invocation');
@@ -2845,6 +2864,7 @@
       value: DOMException
     });
 
+    // eslint-disable-next-line jsdoc/ts-ban-ts-comment -- TS 6/7
     // @ts-ignore We don't need all its properties; needed under some TS versions
     return DOMException;
   }
@@ -2857,6 +2877,7 @@
    * @returns {Error}
    */
   function createNonNativeDOMException(name, message) {
+    // eslint-disable-next-line jsdoc/ts-ban-ts-comment -- TS 6/7
     // @ts-ignore It's ok; needed under some TS versions
     return new ShimNonNativeDOMException(message, name);
   }
@@ -2879,6 +2900,8 @@
       return;
     }
     var msg = error && _typeof(error) === 'object' && error.message ? error.message : (/** @type {string} */error);
+
+    /* c8 ignore next -- Defensive fallback for an environment lacking `console.error` */
     var method = typeof console.error === 'function' ? 'error' : 'log';
     console[method](name + ': ' + message + '. ' + (msg || ''));
     if (console.trace) {
@@ -3064,8 +3087,10 @@
    */
   IDBRequest.__super = function IDBRequest() {
     var _this = this;
+    // eslint-disable-next-line jsdoc/ts-ban-ts-comment -- TS 6/7
     // @ts-ignore It's ok
     this[Symbol.toStringTag] = 'IDBRequest';
+    // eslint-disable-next-line jsdoc/ts-ban-ts-comment -- TS 6/7
     // @ts-ignore Part of `ShimEventTarget`
     this.__setOptions({
       legacyOutputDidListenersThrowFlag: true // Event hook for IndexedB
@@ -3123,10 +3148,7 @@
    * @returns {import('./IDBTransaction.js').IDBTransactionFull|null|undefined}
    */
   IDBRequest.prototype.__getParent = function () {
-    if (this.toString() === '[object IDBOpenDBRequest]') {
-      return null;
-    }
-    return this.__transaction;
+    return this.toString() === '[object IDBOpenDBRequest]' ? null : this.__transaction;
   };
 
   /* eslint-disable unicorn/no-top-level-side-effects -- Would be good */
@@ -3185,8 +3207,10 @@
     function IDBOpenDBRequest() {
       IDBRequest.__super.call(this);
 
+      // eslint-disable-next-line jsdoc/ts-ban-ts-comment -- TS 6/7
       // @ts-ignore It's ok
       this[Symbol.toStringTag] = 'IDBOpenDBRequest';
+      // eslint-disable-next-line jsdoc/ts-ban-ts-comment -- TS 6/7
       // @ts-ignore It's ok
       this.__setOptions({
         legacyOutputDidListenersThrowFlag: true,
@@ -4197,8 +4221,14 @@
                 }
                 if (!multiEntry || !fullKeys && keys.every(function (k) {
                   return cmp(/** @type {Key} */k, /** @type {Key} */key.value) !== 0;
-                }) || fullKeys && keys.every(function (k) {
-                  return cmp(/** @type {Key} */k, /** @type {Key} */ /** @type {unknown} */key) !== 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(function (k) {
+                  return cmp(/** @type {Key} */ /** @type {KeyValueObject} */k.value, /** @type {Key} */key.value) !== 0;
                 })) {
                   safePush(keys, fullKeys ? key : key.value);
                 }
@@ -4223,12 +4253,9 @@
         {
           var date = /** @type {Date} */input;
           if (!Number.isNaN(date.getTime())) {
-            return fullKeys ? {
-              type: type,
-              value: date.getTime()
-            } : {
+            return {
               type: type,
-              value: new Date(date)
+              value: fullKeys ? date.getTime() : new Date(date)
             };
           }
           return {
@@ -4316,10 +4343,7 @@
     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);
   }
 
   /**
@@ -4500,10 +4524,7 @@
    */
   function isMultiEntryMatch(encodedEntry, encodedKey) {
     var 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;
   }
 
   /**
@@ -4621,10 +4642,7 @@
    * @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);
   }
 
   /**
@@ -5030,10 +5048,11 @@
     if (hasLower && hasUpper) {
       sql.push('AND');
     }
-    if (hasUpper) {
-      sql.push(quotedKeyColumnName, range.upperOpen ? '<' : '<=', '?');
-      sqlValues.push(escapeSQLiteStatement(/** @type {string} */encodedUpperKey));
+    if (!hasUpper) {
+      return;
     }
+    sql.push(quotedKeyColumnName, range.upperOpen ? '<' : '<=', '?');
+    sqlValues.push(escapeSQLiteStatement(/** @type {string} */encodedUpperKey));
   }
 
   /**
@@ -5046,10 +5065,7 @@
     if (instanceOf(value, IDBKeyRange)) {
       // We still need to validate IDBKeyRange-like objects (the above check is based on loose duck-typing)
       var range = /** @type {IDBKeyRangeFull} */value;
-      if (range.toString() !== '[object IDBKeyRange]') {
-        return IDBKeyRange.__createInstance(range.lower, range.upper, range.lowerOpen, range.upperOpen);
-      }
-      return range;
+      return range.toString() !== '[object IDBKeyRange]' ? IDBKeyRange.__createInstance(range.lower, range.upper, range.lowerOpen, range.upperOpen) : range;
     }
     if (isNullish(value)) {
       if (nullDisallowed) {
@@ -5094,9 +5110,11 @@
       if (testObject.test) {
         cleanInterface = true;
       }
+      /* c8 ignore start -- Defensive fallback for an engine with a broken `Object.defineProperty` */
     } catch (err) {
       // Object.defineProperty does not work as intended.
     }
+    /* c8 ignore stop -- Defensive fallback for an engine with a broken `Object.defineProperty` */
   }
 
   /**
@@ -5297,6 +5315,7 @@
         this._length = 0;
       };
       DOMStringList.prototype = DOMStringListAlias.prototype;
+      // eslint-disable-next-line jsdoc/ts-ban-ts-comment -- TS 6/7
       // @ts-ignore It's ok; needed under some TS versions
       return /** @type {DOMStringListFull} */new DOMStringList();
     }
@@ -5596,12 +5615,14 @@
    */
   IDBTransaction.prototype.__executeRequests = function () {
     var 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
@@ -5621,6 +5642,10 @@
       var q,
         i = -1;
 
+      // On a standard driver, `keepAliveAndWait` issues a SQL query, which
+      //   is a macrotask. Otherwise it issues ten microtasks.
+      var 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
@@ -5647,6 +5672,7 @@
           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();
@@ -5656,10 +5682,11 @@
           });
         } 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 */
       }
 
       /**
@@ -5672,21 +5699,26 @@
        * @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
         }
+        /* 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) {
-          // TS guard
           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;
@@ -5703,6 +5735,7 @@
         //   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) {
@@ -5712,6 +5745,7 @@
             return;
           }
         }
+        /* c8 ignore stop -- see comment above */
         runContinuationSafely(advanceAfterDispatch);
       }
 
@@ -5723,15 +5757,19 @@
        * @returns {void}
        */
       function error() {
+        /* 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 */
         for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
           args[_key] = arguments[_key];
         }
@@ -5756,10 +5794,11 @@
           }
         });
         q.req.addDefaultEventListener('error', function () {
+          /* 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) {
-            // TS guard
             return;
           }
+          /* c8 ignore stop -- see comment above */
           me.__abortTransaction(q.req.__error);
         });
         me.__active = true;
@@ -5771,16 +5810,19 @@
         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
-            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
+          runContinuationSafely(advanceAfterDispatch);
+          return;
+        }
+        me.__abortTransaction(createDOMException('AbortError', 'A request was aborted (in user handler after error).'));
+        /* c8 ignore stop -- see comment above */
       }
 
       /**
@@ -5804,10 +5846,12 @@
           //   (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)
@@ -5832,18 +5876,22 @@
             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();
       }
 
@@ -5865,16 +5913,20 @@
        *   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;
@@ -5896,13 +5948,15 @@
        * @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();
@@ -5934,31 +5988,34 @@
        * @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(function () {
-          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();
         });
       }
       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 */
       var err = webSQLErrback(/** @type {Error & {code?: number}} */webSQLErr);
       me.__abortTransaction(err);
     }, function () {
@@ -5969,18 +6026,25 @@
         // 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 --
@@ -6029,6 +6093,7 @@
        */
       function complete() {
         me.__completed = true;
+        /* c8 ignore next -- Debug-only log; no test sets `CFG.DEBUG`. */
         if (CFG.DEBUG) {
           console.log('Transaction completed');
         }
@@ -6038,6 +6103,7 @@
           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.
@@ -6045,6 +6111,7 @@
           // (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 = {};
@@ -6052,10 +6119,12 @@
         }
       }
       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
@@ -6091,6 +6160,7 @@
   IDBTransaction.prototype.__createRequest = function (source) {
     var me = this;
     var 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;
@@ -6160,9 +6230,11 @@
    * @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 */
   };
 
   /**
@@ -6176,6 +6248,7 @@
     }
   };
 
+  /* 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}
@@ -6183,6 +6256,7 @@
   IDBTransaction.prototype.__assertVersionChange = function () {
     IDBTransaction.__assertVersionChange(this);
   };
+  /* c8 ignore stop -- see comment above */
 
   /**
    * Returns the specified object store.
@@ -6204,9 +6278,12 @@
       throw createDOMException('NotFoundError', objectStoreName + ' is not participating in this transaction');
     }
     var 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
     //   recreation to create new clone object
@@ -6225,10 +6302,12 @@
   IDBTransaction.prototype.__abortTransaction = function (err) {
     var 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
@@ -6258,19 +6337,16 @@
     if (err !== null) {
       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(function () {
         throw err;
       }, 0);
     }
+    /* c8 ignore stop -- see comment above */
 
     /**
      * @param {import('websql-configurable/lib/websql/WebSQLTransaction.js').default|null} [tx]
@@ -6279,13 +6355,17 @@
      */
     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);
       }
@@ -6301,10 +6381,11 @@
         //  behaves first-in-first-out with the same timeout so we could
         //  just use a `forEach`.
         return promises.then(function () {
+          /* 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) {
-            // TS guard
             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).');
@@ -6315,10 +6396,11 @@
           return new SyncPromise(/** @type {(resolve: (value?: unknown) => void) => void} */
           function (resolve) {
             setTimeout(function () {
+              /* 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) {
-                // TS guard
                 throw new Error('Missing request');
               }
+              /* c8 ignore stop -- see comment above */
               q.req.dispatchEvent(reqEvt); // No need to catch errors
               resolve();
             }, 0);
@@ -6338,10 +6420,12 @@
           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(function (err) {
         console.log('Abort error');
         throw err;
       });
+      /* c8 ignore stop -- see comment above */
     }
     me.__transFinishedCb(true, function (rollback) {
       if (rollback && me.__tx) {
@@ -6349,20 +6433,24 @@
         //   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;
         }
         try {
           me.__tx.executeSql('ROLLBACK', [], 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
@@ -6380,6 +6468,7 @@
     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);
     }
@@ -6411,6 +6500,7 @@
     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);
     }
@@ -6453,6 +6543,7 @@
   };
 
   // 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
@@ -6468,6 +6559,7 @@
       throw err;
     }
   };
+  /* c8 ignore stop -- see comment above */
 
   /**
    *
@@ -7565,7 +7657,7 @@
           return Number.isNaN(t) ? "NaN" : t;
         },
         revive: function revive(e) {
-          return "NaN" === e ? new Date(NaN) : new Date(e);
+          return new Date("NaN" === e ? NaN : e);
         }
       }
     },
@@ -8425,9 +8517,12 @@
   }).find(function (preset) {
     return preset && !Array.isArray(preset) && 'filelist' in preset;
   });
-  var origFileList = specSet && !Array.isArray(specSet) && 'filelist' in specSet ? specSet.filelist : undefined;
-  var origTest = origFileList && _typeof(origFileList) === 'object' && 'test' in origFileList && typeof origFileList.test === 'function' ? origFileList.test : undefined;
-  var origRevive = origFileList && _typeof(origFileList) === 'object' && 'revive' in origFileList && typeof origFileList.revive === 'function' ? origFileList.revive : undefined;
+  var 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;
+  var 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;
+  var 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;
   var customFileList = origFileList ? _objectSpread2(_objectSpread2({}, origFileList), {}, {
     /**
      * @param {unknown} x
@@ -8435,10 +8530,7 @@
      * @returns {boolean}
      */
     test: function 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
@@ -8449,10 +8541,12 @@
       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;
     }
-  }) : undefined;
-  var typeson = new Typeson().register([fe, customFileList ? {
+  }) /* c8 ignore next -- Defensive fallback if typeson-registry's `filelist` preset entry ever goes missing */ : undefined;
+  var typeson = new Typeson().register([fe, /* c8 ignore next -- Defensive fallback if typeson-registry's `filelist` preset entry ever goes missing */
+  customFileList ? {
     filelist: customFileList
   } : {}]);
 
@@ -8608,7 +8702,6 @@
    *   __unique: boolean,
    *   __objectStore: import('./IDBObjectStore.js').IDBObjectStoreFull,
    *   __keyPath: import('./Key.js').KeyPath,
-   *   __recreated?: boolean,
    *   __fetchIndexData: (
    *     range: Query,
    *     opType: "value"|"key"|"count",
@@ -8702,6 +8795,7 @@
             storeHandle.__indexHandles[newName] = oldIndexHandle; // Ensure new reference accessible
             me.__pendingName = oldName;
             var colInfoToPreserveArr = [['key', 'BLOB ' + (objectStore.autoIncrement ? 'UNIQUE, inc INTEGER PRIMARY KEY AUTOINCREMENT' : 'PRIMARY KEY')], ['value', 'BLOB']].concat(
+            // eslint-disable-next-line jsdoc/ts-ban-ts-comment -- TS 6/7
             // @ts-ignore Has numeric indexes instead of iterator; needed under some TS versions
             _toConsumableArray(objectStore.indexNames).filter(function (indexName) {
               return indexName !== newName;
@@ -8753,7 +8847,7 @@
       }
     });
     /** @type {const} */
-    ['__pendingCreate', '__pendingDelete', '__deleted', '__originalName', '__recreated'].forEach(function (p) {
+    ['__pendingCreate', '__pendingDelete', '__deleted', '__originalName'].forEach(function (p) {
       // @ts-expect-error Why is this type "never"?
       idx[p] = index[p];
     });
@@ -8785,11 +8879,12 @@
     var transaction = store.transaction;
     /** @type {import('./IDBTransaction.js').IDBTransactionFull} */
     transaction.__addNonRequestToTransactionQueue(function createIndex(tx, args, success, failure) {
-      var columnExists = idx && (idx.__deleted || idx.__recreated); // This check must occur here rather than earlier as properties may not have been set yet otherwise
+      var columnExists = idx && idx.__deleted; // This check must occur here rather than earlier as properties may not have been set yet otherwise
 
       /** @type {{[key: string]: boolean}} */
       var indexValues = {};
 
+      /* c8 ignore start -- Defensive: SQL execution error, not reliably reproducible without mocking the SQL layer. */
       /**
        * @param {WebSQLTransaction} tx
        * @param {(Error & {code?: number})} err
@@ -8798,6 +8893,7 @@
       function error(tx, err) {
         failure(createDOMException('UnknownError', 'Could not create index "' + indexName + '"' + err.code + '::' + err.message, err));
       }
+      /* c8 ignore stop -- see comment above */
 
       /**
        * @param {WebSQLTransaction} tx
@@ -8847,12 +8943,6 @@
               } else {
                 delete index.__pendingCreate;
                 delete indexHandle.__pendingCreate;
-                if (index.__deleted) {
-                  delete index.__deleted;
-                  delete indexHandle.__deleted;
-                  index.__recreated = true;
-                  indexHandle.__recreated = true;
-                }
                 indexValues = {};
                 success(store);
               }
@@ -8861,7 +8951,7 @@
         }, /** @type {SqlErrorCallback} */error);
       }
       var escapedStoreNameSQL = escapeStoreNameForSQL(storeName);
-      var escapedIndexNameSQL = escapeIndexNameForSQL(index.name);
+      var escapedIndexNameSQL = escapeIndexNameForSQL(indexName);
 
       /**
        * @param {WebSQLTransaction} tx
@@ -8913,6 +9003,7 @@
     var transaction = store.transaction;
     /** @type {import('./IDBTransaction.js').IDBTransactionFull} */
     transaction.__addNonRequestToTransactionQueue(function deleteIndex(tx, args, success, failure) {
+      /* c8 ignore start -- Defensive: SQL execution error, not reliably reproducible without mocking the SQL layer. */
       /**
        * @param {WebSQLTransaction} tx
        * @param {(Error & {code?: number})} err
@@ -8921,6 +9012,7 @@
       function error(tx, err) {
         failure(createDOMException('UnknownError', 'Could not delete index "' + index.name + '"', err));
       }
+      /* c8 ignore stop -- see comment above */
 
       /**
        * @returns {void}
@@ -8929,7 +9021,6 @@
         // Update the object store's index list
         IDBIndex.__updateIndexList(store, tx, function (store) {
           delete index.__pendingDelete;
-          delete index.__recreated;
           index.__deleted = true;
           if (indexHandle) {
             indexHandle.__deleted = true;
@@ -8990,20 +9081,18 @@
    * @param {Query} range
    * @param {"value"|"key"|"count"} opType
    * @param {boolean} nullDisallowed
-   * @param {number} [count]
    * @this {IDBIndexFull}
    * @returns {import('./IDBRequest.js').IDBRequestFull}
    */
-  IDBIndex.prototype.__fetchIndexData = function (range, opType, nullDisallowed, count) {
+  IDBIndex.prototype.__fetchIndexData = function (range, opType, nullDisallowed) {
     var me = this;
-    if (count !== undefined) {
-      count = enforceRange(count, 'unsigned long');
-    }
     IDBIndex.__invalidStateIfDeleted(me);
     IDBObjectStore.__invalidStateIfDeleted(me.objectStore);
+    /* c8 ignore start -- Defensive: `IDBObjectStore.__invalidStateIfDeleted` just above already throws when `me.objectStore.__deleted` is true, so this identical check can never be reached. */
     if (me.objectStore.__deleted) {
       throw createDOMException('InvalidStateError', "This index's object store has been deleted");
     }
+    /* c8 ignore stop -- see comment above */
     IDBTransaction.__assertActive(me.objectStore.transaction);
     if (nullDisallowed && isNullish(range)) {
       throw createDOMException('DataError', 'No key or range was specified');
@@ -9013,7 +9102,7 @@
       for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
         args[_key] = arguments[_key];
       }
-      executeFetchIndexData.apply(void 0, [count].concat(_toConsumableArray(fetchArgs), args));
+      executeFetchIndexData.apply(void 0, _toConsumableArray(fetchArgs).concat(args));
     }, undefined, me);
   };
 
@@ -9172,13 +9261,16 @@
     var colInfoToPreserve = colInfoToPreserveArr.map(function (colInfo) {
       return colInfo.join(' ');
     });
+    /* c8 ignore next -- Defensive: the sole caller always supplies a non-empty `colInfoToPreserveArr` (seeded with `key`/`value` column info), so the empty-array fallback is unreachable. */
     var listColInfoToPreserve = colInfoToPreserve.length ? colInfoToPreserve.join(', ') + ', ' : '';
+    /* c8 ignore next -- Defensive: see comment above. */
     var listColsToPreserve = colNamesToPreserve.length ? colNamesToPreserve.join(', ') + ', ' : '';
 
     // We could adapt the approach at https://stackoverflow.com/a/8430746/271577
     //    to make the approach reusable without passing column names, but it is a bit fragile
     /** @type {import('./IDBTransaction.js').IDBTransactionFull} */
     store.transaction.__addNonRequestToTransactionQueue(function renameIndex(tx, args, success, error) {
+      /* c8 ignore start -- Defensive: only reached if one of the chained `CREATE TABLE`/`INSERT`/`DROP TABLE`/`ALTER TABLE` statements below fails, which is not reliably reproducible without mocking the SQL layer. */
       /**
        * @param {WebSQLTransaction} tx
        * @param {(Error & {code?: number})} err
@@ -9187,6 +9279,7 @@
       function sqlError(tx, err) {
         error(err);
       }
+      /* c8 ignore stop -- see comment above */
       /**
        * @returns {void}
        */
@@ -9195,8 +9288,14 @@
           cb(tx, success);
           return;
         }
+        /* c8 ignore start -- Defensive: `__renameIndex`'s only caller (the `IDBIndex.prototype.name` setter) always supplies a `cb`, so this fallback is dead with the current call graph. */
         success();
       }
+      /* c8 ignore stop -- see comment above */
+      if (!CFG.useSQLiteIndexes) {
+        finish();
+        return;
+      }
       // See https://www.sqlite.org/lang_altertable.html#otheralter
       // We don't query for indexes as we already have the info
       // This approach has the advantage of auto-deleting indexes via the DROP TABLE
@@ -9220,10 +9319,6 @@
               console.log(sql);
             }
             tx.executeSql(sql, [], function (tx) {
-              if (!CFG.useSQLiteIndexes) {
-                finish();
-                return;
-              }
               var indexCreations = colNamesToPreserve.slice(2) // Doing `key` separately and no need for index on `value`
               .map(function (escapedIndexNameSQL) {
                 return new SyncPromise(function (resolve, reject) {
@@ -9232,13 +9327,16 @@
                   // if (CFG.DEBUG) { console.log(sql); }
                   // tx.executeSql(sql, [], function () {
                   var sql = 'CREATE INDEX ' + escapedIndexToRecreate + ' ON ' + escapedStoreNameSQL + '(' + escapedIndexNameSQL + ')';
+                  /* c8 ignore next -- Debug-only log; no test sets `CFG.DEBUG`. */
                   if (CFG.DEBUG) {
                     console.log(sql);
                   }
-                  tx.executeSql(sql, [], resolve, /** @type {SqlErrorCallback} */
+                  tx.executeSql(sql, [], resolve, /* c8 ignore start -- Defensive: SQL execution error, not reliably reproducible without mocking the SQL layer. */
+                  /** @type {SqlErrorCallback} */
                   function (tx, err) {
                     reject(err);
-                  });
+                  }
+                  /* c8 ignore stop -- see comment above */);
                   // }, function (tx, err) {
                   //    reject(err);
                   // });
@@ -9256,19 +9354,25 @@
                   if (CFG.DEBUG) {
                     console.log(sql);
                   }
-                  tx.executeSql(sql, [], resolve, /** @type {SqlErrorCallback} */
+                  tx.executeSql(sql, [], resolve, /* c8 ignore start -- Defensive: SQL execution error, not reliably reproducible without mocking the SQL layer. */
+                  /** @type {SqlErrorCallback} */
                   function (tx, err) {
                     reject(err);
-                  });
-                }, /** @type {SqlErrorCallback} */
+                  }
+                  /* c8 ignore stop -- see comment above */);
+                }, /* c8 ignore start -- Defensive: SQL execution error, not reliably reproducible without mocking the SQL layer. */
+                /** @type {SqlErrorCallback} */
                 function (tx, err) {
                   reject(err);
-                });
+                }
+                /* c8 ignore stop -- see comment above */);
               }));
               SyncPromise.all(indexCreations).then(finish).catch(/** @type {(reason: unknown) => PromiseLike<never>} */
               error).catch(function (err) {
+                /* c8 ignore start -- Defensive: only reached if `finish` or the outer `error` callback itself throws; not reliably reproducible. */
                 console.log('Index rename error');
                 throw err;
+                /* c8 ignore stop -- see comment above */
               });
             }, /** @type {SqlErrorCallback} */sqlError);
           }, /** @type {SqlErrorCallback} */sqlError);
@@ -9297,7 +9401,6 @@
   /* eslint-enable unicorn/no-top-level-side-effects -- Would be good */
 
   /**
-   * @param {number|null} count
    * @param {boolean} unboundedDisallowed
    * @param {IDBIndexFull} index
    * @param {boolean} hasKey
@@ -9314,12 +9417,9 @@
    * @param {(tx: WebSQLTransaction, err: (Error & {code?: number})) => void} error
    * @returns {void}
    */
-  function executeFetchIndexData(count, unboundedDisallowed, index, hasKey, range, opType, multiChecks, sql, sqlValues, tx, args, success, error) {
+  function executeFetchIndexData(unboundedDisallowed, index, hasKey, range, opType, multiChecks, sql, sqlValues, tx, args, success, error) {
     if (unboundedDisallowed) {
-      count = 1;
-    }
-    if (count) {
-      sql.push('LIMIT', String(count));
+      sql.push('LIMIT', '1');
     }
     var isCount = opType === 'count';
     if (CFG.DEBUG) {
@@ -9357,41 +9457,48 @@
         var escapedIndexNameForKeyCol = escapeIndexNameForSQLKeyColumn(index.name);
         var encodedKey = _encode(range, index.multiEntry);
         var _loop = function _loop() {
-          var row = /** @type {{key: string, value: string, [k: string]: string}} */data.rows.item(i);
-          var rowKey = /** @type {import('./Key.js').ValueTypeArray} */
-          _decode(row[escapedIndexNameForKeyCol]);
-          var record;
-          if (hasKey && (multiChecks && /** @type {import('./Key.js').ValueType[]} */range.some(
-          /**
-           * @param {import('./Key.js').ValueType} check
-           * @returns {boolean}
-           */
-          function (check) {
-            return rowKey.includes(check);
-          }) ||
-          // More precise than our SQL
-          isMultiEntryMatch(
-          // Added `JSON.stringify` as was having problems with
-          //        `JSON.stringify` encoding added to nested
-          //        array keys
-          JSON.stringify(encodedKey).slice(1, -1), row[escapedIndexNameForKeyCol]))) {
-            recordCount++;
-            record = row;
-          } else if (!hasKey && !multiChecks) {
-            if (rowKey !== undefined) {
-              recordCount += Array.isArray(rowKey) ? rowKey.length : 1;
+            var row = /** @type {{key: string, value: string, [k: string]: string}} */data.rows.item(i);
+            var rowKey = /** @type {import('./Key.js').ValueTypeArray} */
+            _decode(row[escapedIndexNameForKeyCol]);
+            var record;
+            if (hasKey && (multiChecks && /** @type {import('./Key.js').ValueType[]} */range.some(
+            /**
+             * @param {import('./Key.js').ValueType} check
+             * @returns {boolean}
+             */
+            function (check) {
+              return rowKey.includes(check);
+            }) ||
+            // More precise than our SQL
+            isMultiEntryMatch(
+            // Added `JSON.stringify` as was having problems with
+            //        `JSON.stringify` encoding added to nested
+            //        array keys
+            JSON.stringify(encodedKey).slice(1, -1), row[escapedIndexNameForKeyCol]))) {
+              recordCount++;
               record = row;
+            } else if (!hasKey && !multiChecks) {
+              if (rowKey !== undefined) {
+                recordCount += Array.isArray(rowKey) ? rowKey.length : 1;
+                record = row;
+              }
             }
-          }
-          if (record) {
+            /* c8 ignore start -- Defensive: the SQL `LIKE` clause is a coarse pre-filter and this precise re-check in JS is meant to catch its false positives, but the encoding's per-character dash-prefix plus trailing-space delimiter (see `Key.js` string encoding) and fixed-length number encoding prevent one encoded value from ever being a spurious substring of another, so a `LIKE` hit always also passes this check in practice. */
+            if (!record) {
+              return 0; // continue
+            }
+            /* c8 ignore stop -- see comment above */
+
             records.push(decode$1(record));
             if (unboundedDisallowed) {
               return 1; // break
             }
-          }
-        };
+          },
+          _ret;
         for (var i = 0; i < data.rows.length; i++) {
-          if (_loop()) break;
+          _ret = _loop();
+          if (_ret === 0) continue;
+          if (_ret === 1) break;
         }
       } else {
         for (var _i = 0; _i < data.rows.length; _i++) {
@@ -9405,8 +9512,16 @@
       if (isCount) {
         success(recordCount);
       } else if (recordCount === 0) {
+        // `unboundedDisallowed` is always `true` here: this function is only reached (for
+        //   non-`count` `opType`s) via `get`/`getKey`, which always pass `nullDisallowed: true`
+        //   through as `unboundedDisallowed`. `getAll`/`getAllKeys`/`getAllRecords` use a
+        //   different (cursor-based) code path, so the `unboundedDisallowed`-`false` case
+        //   (returning `[]` here) is unreachable given current callers.
+        /* c8 ignore next -- see comment above */
         success(unboundedDisallowed ? undefined : []);
       } else {
+        // `unboundedDisallowed` is always `true` here; see comment above.
+        /* c8 ignore next -- see comment above */
         success(unboundedDisallowed ? records[0] : records);
       }
     }, /** @type {SqlErrorCallback} */error);
@@ -9650,6 +9765,7 @@
               tx.executeSql(sql, sqlValues, function (tx) {
                 // This SQL preserves indexes per https://www.sqlite.org/lang_altertable.html
                 var sql = 'ALTER TABLE ' + escapeStoreNameForSQL(oldName) + ' RENAME TO ' + escapeStoreNameForSQL(name);
+                /* c8 ignore next -- Debug-only log; no test sets `CFG.DEBUG` while renaming a store. */
                 if (CFG.DEBUG) {
                   console.log(sql);
                 }
@@ -9658,8 +9774,10 @@
                   success();
                 });
               }, function (tx, err) {
+                /* c8 ignore start -- Defensive: SQL execution error, not reliably reproducible without mocking the SQL layer. */
                 error(err);
                 return false;
+                /* c8 ignore stop -- see comment above */
               });
             });
           }
@@ -9733,6 +9851,7 @@
       storeHandles[storeName] = IDBObjectStore.__clone(store, transaction);
     }
     transaction.__addNonRequestToTransactionQueue(function createObjectStore(tx, args, success, failure) {
+      /* c8 ignore start -- Defensive: SQL execution error, not reliably reproducible without mocking the SQL layer. */
       /**
        * @param {WebSQLTransaction} tx
        * @param {(Error & {code?: number})} [err]
@@ -9745,6 +9864,8 @@
         failure(createDOMException('UnknownError', 'Could not create object store "' + storeName + '"', err));
         return false;
       }
+      /* c8 ignore stop -- see comment above */
+
       var escapedStoreNameSQL = escapeStoreNameForSQL(storeName);
       // key INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL UNIQUE
       var sql = ['CREATE TABLE', escapedStoreNameSQL, '(key BLOB', store.autoIncrement ? 'UNIQUE, inc INTEGER PRIMARY KEY AUTOINCREMENT' : 'PRIMARY KEY', ', value BLOB)'].join(' ');
@@ -9799,6 +9920,7 @@
 
     // Remove the object store from WebSQL
     transaction.__addNonRequestToTransactionQueue(function deleteObjectStore(tx, args, success, failure) {
+      /* c8 ignore start -- Defensive: SQL execution error, not reliably reproducible without mocking the SQL layer. */
       /**
        * @param {WebSQLTransaction} tx
        * @param {(Error & {code?: number})} [err]
@@ -9811,6 +9933,8 @@
         failure(createDOMException('UnknownError', 'Could not delete ObjectStore', err));
         return false;
       }
+      /* c8 ignore stop -- see comment above */
+
       tx.executeSql('SELECT "name" FROM __sys__ WHERE "name" = ?', [escapeSQLiteStatement(store.__currentName)], function (tx, data) {
         if (data.rows.length > 0) {
           tx.executeSql('DROP TABLE ' + escapeStoreNameForSQL(store.__currentName), [], function () {
@@ -9990,13 +10114,15 @@
           return;
         }
         var indexKeyValue = indexKey.value;
+        /* c8 ignore start -- Defensive: unreachable given the current `Key.js` implementation, where a keyPath evaluation that would resolve to `undefined` always instead reports `invalid`/`failure` (caught above, causing an earlier `return`) rather than succeeding with an `undefined` value. */
         if (indexKeyValue === undefined) {
           resolve(undefined);
           return;
         }
+        /* c8 ignore stop -- see comment above */
         var multiCheck = index.multiEntry && Array.isArray(indexKeyValue);
         var fetchArgs = buildFetchIndexDataSQL(true, index, indexKeyValue, 'key', multiCheck);
-        executeFetchIndexData.apply(void 0, [null].concat(_toConsumableArray(fetchArgs), [tx, null, function success(key) {
+        executeFetchIndexData.apply(void 0, _toConsumableArray(fetchArgs).concat([tx, null, function success(key) {
           if (key === undefined || excludeKey !== undefined && cmp(/** @type {import('./Key.js').Key} */key, excludeKey) === 0) {
             resolve(undefined);
             return;
@@ -10076,16 +10202,18 @@
          * @returns {void}
          */
         function setIndexInfo(index) {
+          /* c8 ignore start -- Defensive: unreachable given the current `Key.js` implementation, where a keyPath evaluation that would resolve to `undefined` always instead reports `invalid`/`failure` (caught above, causing an earlier `return`) rather than succeeding with an `undefined` value. */
           if (indexKeyValue === undefined) {
             return;
           }
+          /* c8 ignore stop -- see comment above */
           paramMap[index.__currentName] = /** @type {string} */
           _encode(indexKeyValue, index.multiEntry);
         }
         if (index.unique) {
           var multiCheck = index.multiEntry && Array.isArray(indexKeyValue);
           var fetchArgs = buildFetchIndexDataSQL(true, index, indexKeyValue, 'key', multiCheck);
-          executeFetchIndexData.apply(void 0, [null].concat(_toConsumableArray(fetchArgs), [tx, null, function success(key) {
+          executeFetchIndexData.apply(void 0, _toConsumableArray(fetchArgs).concat([tx, null, function success(key) {
             if (key === undefined) {
               setIndexInfo(index);
               resolve(undefined);
@@ -10176,6 +10304,7 @@
       _me$__validateKeyAndV2 = _slicedToArray(_me$__validateKeyAndV, 2),
       ky = _me$__validateKeyAndV2[0],
       clonedValue = _me$__validateKeyAndV2[1];
+    // eslint-disable-next-line jsdoc/ts-ban-ts-comment -- TS 6/7
     // @ts-ignore -- Private API
     IDBObjectStore.__storingRecordObjectStore(request, me, true, clonedValue, true, ky);
     return request;
@@ -10207,6 +10336,7 @@
       _me$__validateKeyAndV4 = _slicedToArray(_me$__validateKeyAndV3, 2),
       ky = _me$__validateKeyAndV4[0],
       clonedValue = _me$__validateKeyAndV4[1];
+    // eslint-disable-next-line jsdoc/ts-ban-ts-comment -- TS 6/7
     // @ts-ignore -- Private API
     IDBObjectStore.__storingRecordObjectStore(request, me, true, clonedValue, false, ky);
     return request;
@@ -10233,8 +10363,10 @@
       }
       cb(tx);
     }, function (tx, err) {
+      /* c8 ignore start -- Defensive: SQL execution error, not reliably reproducible without mocking the SQL layer. */
       error(err);
       return false;
+      /* c8 ignore stop -- see comment above */
     });
   };
 
@@ -10343,16 +10475,20 @@
             return;
           }
           ret = getKey ? _decode(unescapeSQLiteResponse(/** @type {{key: string}} */data.rows.item(0).key), false) : decode(unescapeSQLiteResponse(/** @type {{value: string}} */data.rows.item(0).value));
+          /* c8 ignore start -- Defensive: catches unexpected decode failures (e.g. corrupted stored data); not reliably reproducible via the public API since encode/decode are always paired and never write undecodable data. */
         } catch (e) {
           // If no result is returned, or error occurs when parsing JSON
           if (CFG.DEBUG) {
             console.log(e);
           }
         }
+        /* c8 ignore stop -- see comment above */
         success(ret);
       }, function (tx, err) {
+        /* c8 ignore start -- Defensive: SQL execution error, not reliably reproducible without mocking the SQL layer. */
         error(err);
         return false;
+        /* c8 ignore stop -- see comment above */
       });
     }, undefined, me);
   };
@@ -10464,8 +10600,10 @@
         });
         success();
       }, function (tx, err) {
+        /* c8 ignore start -- Defensive: SQL execution error, not reliably reproducible without mocking the SQL layer. */
         error(err);
         return false;
+        /* c8 ignore stop -- see comment above */
       });
     }, undefined, me);
   };
@@ -10493,8 +10631,10 @@
         });
         success();
       }, function (tx, err) {
+        /* c8 ignore start -- Defensive: SQL execution error, not reliably reproducible without mocking the SQL layer. */
         error(err);
         return false;
+        /* c8 ignore stop -- see comment above */
       });
     }, undefined, me);
   };
@@ -10829,7 +10969,7 @@
     if (keyPath !== null && !isValidKeyPath(keyPath)) {
       throw createDOMException('SyntaxError', 'The keyPath argument contains an invalid key path.');
     }
-    if (Object.hasOwn(this.__objectStores, storeName) && !this.__objectStores[storeName].__pendingDelete) {
+    if (Object.hasOwn(this.__objectStores, storeName) && !this.__objectStores[storeName].__pendingDelete && !this.__objectStores[storeName].__deleted) {
       throw createDOMException('ConstraintError', 'Object store "' + storeName + '" already exists in ' + this.name);
     }
     var autoInc = createOptions.autoIncrement;
@@ -10978,7 +11118,6 @@
     }
   };
 
-  // Todo __forceClose: Add tests for `__forceClose`
   /**
    *
    * @param {string} msg
@@ -10987,23 +11126,39 @@
    */
   IDBDatabase.prototype.__forceClose = function (msg) {
     var me = this;
+    // `close()` (below) resets `me.__transactions` to `[]`, so the
+    //   transactions to abort -- and the total count the completion check
+    //   below needs -- must be captured before calling it, not read back off
+    //   `me.__transactions` afterward.
+    var transactions = me.__transactions;
     me.close();
+
+    /**
+     * @returns {void}
+     */
+    function dispatchClose() {
+      // Todo __forceClose: unblock any pending `upgradeneeded` or `deleteDatabase` calls
+      var evt = createEvent('close');
+      setTimeout(function () {
+        me.dispatchEvent(evt);
+      }, 0);
+    }
+    if (!transactions.length) {
+      dispatchClose();
+      return;
+    }
     var ct = 0;
-    me.__transactions.forEach(function (trans) {
+    transactions.forEach(function (trans) {
       // eslint-disable-next-line camelcase -- Clear API
       trans.on__abort = function () {
         ct++;
-        if (ct === me.__transactions.length) {
-          // Todo __forceClose: unblock any pending `upgradeneeded` or `deleteDatabase` calls
-          var evt = createEvent('close');
-          setTimeout(function () {
-            me.dispatchEvent(evt);
-          }, 0);
+        if (ct !== transactions.length) {
+          return;
         }
+        dispatchClose();
       };
       trans.__abortTransaction(createDOMException('AbortError', 'The connection was force-closed: ' + (msg || '')));
     });
-    me.__transactions = [];
   };
   /* eslint-disable unicorn/no-top-level-side-effects -- Would be good */
   defineOuterInterface(IDBDatabase.prototype, listeners);
@@ -11170,6 +11325,7 @@
           return undefined;
         }
         var e = /** @type {Event & IDBVersionChangeEvent} */
+        // eslint-disable-next-line jsdoc/ts-ban-ts-comment -- TS 6/7
         // @ts-ignore It's ok; needed under some TS versions
         new IDBVersionChangeEvent('versionchange', {
           oldVersion: oldVersion,
@@ -11217,6 +11373,7 @@
           }
         };
         var e = /** @type {Event & IDBVersionChangeEvent} */
+        // eslint-disable-next-line jsdoc/ts-ban-ts-comment -- TS 6/7
         // @ts-ignore It's ok; needed under some TS versions
         new IDBVersionChangeEvent('blocked', {
           oldVersion: oldVersion,
@@ -11277,6 +11434,13 @@
 
   /** @type {import('websql-configurable/lib/websql/WebSQLDatabase.js').default} */
   var sysdb;
+  // Tracks which `CFG.memoryDatabase` value `sysdb` was opened against, so a
+  //   later change to that config (e.g. toggling in-memory mode on and back
+  //   off) causes `sysdb` to be recreated for the new setting rather than
+  //   staying pinned, forever, to whatever it was the first time any database
+  //   was created in the process.
+  /** @type {string|null|undefined} */
+  var sysdbMemoryDatabaseSetting;
   var nameCounter = 0;
 
   /**
@@ -11358,12 +11522,20 @@
   function cleanupDatabaseResources(__openDatabase, name, escapedDatabaseName, databaseDeleted, dbError) {
     var useMemoryDatabase = typeof CFG.memoryDatabase === 'string';
     if (useMemoryDatabase) {
+      /* c8 ignore start -- Defensive: only reachable if `websqlDBCache[name]`
+         was initialized as an empty placeholder by `open()`'s connection-queue
+         setup (`addRequestToConnectionQueue`, above `openDB`) but never
+         populated with an actual instance -- e.g. `__openDatabase` throwing
+         after a `dbVersions` row already existed for `name` from an earlier,
+         successful `open()` -- or if `name` was never added to the cache at
+         all. Not reachable via normal, non-tampered API usage. */
       var latestSQLiteDBCached = Object.hasOwn(websqlDBCache, name) ? getLatestCachedWebSQLDB(name) : null;
       if (!latestSQLiteDBCached) {
         console.warn('Could not find a memory database instance to delete.');
         databaseDeleted();
         return;
       }
+      /* c8 ignore stop -- see comment above */
       var _sqliteDB = latestSQLiteDBCached._db;
       if (!_sqliteDB || !_sqliteDB.close) {
         console.error('The `openDatabase` implementation does not have the expected `._db.close` method for closing the database');
@@ -11417,15 +11589,24 @@
             tables.item(i).name)), [], function () {
               deleteTables(i + 1);
             }, function () {
+              /* c8 ignore start -- Defensive: continues deleting the rest
+                 even if this specific store's table is already gone (e.g.
+                 duplicate `__sys__` rows for the same escaped table name, or
+                 external tampering); not reachable via normal API usage. */
               deleteTables(i + 1);
               return false;
+              /* c8 ignore stop -- see comment above */
             });
           }
         })(0);
       }, function () {
-        // __sys__ table does not exist, but that does not mean delete did not happen
+        /* c8 ignore start -- `__sys__` is always created by `openDB` before this
+           database's `dbVersions` row (a prerequisite for reaching this code at
+           all) is ever inserted; only reachable if the file was tampered with/
+           removed externally afterward. */
         databaseDeleted();
         return false;
+        /* c8 ignore stop -- see comment above */
       });
     });
   }
@@ -11456,9 +11637,11 @@
       }
       failure(er);
     }
-    if (sysdb) {
+    if (sysdb && sysdbMemoryDatabaseSetting === CFG.memoryDatabase) {
       success();
     } else {
+      // eslint-disable-next-line unicorn/no-top-level-assignment-in-function -- Needed
+      sysdbMemoryDatabaseSetting = CFG.memoryDatabase;
       // eslint-disable-next-line unicorn/no-top-level-assignment-in-function -- Necessary?
       sysdb = __openDatabase(typeof CFG.memoryDatabase === 'string' ? CFG.memoryDatabase : joinPath(typeof CFG.sysDatabaseBasePath === 'string' ? CFG.sysDatabaseBasePath : CFG.databaseBasePath || '', '__sysdb__' + (CFG.addSQLiteExtension !== false ? '.sqlite' : '')), '1', 'System Database', CFG.DEFAULT_DB_SIZE);
       sysdb.transaction(function (systx) {
@@ -11638,6 +11821,17 @@
              * @returns {void}
              */
             var sysdbFinishedCb = function sysdbFinishedCb(systx, err, cb) {
+              /* c8 ignore start -- This initial definition is always
+                 superseded before ever being invoked: the `sysdb.transaction(...)`
+                 call below always reaches its `nonstandardTransCb` (4th arg)
+                 after this same SQL batch finishes running (since `dbCreateError`
+                 always reports errors as "handled" and this call site is never
+                 a `readTransaction`), which unconditionally reassigns
+                 `sysdbFinishedCb` to a version using the library's own
+                 `rollback`/`commit` -- well before any real invocation from
+                 `on__beforecomplete`/`on__preabort`/`on__abort` below (those only
+                 fire once the upgrade transaction itself later completes/aborts).
+                 Kept as a defensive fallback in case that invariant ever changes. */
               if (err) {
                 /**
                  * @param {unknown} [errorToShow]
@@ -11686,6 +11880,7 @@
               }
               // In browser, should auto-commit
               cb(); // eslint-disable-line promise/no-callback-in-promise -- Convenient
+              /* c8 ignore stop -- see comment above */
             };
             sysdb.transaction(function (systx) {
               /**
@@ -11693,6 +11888,7 @@
                */
               function versionSet() {
                 var e = /** @type {import('eventtargeter').EventWithProps & Event & IDBVersionChangeEvent} */
+                // eslint-disable-next-line jsdoc/ts-ban-ts-comment -- TS 6/7
                 // @ts-ignore It's ok; needed under some TS versions
                 new IDBVersionChangeEvent('upgradeneeded', {
                   oldVersion: oldVersion,
@@ -11818,9 +12014,17 @@
                 // eslint-disable-next-line camelcase -- Clear API
                 req.transaction.on__complete = function () {
                   var pos = connection.__transactions.indexOf(req.transaction);
+                  // `req.transaction` (the versionchange transaction) is created
+                  //   directly via `IDBTransaction.__createInstance` above, never
+                  //   via `IDBDatabase.prototype.transaction()` (the only place
+                  //   that pushes onto `connection.__transactions`), so `pos` is
+                  //   always -1 here.
+                  /* c8 ignore start -- see comment above */
                   if (pos !== -1) {
                     connection.__transactions.splice(pos, 1);
                   }
+                  /* c8 ignore stop -- see comment above */
+
                   if (/** @type {import('./IDBDatabase.js').IDBDatabaseFull} */req.__result.__closePending) {
                     req.__transaction = null;
                     var err = createDOMException('AbortError', 'The connection has been closed.');
@@ -11856,9 +12060,16 @@
                 systx.executeSql('UPDATE dbVersions SET "version" = ? WHERE "name" = ?', [version, sqlSafeName], versionSet, dbCreateError);
               }
             }, dbCreateError, undefined, function (currentTask, err, done, rollback, commit) {
+              // Defensive fallback, not reachable in practice: same reasoning
+              //   as `deleteDatabase`'s own `nonstandardTransCb` below
+              //   (`currentTask.readOnly` is always false here, and
+              //   `dbCreateError` always returns `false`, so `err` is never
+              //   truthy either).
+              /* c8 ignore start -- see comment above */
               if (currentTask.readOnly || err) {
                 return true;
               }
+              /* c8 ignore stop -- see comment above */
               sysdbFinishedCb = function sysdbFinishedCb(systx, err, cb) {
                 if (err) {
                   rollback(err,
@@ -11873,7 +12084,17 @@
                       } else {
                         systx.executeSql('UPDATE dbVersions SET "version" = ? WHERE "name" = ?', [oldVersion, sqlSafeName]);
                       }
-                    }, function (sqlErr) {
+                    },
+                    // Deeply-nested defensive path: only reached if
+                    //   the *revert* SQL (undoing the `dbVersions`
+                    //   INSERT/UPDATE after the original version-
+                    //   upgrade itself already failed) fails a
+                    //   *second* time. Not feasibly triggerable
+                    //   without fault-injecting the underlying SQL
+                    //   driver on this specific, already-failing
+                    //   revert statement.
+                    function (sqlErr) {
+                      /* c8 ignore next 2 -- see comment above */
                       isRevertingSysdb = false;
                       cb(sqlErr); // eslint-disable-line promise/no-callback-in-promise -- Convenient
                     }, function () {
@@ -11889,8 +12110,20 @@
             });
             return undefined;
           }).catch(function (err) {
+            /* c8 ignore start -- Purely defensive: nothing in
+               `triggerAnyVersionChangeAndBlockedEvents`'s promise chain
+               (or this `.then()` continuation above) ever rejects/throws
+               under any reachable application-level condition -- all of
+               its continuations resolve cleanly, and its `dispatchEvent`
+               calls are deliberately fire-and-forget ("No need to catch
+               errors"), running inside a `setTimeout` where a listener
+               throwing becomes an uncaught exception in that macrotask
+               rather than a promise rejection here. This exists solely
+               to surface a truly-unexpected internal bug via the console
+               before rethrowing, not to handle a real, testable error path. */
             console.log('Error within `triggerAnyVersionChangeAndBlockedEvents`');
             throw err;
+            /* c8 ignore stop -- see comment above */
           });
         } else {
           finishRequest();
@@ -11918,11 +12151,19 @@
       if ((useMemoryDatabase || useDatabaseCache) && Object.hasOwn(websqlDBCache, name) && Object.hasOwn(websqlDBCache[name], version)) {
         db = websqlDBCache[name][version];
       } else {
-        db = /** @type {DatabaseFull} */me.__openDatabase(useMemoryDatabase ? CFG.memoryDatabase : joinPath(CFG.databaseBasePath || '', escapedDatabaseName), '1', name, CFG.DEFAULT_DB_SIZE);
+        db = /** @type {DatabaseFull} */me.__openDatabase(useMemoryDatabase ? (/** @type {string} */CFG.memoryDatabase) : joinPath(CFG.databaseBasePath || '', escapedDatabaseName), '1', name, CFG.DEFAULT_DB_SIZE);
         if (useDatabaseCache) {
+          /* c8 ignore start -- Defensive: by the time `openDB` runs,
+             `websqlDBCache[name]` has always already been created by
+             `addRequestToConnectionQueue`'s own callback above (guarded
+             by this same `useDatabaseCache` condition), which always
+             runs first and unconditionally ensures the entry exists
+             before ever calling `openDB`. Kept as a safety net in case
+             that invariant ever changes. */
           if (!Object.hasOwn(websqlDBCache, name)) {
             websqlDBCache[name] = {};
           }
+          /* c8 ignore stop -- see comment above */
           websqlDBCache[name][version] = db;
         }
       }
@@ -12073,6 +12314,7 @@
           req.__result = undefined;
           req.__done = true;
           var e = /** @type {Event & IDBVersionChangeEvent} */
+          // eslint-disable-next-line jsdoc/ts-ban-ts-comment -- TS 6/7
           // @ts-ignore It's ok; needed under some TS versions
           new IDBVersionChangeEvent('success', {
             oldVersion: version,
@@ -12115,9 +12357,23 @@
                   cleanupDatabaseResources(me.__openDatabase, name, escapedDatabaseName, databaseDeleted, dbError);
                 }, dbError);
               }, dbError, undefined, function (currentTask, err, done, rollback, commit) {
+                /* c8 ignore start -- Defensive fallback, not reachable in
+                   practice: `currentTask.readOnly` is always `false` here
+                   (this callback is only ever attached to the writable
+                   `sysdb.transaction(...)` call above, never to a
+                   `sysdb.readTransaction(...)`), and `err` can only be
+                   truthy if the `DELETE FROM dbVersions` statement's own
+                   error callback (`dbError`) reports the failure back to
+                   `websql-configurable` as unhandled -- but `dbError`
+                   deliberately always `return`s `false`, which tells the
+                   library the error was already handled (and to keep
+                   `err` falsy here), precisely so this custom
+                   `sysdbFinishedCbDelete` rollback/commit path below is
+                   used instead of the library's own default rollback. */
                 if (currentTask.readOnly || err) {
                   return true;
                 }
+                /* c8 ignore stop -- see comment above */
                 sysdbFinishedCbDelete = function sysdbFinishedCbDelete(err, cb) {
                   if (err) {
                     rollback(err, cb);
@@ -12243,10 +12499,9 @@
   };
 
   /**
-   * @todo forceClose: Test
    * This is provided to facilitate unit-testing of the
    *  closing of a database connection with a forced flag:
-   * <https://w3c.github.io/IndexedDB/#steps-for-closing-a-database-connection>
+   * <https://w3c.github.io/IndexedDB/#steps-for-closing-a-database-connection>.
    * @param {string} dbName
    * @param {Integer} connIdx
    * @param {string} msg
@@ -12347,6 +12602,7 @@
      * @this {IDBRecordFull}
      */
     function IDBRecord() {
+      // eslint-disable-next-line jsdoc/ts-ban-ts-comment -- TS 6/7
       // @ts-ignore Should be ok
       this[Symbol.toStringTag] = 'IDBRecord';
       this.__key = key;
@@ -12383,6 +12639,7 @@
       if (!(this instanceof IDBRecordAlias)) {
         throw new TypeError('Illegal invocation');
       }
+      // eslint-disable-next-line jsdoc/ts-ban-ts-comment -- TS 6/7
       // @ts-ignore `this` is a real instance past the check above (not an issue in TS7)
       return this['__' + prop];
     });
@@ -12725,6 +12982,7 @@
         success(undefined, undefined, undefined);
       }
     }, function (tx, err) {
+      /* c8 ignore next -- Debug-only log; no test sets `CFG.DEBUG`. */
       if (CFG.DEBUG) {
         console.log('Could not execute Cursor.continue', sqlStr, sqlValues);
       }
@@ -12908,7 +13166,16 @@
           if (a.key > b.key) {
             return me.direction === 'prev' ? -1 : 1;
           }
+          /* c8 ignore start -- Defensive: only reachable if two matches
+             in the same batch shared both the same `matchingKey` and
+             the same primary `key`, which would require the same
+             record's multi-entry array to contain a duplicate value.
+             `Key.js`'s array-to-key conversion already drops duplicate
+             values when a multi-entry index entry is built, so this
+             can never happen in practice; kept only to satisfy the
+             `Array.prototype.sort` comparator contract. */
           return 0;
+          /* c8 ignore stop -- see comment above */
         });
         me.__prefetchedIndex = 0;
         me.__prefetchedData = {
@@ -12927,13 +13194,19 @@
           console.log('[multiEntry] Preloaded ' + me.__prefetchedData.length + ' records for multiEntry cursor');
         }
         me.__decode(rows[0], success);
-      }, function (tx, err) {
+      },
+      /* c8 ignore start -- Defensive: guards against an unexpected SQLite
+         execution error (e.g. I/O error, corruption) while querying for
+         multi-entry cursor matches; not reliably reproducible without
+         mocking the SQL layer. */
+      function (tx, err) {
         if (CFG.DEBUG) {
           console.log('[multiEntry] Could not execute Cursor.continue', sqlStr, sqlValues);
         }
         error(err);
         return false;
       });
+      /* c8 ignore stop -- see comment above */
     }
     runQuery();
   };
@@ -13042,6 +13315,7 @@
    * @returns {void}
    */
   IDBCursor.prototype.__invalidateCache = function () {
+    // eslint-disable-next-line jsdoc/ts-ban-ts-comment -- TS 6/7
     // @ts-ignore Why is this not being found?; needed under some TS versions
     this.__prefetchedData = null;
     this.__multiEntryExhausted = false;
@@ -13066,7 +13340,7 @@
       convertValueToKeyRethrowingAndIfInvalid(key);
       var cmpResult = cmp(key, me.key);
       if (cmpResult === 0 || me.direction.includes('next') && cmpResult === -1 || me.direction.includes('prev') && cmpResult === 1) {
-        throw createDOMException('DataError', 'Cannot ' + (advanceState ? 'advance' : 'continue') + ' the cursor in an unexpected direction');
+        throw createDOMException('DataError', 'Cannot continue the cursor in an unexpected direction');
       }
     }
     this.__continueFinish(key, undefined, advanceState);
@@ -13323,6 +13597,7 @@
       //   continuation logic in `__findBasic` to see this update's
       //   effect on ordering (see "Modify records during cursor
       //   iteration" in idbcursor_update_index.any.js).
+      // eslint-disable-next-line jsdoc/ts-ban-ts-comment -- TS 6/7
       // @ts-ignore -- API (not erring in TS 6)
       IDBObjectStore.__storingRecordObjectStore(request, me.__store, true, clonedValue, false, key);
     }
@@ -13372,14 +13647,33 @@
             // We don't invalidate the cache (as we don't access it anymore
             //    and it will set the index off)
             success(undefined);
+            /* c8 ignore start -- Defensive: `__find` (invoked just above) has
+               already confirmed a row exists for this primary key within the
+               same transaction queue, so `rowsAffected` should always be 1 in
+               normal usage. This branch would only be reached if the underlying
+               row were removed by another request queued in the same
+               transaction between `__find`'s check and this DELETE actually
+               running (e.g. deleting the same record directly via the object
+               store while a cursor over it is mid-iteration); attempts to
+               construct such a scenario instead trigger a transaction abort
+               (`AbortError`) before this callback ever runs, since the default
+               action of an unhandled request error is to abort the
+               transaction. */
           } else {
             // @ts-expect-error Apparently ok
             error('No rows with key found' + key);
           }
-        }, function (tx, data) {
+          /* c8 ignore stop -- see comment above */
+        },
+        /* c8 ignore start -- Defensive: guards against an unexpected SQLite
+           execution error (e.g. I/O error, corruption) while deleting the
+           current row; not reliably reproducible without mocking the SQL
+           layer. */
+        function (tx, data) {
           error(data);
           return false;
         });
+        /* c8 ignore stop -- see comment above */
       }, error);
     }, undefined, me);
   };
@@ -13790,7 +14084,7 @@
       setConfig(initialConfig);
     }
     var IDB = /** @type {ShimmedObject & {[key: string]: unknown}} */
-    /** @type {unknown} */idb || globalThis || {};
+    /** @type {unknown} */idb || globalThis;
     /**
      * @param {string} name
      * @param {unknown} value
@@ -13881,80 +14175,87 @@
           });
         }
         var shimIDBFactory = IDBFactory;
-        if (CFG.win.openDatabase !== undefined) {
-          shimIndexedDB.__openDatabase = CFG.win.openDatabase.bind(CFG.win); // We cache here in case the function is overwritten later as by the IndexedDB support promises tests
-          // Polyfill ALL of IndexedDB, using WebSQL
-          shim('indexedDB', shimIndexedDB, {
-            enumerable: true,
-            configurable: true,
-            get: function get() {
-              if (this !== IDB && !isNullish(this) && !this.shimNS) {
-                // Latter is hack for test environment
-                throw new TypeError('Illegal invocation');
-              }
-              return shimIndexedDB;
+        if (CFG.win.openDatabase === undefined) {
+          return;
+        }
+        shimIndexedDB.__openDatabase = CFG.win.openDatabase.bind(CFG.win); // We cache here in case the function is overwritten later as by the IndexedDB support promises tests
+        // Polyfill ALL of IndexedDB, using WebSQL
+        shim('indexedDB', shimIndexedDB, {
+          enumerable: true,
+          configurable: true,
+          get: function get() {
+            if (this !== IDB && !isNullish(this) && !this.shimNS) {
+              // Latter is hack for test environment
+              throw new TypeError('Illegal invocation');
             }
-          });
-          /** @type {[string, unknown][]} */
-          [['IDBFactory', shimIDBFactory], ['IDBDatabase', IDBDatabase], ['IDBObjectStore', IDBObjectStore], ['IDBIndex', IDBIndex], ['IDBTransaction', IDBTransaction], ['IDBCursor', IDBCursor], ['IDBCursorWithValue', IDBCursorWithValue], ['IDBRecord', IDBRecord], ['IDBKeyRange', IDBKeyRange], ['IDBRequest', IDBRequest], ['IDBOpenDBRequest', IDBOpenDBRequest], ['IDBVersionChangeEvent', IDBVersionChangeEvent]].forEach(function (_ref3) {
-            var _ref4 = _slicedToArray(_ref3, 2),
-              prop = _ref4[0],
-              obj = _ref4[1];
-            shim(prop, obj, {
-              enumerable: false,
-              configurable: true
-            });
-          });
-          // For Node environments
-          if (CFG.fs) {
-            setFS(CFG.fs);
+            return shimIndexedDB;
           }
-          if (CFG.fullIDLSupport) {
-            // Slow per MDN so off by default! Though apparently needed for WebIDL: https://stackoverflow.com/questions/41927589/rationales-consequences-of-webidl-class-inheritance-requirements
-
-            Object.setPrototypeOf(IDB.IDBOpenDBRequest, IDB.IDBRequest);
-            Object.setPrototypeOf(IDB.IDBCursorWithValue, IDB.IDBCursor);
-            Object.setPrototypeOf(IDBDatabase, EventTarget);
-            Object.setPrototypeOf(IDBRequest, EventTarget);
-            Object.setPrototypeOf(IDBTransaction, EventTarget);
-            Object.setPrototypeOf(IDBVersionChangeEvent, ShimEvent);
-            // `ShimDOMException` is the real native `DOMException` when one
-            //   is available (see `DOMException.js`'s `useNativeDOMException`)
-            //   -- which, unlike the shim classes above, is a single,
-            //   process-wide singleton shared by reference across every
-            //   sandbox this library gets installed into (see
-            //   `node-idb-test.js`'s `sandboxObj`). A native `DOMException`
-            //   already has the correct prototype chain out of the box
-            //   (`Object.getPrototypeOf(DOMException) === Function.prototype`,
-            //   not `Error`), so forcing it here isn't just unneeded but
-            //   actively wrong -- and, because it's shared, permanently
-            //   wrong for every later use of `DOMException` in the same
-            //   process (e.g. a later WPT test file's own idlharness-style
-            //   check that `DOMException` does *not* inherit from `Error`
-            //   on the class side), not just this one shim install.
-            if (typeof DOMException === 'undefined' || ShimDOMException !== DOMException) {
-              Object.setPrototypeOf(ShimDOMException, Error);
-              Object.setPrototypeOf(ShimDOMException.prototype, Error.prototype);
-            }
+        });
+        /** @type {[string, unknown][]} */
+        [['IDBFactory', shimIDBFactory], ['IDBDatabase', IDBDatabase], ['IDBObjectStore', IDBObjectStore], ['IDBIndex', IDBIndex], ['IDBTransaction', IDBTransaction], ['IDBCursor', IDBCursor], ['IDBCursorWithValue', IDBCursorWithValue], ['IDBRecord', IDBRecord], ['IDBKeyRange', IDBKeyRange], ['IDBRequest', IDBRequest], ['IDBOpenDBRequest', IDBOpenDBRequest], ['IDBVersionChangeEvent', IDBVersionChangeEvent]].forEach(function (_ref3) {
+          var _ref4 = _slicedToArray(_ref3, 2),
+            prop = _ref4[0],
+            obj = _ref4[1];
+          shim(prop, obj, {
+            enumerable: false,
+            configurable: true
+          });
+        });
+        // For Node environments
+        if (CFG.fs) {
+          setFS(CFG.fs);
+        }
+        if (CFG.fullIDLSupport) {
+          // Slow per MDN so off by default! Though apparently needed for WebIDL: https://stackoverflow.com/questions/41927589/rationales-consequences-of-webidl-class-inheritance-requirements
+
+          Object.setPrototypeOf(IDB.IDBOpenDBRequest, IDB.IDBRequest);
+          Object.setPrototypeOf(IDB.IDBCursorWithValue, IDB.IDBCursor);
+          Object.setPrototypeOf(IDBDatabase, EventTarget);
+          Object.setPrototypeOf(IDBRequest, EventTarget);
+          Object.setPrototypeOf(IDBTransaction, EventTarget);
+          Object.setPrototypeOf(IDBVersionChangeEvent, ShimEvent);
+          // `ShimDOMException` is the real native `DOMException` when one
+          //   is available (see `DOMException.js`'s `useNativeDOMException`)
+          //   -- which, unlike the shim classes above, is a single,
+          //   process-wide singleton shared by reference across every
+          //   sandbox this library gets installed into (see
+          //   `node-idb-test.js`'s `sandboxObj`). A native `DOMException`
+          //   already has the correct prototype chain out of the box
+          //   (`Object.getPrototypeOf(DOMException) === Function.prototype`,
+          //   not `Error`), so forcing it here isn't just unneeded but
+          //   actively wrong -- and, because it's shared, permanently
+          //   wrong for every later use of `DOMException` in the same
+          //   process (e.g. a later WPT test file's own idlharness-style
+          //   check that `DOMException` does *not* inherit from `Error`
+          //   on the class side), not just this one shim install.
+          if (typeof DOMException === 'undefined' || ShimDOMException !== DOMException) {
+            Object.setPrototypeOf(ShimDOMException, Error);
+            Object.setPrototypeOf(ShimDOMException.prototype, Error.prototype);
           }
-          if (IDB.indexedDB && !IDB.indexedDB.toString().includes('[native code]')) {
-            if (CFG.addNonIDBGlobals) {
-              // As `DOMStringList` exists per IDL (and Chrome) in the global
-              //   thread (but not in workers), we prefix the name to avoid
-              //   shadowing or conflicts
-              setNonIDBGlobals('Shim');
-            }
-            if (CFG.replaceNonIDBGlobals) {
-              setNonIDBGlobals();
-            }
+        }
+        if (IDB.indexedDB && !IDB.indexedDB.toString().includes('[native code]')) {
+          if (CFG.addNonIDBGlobals) {
+            // As `DOMStringList` exists per IDL (and Chrome) in the global
+            //   thread (but not in workers), we prefix the name to avoid
+            //   shadowing or conflicts
+            setNonIDBGlobals('Shim');
           }
-          /* c8 ignore start -- TS guard */
-          if (!IDB.shimIndexedDB) {
-            return;
+          if (CFG.replaceNonIDBGlobals) {
+            setNonIDBGlobals();
           }
-          /* c8 ignore stop -- TS guard */
-          IDB.shimIndexedDB.__setConnectionQueueOrigin();
         }
+        /* c8 ignore start -- Defensive: `IDB.shimIndexedDB` was already
+           confirmed truthy just before this function (`__useShim`) was
+           defined and immediately invoked (see the `if ('shimIndexedDB'
+           in IDB && IDB.shimIndexedDB)` guard above), and nothing in
+           this function's body reassigns or deletes it. Only reachable
+           if `IDB` is some unusual object (e.g. a Proxy) whose
+           `shimIndexedDB` property value changes between reads. */
+        if (!IDB.shimIndexedDB) {
+          return;
+        }
+        /* c8 ignore stop -- see comment above */
+        IDB.shimIndexedDB.__setConnectionQueueOrigin();
       };
       IDB.shimIndexedDB.__debug = /** @type {(val: boolean) => void} */function (val) {
         CFG.DEBUG = val;