@kabmo-labs/kabmo 0.8.0 → 0.9.0

package/src/shared/lib/chat/timeline/omp-callbacks.test.ts

@@ -55,6 +55,8 @@ function makeCallbacks(overrides: Partial<OmpAgentCallbacksDeps> = {}): OmpAgent
     appSettings: {},
     enqueueExtensionDialog: () => {},
     withdrawExtensionDialog: () => {},
+    reloadMessages: () => {},
+    needsReloadRef: { current: false },
     ...overrides,
   };
   return createOmpAgentCallbacks(deps);
@@ -133,6 +135,40 @@ describe('createOmpAgentCallbacks run boundaries', () => {
     expect(verbs).toEqual(['Thinking']);
   });
 
+  test('a run that lost frames re-reads its transcript when it settles', () => {
+    // A reconnect while the run was STILL streaming cannot reload: its rows are
+    // the stream's, and replacing them mid-turn is the lagging-snapshot bug.
+    // But the segments that finished during the outage have no other way back —
+    // their `message_end` went into the dead socket, and `agent_end` only
+    // materializes turns that stopped abnormally. So the loss is remembered and
+    // the read happens at the settle.
+    const reads: number[] = [];
+    const needsReloadRef = { current: true };
+    const callbacks = recordingCallbacks({
+      reloadMessages: () => { reads.push(1); },
+      needsReloadRef,
+    });
+
+    callbacks.onAgentEnd?.({});
+
+    expect(reads.length).toBe(1);
+    // Consumed: a later run end must not re-read a transcript nothing lost.
+    expect(needsReloadRef.current).toBe(false);
+    callbacks.onAgentEnd?.({});
+    expect(reads.length).toBe(1);
+  });
+
+  test('an ordinary run end does NOT re-read the transcript', () => {
+    // The read is a full parse of the session JSONL; a run that never lost a
+    // frame must not pay it.
+    const reads: number[] = [];
+    const callbacks = recordingCallbacks({ reloadMessages: () => { reads.push(1); } });
+
+    callbacks.onAgentEnd?.({});
+
+    expect(reads).toEqual([]);
+  });
+
   test('a real omp frame sequence drives the boundary once per run', () => {
     const callbacks = recordingCallbacks();
     const deps = makeFoldDeps(callbacks);

package/src/shared/lib/chat/timeline/omp-callbacks.ts

@@ -51,6 +51,14 @@ export interface OmpAgentCallbacksDeps {
   enqueueExtensionDialog: (request: ExtensionUiDialogRequest) => void;
   /** Drop a queued request omp withdrew (`method: 'cancel'`). */
   withdrawExtensionDialog: (targetId: string) => void;
+  /** Re-read the committed transcript (see `lost-run.ts`). Used at `agent_end`
+   *  when frames were lost mid-run: the segments that finished during the
+   *  outage have no other way back. */
+  reloadMessages: () => void;
+  /** Set when a run lost frames while STILL STREAMING. Its earlier segments can
+   *  only be recovered by a full read, which is safe only once the run is over —
+   *  so the read happens here, at the settle. */
+  needsReloadRef: { current: boolean };
 }
 
 export function createOmpAgentCallbacks(deps: OmpAgentCallbacksDeps): OmpAgentCallbacks {
@@ -70,6 +78,8 @@ export function createOmpAgentCallbacks(deps: OmpAgentCallbacksDeps): OmpAgentCa
     appSettings,
     enqueueExtensionDialog,
     withdrawExtensionDialog,
+    reloadMessages,
+    needsReloadRef,
   } = deps;
 
   bindStreamingCoalescer(setLocalMessages, () => scrollToBottom('smooth'));
@@ -245,6 +255,14 @@ export function createOmpAgentCallbacks(deps: OmpAgentCallbacksDeps): OmpAgentCa
       // placeholder until the realtime scan surfaces the row.
       const sid = adoptedSessionIdRef.current ?? sessionIdRef.current;
       if (sid) refreshSessionMeta(sid);
+      // A run that lost frames while still streaming: its earlier segments (a
+      // tool card, a thinking block, an earlier answer) have no other way back.
+      // Read now — the run is over, so a full transcript read cannot clobber a
+      // live row — and `reloadMessages` retries while omp has not flushed.
+      if (needsReloadRef.current) {
+        needsReloadRef.current = false;
+        reloadMessages();
+      }
     },
     onModelChanged: () => {
       // omp's model_changed frame carries no payload — re-read the session

package/src/shared/lib/chat/timeline/run-signals.test.ts

@@ -56,6 +56,8 @@ function deps(overrides: Partial<OmpAgentCallbacksDeps> = {}): OmpAgentCallbacks
     appSettings: {},
     enqueueExtensionDialog: () => {},
     withdrawExtensionDialog: () => {},
+    reloadMessages: () => {},
+    needsReloadRef: { current: false },
     ...overrides,
   };
 }

