indexeddbshim 19.0.4 → 19.0.6

package/dist/indexeddbshim-UnicodeIdentifiers-node.cjs

@@ -1,4 +1,4 @@
-/*! indexeddbshim - v19.0.4 - 9/17/2026 */
+/*! indexeddbshim - v19.0.6 - 9/22/2026 */
 
 'use strict';
 
@@ -110,6 +110,7 @@ const phases = {
 const 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
 ?
 /**
@@ -127,9 +128,10 @@ function DOMException(msg, name) {
     configurable: true
   });
   return err;
-} : DOMException;
+}
+/* c8 ignore stop */ : DOMException;
 
-/** @type {WeakMap<object, any>} */
+/** @type {WeakMap<object, EventWithProps>} */
 const ev = new WeakMap();
 /** @type {WeakMap<object, EventWithProps>} */
 const evCfg = new WeakMap();
@@ -175,11 +177,12 @@ function definePassthroughProps(instance, props, _evCfg, _ev) {
     obj[prop] = {
       configurable: true,
       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} */{}));
 }
 
 /**
@@ -202,8 +205,9 @@ function getIsTrusted() {
     throw new TypeError('Illegal invocation');
   }
   const _evCfg = getEvCfg(this);
-  const _ev = ev.get(this);
-  return Boolean(Object.hasOwn(_evCfg, 'isTrusted') ? _evCfg.isTrusted : Reflect.has(_ev, 'isTrusted') && _ev.isTrusted);
+  const _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);
 }
 
 /**
@@ -353,15 +357,15 @@ const ShimEvent = Event;
 //   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} */
