@kabmo-labs/kabmo 0.8.0 → 0.9.0

package/src/shared/lib/code/highlight-memo.ts

@@ -0,0 +1,149 @@
+/**
+ * @license
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/**
+ * A bounded memo in front of the syntax highlighter, for BLOCK highlights — the
+ * code a tool card draws when it opens.
+ *
+ * Shiki tokenization is the expensive half of rendering a tool card: profiled on
+ * a throttled phone, a `read` expand spent 75% of its long task in
+ * `findNextMatchSync`/the grammar engine, and the same card re-expanded in 33 ms
+ * once its grammar was warm. Two consequences follow, and this module is the
+ * second half of both (the first is `idle.ts`, which moves the work off the tap):
+ *
+ * 1. A card that is closed and reopened is the same code and the same language,
+ *    so its markup is the same string. Tokenizing it again is pure waste, and a
+ *    reader paging through a transcript does exactly that repeatedly.
+ * 2. `Edit` asked for three highlights per render (old, new, preview) when at
+ *    most one of them is ever drawn. Caching per `(language, code)` makes the
+ *    duplicates free even before the call sites are gated.
+ *
+ * The key is a two-level map — language, then the code string itself — rather
+ * than one composite string, because the composite would COPY the whole file on
+ * every lookup, which is exactly the per-frame allocation this exists to remove.
+ * Insertion order is the LRU order.
+ *
+ * Nothing is cached while the language's grammar has not landed: `highlightCode`
+ * answers escaped text in that state, and caching it would pin the plain
+ * fallback for the life of the entry (the trap `highlight-cache.ts` documents
+ * for search rows). `useSyntaxReady` re-runs the caller when a grammar arrives,
+ * which is when the entry finally becomes cacheable.
+ */
+
+import { isLanguageReady } from '@/shared/lib/code/highlighter-lazy';
+import { highlightCode, highlightLines, type HighlightLinesOptions } from '@/shared/lib/code/syntax-highlight';
+
+/** Per language: a transcript page's worth of distinct blocks. */
+const MAX_BLOCKS_PER_LANGUAGE = 24;
+/** Across every language, so a long session cannot grow without bound. */
+const MAX_CACHED_CHARS = 512 * 1024;
+
+const blocks = new Map<string, Map<string, string>>();
+let cachedChars = 0;
+
+function bucket(language: string): Map<string, string> {
+  const existing = blocks.get(language);
+  if (existing) return existing;
+  const created = new Map<string, string>();
+  blocks.set(language, created);
+  return created;
+}
+
+/** Drop the oldest entry of the first language that has one. */
+function evictOne(): boolean {
+  for (const entries of blocks.values()) {
+    const oldest = entries.keys().next();
+    if (oldest.done) continue;
+    const value = entries.get(oldest.value) ?? '';
+    entries.delete(oldest.value);
+    cachedChars -= value.length;
+    return true;
+  }
+  return false;
+}
+
+function remember(language: string, code: string, html: string): void {
+  const entries = bucket(language);
+  const previous = entries.get(code);
+  if (previous !== undefined) {
+    entries.delete(code);
+    cachedChars -= previous.length;
+  }
+  entries.set(code, html);
+  cachedChars += html.length;
+  while (entries.size > MAX_BLOCKS_PER_LANGUAGE) {
+    const oldest = entries.keys().next();
+    if (oldest.done) break;
+    const value = entries.get(oldest.value) ?? '';
+    entries.delete(oldest.value);
+    cachedChars -= value.length;
+  }
+  while (cachedChars > MAX_CACHED_CHARS && evictOne()) {
+    // Keep dropping until the budget holds or nothing is left to drop.
+  }
+}
+
+/** The cached markup for `(language, code)`, or `undefined`. */
+export function cachedHighlightBlock(code: string, language: string): string | undefined {
+  const entries = blocks.get(language);
+  if (!entries) return undefined;
+  const hit = entries.get(code);
+  if (hit === undefined) return undefined;
+  // Reading is a use: move it to the most-recently-used end.
+  entries.delete(code);
+  entries.set(code, hit);
+  return hit;
+}
+
+/** The cached per-line markup, or `undefined`. */
+export function cachedHighlightBlockLines(code: string, language: string): string[] | undefined {
+  const hit = cachedHighlightBlock(code, language);
+  return hit === undefined ? undefined : hit.split('\n');
+}
+
+function cacheable(language: string, options: HighlightLinesOptions): boolean {
+  // A find-in-progress needs the match markup, which only the line path emits —
+  // and which changes per query, so those results are never shared.
+  if (options.marks && options.marks.length > 0) return false;
+  return isLanguageReady(language);
+}
+
+/** `highlightCode` for one block, memoized per `(language, code)`. */
+export function highlightBlock(code: string, language: string, options: HighlightLinesOptions = {}): string {
+  if (!code) return '';
+  const cached = options.marks?.length ? undefined : cachedHighlightBlock(code, language);
+  if (cached !== undefined) return cached;
+  const html = highlightCode(code, language, options);
+  if (cacheable(language, options)) remember(language, code, html);
+  return html;
+}
+
+/** `highlightLines` for one block, memoized per `(language, code)`. */
+export function highlightBlockLines(
+  code: string,
+  language: string,
+  options: HighlightLinesOptions = {},
+): string[] {
+  if (!code) return [''];
+  const cached = options.marks?.length ? undefined : cachedHighlightBlockLines(code, language);
+  if (cached !== undefined) return cached;
+  const lines = highlightLines(code, language, options);
+  if (cacheable(language, options)) remember(language, code, lines.join('\n'));
+  return lines;
+}
+
+/** Drop every entry. For tests and for a highlighter restart (grammar reload). */
+export function clearHighlightMemo(): void {
+  blocks.clear();
+  cachedChars = 0;
+}
+
+/** How many blocks are held — a hit and a recompute return equal strings, so
+ *  the map is the only observable. */
+export function highlightMemoSize(): number {
+  let total = 0;
+  for (const entries of blocks.values()) total += entries.size;
+  return total;
+}