package/src/shared/lib/code/editor/comment-syntax.test.ts

@@ -0,0 +1,37 @@
+/**
+ * @license
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/**
+ * The comment tokens `toggleComment` reads out of `languageData`.
+ *
+ * A wrong token is not a cosmetic bug: `//` inserted into YAML is a syntax
+ * error, and a `//` inserted into CSS comments out nothing while breaking the
+ * rule it was added to. The three shapes are asserted, plus the default that
+ * every C-family grammar relies on.
+ */
+
+import { describe, expect, test } from 'bun:test';
+
+import { commentSyntaxFor } from '@/shared/lib/code/editor/comment-syntax';
+
+describe('commentSyntaxFor', () => {
+  test('defaults to a line comment for the C-family', () => {
+    expect(commentSyntaxFor('typescript')).toEqual({ line: '//' });
+    expect(commentSyntaxFor('rust')).toEqual({ line: '//' });
+    expect(commentSyntaxFor('not-a-language')).toEqual({ line: '//' });
+  });
+
+  test('names the languages whose line comment is not `//`', () => {
+    expect(commentSyntaxFor('python')).toEqual({ line: '#' });
+    expect(commentSyntaxFor('yaml')).toEqual({ line: '#' });
+    expect(commentSyntaxFor('sql')).toEqual({ line: '--' });
+  });
+
+  test('wraps the languages that have only block comments', () => {
+    expect(commentSyntaxFor('css')).toEqual({ block: ['/*', '*/'] });
+    expect(commentSyntaxFor('html')).toEqual({ block: ['<!--', '-->'] });
+    expect(commentSyntaxFor('markdown')).toEqual({ block: ['<!--', '-->'] });
+  });
+});

package/src/shared/lib/code/editor/comment-syntax.ts

@@ -0,0 +1,55 @@
+/**
+ * @license
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/**
+ * How each language writes a line comment.
+ *
+ * The only thing the editor still needs from the old text-command layer:
+ * CodeMirror's `toggleComment` reads its tokens out of the `languageData` facet
+ * and needs no syntax tree, so this table IS the whole of the comment feature.
+ * Everything else the old module did (line moves, duplicates, deletes, inserts,
+ * indent, occurrences, edit replication) is a CM6 command now.
+ *
+ * The default is `//`, which is right for every C-family grammar. The exceptions
+ * are the ones a wrong token would visibly break — `#` in YAML is a syntax
+ * error, not a comment — and a language that has ONLY block comments gets the
+ * wrapper, because a `//` inserted into CSS comments out nothing and breaks the
+ * rule it was added to.
+ */
+
+/** A line-comment syntax: a prefix per line, or a wrapper for block-only languages. */
+export type CommentSyntax = { line: string } | { block: readonly [string, string] };
+
+const COMMENT_SYNTAX: Record<string, CommentSyntax> = {
+  python: { line: '#' },
+  bash: { line: '#' },
+  yaml: { line: '#' },
+  toml: { line: '#' },
+  ruby: { line: '#' },
+  perl: { line: '#' },
+  r: { line: '#' },
+  makefile: { line: '#' },
+  dockerfile: { line: '#' },
+  ini: { line: '#' },
+  properties: { line: '#' },
+  elixir: { line: '#' },
+  graphql: { line: '#' },
+  nix: { line: '#' },
+  sql: { line: '--' },
+  lua: { line: '--' },
+  haskell: { line: '--' },
+  css: { block: ['/*', '*/'] },
+  scss: { block: ['/*', '*/'] },
+  less: { block: ['/*', '*/'] },
+  sass: { block: ['/*', '*/'] },
+  stylus: { block: ['/*', '*/'] },
+  html: { block: ['<!--', '-->'] },
+  xml: { block: ['<!--', '-->'] },
+  markdown: { block: ['<!--', '-->'] },
+};
+
+export function commentSyntaxFor(language: string): CommentSyntax {
+  return COMMENT_SYNTAX[language] ?? { line: '//' };
+}