-const ShimEventProto = ShimEvent.prototype;
+
+const ShimEventProto = /** @type {Record<PropertyKey, unknown>} */ /** @type {unknown} */ShimEvent.prototype;
 
 /** @this {EventWithProps} */
 ShimEventProto.preventDefault = function preventDefault() {
   if (!(this instanceof ShimEvent)) {
     throw new TypeError('Illegal invocation');
   }
-  const _ev = ev.get(this);
+  const _ev = /** @type {EventWithProps} */ /** @type {EventWithProps} */ev.get(this);
   const _evCfg = getEvCfg(this);
   if (this.cancelable && !_evCfg._passive) {
     _evCfg.defaultPrevented = true;
@@ -547,13 +551,12 @@ class CustomEvent extends Event {
   }
 }
 const ShimCustomEvent = CustomEvent;
-/** @type {any} */
-const ShimCustomEventProto = ShimCustomEvent.prototype;
+const 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, bubbles = false, cancelable = false, detail = null) {
@@ -562,6 +565,10 @@ ShimCustomEventProto.initCustomEvent = function initCustomEvent(type, bubbles =
     throw new TypeError('Illegal invocation');
   }
   const _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, {
@@ -569,16 +576,13 @@ ShimCustomEventProto.initCustomEvent = function initCustomEvent(type, bubbles =
     cancelable,
     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';
@@ -998,7 +1002,7 @@ Object.assign(EventTarget.prototype, {
       /** @type {string[]} */
       this._extraProperties.forEach(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`?
         }
       });
     }
@@ -1078,6 +1082,7 @@ Object.assign(EventTarget.prototype, {
           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:
@@ -1380,7 +1385,7 @@ EventTarget.EventTargetFactory = EventTargetFactory;
  *   databaseNameLengthLimit: number|false,
  *   escapeNFDForDatabaseNames: boolean,
  *   addSQLiteExtension: boolean,
- *   memoryDatabase: string,
+ *   memoryDatabase: string|null|undefined,
  *   deleteDatabaseFiles: boolean,
  *   databaseBasePath: string,
  *   sysDatabaseBasePath: string,
@@ -1523,13 +1528,27 @@ const CFG = /** @type {ConfigValues} */{};
 // 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}
  */
 val => {
+  if (val === null || val === undefined) {
+    return;
+  }
   if (!/^(?::memory:|file::memory:(\?[^#]*)?(#.*)?)?$/u.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
@@ -1582,10 +1601,7 @@ function escapeUnmatchedSurrogates(arg) {
   return arg.replaceAll(/([\uD800-\uDBFF])(?![\uDC00-\uDFFF])|(^|[^\uD800-\uDBFF])([\uDC00-\uDFFF])/gu, 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');
   });
 }
 
@@ -2260,7 +2276,8 @@ Object.defineProperty(IDBVersionChangeEvent, Symbol.hasInstance, {
 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)
@@ -2424,8 +2441,10 @@ function createNonNativeDOMExceptionClass() {
        */
       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');
@@ -2484,6 +2503,7 @@ function createNonNativeDOMExceptionClass() {
     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;
 }
@@ -2496,6 +2516,7 @@ const ShimNonNativeDOMException = createNonNativeDOMExceptionClass();
  * @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);
 }
@@ -2518,6 +2539,8 @@ function logError(name, message, error) {
     return;
   }
   const msg = error && typeof error === 'object' && error.message ? error.message : (/** @type {string} */error);
+
+  /* c8 ignore next -- Defensive fallback for an environment lacking `console.error` */
   const method = typeof console.error === 'function' ? 'error' : 'log';
   console[method](name + ': ' + message + '. ' + (msg || ''));
   if (console.trace) {
@@ -2693,8 +2716,10 @@ function IDBRequest() {
  * @this {IDBRequestFull}
  */
 IDBRequest.__super = function IDBRequest() {
+  // 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
@@ -2755,10 +2780,7 @@ IDBRequest.prototype[Symbol.toStringTag] = 'IDBRequestPrototype';
  * @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 */
@@ -2817,8 +2839,10 @@ IDBOpenDBRequest.__createInstance = function () {
   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,
@@ -3781,7 +3805,13 @@ function convertValueToKeyValueDecoded(input, seen, multiEntry, fullKeys) {
                 message: 'Bad array entry value-to-key conversion'
               };
             }
-            if (!multiEntry || !fullKeys && keys.every(k => cmp(/** @type {Key} */k, /** @type {Key} */key.value) !== 0) || fullKeys && keys.every(k => cmp(/** @type {Key} */k, /** @type {Key} */ /** @type {unknown} */key) !== 0)) {
+            if (!multiEntry || !fullKeys && keys.every(k => cmp(/** @type {Key} */k, /** @type {Key} */key.value) !== 0) ||
+            // `keys` holds full `{type, value}` objects here (see
+            //   `safePush` below), so -- like the sibling branch
+            //   above -- `cmp` (which expects raw `Value`s, not
+            //   decoded key objects) must compare their `.value`s,
+            //   not the wrapper objects themselves.
+            fullKeys && keys.every(k => cmp(/** @type {Key} */ /** @type {KeyValueObject} */k.value, /** @type {Key} */key.value) !== 0)) {
               safePush(keys, fullKeys ? key : key.value);
             }
           } catch (err) {
@@ -3799,12 +3829,9 @@ function convertValueToKeyValueDecoded(input, seen, multiEntry, fullKeys) {
       {
         const date = /** @type {Date} */input;
         if (!Number.isNaN(date.getTime())) {
-          return fullKeys ? {
-            type,
-            value: date.getTime()
-          } : {
+          return {
             type,
-            value: new Date(date)
+            value: fullKeys ? date.getTime() : new Date(date)
           };
         }
         return {
@@ -3892,10 +3919,7 @@ function extractKeyValueDecodedFromValueUsingKeyPath(value, keyPath, multiEntry,
   if (r.failure) {
     return r;
   }
-  if (!multiEntry) {
-    return convertValueToKeyValueDecoded(r.value, null, false, fullKeys);
-  }
-  return convertValueToMultiEntryKeyDecoded(r.value, fullKeys);
+  return !multiEntry ? convertValueToKeyValueDecoded(r.value, null, false, fullKeys) : convertValueToMultiEntryKeyDecoded(r.value, fullKeys);
 }
 
 /**
@@ -4067,10 +4091,7 @@ function isKeyInRange(key, range, checkCached) {
  */
 function isMultiEntryMatch(encodedEntry, encodedKey) {
   const keyType = encodedCharToKeyType[encodedKey.slice(0, 1)];
-  if (keyType === 'array') {
-    return encodedKey.indexOf(encodedEntry) > 1;
-  }
-  return encodedKey === encodedEntry;
+  return keyType === 'array' ? encodedKey.indexOf(encodedEntry) > 1 : encodedKey === encodedEntry;
 }
 
 /**
@@ -4181,10 +4202,7 @@ function encode$1(key, inArray) {
  * @returns {undefined|ValueType}
  */
 function decode$1(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);
 }
 
 /**
@@ -4596,10 +4614,11 @@ function setSQLForKeyRange(range, quotedKeyColumnName, sql, sqlValues, addAnd, c
   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));
 }
 
 /**
@@ -4612,10 +4631,7 @@ function convertValueToKeyRange(value, nullDisallowed) {
   if (instanceOf(value, IDBKeyRange)) {
     // We still need to validate IDBKeyRange-like objects (the above check is based on loose duck-typing)
     const 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) {
@@ -4660,9 +4676,11 @@ if (Object.defineProperty) {
     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` */
 }
 
 /**
@@ -4860,6 +4878,7 @@ Object.defineProperty(DOMStringList, '__createInstance', {
       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();
   }
@@ -5157,12 +5176,14 @@ IDBTransaction.prototype.__callTransFinishedCb = function (err, cb) {
  */
 IDBTransaction.prototype.__executeRequests = function () {
   const me = this;
+  /* c8 ignore start -- Dead code: `__executeRequests` has exactly one caller (a single `setTimeout` scheduled once per transaction), so `me.__running` can never already be `true` when this function starts. */
   if (me.__running) {
     if (CFG.DEBUG) {
       console.log('Looks like the request set is already running', me.mode);
     }
     return;
   }
+  /* c8 ignore stop -- see comment above */
 
   // The synchronous script that created this transaction (and
   //   synchronously queued whatever requests it wanted to) has now
@@ -5182,6 +5203,10 @@ IDBTransaction.prototype.__executeRequests = function () {
     let q,
       i = -1;
 
+    // On a standard driver, `keepAliveAndWait` issues a SQL query, which
+    //   is a macrotask. Otherwise it issues ten microtasks.
+    const keepAliveAttempts = isStandardDriver ? 1 : 10;
+
     /**
      * A continuation that must still be able to observe the
      *   transaction as safe to extend (e.g., re-checking whether an
@@ -5208,6 +5233,7 @@ IDBTransaction.prototype.__executeRequests = function () {
         queueMicrotask(cb);
         return;
       }
+      /* c8 ignore start -- Browser-only path: in every automated test environment (Node's websql-configurable/better-sqlite3 driver, and the fake/mock drivers modeled after it) `__usesStandardDriver()` is always `false` (they support the 4-arg `nonstandardTransCb` signature), so `isStandardDriver` is never `true` and this branch is never reached. Only a real standard (3-arg) WebSQL driver, as found in an actual browser, would exercise it. */
       try {
         tx.executeSql('SELECT 1', [], function () {
           cb();
@@ -5217,10 +5243,11 @@ IDBTransaction.prototype.__executeRequests = function () {
         });
       } catch (err) {
         // The driver has already finalized the transaction (or otherwise
-        //   rejected the call) -- nothing left to hold open, so fall back
-        //   to a plain microtask hop for the continuation itself.
-        queueMicrotask(cb);
+        //   rejected the call) -- nothing left to hold open. We explicitly
+        //   abort the transaction here.
+        me.__abortTransaction(/** @type {Error|DOMException} */err);
       }
+      /* c8 ignore stop -- see comment above */
     }
 
     /**
@@ -5233,21 +5260,26 @@ IDBTransaction.prototype.__executeRequests = function () {
      * @returns {void}
      */
     function success(result, req) {
+      /* c8 ignore start -- Defensive: only reached if the transaction was independently errored/finished by a concurrent path (e.g. a driver-level failure or explicit `abort()`) racing with this request's own in-flight SQL success callback; not reliably reproducible without directly manipulating the SQL driver's callback timing. */
       if (me.__errored || me.__requestsFinished) {
         // We've already called "onerror", "onabort", or thrown within the transaction, so don't do it again.
         return;
       }
+      /* c8 ignore stop -- see comment above */
       if (req) {
         q.req = req; // Need to do this in case of cursors
       }
+      /* 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;
@@ -5264,6 +5296,7 @@ IDBTransaction.prototype.__executeRequests = function () {
       //   is what actually resets `__handlerActive`, once it's
       //   confirmed (across its own bounded microtask wait) that no
       //   such continuation queued anything.
+      /* c8 ignore start -- Deliberately not tested: throwing from a request's `onsuccess` handler to exercise this branch would surface as an uncaught error through this test suite's `window.onerror` shim, which (per `retention-spec.js`'s `assertLater` comment) can trigger unbounded recursion here; not safe to trigger directly. */
       if (e.__legacyOutputDidListenersThrowError) {
         logError('Error', 'An error occurred in a success handler attached to request chain', e.__legacyOutputDidListenersThrowError); // We do nothing else with this error as per spec
         if (!me.__committed) {
@@ -5273,6 +5306,7 @@ IDBTransaction.prototype.__executeRequests = function () {
           return;
         }
       }
+      /* c8 ignore stop -- see comment above */
       runContinuationSafely(advanceAfterDispatch);
     }
 
@@ -5284,15 +5318,19 @@ IDBTransaction.prototype.__executeRequests = function () {
      * @returns {void}
      */
     function error(...args /* tx, err */) {
+      /* c8 ignore start -- Defensive: only reached if the transaction was independently errored/finished by a concurrent path racing with this request's own in-flight SQL error callback; not reliably reproducible without directly manipulating the SQL driver's callback timing. */
       if (me.__errored || me.__requestsFinished) {
         // We've already called "onerror", "onabort", or thrown within
         //  the transaction, so don't do it again.
         return;
       }
+      /* c8 ignore stop -- see comment above */
+      /* c8 ignore start -- Defensive: only reached if the SQL driver invoked this request's error callback more than once, or after its success callback already ran; not reliably reproducible without directly manipulating the SQL driver. */
       if (q.req && q.req.__done) {
         // Avoid continuing with aborted requests
         return;
       }
+      /* c8 ignore stop -- see comment above */
       const err = /** @type {Error|DOMException} */findError(args);
       if (!q.req) {
         me.__abortTransaction(err);
@@ -5314,10 +5352,11 @@ IDBTransaction.prototype.__executeRequests = function () {
         }
       });
       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;
@@ -5329,16 +5368,19 @@ IDBTransaction.prototype.__executeRequests = function () {
       q.req.dispatchEvent(e);
       // Do not set __active or __handlerActive flags to false yet --
       //   see the matching comment in `success`, above.
-      if (e.__legacyOutputDidListenersThrowError) {
-        logError('Error', 'An error occurred in an error handler attached to request chain', e.__legacyOutputDidListenersThrowError); // We do nothing else with this error as per spec
-        e.preventDefault(); // Prevent 'error' default as steps indicate we should abort with `AbortError` even without cancellation
-        if (me.__committed) {
-          // An explicit `commit()` locks in the commit, so errors thrown afterward must not abort it
-          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 */
     }
 
     /**
@@ -5362,10 +5404,12 @@ IDBTransaction.prototype.__executeRequests = function () {
         //   (not reset here).
         return true;
       }
+      /* c8 ignore start -- Defensive: reaching this queue entry via the normal advancement path after it was independently marked `__done` (e.g. by `__abortTransaction`'s own separate, async per-request error dispatch) requires a narrow race between that async cleanup and this synchronous advancement; not reliably reproducible without directly manipulating that timing. */
       if (q.req.__done) {
         // Avoid continuing with aborted requests
         return false;
       }
+      /* c8 ignore stop -- see comment above */
       // We're now handing off to (possibly async) work for
       //   this request, so the transaction is no longer active
       //   until its own `success`/`error` dispatch (below)
@@ -5388,18 +5432,22 @@ IDBTransaction.prototype.__executeRequests = function () {
           return;
         }
         q.op(tx, q.args, success, error, executeNextRequest);
+        /* c8 ignore start -- Defensive: `q.op` (the SQL driver callback) is expected to report failures via its own `error`/`failure` callback argument rather than throwing synchronously; not reliably reproducible without directly forcing the driver to throw. */
       } catch (e) {
         error(/** @type {Error} */e);
       }
+      /* c8 ignore stop -- see comment above */
     }
 
     /**
      * @returns {void}
      */
     function runQueuedRequest() {
+      /* c8 ignore start -- Defensive: only reached if `prepareNextRequest` returns `false` (see its own ignore comment above for why that's not reliably reproducible). */
       if (!prepareNextRequest()) {
         return;
       }
+      /* c8 ignore stop -- see comment above */
       launchQueuedOp();
     }
 
@@ -5421,16 +5469,20 @@ IDBTransaction.prototype.__executeRequests = function () {
      *   consumer of that same handler (e.g. one that resolves a
      *   promise from within `onsuccess` and only attaches `oncomplete`
      *   afterward) ever gets a turn to run, so it can miss `complete`
-     *   entirely. `readonly` requests don't hold a real SQL
-     *   transaction open, though, so there's no file-lock/connection
-     *   collision risk in waiting the same bounded amount here.
+     *   afterward) ever gets a turn to run, so it can miss `complete`
+     *   entirely. On a non-standard driver, `readonly` requests don't hold
+     *   a real SQL transaction open, so there's no file-lock/connection
+     *   collision risk. On a standard driver, the wait now issues real SQL
+     *   inside the read transaction, so this does carry a slight risk.
      * @param {number} attemptsLeft
      * @returns {void}
      */
     function checkQueueEntry(attemptsLeft) {
+      /* c8 ignore start -- Defensive: only reached if the transaction is independently errored/finished (e.g. an explicit `abort()`) during this function's keep-alive polling wait; not reliably reproducible without a contrived timing race. */
       if (me.__errored || me.__requestsFinished) {
         return;
       }
+      /* c8 ignore stop -- see comment above */
       if (i < me.__requests.length) {
         runQueuedRequest();
         return;
@@ -5452,13 +5504,15 @@ IDBTransaction.prototype.__executeRequests = function () {
      * @returns {void}
      */
     function executeNextRequest() {
+      /* c8 ignore start -- Defensive: only reached if the transaction was independently errored/finished by a concurrent path racing with this continuation; not reliably reproducible without a contrived timing race. */
       if (me.__errored || me.__requestsFinished) {
         // We've already called "onerror", "onabort", or thrown within the transaction, so don't do it again.
         return;
       }
+      /* c8 ignore stop -- see comment above */
       i++;
       if (i >= me.__requests.length) {
-        checkQueueEntry(10);
+        checkQueueEntry(keepAliveAttempts);
         return;
       }
       runQueuedRequest();
@@ -5490,31 +5544,34 @@ IDBTransaction.prototype.__executeRequests = function () {
      * @returns {void}
      */
     function advanceAfterDispatch() {
+      /* c8 ignore start -- Defensive: only reached if the transaction was independently errored/finished by a concurrent path racing with this continuation; not reliably reproducible without a contrived timing race. */
       if (me.__errored || me.__requestsFinished) {
         return;
       }
+      /* c8 ignore stop -- see comment above */
       i++;
       if (i >= me.__requests.length) {
-        checkQueueEntry(10);
+        checkQueueEntry(keepAliveAttempts);
         return;
       }
       keepAliveAndWait(() => {
-        if (me.__errored || me.__requestsFinished) {
-          return;
-        }
-        if (!prepareNextRequest()) {
+        /* c8 ignore start -- Defensive: only reached if the transaction was independently errored/finished (or the next request's preparation failed) by a concurrent path racing with this continuation; not reliably reproducible without a contrived timing race. */
+        if (me.__errored || me.__requestsFinished || !prepareNextRequest()) {
           return;
         }
+        /* c8 ignore stop -- see comment above */
         launchQueuedOp();
       });
     }
     executeNextRequest();
   }, function webSQLError(webSQLErr) {
+    /* c8 ignore start -- Dead code: the underlying websql-configurable driver's `_onTransactionComplete` always passes either `null` or a genuine `Error`/`DOMException` as this callback's argument, never the literal value `true`, under any driver used by the test suite. */
     // @ts-expect-error It's ok
     if (webSQLErr === true) {
       // Not a genuine SQL error
       return;
     }
+    /* c8 ignore stop -- see comment above */
     const err = webSQLErrback(/** @type {Error & {code?: number}} */webSQLErr);
     me.__abortTransaction(err);
   }, function () {
@@ -5525,18 +5582,25 @@ IDBTransaction.prototype.__executeRequests = function () {
       // 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 --
@@ -5585,6 +5649,7 @@ IDBTransaction.prototype.__executeRequests = function () {
      */
     function complete() {
       me.__completed = true;
+      /* c8 ignore next -- Debug-only log; no test sets `CFG.DEBUG`. */
       if (CFG.DEBUG) {
         console.log('Transaction completed');
       }
@@ -5594,6 +5659,7 @@ IDBTransaction.prototype.__executeRequests = function () {
         me.dispatchEvent(evt);
         me.__internal = false;
         me.dispatchEvent(createEvent('__complete'));
+        /* c8 ignore start -- Deliberately not tested: throwing from an `oncomplete`/`__complete` handler to exercise this branch would surface as an uncaught error through this test suite's `window.onerror` shim, which (per `retention-spec.js`'s `assertLater` comment) can trigger unbounded recursion here; not safe to trigger directly. */
       } catch (e) {
         me.__internal = false;
         // An error occurred in the "oncomplete" handler.
@@ -5601,6 +5667,7 @@ IDBTransaction.prototype.__executeRequests = function () {
         // (this may seem odd/bad, but it's how all native IndexedDB implementations work)
         me.__errored = true;
         throw e;
+        /* c8 ignore stop -- see comment above */
       } finally {
         activeTransactions.delete(me);
         me.__storeHandles = {};
@@ -5608,10 +5675,12 @@ IDBTransaction.prototype.__executeRequests = function () {
       }
     }
     if (me.mode === 'readwrite' || me.mode === 'readonly') {
+      /* c8 ignore start -- Dead code in practice: `__transactionFinished` is only ever set by the driver-queue-idle-races-ahead scenario described above (also `c8 ignore`d there), which is not observed in this test suite. */
       if (me.__transactionFinished) {
         complete();
         return;
       }
+      /* c8 ignore stop -- see comment above */
       me.__transactionEndCallback = complete;
       // The underlying SQL driver's own "queue empty" check
       //   (`nonstandardTransCb`, above) typically already ran and
@@ -5647,6 +5716,7 @@ IDBTransaction.prototype.__executeRequests = function () {
 IDBTransaction.prototype.__createRequest = function (source) {
   const me = this;
   const request = IDBRequest.__createInstance();
+  /* c8 ignore next -- Defensive: every call site (via `__addToTransactionQueue` or directly) always passes an explicit `source`, so the `me.db` fallback is not reachable via the public API. */
   request.__source = source !== undefined ? source : me.db;
   request.__transaction = me;
   return request;
@@ -5716,9 +5786,11 @@ IDBTransaction.prototype.__pushToQueue = function (request, callback, args) {
  * @returns {void}
  */
 IDBTransaction.prototype.__assertActive = function () {
+  /* c8 ignore start -- Defensive: every call site (via `__addToTransactionQueue`/`__addNonRequestToTransactionQueue`) either already performed the static `IDBTransaction.__assertActive(tx)` check synchronously just beforehand, or queues against a transaction just created fresh (necessarily active), so this redundant instance-level check is not reachable via the public API. */
   if (!this.__active || !this.__handlerActive || this.__committed) {
     throw createDOMException('TransactionInactiveError', 'A request was placed against a transaction which is currently not active, or which is finished');
   }
+  /* c8 ignore stop -- see comment above */
 };
 
 /**
@@ -5732,6 +5804,7 @@ IDBTransaction.prototype.__assertWritable = function () {
   }
 };
 
+/* c8 ignore start -- Dead code: this instance method has no callers anywhere in src/ (confirmed via grep); every real call site uses the static `IDBTransaction.__assertVersionChange(tx)` directly instead. */
 /**
  * @this {IDBTransactionFull}
  * @returns {void}
@@ -5739,6 +5812,7 @@ IDBTransaction.prototype.__assertWritable = function () {
 IDBTransaction.prototype.__assertVersionChange = function () {
   IDBTransaction.__assertVersionChange(this);
 };
+/* c8 ignore stop -- see comment above */
 
 /**
  * Returns the specified object store.
@@ -5760,9 +5834,12 @@ IDBTransaction.prototype.objectStore = function (objectStoreName) {
     throw createDOMException('NotFoundError', objectStoreName + ' is not participating in this transaction');
   }
   const store = me.db.__objectStores[objectStoreName];
+  /* c8 ignore start -- Defensive: `me.__objectStoreNames` (checked just above) and `me.db.__objectStores` are always kept in sync by every code path that adds/renames/removes a store, so a name that passes the participation check above should always also be found here; not reliably reproducible via the public API. */
   if (!store) {
     throw createDOMException('NotFoundError', objectStoreName + ' does not exist in ' + me.db.name);
   }
+  /* c8 ignore stop -- see comment above */
+
   if (!Object.hasOwn(me.__storeHandles, objectStoreName) ||
   // These latter conditions are to allow store
   //   recreation to create new clone object
@@ -5781,10 +5858,12 @@ IDBTransaction.prototype.objectStore = function (objectStoreName) {
 IDBTransaction.prototype.__abortTransaction = function (err) {
   const me = this;
   logError('Error', 'An error occurred in a transaction', err);
+  /* c8 ignore start -- Defensive re-entrancy guard: only reached if `__abortTransaction` is invoked a second time on the same transaction after `__errored` is already `true` (e.g. two independent internal error paths racing); not reliably reproducible without a contrived timing race. */
   if (me.__errored) {
     // We've already called "onerror", "onabort", or thrown, so don't do it again.
     return;
   }
+  /* c8 ignore stop -- see comment above */
   me.__errored = true;
   if (me.mode === 'versionchange') {
     // Steps for aborting an upgrade transaction
@@ -5814,19 +5893,16 @@ IDBTransaction.prototype.__abortTransaction = function (err) {
   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(() => {
       throw err;
     }, 0);
   }
+  /* c8 ignore stop -- see comment above */
 
   /**
    * @param {import('websql-configurable/lib/websql/WebSQLTransaction.js').default|null} [tx]
@@ -5835,13 +5911,17 @@ IDBTransaction.prototype.__abortTransaction = function (err) {
    */
   function abort(tx, errOrResult) {
     if (!tx) {
+      /* c8 ignore next -- Debug-only log; only reached via the no-op `abort()` calls below (rare paths), and requires `CFG.DEBUG` to have any effect anyway. */
       if (CFG.DEBUG) {
         console.log('Rollback not possible due to missing transaction', me);
       }
+      /* c8 ignore start -- Defensive: the underlying WebSQL/SQLite driver erroring on the manual `ROLLBACK` executed below (with a result object exposing a numeric `code`) is not reliably reproducible without mocking the SQL layer. */
     } else if (errOrResult && 'code' in errOrResult && typeof errOrResult.code === 'number') {
       if (CFG.DEBUG) {
         console.log('Rollback erred; feature is probably not supported as per WebSQL', me);
       }
+      /* c8 ignore stop -- see comment above */
+      /* c8 ignore next -- Debug-only log; no test sets `CFG.DEBUG`. */
     } else if (CFG.DEBUG) {
       console.log('Rollback succeeded', me);
     }
@@ -5855,10 +5935,11 @@ IDBTransaction.prototype.__abortTransaction = function (err) {
       //  behaves first-in-first-out with the same timeout so we could
       //  just use a `forEach`.
       return promises.then(function () {
+        /* 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).');
@@ -5869,10 +5950,11 @@ IDBTransaction.prototype.__abortTransaction = function (err) {
         return new SyncPromise(/** @type {(resolve: (value?: unknown) => void) => void} */
         resolve => {
           setTimeout(() => {
+            /* 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);
@@ -5892,10 +5974,12 @@ IDBTransaction.prototype.__abortTransaction = function (err) {
         releaseFinishedTransaction(me);
       }, 0);
       return undefined;
+      /* c8 ignore start -- Diagnostic safety net: nothing in the preceding promise chain normally rejects (the only throws it could catch are the dead invariant-violation checks above), so this handler is not reachable in practice. */
     }).catch(err => {
       console.log('Abort error');
       throw err;
     });
+    /* c8 ignore stop -- see comment above */
   }
   me.__transFinishedCb(true, function (rollback) {
     if (rollback && me.__tx) {
@@ -5903,20 +5987,24 @@ IDBTransaction.prototype.__abortTransaction = function (err) {
       //   rollback automatically), but for Node.js, etc., we give chance for
       //   manual aborts which would otherwise not work.
       if (me.mode === 'readwrite') {
+        /* c8 ignore start -- Dead code in practice: `__transactionFinished` is only ever set by the driver-queue-idle-races-ahead scenario described earlier in this file (also `c8 ignore`d there), which is not observed in this test suite. */
         if (me.__transactionFinished) {
           abort();
           return;
         }
+        /* c8 ignore stop -- see comment above */
         me.__transactionEndCallback = abort;
         return;
       }
       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
@@ -5934,6 +6022,7 @@ IDBTransaction.prototype.abort = function () {
   if (!(me instanceof IDBTransaction)) {
     throw new TypeError('Illegal invocation');
   }
+  /* c8 ignore next -- Debug-only log; no test sets `CFG.DEBUG`. */
   if (CFG.DEBUG) {
     console.log('The transaction was aborted', me);
   }
@@ -5965,6 +6054,7 @@ IDBTransaction.prototype.commit = function () {
   if (!me.__active || !me.__handlerActive || me.__committed) {
     throw createDOMException('InvalidStateError', 'Failed to execute \'commit\' on \'IDBTransaction\': The transaction is not active.');
   }
+  /* c8 ignore next -- Debug-only log; no test sets `CFG.DEBUG`. */
   if (CFG.DEBUG) {
     console.log('The transaction was explicitly committed', me);
   }
@@ -6007,6 +6097,7 @@ IDBTransaction.__assertNotFinished = function (tx) {
 };
 
 // object store methods behave differently: see https://github.com/w3c/IndexedDB/issues/192
+/* c8 ignore start -- Dead code: this function has no callers anywhere in src/ (confirmed via grep); object store methods use `IDBTransaction.__assertActive`/`__assertNotFinished` directly instead. */
 /**
  *
  * @param {IDBTransactionFull} tx
@@ -6022,6 +6113,7 @@ IDBTransaction.__assertNotFinishedObjectStoreMethod = function (tx) {
     throw err;
   }
 };
+/* c8 ignore stop -- see comment above */
 
 /**
  *
@@ -6946,7 +7038,7 @@ const w = {
         const t = e.getTime();
         return Number.isNaN(t) ? "NaN" : t;
       },
-      revive: e => "NaN" === e ? new Date(NaN) : new Date(e)
+      revive: e => new Date("NaN" === e ? NaN : e)
     }
   },
   T = {
@@ -7634,9 +7726,12 @@ const pe = ye.concat({
 //   we need to override it so it works with our tests
 
 const specSet = fe.flatMap(preset => Array.isArray(preset) ? preset : [preset]).find(preset => preset && !Array.isArray(preset) && 'filelist' in preset);
-const origFileList = specSet && !Array.isArray(specSet) && 'filelist' in specSet ? specSet.filelist : undefined;
-const origTest = origFileList && typeof origFileList === 'object' && 'test' in origFileList && typeof origFileList.test === 'function' ? origFileList.test : undefined;
-const origRevive = origFileList && typeof origFileList === 'object' && 'revive' in origFileList && typeof origFileList.revive === 'function' ? origFileList.revive : undefined;
+const origFileList = specSet && !Array.isArray(specSet) && 'filelist' in specSet ? specSet.filelist
+/* c8 ignore next -- Defensive fallback if typeson-registry's `filelist` preset entry ever goes missing */ : undefined;
+const origTest = origFileList && typeof origFileList === 'object' && 'test' in origFileList && typeof origFileList.test === 'function' ? origFileList.test
+/* c8 ignore next -- Defensive fallback if typeson-registry's `filelist.test` ever goes missing */ : undefined;
+const origRevive = origFileList && typeof origFileList === 'object' && 'revive' in origFileList && typeof origFileList.revive === 'function' ? origFileList.revive
+/* c8 ignore next -- Defensive fallback if typeson-registry's `filelist.revive` ever goes missing */ : undefined;
 const customFileList = origFileList ? {
   ...origFileList,
   /**
@@ -7645,10 +7740,7 @@ const customFileList = origFileList ? {
    * @returns {boolean}
    */
   test(x, state) {
-    if (typeof FileList !== 'undefined') {
-      return x instanceof FileList;
-    }
-    return typeof origTest === 'function' ? origTest(x, state) : false;
+    return typeof FileList !== 'undefined' ? x instanceof FileList : typeof origTest === 'function' && origTest(x, state);
   },
   /**
    * @param {unknown} x
@@ -7659,10 +7751,13 @@ const customFileList = origFileList ? {
     if (typeof FileList !== 'undefined') {
       return Reflect.construct(FileList, [x]);
     }
+    /* c8 ignore next -- Defensive fallback if typeson-registry's `filelist.revive` ever goes missing */
     return typeof origRevive === 'function' ? origRevive(x, state) : undefined;
   }
-} : undefined;
-let typeson = new Typeson().register([fe, customFileList ? {
+}
+/* c8 ignore next -- Defensive fallback if typeson-registry's `filelist` preset entry ever goes missing */ : undefined;
+let typeson = new Typeson().register([fe, /* c8 ignore next -- Defensive fallback if typeson-registry's `filelist` preset entry ever goes missing */
+customFileList ? {
   filelist: customFileList
 } : {}]);
 
@@ -7818,7 +7913,6 @@ const IDBIndexAlias = IDBIndex;
  *   __unique: boolean,
  *   __objectStore: import('./IDBObjectStore.js').IDBObjectStoreFull,
  *   __keyPath: import('./Key.js').KeyPath,
- *   __recreated?: boolean,
  *   __fetchIndexData: (
  *     range: Query,
  *     opType: "value"|"key"|"count",
@@ -7916,6 +8010,7 @@ IDBIndex.__createInstance = function (store, indexProperties) {
           storeHandle.__indexHandles[newName] = oldIndexHandle; // Ensure new reference accessible
           me.__pendingName = oldName;
           const 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
           [...objectStore.indexNames].filter(indexName => indexName !== newName).map(indexName => [escapeIndexNameForSQL(indexName), 'BLOB']));
           me.__renameIndex(objectStore, oldName, newName, colInfoToPreserveArr, function (tx, success) {
@@ -7963,7 +8058,7 @@ IDBIndex.__clone = function (index, store) {
     }
   });
   /** @type {const} */
-  ['__pendingCreate', '__pendingDelete', '__deleted', '__originalName', '__recreated'].forEach(p => {
+  ['__pendingCreate', '__pendingDelete', '__deleted', '__originalName'].forEach(p => {
     // @ts-expect-error Why is this type "never"?
     idx[p] = index[p];
   });
@@ -7997,11 +8092,12 @@ IDBIndex.__createIndex = function (store, index) {
   } = store;
   /** @type {import('./IDBTransaction.js').IDBTransactionFull} */
   transaction.__addNonRequestToTransactionQueue(function createIndex(tx, args, success, failure) {
-    const columnExists = idx && (idx.__deleted || idx.__recreated); // This check must occur here rather than earlier as properties may not have been set yet otherwise
+    const 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}} */
     let indexValues = {};
 
+    /* c8 ignore start -- Defensive: SQL execution error, not reliably reproducible without mocking the SQL layer. */
     /**
      * @param {WebSQLTransaction} tx
      * @param {(Error & {code?: number})} err
@@ -8010,6 +8106,7 @@ IDBIndex.__createIndex = function (store, index) {
     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
@@ -8059,12 +8156,6 @@ IDBIndex.__createIndex = function (store, index) {
             } 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);
             }
@@ -8073,7 +8164,7 @@ IDBIndex.__createIndex = function (store, index) {
       }, /** @type {SqlErrorCallback} */error);
     }
     const escapedStoreNameSQL = escapeStoreNameForSQL(storeName);
-    const escapedIndexNameSQL = escapeIndexNameForSQL(index.name);
+    const escapedIndexNameSQL = escapeIndexNameForSQL(indexName);
 
     /**
      * @param {WebSQLTransaction} tx
@@ -8127,6 +8218,7 @@ IDBIndex.__deleteIndex = function (store, index) {
   } = store;
   /** @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
@@ -8135,6 +8227,7 @@ IDBIndex.__deleteIndex = function (store, index) {
     function error(tx, err) {
       failure(createDOMException('UnknownError', 'Could not delete index "' + index.name + '"', err));
     }
+    /* c8 ignore stop -- see comment above */
 
     /**
      * @returns {void}
@@ -8143,7 +8236,6 @@ IDBIndex.__deleteIndex = function (store, index) {
       // 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;
@@ -8204,27 +8296,25 @@ IDBIndex.__updateIndexList = function (store, tx, success, failure) {
  * @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) {
   const 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');
   }
   const fetchArgs = buildFetchIndexDataSQL(nullDisallowed, me, range, opType, false);
   return /** @type {import('./IDBTransaction.js').IDBTransactionFull} */me.objectStore.transaction.__addToTransactionQueue(function (...args) {
-    executeFetchIndexData(count, ...fetchArgs,
+    executeFetchIndexData(...fetchArgs,
     // @ts-expect-error It's ok
     ...args);
   }, undefined, me);
@@ -8378,13 +8468,16 @@ IDBIndex.prototype.__renameIndex = function (store, oldName, newName, colInfoToP
   const escapedTmpStoreNameSQL = sqlQuote('tmp_' + escapeStoreNameForSQL(storeName).slice(1, -1));
   const colNamesToPreserve = colInfoToPreserveArr.map(colInfo => colInfo[0]);
   const colInfoToPreserve = colInfoToPreserveArr.map(colInfo => 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. */
   const listColInfoToPreserve = colInfoToPreserve.length ? colInfoToPreserve.join(', ') + ', ' : '';
+  /* c8 ignore next -- Defensive: see comment above. */
   const 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
@@ -8393,6 +8486,7 @@ IDBIndex.prototype.__renameIndex = function (store, oldName, newName, colInfoToP
     function sqlError(tx, err) {
       error(err);
     }
+    /* c8 ignore stop -- see comment above */
     /**
      * @returns {void}
      */
@@ -8401,8 +8495,14 @@ IDBIndex.prototype.__renameIndex = function (store, oldName, newName, colInfoToP
         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
@@ -8426,10 +8526,6 @@ IDBIndex.prototype.__renameIndex = function (store, oldName, newName, colInfoToP
             console.log(sql);
           }
           tx.executeSql(sql, [], function (tx) {
-            if (!CFG.useSQLiteIndexes) {
-              finish();
-              return;
-            }
             const indexCreations = colNamesToPreserve.slice(2) // Doing `key` separately and no need for index on `value`
             .map(escapedIndexNameSQL => new SyncPromise(function (resolve, reject) {
               const escapedIndexToRecreate = sqlQuote(escapedStoreNameSQL.slice(1, -1) + '^5' + escapedIndexNameSQL.slice(1, -1));
@@ -8437,13 +8533,16 @@ IDBIndex.prototype.__renameIndex = function (store, oldName, newName, colInfoToP
               // if (CFG.DEBUG) { console.log(sql); }
               // tx.executeSql(sql, [], function () {
               const 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);
               // });
@@ -8460,19 +8559,25 @@ IDBIndex.prototype.__renameIndex = function (store, oldName, newName, colInfoToP
                 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(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);
@@ -8499,7 +8604,6 @@ Object.defineProperty(IDBIndex, 'prototype', {
 /* eslint-enable unicorn/no-top-level-side-effects -- Would be good */
 
 /**
- * @param {number|null} count
  * @param {boolean} unboundedDisallowed
  * @param {IDBIndexFull} index
  * @param {boolean} hasKey
@@ -8516,12 +8620,9 @@ Object.defineProperty(IDBIndex, 'prototype', {
  * @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');
   }
   const isCount = opType === 'count';
   if (CFG.DEBUG) {
@@ -8583,11 +8684,15 @@ function executeFetchIndexData(count, unboundedDisallowed, index, hasKey, range,
             record = row;
           }
         }
-        if (record) {
-          records.push(decode$2(record));
-          if (unboundedDisallowed) {
-            break;
-          }
+        /* 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) {
+          continue;
+        }
+        /* c8 ignore stop -- see comment above */
+
+        records.push(decode$2(record));
+        if (unboundedDisallowed) {
+          break;
         }
       }
     } else {
@@ -8602,8 +8707,16 @@ function executeFetchIndexData(count, unboundedDisallowed, index, hasKey, range,
     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);
@@ -8849,6 +8962,7 @@ IDBObjectStore.__createInstance = function (storeProperties, transaction) {
             tx.executeSql(sql, sqlValues, function (tx) {
               // This SQL preserves indexes per https://www.sqlite.org/lang_altertable.html
               const 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);
               }
@@ -8857,8 +8971,10 @@ IDBObjectStore.__createInstance = function (storeProperties, transaction) {
                 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 */
             });
           });
         }
@@ -8932,6 +9048,7 @@ IDBObjectStore.__createObjectStore = function (db, store) {
     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]
@@ -8944,6 +9061,8 @@ IDBObjectStore.__createObjectStore = function (db, store) {
       failure(createDOMException('UnknownError', 'Could not create object store "' + storeName + '"', err));
       return false;
     }
+    /* c8 ignore stop -- see comment above */
+
     const escapedStoreNameSQL = escapeStoreNameForSQL(storeName);
     // key INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL UNIQUE
     const sql = ['CREATE TABLE', escapedStoreNameSQL, '(key BLOB', store.autoIncrement ? 'UNIQUE, inc INTEGER PRIMARY KEY AUTOINCREMENT' : 'PRIMARY KEY', ', value BLOB)'].join(' ');
@@ -8998,6 +9117,7 @@ IDBObjectStore.__deleteObjectStore = function (db, store) {
 
   // 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]
@@ -9010,6 +9130,8 @@ IDBObjectStore.__deleteObjectStore = function (db, store) {
       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 () {
@@ -9189,13 +9311,15 @@ IDBObjectStore.prototype.__checkIndexConstraints = function (tx, value, excludeK
         return;
       }
       const 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 */
       const multiCheck = index.multiEntry && Array.isArray(indexKeyValue);
       const fetchArgs = buildFetchIndexDataSQL(true, index, indexKeyValue, 'key', multiCheck);
-      executeFetchIndexData(null, ...fetchArgs, tx, null, function success(key) {
+      executeFetchIndexData(...fetchArgs, tx, null, function success(key) {
         if (key === undefined || excludeKey !== undefined && cmp(/** @type {import('./Key.js').Key} */key, excludeKey) === 0) {
           resolve(undefined);
           return;
@@ -9275,16 +9399,18 @@ IDBObjectStore.prototype.__insertData = function (tx, encoded, value, clonedKeyO
        * @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$1(indexKeyValue, index.multiEntry);
       }
       if (index.unique) {
         const multiCheck = index.multiEntry && Array.isArray(indexKeyValue);
         const fetchArgs = buildFetchIndexDataSQL(true, index, indexKeyValue, 'key', multiCheck);
-        executeFetchIndexData(null, ...fetchArgs, tx, null, function success(key) {
+        executeFetchIndexData(...fetchArgs, tx, null, function success(key) {
           if (key === undefined) {
             setIndexInfo(index);
             resolve(undefined);
@@ -9369,6 +9495,7 @@ IDBObjectStore.prototype.add = function (value /* , key */) {
   me.transaction.__assertWritable();
   const request = /** @type {import('./IDBTransaction.js').IDBTransactionFull} */me.transaction.__createRequest(me);
   const [ky, clonedValue] = me.__validateKeyAndValueAndCloneValue(value, key, false);
+  // 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;
@@ -9397,6 +9524,7 @@ IDBObjectStore.prototype.put = function (value /* , key */) {
   me.transaction.__assertWritable();
   const request = /** @type {import('./IDBTransaction.js').IDBTransactionFull} */me.transaction.__createRequest(me);
   const [ky, clonedValue] = me.__validateKeyAndValueAndCloneValue(value, key, false);
+  // 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;
@@ -9423,8 +9551,10 @@ IDBObjectStore.prototype.__overwrite = function (tx, key, cb, error) {
     }
     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 */
   });
 };
 
@@ -9533,16 +9663,20 @@ IDBObjectStore.prototype.__get = function (query, getKey) {
           return;
         }
         ret = getKey ? decode$1(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);
 };
@@ -9657,8 +9791,10 @@ IDBObjectStore.prototype.delete = function (query) {
       });
       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);
 };
@@ -9686,8 +9822,10 @@ IDBObjectStore.prototype.clear = function () {
       });
       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);
 };
@@ -10017,7 +10155,7 @@ IDBDatabase.prototype.createObjectStore = function (storeName /* , createOptions
   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);
   }
   const autoInc = createOptions.autoIncrement;
@@ -10165,7 +10303,6 @@ IDBDatabase.prototype.throwIfUpgradeTransactionNull = function () {
   }
 };
 
-// Todo __forceClose: Add tests for `__forceClose`
 /**
  *
  * @param {string} msg
@@ -10174,23 +10311,39 @@ IDBDatabase.prototype.throwIfUpgradeTransactionNull = function () {
  */
 IDBDatabase.prototype.__forceClose = function (msg) {
   const 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.
+  const transactions = me.__transactions;
   me.close();
+
+  /**
+   * @returns {void}
+   */
+  function dispatchClose() {
+    // Todo __forceClose: unblock any pending `upgradeneeded` or `deleteDatabase` calls
+    const evt = createEvent('close');
+    setTimeout(() => {
+      me.dispatchEvent(evt);
+    }, 0);
+  }
+  if (!transactions.length) {
+    dispatchClose();
+    return;
+  }
   let 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
-        const evt = createEvent('close');
-        setTimeout(() => {
-          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);
@@ -10351,6 +10504,7 @@ function triggerAnyVersionChangeAndBlockedEvents(openConnections, req, oldVersio
         return undefined;
       }
       const 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,
@@ -10398,6 +10552,7 @@ function triggerAnyVersionChangeAndBlockedEvents(openConnections, req, oldVersio
         }
       };
       const 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,
@@ -10458,6 +10613,13 @@ const pendingVersionChanges = new Map();
 
 /** @type {import('websql-configurable/lib/websql/WebSQLDatabase.js').default} */
 let 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} */
+let sysdbMemoryDatabaseSetting;
 let nameCounter = 0;
 
 /**
@@ -10539,12 +10701,20 @@ function closeCachedWebSQLConnections(name, cb) {
 function cleanupDatabaseResources(__openDatabase, name, escapedDatabaseName, databaseDeleted, dbError) {
   const 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. */
     const 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 */
     const sqliteDB = latestSQLiteDBCached._db;
     if (!sqliteDB || !sqliteDB.close) {
       console.error('The `openDatabase` implementation does not have the expected `._db.close` method for closing the database');
@@ -10598,15 +10768,24 @@ function cleanupDatabaseResources(__openDatabase, name, escapedDatabaseName, dat
           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 */
     });
   });
 }
@@ -10637,9 +10816,11 @@ function createSysDB(__openDatabase, success, failure) {
     }
     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) {
@@ -10819,6 +11000,17 @@ IDBFactory.prototype.open = function (name /* , version */) {
            * @returns {void}
            */
           let sysdbFinishedCb = function (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]
@@ -10867,6 +11059,7 @@ IDBFactory.prototype.open = function (name /* , version */) {
             }
             // 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) {
             /**
@@ -10874,6 +11067,7 @@ IDBFactory.prototype.open = function (name /* , version */) {
              */
             function versionSet() {
               const 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,
@@ -10999,9 +11193,17 @@ IDBFactory.prototype.open = function (name /* , version */) {
               // eslint-disable-next-line camelcase -- Clear API
               req.transaction.on__complete = function () {
                 const 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;
                   const err = createDOMException('AbortError', 'The connection has been closed.');
@@ -11037,9 +11239,16 @@ IDBFactory.prototype.open = function (name /* , version */) {
               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 (systx, err, cb) {
               if (err) {
                 rollback(err,
@@ -11054,7 +11263,17 @@ IDBFactory.prototype.open = function (name /* , version */) {
                     } 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 () {
@@ -11070,8 +11289,20 @@ IDBFactory.prototype.open = function (name /* , version */) {
           });
           return undefined;
         }).catch(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();
@@ -11099,11 +11330,19 @@ IDBFactory.prototype.open = function (name /* , version */) {
     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;
       }
     }
@@ -11254,6 +11493,7 @@ IDBFactory.prototype.deleteDatabase = function (name) {
         req.__result = undefined;
         req.__done = true;
         const 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,
@@ -11297,9 +11537,23 @@ IDBFactory.prototype.deleteDatabase = function (name) {
                 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 (err, cb) {
                 if (err) {
                   rollback(err, cb);
@@ -11426,10 +11680,9 @@ IDBFactory.prototype.databases = function () {
 };
 
 /**
- * @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
@@ -11529,6 +11782,7 @@ IDBRecord.__createInstance = function (key, primaryKey, value) {
    * @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;
@@ -11569,6 +11823,7 @@ readonlyProperties.forEach(prop => {
       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];
     }
@@ -11912,6 +12167,7 @@ IDBCursor.prototype.__findBasic = function (key, primaryKey, tx, success, error,
       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);
     }
@@ -12087,7 +12343,16 @@ IDBCursor.prototype.__findMultiEntry = function (key, primaryKey, tx, success, e
         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 = {
@@ -12106,13 +12371,19 @@ IDBCursor.prototype.__findMultiEntry = function (key, primaryKey, tx, success, e
         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();
 };
@@ -12221,6 +12492,7 @@ IDBCursor.prototype.__sourceOrEffectiveObjStoreDeleted = function () {
  * @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;
@@ -12245,7 +12517,7 @@ IDBCursor.prototype.__continue = function (key, advanceContinue) {
     convertValueToKeyRethrowingAndIfInvalid(key);
     const 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);
@@ -12494,6 +12766,7 @@ IDBCursor.prototype.update = function (valueToUpdate) {
     //   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);
   }
@@ -12540,14 +12813,33 @@ IDBCursor.prototype.delete = function () {
           // 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);
 };
@@ -12953,7 +13245,7 @@ function setGlobalVars(idb, initialConfig) {
     setConfig(initialConfig);
   }
   const IDB = /** @type {ShimmedObject & {[key: string]: unknown}} */
-  /** @type {unknown} */idb || globalThis || {};
+  /** @type {unknown} */idb || globalThis;
   /**
    * @param {string} name
    * @param {unknown} value
@@ -13048,77 +13340,84 @@ function setGlobalVars(idb, initialConfig) {
         });
       }
       const 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() {
-            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() {
+          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(([prop, obj]) => {
-          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(([prop, obj]) => {
+        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;
@@ -13226,6 +13525,7 @@ function setGlobalVars(idb, initialConfig) {
  * @returns {SQLiteDatabaseInstance}
  */
 function wrappedSQLiteDatabase(name) {
+  // eslint-disable-next-line jsdoc/ts-ban-ts-comment -- TS 6/7
   // @ts-ignore It's ok; needed under some TS versions
   const db = new SQLiteDatabase(name, {});
   if (CFG.sqlBusyTimeout) {