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

package/src/ThreeWayTable.ts

@@ -0,0 +1,701 @@
+import { lcsAlign, textSimilarity } from './Alignment'
+import { injectClass, parseOpeningTagAt } from './HtmlScanner'
+import {
+  type CellRange,
+  exceedsSizeLimit,
+  findTopLevelTables,
+  makePlaceholderPrefix,
+  PLACEHOLDER_SUFFIX,
+  type RowRange,
+  rowKey,
+  sameDimensions,
+  spliceString,
+  type TableRange,
+} from './TableDiff'
+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.
+ *
+ * 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).
+ */
+
+export interface ThreeWayPreprocessResult {
+  modifiedV1: string
+  modifiedV2: string
+  modifiedV3: string
+  placeholderToDiff: Map<string, string>
+}
+
+export type ThreeWayDiffCellFn = (v1Cell: string, v2Cell: string, v3Cell: string) => string
+
+export function preprocessTablesThreeWay(
+  v1: string,
+  v2: string,
+  v3: 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)
+  }
+
+  // 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)
+}
+
+function preprocessAlignedByPosition(
+  v1: string,
+  v2: string,
+  v3: string,
+  t1s: TableRange[],
+  t2s: TableRange[],
+  t3s: 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++) {
+    pairs.push({
+      t1: t1s[i],
+      t2: t2s[i],
+      t3: t3s[i],
+      diffed: diffTableThreeWay(v1, v2, v3, t1s[i], t2s[i], t3s[i], cellDiff),
+    })
+  }
+  let modifiedV1 = v1
+  let modifiedV2 = v2
+  let modifiedV3 = v3
+  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)
+  }
+  return { modifiedV1, modifiedV2, modifiedV3, 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
+ *
+ * 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).
+ */
+function preprocessMisalignedByContent(
+  v1: string,
+  v2: string,
+  v3: string,
+  t1s: TableRange[],
+  t2s: TableRange[],
+  t3s: 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) {
+    if (a.oldIdx !== null && a.newIdx !== null) {
+      v1ToV2[a.oldIdx] = a.newIdx
+      v2ToV1[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) {
+    if (a.oldIdx !== null && a.newIdx !== null) {
+      v2ToV3[a.oldIdx] = a.newIdx
+      v3ToV2[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),
+  }
+
+  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
+    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
+  }
+
+  // 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
+    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
+  }
+
+  // 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
+    const placeholder = allocate()
+    placeholderToDiff.set(
+      placeholder,
+      wrapWhole('del', 'me', v2.slice(t2s[v2Idx].tableStart, t2s[v2Idx].tableEnd), 'cp')
+    )
+    placeholders.v2[v2Idx] = 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
+    const placeholder = allocate()
+    placeholderToDiff.set(placeholder, wrapWhole('del', 'cp', v1.slice(t1s[v1Idx].tableStart, t1s[v1Idx].tableEnd)))
+    placeholders.v1[v1Idx] = 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
+    const placeholder = allocate()
+    placeholderToDiff.set(placeholder, wrapWhole('ins', 'me', v3.slice(t3s[v3Idx].tableStart, t3s[v3Idx].tableEnd)))
+    placeholders.v3[v3Idx] = 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]
+    if (p === null) continue
+    modifiedV1 = spliceString(modifiedV1, t1s[i].tableStart, t1s[i].tableEnd, p)
+  }
+  let modifiedV2 = v2
+  for (let i = t2s.length - 1; i >= 0; i--) {
+    const p = placeholders.v2[i]
+    if (p === null) continue
+    modifiedV2 = spliceString(modifiedV2, t2s[i].tableStart, t2s[i].tableEnd, p)
+  }
+  let modifiedV3 = v3
+  for (let i = t3s.length - 1; i >= 0; i--) {
+    const p = placeholders.v3[i]
+    if (p === null) continue
+    modifiedV3 = spliceString(modifiedV3, t3s[i].tableStart, t3s[i].tableEnd, p)
+  }
+
+  return { modifiedV1, modifiedV2, modifiedV3, 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
+
+/**
+ * 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[]
+): 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
+  }
+  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()
+}
+
+function diffTableThreeWay(
+  v1: string,
+  v2: string,
+  v3: string,
+  t1: TableRange,
+  t2: TableRange,
+  t3: TableRange,
+  cellDiff: ThreeWayDiffCellFn
+): string {
+  if (sameDimensions(t1, t2) && sameDimensions(t2, t3)) {
+    return diffTablePositional(v1, v2, v3, t1, t2, t3, cellDiff)
+  }
+  return diffTableStructural(v1, v2, v3, t1, t2, t3, cellDiff)
+}
+
+function diffTablePositional(
+  v1: string,
+  v2: string,
+  v3: string,
+  t1: TableRange,
+  t2: TableRange,
+  t3: 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.
+  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))
+      out.push(
+        cellDiff(
+          v1.slice(c1.contentStart, c1.contentEnd),
+          v2.slice(c2.contentStart, c2.contentEnd),
+          v3.slice(c3.contentStart, c3.contentEnd)
+        )
+      )
+      cursor = c2.contentEnd
+    }
+  }
+  out.push(v2.slice(cursor, t2.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
+ *
+ * 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.
+ */
+function diffTableStructural(
+  v1: string,
+  v2: string,
+  v3: string,
+  t1: TableRange,
+  t2: TableRange,
+  t3: 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 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'))
+      }
+    }
+    const meIns = meInsRowsAt.get(i)
+    if (meIns) {
+      for (const v3RowIdx of meIns) {
+        out.push(emitFullRowAttributed(v3, t3.rows[v3RowIdx], '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)
+  }
+  // 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'))
+  return out.join('')
+}
+
+function diffRowPositional(
+  v1: string,
+  v2: string,
+  v3: string,
+  v1Row: RowRange,
+  v2Row: RowRange,
+  v3Row: 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)
+      )
+    )
+    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)
+    }
+  }
+  if (pending.length > 0) {
+    const existing = out.get(nextV2Boundary) ?? []
+    existing.unshift(...pending.reverse())
+    out.set(nextV2Boundary, existing)
+  }
+  return out
+}
+
+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.
+  const out = new Map<number, number[]>()
+  let nextV2Boundary = v2RowCount
+  const pending: number[] = []
+  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) ?? []
+        existing.unshift(...pending.toReversed())
+        out.set(nextV2Boundary, existing)
+        pending.length = 0
+      }
+      nextV2Boundary = 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)
+  }
+  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.
+ */
+function emitFullRowAttributed(
+  html: string,
+  row: RowRange,
+  kind: 'ins' | 'del',
+  author: Author,
+  rejectsAuthor?: 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)
+
+  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))
+    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 {
+  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 innerContent = html.slice(cell.contentStart, cell.contentEnd)
+  const innerWrapped =
+    innerContent.trim().length === 0
+      ? innerContent
+      : Utils.wrapText(innerContent, kind, `diff${kind}`, authorAttribution(author, rejectsAuthor))
+  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)
+  const tagWithClass = injectClass(openingTag, `diff${kind} ${meta.extraClasses}`)
+  return injectDataAttrs(tagWithClass, meta.dataAttrs ?? {})
+}
+
+function injectDataAttrs(openingTag: string, dataAttrs: Readonly<Record<string, string>>): 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}>`
+}