package/src/shared/lib/code/editor/find-replace.test.ts

@@ -0,0 +1,134 @@
+/**
+ * @license
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/**
+ * Replacement expansion: what one match becomes, and how a template is read.
+ *
+ * Each rule is asserted against the engine's own `String.replace` where one
+ * exists, because the search panel's replace PREVIEW and the write that lands
+ * must agree — a preview that painted `$1` over a file that would receive the
+ * captured group is exactly the drift this covers.
+ */
+
+import { describe, expect, test } from 'bun:test';
+
+import {
+  expandReplacement,
+  replaceAllMatches,
+  replaceMatch,
+} from '@/shared/lib/code/editor/find-replace';
+import type { FindOptions } from '@/shared/lib/code/editor/find-scan';
+import { findMatches } from '@/shared/lib/code/editor/find-scan';
+
+const PLAIN: FindOptions = { matchCase: false, wholeWord: false, isRegex: false };
+
+describe('replaceMatch', () => {
+  test('literal replacement inserts the field verbatim, dollar signs included', () => {
+    const text = 'const a = 1;';
+    const result = replaceMatch(text, { start: 6, end: 7 }, 'a', '$&x', PLAIN);
+    expect(result?.text).toBe('const $&x = 1;');
+    expect(result?.caret).toBe(6 + 3);
+  });
+
+  test('regex replacement expands capture groups like String.replace', () => {
+    const text = 'key = value';
+    const result = replaceMatch(text, { start: 6, end: 11 }, '(\\w+)', '[$1]', { ...PLAIN, isRegex: true });
+    expect(result?.text).toBe('key = [value]');
+    expect(result?.caret).toBe(13);
+  });
+
+  test('refuses a match that is no longer at its offset', () => {
+    expect(replaceMatch('abc', { start: 5, end: 7 }, 'a', 'z', PLAIN)).toBeNull();
+  });
+});
+
+describe('replaceAllMatches', () => {
+  test('literal replace-all rewrites every occurrence', () => {
+    expect(replaceAllMatches('a a a', 'a', 'b', PLAIN)).toBe('b b b');
+  });
+
+  test('regex replace-all agrees with the engine', () => {
+    const text = 'foo1 bar2';
+    const options: FindOptions = { ...PLAIN, isRegex: true };
+    expect(replaceAllMatches(text, '([a-z]+)(\\d)', '$2-$1', options)).toBe(text.replace(/([a-z]+)(\d)/g, '$2-$1'));
+  });
+
+  test('whole-word replace-all leaves substrings alone', () => {
+    expect(replaceAllMatches('cat category', 'cat', 'dog', { ...PLAIN, wholeWord: true })).toBe('dog category');
+  });
+
+  test('returns null for an unusable query', () => {
+    expect(replaceAllMatches('abc', '(', 'x', { ...PLAIN, isRegex: true })).toBeNull();
+    expect(replaceAllMatches('abc', '', 'x', PLAIN)).toBeNull();
+  });
+});
+
+/**
+ * The write path and the match list must be the SAME answer.
+ *
+ * They were not, and every case below was silent: the scan runs through
+ * CodeMirror's `RegExpCursor` (`gm` + `u`) while the replacement compiled the
+ * query itself (`g`/`gi`), so the count in the widget and the bytes written
+ * disagreed about anchors, unicode property escapes and which escapes are even
+ * legal. `find-scan.ts` now states the flags once (`BASE_FLAGS`), and these
+ * assert the two ends together rather than one engine in isolation.
+ */
+describe('the write path agrees with the scan', () => {
+  const REGEX: FindOptions = { ...PLAIN, isRegex: true };
+
+  test('an anchored pattern rewrites every line the scan counted', () => {
+    const text = 'foo\nbar\nfoo';
+    expect(findMatches(text, '^foo', REGEX).matches).toHaveLength(2);
+    expect(replaceAllMatches(text, '^foo', 'X', REGEX)).toBe('X\nbar\nX');
+
+    expect(findMatches(text, 'foo$', REGEX).matches).toHaveLength(2);
+    expect(replaceAllMatches(text, 'foo$', 'X', REGEX)).toBe('X\nbar\nX');
+  });
+
+  test('a unicode property escape finds AND replaces', () => {
+    const text = 'a1 b2';
+    expect(findMatches(text, '\\p{L}\\d', REGEX).matches).toHaveLength(2);
+    expect(replaceAllMatches(text, '\\p{L}\\d', 'X', REGEX)).toBe('X X');
+    expect(replaceMatch(text, { start: 0, end: 2 }, '\\p{L}\\d', 'X', REGEX)?.text).toBe('X b2');
+  });
+
+  test('an escape the scan calls invalid is refused by the write too', () => {
+    // `\-` is a legal identity escape without `u` and a syntax error with it.
+    expect(findMatches('a-b', '\\-', REGEX).invalid).toBe(true);
+    expect(replaceAllMatches('a-b', '\\-', 'X', REGEX)).toBeNull();
+  });
+
+  test('a zero-width match is replaced by nothing, exactly as it is uncounted', () => {
+    // The widget says "No results" for `^`; inserting at every line start under
+    // it was the write contradicting the count it was shown beside.
+    expect(findMatches('a\nb', '^', REGEX).matches).toEqual([]);
+    expect(replaceAllMatches('a\nb', '^', 'X', REGEX)).toBe('a\nb');
+    expect(replaceAllMatches('abc', 'x*', 'X', REGEX)).toBe('abc');
+  });
+});
+
+describe('expandReplacement', () => {
+  /** Indexed by group number, `[0]` unused — the shape `groupsOf` produces. */
+  const groups = { full: 'ab12', numbered: [undefined, 'a', 'b'] as const, named: { tail: '12' } };
+
+  test('expands $&, $1 and $<name>', () => {
+    expect(expandReplacement('$&|$1|$2|$<tail>', groups)).toBe('ab12|a|b|12');
+  });
+
+  test('$$ is a literal dollar and an unknown group is empty', () => {
+    expect(expandReplacement('$$$9', groups)).toBe('$');
+  });
+
+  test('a missing two-digit group falls back to the one-digit group plus the digit', () => {
+    // The engine's own reading of `$12` with two groups: `$1` then a literal `2`.
+    expect('x'.replace(/(x)/, '$12')).toBe('x2');
+    expect(expandReplacement('$12', groups)).toBe('a2');
+  });
+
+  test('a template without a dollar is returned as-is', () => {
+    expect(expandReplacement('plain', groups)).toBe('plain');
+  });
+});
+

