test: stand elapsed-time bounds down under coverage

- add packages/mejiro/tests/timing.ts exporting expectElapsedUnder(), which
  skips the wall-clock bound while coverage is being collected; the
  surrounding test still runs and still asserts what the operation
  produced, so the correctness checks and their coverage are unaffected
- V8 instrumentation multiplies elapsed time by a factor that varies with
  the input, so a budget or a scaling ratio measured under it describes
  the instrumentation rather than the code: tokenizeManuscriptSource is
  cleanly linear uninstrumented (11.9ms -> 22.8ms -> 48.7ms -> 94.4ms as
  the input doubles from 160k to 1.28M characters) yet reads as nearly
  quadratic with coverage on
- expose whether the run collects coverage to the tests through a
  MEJIRO_COVERAGE env var in vitest.config.ts
- route the eight elapsed-time assertions in chapter-layout-cost,
  manuscript-tokens and epub/xml-utils through the helper, the xml-utils
  pair included since it is the same construction
- leave the regression coverage on those runs to the deterministic guards
  that do not depend on machine speed: the characters fed to
  computeBreaks and the buildRenderPage call count
- raise testTimeout to 30s, since several tests parse every source file in
  the workspace or build EPUB archives from scratch and exceed the 5s
  default under instrumentation

Author: libraz

packages/mejiro/tests/book/chapter-layout-cost.test.ts

@@ -3,6 +3,7 @@ import { type CachedParagraph, ChapterLayout } from '../../src/book/chapter-layo
 import { computeBreaks } from '../../src/layout.js';
 import type { RenderEntry } from '../../src/render/types.js';
 import { toCodepoints, uniformAdvances } from '../helpers.js';
+import { expectElapsedUnder } from '../timing.js';
 
 const counters = vi.hoisted(() => ({ buildRenderPage: 0, breakChars: 0 }));
 
