@monochromatic-dev/module-logger 0.2.0 → 0.4.0

package/src/sink/indexed-db.ts

@@ -11,47 +11,47 @@ import type {
 } from '../types.ts';
 
 /**
- * Database holding this logger's batches, one per origin, shared by every tab.
+ Database holding this logger's batches, one per origin, shared by every tab.
  */
 const DATABASE_NAME = 'monochromatic.log';
 
 /**
- * Schema version; bump only with an upgrade path in `onupgradeneeded`.
+ Schema version; bump only with an upgrade path in `onupgradeneeded`.
  */
 const DATABASE_VERSION = 1;
 
 /**
- * Object store holding one newline-joined JSONL batch string per
- * auto-incremented key, so key order is arrival order across every tab and
- * retention can trim oldest-first without any run bookkeeping.
+ Object store holding one newline-joined JSONL batch string per
+ auto-incremented key, so key order is arrival order across every tab and
+ retention can trim oldest-first without any run bookkeeping.
  */
 const BATCH_STORE = 'batch';
 
 /**
- * Retention cap on stored batches, trimmed oldest-first inside each persist
- * transaction. At the buffer's 32 KiB flush cap this bounds the store near
- * 64 MiB, well under the multi-gigabyte origin quota
- * (`navigator.storage.estimate()` reported 10 GiB on the measuring machine)
- * while months of sessions still fit. A count cap instead of a byte tally
- * because severity-flushed batches vary in size and an exact byte budget
- * would need a cross-session tally re-summed at startup; the bound is
- * approximate by design.
+ Retention cap on stored batches, trimmed oldest-first inside each persist
+ transaction. At the buffer's 32 KiB flush cap this bounds the store near
+ 64 MiB, well under the multi-gigabyte origin quota
+ (`navigator.storage.estimate()` reported 10 GiB on the measuring machine)
+ while months of sessions still fit. A count cap instead of a byte tally
+ because severity-flushed batches vary in size and an exact byte budget
+ would need a cross-session tally re-summed at startup; the bound is
+ approximate by design.
  */
 const MAX_STORED_BATCHES = 2_048;
 
 /**
- * Opens (creating on first use) the logger's IndexedDB database with the
- * batch store ready.
- *
- * @returns Open database connection.
- *
- * @throws DOMException - When the backend refuses to open, for example in a
- * storage-partitioned context that denies IndexedDB.
+ Opens (creating on first use) the logger's IndexedDB database with the
+ batch store ready.
+ 
+ @returns Open database connection.
+ 
+ @throws DOMException - When the backend refuses to open, for example in a
+ storage-partitioned context that denies IndexedDB.
  */
 async function openLogDatabase(): Promise<IDBDatabase> {
   /**
-   * Open request; the upgrade handler runs only when the database is new or
-   * below {@link DATABASE_VERSION}.
+   Open request; the upgrade handler runs only when the database is new or
+   below {@link DATABASE_VERSION}.
    */
   const request = globalThis.indexedDB
     .open(
@@ -69,20 +69,20 @@ async function openLogDatabase(): Promise<IDBDatabase> {
 }
 
 /**
- * Persists one batch and trims the store back under the retention cap, all
- * inside one readwrite transaction so a crash between the steps cannot leave
- * the trim half-applied.
- *
- * @param database - Open connection from {@link openLogDatabase}.
- *
- * @param batch - Newline-joined JSONL batch string to persist.
- *
- * @throws DOMException - When the transaction errors or aborts, for example
- * under an origin-quota overflow.
- *
- * @mutates database - `database.transaction` opens a readwrite transaction,
- * registering live state on the host-owned connection, and the queued add
- * and trim change the store that connection controls.
+ Persists one batch and trims the store back under the retention cap, all
+ inside one readwrite transaction so a crash between the steps cannot leave
+ the trim half-applied.
+ 
+ @param database - Open connection from {@link openLogDatabase}.
+ 
+ @param batch - Newline-joined JSONL batch string to persist.
+ 
+ @throws DOMException - When the transaction errors or aborts, for example
+ under an origin-quota overflow.
+ 
+ @mutates database - `database.transaction` opens a readwrite transaction,
+ registering live state on the host-owned connection, and the queued add
+ and trim change the store that connection controls.
  */
 async function persistBatch(
   {
@@ -94,32 +94,32 @@ async function persistBatch(
   },
 ): Promise<void> {
   /**
-   * Single transaction carrying the add, the count, and any trim.
+   Single transaction carrying the add, the count, and any trim.
    */
   const transaction = database.transaction(
     BATCH_STORE,
     'readwrite',
   );
   /**
-   * Batch store within this transaction.
+   Batch store within this transaction.
    */
   const store = transaction.objectStore(BATCH_STORE,);
   store.add(batch,);
   /**
-   * Stored batch count including the add queued in this transaction.
+   Stored batch count including the add queued in this transaction.
    */
   const count = await awaitRequest(store.count(),);
   if (count > MAX_STORED_BATCHES) {
     /**
-     * Oldest keys past the cap; `getAllKeys` returns keys in ascending order,
-     * which for an auto-incremented store is arrival order.
+     Oldest keys past the cap; `getAllKeys` returns keys in ascending order,
+     which for an auto-incremented store is arrival order.
      */
     const staleKeys = await awaitRequest(store.getAllKeys(
       null,
       count - MAX_STORED_BATCHES,
     ),);
     /**
-     * Newest key still to be trimmed; everything at or below it goes.
+     Newest key still to be trimmed; everything at or below it goes.
      */
     const newestStale = staleKeys.at(-1,);
     if (newestStale !== undefined)
@@ -129,85 +129,85 @@ async function persistBatch(
 }
 
 /**
- * Builds an IndexedDB sink that buffers serialized records through the shared
- * {@link createRecordBuffer} policy and persists each newline-joined JSONL
- * batch as one string value per transaction, measured at 0.15 µs of
- * main-thread enqueue per record on headless Chromium 149 (one `add` per
- * 32 KiB batch). The connection lives in this instance's closure (no
- * module-global state), so independent loggers and tests never share a
- * handle or need a reset hook.
- *
- * Records are readable the moment their transaction settles (DevTools
- * Application tab included), survive tab close and browser restart, and
- * auto-incremented keys serialize across tabs, so no run-scoped naming is
- * needed. Retention trims oldest-first past {@link MAX_STORED_BATCHES}.
- * Transactions use the default relaxed durability: relaxed commits reach the
- * browser's storage backend promptly and survive renderer crashes, and the
- * OS-crash window `durability: 'strict'` would close is the rarest failure
- * class, not worth an fsync per batch.
- *
- * Flush triggers (32 KiB in-write cap, `warn`-or-worse severity, 250 ms
- * quiet-period deadline, page lifecycle, and the `flush` hook) are the
- * buffer's; see {@link createRecordBuffer}. The sink's `flush` hook awaits
- * every issued batch transaction before resolving.
- *
- * @returns Sink backed by IndexedDB.
- *
- * @example
- * ```ts
- * const { logger } = createLogger({ sinks: [createIndexedDbSink()] });
- * logger.warn('quota nearing limit');
- * ```
+ Builds an IndexedDB sink that buffers serialized records through the shared
+ {@link createRecordBuffer} policy and persists each newline-joined JSONL
+ batch as one string value per transaction, measured at 0.15 µs of
+ main-thread enqueue per record on headless Chromium 149 (one `add` per
+ 32 KiB batch). The connection lives in this instance's closure (no
+ module-global state), so independent loggers and tests never share a
+ handle or need a reset hook.
+ 
+ Records are readable the moment their transaction settles (DevTools
+ Application tab included), survive tab close and browser restart, and
+ auto-incremented keys serialize across tabs, so no run-scoped naming is
+ needed. Retention trims oldest-first past {@link MAX_STORED_BATCHES}.
+ Transactions use the default relaxed durability: relaxed commits reach the
+ browser's storage backend promptly and survive renderer crashes, and the
+ OS-crash window `durability: 'strict'` would close is the rarest failure
+ class, not worth an fsync per batch.
+ 
+ Flush triggers (32 KiB in-write cap, `warn`-or-worse severity, 250 ms
+ quiet-period deadline, page lifecycle, and the `flush` hook) are the
+ buffer's; see {@link createRecordBuffer}. The sink's `flush` hook awaits
+ every issued batch transaction before resolving.
+ 
+ @returns Sink backed by IndexedDB.
+ 
+ @example
+ ```ts
+ const { logger } = createLogger({ sinks: [createIndexedDbSink()] });
+ logger.warn('quota nearing limit');
+ ```
  */
 export function createIndexedDbSink(): Sink {
   /**
-   * Instance-local open connection, set by `verify` and reused by every batch
-   * write. Absent until a successful verification.
+   Instance-local open connection, set by `verify` and reused by every batch
+   write. Absent until a successful verification.
    */
   const state: { database?: IDBDatabase; } = {};
 
   /**
-   * Batch transactions issued and not yet settled; the `flush` hook drains
-   * this so logger-level `flush()` observes every issued batch.
+   Batch transactions issued and not yet settled; the `flush` hook drains
+   this so logger-level `flush()` observes every issued batch.
    */
   const pendingBatchWrites = new Set<Promise<void>>();
 
   /**
-   * Verifies IndexedDB is available and round-trips a probe value, keeping
-   * the opened connection for subsequent writes. The logger calls this once
-   * and owns the resulting availability.
-   *
-   * @returns Whether IndexedDB logging is available.
+   Verifies IndexedDB is available and round-trips a probe value, keeping
+   the opened connection for subsequent writes. The logger calls this once
+   and owns the resulting availability.
+   
+   @returns Whether IndexedDB logging is available.
    */
   async function verify(): Promise<boolean> {
     try {
       if ((typeof globalThis.indexedDB) === 'undefined')
         return false;
       /**
-       * Connection kept for the sink's lifetime once the probe passes.
+       Connection kept for the sink's lifetime once the probe passes.
        */
       const database = await openLogDatabase();
       /**
-       * Probe transaction: add, read back, and remove one sentinel value.
+       Probe transaction: add, read back, and remove one sentinel value.
        */
       const transaction = database.transaction(
         BATCH_STORE,
         'readwrite',
       );
       /**
-       * Batch store within the probe transaction.
+       Batch store within the probe transaction.
        */
       const store = transaction.objectStore(BATCH_STORE,);
       /**
-       * Timestamp-based probe value so concurrent verifications never read each other's writes.
+       Timestamp-based probe value so concurrent verifications never read each other's writes.
        */
       const probeValue = `probe-${Date.now()}`;
       /**
-       * Key the store assigned to the probe, used to read it back and remove it.
+       Key the store assigned to the probe, used to read it back and remove it.
        */
       const probeKey = await awaitRequest(store.add(probeValue,),);
       /**
-       * Probe value read back; equality proves the backend round-trips writes.
+       Probe value read back; equality proves the backend round-trips writes.
        */
       const readBack = await awaitRequest(store.get(probeKey,) as IDBRequest<unknown>,);
       store.delete(probeKey,);
@@ -229,10 +229,10 @@ export function createIndexedDbSink(): Sink {
   }
 
   /**
-   * Writes one batch through {@link persistBatch}, swallowing and reporting
-   * failures so the pending-write set always settles.
-   *
-   * @param batch - Newline-joined JSONL batch from the buffer.
+   Writes one batch through {@link persistBatch}, swallowing and reporting
+   failures so the pending-write set always settles.
+   
+   @param batch - Newline-joined JSONL batch from the buffer.
    */
   async function writeBatch(batch: string,): Promise<void> {
     if (!state.database)
@@ -253,10 +253,10 @@ export function createIndexedDbSink(): Sink {
   }
 
   /**
-   * Removes a tracked batch write from {@link pendingBatchWrites} once it
-   * settles.
-   *
-   * @param pending - Promise returned by {@link writeBatch}.
+   Removes a tracked batch write from {@link pendingBatchWrites} once it
+   settles.
+   
+   @param pending - Promise returned by {@link writeBatch}.
    */
   async function removePendingWhenSettled(pending: Promise<void>,): Promise<void> {
     await pending;
@@ -264,14 +264,14 @@ export function createIndexedDbSink(): Sink {
   }
 
   /**
-   * Backend handoff for the buffer: issues the batch transaction without
-   * awaiting and tracks it for the `flush` hook.
-   *
-   * @param batch - Newline-joined JSONL batch from the buffer.
+   Backend handoff for the buffer: issues the batch transaction without
+   awaiting and tracks it for the `flush` hook.
+   
+   @param batch - Newline-joined JSONL batch from the buffer.
    */
   function handOffBatch(batch: string,): void {
     /**
-     * In-flight batch write; never rejects, because {@link writeBatch} reports internally.
+     In-flight batch write; never rejects, because {@link writeBatch} reports internally.
      */
     const pending = writeBatch(batch,);
     pendingBatchWrites.add(pending,);
@@ -279,17 +279,17 @@ export function createIndexedDbSink(): Sink {
   }
 
   /**
-   * Shared buffering stage; every flush trigger issues one batch transaction.
+   Shared buffering stage; every flush trigger issues one batch transaction.
    */
   const buffer = createRecordBuffer({ onFlush: handOffBatch, },);
 
   /**
-   * Buffers a log record through the shared policy; see
-   * {@link createRecordBuffer} for the flush triggers.
-   *
-   * @param record - Log record to buffer and eventually persist.
-   *
-   * @mutates record - `JSON.stringify` may invoke `toJSON`, getters, or proxy traps.
+   Buffers a log record through the shared policy; see
+   {@link createRecordBuffer} for the flush triggers.
+   
+   @param record - Log record to buffer and eventually persist.
+   
+   @mutates record - `JSON.stringify` may invoke `toJSON`, getters, or proxy traps.
    */
   function write(record: {
     level: Level;
@@ -304,13 +304,13 @@ export function createIndexedDbSink(): Sink {
   }
 
   /**
-   * Drains the buffer into the store and resolves once every issued batch
-   * transaction has settled.
+   Drains the buffer into the store and resolves once every issued batch
+   transaction has settled.
    */
   async function flush(): Promise<void> {
     buffer.drain();
     /**
-     * Snapshot of in-flight batch writes at drain time.
+     Snapshot of in-flight batch writes at drain time.
      */
     const writes = [...pendingBatchWrites,];
     await Promise.all(writes,);

package/src/sink/indexed-db.unit.test.ts

@@ -3,16 +3,7 @@ import {
   expect,
   it,
 } from '@monochromatic-dev/module-test/ts';
-import {
-  sinks,
-} from '@monochromatic-dev/module-logger';
-
-/**
- * Sink factories under test, read from the built artifact's `sinks` namespace.
- */
-const {
-  createIndexedDbSink,
-} = sinks;
+import { createIndexedDbSink, } from '@monochromatic-dev/module-logger/browser';
 
 // Node, Deno, and Bun expose no `indexedDB` (probed on Node 26, Deno 2.9,
 // Bun 1.3), so this file exercises the unavailable-backend fallback that the
@@ -20,7 +11,8 @@ const {
 // short-circuits on the missing global, and drained batches hit the
 // unset-connection guard. The available path lives in
 // `indexed-db.browser.test.ts`; the shared buffering policy is covered in
-// `record-buffer.unit.test.ts`.
+// `record-buffer.unit.test.ts`. The factory is reached through the
+// `./browser` subpath because the root entry no longer exports it.
 await describe({
   name: 'IndexedDB sink (node fallback)',
   children: [
@@ -40,7 +32,7 @@ await describe({
         // flush trigger fires.
         const sink = createIndexedDbSink();
         /**
-         * Resolved write result; the sink write contract is `Promise<void>`.
+         Resolved write result; the sink write contract is `Promise<void>`.
          */
         const result = await sink.write({
           level: 'info',
@@ -69,7 +61,7 @@ await describe({
           timestamp: 1,
         },);
         /**
-         * Resolved flush result; must settle even with no connection to write to.
+         Resolved flush result; must settle even with no connection to write to.
          */
         const result = await sink.flush?.();
         expect(result,)

package/src/sink/local-storage-key.ts

@@ -1,30 +1,30 @@
 /**
- * Key naming for the localStorage persistence engine.
- *
- * localStorage is shared by every tab of the origin and survives restarts, so
- * unlike the per-tab sessionStorage keys (`monochromatic.log.{n}`), these keys
- * carry a run identity: `monochromatic.log.{stamp}.{nonce}.{index}`. The stamp
- * orders runs oldest-first for cross-run eviction, the nonce keeps two tabs
- * started in the same millisecond from colliding, and the index orders batches
- * within a run.
- *
- * @module
+ Key naming for the localStorage persistence engine.
+ 
+ localStorage is shared by every tab of the origin and survives restarts, so
+ unlike the per-tab sessionStorage keys (`monochromatic.log.{n}`), these keys
+ carry a run identity: `monochromatic.log.{stamp}.{nonce}.{index}`. The stamp
+ orders runs oldest-first for cross-run eviction, the nonce keeps two tabs
+ started in the same millisecond from colliding, and the index orders batches
+ within a run.
+ 
+ @module
  */
 
 /**
- * Prefix namespacing this logger's localStorage entries away from host
- * application keys.
+ Prefix namespacing this logger's localStorage entries away from host
+ application keys.
  */
 export const LOCAL_STORAGE_KEY_PREFIX = 'monochromatic.log';
 
 /**
- * Identity segments after the prefix: stamp, nonce, and index.
+ Identity segments after the prefix: stamp, nonce, and index.
  */
 const RUN_KEY_SEGMENTS = 3;
 
 /**
- * Parsed identity of one owned localStorage entry, used to order eviction
- * across runs.
+ Parsed identity of one owned localStorage entry, used to order eviction
+ across runs.
  */
 export type ParsedLogKey = {
   readonly key: string;
@@ -34,13 +34,13 @@ export type ParsedLogKey = {
 };
 
 /**
- * Reports whether `text` is one or more ASCII digits, so key parsing accepts
- * only counter-shaped segments and never claims a host application's key. A
- * linear scan instead of a regex: the rule is a plain character-range check.
- *
- * @param text - Candidate key segment.
- *
- * @returns Whether every character is an ASCII digit and one exists.
+ Reports whether `text` is one or more ASCII digits, so key parsing accepts
+ only counter-shaped segments and never claims a host application's key. A
+ linear scan instead of a regex: the rule is a plain character-range check.
+ 
+ @param text - Candidate key segment.
+ 
+ @returns Whether every character is an ASCII digit and one exists.
  */
 function isDigits(text: string,): boolean {
   if (text.length === 0)
@@ -53,20 +53,20 @@ function isDigits(text: string,): boolean {
 }
 
 /**
- * Builds the namespaced localStorage key for one batch slot of one run.
- *
- * @param stamp - Run creation time ordering runs oldest-first.
- *
- * @param nonce - Same-millisecond disambiguator between concurrent tabs.
- *
- * @param index - Zero-based batch slot within the run.
- *
- * @returns Key such as `monochromatic.log.1753000000000.a1b2.3`.
- *
- * @example
- * ```ts
- * buildLogKey({ stamp: 1753000000000, nonce: 'a1b2', index: 3 });
- * ```
+ Builds the namespaced localStorage key for one batch slot of one run.
+ 
+ @param stamp - Run creation time ordering runs oldest-first.
+ 
+ @param nonce - Same-millisecond disambiguator between concurrent tabs.
+ 
+ @param index - Zero-based batch slot within the run.
+ 
+ @returns Key such as `monochromatic.log.1753000000000.a1b2.3`.
+ 
+ @example
+ ```ts
+ buildLogKey({ stamp: 1753000000000, nonce: 'a1b2', index: 3 });
+ ```
  */
 export function buildLogKey(
   {
@@ -83,40 +83,40 @@ export function buildLogKey(
 }
 
 /**
- * Parses a localStorage key back into its run identity, or reports it foreign
- * by leaving `parsed` absent. Parsing is strict (exact prefix, exactly the
- * identity segment count, digit-shaped stamp and index, non-empty nonce)
- * because eviction trusts this to never classify a host application's key, or
- * the sessionStorage sink's flat `monochromatic.log.{n}` shape, as evictable.
- *
- * @param key - Candidate localStorage key.
- *
- * @returns Wrapper whose `parsed` property is present only for an owned key.
- *
- * @example
- * ```ts
- * parseLogKey('monochromatic.log.1753000000000.a1b2.3').parsed; // ParsedLogKey
- * parseLogKey('monochromatic.log.5').parsed; // undefined: sessionStorage shape
- * ```
+ Parses a localStorage key back into its run identity, or reports it foreign
+ by leaving `parsed` absent. Parsing is strict (exact prefix, exactly the
+ identity segment count, digit-shaped stamp and index, non-empty nonce)
+ because eviction trusts this to never classify a host application's key, or
+ the sessionStorage sink's flat `monochromatic.log.{n}` shape, as evictable.
+ 
+ @param key - Candidate localStorage key.
+ 
+ @returns Wrapper whose `parsed` property is present only for an owned key.
+ 
+ @example
+ ```ts
+ parseLogKey('monochromatic.log.1753000000000.a1b2.3').parsed; // ParsedLogKey
+ parseLogKey('monochromatic.log.5').parsed; // undefined: sessionStorage shape
+ ```
  */
 export function parseLogKey(key: string,): { readonly parsed?: ParsedLogKey; } {
   if (!key.startsWith(`${LOCAL_STORAGE_KEY_PREFIX}.`,))
     return {};
   /**
-   * Key remainder past the prefix and its trailing dot, holding the run
-   * identity segments.
+   Key remainder past the prefix and its trailing dot, holding the run
+   identity segments.
    */
   const rest = key.slice(LOCAL_STORAGE_KEY_PREFIX.length + 1,);
   /**
-   * Dot-separated identity segments; exactly stamp, nonce, index for an owned
-   * key.
+   Dot-separated identity segments; exactly stamp, nonce, index for an owned
+   key.
    */
   const segments = rest.split('.',);
   if (segments.length !== RUN_KEY_SEGMENTS)
     return {};
   /**
-   * Identity segments in declaration order; any missing or malformed one
-   * makes the key foreign.
+   Identity segments in declaration order; any missing or malformed one
+   makes the key foreign.
    */
   const [stampText, nonce, indexText,] = segments;
   if (
@@ -142,22 +142,22 @@ export function parseLogKey(key: string,): { readonly parsed?: ParsedLogKey; } {
 }
 
 /**
- * Orders parsed keys oldest-first for eviction: by run stamp, then by nonce
- * (an arbitrary but stable tiebreak between same-millisecond runs), then by
- * batch index within the run.
- *
- * @param first - Parsed key compared first.
- *
- * @param second - Parsed key compared second.
- *
- * @returns Negative when `first` is older, positive when newer, zero on ties.
- *
- * @example
- * ```ts
- * entries.toSorted(function byOldestFirst(first, second) {
- *   return compareLogKeys({ first, second });
- * });
- * ```
+ Orders parsed keys oldest-first for eviction: by run stamp, then by nonce
+ (an arbitrary but stable tiebreak between same-millisecond runs), then by
+ batch index within the run.
+ 
+ @param first - Parsed key compared first.
+ 
+ @param second - Parsed key compared second.
+ 
+ @returns Negative when `first` is older, positive when newer, zero on ties.
+ 
+ @example
+ ```ts
+ entries.toSorted(function byOldestFirst(first, second) {
+   return compareLogKeys({ first, second });
+ });
+ ```
  */
 export function compareLogKeys(
   {

package/src/sink/local-storage-key.unit.test.ts

@@ -10,9 +10,9 @@ import {
 } from '@monochromatic-dev/module-logger';
 
 /**
- * Keys the strict parser must reject: host application keys, the
- * sessionStorage sink's flat shape, and malformed run identities. Eviction
- * safety rests on every one of these staying foreign.
+ Keys the strict parser must reject: host application keys, the
+ sessionStorage sink's flat shape, and malformed run identities. Eviction
+ safety rests on every one of these staying foreign.
  */
 const FOREIGN_KEYS: readonly string[] = [
   'other.key',
@@ -33,7 +33,7 @@ await describe({
       name: 'round-trips a built key back to its identity',
       fn: async () => {
         /**
-         * Identity pushed through build-then-parse; equality proves the pair inverse.
+         Identity pushed through build-then-parse; equality proves the pair inverse.
          */
         const identity = {
           stamp: 1_753_000_000_000,
@@ -41,11 +41,11 @@ await describe({
           index: 7,
         };
         /**
-         * Key the builder produced for the identity.
+         Key the builder produced for the identity.
          */
         const built = buildLogKey(identity,);
         /**
-         * Identity parsed back out of the built key.
+         Identity parsed back out of the built key.
          */
         const { parsed, } = parseLogKey(built,);
         expect(parsed,)
@@ -70,7 +70,7 @@ await describe({
       name: 'compareLogKeys orders by stamp, then nonce, then index',
       fn: async () => {
         /**
-         * Keys deliberately shuffled across all three ordering dimensions.
+         Keys deliberately shuffled across all three ordering dimensions.
          */
         const shuffled = [
           'monochromatic.log.2000.aaaa.0',
@@ -83,7 +83,7 @@ await describe({
             return (parsed === undefined) ? [] : [parsed,];
           },);
         /**
-         * Oldest-first ordering the eviction queue relies on.
+         Oldest-first ordering the eviction queue relies on.
          */
         const sorted = shuffled.toSorted(function byOldestFirst(first, second,) {
           return compareLogKeys({