package/src/shared/lib/code/editor/{find.ts → find-replace.ts}

@@ -3,117 +3,23 @@
  * SPDX-License-Identifier: Apache-2.0
  */
 
-import { lineIndexAt, lineStartOffset, type TextRange } from '@/shared/lib/code/editor/lines';
-
-export { lineIndexAt, lineStartOffset };
-
 /**
- * Find and replace over one document buffer — the pure half of the editor's
- * find widget.
+ * Replacement expansion, split from the scan.
  *
- * Everything here is offset arithmetic on a string: what the query compiles
- * to, which ranges match, where the caret lands after a replacement, and how
- * `$1` is expanded. The widget, the hook that owns its state and the editor
- * surface that paints the matches all read these results, so none of them
- * re-implements a rule and the count in the widget cannot disagree with the
- * ranges on screen.
- */
-
-export interface FindOptions {
-  matchCase: boolean;
-  wholeWord: boolean;
-  isRegex: boolean;
-}
-
-/** Half-open `[start, end)` offset range in the document. */
-export type FindMatch = TextRange;
-
-export interface FindResult {
-  matches: FindMatch[];
-  /** The document holds more matches than the cap; the list stops at it. */
-  truncated: boolean;
-  /** A regex query that does not compile — a different answer from "no matches". */
-  invalid: boolean;
-}
-
-/**
- * Ceiling on collected matches. A one-character query over a large file matches
- * tens of thousands of times and every match costs a Range in the highlight
- * registry, so past this the list stops and the widget reports `N+`.
- */
-export const MAX_FIND_MATCHES = 5_000;
-
-export const DEFAULT_FIND_OPTIONS: FindOptions = {
-  matchCase: false,
-  wholeWord: false,
-  isRegex: false,
-};
-
-/**
- * The pattern a query compiles to, or null when the query is empty or does not
- * compile. A literal query is escaped here rather than at the call site so the
- * match scan and the replacement splice can never disagree about what the
- * pattern was.
+ * The scan (`find-scan.ts`) answers "where does this query match"; this answers
+ * "what does one match become". They are separate because the search panel's
+ * replace PREVIEW and the write that actually lands must read ONE expansion
+ * rule — a row that painted `$1` literally over a file that would receive the
+ * captured group is the drift this module exists to prevent — while the scan has
+ * a different consumer (the find bar's match list and count).
  *
- * Whole-word is a `\b`-anchored non-capturing group rather than a bare wrap so
- * an alternation (`foo|bar`) keeps its own precedence.
+ * The template grammar is `String.prototype.replace`'s for a string replacement:
+ * `$$`, `$&`, `$1`–`$99` and `$<name>`. The prefix/suffix forms (`` $` `` /
+ * `$'`) are deliberately left literal — nothing in the UI offers them, and
+ * leaving the two characters alone is the honest reading.
  */
