@createiq/htmldiff 1.2.0-beta.0 → 1.2.0-beta.10

package/src/ThreeWayTable.ts

@@ -1,4 +1,4 @@
-import { lcsAlign, textSimilarity } from './Alignment'
+import { type Alignment, lcsAlign, pairSimilarUnmatched, textSimilarity } from './Alignment'
 import { injectClass, parseOpeningTagAt } from './HtmlScanner'
 import {
   type CellRange,
@@ -8,6 +8,7 @@ import {
   PLACEHOLDER_SUFFIX,
   type RowRange,
   rowKey,
+  rowText,
   sameDimensions,
   spliceString,
   type TableRange,
@@ -16,675 +17,735 @@ import { type Author, authorAttribution } from './ThreeWayDiff'
 import Utils from './Utils'
 
 /**
- * Three-way table preprocessing. Same shape as the existing two-way
- * `preprocessTables` but takes V1/V2/V3 and a cell-level three-way diff
- * callback. All three inputs share a single placeholder nonce so V2's
- * tokenisation is identical when the word-level 3-way merger sees it
- * from both pair-wise analyses.
+ * Three-way table preprocessing for the genesis-spine merge.
  *
- * This commit handles only the same-dimensions positional case across
- * all three table triples. The structural-change case (rows/cells
- * differ between any pair) throws; the next commit replaces that with
- * a row-level V2-spine merge that mirrors the word-level approach.
- * Multi-table count divergence (CP added or Me removed a whole table)
- * is handled in commit 6 (D3).
+ * Inputs: `genesis` (common ancestor), `cpLatest` (counterparty's
+ * accumulated position), `meCurrent` (Me's accumulated position). All
+ * three share a single placeholder nonce so genesis tokenises
+ * identically across both pair-wise word-level analyses.
+ *
+ * Three paths:
+ * 1. **Positional** — all three have the same table count AND each
+ *    positional triple's tableKey is similar enough that 1:1 pairing
+ *    by position is sound. Recurses cellDiff per cell, structural
+ *    layout from genesis.
+ * 2. **Row-structural** — paired triples whose row/cell counts differ.
+ *    Per-table row-level LCS against genesis; recurse on preserved
+ *    rows, emit author-attributed full rows for the rest.
+ * 3. **Multi-table by content** — table counts diverge across inputs.
+ *    Pair tables to genesis via content-LCS, then assign placeholders
+ *    such that each placeholder appears in exactly the inputs that
+ *    contain the underlying table. The word-level merger walks the
+ *    genesis spine and attributes unpaired tables naturally
+ *    (cp-only/me-only/both-agree).
  */
 
 export interface ThreeWayPreprocessResult {
-  modifiedV1: string
-  modifiedV2: string
-  modifiedV3: string
+  modifiedGenesis: string
+  modifiedCp: string
+  modifiedMe: string
   placeholderToDiff: Map<string, string>
 }
 
-export type ThreeWayDiffCellFn = (v1Cell: string, v2Cell: string, v3Cell: string) => string
+export type ThreeWayDiffCellFn = (genesisCell: string, cpCell: string, meCell: string) => string
 
 export function preprocessTablesThreeWay(
-  v1: string,
-  v2: string,
-  v3: string,
+  genesis: string,
+  cpLatest: string,
+  meCurrent: string,
   cellDiff: ThreeWayDiffCellFn
 ): ThreeWayPreprocessResult | null {
-  const t1s = findTopLevelTables(v1)
-  const t2s = findTopLevelTables(v2)
-  const t3s = findTopLevelTables(v3)
-
-  // No tables in any input — caller can skip preprocessing entirely.
-  if (t1s.length === 0 && t2s.length === 0 && t3s.length === 0) return null
-
-  // Size cap: bail to word-level diff for pathologically large tables.
-  for (const t of t1s) if (exceedsSizeLimit(t)) return null
-  for (const t of t2s) if (exceedsSizeLimit(t)) return null
-  for (const t of t3s) if (exceedsSizeLimit(t)) return null
-
-  const placeholderPrefix = makePlaceholderPrefix(v1, v2, v3)
-
-  // Fast path: counts match AND each positional triple looks similar
-  // enough that 1:1 positional pairing is sound. The similarity gate
-  // catches the swap case — V1=[A,B], V2=[B,A] has matching counts but
-  // positionally pairing would mis-attribute. Without the gate, a swap
-  // would silently land in the per-cell diff machinery comparing
-  // unrelated tables.
-  if (positionallyAligned(v1, v2, v3, t1s, t2s, t3s)) {
-    return preprocessAlignedByPosition(v1, v2, v3, t1s, t2s, t3s, cellDiff, placeholderPrefix)
+  const gTables = findTopLevelTables(genesis)
+  const cTables = findTopLevelTables(cpLatest)
+  const mTables = findTopLevelTables(meCurrent)
+
+  if (gTables.length === 0 && cTables.length === 0 && mTables.length === 0) return null
+
+  for (const t of gTables) if (exceedsSizeLimit(t)) return null
+  for (const t of cTables) if (exceedsSizeLimit(t)) return null
+  for (const t of mTables) if (exceedsSizeLimit(t)) return null
+
+  const placeholderPrefix = makePlaceholderPrefix(genesis, cpLatest, meCurrent)
+
+  if (positionallyAligned(genesis, cpLatest, meCurrent, gTables, cTables, mTables)) {
+    return preprocessAlignedByPosition(
+      genesis,
+      cpLatest,
+      meCurrent,
+      gTables,
+      cTables,
+      mTables,
+      cellDiff,
+      placeholderPrefix
+    )
   }
 
-  // Multi-table mismatch (D3). CP added/removed/moved a table, Me added/
-  // removed/moved a table, etc. Use content-LCS to pair tables across
-  // each adjacent pair, then assign placeholders so the word-level 3-way
-  // merger naturally attributes unpaired tables — the placeholder token
-  // appears only in the inputs where the table exists, and the merger
-  // sees that as an insertion/deletion.
-  return preprocessMisalignedByContent(v1, v2, v3, t1s, t2s, t3s, cellDiff, placeholderPrefix)
+  return preprocessByContent(genesis, cpLatest, meCurrent, gTables, cTables, mTables, cellDiff, placeholderPrefix)
 }
 
 function preprocessAlignedByPosition(
-  v1: string,
-  v2: string,
-  v3: string,
-  t1s: TableRange[],
-  t2s: TableRange[],
-  t3s: TableRange[],
+  genesis: string,
+  cpLatest: string,
+  meCurrent: string,
+  gTables: TableRange[],
+  cTables: TableRange[],
+  mTables: TableRange[],
   cellDiff: ThreeWayDiffCellFn,
   placeholderPrefix: string
 ): ThreeWayPreprocessResult {
-  const pairs: Array<{
-    t1: TableRange
-    t2: TableRange
-    t3: TableRange
-    diffed: string
-  }> = []
-  for (let i = 0; i < t1s.length; i++) {
+  const pairs: Array<{ g: TableRange; c: TableRange; m: TableRange; diffed: string }> = []
+  for (let i = 0; i < gTables.length; i++) {
     pairs.push({
-      t1: t1s[i],
-      t2: t2s[i],
-      t3: t3s[i],
-      diffed: diffTableThreeWay(v1, v2, v3, t1s[i], t2s[i], t3s[i], cellDiff),
+      g: gTables[i],
+      c: cTables[i],
+      m: mTables[i],
+      diffed: diffTableThreeWay(genesis, cpLatest, meCurrent, gTables[i], cTables[i], mTables[i], cellDiff),
     })
   }
-  let modifiedV1 = v1
-  let modifiedV2 = v2
-  let modifiedV3 = v3
+  let modifiedGenesis = genesis
+  let modifiedCp = cpLatest
+  let modifiedMe = meCurrent
   const placeholderToDiff = new Map<string, string>()
-  // Splice end → start so earlier offsets stay valid.
   for (let i = pairs.length - 1; i >= 0; i--) {
     const placeholder = `${placeholderPrefix}${i}${PLACEHOLDER_SUFFIX}`
     placeholderToDiff.set(placeholder, pairs[i].diffed)
-    modifiedV1 = spliceString(modifiedV1, pairs[i].t1.tableStart, pairs[i].t1.tableEnd, placeholder)
-    modifiedV2 = spliceString(modifiedV2, pairs[i].t2.tableStart, pairs[i].t2.tableEnd, placeholder)
-    modifiedV3 = spliceString(modifiedV3, pairs[i].t3.tableStart, pairs[i].t3.tableEnd, placeholder)
+    modifiedGenesis = spliceString(modifiedGenesis, pairs[i].g.tableStart, pairs[i].g.tableEnd, placeholder)
+    modifiedCp = spliceString(modifiedCp, pairs[i].c.tableStart, pairs[i].c.tableEnd, placeholder)
+    modifiedMe = spliceString(modifiedMe, pairs[i].m.tableStart, pairs[i].m.tableEnd, placeholder)
   }
-  return { modifiedV1, modifiedV2, modifiedV3, placeholderToDiff }
+  return { modifiedGenesis, modifiedCp, modifiedMe, placeholderToDiff }
 }
 
 /**
- * Multi-table mismatch handler. Tables are paired across V1↔V2 and
- * V2↔V3 via content-LCS, then substituted as placeholders such that
- * each placeholder appears in exactly the inputs where its underlying
- * table exists. The word-level merger sees:
- *   - paired-everywhere placeholders → equal in both diffs → unwrapped
- *   - V2-only (CP-inserted + Me-rejected)  → inserted by CP, deleted by
- *     Me → reject wrapper around the table
- *   - V2+V3 (CP-inserted, Me-kept) → ins-cp wrapper
- *   - V1+V2 (Me-deleted) → del-me wrapper
- *   - V1-only (CP-deleted before V2) → del-cp wrapper
- *   - V3-only (Me-inserted) → ins-me wrapper
+ * Multi-table handler. Tables are paired against `genesis` (the spine)
+ * via content-LCS on each of cp and me. Placeholders are assigned so
+ * each appears only in the inputs that actually contain the underlying
+ * table. The word-level merger then attributes them naturally:
  *
- * Each placeholder's content is the diffed table for paired triples,
- * or the raw table HTML for unpaired tables (the word-level wrapper
- * provides the attribution).
+ *   - paired in genesis+cp+me   → equal in both diffs → emit recursive 3-way diff
+ *   - in cp+me, not in genesis  → both-agree insertion → emit plain
+ *   - in cp only                → cp insertion → ins-cp wrapper (Me didn't take it)
+ *   - in me only                → me insertion → ins-me wrapper
+ *   - in genesis+cp, not me     → me deletion → del-me wrapper
+ *   - in genesis+me, not cp     → cp deletion → del-cp wrapper
+ *   - in genesis only           → both deleted, settled → silent (placeholder content empty)
  */
-function preprocessMisalignedByContent(
-  v1: string,
-  v2: string,
-  v3: string,
-  t1s: TableRange[],
-  t2s: TableRange[],
-  t3s: TableRange[],
+function preprocessByContent(
+  genesis: string,
+  cpLatest: string,
+  meCurrent: string,
+  gTables: TableRange[],
+  cTables: TableRange[],
+  mTables: TableRange[],
   cellDiff: ThreeWayDiffCellFn,
   placeholderPrefix: string
 ): ThreeWayPreprocessResult {
-  const k1 = t1s.map(t => tableKey(v1, t))
-  const k2 = t2s.map(t => tableKey(v2, t))
-  const k3 = t3s.map(t => tableKey(v3, t))
-
-  const align12 = lcsAlign(k1, k2)
-  const align23 = lcsAlign(k2, k3)
-
-  // Maps from table-index → counterpart in the other input (or -1).
-  const v1ToV2 = new Array<number>(t1s.length).fill(-1)
-  const v2ToV1 = new Array<number>(t2s.length).fill(-1)
-  for (const a of align12) {
+  const gKeys = gTables.map(t => tableKey(genesis, t))
+  const cKeys = cTables.map(t => tableKey(cpLatest, t))
+  const mKeys = mTables.map(t => tableKey(meCurrent, t))
+
+  // Exact tableKey LCS, then fuzzy-pair unmatched runs by content
+  // similarity. Without this, a table whose cells were edited (but
+  // not its overall shape) fails the exact tableKey match and the
+  // table-level aligner pulls it apart into a whole-table del + a
+  // whole-table ins. Same fuzzy pass `TableDiff` uses for the 2-way
+  // path — `pairSimilarTablesThreeWay` is defined below.
+  const alignCp = pairSimilarTablesThreeWay(lcsAlign(gKeys, cKeys), genesis, cpLatest, gTables, cTables)
+  const alignMe = pairSimilarTablesThreeWay(lcsAlign(gKeys, mKeys), genesis, meCurrent, gTables, mTables)
+
+  // Maps: genesisIdx → matching cpIdx (-1 if none); cpIdx → matching genesisIdx; etc.
+  const gToCp = new Array<number>(gTables.length).fill(-1)
+  const cpToG = new Array<number>(cTables.length).fill(-1)
+  for (const a of alignCp) {
     if (a.oldIdx !== null && a.newIdx !== null) {
-      v1ToV2[a.oldIdx] = a.newIdx
-      v2ToV1[a.newIdx] = a.oldIdx
+      gToCp[a.oldIdx] = a.newIdx
+      cpToG[a.newIdx] = a.oldIdx
     }
   }
-  const v2ToV3 = new Array<number>(t2s.length).fill(-1)
-  const v3ToV2 = new Array<number>(t3s.length).fill(-1)
-  for (const a of align23) {
+  const gToMe = new Array<number>(gTables.length).fill(-1)
+  const meToG = new Array<number>(mTables.length).fill(-1)
+  for (const a of alignMe) {
     if (a.oldIdx !== null && a.newIdx !== null) {
-      v2ToV3[a.oldIdx] = a.newIdx
-      v3ToV2[a.newIdx] = a.oldIdx
+      gToMe[a.oldIdx] = a.newIdx
+      meToG[a.newIdx] = a.oldIdx
     }
   }
 
-  // Allocate placeholders. Each logical-table-position (paired triple,
-  // paired pair, or singleton) gets one shared placeholder used in
-  // every input that contains it.
   let nextId = 0
   const placeholderToDiff = new Map<string, string>()
   const placeholders = {
-    v1: new Array<string | null>(t1s.length).fill(null),
-    v2: new Array<string | null>(t2s.length).fill(null),
-    v3: new Array<string | null>(t3s.length).fill(null),
+    g: new Array<string | null>(gTables.length).fill(null),
+    c: new Array<string | null>(cTables.length).fill(null),
+    m: new Array<string | null>(mTables.length).fill(null),
   }
-
   const allocate = (): string => `${placeholderPrefix}${nextId++}${PLACEHOLDER_SUFFIX}`
 
-  // 1. Triples paired through V2 (preserved in both V1↔V2 AND V2↔V3) — full 3-way diff.
-  for (let v2Idx = 0; v2Idx < t2s.length; v2Idx++) {
-    const v1Idx = v2ToV1[v2Idx]
-    const v3Idx = v2ToV3[v2Idx]
-    if (v1Idx === -1 || v3Idx === -1) continue
-    const placeholder = allocate()
-    placeholderToDiff.set(placeholder, diffTableThreeWay(v1, v2, v3, t1s[v1Idx], t2s[v2Idx], t3s[v3Idx], cellDiff))
-    placeholders.v1[v1Idx] = placeholder
-    placeholders.v2[v2Idx] = placeholder
-    placeholders.v3[v3Idx] = placeholder
-  }
-
-  // For unpaired placeholders the word-level merger can't wrap a tag
-  // token (insertTag emits tags verbatim), so we bake the author
-  // attribution directly into the placeholder content. The merger then
-  // only has to position the placeholder via word-level alignment;
-  // the attribution wrapping is already in the substituted HTML.
-  const wrapWhole = (tag: 'ins' | 'del', author: Author, tableHtml: string, rejects?: Author): string =>
-    Utils.wrapText(tableHtml, tag, `diff${tag}`, authorAttribution(author, rejects))
-
-  // 2. V2 tables paired only with V3 (CP-inserted into V2, Me-kept).
-  for (let v2Idx = 0; v2Idx < t2s.length; v2Idx++) {
-    if (placeholders.v2[v2Idx] !== null) continue
-    const v3Idx = v2ToV3[v2Idx]
-    if (v3Idx === -1) continue
+  // For unpaired-in-one-side placeholders, bake author attribution
+  // into the placeholder content — the word-level merger emits tag
+  // tokens (HTML comments) verbatim, so it can't wrap them itself.
+  const wrapWhole = (tag: 'ins' | 'del', author: Author, tableHtml: string): string =>
+    Utils.wrapText(tableHtml, tag, `diff${tag}`, authorAttribution(author))
+
+  // 1. Triples paired in all three (genesis + cp + me) → recursive 3-way diff.
+  for (let gIdx = 0; gIdx < gTables.length; gIdx++) {
+    const cIdx = gToCp[gIdx]
+    const mIdx = gToMe[gIdx]
+    if (cIdx === -1 || mIdx === -1) continue
     const placeholder = allocate()
-    placeholderToDiff.set(placeholder, wrapWhole('ins', 'cp', v2.slice(t2s[v2Idx].tableStart, t2s[v2Idx].tableEnd)))
-    placeholders.v2[v2Idx] = placeholder
-    placeholders.v3[v3Idx] = placeholder
+    placeholderToDiff.set(
+      placeholder,
+      diffTableThreeWay(genesis, cpLatest, meCurrent, gTables[gIdx], cTables[cIdx], mTables[mIdx], cellDiff)
+    )
+    placeholders.g[gIdx] = placeholder
+    placeholders.c[cIdx] = placeholder
+    placeholders.m[mIdx] = placeholder
   }
 
-  // 3. V2 tables paired only with V1 (preserved from V1, Me-deleted in V3).
-  for (let v2Idx = 0; v2Idx < t2s.length; v2Idx++) {
-    if (placeholders.v2[v2Idx] !== null) continue
-    const v1Idx = v2ToV1[v2Idx]
-    if (v1Idx === -1) continue
+  // 2. Genesis + CP only (not in Me) → me deletion.
+  for (let gIdx = 0; gIdx < gTables.length; gIdx++) {
+    if (placeholders.g[gIdx] !== null) continue
+    const cIdx = gToCp[gIdx]
+    if (cIdx === -1) continue
     const placeholder = allocate()
-    placeholderToDiff.set(placeholder, wrapWhole('del', 'me', v2.slice(t2s[v2Idx].tableStart, t2s[v2Idx].tableEnd)))
-    placeholders.v1[v1Idx] = placeholder
-    placeholders.v2[v2Idx] = placeholder
+    placeholderToDiff.set(
+      placeholder,
+      wrapWhole('del', 'me', genesis.slice(gTables[gIdx].tableStart, gTables[gIdx].tableEnd))
+    )
+    placeholders.g[gIdx] = placeholder
+    placeholders.c[cIdx] = placeholder
   }
 
-  // 4. V2 tables paired with neither (CP-inserted AND Me-deleted = reject).
-  for (let v2Idx = 0; v2Idx < t2s.length; v2Idx++) {
-    if (placeholders.v2[v2Idx] !== null) continue
+  // 3. Genesis + Me only (not in CP) → cp deletion.
+  for (let gIdx = 0; gIdx < gTables.length; gIdx++) {
+    if (placeholders.g[gIdx] !== null) continue
+    const mIdx = gToMe[gIdx]
+    if (mIdx === -1) continue
     const placeholder = allocate()
     placeholderToDiff.set(
       placeholder,
-      wrapWhole('del', 'me', v2.slice(t2s[v2Idx].tableStart, t2s[v2Idx].tableEnd), 'cp')
+      wrapWhole('del', 'cp', genesis.slice(gTables[gIdx].tableStart, gTables[gIdx].tableEnd))
     )
-    placeholders.v2[v2Idx] = placeholder
+    placeholders.g[gIdx] = placeholder
+    placeholders.m[mIdx] = placeholder
   }
 
-  // 5. V1 tables unpaired with V2 (CP-deleted before V2).
-  for (let v1Idx = 0; v1Idx < t1s.length; v1Idx++) {
-    if (placeholders.v1[v1Idx] !== null) continue
+  // 4. Genesis only (not in CP, not in Me) → both deleted, settled, silent.
+  //    Placeholder ONLY in genesis; cp and me lack it. The word-level merger
+  //    sees it as "deleted by both" via the genesis-spine fate maps and
+  //    silences it via the settled-deletion rule (empty placeholder content).
+  for (let gIdx = 0; gIdx < gTables.length; gIdx++) {
+    if (placeholders.g[gIdx] !== null) continue
+    const placeholder = allocate()
+    placeholderToDiff.set(placeholder, '')
+    placeholders.g[gIdx] = placeholder
+  }
+
+  // 5. CP + Me both inserted (no genesis) — agreement check. If their
+  //    table content is textually identical, emit plain (settled). Otherwise
+  //    each side gets its own placeholder (cp-only / me-only treatment).
+  for (let cIdx = 0; cIdx < cTables.length; cIdx++) {
+    if (placeholders.c[cIdx] !== null) continue
+    // CP table not paired to genesis. Is there an unpaired Me table with
+    // matching content?
+    const cText = cKeys[cIdx]
+    let mIdx = -1
+    for (let candidate = 0; candidate < mTables.length; candidate++) {
+      if (placeholders.m[candidate] !== null) continue
+      if (meToG[candidate] !== -1) continue
+      if (mKeys[candidate] === cText) {
+        mIdx = candidate
+        break
+      }
+    }
+    if (mIdx === -1) continue
+    // Both inserted the same table content → settled insertion.
     const placeholder = allocate()
-    placeholderToDiff.set(placeholder, wrapWhole('del', 'cp', v1.slice(t1s[v1Idx].tableStart, t1s[v1Idx].tableEnd)))
-    placeholders.v1[v1Idx] = placeholder
+    placeholderToDiff.set(placeholder, cpLatest.slice(cTables[cIdx].tableStart, cTables[cIdx].tableEnd))
+    placeholders.c[cIdx] = placeholder
+    placeholders.m[mIdx] = placeholder
+  }
+
+  // 6. Remaining CP-only tables (inserted by CP, Me didn't take).
+  for (let cIdx = 0; cIdx < cTables.length; cIdx++) {
+    if (placeholders.c[cIdx] !== null) continue
+    const placeholder = allocate()
+    placeholderToDiff.set(
+      placeholder,
+      wrapWhole('ins', 'cp', cpLatest.slice(cTables[cIdx].tableStart, cTables[cIdx].tableEnd))
+    )
+    placeholders.c[cIdx] = placeholder
   }
 
-  // 6. V3 tables unpaired with V2 (Me-inserted into V3).
-  for (let v3Idx = 0; v3Idx < t3s.length; v3Idx++) {
-    if (placeholders.v3[v3Idx] !== null) continue
+  // 7. Remaining Me-only tables (Me inserted, CP didn't).
+  for (let mIdx = 0; mIdx < mTables.length; mIdx++) {
+    if (placeholders.m[mIdx] !== null) continue
     const placeholder = allocate()
-    placeholderToDiff.set(placeholder, wrapWhole('ins', 'me', v3.slice(t3s[v3Idx].tableStart, t3s[v3Idx].tableEnd)))
-    placeholders.v3[v3Idx] = placeholder
+    placeholderToDiff.set(
+      placeholder,
+      wrapWhole('ins', 'me', meCurrent.slice(mTables[mIdx].tableStart, mTables[mIdx].tableEnd))
+    )
+    placeholders.m[mIdx] = placeholder
   }
 
-  // Splice placeholders into each input. End → start per input.
-  let modifiedV1 = v1
-  for (let i = t1s.length - 1; i >= 0; i--) {
-    const p = placeholders.v1[i]
+  // Splice end → start per input.
+  let modifiedGenesis = genesis
+  for (let i = gTables.length - 1; i >= 0; i--) {
+    const p = placeholders.g[i]
     if (p === null) continue
-    modifiedV1 = spliceString(modifiedV1, t1s[i].tableStart, t1s[i].tableEnd, p)
+    modifiedGenesis = spliceString(modifiedGenesis, gTables[i].tableStart, gTables[i].tableEnd, p)
   }
-  let modifiedV2 = v2
-  for (let i = t2s.length - 1; i >= 0; i--) {
-    const p = placeholders.v2[i]
+  let modifiedCp = cpLatest
+  for (let i = cTables.length - 1; i >= 0; i--) {
+    const p = placeholders.c[i]
     if (p === null) continue
-    modifiedV2 = spliceString(modifiedV2, t2s[i].tableStart, t2s[i].tableEnd, p)
+    modifiedCp = spliceString(modifiedCp, cTables[i].tableStart, cTables[i].tableEnd, p)
   }
-  let modifiedV3 = v3
-  for (let i = t3s.length - 1; i >= 0; i--) {
-    const p = placeholders.v3[i]
+  let modifiedMe = meCurrent
+  for (let i = mTables.length - 1; i >= 0; i--) {
+    const p = placeholders.m[i]
     if (p === null) continue
-    modifiedV3 = spliceString(modifiedV3, t3s[i].tableStart, t3s[i].tableEnd, p)
+    modifiedMe = spliceString(modifiedMe, mTables[i].tableStart, mTables[i].tableEnd, p)
   }
 
-  return { modifiedV1, modifiedV2, modifiedV3, placeholderToDiff }
+  return { modifiedGenesis, modifiedCp, modifiedMe, placeholderToDiff }
 }
 
-/**
- * Threshold at which positional pairing is considered sound. Below this
- * similarity, two positionally-aligned tables are probably different
- * tables (e.g. CP swapped them around) and content-LCS pairing should
- * be used instead. 0.5 is a deliberately loose bar — paired-but-content-
- * edited tables (the common case) sit well above it; genuinely different
- * tables sit well below.
- */
-const POSITIONAL_PAIR_SIMILARITY_THRESHOLD = 0.5
+// Positional pairing is the strict-default for three-way table merge:
+// when all three inputs have the same number of tables in the same
+// order, we pair them by index and let `diffTableThreeWay` handle
+// per-table cell/row level differences. The similarity guard below
+// only kicks in to *reject* positional alignment when a pair is
+// SO dissimilar that it's near-certainly a table reorder/rename
+// where content-LCS pairing would be materially better. The
+// threshold is intentionally low — the 2-way path has no such guard
+// and pairs purely by index (its `diffTable` falls back through
+// same-dimension → equal-row-count → row-LCS → whole-table on its
+// own), so the three-way path was stricter than its sibling and
+// silently dropped to whole-table del+ins for legitimate edits
+// like "rename one column and tweak its values". Aligning the
+// threshold here keeps the two-way and three-way paths in step.
+const POSITIONAL_PAIR_SIMILARITY_THRESHOLD = 0.15
 
-/**
- * Returns true when V1/V2/V3 tables can be 1:1 paired by position. The
- * three lists must have equal length AND each positional triple must
- * have content similar enough that positional pairing reflects the
- * authors' likely intent. The slow content-LCS path handles cases that
- * fail this gate (table reordering, additions, deletions).
- */
 function positionallyAligned(
-  v1: string,
-  v2: string,
-  v3: string,
-  t1s: TableRange[],
-  t2s: TableRange[],
-  t3s: TableRange[]
+  genesis: string,
+  cpLatest: string,
+  meCurrent: string,
+  gTables: TableRange[],
+  cTables: TableRange[],
+  mTables: TableRange[]
 ): boolean {
-  if (t1s.length !== t2s.length || t2s.length !== t3s.length) return false
-  for (let i = 0; i < t1s.length; i++) {
-    const k1 = tableKey(v1, t1s[i])
-    const k2 = tableKey(v2, t2s[i])
-    const k3 = tableKey(v3, t3s[i])
-    if (textSimilarity(k1, k2) < POSITIONAL_PAIR_SIMILARITY_THRESHOLD) return false
-    if (textSimilarity(k2, k3) < POSITIONAL_PAIR_SIMILARITY_THRESHOLD) return false
+  if (gTables.length !== cTables.length || cTables.length !== mTables.length) return false
+  for (let i = 0; i < gTables.length; i++) {
+    const kG = tableKey(genesis, gTables[i])
+    const kC = tableKey(cpLatest, cTables[i])
+    const kM = tableKey(meCurrent, mTables[i])
+    if (textSimilarity(kG, kC) < POSITIONAL_PAIR_SIMILARITY_THRESHOLD) return false
+    if (textSimilarity(kG, kM) < POSITIONAL_PAIR_SIMILARITY_THRESHOLD) return false
   }
   return true
 }
 
 function tableKey(html: string, table: TableRange): string {
-  // Whitespace-normalised full table HTML — tables with byte-identical
-  // content (modulo whitespace) pair; any structural or content
-  // difference falls through to unpaired (table-level ins/del).
   return html.slice(table.tableStart, table.tableEnd).replace(/\s+/g, ' ').trim()
 }
 
+/**
+ * Character-level similarity above which the three-way aligner treats
+ * two rows / tables as "the same logical entry, edited" rather than
+ * an unrelated delete + insert. Matched to TableDiff's
+ * `ROW_FUZZY_THRESHOLD` / `CELL_FUZZY_THRESHOLD` so 2-way and 3-way
+ * agree on which pairings are reachable; if a row's content overlap
+ * is enough to fool the 2-way diff into pairing, it should also be
+ * enough for 3-way.
+ */
+const THREE_WAY_FUZZY_THRESHOLD = 0.5
+
+/**
+ * Run the same fuzzy-pairing pass `TableDiff.pairSimilarUnmatchedRows`
+ * applies after its exact-LCS, but against one side of the genesis
+ * spine (either cp or me). The genesis tables/rows are always the
+ * "old" side; `newTable` is the cp or me table being aligned. Returns
+ * the enriched alignment with additional paired entries.
+ *
+ * Cell-count guard: only fuzzy-pair when both rows have the same cell
+ * count. Without this guard an asymmetric restructure — e.g. CP and
+ * Me both added a different column — leads to ONE side fuzzy-pairing
+ * its row with genesis (content overlap above threshold) while the
+ * other side falls below threshold. That mismatch routes through
+ * `diffTableStructural`'s "Me dropped, CP kept" (or the mirror)
+ * branch, which emits CP's row as a Me-attributed deletion. In
+ * cp-only mode `stripMeAttributedMarkers` then removes the row
+ * entirely and CP's edit vanishes from the view — exactly the
+ * content-loss case we're meant to prevent. Restricting fuzzy
+ * pairing to same-shape rows preserves the common case (single cell
+ * edit, identical row shape) while pushing structural mismatches
+ * back to the boundary-insertion path that emits both sides
+ * explicitly.
+ */
+function pairSimilarRowsThreeWay(
+  alignment: Alignment[],
+  genesis: string,
+  newHtml: string,
+  oldTable: TableRange,
+  newTable: TableRange
+): Alignment[] {
+  const oldTexts = oldTable.rows.map(r => rowText(genesis, r))
+  const newTexts = newTable.rows.map(r => rowText(newHtml, r))
+  return pairSimilarUnmatched(alignment, THREE_WAY_FUZZY_THRESHOLD, (oldIdx, newIdx) => {
+    // Returning 0 sits below any positive threshold so
+    // `pairSimilarUnmatched` won't pair these rows; the guard remains
+    // defensive should the threshold ever be lowered to 0.
+    if (oldTable.rows[oldIdx].cells.length !== newTable.rows[newIdx].cells.length) return 0
+    return textSimilarity(oldTexts[oldIdx], newTexts[newIdx])
+  })
+}
+
+/**
+ * Table-level counterpart: after `lcsAlign(gKeys, otherKeys)` over
+ * full table HTML keys, fuzzy-pair unmatched table runs by their
+ * row-text-concatenated content. Without this, a table whose body
+ * was edited (but not its outer shape) fails the exact-key match
+ * and the preprocessing emits whole-table del + whole-table ins
+ * instead of recursing into per-cell three-way diffs.
+ */
+function pairSimilarTablesThreeWay(
+  alignment: Alignment[],
+  oldHtml: string,
+  newHtml: string,
+  oldTables: TableRange[],
+  newTables: TableRange[]
+): Alignment[] {
+  const oldTexts = oldTables.map(t => t.rows.map(r => rowText(oldHtml, r)).join(' '))
+  const newTexts = newTables.map(t => t.rows.map(r => rowText(newHtml, r)).join(' '))
+  return pairSimilarUnmatched(alignment, THREE_WAY_FUZZY_THRESHOLD, (oldIdx, newIdx) =>
+    textSimilarity(oldTexts[oldIdx], newTexts[newIdx])
+  )
+}
+
+// ────────────────────────────────────────────────────────────────────────────
+// Per-table diff: positional cells or row-level structural change.
+
 function diffTableThreeWay(
-  v1: string,
-  v2: string,
-  v3: string,
-  t1: TableRange,
-  t2: TableRange,
-  t3: TableRange,
+  genesis: string,
+  cpLatest: string,
+  meCurrent: string,
+  tG: TableRange,
+  tC: TableRange,
+  tM: TableRange,
   cellDiff: ThreeWayDiffCellFn
 ): string {
-  if (sameDimensions(t1, t2) && sameDimensions(t2, t3)) {
-    return diffTablePositional(v1, v2, v3, t1, t2, t3, cellDiff)
+  if (sameDimensions(tG, tC) && sameDimensions(tC, tM)) {
+    return diffTablePositional(genesis, cpLatest, meCurrent, tG, tC, tM, cellDiff)
   }
-  return diffTableStructural(v1, v2, v3, t1, t2, t3, cellDiff)
+  return diffTableStructural(genesis, cpLatest, meCurrent, tG, tC, tM, cellDiff)
 }
 
 function diffTablePositional(
-  v1: string,
-  v2: string,
-  v3: string,
-  t1: TableRange,
-  t2: TableRange,
-  t3: TableRange,
+  genesis: string,
+  cpLatest: string,
+  meCurrent: string,
+  tG: TableRange,
+  tC: TableRange,
+  tM: TableRange,
   cellDiff: ThreeWayDiffCellFn
 ): string {
-  // Walk V2 verbatim — its scaffolding (`<table>`, `<tr>`, attributes,
-  // inter-cell whitespace) is the spine. Substitute each cell content
-  // range with the 3-way merge.
+  // Walk genesis's table scaffolding verbatim — it's the common
+  // ancestor. Cells are merged 3-way via cellDiff. Choosing genesis as
+  // the spine keeps the table structure stable across both pair-wise
+  // diffs that the word-level merger will see.
   const out: string[] = []
-  let cursor = t2.tableStart
-  for (let r = 0; r < t2.rows.length; r++) {
-    const r1 = t1.rows[r]
-    const r2 = t2.rows[r]
-    const r3 = t3.rows[r]
-    for (let c = 0; c < r2.cells.length; c++) {
-      const c1 = r1.cells[c]
-      const c2 = r2.cells[c]
-      const c3 = r3.cells[c]
-      out.push(v2.slice(cursor, c2.contentStart))
+  let cursor = tG.tableStart
+  for (let r = 0; r < tG.rows.length; r++) {
+    const rG = tG.rows[r]
+    const rC = tC.rows[r]
+    const rM = tM.rows[r]
+    for (let c = 0; c < rG.cells.length; c++) {
+      const cG = rG.cells[c]
+      const cC = rC.cells[c]
+      const cM = rM.cells[c]
+      out.push(genesis.slice(cursor, cG.contentStart))
       out.push(
         cellDiff(
-          v1.slice(c1.contentStart, c1.contentEnd),
-          v2.slice(c2.contentStart, c2.contentEnd),
-          v3.slice(c3.contentStart, c3.contentEnd)
+          genesis.slice(cG.contentStart, cG.contentEnd),
+          cpLatest.slice(cC.contentStart, cC.contentEnd),
+          meCurrent.slice(cM.contentStart, cM.contentEnd)
         )
       )
-      cursor = c2.contentEnd
+      cursor = cG.contentEnd
     }
   }
-  out.push(v2.slice(cursor, t2.tableEnd))
+  out.push(genesis.slice(cursor, tG.tableEnd))
   return out.join('')
 }
 
 /**
- * Structural-change three-way table diff: rows or cells differ in count
- * across V1/V2/V3. Strategy:
- *   1. Run row-LCS for each pair (V1↔V2, V2↔V3) over rowKeys
- *   2. Build per-V2-row origin (from align1) and fate (from align2)
- *   3. Walk V2's row order, interleaving:
- *      - CP-deleted V1 rows (in align1 but not preserved into V2)
- *      - Me-inserted V3 rows (in align2 but not from V2)
- *   4. For each V2 row, combine origin+fate to decide:
- *      - equal: recurse cellDiff if cell counts match, else fall back
- *      - ins-cp: emit V2 row as fully-CP-inserted
- *      - del-me: emit V2 row as fully-Me-deleted
- *      - reject: emit V2 row as Me-rejects-CP
+ * Row-level genesis-spine merge for tables with diverging row/cell
+ * counts.
  *
- * Tie-break to Me on LCS disagreement (D2): each LCS is authoritative
- * for its own pair-wise view; we don't attempt to reconcile cases where
- * align1's idea of V2's V1 origin contradicts what align2 implies via
- * V3 history. In practice these cases manifest as the row being
- * attributed independently per pair, which is the conservative correct
- * thing to do.
+ * 1. Align cp rows to genesis rows (alignCp), me rows to genesis rows
+ *    (alignMe), each via row-LCS over rowKeys.
+ * 2. Per genesis row: cpFate (kept / deleted), meFate (kept / deleted).
+ *    Both kept → recurse cell diff (with structural-change cell handling
+ *    falling back to me-attribution Replace per the documented
+ *    limitation). One kept, other deleted → emit author-attributed full
+ *    row. Both deleted → silent.
+ * 3. Off-spine rows: cp-only inserted rows + me-only inserted rows.
+ *    Check for content agreement at the same boundary; agreed
+ *    insertions emit plain.
  */
 function diffTableStructural(
-  v1: string,
-  v2: string,
-  v3: string,
-  t1: TableRange,
-  t2: TableRange,
-  t3: TableRange,
+  genesis: string,
+  cpLatest: string,
+  meCurrent: string,
+  tG: TableRange,
+  tC: TableRange,
+  tM: TableRange,
   cellDiff: ThreeWayDiffCellFn
 ): string {
-  const v1Keys = t1.rows.map(r => rowKey(v1, r))
-  const v2Keys = t2.rows.map(r => rowKey(v2, r))
-  const v3Keys = t3.rows.map(r => rowKey(v3, r))
-
-  const align1 = lcsAlign(v1Keys, v2Keys)
-  const align2 = lcsAlign(v2Keys, v3Keys)
-
-  // Per-V2-row attribution lookups.
-  // Origin: 'preserved' (with V1 row index) or 'cp-inserted'.
-  // Fate: 'preserved' (with V3 row index) or 'me-deleted'.
-  const v2Origin = new Array<{ kind: 'preserved'; v1Idx: number } | { kind: 'cp-inserted' }>(t2.rows.length)
-  for (let i = 0; i < v2Origin.length; i++) v2Origin[i] = { kind: 'cp-inserted' }
-  for (const a of align1) {
-    if (a.newIdx !== null && a.oldIdx !== null) {
-      v2Origin[a.newIdx] = { kind: 'preserved', v1Idx: a.oldIdx }
-    }
-  }
+  const gKeys = tG.rows.map(r => rowKey(genesis, r))
+  const cKeys = tC.rows.map(r => rowKey(cpLatest, r))
+  const mKeys = tM.rows.map(r => rowKey(meCurrent, r))
+
+  // Exact LCS first, then fuzzy-pair remaining unmatched runs. Without
+  // the fuzzy pass, a row where CP edited just a single cell's text
+  // produces no key match — the row aligner emits the genesis row as
+  // CP-deleted AND CP's reshaped row as inserted, when a cell-level
+  // diff against the paired row would render the edit far more
+  // legibly. The 2-way path (`TableDiff.pairSimilarUnmatchedRows`)
+  // has done this since inception; bringing the three-way path in
+  // step removes the asymmetry where the cp-only / all-changes view
+  // looks markedly worse than plain 2-way for ordinary cell edits.
+  const alignCp = pairSimilarRowsThreeWay(lcsAlign(gKeys, cKeys), genesis, cpLatest, tG, tC)
+  const alignMe = pairSimilarRowsThreeWay(lcsAlign(gKeys, mKeys), genesis, meCurrent, tG, tM)
+
+  // genesisIdx → matching cpIdx (-1 if cp deleted this row)
+  const gToCp = new Array<number>(tG.rows.length).fill(-1)
+  for (const a of alignCp) {
+    if (a.oldIdx !== null && a.newIdx !== null) gToCp[a.oldIdx] = a.newIdx
+  }
+  const gToMe = new Array<number>(tG.rows.length).fill(-1)
+  for (const a of alignMe) {
+    if (a.oldIdx !== null && a.newIdx !== null) gToMe[a.oldIdx] = a.newIdx
+  }
+
+  // Off-spine row collections: cp rows with no genesis counterpart, me rows with no genesis counterpart.
+  // Keyed by "the genesis row index they should appear before" so emission interleaves correctly.
+  const cpInsAt = collectInsertedRowsAtBoundary(alignCp, tG.rows.length)
+  const meInsAt = collectInsertedRowsAtBoundary(alignMe, tG.rows.length)
 
-  const v2Fate = new Array<{ kind: 'preserved'; v3Idx: number } | { kind: 'me-deleted' }>(t2.rows.length)
-  for (let i = 0; i < v2Fate.length; i++) v2Fate[i] = { kind: 'me-deleted' }
-  for (const a of align2) {
-    if (a.oldIdx !== null && a.newIdx !== null) {
-      v2Fate[a.oldIdx] = { kind: 'preserved', v3Idx: a.newIdx }
-    }
-  }
-
-  // Off-spine surfaces.
-  // CP-deleted V1 rows: in align1 with newIdx == null. They land at the
-  // V2 boundary that follows them. The boundary index is the next
-  // preserved V2 row, or v2.rows.length if no following preserved row.
-  const cpDelRowsAt = collectCpDelRowsAtBoundary(align1, t2.rows.length)
-  // Me-inserted V3 rows: in align2 with oldIdx == null. They land at the
-  // V2 boundary they sit before — i.e. the next preserved V2 row.
-  const meInsRowsAt = collectMeInsRowsAtBoundary(align2, t2.rows.length)
-
-  // Emit. We reconstruct the table from scratch since rows may be added
-  // or deleted from V2's order; preserve the V2 header (everything up
-  // to the first <tr>) and the V2 footer (after the last </tr>).
   const out: string[] = []
-  out.push(tableHeaderSlice(v2, t2))
-
-  const emitBoundary = (i: number) => {
-    const cpDel = cpDelRowsAt.get(i)
-    if (cpDel) {
-      for (const v1RowIdx of cpDel) {
-        out.push(emitFullRowAttributed(v1, t1.rows[v1RowIdx], 'del', 'cp'))
+  out.push(tableHeaderSlice(genesis, tG))
+
+  const emitBoundaryInsertions = (b: number) => {
+    const cIdxs = cpInsAt.get(b) ?? []
+    const mIdxs = meInsAt.get(b) ?? []
+    if (cIdxs.length === 0 && mIdxs.length === 0) return
+    // Detect settled insertions (cp and me both inserted the same row content).
+    // Pair by content key, in order of appearance.
+    const remainingMe = new Set(mIdxs)
+    for (const cIdx of cIdxs) {
+      const cText = cKeys[cIdx]
+      let agreedMeIdx: number | undefined
+      for (const mIdx of remainingMe) {
+        if (mKeys[mIdx] === cText) {
+          agreedMeIdx = mIdx
+          break
+        }
       }
-    }
-    const meIns = meInsRowsAt.get(i)
-    if (meIns) {
-      for (const v3RowIdx of meIns) {
-        out.push(emitFullRowAttributed(v3, t3.rows[v3RowIdx], 'ins', 'me'))
+      if (agreedMeIdx !== undefined) {
+        remainingMe.delete(agreedMeIdx)
+        // Settled insertion — emit cp's row verbatim, unmarked.
+        out.push(cpLatest.slice(tC.rows[cIdx].rowStart, tC.rows[cIdx].rowEnd))
+      } else {
+        out.push(emitFullRowAttributed(cpLatest, tC.rows[cIdx], 'ins', 'cp'))
       }
     }
+    for (const mIdx of remainingMe) {
+      out.push(emitFullRowAttributed(meCurrent, tM.rows[mIdx], 'ins', 'me'))
+    }
   }
 
-  for (let r = 0; r < t2.rows.length; r++) {
-    emitBoundary(r)
-    const v2Row = t2.rows[r]
-    const origin = v2Origin[r]
-    const fate = v2Fate[r]
-    out.push(emitV2Row(v1, v2, v3, v2Row, t1, t3, origin, fate, cellDiff))
-  }
-  emitBoundary(t2.rows.length)
-  out.push(tableFooterSlice(v2, t2))
-  return out.join('')
-}
-
-function emitV2Row(
-  v1: string,
-  v2: string,
-  v3: string,
-  v2Row: RowRange,
-  t1: TableRange,
-  t3: TableRange,
-  origin: { kind: 'preserved'; v1Idx: number } | { kind: 'cp-inserted' },
-  fate: { kind: 'preserved'; v3Idx: number } | { kind: 'me-deleted' },
-  cellDiff: ThreeWayDiffCellFn
-): string {
-  if (origin.kind === 'cp-inserted' && fate.kind === 'me-deleted') {
-    // CP added the row, Me removed it: reject. Show as Me-deletion of
-    // CP's insertion via the rejects markup.
-    return emitFullRowAttributed(v2, v2Row, 'del', 'me', 'cp')
-  }
-  if (origin.kind === 'cp-inserted') {
-    // CP added the row, Me kept it. Attribute as CP-inserted but emit
-    // V2's content (which equals V3's content since Me kept it).
-    return emitFullRowAttributed(v2, v2Row, 'ins', 'cp')
-  }
-  if (fate.kind === 'me-deleted') {
-    // Me removed an original V1 row. Emit as Me-deletion of V2's content.
-    return emitFullRowAttributed(v2, v2Row, 'del', 'me')
-  }
-  // Preserved on both sides — recurse into cells. The discriminated-union
-  // narrowing makes the indices safe to access directly.
-  const v1Row = t1.rows[origin.v1Idx]
-  const v3Row = t3.rows[fate.v3Idx]
-  if (v1Row.cells.length === v2Row.cells.length && v2Row.cells.length === v3Row.cells.length) {
-    // Same cell counts → positional cell diff via cellDiff.
-    return diffRowPositional(v1, v2, v3, v1Row, v2Row, v3Row, cellDiff)
+  for (let g = 0; g < tG.rows.length; g++) {
+    emitBoundaryInsertions(g)
+
+    const cIdx = gToCp[g]
+    const mIdx = gToMe[g]
+    const cpDel = cIdx === -1
+    const meDel = mIdx === -1
+
+    if (!cpDel && !meDel) {
+      // Both kept — recurse cell-level diff against this row triple.
+      out.push(emitPreservedRow(genesis, cpLatest, meCurrent, tG.rows[g], tC.rows[cIdx], tM.rows[mIdx], cellDiff))
+    } else if (cpDel && meDel) {
+      // Both deleted — silent (settled).
+    } else if (cpDel) {
+      // CP dropped, Me kept → emit Me's row attributed as cp-deletion. The
+      // content shown is what Me has; the styling tells the reader CP
+      // wanted it gone.
+      out.push(emitFullRowAttributed(meCurrent, tM.rows[mIdx], 'del', 'cp'))
+    } else {
+      // Me dropped, CP kept → emit CP's row attributed as me-deletion.
+      out.push(emitFullRowAttributed(cpLatest, tC.rows[cIdx], 'del', 'me'))
+    }
   }
-  // Cell-count mismatch within a preserved row. Cell-level structural
-  // change is deferred; fall back to Me-attribution Replace (V2 row
-  // removed, V3 row inserted). This is lossy for CP's contribution
-  // within the row but functional. Real-world legal docs rarely change
-  // column count mid-row; this is a known limitation.
-  const out: string[] = []
-  out.push(emitFullRowAttributed(v2, v2Row, 'del', 'me'))
-  out.push(emitFullRowAttributed(v3, v3Row, 'ins', 'me'))
+  emitBoundaryInsertions(tG.rows.length)
+  out.push(tableFooterSlice(genesis, tG))
   return out.join('')
 }
 
-function diffRowPositional(
-  v1: string,
-  v2: string,
-  v3: string,
-  v1Row: RowRange,
-  v2Row: RowRange,
-  v3Row: RowRange,
+function emitPreservedRow(
+  genesis: string,
+  cpLatest: string,
+  meCurrent: string,
+  rG: RowRange,
+  rC: RowRange,
+  rM: RowRange,
   cellDiff: ThreeWayDiffCellFn
 ): string {
-  // Walk V2's row verbatim, substituting each cell content with the
-  // 3-way merge. Mirrors `diffTablePositional` at the row scale.
-  const out: string[] = []
-  let cursor = v2Row.rowStart
-  for (let c = 0; c < v2Row.cells.length; c++) {
-    const c1 = v1Row.cells[c]
-    const c2 = v2Row.cells[c]
-    const c3 = v3Row.cells[c]
-    out.push(v2.slice(cursor, c2.contentStart))
-    out.push(
-      cellDiff(
-        v1.slice(c1.contentStart, c1.contentEnd),
-        v2.slice(c2.contentStart, c2.contentEnd),
-        v3.slice(c3.contentStart, c3.contentEnd)
+  if (rG.cells.length === rC.cells.length && rC.cells.length === rM.cells.length) {
+    // Same cell counts — positional cell diff.
+    const out: string[] = []
+    let cursor = rG.rowStart
+    for (let c = 0; c < rG.cells.length; c++) {
+      const cG = rG.cells[c]
+      const cC = rC.cells[c]
+      const cM = rM.cells[c]
+      out.push(genesis.slice(cursor, cG.contentStart))
+      out.push(
+        cellDiff(
+          genesis.slice(cG.contentStart, cG.contentEnd),
+          cpLatest.slice(cC.contentStart, cC.contentEnd),
+          meCurrent.slice(cM.contentStart, cM.contentEnd)
+        )
       )
-    )
-    cursor = c2.contentEnd
-  }
-  out.push(v2.slice(cursor, v2Row.rowEnd))
-  return out.join('')
-}
-
-function collectCpDelRowsAtBoundary(align: ReturnType<typeof lcsAlign>, v2RowCount: number): Map<number, number[]> {
-  // For each unpaired V1 row (oldIdx set, newIdx null), determine its
-  // V2 boundary index: the position just before the next preserved V2
-  // row, or v2RowCount if there's no following preserved row.
-  const out = new Map<number, number[]>()
-  let nextV2Boundary = v2RowCount
-  // Walk the alignment in reverse so we can compute nextV2Boundary
-  // running backwards, then assign each unpaired V1 row to the boundary
-  // currently in scope.
-  const pending: number[] = []
-  for (let i = align.length - 1; i >= 0; i--) {
-    const a = align[i]
-    if (a.newIdx !== null) {
-      // Flush pending unpaired V1 rows to this V2 boundary.
-      if (pending.length > 0) {
-        const existing = out.get(nextV2Boundary) ?? []
-        // pending was filled backwards — reverse so document order is preserved.
-        existing.unshift(...pending.toReversed())
-        out.set(nextV2Boundary, existing)
-        pending.length = 0
-      }
-      nextV2Boundary = a.newIdx
-    } else if (a.oldIdx !== null) {
-      // Unpaired V1 row — CP deleted it.
-      pending.push(a.oldIdx)
+      cursor = cG.contentEnd
     }
-  }
-  if (pending.length > 0) {
-    const existing = out.get(nextV2Boundary) ?? []
-    existing.unshift(...pending.reverse())
-    out.set(nextV2Boundary, existing)
-  }
-  return out
+    out.push(genesis.slice(cursor, rG.rowEnd))
+    return out.join('')
+  }
+  // Cell-count mismatch within a preserved row — cell-level structural
+  // alignment is non-trivial (which Me cell maps to which CP cell when
+  // the counts diverge?). The previous fallback emitted only
+  // genesis-as-del + me-as-ins, which silently destroyed CP's row
+  // content whenever CP changed the cell count — a content-loss bug
+  // (a row where CP added a column would disappear from the rendered
+  // diff entirely). Emit each side's row as a distinct attributed
+  // block so neither party's restructure can vanish:
+  //   - if both restructured (different shapes on both sides) the
+  //     genesis row is settled-deleted (silent) and we emit cp + me
+  //     rows side by side, each attributed to its author;
+  //   - if only one restructured, the genesis row is del-attributed to
+  //     the restructuring author so the reader sees what was there
+  //     before, then the new shape ins-attributed to the same author.
+  //
+  // Content edits inside a side that DID keep the genesis cell count
+  // are not surfaced here (no positional path is available across
+  // mismatched shapes); the underlying data is still present in the
+  // source document but the visual diff doesn't decompose it. That is
+  // a degradation of detail, not content loss — symmetric for cp/me.
+  const cpRestructured = rC.cells.length !== rG.cells.length
+  const meRestructured = rM.cells.length !== rG.cells.length
+  const blocks: string[] = []
+  if (cpRestructured && meRestructured) {
+    // Both sides restructured; genesis shape retained by neither.
+    blocks.push(emitFullRowAttributed(cpLatest, rC, 'ins', 'cp'))
+    blocks.push(emitFullRowAttributed(meCurrent, rM, 'ins', 'me'))
+  } else if (cpRestructured) {
+    blocks.push(emitFullRowAttributed(genesis, rG, 'del', 'cp'))
+    blocks.push(emitFullRowAttributed(cpLatest, rC, 'ins', 'cp'))
+  } else {
+    blocks.push(emitFullRowAttributed(genesis, rG, 'del', 'me'))
+    blocks.push(emitFullRowAttributed(meCurrent, rM, 'ins', 'me'))
+  }
+  return blocks.join('')
 }
 
-function collectMeInsRowsAtBoundary(align: ReturnType<typeof lcsAlign>, v2RowCount: number): Map<number, number[]> {
-  // For each unpaired V3 row (newIdx set, oldIdx null), determine its
-  // V2 boundary: the position of the next preserved V2 row, or
-  // v2RowCount if at the tail. Mirror of CP-del logic.
+/**
+ * Returns map "genesis-row-boundary → list of new-side row indices
+ * inserted at that boundary". Mirrors the word-level boundary collection
+ * but at the row scale.
+ */
+function collectInsertedRowsAtBoundary(
+  align: ReturnType<typeof lcsAlign>,
+  genesisRowCount: number
+): Map<number, number[]> {
   const out = new Map<number, number[]>()
-  let nextV2Boundary = v2RowCount
+  let nextGenesisBoundary = genesisRowCount
   const pending: number[] = []
+  // Walk in reverse so nextGenesisBoundary tracks the next preserved row
+  // we'll encounter; flush pending unpaired new rows at the appropriate
+  // genesis boundary.
   for (let i = align.length - 1; i >= 0; i--) {
     const a = align[i]
     if (a.oldIdx !== null) {
       if (pending.length > 0) {
-        const existing = out.get(nextV2Boundary) ?? []
+        const existing = out.get(nextGenesisBoundary) ?? []
         existing.unshift(...pending.toReversed())
-        out.set(nextV2Boundary, existing)
+        out.set(nextGenesisBoundary, existing)
         pending.length = 0
       }
-      nextV2Boundary = a.oldIdx
+      nextGenesisBoundary = a.oldIdx
     } else if (a.newIdx !== null) {
       pending.push(a.newIdx)
     }
   }
   if (pending.length > 0) {
-    const existing = out.get(nextV2Boundary) ?? []
-    existing.unshift(...pending.reverse())
-    out.set(nextV2Boundary, existing)
+    const existing = out.get(nextGenesisBoundary) ?? []
+    existing.unshift(...pending.toReversed())
+    out.set(nextGenesisBoundary, existing)
   }
   return out
 }
 
 function tableHeaderSlice(html: string, table: TableRange): string {
-  // Slice from <table> to start of first <tr>. If table is empty, take
-  // everything up to </table>.
   const firstRow = table.rows[0]
   if (!firstRow) return html.slice(table.tableStart, table.tableEnd - '</table>'.length)
   return html.slice(table.tableStart, firstRow.rowStart)
 }
 
 function tableFooterSlice(html: string, table: TableRange): string {
-  // Slice from end of last <tr> to </table>.
   const lastRow = table.rows[table.rows.length - 1]
   if (!lastRow) return '</table>'
   return html.slice(lastRow.rowEnd, table.tableEnd)
 }
 
 /**
- * Emit a row that's fully attributed to one author, in an ins or del
- * role. `rejectsAuthor` is set when the row is a Me-deletion of a
- * CP-inserted row. Wraps `<tr>` in `class='diffins cp'` etc. and each
- * `<td>` content in the corresponding `<ins>`/`<del>` wrapper with the
- * author classes/attrs.
+ * Emit a row fully attributed to one author. Wraps `<tr>` and each
+ * `<td>` with the author's diffins/diffdel class and `data-author`
+ * attribute; wraps cell content with an inner `<ins>`/`<del>` matching
+ * the word-level emission shape.
  */
-function emitFullRowAttributed(
-  html: string,
-  row: RowRange,
-  kind: 'ins' | 'del',
-  author: Author,
-  rejectsAuthor?: Author
-): string {
+function emitFullRowAttributed(html: string, row: RowRange, kind: 'ins' | 'del', author: Author): string {
   const trOpening = parseOpeningTagAt(html, row.rowStart)
-  if (!trOpening) return html.slice(html.length, html.length)
-  const trWithAttrs = injectAuthorAttribution(html.slice(row.rowStart, trOpening.end), kind, author, rejectsAuthor)
+  if (!trOpening) return html.slice(row.rowStart, row.rowEnd)
+  const trWithAttrs = injectAuthorAttribution(html.slice(row.rowStart, trOpening.end), kind, author)
 
   const out: string[] = [trWithAttrs]
   let cursor = trOpening.end
   for (const cell of row.cells) {
     out.push(html.slice(cursor, cell.cellStart))
-    out.push(emitFullCellAttributed(html, cell, kind, author, rejectsAuthor))
+    out.push(emitFullCellAttributed(html, cell, kind, author))
     cursor = cell.cellEnd
   }
   out.push(html.slice(cursor, row.rowEnd))
   return out.join('')
 }
 
-function emitFullCellAttributed(
-  html: string,
-  cell: CellRange,
-  kind: 'ins' | 'del',
-  author: Author,
-  rejectsAuthor?: Author
-): string {
+function emitFullCellAttributed(html: string, cell: CellRange, kind: 'ins' | 'del', author: Author): string {
   const tdOpening = parseOpeningTagAt(html, cell.cellStart)
   if (!tdOpening) return html.slice(cell.cellStart, cell.cellEnd)
-  const tdWithAttrs = injectAuthorAttribution(html.slice(cell.cellStart, tdOpening.end), kind, author, rejectsAuthor)
-  // Wrap the content in an ins/del with the author classes — same
-  // shape as the word-level emission. Empty cells get the class on the
-  // <td> but no inner wrapper.
+  const tdWithAttrs = injectAuthorAttribution(html.slice(cell.cellStart, tdOpening.end), kind, author)
   const innerContent = html.slice(cell.contentStart, cell.contentEnd)
   const innerWrapped =
     innerContent.trim().length === 0
       ? innerContent
-      : Utils.wrapText(innerContent, kind, `diff${kind}`, authorAttribution(author, rejectsAuthor))
+      : Utils.wrapText(innerContent, kind, `diff${kind}`, authorAttribution(author))
   const closing = html.slice(cell.contentEnd, cell.cellEnd)
   return tdWithAttrs + innerWrapped + closing
 }
 
-/**
- * Inject author classes + data-attrs into an existing opening tag (e.g.
- * an `<tr>` or `<td>` already in the source HTML). Uses the same
- * attribution shape as `authorAttribution` + `Utils.wrapText` so the
- * inject-into-existing and wrap-around-text paths agree.
- */
-function injectAuthorAttribution(
-  openingTag: string,
-  kind: 'ins' | 'del',
-  author: Author,
-  rejectsAuthor?: Author
-): string {
-  const meta = authorAttribution(author, rejectsAuthor)
+function injectAuthorAttribution(openingTag: string, kind: 'ins' | 'del', author: Author): string {
+  const meta = authorAttribution(author)
   const tagWithClass = injectClass(openingTag, `diff${kind} ${meta.extraClasses}`)
   return injectDataAttrs(tagWithClass, meta.dataAttrs ?? {})
 }
@@ -693,9 +754,6 @@ function injectDataAttrs(openingTag: string, dataAttrs: Readonly<Record<string,
   const keys = Object.keys(dataAttrs)
   if (keys.length === 0) return openingTag
   const attrs = keys.map(k => ` data-${k}='${dataAttrs[k]}'`).join('')
-  // Insert the data-* attributes just before the closing '>' of the
-  // opening tag. `<tr>` and `<td>` are never self-closing in real HTML,
-  // but handle `/>` defensively for symmetry with other HTML emitters.
   if (openingTag.endsWith('/>')) return `${openingTag.slice(0, -2)}${attrs}/>`
   return `${openingTag.slice(0, -1)}${attrs}>`
 }