@@ -108,7 +109,7 @@ function dragBreakChars(layout: ChapterLayout): number {
 describe('image reflow cost', () => {
   it('reflows a book-length chapter within a frame budget', () => {
     // The frame budget is 16.7ms; the bound is loosened for slower machines.
-    expect(medianDragMs(makeBookLayout(80_000))).toBeLessThan(50);
+    expectElapsedUnder(medianDragMs(makeBookLayout(80_000)), 50);
   }, 30_000);
 
   it('scales with the line count rather than the character count', () => {
@@ -157,6 +158,6 @@ describe('selectionRects cost', () => {
     const pagesSpanned = new Set(deep.map((r) => r.pageIdx)).size;
     expect(counters.buildRenderPage).toBe(pagesSpanned);
     expect(deep).toHaveLength(100);
-    expect(elapsed).toBeLessThan(50);
+    expectElapsedUnder(elapsed, 50);
   });
 });

packages/mejiro/tests/epub/xml-utils.test.ts

@@ -1,5 +1,6 @@
 import { describe, expect, it } from 'vitest';
 import { extractStylesheetLinks, stripStylesheetLinks } from '../../src/epub/xml-utils.js';
+import { expectElapsedUnder } from '../timing.js';
 
 describe('stripStylesheetLinks', () => {
   it('removes stylesheet links written as self-closing, bare and explicitly closed tags', () => {
@@ -51,7 +52,7 @@ describe('stripStylesheetLinks', () => {
 
     expect(stripped).toBe(xhtml);
     expect(links).toEqual([]);
-    expect(elapsed).toBeLessThan(1_000);
+    expectElapsedUnder(elapsed, 1_000);
   });
 
   it('completes in linear time on many unterminated tags followed by a stylesheet link', () => {
@@ -64,6 +65,6 @@ describe('stripStylesheetLinks', () => {
 
     // The unterminated starts are part of the tag that finally closes.
     expect(stripped).toBe('');
-    expect(elapsed).toBeLessThan(1_000);
+    expectElapsedUnder(elapsed, 1_000);
   });
 });

packages/mejiro/tests/manuscript-tokens.test.ts

@@ -1,6 +1,7 @@
 import { describe, expect, it } from 'vitest';
 import { parseManuscript } from '../src/manuscript.js';
 import { tokenizeManuscriptSource } from '../src/manuscript-tokens.js';
+import { expectElapsedUnder } from './timing.js';
 
 describe('tokenizeManuscriptSource', () => {
   it('detects bar-notation ruby spans with correct source ranges', () => {
@@ -87,7 +88,7 @@ describe('tokenizeManuscriptSource', () => {
     const elapsed = performance.now() - start;
 
     expect(tokens).toEqual([]);
-    expect(elapsed).toBeLessThan(500);
+    expectElapsedUnder(elapsed, 500);
   });
 
   it('tokenizes text dense with unclosed markers in linear time', () => {
@@ -98,9 +99,9 @@ describe('tokenizeManuscriptSource', () => {
     const fullElapsed = fastestRun(() => tokenizeManuscriptSource(full));
 
     expect(tokenizeManuscriptSource(full)).toEqual([]);
-    expect(fullElapsed).toBeLessThan(500);
+    expectElapsedUnder(fullElapsed, 500);
     // Quadratic scanning would roughly quadruple when the source doubles.
-    expect(fullElapsed).toBeLessThan(halfElapsed * 3 + 5);
+    expectElapsedUnder(fullElapsed, halfElapsed * 3 + 5);
   });
 
   it('scans a long base run without ruby in linear time', () => {
@@ -109,7 +110,7 @@ describe('tokenizeManuscriptSource', () => {
     const elapsed = fastestRun(() => tokenizeManuscriptSource(text));
 
     expect(tokenizeManuscriptSource(text)).toEqual([]);
-    expect(elapsed).toBeLessThan(500);
+    expectElapsedUnder(elapsed, 500);
   });
 
   it('still matches markers on later lines after an unclosed marker', () => {

packages/mejiro/tests/timing.ts

@@ -0,0 +1,29 @@
+import { expect } from 'vitest';
+
+/**
+ * Whether the current run collects coverage, as set by `vitest.config.ts`.
+ *
+ * V8 instrumentation multiplies elapsed time by a factor that varies with the
+ * input, so a wall-clock budget or a scaling ratio measured under it describes
+ * the instrumentation rather than the code.
+ */
+const underCoverage = process.env.MEJIRO_COVERAGE === '1';
+
+/**
+ * Asserts that an operation stayed inside an elapsed-time bound, except while
+ * coverage is being collected.
+ *
+ * The surrounding test still runs and still checks what the operation actually
+ * produced; only the timing bound stands down, because a threshold that has to
+ * be widened for instrumentation or a slow runner stops being a signal. The
+ * algorithmic guards that hold regardless of machine speed — counting the work
+ * fed to a hot function rather than timing it — carry the regression coverage
+ * on those runs.
+ *
+ * @param elapsed - Measured duration in milliseconds.
+ * @param limit - Upper bound the duration must stay below.
+ */
+export function expectElapsedUnder(elapsed: number, limit: number): void {
+  if (underCoverage) return;
+  expect(elapsed).toBeLessThan(limit);
+}

vitest.config.ts

@@ -1,6 +1,17 @@
 import { fileURLToPath } from 'node:url';
 import { defineConfig } from 'vitest/config';
 
+/**
+ * Whether this run collects coverage.
+ *
+ * V8 instrumentation inflates elapsed time by a factor that varies with the
+ * input, which makes wall-clock budgets and scaling ratios meaningless — a
+ * tokenizer measured as linear without coverage reads as superlinear with it.
+ * Tests that assert on elapsed time read this flag and stand down, so the
+ * coverage run stays a binary signal instead of a machine-speed gate.
+ */
+const coverageEnabled = process.argv.includes('--coverage');
+
 export default defineConfig({
   resolve: {
     alias: [
@@ -21,6 +32,12 @@ export default defineConfig({
   test: {
     include: ['packages/*/tests/**/*.test.{ts,tsx}'],
     setupFiles: ['tests/vitest.setup.ts'],
+    // biome-ignore lint/style/useNamingConvention: environment variable names are SCREAMING_SNAKE_CASE
+    env: { MEJIRO_COVERAGE: coverageEnabled ? '1' : '' },
+    // Several tests parse every source file in the workspace or build EPUB
+    // archives from scratch; under coverage they run several times longer than
+    // the 5s default allows.
+    testTimeout: 30_000,
     benchmark: {
       include: ['packages/*/bench/**/*.bench.ts'],
     },