-export function buildFindRegex(query: string, options: FindOptions): RegExp | null {
-  if (!query) return null;
-  const source = options.isRegex ? query : query.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
-  const wrapped = options.wholeWord ? `\\b(?:${source})\\b` : source;
-  try {
-    return new RegExp(wrapped, options.matchCase ? 'g' : 'gi');
-  } catch {
-    return null;
-  }
-}
 
-/**
- * Every match of `query` in `text`, in document order.
- *
- * Zero-width matches (`^`, `\b`, `a*`) are skipped: they have nothing to
- * highlight and nothing to replace, and stepping past them is what keeps the
- * scan terminating.
- */
-export function findMatches(text: string, query: string, options: FindOptions): FindResult {
-  const regex = buildFindRegex(query, options);
-  if (!query) return { matches: [], truncated: false, invalid: false };
-  if (!regex) return { matches: [], truncated: false, invalid: true };
-
-  const matches: FindMatch[] = [];
-  let match: RegExpExecArray | null;
-  while ((match = regex.exec(text)) !== null) {
-    if (match[0].length === 0) {
-      regex.lastIndex += 1;
-      continue;
-    }
-    matches.push({ start: match.index, end: match.index + match[0].length });
-    if (matches.length >= MAX_FIND_MATCHES) return { matches, truncated: true, invalid: false };
-  }
-  return { matches, truncated: false, invalid: false };
-}
-
-/**
- * The match to call "current" for a caret/anchor at `offset`: the first one
- * that ends after it, so a caret sitting inside a match still counts as being
- * on that match. Wraps to the first match when the anchor is past the last one,
- * and reports -1 for an empty list.
- */
-export function matchIndexAtOrAfter(matches: readonly FindMatch[], offset: number): number {
-  if (matches.length === 0) return -1;
-  for (let index = 0; index < matches.length; index++) {
-    if (matches[index].end > offset) return index;
-  }
-  return 0;
-}
-
-/** Step one match forward (`1`) or back (`-1`), wrapping at either end. */
-export function stepMatchIndex(index: number, count: number, direction: 1 | -1): number {
-  if (count <= 0) return -1;
-  if (index < 0) return direction === 1 ? 0 : count - 1;
-  return (index + direction + count) % count;
-}
+import { buildFindRegex, type FindMatch, type FindOptions } from '@/shared/lib/code/editor/find-scan';
 
 /** What a replacement template is expanded against. */
 export interface MatchGroups {
@@ -210,7 +116,16 @@ export function replaceMatch(
   };
 }
 