package/src/shared/lib/code/highlighter-warmup.ts

@@ -0,0 +1,112 @@
+/**
+ * @license
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/**
+ * Pay the tokenizer's start-up cost before the reader taps anything.
+ *
+ * `EAGER_LANGS` are loaded in the background at boot, but loading a grammar is
+ * not compiling it: the grammar's regexes are built and JIT-ed on the first
+ * tokenize, which is why the FIRST expand of a card in a given language measured
+ * 220–300 ms at 4× CPU while the same card re-expanded in 33 ms. That first
+ * expand is the one a reader actually experiences — a transcript opens with
+ * `read` and `bash` cards.
+ *
+ * So each eager grammar is tokenized once, on a tiny sample, while the main
+ * thread is idle. The sample's markup is discarded; the work being paid for is
+ * the compile behind it. One language per idle slice, so a slow grammar cannot
+ * become the long task this exists to prevent — and a grammar that has not
+ * landed yet is retried rather than skipped, because tokenizing before it
+ * arrives compiles nothing.
+ *
+ * Booted from `main.tsx` rather than from `highlighter.ts`: the warm-up needs
+ * the memo, which needs the highlighter, and an import in the other direction
+ * would close that cycle.
+ */
+
+import { isLanguageReady } from '@/shared/lib/code/highlighter-lazy';
+import { highlightBlock } from '@/shared/lib/code/highlight-memo';
+import { scheduleIdle } from '@/shared/lib/code/idle';
+import { EAGER_LANGS } from '@/shared/lib/code/shiki-langs';
+
+/**
+ * A few lines that make the grammar walk its own rule set: a keyword, a string,
+ * a comment, a call and a block. The exact text does not matter — the compile
+ * does — so these are deliberately tiny.
+ */
+const SAMPLES: Record<string, string> = {
+  typescript: '// warm\nconst value: number = 1;\nfunction read(input: string) {\n  return input;\n}\n',
+  tsx: '// warm\nexport const View = ({ title }: { title: string }) => (\n  <div className="row">{title}</div>\n);\n',
+  javascript: '// warm\nconst value = 1;\nfunction read(input) {\n  return input;\n}\n',
+  jsx: '// warm\nexport const View = ({ title }) => (\n  <div className="row">{title}</div>\n);\n',
+  json: '{\n  "name": "warm",\n  "items": [1, 2, 3],\n  "ok": true\n}\n',
+  bash: '#!/bin/sh\n# warm\nset -e\nfor file in *.ts; do\n  echo "$file"\ndone\n',
+  python: '# warm\ndef read(value: str) -> str:\n    return value.strip()\n',
+  markdown: '# warm\n\nA paragraph with **bold** text and a `code` span.\n\n- item\n',
+  yaml: 'name: warm\nitems:\n  - one\n  - two\nenabled: true\n',
+  diff: '--- a/file.ts\n+++ b/file.ts\n@@ -1,2 +1,2 @@\n-old line\n+new line\n context\n',
+};
+
+const DEFAULT_SAMPLE = '// warm\nconst value = 1;\nfunction read(input) {\n  return input;\n}\n';
+
+/** How many idle slices a not-yet-loaded grammar is retried for. */
+const MAX_WAIT_SLICES = 120;
+
+export interface WarmOptions {
+  /** Languages to warm; defaults to the eager set. */
+  languages?: readonly string[];
+  /** The tokenizer; injected so a test can observe the schedule. */
+  highlight?: (code: string, language: string) => void;
+  /** Grammar readiness; injected for the same reason. */
+  ready?: (language: string) => boolean;
+  /** The idle scheduler; injected so a test can drive it synchronously. */
+  schedule?: (run: () => void) => () => void;
+}
+
+let started = false;
+
+/**
+ * Warm every eager grammar once per page load, one per idle slice.
+ *
+ * Idempotent: a second call is a no-op, so a re-evaluated client entry cannot
+ * re-tokenize every language.
+ */
+export function warmSyntaxTokenizers(options: WarmOptions = {}): void {
+  if (started) return;
+  if (typeof window === 'undefined') return;
+  started = true;
+
+  const languages = options.languages ?? EAGER_LANGS;
+  const highlight = options.highlight ?? ((code: string, language: string) => { highlightBlock(code, language); });
+  const ready = options.ready ?? isLanguageReady;
+  const schedule = options.schedule ?? ((run: () => void) => scheduleIdle(run));
+
+  const queue = [...languages];
+  let waiting = 0;
+  const step = () => {
+    const language = queue.shift();
+    if (language === undefined) return;
+    if (!ready(language)) {
+      // The grammar is still being fetched. Warming it now would compile
+      // nothing and the sample would not even be cacheable.
+      if (++waiting <= MAX_WAIT_SLICES) queue.push(language);
+      schedule(step);
+      return;
+    }
+    waiting = 0;
+    try {
+      highlight(SAMPLES[language] ?? DEFAULT_SAMPLE, language);
+    } catch {
+      // A grammar that cannot warm is not an error: the first real highlight
+      // falls back to escaped text and retries when the grammar lands.
+    }
+    schedule(step);
+  };
+  schedule(step);
+}
+
+/** Test/restart seam: forget that the warm-up already ran. */
+export function resetTokenizerWarmup(): void {
+  started = false;
+}

