@monochromatic-dev/module-logger 0.2.0 → 0.4.0

package/src/sink/session-storage-quota.ts

@@ -1,16 +1,16 @@
 /**
- * Per-runtime default sessionStorage quota heuristics.
- *
- * The Web Storage API exposes no way to read the sessionStorage quota (unlike
- * `navigator.storage.estimate()`, which reports the unrelated persistent-storage
- * budget), so the sink caps its own footprint from a table of measured
- * defaults. Each figure was fill-probed on a fresh store: values are written at
- * a growing single key until a `QuotaExceededError`, binary-searching the
- * largest that fits. Figures are UTF-16 code units (JS string length, counting
- * key plus value) because that is what sessionStorage measures and what the
- * sink compares `serialized.length` against.
- *
- * @module
+ Per-runtime default sessionStorage quota heuristics.
+ 
+ The Web Storage API exposes no way to read the sessionStorage quota (unlike
+ `navigator.storage.estimate()`, which reports the unrelated persistent-storage
+ budget), so the sink caps its own footprint from a table of measured
+ defaults. Each figure was fill-probed on a fresh store: values are written at
+ a growing single key until a `QuotaExceededError`, binary-searching the
+ largest that fits. Figures are UTF-16 code units (JS string length, counting
+ key plus value) because that is what sessionStorage measures and what the
+ sink compares `serialized.length` against.
+ 
+ @module
  */
 
 import {
@@ -19,18 +19,18 @@ import {
 } from './web-storage-runtime.ts';
 
 /**
- * Measured default per-origin sessionStorage quotas, in UTF-16 code units, one
- * bucket per detectable runtime:
- *
- * - `deno`: 10 MiB on Deno 2.9.
- * - `node`: 5 MiB on Node 26.
- * - `browser`: 5 MiB, measured identical on Chromium, Firefox, and WebKit under
- *   Playwright v1.61, so the three engines share one bucket and no fragile
- *   user-agent sniffing is needed to tell them apart.
- *
- * Bun 1.3 exposes no `sessionStorage`, so its bucket is uncapped: its sink
- * never verifies and never reaches the cap. An unrecognized runtime is also
- * uncapped so the caller relies on reactive eviction alone.
+ Measured default per-origin sessionStorage quotas, in UTF-16 code units, one
+ bucket per detectable runtime:
+ 
+ - `deno`: 10 MiB on Deno 2.9.
+ - `node`: 5 MiB on Node 26.
+ - `browser`: 5 MiB, measured identical on Chromium, Firefox, and WebKit under
+   Playwright v1.61, so the three engines share one bucket and no fragile
+   user-agent sniffing is needed to tell them apart.
+ 
+ Bun 1.3 exposes no `sessionStorage`, so its bucket is uncapped: its sink
+ never verifies and never reaches the cap. An unrecognized runtime is also
+ uncapped so the caller relies on reactive eviction alone.
  */
 const RUNTIME_QUOTA_CHARS: Record<WebStorageRuntime, number> = {
   browser: 5_242_880,
@@ -41,16 +41,16 @@ const RUNTIME_QUOTA_CHARS: Record<WebStorageRuntime, number> = {
 };
 
 /**
- * Detects the current runtime's default sessionStorage quota in UTF-16 code
- * units, or `Number.POSITIVE_INFINITY` when the runtime is unrecognized so the
- * caller leaves its footprint uncapped and relies on reactive eviction alone.
- *
- * @returns Total quota in code units, or `Number.POSITIVE_INFINITY` if unknown.
- *
- * @example
- * ```ts
- * const capChars = detectSessionStorageQuotaChars() / 2; // half the total
- * ```
+ Detects the current runtime's default sessionStorage quota in UTF-16 code
+ units, or `Number.POSITIVE_INFINITY` when the runtime is unrecognized so the
+ caller leaves its footprint uncapped and relies on reactive eviction alone.
+ 
+ @returns Total quota in code units, or `Number.POSITIVE_INFINITY` if unknown.
+ 
+ @example
+ ```ts
+ const capChars = detectSessionStorageQuotaChars() / 2; // half the total
+ ```
  */
 export function detectSessionStorageQuotaChars(): number {
   return RUNTIME_QUOTA_CHARS[detectWebStorageRuntime()];

package/src/sink/session-storage-quota.unit.test.ts

@@ -8,14 +8,14 @@ import {
 } from '@monochromatic-dev/module-logger';
 
 /**
- * Temporarily sets `globalThis` keys to the supplied values, restoring each to
- * its prior value (or deleting keys that were absent) when the returned guard
- * leaves `using` scope, so a runtime-detection test can impersonate Deno, Bun,
- * or a browser without leaking the fake globals into later tests.
- *
- * @param overrides - Global keys to install for the duration of the scope.
- *
- * @returns Disposable that restores the original globals on exit.
+ Temporarily sets `globalThis` keys to the supplied values, restoring each to
+ its prior value (or deleting keys that were absent) when the returned guard
+ leaves `using` scope, so a runtime-detection test can impersonate Deno, Bun,
+ or a browser without leaking the fake globals into later tests.
+ 
+ @param overrides - Global keys to install for the duration of the scope.
+ 
+ @returns Disposable that restores the original globals on exit.
  */
 function withGlobalOverrides(overrides: Record<string, unknown>,): Disposable {
   const host = globalThis as unknown as Record<string, unknown>;

package/src/sink/session-storage-store.ts

@@ -3,61 +3,61 @@ import { detectSessionStorageQuotaChars, } from './session-storage-quota.ts';
 import { isQuotaExceededError, } from './web-storage-quota-error.ts';
 
 /**
- * Prefix for sessionStorage keys to namespace log entries.
+ Prefix for sessionStorage keys to namespace log entries.
  */
 const STORAGE_KEY_PREFIX = 'monochromatic.log';
 
 /**
- * Builds the namespaced sessionStorage key for a log entry at `index`.
- *
- * @param index - Zero-based slot number of an entry.
- *
- * @returns Prefixed key such as `monochromatic.log.3`.
- *
- * @example
- * ```ts
- * storageKey(3); // 'monochromatic.log.3'
- * ```
+ Builds the namespaced sessionStorage key for a log entry at `index`.
+ 
+ @param index - Zero-based slot number of an entry.
+ 
+ @returns Prefixed key such as `monochromatic.log.3`.
+ 
+ @example
+ ```ts
+ storageKey(3); // 'monochromatic.log.3'
+ ```
  */
 function storageKey(index: number,): string {
   return `${STORAGE_KEY_PREFIX}.${index}`;
 }
 
 /**
- * Builds the persistence engine behind the sessionStorage sink: each `persist`
- * lands one already-serialized batch under a counter-incremented key, with
- * proactive and reactive quota eviction. The counter lives in this instance's
- * closure (no module-global state), so independent sinks and tests never share
- * keys or need a reset hook.
- *
- * The engine caps its own footprint at half the runtime's sessionStorage
- * quota, proactively dropping its oldest entries, and reactively drops them
- * again if the real store overflows; see {@link createSessionStorageStore.persist}.
- *
- * @returns Engine exposing `persist` for one batch value per call.
- *
- * @example
- * ```ts
- * const store = createSessionStorageStore();
- * store.persist('{"level":"info","message":"hi","timestamp":0}');
- * ```
+ Builds the persistence engine behind the sessionStorage sink: each `persist`
+ lands one already-serialized batch under a counter-incremented key, with
+ proactive and reactive quota eviction. The counter lives in this instance's
+ closure (no module-global state), so independent sinks and tests never share
+ keys or need a reset hook.
+ 
+ The engine caps its own footprint at half the runtime's sessionStorage
+ quota, proactively dropping its oldest entries, and reactively drops them
+ again if the real store overflows; see {@link createSessionStorageStore.persist}.
+ 
+ @returns Engine exposing `persist` for one batch value per call.
+ 
+ @example
+ ```ts
+ const store = createSessionStorageStore();
+ store.persist('{"level":"info","message":"hi","timestamp":0}');
+ ```
  */
 export function createSessionStorageStore(): { readonly persist: (batch: string,) => void; } {
   /**
-   * Instance-local write cursor, eviction watermark, and footprint tally.
-   * `lineCounter` is the next slot to write and advances only when a `setItem`
-   * actually lands, so this engine's present entries occupy the contiguous
-   * range `[oldestIndex, lineCounter)`. `oldestIndex` is the lowest slot the
-   * engine still owns; eviction removes that entry and climbs `oldestIndex`
-   * toward `lineCounter`, so `oldestIndex < lineCounter` doubles as the "a
-   * prior write succeeded and an owned entry remains" guard that keeps
-   * eviction from ever touching another origin consumer's keys. `usedChars`
-   * tracks the code units this engine currently occupies so the half-quota cap
-   * needs no re-summing. `reportedFailure` gates the give-up diagnostic to
-   * once per failure episode: a persistently full store (another writer owning
-   * the space) would otherwise emit one `console.warn` per batch, so the flag
-   * stays set until a write next lands, which re-arms a single report for the
-   * next episode.
+   Instance-local write cursor, eviction watermark, and footprint tally.
+   `lineCounter` is the next slot to write and advances only when a `setItem`
+   actually lands, so this engine's present entries occupy the contiguous
+   range `[oldestIndex, lineCounter)`. `oldestIndex` is the lowest slot the
+   engine still owns; eviction removes that entry and climbs `oldestIndex`
+   toward `lineCounter`, so `oldestIndex < lineCounter` doubles as the "a
+   prior write succeeded and an owned entry remains" guard that keeps
+   eviction from ever touching another origin consumer's keys. `usedChars`
+   tracks the code units this engine currently occupies so the half-quota cap
+   needs no re-summing. `reportedFailure` gates the give-up diagnostic to
+   once per failure episode: a persistently full store (another writer owning
+   the space) would otherwise emit one `console.warn` per batch, so the flag
+   stays set until a write next lands, which re-arms a single report for the
+   next episode.
    */
   const state: {
     lineCounter: number;
@@ -72,27 +72,27 @@ export function createSessionStorageStore(): { readonly persist: (batch: string,
   };
 
   /**
-   * Half the detected runtime sessionStorage quota, in UTF-16 code units, or
-   * `Number.POSITIVE_INFINITY` on an unrecognized runtime. The engine keeps
-   * its own footprint at or below this so the logger never claims more than
-   * half the store, leaving the rest for the host application. An infinite cap
-   * disables the proactive check, leaving only reactive quota-error eviction.
+   Half the detected runtime sessionStorage quota, in UTF-16 code units, or
+   `Number.POSITIVE_INFINITY` on an unrecognized runtime. The engine keeps
+   its own footprint at or below this so the logger never claims more than
+   half the store, leaving the rest for the host application. An infinite cap
+   disables the proactive check, leaving only reactive quota-error eviction.
    */
   const capChars = detectSessionStorageQuotaChars() / 2;
 
   /**
-   * Removes this engine's oldest still-present entry, advancing the watermark
-   * and subtracting the reclaimed entry's code units from the running
-   * footprint. Reading the value back before removal keeps `usedChars` honest
-   * even if the entry drifted from what was written.
+   Removes this engine's oldest still-present entry, advancing the watermark
+   and subtracting the reclaimed entry's code units from the running
+   footprint. Reading the value back before removal keeps `usedChars` honest
+   even if the entry drifted from what was written.
    */
   function evictOldest(): void {
     /**
-     * Key of the oldest owned entry, removed to reclaim its slot and its space.
+     Key of the oldest owned entry, removed to reclaim its slot and its space.
      */
     const key = storageKey(state.oldestIndex,);
     /**
-     * Value being evicted, read back so its length can leave the footprint tally.
+     Value being evicted, read back so its length can leave the footprint tally.
      */
     const evicted = globalThis.sessionStorage
       .getItem(key,);
@@ -107,26 +107,26 @@ export function createSessionStorageStore(): { readonly persist: (batch: string,
   }
 
   /**
-   * Persists one serialized batch to sessionStorage under a
-   * counter-incremented key.
-   *
-   * First it proactively drops its own oldest entries so its footprint stays
-   * at or below half the runtime's sessionStorage quota, leaving the rest for
-   * the host application. It then writes, and on a quota overflow (the store
-   * being fuller than the cap accounts for), and only while an owned entry
-   * remains (so the reclaimed keys are its own, never another origin
-   * consumer's), it drops its oldest still-present entry and retries until the
-   * batch fits or nothing of its own remains to drop. A batch larger than the
-   * whole quota therefore evicts every owned entry, then reports and gives up
-   * rather than looping forever. A non-quota failure is reported without any
-   * eviction. The sink only persists after verification, so no availability
-   * guard is needed here.
-   *
-   * @param batch - Serialized JSONL batch to persist.
+   Persists one serialized batch to sessionStorage under a
+   counter-incremented key.
+   
+   First it proactively drops its own oldest entries so its footprint stays
+   at or below half the runtime's sessionStorage quota, leaving the rest for
+   the host application. It then writes, and on a quota overflow (the store
+   being fuller than the cap accounts for), and only while an owned entry
+   remains (so the reclaimed keys are its own, never another origin
+   consumer's), it drops its oldest still-present entry and retries until the
+   batch fits or nothing of its own remains to drop. A batch larger than the
+   whole quota therefore evicts every owned entry, then reports and gives up
+   rather than looping forever. A non-quota failure is reported without any
+   eviction. The sink only persists after verification, so no availability
+   guard is needed here.
+   
+   @param batch - Serialized JSONL batch to persist.
    */
   function persist(batch: string,): void {
     /**
-     * Code units this batch adds; the key's length is left out as a negligible near-constant.
+     Code units this batch adds; the key's length is left out as a negligible near-constant.
      */
     const batchChars = batch.length;
 
@@ -138,8 +138,8 @@ export function createSessionStorageStore(): { readonly persist: (batch: string,
     }
 
     /**
-     * Write-attempt bound: one try for each entry still available to evict,
-     * followed by one final try after every owned entry has been removed.
+     Write-attempt bound: one try for each entry still available to evict,
+     followed by one final try after every owned entry has been removed.
      */
     const maxWriteAttempts = (state.lineCounter - state.oldestIndex) + 1;
     for (let writeAttempt = 0; writeAttempt < maxWriteAttempts; writeAttempt++) {

package/src/sink/session-storage.ts

@@ -8,32 +8,32 @@ import type {
 } from '../types.ts';
 
 /**
- * Verifies sessionStorage actually persists data. Stateless: the logger calls
- * this once per sink at startup and owns the resulting availability, so no
- * verified/available flag is kept here.
- *
- * Election is by probe alone: any runtime whose `sessionStorage` round-trips
- * (browsers, Node 22+, Deno) keeps the sink, and the buffered write path
- * keeps the per-record cost acceptable everywhere rather than a runtime brand
- * check deciding who may log here.
- *
- * @returns Whether sessionStorage is available and round-trips a probe write.
- *
- * @example
- * ```ts
- * if (await verifySessionStorage()) {
- *   // sessionStorage usable
- * }
- * ```
+ Verifies sessionStorage actually persists data. Stateless: the logger calls
+ this once per sink at startup and owns the resulting availability, so no
+ verified/available flag is kept here.
+ 
+ Election is by probe alone: any runtime whose `sessionStorage` round-trips
+ (browsers, Node 22+, Deno) keeps the sink, and the buffered write path
+ keeps the per-record cost acceptable everywhere rather than a runtime brand
+ check deciding who may log here.
+ 
+ @returns Whether sessionStorage is available and round-trips a probe write.
+ 
+ @example
+ ```ts
+ if (await verifySessionStorage()) {
+   // sessionStorage usable
+ }
+ ```
  */
 function verifySessionStorage(): Promise<boolean> {
   try {
     /**
-     * Sentinel key used only for the probe write/read; removed afterward to avoid polluting real log entries.
+     Sentinel key used only for the probe write/read; removed afterward to avoid polluting real log entries.
      */
     const testKey = '__monochromatic_verify__';
     /**
-     * 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 testValue = `test-${Date.now()}`;
     globalThis.sessionStorage
@@ -42,7 +42,7 @@ function verifySessionStorage(): Promise<boolean> {
       testValue,
     );
     /**
-     * Probe value read back from storage; equality with `testValue` proves writes actually persist.
+     Probe value read back from storage; equality with `testValue` proves writes actually persist.
      */
     const readBack = globalThis.sessionStorage
       .getItem(testKey,);
@@ -61,43 +61,43 @@ function verifySessionStorage(): Promise<boolean> {
 }
 
 /**
- * Builds a sessionStorage sink that buffers serialized records through the
- * shared {@link createRecordBuffer} policy and persists each newline-joined
- * JSONL batch under a counter-incremented key through
- * {@link createSessionStorageStore}. One uniform write path runs on every
- * runtime; no per-runtime mode exists. 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}.
- *
- * @returns Sink backed by web `sessionStorage`.
- *
- * @example
- * ```ts
- * const { logger } = createLogger({ sinks: [createSessionStorageSink()] });
- * logger.info('user signed in'); // buffered
- * logger.warn('quota near');     // flushes both records in one batch
- * ```
+ Builds a sessionStorage sink that buffers serialized records through the
+ shared {@link createRecordBuffer} policy and persists each newline-joined
+ JSONL batch under a counter-incremented key through
+ {@link createSessionStorageStore}. One uniform write path runs on every
+ runtime; no per-runtime mode exists. 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}.
+ 
+ @returns Sink backed by web `sessionStorage`.
+ 
+ @example
+ ```ts
+ const { logger } = createLogger({ sinks: [createSessionStorageSink()] });
+ logger.info('user signed in'); // buffered
+ logger.warn('quota near');     // flushes both records in one batch
+ ```
  */
 export function createSessionStorageSink(): Sink {
   /**
-   * Persistence engine owning key allocation, footprint accounting, and quota
-   * eviction; the buffer decides when a batch is handed to it.
+   Persistence engine owning key allocation, footprint accounting, and quota
+   eviction; the buffer decides when a batch is handed to it.
    */
   const store = createSessionStorageStore();
 
   /**
-   * Shared buffering stage; every flush trigger lands one joined batch in the
-   * persistence engine synchronously.
+   Shared buffering stage; every flush trigger lands one joined batch in the
+   persistence engine synchronously.
    */
   const buffer = createRecordBuffer({ onFlush: store.persist, },);
 
   /**
-   * 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;
@@ -112,8 +112,8 @@ export function createSessionStorageSink(): Sink {
   }
 
   /**
-   * Drains the buffer into the persistence engine; the drain is synchronous,
-   * so the batch has landed by the time the resolved promise is observed.
+   Drains the buffer into the persistence engine; the drain is synchronous,
+   so the batch has landed by the time the resolved promise is observed.
    */
   function flush(): Promise<void> {
     buffer.drain();

package/src/sink/session-storage.unit.test.ts

@@ -11,20 +11,20 @@ import {
 } from '@monochromatic-dev/module-logger';
 
 /**
- * Sink factories under test, read from the built artifact's `sinks` namespace.
+ Sink factories under test, read from the built artifact's `sinks` namespace.
  */
 const {
   createSessionStorageSink,
 } = sinks;
 
 /**
- * Swaps `globalThis.sessionStorage` for `fake`, restoring the real backend when
- * the returned guard leaves `using` scope, so a fake never leaks into a later
- * test in the serial suite.
- *
- * @param fake - Storage stand-in to install for the duration of the scope.
- *
- * @returns Disposable that restores the original `sessionStorage` on exit.
+ Swaps `globalThis.sessionStorage` for `fake`, restoring the real backend when
+ the returned guard leaves `using` scope, so a fake never leaks into a later
+ test in the serial suite.
+ 
+ @param fake - Storage stand-in to install for the duration of the scope.
+ 
+ @returns Disposable that restores the original `sessionStorage` on exit.
  */
 function installFakeStorage(fake: Storage,): Disposable {
   const original = globalThis.sessionStorage;
@@ -37,14 +37,14 @@ function installFakeStorage(fake: Storage,): Disposable {
 }
 
 /**
- * Builds an in-memory `Storage` stand-in that rejects a `setItem` once stored
- * value lengths would exceed `byteBudget`, throwing the same
- * `QuotaExceededError` a real backend raises. Records every `removeItem` under
- * `removed` so a test can assert exactly which keys the sink evicted.
- *
- * @param byteBudget - Total value length the store accepts before overflowing.
- *
- * @returns Storage stand-in exposing the evicted-key log as `removed`.
+ Builds an in-memory `Storage` stand-in that rejects a `setItem` once stored
+ value lengths would exceed `byteBudget`, throwing the same
+ `QuotaExceededError` a real backend raises. Records every `removeItem` under
+ `removed` so a test can assert exactly which keys the sink evicted.
+ 
+ @param byteBudget - Total value length the store accepts before overflowing.
+ 
+ @returns Storage stand-in exposing the evicted-key log as `removed`.
  */
 function createQuotaStorage(byteBudget: number,): Storage & { readonly removed: string[]; } {
   const store = new Map<string, string>();
@@ -77,12 +77,12 @@ function createQuotaStorage(byteBudget: number,): Storage & { readonly removed:
 }
 
 /**
- * Builds an in-memory `Storage` stand-in whose first `setItem` succeeds and
- * every later one throws a non-quota error, so a test can prove the sink does
- * not evict for failures other than a quota overflow. Records `removeItem`
- * calls under `removed`.
- *
- * @returns Storage stand-in exposing the evicted-key log as `removed`.
+ Builds an in-memory `Storage` stand-in whose first `setItem` succeeds and
+ every later one throws a non-quota error, so a test can prove the sink does
+ not evict for failures other than a quota overflow. Records `removeItem`
+ calls under `removed`.
+ 
+ @returns Storage stand-in exposing the evicted-key log as `removed`.
  */
 function createFlakyStorage(): Storage & { readonly removed: string[]; } {
   const store = new Map<string, string>();
@@ -107,10 +107,10 @@ function createFlakyStorage(): Storage & { readonly removed: string[]; } {
 }
 
 /**
- * Captures `console.warn` output, restoring the real method when the returned
- * guard leaves `using` scope, so a test can count the sink's give-up reports.
- *
- * @returns Disposable exposing captured warn lines as `calls`.
+ Captures `console.warn` output, restoring the real method when the returned
+ guard leaves `using` scope, so a test can count the sink's give-up reports.
+ 
+ @returns Disposable exposing captured warn lines as `calls`.
  */
 function spyConsoleWarn(): Disposable & { readonly calls: string[]; } {
   const original = console.warn;
@@ -128,11 +128,11 @@ function spyConsoleWarn(): Disposable & { readonly calls: string[]; } {
 }
 
 /**
- * Counts captured warn lines that are the sessionStorage sink's give-up report.
- *
- * @param calls - Captured `console.warn` lines from {@link spyConsoleWarn}.
- *
- * @returns How many lines report a sink write failure.
+ Counts captured warn lines that are the sessionStorage sink's give-up report.
+ 
+ @param calls - Captured `console.warn` lines from {@link spyConsoleWarn}.
+ 
+ @returns How many lines report a sink write failure.
  */
 function sinkFailureCount(calls: readonly string[],): number {
   return calls.filter(function isSinkFailure(line,) {
@@ -174,7 +174,7 @@ await describe({
         await sink.verify();
 
         /**
-         * Routine record; severity below `warn` stays buffered.
+         Routine record; severity below `warn` stays buffered.
          */
         const record: LogRecord = {
           level: 'info',
@@ -206,7 +206,7 @@ await describe({
         await sink.verify();
 
         /**
-         * Routine record buffered first; must survive into the batch the warning triggers.
+         Routine record buffered first; must survive into the batch the warning triggers.
          */
         const first: LogRecord = {
           level: 'info',
@@ -214,7 +214,7 @@ await describe({
           timestamp: 0,
         };
         /**
-         * Warning record whose severity forces the synchronous flush.
+         Warning record whose severity forces the synchronous flush.
          */
         const second: LogRecord = {
           level: 'warn',
@@ -244,7 +244,7 @@ await describe({
         await sink.verify();
 
         /**
-         * Routine record left to the deadline timer.
+         Routine record left to the deadline timer.
          */
         const record: LogRecord = {
           level: 'debug',
@@ -254,7 +254,7 @@ await describe({
         await sink.write(record,);
 
         /**
-         * Comfortably past the sink's 250 ms quiet-period deadline.
+         Comfortably past the sink's 250 ms quiet-period deadline.
          */
         const pastDeadlineMs = 400;
         await wait(pastDeadlineMs,);
@@ -275,7 +275,7 @@ await describe({
         await sink.verify();
 
         /**
-         * Small routine record buffered first; must not share a batch with the cap-breaching record.
+         Small routine record buffered first; must not share a batch with the cap-breaching record.
          */
         const small: LogRecord = {
           level: 'info',
@@ -343,7 +343,7 @@ await describe({
       name: 'caps its own footprint at half the runtime quota, proactively evicting oldest',
       fn: async () => {
         /**
-         * Half the detected runtime quota: the footprint ceiling the engine enforces.
+         Half the detected runtime quota: the footprint ceiling the engine enforces.
          */
         const capChars = detectSessionStorageQuotaChars() / 2;
         // A fake store far larger than the cap, so only the proactive half-quota
@@ -483,7 +483,7 @@ await describe({
         using warn = spyConsoleWarn();
         const sink = createSessionStorageSink();
         /**
-         * Record larger than the whole budget; unwritable even after eviction.
+         Record larger than the whole budget; unwritable even after eviction.
          */
         const oversized = {
           level: 'error' as const,