-/** Replace every match. Null when the query is empty or does not compile. */
+/**
+ * Replace every match. Null when the query is empty or does not compile.
+ *
+ * A ZERO-WIDTH match is left alone, exactly as the scan leaves it out of the
+ * list: `^`, `$`, `\b` and `a*` have nothing to highlight and nothing to
+ * replace, so a `^` query reads "No results" in the widget — and rewriting every
+ * line start under it was the write disagreeing with the count it was shown
+ * next to. (A non-empty literal query can never match zero characters, so this
+ * only ever applies to regex mode.)
+ */
 export function replaceAllMatches(
   text: string,
   query: string,
@@ -221,6 +136,7 @@ export function replaceAllMatches(
   if (!regex) return null;
   if (!options.isRegex) return text.replace(regex, () => replacement);
   return text.replace(regex, (...args: unknown[]) => {
+    if (String(args[0]).length === 0) return '';
     // A replacer's arguments are `(match, …groups, offset, string, groups?)`;
     // rebuilding an exec result from them keeps one expansion rule for both
     // the single and the bulk path.

package/src/shared/lib/code/editor/{find.test.ts → find-scan.test.ts}

@@ -4,28 +4,27 @@
  */
 
 /**
- * The find widget's arithmetic: what a query matches, where the caret lands
- * after a replacement, and how `$1` is expanded. These are the rules the widget
- * count, the on-screen highlights and the written buffer all read, so each is
- * asserted against the engine's own `String.replace` behaviour where one
- * exists.
+ * The find widget's scan: what a query matches and how the caret anchors to it.
+ *
+ * The scan runs on CodeMirror's `RegExpCursor`, so these cases are the CONTRACT
+ * that cursor has to keep — the same ordered list, the same case/whole-word/regex
+ * options, a broken pattern reported as `invalid` rather than as "no matches",
+ * and the cap. They are asserted here rather than through a live editor because
+ * the widget, the count and the painted marks all read this one function.
  */
 
 import { describe, expect, test } from 'bun:test';
 
 import {
   buildFindRegex,
-  expandReplacement,
   findMatches,
   lineIndexAt,
   lineStartOffset,
   matchIndexAtOrAfter,
   MAX_FIND_MATCHES,
-  replaceAllMatches,
-  replaceMatch,
   stepMatchIndex,
   type FindOptions,
-} from '@/shared/lib/code/editor/find';
+} from '@/shared/lib/code/editor/find-scan';
 
 const PLAIN: FindOptions = { matchCase: false, wholeWord: false, isRegex: false };
 
@@ -83,6 +82,17 @@ describe('findMatches', () => {
     expect(result.invalid).toBe(false);
   });
 
+  test('finds a match that begins at a line start, and one that spans lines', () => {
+    // The cursor searches line by line, so both edges are where it can lose a
+    // match: a pattern anchored at a line start, and one whose `\n` forces the
+    // whole-document path.
+    expect(findMatches('one\ntwo\ntwo', 'two', PLAIN).matches).toEqual([
+      { start: 4, end: 7 },
+      { start: 8, end: 11 },
+    ]);
+    expect(findMatches('one\ntwo', 'one\ntwo', { ...PLAIN, isRegex: true }).matches).toEqual([{ start: 0, end: 7 }]);
+  });
+
   test('caps the collected matches and says so', () => {
     const text = 'a'.repeat(MAX_FIND_MATCHES + 10);
     const result = findMatches(text, 'a', PLAIN);
@@ -104,70 +114,6 @@ describe('buildFindRegex', () => {
   });
 });
 
-describe('replaceMatch', () => {
-  test('literal replacement inserts the field verbatim, dollar signs included', () => {
-    const text = 'const a = 1;';
-    const result = replaceMatch(text, { start: 6, end: 7 }, 'a', '$&x', PLAIN);
-    expect(result?.text).toBe('const $&x = 1;');
-    expect(result?.caret).toBe(6 + 3);
-  });
-
-  test('regex replacement expands capture groups like String.replace', () => {
-    const text = 'key = value';
-    const result = replaceMatch(text, { start: 6, end: 11 }, '(\\w+)', '[$1]', { ...PLAIN, isRegex: true });
-    expect(result?.text).toBe('key = [value]');
-    expect(result?.caret).toBe(13);
-  });
-
-  test('refuses a match that is no longer at its offset', () => {
-    expect(replaceMatch('abc', { start: 5, end: 7 }, 'a', 'z', PLAIN)).toBeNull();
-  });
-});
-
-describe('replaceAllMatches', () => {
-  test('literal replace-all rewrites every occurrence', () => {
-    expect(replaceAllMatches('a a a', 'a', 'b', PLAIN)).toBe('b b b');
-  });
-
-  test('regex replace-all agrees with the engine', () => {
-    const text = 'foo1 bar2';
-    const options: FindOptions = { ...PLAIN, isRegex: true };
-    expect(replaceAllMatches(text, '([a-z]+)(\\d)', '$2-$1', options)).toBe(text.replace(/([a-z]+)(\d)/g, '$2-$1'));
-  });
-
-  test('whole-word replace-all leaves substrings alone', () => {
-    expect(replaceAllMatches('cat category', 'cat', 'dog', { ...PLAIN, wholeWord: true })).toBe('dog category');
-  });
-
-  test('returns null for an unusable query', () => {
-    expect(replaceAllMatches('abc', '(', 'x', { ...PLAIN, isRegex: true })).toBeNull();
-    expect(replaceAllMatches('abc', '', 'x', PLAIN)).toBeNull();
-  });
-});
-
-describe('expandReplacement', () => {
-  /** Indexed by group number, `[0]` unused — the shape `groupsOf` produces. */
-  const groups = { full: 'ab12', numbered: [undefined, 'a', 'b'] as const, named: { tail: '12' } };
-
-  test('expands $&, $1 and $<name>', () => {
-    expect(expandReplacement('$&|$1|$2|$<tail>', groups)).toBe('ab12|a|b|12');
-  });
-
-  test('$$ is a literal dollar and an unknown group is empty', () => {
-    expect(expandReplacement('$$$9', groups)).toBe('$');
-  });
-
-  test('a missing two-digit group falls back to the one-digit group plus the digit', () => {
-    // The engine's own reading of `$12` with two groups: `$1` then a literal `2`.
-    expect('x'.replace(/(x)/, '$12')).toBe('x2');
-    expect(expandReplacement('$12', groups)).toBe('a2');
-  });
-
-  test('a template without a dollar is returned as-is', () => {
-    expect(expandReplacement('plain', groups)).toBe('plain');
-  });
-});
-
 describe('caret anchoring', () => {
   test('lineIndexAt and lineStartOffset are inverses for every line start', () => {
     const text = 'one\ntwo\n\nfour';