package/src/shared/lib/code/highlighter.ts

@@ -69,7 +69,9 @@ async function boot(): Promise<HighlighterCore | null> {
     notify();
     // Grammars arrive on demand (`ensureLanguage`); the eager set is only a
     // head start for the languages a chat session hits immediately, and boot
-    // does not wait on it.
+    // does not wait on it. `main.tsx` pays the tokenizer's compile cost once
+    // the eager set has landed — loading a grammar is not compiling it, and the
+    // first card expand used to pay that compile inside the tap.
     void ensureLanguages(highlighter, EAGER_LANGS);
     return highlighter;
   } catch (error) {

package/src/shared/lib/code/idle.ts

@@ -0,0 +1,37 @@
+/**
+ * @license
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/**
+ * Run work when the main thread is next free.
+ *
+ * Tokenizing a tool card's code is the expensive half of expanding it — measured
+ * at 730–1484 ms on a throttled phone for a `read`/`grep` card — and running it
+ * inside the render that a tap scheduled put all of that in the tap's own task:
+ * the card appeared only after the grammar had walked every line. Deferring it
+ * costs one plain-text frame and moves the work out of the interaction.
+ *
+ * `requestIdleCallback` is the browser's own "nothing else is waiting" signal;
+ * the timeout is a FLOOR on latency rather than a budget, so a busy page still
+ * paints the colour within a quarter second. Runtimes without it (happy-dom,
+ * older Safari) fall back to the next macrotask.
+ */
+
+const IDLE_TIMEOUT_MS = 250;
+
+type IdleHost = {
+  requestIdleCallback?: (callback: () => void, options?: { timeout: number }) => number;
+  cancelIdleCallback?: (handle: number) => void;
+};
+
+/** Schedule `run`; the returned function cancels it. */
+export function scheduleIdle(run: () => void, timeoutMs: number = IDLE_TIMEOUT_MS): () => void {
+  const host = globalThis as unknown as IdleHost;
+  if (typeof host.requestIdleCallback === 'function') {
+    const handle = host.requestIdleCallback(run, { timeout: timeoutMs });
+    return () => host.cancelIdleCallback?.(handle);
+  }
+  const handle = setTimeout(run, 0);
+  return () => clearTimeout(handle);
+}

package/src/shared/lib/code/outline/rows.test.ts

@@ -0,0 +1,96 @@
+/**
+ * @license
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/**
+ * The outline's two bounds.
+ *
+ * Both exist because a large file's outline is not a long list, it is a DOM:
+ * measured on a 10 MB source with 63 618 declarations, the panel mounted
+ * 446 308 nodes and a keystroke cost 953 ms (against the editor's own 34 ms).
+ * These cases pin the arithmetic that keeps that from happening, and the
+ * sentences that stop a truncated list from reading as a complete one.
+ */
+
+import { describe, expect, test } from 'bun:test';
+import {
+  MAX_OUTLINE_ROWS,
+  MAX_OUTLINE_SCAN_CHARS,
+  outlineTooLargeNotice,
+  outlineTruncatedNotice,
+  outlineWindow,
+} from '@/shared/lib/code/outline/rows';
+import type { OutlineSymbol } from '@/shared/lib/code/outline/types';
+
+function symbols(count: number): OutlineSymbol[] {
+  return Array.from({ length: count }, (_, i) => ({
+    name: `fn${i}`,
+    kind: 'function' as const,
+    line: i + 1,
+    column: 0,
+    depth: 0,
+  }));
+}
+
+describe('outlineWindow', () => {
+  test('a list under the cap is returned whole, in source order', () => {
+    const all = symbols(5);
+    const window = outlineWindow(all);
+
+    expect(window.rows).toEqual(all);
+    expect(window.total).toBe(5);
+    expect(window.truncated).toBe(false);
+  });
+
+  test('exactly the cap is not truncated', () => {
+    const window = outlineWindow(symbols(MAX_OUTLINE_ROWS));
+
+    expect(window.rows).toHaveLength(MAX_OUTLINE_ROWS);
+    expect(window.truncated).toBe(false);
+  });
+
+  test('past the cap the list is the FIRST rows, and it says how many there are', () => {
+    const window = outlineWindow(symbols(MAX_OUTLINE_ROWS + 120));
+
+    expect(window.rows).toHaveLength(MAX_OUTLINE_ROWS);
+    expect(window.total).toBe(MAX_OUTLINE_ROWS + 120);
+    expect(window.truncated).toBe(true);
+    // Source order, not a sample: the outline is a map of the document, so the
+    // top of the file is what a window shows.
+    expect(window.rows[0].name).toBe('fn0');
+    expect(window.rows[MAX_OUTLINE_ROWS - 1].name).toBe(`fn${MAX_OUTLINE_ROWS - 1}`);
+  });
+
+  test('an empty list is not truncated', () => {
+    const window = outlineWindow([]);
+
+    expect(window.rows).toEqual([]);
+    expect(window.total).toBe(0);
+    expect(window.truncated).toBe(false);
+  });
+});
+
+describe('outlineTooLargeNotice', () => {
+  test('a buffer at the scan ceiling is still outlined', () => {
+    expect(outlineTooLargeNotice(MAX_OUTLINE_SCAN_CHARS)).toBeNull();
+    expect(outlineTooLargeNotice(1024)).toBeNull();
+  });
+
+  test('past it the sentence names the size, so the empty panel is explained', () => {
+    const notice = outlineTooLargeNotice(MAX_OUTLINE_SCAN_CHARS + 1);
+
+    expect(notice).not.toBeNull();
+    expect(notice).toContain('8.0 MB');
+    expect(notice).toContain('too large to outline');
+  });
+});
+
+describe('outlineTruncatedNotice', () => {
+  test('it names both the shown count and the total, thousands separated', () => {
+    const notice = outlineTruncatedNotice(63618);
+
+    expect(notice).toContain('500');
+    expect(notice).toContain('63,618');
+  });
+});

package/src/shared/lib/code/outline/rows.ts

@@ -0,0 +1,94 @@
+/**
+ * @license
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/**
+ * How much of an outline a panel is allowed to draw, and when it is not drawn
+ * at all.
+ *
+ * Both bounds exist because a large file's outline is not a long list — it is a
+ * DOM. Measured in the browser on a 10 MB source file with 63 618 declarations:
+ * **446 308 DOM nodes, 415 MB of JS heap, and 953 ms per keystroke** while the
+ * panel was on screen (the editor's own cost is 34 ms). Expanding the section
+ * took 2.7 s. The scan is not the problem — it is 366 ms in Bun, once per pause
+ * — the ROWS are.
+ *
+ * Two answers, and they are different questions:
+ *
+ * - **`MAX_OUTLINE_ROWS` caps the list.** An outline is a map you scan by eye or
+ *   jump from; nobody reads 63 000 rows, and the panel says how many it is not
+ *   showing rather than silently truncating. Same shape as the search panel's
+ *   `MAX_SEARCH_RESULTS`.
+ * - **`MAX_OUTLINE_SCAN_CHARS` skips the scan above a size where it costs more
+ *   than the list is worth.** At 10 MB a scan is ~366 ms of blocked main thread
+ *   every time the buffer settles, which is a stutter per typing pause. The
+ *   sentence says so instead of leaving the panel empty, which would read as
+ *   "this file has no declarations".
+ *
+ * The size is counted in CODE UNITS (`content.length`), not bytes: measuring
+ * UTF-8 bytes would mean encoding the whole buffer to answer a guard, and for
+ * the ASCII that dominates source files the two numbers are the same. A file of
+ * multibyte characters therefore trips the guard slightly early — the safe
+ * direction.
+ */
+
+import type { OutlineSymbol } from '@/shared/lib/code/outline/types';
+
+/**
+ * Rows a panel renders. Past this the list is truncated with a count, not
+ * silently shortened.
+ */
+export const MAX_OUTLINE_ROWS = 500;
+
+/** Buffer size above which the outline is not scanned at all. */
+/**
+ * Buffer size above which the outline is not scanned at all.
+ *
+ * The scan is one blocked stretch of main thread after each typing pause, and it
+ * measured 38 ms at 1 MB, 160 ms at 5 MB, 262 ms at 10 MB and 519 ms at 20 MB —
+ * linear in the buffer. 8 MiB keeps that pause under ~210 ms, which is less than
+ * the debounce that schedules it and therefore reads as "the list settled"
+ * rather than as a stutter.
+ *
+ * Past it the panel says the file is too large to outline instead of scanning
+ * it: a declaration list for a 30 MB file is not worth a half-second freeze on
+ * every pause, and an empty list would read as "no declarations here".
+ */
+export const MAX_OUTLINE_SCAN_CHARS = 8 * 1024 * 1024;
+
+export interface OutlineWindow {
+  /** The rows to render — at most `MAX_OUTLINE_ROWS`. */
+  rows: OutlineSymbol[];
+  /** Symbols the scan actually found, including the ones not rendered. */
+  total: number;
+  /** True when `rows` is shorter than `total`. */
+  truncated: boolean;
+}
+
+/**
+ * The rows a panel should render, and whether it is showing all of them.
+ *
+ * Source order is preserved: an outline is a map of a document, so the first N
+ * declarations are the top of the file rather than an arbitrary sample.
+ */
+export function outlineWindow(symbols: readonly OutlineSymbol[]): OutlineWindow {
+  const total = symbols.length;
+  if (total <= MAX_OUTLINE_ROWS) return { rows: symbols as OutlineSymbol[], total, truncated: false };
+  return { rows: symbols.slice(0, MAX_OUTLINE_ROWS), total, truncated: true };
+}
+
+/** The sentence printed under a truncated list. */
+export function outlineTruncatedNotice(total: number): string {
+  return `Showing the first ${MAX_OUTLINE_ROWS.toLocaleString()} of ${total.toLocaleString()} symbols.`;
+}
+
+/**
+ * The sentence a panel prints instead of rows when the buffer is past the scan
+ * ceiling, or null when it is not.
+ */
+export function outlineTooLargeNotice(contentLength: number): string | null {
+  if (contentLength <= MAX_OUTLINE_SCAN_CHARS) return null;
+  const mb = contentLength / (1024 * 1024);
+  return `This file is ${mb.toFixed(1)} MB — too large to outline.`;
+}

package/src/shared/lib/code/syntax-highlight.test.ts

@@ -6,10 +6,9 @@
 import { beforeAll, describe, expect, test } from 'bun:test';
 
 import { bootSyntax, onLanguageReady, requestLanguage } from '@/shared/lib/code/highlighter';
-import { findMatches } from '@/shared/lib/code/editor/find';
+import { findMatches } from '@/shared/lib/code/editor/find-scan';
 import { getLanguageFromPath } from '@/shared/lib/code/language';
 import { highlightCode, highlightLines } from '@/shared/lib/code/syntax-highlight';
-import { highlightCodeWindow } from '@/shared/lib/code/windowed-highlight';
 
 /** Shiki emits `<span class="shiki">…` with dual-theme CSS variables per token. */
 const SHIKI_RE = /<span class="shiki">/;
@@ -115,54 +114,6 @@ describe('highlightCode', () => {
   });
 });
 
