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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@createiq/htmldiff",
-  "version": "1.2.0-beta.0",
+  "version": "1.2.0-beta.2",
   "description": "TypeScript port of htmldiff.net",
   "type": "module",
   "author": "Mathew Mannion <mathew.mannion@linklaters.com>",

package/src/HtmlDiff.ts

@@ -162,7 +162,22 @@ export default class HtmlDiff {
   // constructor overload that would re-leak the parameter we just hid.
   private tablePreprocessDepth = 0
 
-  private specialTagDiffStack: string[] = []
+  /**
+   * Tracks currently-open formatting-tag wraps. Each entry pairs the
+   * opening tag (so a later closing tag can find its match) with the
+   * styling info needed to RE-OPEN the wrap if an overlapping
+   * formatting-tag close forces it to split. Without the styling info,
+   * an overlap like `<strong>X</strong>` ↔ `<u>X</u>` produces an
+   * unclosable wrap (the closing tag for the outer wrap arrives while
+   * an inner wrap is still on the stack); see `insertTag`'s closing
+   * handler for the split logic.
+   */
+  private specialTagDiffStack: Array<{
+    tag: string
+    styledTagNames: string
+    cssClass: string
+    metadata: WrapMetadata | undefined
+  }> = []
   private newWords: string[] = []
   private oldWords: string[] = []
   /**
@@ -336,41 +351,61 @@ export default class HtmlDiff {
    * pairs would project on their own. Pass an explicit boolean to
    * override.
    */
-  static executeThreeWay(v1: string, v2: string, v3: string, options: ThreeWayOptions = {}): string {
-    return HtmlDiff.executeThreeWayWithDepth(v1, v2, v3, options, 0)
+  /**
+   * Three-way HTML diff against a shared genesis. Produces attributed
+   * HTML that distinguishes CP's accumulated changes (genesis → cpLatest)
+   * from Me's accumulated changes (genesis → meCurrent). Use this for
+   * blackline UX where the negotiation has gone through multiple turns
+   * and the reader wants to see "who proposed what" across the whole
+   * history, not just the most recent round.
+   *
+   * When both parties happen to have made the same change (e.g. CP
+   * proposed a wording change in turn N, Me adopted it in turn N+1),
+   * the change reads as "settled" and is emitted unmarked — only
+   * disagreements and pending proposals carry author attribution.
+   *
+   * @param genesis    the shared common ancestor (per-user — the FE
+   *                   picks between V1.0 and /preview/initialAnswers
+   *                   based on `prefillReceiverAnswers`)
+   * @param cpLatest   the counterparty's current published version
+   * @param meCurrent  Me's current draft (the document on screen)
+   */
+  static executeThreeWay(genesis: string, cpLatest: string, meCurrent: string, options: ThreeWayOptions = {}): string {
+    return HtmlDiff.executeThreeWayWithDepth(genesis, cpLatest, meCurrent, options, 0)
   }
 
   private static executeThreeWayWithDepth(
-    v1: string,
-    v2: string,
-    v3: string,
+    genesis: string,
+    cpLatest: string,
+    meCurrent: string,
     options: ThreeWayOptions,
     depth: number
   ): string {
-    // Table preprocessing first — replaces each V1/V2/V3 table with a
+    // Table preprocessing first — replaces each genesis/cp/me table with a
     // shared-nonce placeholder, then the word-level merge runs over the
     // table-free inputs. Cells are diffed recursively via executeThreeWay
-    // so the cell content is itself three-way attributed. Restoration
-    // happens at the end.
+    // so the cell content is itself three-way attributed.
     //
-    // Depth-cap the recursion. Each level recurses cellDiff → executeThreeWay,
-    // which would otherwise run unbounded on adversarially-nested input.
-    // Beyond the cap, skip table preprocessing entirely and let the
-    // word-level merge handle the raw HTML — same bail-out semantics as
-    // the 2-way `MaxTablePreprocessDepth` cap.
+    // Depth-cap the recursion so adversarially-nested input can't blow
+    // stack/memory.
     const tablePreprocess =
       depth < HtmlDiff.MaxThreeWayDepth
-        ? preprocessTablesThreeWay(v1, v2, v3, (c1, c2, c3) =>
-            HtmlDiff.executeThreeWayWithDepth(c1, c2, c3, options, depth + 1)
+        ? preprocessTablesThreeWay(genesis, cpLatest, meCurrent, (g, c, m) =>
+            HtmlDiff.executeThreeWayWithDepth(g, c, m, options, depth + 1)
           )
         : null
-    const inV1 = tablePreprocess?.modifiedV1 ?? v1
-    const inV2 = tablePreprocess?.modifiedV2 ?? v2
-    const inV3 = tablePreprocess?.modifiedV3 ?? v3
-
+    const inGenesis = tablePreprocess?.modifiedGenesis ?? genesis
+    const inCp = tablePreprocess?.modifiedCp ?? cpLatest
+    const inMe = tablePreprocess?.modifiedMe ?? meCurrent
+
+    // Symmetric projection across both analyses. The genesis-spine
+    // algorithm requires `genesis` to tokenise identically on each
+    // pair-wise analysis (both have genesis as the OLD side), so the
+    // useProjections decision must agree across both calls.
     const useProjections =
       options.useProjections ??
-      (HtmlDiff.evaluateProjectionApplicability(inV1, inV2) && HtmlDiff.evaluateProjectionApplicability(inV2, inV3))
+      (HtmlDiff.evaluateProjectionApplicability(inGenesis, inCp) &&
+        HtmlDiff.evaluateProjectionApplicability(inGenesis, inMe))
 
     const analyzeOpts: AnalyzeOptions = {
       useProjections,
@@ -379,21 +414,21 @@ export default class HtmlDiff {
       orphanMatchThreshold: options.orphanMatchThreshold,
       ignoreWhitespaceDifferences: options.ignoreWhitespaceDifferences,
     }
-    const d1 = HtmlDiff.analyze(inV1, inV2, analyzeOpts)
-    const d2 = HtmlDiff.analyze(inV2, inV3, analyzeOpts)
+    const dCp = HtmlDiff.analyze(inGenesis, inCp, analyzeOpts)
+    const dMe = HtmlDiff.analyze(inGenesis, inMe, analyzeOpts)
 
-    // Spine sanity check. Symmetric `useProjections` should guarantee
-    // alignment, but if a bug ever lets these diverge we want to fail
-    // loudly rather than silently produce a misattributed output.
-    if (d1.newDiffWords.length !== d2.oldDiffWords.length) {
+    // Spine sanity check — both analyses must share an identical genesis
+    // tokenisation. Symmetric useProjections guarantees this; if it ever
+    // diverges, fail loudly rather than silently misattribute.
+    if (dCp.oldDiffWords.length !== dMe.oldDiffWords.length) {
       throw new Error(
-        'HtmlDiff.executeThreeWay: V2 tokenisation diverged across pair-wise analyses ' +
-          `(${d1.newDiffWords.length} vs ${d2.oldDiffWords.length}). ` +
+        'HtmlDiff.executeThreeWay: genesis tokenisation diverged across pair-wise analyses ' +
+          `(${dCp.oldDiffWords.length} vs ${dMe.oldDiffWords.length}). ` +
           'This indicates the symmetric-projection coordination has a bug.'
       )
     }
 
-    const segments = buildSegments(d1, d2)
+    const segments = buildSegments(dCp, dMe)
     const merged = HtmlDiff.emitSegments(segments)
     return tablePreprocess ? restoreTablePlaceholders(merged, tablePreprocess.placeholderToDiff) : merged
   }
@@ -807,8 +842,13 @@ export default class HtmlDiff {
       // if there are nonTags, the index of the last tag is the index before the first nonTag.
       const indexLastTagInFirstTagBlock = indexOfFirstNonTag === -1 ? words.length - 1 : indexOfFirstNonTag - 1
 
-      let specialCaseTagInjection = ''
-      let specialCaseTagInjectionIsBefore = false
+      // Pre-injection sits BEFORE the extracted tag-block content (used
+      // by closing tags so `</ins></strong>` reads left-to-right).
+      // Post-injection sits AFTER (used by opening tags so the rendered
+      // order is `<strong><ins ...>` and by the overlap-split case so
+      // the re-opened `<ins>`s sit AFTER the actual closing tag).
+      let preInject = ''
+      let postInject = ''
 
       // handle opening tag
       if (HtmlDiff.SpecialCaseOpeningTagRegex.test(words[0])) {
@@ -820,10 +860,11 @@ export default class HtmlDiff {
         }
         const styledTagNames = Array.from(tagNames).join(' ')
 
-        this.specialTagDiffStack.push(words[0])
         // Carry the caller's metadata into the formatting-tag wrapper so
         // a 3-way author tag survives a `<strong>`/`<em>` content edit.
-        specialCaseTagInjection = `<ins${Utils.composeTagAttributes(`mod ${styledTagNames}`, metadata ?? {})}>`
+        const styledCssClass = `mod ${styledTagNames}`
+        this.specialTagDiffStack.push({ tag: words[0], styledTagNames, cssClass: styledCssClass, metadata })
+        postInject = `<ins${Utils.composeTagAttributes(styledCssClass, metadata ?? {})}>`
         if (tag === HtmlDiff.DelTag) {
           words.shift()
 
@@ -835,7 +876,6 @@ export default class HtmlDiff {
       }
       // handle closing tag
       else if (HtmlDiff.SpecialCaseClosingTagsSet.has(words[0].toLowerCase())) {
-        const openingTag = this.specialTagDiffStack.length === 0 ? null : this.specialTagDiffStack.pop()
         // For delete operations: when the tag block contains a mix of formatting and
         // non-formatting closing tags (e.g. </strong></div>), compare against the first
         // closing tag (the formatting one) rather than the last tag in the block.
@@ -850,19 +890,39 @@ export default class HtmlDiff {
             tagIndexToCompare = 0
           }
         }
-        const openingAndClosingTagsMatch =
-          !!openingTag && Utils.getTagName(openingTag) === Utils.getTagName(words[tagIndexToCompare])
 
-        if (openingTag && openingAndClosingTagsMatch) {
-          specialCaseTagInjection = '</ins>'
-          specialCaseTagInjectionIsBefore = true
+        // Search the stack for a matching opener (LIFO). When the match
+        // is the top entry, this is the normal balanced case and we
+        // emit a single `</ins>` before the closing tag. When the match
+        // is below an unmatched opener — i.e. another formatting wrap
+        // opened after it but hasn't been closed yet — the wraps
+        // overlap in source order, which has no valid LIFO HTML
+        // expression. Resolve by SPLITTING the wraps: close everything
+        // above the match (their `<ins>`s and the match's `<ins>`), then
+        // re-open the above wraps with fresh `<ins>` tags AFTER the
+        // closing tag emits. The above wraps continue to apply until
+        // their own closing tag arrives.
+        const closingTagName = Utils.getTagName(words[tagIndexToCompare])
+        let matchIdx = -1
+        for (let i = this.specialTagDiffStack.length - 1; i >= 0; i--) {
+          if (Utils.getTagName(this.specialTagDiffStack[i].tag) === closingTagName) {
+            matchIdx = i
+            break
+          }
         }
 
-        // if the tag has a corresponding opening tag, but they don't match,
-        // we need to push the opening tag back onto the stack
-        else if (openingTag) {
-          this.specialTagDiffStack.push(openingTag)
+        if (matchIdx >= 0) {
+          const aboveEntries = this.specialTagDiffStack.splice(matchIdx + 1)
+          this.specialTagDiffStack.pop() // pop the matched entry
+          // One `</ins>` per above entry, then one for the match itself.
+          preInject = '</ins>'.repeat(aboveEntries.length + 1)
+          for (const entry of aboveEntries) {
+            postInject += `<ins${Utils.composeTagAttributes(entry.cssClass, entry.metadata ?? {})}>`
+            this.specialTagDiffStack.push(entry) // their wrap continues via the new <ins>
+          }
         }
+        // No match in stack — orphan closing tag, drop the `<ins>` work
+        // and just let the tag itself flow through extractConsecutiveWords.
 
         if (tag === HtmlDiff.DelTag) {
           words.shift()
@@ -873,7 +933,7 @@ export default class HtmlDiff {
         }
       }
 
-      if (words.length === 0 && specialCaseTagInjection.length === 0) {
+      if (words.length === 0 && preInject.length === 0 && postInject.length === 0) {
         break
       }
 
@@ -889,11 +949,7 @@ export default class HtmlDiff {
               !HtmlDiff.SpecialCaseClosingTagsSet.has(x.toLowerCase())
           : Utils.isTag
 
-      if (specialCaseTagInjectionIsBefore) {
-        this.content.push(specialCaseTagInjection + this.extractConsecutiveWords(words, isTagForExtraction).join(''))
-      } else {
-        this.content.push(this.extractConsecutiveWords(words, isTagForExtraction).join('') + specialCaseTagInjection)
-      }
+      this.content.push(preInject + this.extractConsecutiveWords(words, isTagForExtraction).join('') + postInject)
 
       if (words.length === 0) continue
 

package/src/ThreeWayDiff.ts

@@ -4,92 +4,134 @@ import type Operation from './Operation'
 import type { WrapMetadata } from './Utils'
 
 /**
- * Composes diff(V1, V2) (CP's changes) and diff(V2, V3) (Me's changes)
- * into a single attributed segment stream. The output is consumed by
- * `HtmlDiff.executeThreeWay` for emission.
+ * Composes diff(genesis → cp-latest) (CP's accumulated changes from the
+ * common ancestor) and diff(genesis → me-current) (Me's accumulated
+ * changes from the common ancestor) into a single attributed segment
+ * stream. The output is consumed by `HtmlDiff.executeThreeWay` for
+ * emission.
  *
- * V2 is the structural spine. Both pair-wise analyses must tokenise V2
- * identically (`HtmlDiff.executeThreeWay` enforces this via the
- * symmetric-projection decision), so V2-diff indices are stable across
- * the two streams and we can fold them into a single per-V2-token
- * attribution view, interleaved with off-spine CP-deletions (V1-side)
- * and Me-insertions (V3-side).
+ * Genesis is the structural spine. Both pair-wise analyses must
+ * tokenise genesis identically (`HtmlDiff.executeThreeWay` enforces
+ * this via the symmetric-projection decision), so genesis-diff indices
+ * are stable across the two streams.
+ *
+ * Per genesis token: classify by what each side did to it
+ * (kept / deleted) and emit accordingly. Per genesis boundary: collect
+ * each side's insertions and check for agreement — when both sides
+ * inserted identical content, the insertion is treated as "settled"
+ * and emitted unmarked (the reader sees the agreed-on text without
+ * authorship markup, matching Word-style track-changes conventions
+ * where both authors agreeing is silent).
+ *
+ * The emission order at a boundary mirrors the 2-way del-then-ins
+ * convention: a Replace (genesis token deleted + a paired insertion)
+ * reads as `<del>old</del><ins>new</ins>`. Pure insertions are
+ * positioned at their natural boundary.
  */
 
 export type Author = 'cp' | 'me'
 
 /**
- * Attribution assigned to each output segment. `reject` is its own kind
- * (rather than a flavour of `del`) so exhaustive switching is safe — no
- * property-presence narrowing required at use sites.
+ * Attribution assigned to each output segment.
+ *
+ * `equal` covers three cases: tokens both authors kept (rendered as the
+ * genesis word), insertion spans both authors made identically (rendered
+ * plain), and structural tags around both-deleted tokens (rendered to
+ * keep layout intact while the content token itself is dropped).
+ * Equal segments carry no markup.
  */
-export type Attribution =
-  | { kind: 'equal' }
-  | { kind: 'ins'; author: Author }
-  | { kind: 'del'; author: Author }
-  // Me deleting tokens that CP inserted = rejecting CP's proposal.
-  | { kind: 'reject'; by: 'me'; rejected: 'cp' }
+export type Attribution = { kind: 'equal' } | { kind: 'ins'; author: Author } | { kind: 'del'; author: Author }
 
 export interface Segment {
   attr: Attribution
-  /** Tokens to emit. For Equal segments these are original V2 words
+  /** Tokens to emit. For Equal segments these are original genesis words
    *  (including structural tags); for ins/del they are diff-space tokens. */
   words: string[]
 }
 
-export function buildSegments(d1: AnalyzeResult, d2: AnalyzeResult): Segment[] {
-  const v2DiffLen = d1.newDiffWords.length
-  const fromV1 = buildOriginMap(d1.operations, v2DiffLen)
-  const toV3 = buildFateMap(d2.operations, v2DiffLen)
-  const cpDeletionsAt = collectDeletionsAtBoundary(d1)
-  const meInsertionsAt = collectInsertionsAtBoundary(d2)
+/**
+ * Builds the attributed segment stream for a three-way diff.
+ *
+ * @param dCp  analysis of diff(genesis → cp-latest)
+ * @param dMe  analysis of diff(genesis → me-current)
+ *
+ * Both analyses must share the same `oldDiffWords` (the genesis tokens)
+ * — the caller guarantees this by passing the same genesis input and
+ * the same `useProjections` decision to both `HtmlDiff.analyze` calls.
+ */
+export function buildSegments(dCp: AnalyzeResult, dMe: AnalyzeResult): Segment[] {
+  const genesisLen = dCp.oldDiffWords.length
+
+  // Per genesis token: did each author keep it or delete it?
+  const cpFate = buildFateFromGenesis(dCp.operations, genesisLen)
+  const meFate = buildFateFromGenesis(dMe.operations, genesisLen)
+
+  // Per boundary: tokens each author inserted at that boundary. Keyed by
+  // `endInOld` so a Replace's insertion sits AFTER the deleted genesis
+  // token (visual del-then-ins). Pure Insert ops have endInOld ==
+  // startInOld so they land at their natural between-tokens boundary.
+  const cpInsAt = collectInsertionsKeyedByEnd(dCp)
+  const meInsAt = collectInsertionsKeyedByEnd(dMe)
 
-  // Inverse map V2-diff-index → V2-original-index. Identity when no projection.
-  const diffToOriginal: readonly number[] = d1.newContentToOriginal ?? Array.from({ length: v2DiffLen }, (_, i) => i)
-  const v2OriginalLen = d1.newOriginalWords.length
+  // Inverse map genesis-diff-index → genesis-original-index. Identity when
+  // no projection. Used to slice the original genesis words for Equal
+  // segments so structural tags pass through verbatim.
+  const diffToOriginal: readonly number[] = dCp.oldContentToOriginal ?? Array.from({ length: genesisLen }, (_, i) => i)
+  const genesisOriginalLen = dCp.oldOriginalWords.length
 
   const segments: Segment[] = []
   let originalCursor = 0
 
-  for (let i = 0; i < v2DiffLen; i++) {
-    // CP-deletions from V1 land BEFORE the V2 token at this boundary —
-    // they conceptually "preceded" V2[i] in V1's stream.
-    const cpDel = cpDeletionsAt.get(i)
-    if (cpDel?.length) appendSegment(segments, { kind: 'del', author: 'cp' }, cpDel)
+  // Boundary 0 — pure insertions BEFORE genesis[0].
+  emitBoundary(0, cpInsAt, meInsAt, dCp.newDiffWords, dMe.newDiffWords, segments)
 
-    const attr = combine(fromV1[i], toV3[i])
+  for (let i = 0; i < genesisLen; i++) {
+    const cpDel = cpFate[i] === 'deleted'
+    const meDel = meFate[i] === 'deleted'
+
+    // Pick up structural tags from cursor through to this genesis token's
+    // original index. Same cursor-based slicing as the 2-way path so a
+    // `<p>` opening tag preceding a content token gets attributed with
+    // that token's segment.
     const origIdx = diffToOriginal[i]
-    const slice = d1.newOriginalWords.slice(originalCursor, origIdx + 1)
+    const slice = dCp.oldOriginalWords.slice(originalCursor, origIdx + 1)
     originalCursor = origIdx + 1
 
-    // Me-insertions at this boundary go BEFORE V2[i] for pure
-    // insertions, but AFTER V2[i] when V2[i] is itself a Me-deletion
-    // (i.e. a Me Replace). This mirrors the 2-way del-then-ins
-    // convention so a Replace reads as `<del>X</del><ins>Y</ins>`.
-    const meIns = meInsertionsAt.get(i)
-    const meInsAfterV2 = meIns?.length && isDeletion(attr)
-
-    if (meIns?.length && !meInsAfterV2) {
-      appendSegment(segments, { kind: 'ins', author: 'me' }, meIns)
-    }
-    appendSegment(segments, attr, slice)
-    if (meInsAfterV2) {
-      appendSegment(segments, { kind: 'ins', author: 'me' }, meIns)
+    if (!cpDel && !meDel) {
+      // Kept by both — equal. Emit the original-word slice (includes
+      // any leading structural tags).
+      appendSegment(segments, { kind: 'equal' }, slice)
+    } else if (cpDel && meDel) {
+      // Both deleted — settled. Filter at emission time; pass the
+      // structural-tag-bearing slice through as equal so layout
+      // survives. The content token itself is the LAST element of the
+      // slice (since slice ends at origIdx+1); drop only that.
+      // If slice has multiple elements (leading structural tags), they
+      // belong to the surrounding flow and should remain.
+      if (slice.length > 1) {
+        appendSegment(segments, { kind: 'equal' }, slice.slice(0, slice.length - 1))
+      }
+      // The content token itself is silenced.
+    } else if (cpDel) {
+      // CP deleted, Me kept → render as <del cp>. Me's keeping means the
+      // token is still in V_me; the markup tells the reader "CP wanted
+      // this gone, you've kept it."
+      appendSegment(segments, { kind: 'del', author: 'cp' }, slice)
+    } else {
+      // Me deleted, CP kept → render as <del me>.
+      appendSegment(segments, { kind: 'del', author: 'me' }, slice)
     }
+
+    // Boundary i+1 — pure insertions between genesis[i] and genesis[i+1],
+    // AND replace-insertions paired with genesis[i] (which we just
+    // emitted as a deletion).
+    emitBoundary(i + 1, cpInsAt, meInsAt, dCp.newDiffWords, dMe.newDiffWords, segments)
   }
-  // Tail-end interleavings (CP-del / Me-ins at boundary v2DiffLen — i.e.
-  // after every V2 token). Ordering doesn't matter since there's no
-  // V2 token to anchor around.
-  const tailCpDel = cpDeletionsAt.get(v2DiffLen)
-  if (tailCpDel?.length) appendSegment(segments, { kind: 'del', author: 'cp' }, tailCpDel)
-  const tailMeIns = meInsertionsAt.get(v2DiffLen)
-  if (tailMeIns?.length) appendSegment(segments, { kind: 'ins', author: 'me' }, tailMeIns)
-
-  // Trailing V2-original tokens (structural closing tags after the last
-  // content word). Emit as equal — there's no following segment to claim
-  // them, and attributing them to either author would be arbitrary.
-  if (originalCursor < v2OriginalLen) {
-    appendSegment(segments, { kind: 'equal' }, d1.newOriginalWords.slice(originalCursor))
+
+  // Trailing original tokens (structural closing tags after the last
+  // content word).
+  if (originalCursor < genesisOriginalLen) {
+    appendSegment(segments, { kind: 'equal' }, dCp.oldOriginalWords.slice(originalCursor))
   }
 
   return segments
@@ -97,80 +139,89 @@ export function buildSegments(d1: AnalyzeResult, d2: AnalyzeResult): Segment[] {
 
 // ────────────────────────────────────────────────────────────────────────────
 
-type V2Origin = 'preserved-from-v1' | 'inserted-by-cp' | 'replaced-into-by-cp'
-type V2Fate = 'preserved-to-v3' | 'deleted-by-me' | 'replaced-out-by-me'
-
-function buildOriginMap(ops: readonly Operation[], v2Len: number): V2Origin[] {
-  const out: V2Origin[] = new Array(v2Len).fill('preserved-from-v1')
-  for (const op of ops) {
-    const origin =
-      op.action === Action.Insert ? 'inserted-by-cp' : op.action === Action.Replace ? 'replaced-into-by-cp' : null
-    if (origin === null) continue
-    for (let i = op.startInNew; i < op.endInNew; i++) {
-      if (i >= 0 && i < v2Len) out[i] = origin
-    }
-  }
-  return out
-}
+type GenesisFate = 'kept' | 'deleted'
 
-function buildFateMap(ops: readonly Operation[], v2Len: number): V2Fate[] {
-  const out: V2Fate[] = new Array(v2Len).fill('preserved-to-v3')
+/**
+ * Per genesis-diff-index, what did this side do to that token? Both
+ * Delete and Replace ops remove the token from the side's output, so
+ * both contribute `'deleted'`. Equal ops contribute `'kept'`. Insert
+ * ops have an empty old range, so they don't touch the genesis fate
+ * map.
+ */
+function buildFateFromGenesis(ops: readonly Operation[], genesisLen: number): GenesisFate[] {
+  const out: GenesisFate[] = new Array(genesisLen).fill('kept')
   for (const op of ops) {
-    const fate =
-      op.action === Action.Delete ? 'deleted-by-me' : op.action === Action.Replace ? 'replaced-out-by-me' : null
-    if (fate === null) continue
+    if (op.action !== Action.Delete && op.action !== Action.Replace) continue
     for (let i = op.startInOld; i < op.endInOld; i++) {
-      if (i >= 0 && i < v2Len) out[i] = fate
+      if (i >= 0 && i < genesisLen) out[i] = 'deleted'
     }
   }
   return out
 }
 
-function isDeletion(attr: Attribution): boolean {
-  return attr.kind === 'del' || attr.kind === 'reject'
-}
-
-function combine(origin: V2Origin, fate: V2Fate): Attribution {
-  const cpInserted = origin === 'inserted-by-cp' || origin === 'replaced-into-by-cp'
-  const meDeleted = fate === 'deleted-by-me' || fate === 'replaced-out-by-me'
-  if (!cpInserted && !meDeleted) return { kind: 'equal' }
-  if (cpInserted && !meDeleted) return { kind: 'ins', author: 'cp' }
-  if (!cpInserted && meDeleted) return { kind: 'del', author: 'me' }
-  return { kind: 'reject', by: 'me', rejected: 'cp' }
-}
-
 /**
- * Map V2-diff-boundary → CP-deleted V1 tokens at that boundary. Includes
- * both pure Delete ops and the V1-side of Replace ops (semantically a
- * Delete+Insert; the Insert half is picked up by the V2-token walk).
+ * Per genesis boundary `b`, collect tokens this side inserted at that
+ * boundary. Keyed by `endInOld` so a Replace at genesis[k..k+1] has its
+ * insertion at boundary k+1 (after the deleted token) rather than k
+ * (before) — that produces the del-then-ins visual order.
+ *
+ * For pure Insert ops the old range is empty (endInOld == startInOld),
+ * so the key is the same as the semantic between-tokens position.
  */
-function collectDeletionsAtBoundary(d: AnalyzeResult): Map<number, string[]> {
+function collectInsertionsKeyedByEnd(d: AnalyzeResult): Map<number, string[]> {
   const out = new Map<number, string[]>()
   for (const op of d.operations) {
-    if (op.action !== Action.Delete && op.action !== Action.Replace) continue
-    const words = d.oldDiffWords.slice(op.startInOld, op.endInOld)
+    if (op.action !== Action.Insert && op.action !== Action.Replace) continue
+    const words = d.newDiffWords.slice(op.startInNew, op.endInNew)
     if (words.length === 0) continue
-    const existing = out.get(op.startInNew) ?? []
+    const key = op.endInOld
+    const existing = out.get(key) ?? []
     existing.push(...words)
-    out.set(op.startInNew, existing)
+    out.set(key, existing)
   }
   return out
 }
 
-function collectInsertionsAtBoundary(d: AnalyzeResult): Map<number, string[]> {
-  const out = new Map<number, string[]>()
-  for (const op of d.operations) {
-    if (op.action !== Action.Insert && op.action !== Action.Replace) continue
-    const words = d.newDiffWords.slice(op.startInNew, op.endInNew)
-    if (words.length === 0) continue
-    const existing = out.get(op.startInOld) ?? []
-    existing.push(...words)
-    out.set(op.startInOld, existing)
+/**
+ * Emit any insertions at boundary `b`. When both authors inserted at
+ * the same boundary AND the inserted token sequences are textually
+ * identical, the insertion is treated as agreed and emitted unmarked.
+ * Otherwise each side's insertion is emitted with author attribution.
+ *
+ * The CP-then-Me ordering for disagreement is arbitrary but consistent;
+ * callers don't depend on it.
+ */
+function emitBoundary(
+  b: number,
+  cpInsAt: Map<number, string[]>,
+  meInsAt: Map<number, string[]>,
+  _cpDiffWords: readonly string[],
+  _meDiffWords: readonly string[],
+  segments: Segment[]
+) {
+  const cpIns = cpInsAt.get(b)
+  const meIns = meInsAt.get(b)
+  const hasCp = !!cpIns && cpIns.length > 0
+  const hasMe = !!meIns && meIns.length > 0
+  if (!hasCp && !hasMe) return
+
+  if (hasCp && hasMe && tokenArraysEqual(cpIns, meIns)) {
+    // Both authors inserted the same content — settled. Emit unmarked.
+    appendSegment(segments, { kind: 'equal' }, cpIns)
+    return
   }
-  return out
+
+  if (hasCp) appendSegment(segments, { kind: 'ins', author: 'cp' }, cpIns)
+  if (hasMe) appendSegment(segments, { kind: 'ins', author: 'me' }, meIns)
 }
 
-function appendSegment(segments: Segment[], attr: Attribution, words: string[]) {
+function tokenArraysEqual(a: readonly string[], b: readonly string[]): boolean {
+  if (a.length !== b.length) return false
+  for (let i = 0; i < a.length; i++) if (a[i] !== b[i]) return false
+  return true
+}
+
+function appendSegment(segments: Segment[], attr: Attribution, words: readonly string[]) {
   if (words.length === 0) return
   const last = segments[segments.length - 1]
   if (last && sameAttribution(last.attr, attr)) {
@@ -184,7 +235,6 @@ function sameAttribution(a: Attribution, b: Attribution): boolean {
   if (a.kind === 'equal' && b.kind === 'equal') return true
   if (a.kind === 'ins' && b.kind === 'ins') return a.author === b.author
   if (a.kind === 'del' && b.kind === 'del') return a.author === b.author
-  if (a.kind === 'reject' && b.kind === 'reject') return true
   return false
 }
 
@@ -195,29 +245,25 @@ function sameAttribution(a: Attribution, b: Attribution): boolean {
  * pre-wrap) stay consistent. A change here propagates to every author
  * marker in the output.
  */
-export function authorAttribution(author: Author, rejects?: Author): WrapMetadata {
-  const dataAttrs: Record<string, string> = { author }
-  if (rejects !== undefined) dataAttrs.rejects = rejects
-  const extraClasses = rejects !== undefined ? `${author} rejects-${rejects}` : author
-  return { extraClasses, dataAttrs }
+export function authorAttribution(author: Author): WrapMetadata {
+  return { extraClasses: author, dataAttrs: { author } }
 }
 
 /**
  * Resolve a segment's attribution into the wrapper-tag, base CSS class,
  * and `WrapMetadata` consumed by `Utils.wrapText` / `insertTag`. The
  * caller is `HtmlDiff.executeThreeWay`'s emission loop.
+ *
+ * `equal` segments don't go through this — they're emitted unmarked.
  */
 export function segmentEmissionShape(attr: Exclude<Attribution, { kind: 'equal' }>): {
   tag: 'ins' | 'del'
   baseClass: 'diffins' | 'diffdel'
   metadata: WrapMetadata
 } {
-  switch (attr.kind) {
-    case 'ins':
-      return { tag: 'ins', baseClass: 'diffins', metadata: authorAttribution(attr.author) }
-    case 'del':
-      return { tag: 'del', baseClass: 'diffdel', metadata: authorAttribution(attr.author) }
-    case 'reject':
-      return { tag: 'del', baseClass: 'diffdel', metadata: authorAttribution(attr.by, attr.rejected) }
+  return {
+    tag: attr.kind,
+    baseClass: attr.kind === 'ins' ? 'diffins' : 'diffdel',
+    metadata: authorAttribution(attr.author),
   }
 }