@cueloop/schema 0.1.0-alpha.6 → 0.1.0-alpha.61

package/package.json

@@ -1,7 +1,21 @@
 {
   "name": "@cueloop/schema",
-  "version": "0.1.0-alpha.6",
+  "version": "0.1.0-alpha.61",
+  "description": "The ReviewSession primitive: types, markdown block model, quote-primary anchors, feedback serialization",
+  "homepage": "https://github.com/mmurakaru/cueloop#readme",
+  "bugs": {
+    "url": "https://github.com/mmurakaru/cueloop/issues"
+  },
   "license": "Apache-2.0",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/mmurakaru/cueloop.git",
+    "directory": "packages/schema"
+  },
+  "files": [
+    "src",
+    "README.md"
+  ],
   "type": "module",
   "exports": {
     ".": "./src/index.ts"
@@ -9,21 +23,7 @@
   "publishConfig": {
     "access": "public"
   },
-  "files": [
-    "src",
-    "README.md"
-  ],
   "engines": {
     "bun": ">=1.3.0"
-  },
-  "repository": {
-    "type": "git",
-    "url": "git+https://github.com/mmurakaru/cueloop.git",
-    "directory": "packages/schema"
-  },
-  "homepage": "https://github.com/mmurakaru/cueloop#readme",
-  "bugs": {
-    "url": "https://github.com/mmurakaru/cueloop/issues"
-  },
-  "description": "The ReviewSession primitive: types, markdown block model, quote-primary anchors, feedback serialization"
-}
+  }
+}

package/src/anchor.test.ts