-describe('highlightCodeWindow', () => {
-  const source = Array.from({ length: 120 }, (_, index) =>
-    index === 0 ? 'export const first = 1;' : `export const value${index} = ${index}; // line ${index}`,
-  ).join('\n');
-
-  /** The wrapper the app's `.shiki span` colour rule depends on. */
-  const unwrap = (html: string) => html.replace(/^<span class="shiki">/, '').replace(/<\/span>$/, '');
-
-  test('wraps the window in the class the token colours are scoped to', () => {
-    const window = highlightCodeWindow(source, 'typescript', { start: 0, end: 3 });
-
-    // Without this class no `.shiki span` rule matches, so the tokens would
-    // render in the plain ink colour.
-    expect(window).toMatch(SHIKI_RE);
-    expect(window.endsWith('</span>')).toBe(true);
-  });
-
-  test('returns only the requested lines, joined as the editor renders them', () => {
-    const window = highlightCodeWindow(source, 'typescript', { start: 10, end: 13 });
-    const rows = highlightLines(source, 'typescript');
-
-    expect(unwrap(window).split('\n')).toEqual(rows.slice(10, 13));
-  });
-
-  test('keeps multi-line grammar state from the lines above the window', () => {
-    const commented = ['/*', ' * a block comment', ' * spanning several lines', ' */', 'const after = 1;'].join('\n');
-    const rows = highlightLines(commented, 'typescript');
-    // Line 2 sits inside the comment, whose opening line is outside the window.
-    const window = highlightCodeWindow(commented, 'typescript', { start: 2, end: 4 });
-
-    expect(unwrap(window).split('\n')).toEqual(rows.slice(2, 4));
-  });
-
-  test('renders an over-long line as plain text instead of tokenizing it', () => {
-    const minified = `const bundled = "${'x'.repeat(200)}";\nconst next = 1;`;
-    const window = highlightCodeWindow(minified, 'javascript', { start: 0, end: 2 }, { maxLineLength: 50 });
-
-    expect(window).toContain('const bundled');
-    expect(unwrap(window).split('\n')[0]).not.toContain('--shiki-light:');
-    expect(unwrap(window).split('\n')[1]).toContain('--shiki-light:');
-  });
-
-  test('returns nothing for a window outside the document', () => {
-    expect(highlightCodeWindow('const a = 1;', 'typescript', { start: 5, end: 9 })).toBe('');
-    expect(highlightCodeWindow('const a = 1;', 'typescript', { start: 0, end: 0 })).toBe('');
-  });
-});
-
 describe('find marks', () => {
   const code = 'const alpha = 1;\nconst beta = alpha + 2;\n';
   const PLAIN = { matchCase: false, wholeWord: false, isRegex: false };
@@ -206,35 +157,6 @@ describe('find marks', () => {
     expect(plain).not.toContain('<mark');
   });
 
-  test('keeps a windowed match on its own line, re-based to the slice', () => {
-    const marks = findMatches(code, 'alpha', PLAIN).matches;
-    // The window renders line 1 only. The match on line 0 must not reappear on
-    // line 1's text, and the current index (line 0's match) must not mark
-    // anything here.
-    const window = highlightCodeWindow(code, 'typescript', { start: 1, end: 2 }, { marks, currentMark: 0 });
-
-    expect(marked(window).join('')).toBe('alpha');
-    expect(window).not.toContain('data-find-current');
-  });
-
-  test('re-bases the current index onto the marks inside the window', () => {
-    const marks = findMatches(code, 'alpha', PLAIN).matches;
-    const window = highlightCodeWindow(code, 'typescript', { start: 1, end: 2 }, { marks, currentMark: 1 });
-
-    expect(window.match(/data-find-current/g)?.length).toBe(1);
-    expect(marked(window).join('')).toBe('alpha');
-  });
-
-  test('a mark reaching past the window is clipped to it', () => {
-    // The last line has no trailing newline, so a mark that runs to the end of
-    // the slice would be clamped by the rebase.
-    const window = highlightCodeWindow(code, 'typescript', { start: 1, end: 3 }, {
-      marks: [{ start: 30, end: 999 }],
-      currentMark: 0,
-    });
-
-    expect(marked(window).join('')).toBe('alpha + 2;');
-  });
 });
 
 describe('getLanguageFromPath', () => {

package/src/shared/lib/code/syntax-highlight.ts

@@ -168,12 +168,11 @@ export function highlightLines(
   const rawLines = code.split('\n');
   const marks = options.marks;
   const currentMark = options.currentMark ?? -1;
-  const occurrenceFrom = options.occurrenceFrom ?? -1;
   // A grammar that has not arrived yet, or a highlighter that failed to boot,
   // still gets the find marks: the widget's feedback must not depend on Shiki.
   const plain = (lineIndex: number): string => {
     if (!marks || marks.length === 0) return escapeCode(rawLines[lineIndex]);
-    return tokenMarkup(rawLines[lineIndex], lineStartOffset(code, lineIndex), marks, currentMark, occurrenceFrom);
+    return tokenMarkup(rawLines[lineIndex], lineStartOffset(code, lineIndex), marks, currentMark);
   };
   if (!code) return rawLines;
   const hl = getHighlighterSync();
@@ -191,7 +190,7 @@ export function highlightLines(
       let offset = lineStartOffset(code, lineIndex);
       return lineTokens
         .map((tok) => {
-          const content = tokenMarkup(tok.content, offset, marks, currentMark, occurrenceFrom);
+          const content = tokenMarkup(tok.content, offset, marks, currentMark);
           offset += tok.content.length;
           if (!tok.htmlStyle) return content;
           const style = Object.entries(tok.htmlStyle)