@@ -15,80 +15,195 @@ Sessions are written as one JSON document per session. Sessions are written
 atomically.
 `;
 
-function blocksOf(md: string) {
-  return parseBlocks(md);
+function blocksOf(markdown: string) {
+  return parseBlocks(markdown);
 }
 
 describe("anchor cascade", () => {
   test("makeAnchor captures quote + context selectors", () => {
+    // Arrange
     const blocks = blocksOf(DOC);
-    const ctxIdx = blocks.findIndex((b) => b.text.startsWith("Review sessions"));
-    const a = makeAnchor(blocks, ctxIdx, 0, 15); // "Review sessions"
-    expect(a.quote).toBe("Review sessions");
-    expect(a.prefix).toBe("");
-    expect(a.suffix.startsWith(" currently")).toBe(true);
+    const contextBlockIndex = blocks.findIndex((block) => block.text.startsWith("Review sessions"));
+
+    // Act
+    const anchor = makeAnchor(blocks, contextBlockIndex, 0, 15); // "Review sessions"
+
+    // Assert
+    expect(anchor.quote).toBe("Review sessions");
+    expect(anchor.prefix).toBe("");
+    expect(anchor.suffix.startsWith(" currently")).toBe(true);
   });
 
   test("resolves at the recorded position when unchanged", () => {
+    // Arrange
     const blocks = blocksOf(DOC);
-    const ctxIdx = blocks.findIndex((b) => b.text.startsWith("Review sessions"));
-    const a = makeAnchor(blocks, ctxIdx, 7, 15); // "sessions"
-    const r = resolveAnchor(a, blocks)!;
-    expect(r.blockIndex).toBe(ctxIdx);
-    expect(r.start).toBe(7);
-    expect(r.approximate).toBe(false);
+    const contextBlockIndex = blocks.findIndex((block) => block.text.startsWith("Review sessions"));
+    const anchor = makeAnchor(blocks, contextBlockIndex, 7, 15); // "sessions"
+
+    // Act
+    const resolved = resolveAnchor(anchor, blocks)!;
+
+    // Assert
+    expect(resolved.blockIndex).toBe(contextBlockIndex);
+    expect(resolved.start).toBe(7);
+    expect(resolved.approximate).toBe(false);
   });
 
   test("survives text changes before the quote (quote search)", () => {
+    // Arrange
     const blocks = blocksOf(DOC);
-    const ctxIdx = blocks.findIndex((b) => b.text.startsWith("Review sessions"));
-    const a = makeAnchor(blocks, ctxIdx, 0, 15);
-    const edited = blocksOf(DOC.replace("Review sessions currently", "PREFIX. Review sessions now"));
-    const r = resolveAnchor(a, edited)!;
-    const idx = edited.findIndex((b) => b.text.includes("Review sessions"));
-    expect(r.blockIndex).toBe(idx);
-    expect(edited[r.blockIndex]!.text.slice(r.start, r.end)).toBe("Review sessions");
+    const contextBlockIndex = blocks.findIndex((block) => block.text.startsWith("Review sessions"));
+    const anchor = makeAnchor(blocks, contextBlockIndex, 0, 15);
+    const edited = blocksOf(
+      DOC.replace("Review sessions currently", "PREFIX. Review sessions now"),
+    );
+
+    // Act
+    const resolved = resolveAnchor(anchor, edited)!;
+
+    // Assert
+    const editedBlockIndex = edited.findIndex((block) => block.text.includes("Review sessions"));
+
+    expect(resolved.blockIndex).toBe(editedBlockIndex);
+    expect(edited[resolved.blockIndex]!.text.slice(resolved.start, resolved.end)).toBe(
+      "Review sessions",
+    );
   });
 
   test("prefix/suffix selectors disambiguate repeated quotes", () => {
+    // Arrange
     const blocks = blocksOf(DOC);
-    const storIdx = blocks.findIndex((b) => b.text.includes("atomically"));
+    const storageBlockIndex = blocks.findIndex((block) => block.text.includes("atomically"));
     // anchor on the SECOND "Sessions are written" occurrence
-    const text = blocks[storIdx]!.text;
+    const text = blocks[storageBlockIndex]!.text;
     const second = text.indexOf("Sessions are written", text.indexOf("Sessions are written") + 1);
-    const a = makeAnchor(blocks, storIdx, second, second + "Sessions are written".length);
-    const r = resolveAnchor(a, blocks)!;
-    expect(r.start).toBe(second);
+    const anchor = makeAnchor(
+      blocks,
+      storageBlockIndex,
+      second,
+      second + "Sessions are written".length,
+    );
+
+    // Act
+    const resolved = resolveAnchor(anchor, blocks)!;
+
+    // Assert
+    expect(resolved.start).toBe(second);
   });
 
   test("position hint breaks ties when context also repeats", () => {
-    const md = "word word word";
-    const blocks = blocksOf(md);
-    const a = makeAnchor(blocks, 0, 5, 9); // middle "word"
-    const r = resolveAnchor(a, blocks)!;
-    expect(r.start).toBe(5);
+    // Arrange
+    const repeatedWords = "word word word";
+    const blocks = blocksOf(repeatedWords);
+    const anchor = makeAnchor(blocks, 0, 5, 9); // middle "word"
+
+    // Act
+    const resolved = resolveAnchor(anchor, blocks)!;
+
+    // Assert
+    expect(resolved.start).toBe(5);
+  });
+
+  test("binds a quote that still carries its leading list marker", () => {
+    // Arrange
+    // an agent copied the source line verbatim, including the "- " bullet, but
+    // the parsed list block strips the marker from its text
+    const blocks = blocksOf("## Notes\n\n- This is a dummy plan - confirm the item");
+    const anchor = { quote: "- This is a dummy plan", prefix: "", suffix: "" };
+
+    // Act
+    const resolved = resolveAnchor(anchor, blocks)!;
+
+    // Assert
+    expect(resolved).not.toBeNull();
+    expect(resolved.strategy).toBe("normalized");
+    expect(blocks[resolved.blockIndex]!.text.slice(resolved.start, resolved.end)).toBe(
+      "This is a dummy plan",
+    );
+  });
+
+  test("binds a heading quote that still carries its leading hashes", () => {
+    // Arrange
+    const blocks = blocksOf(DOC);
+    const anchor = { quote: "## Storage", prefix: "", suffix: "" };
+
+    // Act
+    const resolved = resolveAnchor(anchor, blocks)!;
+
+    // Assert
+    expect(resolved.strategy).toBe("normalized");
+    expect(blocks[resolved.blockIndex]!.text).toBe("Storage");
+  });
+
+  test("fuzzy tier binds a lightly edited quote", () => {
+    // Arrange
+    const blocks = blocksOf(DOC);
+    const contextBlockIndex = blocks.findIndex((block) => block.text.startsWith("Review sessions"));
+    // a typo the reviewer never saw: "sesssions"
+    const anchor = { quote: "Review sesssions currently live", prefix: "", suffix: "" };
+
+    // Act
+    const resolved = resolveAnchor(anchor, blocks)!;
+
+    // Assert
+    expect(resolved.strategy).toBe("fuzzy");
+    expect(resolved.blockIndex).toBe(contextBlockIndex);
+    expect(resolved.approximate).toBe(true);
+  });
+
+  test("exact matches report the exact strategy", () => {
+    // Arrange
+    const blocks = blocksOf(DOC);
+    const contextBlockIndex = blocks.findIndex((block) => block.text.startsWith("Review sessions"));
+    const anchor = makeAnchor(blocks, contextBlockIndex, 0, 15);
+
+    // Act
+    const resolved = resolveAnchor(anchor, blocks)!;
+
+    // Assert
+    expect(resolved.strategy).toBe("exact");
+    expect(resolved.approximate).toBe(false);
   });
 
   test("trimmed-quote fallback marks the resolution approximate", () => {
-    const blocks = blocksOf("some text here");
-    const a = { quote: " text ", prefix: "some", suffix: "here", blockIndex: 0, start: 4, end: 10 };
+    // Arrange
+    const anchor = {
+      quote: " text ",
+      prefix: "some",
+      suffix: "here",
+      blockIndex: 0,
+      start: 4,
+      end: 10,
+    };
     const edited = blocksOf("some\ntext\nhere");
     // " text " (with spaces) is gone, "text" survives
-    const r = resolveAnchor(a, edited);
-    expect(r).not.toBeNull();
-    expect(r!.approximate).toBe(true);
+
+    // Act
+    const resolved = resolveAnchor(anchor, edited);
+
+    // Assert
+    expect(resolved).not.toBeNull();
+    expect(resolved!.approximate).toBe(true);
   });
 
   test("orphans when the quote is gone entirely", () => {
+    // Arrange
     const blocks = blocksOf(DOC);
-    const ctxIdx = blocks.findIndex((b) => b.text.startsWith("Review sessions"));
-    const a = makeAnchor(blocks, ctxIdx, 0, 15);
-    const edited = blocksOf(DOC.replace(/Review sessions[^\n]*\n[^\n]*/, "Completely different text."));
-    expect(resolveAnchor(a, edited)).toBeNull();
+    const contextBlockIndex = blocks.findIndex((block) => block.text.startsWith("Review sessions"));
+    const anchor = makeAnchor(blocks, contextBlockIndex, 0, 15);
+    const edited = blocksOf(
+      DOC.replace(/Review sessions[^\n]*\n[^\n]*/, "Completely different text."),
+    );
+
+    // Assert
+    expect(resolveAnchor(anchor, edited)).toBeNull();
   });
 
   test("empty quote never binds", () => {
+    // Arrange
     const blocks = blocksOf(DOC);
+
+    // Assert
     expect(resolveAnchor({ quote: "", prefix: "", suffix: "" }, blocks)).toBeNull();
   });
 });

package/src/anchor.ts

@@ -1,74 +1,193 @@
 /**
- * Anchor resolution: the quote-primary cascade (map #2, #22, verified in the
- * edit-mode deep-dive). Anchors resolve against the current block list:
- *   1. exact quote in a block (prefix/suffix selectors break ties,
- *      position hint breaks remaining ties)
- *   2. trimmed quote
- *   3. orphan - keep the quote for display, drop the highlight.
- * Never silently bind to the wrong text.
+ * Anchor resolution: the quote-primary cascade. Anchors resolve against the
+ * current block list, each tier tried only when the one above it misses:
+ *   1. exact      - the quote appears verbatim in a block
+ *   2. trimmed    - the quote appears once surrounding whitespace is dropped
+ *   3. normalized - the quote appears once a leading markdown block marker
+ *                   (bullet, heading, ordered, quote) is stripped, matching how
+ *                   the parser strips block text
+ *   4. fuzzy      - the quote was lightly edited but is still recognizably there
+ *   5. orphan     - none matched; keep the quote for display, drop the highlight
+ * Prefix/suffix selectors and the recorded position break ties within a tier.
+ * Never silently bind to the wrong text: fuzzy needs a high similarity floor.
  */
 
 import type { Anchor } from "./types";
-import type { Block } from "./markdown";
+import { type Block, stripLeadingBlockMarker } from "./markdown";
+import { fuzzyFindBestMatch } from "./fuzzy";
 
-const CONTEXT = 24;
+/** Characters of surrounding text captured as prefix/suffix selectors. */
+const ANCHOR_CONTEXT_CHARS = 24;
+
+/** Minimum similarity a fuzzy match needs before the resolver will trust it. */
+const FUZZY_MINIMUM_SIMILARITY = 0.75;
+
+/** How the quote bound to the block text, weakest binding named last. */
+export type AnchorMatchStrategy = "exact" | "trimmed" | "normalized" | "fuzzy";
 
 export interface ResolvedAnchor {
   blockIndex: number;
   start: number;
   end: number;
-  /** True when the quote had to be trimmed to bind. */
+  /** True whenever the binding was not an exact quote match. */
   approximate: boolean;
+  /** Which cascade tier bound the quote. */
+  strategy: AnchorMatchStrategy;
 }
 
-export function makeAnchor(blocks: Block[], blockIndex: number, start: number, end: number): Anchor {
-  const t = blocks[blockIndex]?.text ?? "";
+export function makeAnchor(
+  blocks: Block[],
+  blockIndex: number,
+  start: number,
+  end: number,
+): Anchor {
+  const blockText = blocks[blockIndex]?.text ?? "";
+
   return {
-    quote: t.slice(start, end),
-    prefix: t.slice(Math.max(0, start - CONTEXT), start),
-    suffix: t.slice(end, end + CONTEXT),
+    quote: blockText.slice(start, end),
+    prefix: blockText.slice(Math.max(0, start - ANCHOR_CONTEXT_CHARS), start),
+    suffix: blockText.slice(end, end + ANCHOR_CONTEXT_CHARS),
     blockIndex,
     start,
     end,
   };
 }
 
-interface Candidate extends ResolvedAnchor {
+interface Candidate {
+  blockIndex: number;
+  start: number;
+  end: number;
   score: number;
 }
 
-function findCandidates(anchor: Anchor, blocks: Block[], quote: string): Candidate[] {
-  const out: Candidate[] = [];
-  blocks.forEach((b, blockIndex) => {
-    const text = b.text;
-    for (let i = text.indexOf(quote); i !== -1; i = text.indexOf(quote, i + 1)) {
-      const pre = text.slice(Math.max(0, i - CONTEXT), i);
-      const suf = text.slice(i + quote.length, i + quote.length + CONTEXT);
-      let score = 0;
-      if (pre === anchor.prefix) score += 2;
-      if (suf === anchor.suffix) score += 2;
-      if (anchor.blockIndex === blockIndex) score += 1;
-      if (anchor.blockIndex === blockIndex && anchor.start === i) score += 1;
-      out.push({ blockIndex, start: i, end: i + quote.length, approximate: false, score });
+/** Score a candidate window by how well its context and position agree. */
+function contextScore(
+  anchor: Anchor,
+  blockIndex: number,
+  block: Block,
+  start: number,
+  end: number,
+): number {
+  const prefix = block.text.slice(Math.max(0, start - ANCHOR_CONTEXT_CHARS), start);
+  const suffix = block.text.slice(end, end + ANCHOR_CONTEXT_CHARS);
+  let score = 0;
+
+  if (prefix === anchor.prefix) score += 2;
+  if (suffix === anchor.suffix) score += 2;
+  if (anchor.blockIndex === blockIndex) score += 1;
+  if (anchor.blockIndex === blockIndex && anchor.start === start) score += 1;
+
+  return score;
+}
+
+/** Every verbatim occurrence of `quote` across the blocks, scored by context. */
+function findExactCandidates(anchor: Anchor, blocks: Block[], quote: string): Candidate[] {
+  const candidates: Candidate[] = [];
+
+  blocks.forEach((block, blockIndex) => {
+    const text = block.text;
+
+    for (
+      let matchStart = text.indexOf(quote);
+      matchStart !== -1;
+      matchStart = text.indexOf(quote, matchStart + 1)
+    ) {
+      const matchEnd = matchStart + quote.length;
+
+      candidates.push({
+        blockIndex,
+        start: matchStart,
+        end: matchEnd,
+        score: contextScore(anchor, blockIndex, block, matchStart, matchEnd),
+      });
     }
   });
-  return out;
+
+  return candidates;
+}
+
+/**
+ * How much a full context agreement (0-6) may nudge the fuzzy ranking. Kept far
+ * below any real similarity gap so text quality always leads and context only
+ * breaks near-ties - a stale position hint must never pull the anchor onto a
+ * meaningfully less-similar passage.
+ */
+const FUZZY_CONTEXT_TIE_BREAK = 0.01;
+
+/** The best fuzzy window per block, ranked by similarity with context as a tiebreak. */
+function findFuzzyCandidates(
+  anchor: Anchor,
+  blocks: Block[],
+  needle: string,
+  minimumSimilarity: number,
+): Candidate[] {
+  const candidates: Candidate[] = [];
+
+  blocks.forEach((block, blockIndex) => {
+    const match = fuzzyFindBestMatch(needle, block.text, minimumSimilarity);
+
+    if (match === null) return;
+    const score =
+      match.similarity +
+      contextScore(anchor, blockIndex, block, match.start, match.end) * FUZZY_CONTEXT_TIE_BREAK;
+
+    candidates.push({ blockIndex, start: match.start, end: match.end, score });
+  });
+
+  return candidates;
+}
+
+/** Highest-scoring candidate, or null when there are none. */
+function pickBest(candidates: Candidate[]): Candidate | null {
+  if (candidates.length === 0) return null;
+  candidates.sort((left, right) => right.score - left.score);
+
+  return candidates[0]!;
+}
+
+function resolved(candidate: Candidate, strategy: AnchorMatchStrategy): ResolvedAnchor {
+  return {
+    blockIndex: candidate.blockIndex,
+    start: candidate.start,
+    end: candidate.end,
+    approximate: strategy !== "exact",
+    strategy,
+  };
 }
 
 /** Resolve an anchor against the current blocks, or null when orphaned. */
 export function resolveAnchor(anchor: Anchor, blocks: Block[]): ResolvedAnchor | null {
   if (anchor.quote === "") return null;
-  let candidates = findCandidates(anchor, blocks, anchor.quote);
-  let approximate = false;
-  if (candidates.length === 0) {
-    const trimmed = anchor.quote.trim();
-    if (trimmed !== "" && trimmed !== anchor.quote) {
-      candidates = findCandidates(anchor, blocks, trimmed);
-      approximate = true;
-    }
+
+  const exact = pickBest(findExactCandidates(anchor, blocks, anchor.quote));
+
+  if (exact) return resolved(exact, "exact");
+
+  const trimmedQuote = anchor.quote.trim();
+
+  if (trimmedQuote !== "" && trimmedQuote !== anchor.quote) {
+    const trimmed = pickBest(findExactCandidates(anchor, blocks, trimmedQuote));
+
+    if (trimmed) return resolved(trimmed, "trimmed");
   }
-  if (candidates.length === 0) return null;
-  candidates.sort((a, b) => b.score - a.score);
-  const best = candidates[0]!;
-  return { ...best, approximate };
+
+  const normalizedQuote = stripLeadingBlockMarker(anchor.quote).trim();
+
+  if (normalizedQuote !== "" && normalizedQuote !== trimmedQuote) {
+    const normalized = pickBest(findExactCandidates(anchor, blocks, normalizedQuote));
+
+    if (normalized) return resolved(normalized, "normalized");
+  }
+
+  const fuzzyNeedle = normalizedQuote !== "" ? normalizedQuote : trimmedQuote;
+
+  if (fuzzyNeedle !== "") {
+    const fuzzy = pickBest(
+      findFuzzyCandidates(anchor, blocks, fuzzyNeedle, FUZZY_MINIMUM_SIMILARITY),
+    );
+
+    if (fuzzy) return resolved(fuzzy, "fuzzy");
+  }
+
+  return null;
 }

package/src/diff.test.ts

@@ -1,5 +1,5 @@
 import { describe, expect, test } from "bun:test";
-import { lcsDiff, unifiedDiff, unifiedDiffText, editStats, wordDiff } from "./diff";
+import { lcsDiff, unifiedDiff, unifiedDiffText, editStats } from "./diff";
 
 describe("unifiedDiff", () => {
   test("equal inputs return null, not an empty diff", () => {
@@ -7,12 +7,17 @@ describe("unifiedDiff", () => {
   });
 
   test("produces hunk headers with correct line numbers", () => {
+    // Arrange
     const oldText = ["l1", "l2", "l3", "l4", "l5", "l6", "l7", "l8"].join("\n");
     const newText = ["l1", "l2", "l3", "CHANGED", "l5", "l6", "l7", "l8"].join("\n");
-    const d = unifiedDiff(oldText, newText, 1)!;
-    expect(d[0]!.t).toBe("hunk");
-    expect(d[0]!.text).toBe("@@ -3,3 +3,3 @@");
-    expect(d.map((l) => l.text)).toEqual([
+
+    // Act
+    const diffLines = unifiedDiff(oldText, newText, 1)!;
+
+    // Assert
+    expect(diffLines[0]!.kind).toBe("hunk");
+    expect(diffLines[0]!.text).toBe("@@ -3,3 +3,3 @@");
+    expect(diffLines.map((line) => line.text)).toEqual([
       "@@ -3,3 +3,3 @@",
       " l3",
       "-l4",
@@ -22,29 +27,44 @@ describe("unifiedDiff", () => {
   });
 
   test("distant changes split into separate hunks", () => {
+    // Arrange
     const oldLines = Array.from({ length: 30 }, (_, i) => `line ${i + 1}`);
     const newLines = [...oldLines];
+
     newLines[1] = "first change";
     newLines[27] = "second change";
-    const d = unifiedDiff(oldLines.join("\n"), newLines.join("\n"), 2)!;
-    expect(d.filter((l) => l.t === "hunk").length).toBe(2);
+
+    // Act
+    const diffLines = unifiedDiff(oldLines.join("\n"), newLines.join("\n"), 2)!;
+
+    // Assert
+    expect(diffLines.filter((line) => line.kind === "hunk").length).toBe(2);
   });
 
   test("applies cleanly: reconstructing new text from old + diff", () => {
+    // Arrange
     const oldText = "keep\ndrop\nkeep2\nkeep3";
     const newText = "keep\nadded\nkeep2\nkeep3\ntail";
-    const d = unifiedDiff(oldText, newText, 50)!;
+
+    // Act
+    const diffLines = unifiedDiff(oldText, newText, 50)!;
+
+    // Assert
     const rebuilt: string[] = [];
-    for (const l of d) {
-      if (l.t === "hunk") continue;
-      if (l.t === "ctx" || l.t === "add") rebuilt.push(l.text.slice(1));
+
+    for (const line of diffLines) {
+      if (line.kind === "hunk") continue;
+      if (line.kind === "ctx" || line.kind === "add") rebuilt.push(line.text.slice(1));
     }
     expect(rebuilt.join("\n")).toBe(newText);
   });
 
   test("unifiedDiffText carries file headers and path", () => {
-    const t = unifiedDiffText("a", "b", "docs/plan.md")!;
-    expect(t.startsWith("--- a/docs/plan.md\n+++ b/docs/plan.md\n@@")).toBe(true);
+    // Act
+    const diffText = unifiedDiffText("a", "b", "docs/plan.md")!;
+
+    // Assert
+    expect(diffText.startsWith("--- a/docs/plan.md\n+++ b/docs/plan.md\n@@")).toBe(true);
   });
 });
 
@@ -54,19 +74,16 @@ describe("editStats", () => {
   });
 });
 
-describe("wordDiff", () => {
-  test("preserves whitespace tokens and reconstructs both sides", () => {
-    const ops = wordDiff("the quick brown fox", "the slow brown foxes");
-    const oldSide = ops.filter((o) => o.t !== "add").map((o) => o.a).join("");
-    const newSide = ops.filter((o) => o.t !== "del").map((o) => o.b).join("");
-    expect(oldSide).toBe("the quick brown fox");
-    expect(newSide).toBe("the slow brown foxes");
-  });
-});
-
 describe("lcsDiff", () => {
   test("custom equality", () => {
-    const ops = lcsDiff([{ v: 1 }, { v: 2 }], [{ v: 2 }, { v: 3 }], (x, y) => x.v === y.v);
-    expect(ops.map((o) => o.t)).toEqual(["del", "ctx", "add"]);
+    // Act
+    const ops = lcsDiff(
+      [{ v: 1 }, { v: 2 }],
+      [{ v: 2 }, { v: 3 }],
+      (oldItem, newItem) => oldItem.v === newItem.v,
+    );
+
+    // Assert
+    expect(ops.map((op) => op.kind)).toEqual(["del", "ctx", "add"]);
   });
 });