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

package/dist/HtmlDiff.mjs

@@ -1252,119 +1252,155 @@ function findTopLevelCells(html, start, end) {
 }
 //#endregion
 //#region src/ThreeWayDiff.ts
-function buildSegments(d1, d2) {
-	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);
-	const diffToOriginal = d1.newContentToOriginal ?? Array.from({ length: v2DiffLen }, (_, i) => i);
-	const v2OriginalLen = d1.newOriginalWords.length;
+/**
+* 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.
+*/
+function buildSegments(dCp, dMe) {
+	const genesisLen = dCp.oldDiffWords.length;
+	const cpFate = buildFateFromGenesis(dCp.operations, genesisLen);
+	const meFate = buildFateFromGenesis(dMe.operations, genesisLen);
+	const cpInsAt = collectInsertionsKeyedByEnd(dCp);
+	const meInsAt = collectInsertionsKeyedByEnd(dMe);
+	const diffToOriginal = dCp.oldContentToOriginal ?? Array.from({ length: genesisLen }, (_, i) => i);
+	const genesisOriginalLen = dCp.oldOriginalWords.length;
 	const segments = [];
 	let originalCursor = 0;
-	for (let i = 0; i < v2DiffLen; i++) {
-		const cpDel = cpDeletionsAt.get(i);
-		if (cpDel?.length) appendSegment(segments, {
-			kind: "del",
-			author: "cp"
-		}, cpDel);
-		const attr = combine(fromV1[i], toV3[i]);
+	emitBoundary(0, cpInsAt, meInsAt, dCp.newDiffWords, dMe.newDiffWords, segments);
+	for (let i = 0; i < genesisLen; i++) {
+		const cpDel = cpFate[i] === "deleted";
+		const meDel = meFate[i] === "deleted";
 		const origIdx = diffToOriginal[i];
-		const slice = d1.newOriginalWords.slice(originalCursor, origIdx + 1);
+		const slice = dCp.oldOriginalWords.slice(originalCursor, origIdx + 1);
 		originalCursor = origIdx + 1;
-		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",
+		if (!cpDel && !meDel) appendSegment(segments, { kind: "equal" }, slice);
+		else if (cpDel && meDel) {
+			if (slice.length > 1) appendSegment(segments, { kind: "equal" }, slice.slice(0, slice.length - 1));
+		} else if (cpDel) appendSegment(segments, {
+			kind: "del",
+			author: "cp"
+		}, slice);
+		else appendSegment(segments, {
+			kind: "del",
 			author: "me"
-		}, meIns);
+		}, slice);
+		emitBoundary(i + 1, cpInsAt, meInsAt, dCp.newDiffWords, dMe.newDiffWords, segments);
 	}
-	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);
-	if (originalCursor < v2OriginalLen) appendSegment(segments, { kind: "equal" }, d1.newOriginalWords.slice(originalCursor));
+	if (originalCursor < genesisOriginalLen) appendSegment(segments, { kind: "equal" }, dCp.oldOriginalWords.slice(originalCursor));
 	return segments;
 }
-function buildOriginMap(ops, v2Len) {
-	const out = new Array(v2Len).fill("preserved-from-v1");
-	for (const op of ops) {
-		const origin = op.action === 2 ? "inserted-by-cp" : op.action === 4 ? "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;
-}
-function buildFateMap(ops, v2Len) {
-	const out = new Array(v2Len).fill("preserved-to-v3");
-	for (const op of ops) {
-		const fate = op.action === 1 ? "deleted-by-me" : op.action === 4 ? "replaced-out-by-me" : null;
-		if (fate === null) continue;
-		for (let i = op.startInOld; i < op.endInOld; i++) if (i >= 0 && i < v2Len) out[i] = fate;
-	}
-	return out;
-}
-function isDeletion(attr) {
-	return attr.kind === "del" || attr.kind === "reject";
-}
-function combine(origin, fate) {
-	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-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 collectDeletionsAtBoundary(d) {
-	const out = /* @__PURE__ */ new Map();
-	for (const op of d.operations) {
+function buildFateFromGenesis(ops, genesisLen) {
+	const out = new Array(genesisLen).fill("kept");
+	for (const op of ops) {
 		if (op.action !== 1 && op.action !== 4) continue;
-		const words = d.oldDiffWords.slice(op.startInOld, op.endInOld);
-		if (words.length === 0) continue;
-		const existing = out.get(op.startInNew) ?? [];
-		existing.push(...words);
-		out.set(op.startInNew, existing);
+		for (let i = op.startInOld; i < op.endInOld; i++) if (i >= 0 && i < genesisLen) out[i] = "deleted";
 	}
 	return out;
 }
-function collectInsertionsAtBoundary(d) {
+/**
+* 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 collectInsertionsKeyedByEnd(d) {
 	const out = /* @__PURE__ */ new Map();
 	for (const op of d.operations) {
 		if (op.action !== 2 && op.action !== 4) continue;
 		const words = d.newDiffWords.slice(op.startInNew, op.endInNew);
 		if (words.length === 0) continue;
-		const existing = out.get(op.startInOld) ?? [];
+		const key = op.endInOld;
+		const existing = out.get(key) ?? [];
 		existing.push(...words);
-		out.set(op.startInOld, existing);
+		out.set(key, existing);
 	}
 	return out;
 }
+/**
+* Emit any insertions at boundary `b`.
+*
+* Reading model: a legal reviewer wants to see CP's INTENT relative
+* to Me's current content. Me's content is the base; CP's deltas are
+* what they need to act on. Under that framing:
+*   - tokens both authors inserted at the same boundary → settled
+*   - tokens CP inserted that Me doesn't have → ins-cp (CP wants
+*     this added)
+*   - tokens Me inserted that CP doesn't have → del-cp (CP wants
+*     this removed from Me's content)
+*
+* The third case is the load-bearing attribution flip. The
+* genesis-spine view technically labels me-only-at-boundary tokens
+* as "ins-me" (Me added them; CP didn't), but that's confusing to
+* a reviewer: they see "Me added X" alongside "CP added Y" and have
+* to mentally derive "CP wants X gone, replaced with Y". Surfacing
+* me-only tokens as `del-cp` shows CP's intent directly:
+*   - "CP accepted Me's text minus `things`": settled bulk + del-cp
+*     `things` (no parallel redundant insertions)
+*   - "CP wants `cruel` where Me wrote `brave`": ins-cp `cruel` +
+*     del-cp `brave` (the substitution intent reads directly)
+*   - "CP added extra words": cp-extras stay as ins-cp (same as
+*     before; the cp-only direction was always intent-correct)
+*
+* Pure single-side insertions (Me added text CP doesn't engage
+* with at all, or vice versa) keep their genesis-spine attribution
+* — these aren't refinement cases, just Me's own content additions.
+*/
+function emitBoundary(b, cpInsAt, meInsAt, _cpDiffWords, _meDiffWords, segments) {
+	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) {
+		appendSegment(segments, {
+			kind: "ins",
+			author: "me"
+		}, meIns);
+		return;
+	}
+	if (!hasMe) {
+		appendSegment(segments, {
+			kind: "ins",
+			author: "cp"
+		}, cpIns);
+		return;
+	}
+	if (tokenArraysEqual(cpIns, meIns)) {
+		appendSegment(segments, { kind: "equal" }, cpIns);
+		return;
+	}
+	const alignment = lcsAlign(cpIns, meIns);
+	for (const a of alignment) if (a.oldIdx !== null && a.newIdx !== null) appendSegment(segments, { kind: "equal" }, [cpIns[a.oldIdx]]);
+	else if (a.oldIdx !== null) appendSegment(segments, {
+		kind: "ins",
+		author: "cp"
+	}, [cpIns[a.oldIdx]]);
+	else if (a.newIdx !== null) appendSegment(segments, {
+		kind: "del",
+		author: "cp"
+	}, [meIns[a.newIdx]]);
+}
+function tokenArraysEqual(a, b) {
+	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, attr, words) {
 	if (words.length === 0) return;
 	const last = segments[segments.length - 1];
@@ -1381,7 +1417,6 @@ function sameAttribution(a, b) {
 	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;
 }
 /**
@@ -1391,375 +1426,404 @@ function sameAttribution(a, b) {
 * pre-wrap) stay consistent. A change here propagates to every author
 * marker in the output.
 */
-function authorAttribution(author, rejects) {
-	const dataAttrs = { author };
-	if (rejects !== void 0) dataAttrs.rejects = rejects;
+function authorAttribution(author) {
 	return {
-		extraClasses: rejects !== void 0 ? `${author} rejects-${rejects}` : author,
-		dataAttrs
+		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.
 */
 function segmentEmissionShape(attr) {
-	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)
+	};
 }
 //#endregion
 //#region src/ThreeWayTable.ts
-function preprocessTablesThreeWay(v1, v2, v3, cellDiff) {
-	const t1s = findTopLevelTables(v1);
-	const t2s = findTopLevelTables(v2);
-	const t3s = findTopLevelTables(v3);
-	if (t1s.length === 0 && t2s.length === 0 && t3s.length === 0) return null;
-	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);
-	if (positionallyAligned(v1, v2, v3, t1s, t2s, t3s)) return preprocessAlignedByPosition(v1, v2, v3, t1s, t2s, t3s, cellDiff, placeholderPrefix);
-	return preprocessMisalignedByContent(v1, v2, v3, t1s, t2s, t3s, cellDiff, placeholderPrefix);
-}
-function preprocessAlignedByPosition(v1, v2, v3, t1s, t2s, t3s, cellDiff, placeholderPrefix) {
+function preprocessTablesThreeWay(genesis, cpLatest, meCurrent, cellDiff) {
+	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);
+	return preprocessByContent(genesis, cpLatest, meCurrent, gTables, cTables, mTables, cellDiff, placeholderPrefix);
+}
+function preprocessAlignedByPosition(genesis, cpLatest, meCurrent, gTables, cTables, mTables, cellDiff, placeholderPrefix) {
 	const pairs = [];
-	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)
+	for (let i = 0; i < gTables.length; i++) pairs.push({
+		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 = /* @__PURE__ */ new Map();
 	for (let i = pairs.length - 1; i >= 0; i--) {
 		const placeholder = `${placeholderPrefix}${i}-->`;
 		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,
+		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, v2, v3, t1s, t2s, t3s, cellDiff, placeholderPrefix) {
-	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);
-	const v1ToV2 = new Array(t1s.length).fill(-1);
-	const v2ToV1 = new Array(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(t2s.length).fill(-1);
-	const v3ToV2 = new Array(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;
+function preprocessByContent(genesis, cpLatest, meCurrent, gTables, cTables, mTables, cellDiff, placeholderPrefix) {
+	const gKeys = gTables.map((t) => tableKey(genesis, t));
+	const cKeys = cTables.map((t) => tableKey(cpLatest, t));
+	const mKeys = mTables.map((t) => tableKey(meCurrent, t));
+	const alignCp = pairSimilarTablesThreeWay(lcsAlign(gKeys, cKeys), genesis, cpLatest, gTables, cTables);
+	const alignMe = pairSimilarTablesThreeWay(lcsAlign(gKeys, mKeys), genesis, meCurrent, gTables, mTables);
+	const gToCp = new Array(gTables.length).fill(-1);
+	const cpToG = new Array(cTables.length).fill(-1);
+	for (const a of alignCp) if (a.oldIdx !== null && a.newIdx !== null) {
+		gToCp[a.oldIdx] = a.newIdx;
+		cpToG[a.newIdx] = a.oldIdx;
+	}
+	const gToMe = new Array(gTables.length).fill(-1);
+	const meToG = new Array(mTables.length).fill(-1);
+	for (const a of alignMe) if (a.oldIdx !== null && a.newIdx !== null) {
+		gToMe[a.oldIdx] = a.newIdx;
+		meToG[a.newIdx] = a.oldIdx;
 	}
 	let nextId = 0;
 	const placeholderToDiff = /* @__PURE__ */ new Map();
 	const placeholders = {
-		v1: new Array(t1s.length).fill(null),
-		v2: new Array(t2s.length).fill(null),
-		v3: new Array(t3s.length).fill(null)
+		g: new Array(gTables.length).fill(null),
+		c: new Array(cTables.length).fill(null),
+		m: new Array(mTables.length).fill(null)
 	};
 	const allocate = () => `${placeholderPrefix}${nextId++}-->`;
-	for (let v2Idx = 0; v2Idx < t2s.length; v2Idx++) {
-		const v1Idx = v2ToV1[v2Idx];
-		const v3Idx = v2ToV3[v2Idx];
-		if (v1Idx === -1 || v3Idx === -1) continue;
+	const wrapWhole = (tag, author, tableHtml) => Utils_default.wrapText(tableHtml, tag, `diff${tag}`, authorAttribution(author));
+	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, diffTableThreeWay(v1, v2, v3, t1s[v1Idx], t2s[v2Idx], t3s[v3Idx], cellDiff));
-		placeholders.v1[v1Idx] = placeholder;
-		placeholders.v2[v2Idx] = placeholder;
-		placeholders.v3[v3Idx] = placeholder;
-	}
-	const wrapWhole = (tag, author, tableHtml, rejects) => Utils_default.wrapText(tableHtml, tag, `diff${tag}`, authorAttribution(author, rejects));
-	for (let v2Idx = 0; v2Idx < t2s.length; v2Idx++) {
-		if (placeholders.v2[v2Idx] !== null) continue;
-		const v3Idx = v2ToV3[v2Idx];
-		if (v3Idx === -1) continue;
+		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;
+	}
+	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("ins", "cp", v2.slice(t2s[v2Idx].tableStart, t2s[v2Idx].tableEnd)));
-		placeholders.v2[v2Idx] = placeholder;
-		placeholders.v3[v3Idx] = placeholder;
-	}
-	for (let v2Idx = 0; v2Idx < t2s.length; v2Idx++) {
-		if (placeholders.v2[v2Idx] !== null) continue;
-		const v1Idx = v2ToV1[v2Idx];
-		if (v1Idx === -1) continue;
+		placeholderToDiff.set(placeholder, wrapWhole("del", "me", genesis.slice(gTables[gIdx].tableStart, gTables[gIdx].tableEnd)));
+		placeholders.g[gIdx] = placeholder;
+		placeholders.c[cIdx] = placeholder;
+	}
+	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)));
-		placeholders.v1[v1Idx] = placeholder;
-		placeholders.v2[v2Idx] = placeholder;
+		placeholderToDiff.set(placeholder, wrapWhole("del", "cp", genesis.slice(gTables[gIdx].tableStart, gTables[gIdx].tableEnd)));
+		placeholders.g[gIdx] = placeholder;
+		placeholders.m[mIdx] = placeholder;
 	}
-	for (let v2Idx = 0; v2Idx < t2s.length; v2Idx++) {
-		if (placeholders.v2[v2Idx] !== null) continue;
+	for (let gIdx = 0; gIdx < gTables.length; gIdx++) {
+		if (placeholders.g[gIdx] !== null) continue;
+		const placeholder = allocate();
+		placeholderToDiff.set(placeholder, "");
+		placeholders.g[gIdx] = placeholder;
+	}
+	for (let cIdx = 0; cIdx < cTables.length; cIdx++) {
+		if (placeholders.c[cIdx] !== null) continue;
+		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;
 		const placeholder = allocate();
-		placeholderToDiff.set(placeholder, wrapWhole("del", "me", v2.slice(t2s[v2Idx].tableStart, t2s[v2Idx].tableEnd), "cp"));
-		placeholders.v2[v2Idx] = placeholder;
+		placeholderToDiff.set(placeholder, cpLatest.slice(cTables[cIdx].tableStart, cTables[cIdx].tableEnd));
+		placeholders.c[cIdx] = placeholder;
+		placeholders.m[mIdx] = placeholder;
 	}
-	for (let v1Idx = 0; v1Idx < t1s.length; v1Idx++) {
-		if (placeholders.v1[v1Idx] !== null) continue;
+	for (let cIdx = 0; cIdx < cTables.length; cIdx++) {
+		if (placeholders.c[cIdx] !== null) continue;
 		const placeholder = allocate();
-		placeholderToDiff.set(placeholder, wrapWhole("del", "cp", v1.slice(t1s[v1Idx].tableStart, t1s[v1Idx].tableEnd)));
-		placeholders.v1[v1Idx] = placeholder;
+		placeholderToDiff.set(placeholder, wrapWhole("ins", "cp", cpLatest.slice(cTables[cIdx].tableStart, cTables[cIdx].tableEnd)));
+		placeholders.c[cIdx] = placeholder;
 	}
-	for (let v3Idx = 0; v3Idx < t3s.length; v3Idx++) {
-		if (placeholders.v3[v3Idx] !== null) continue;
+	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;
 	}
-	let modifiedV1 = v1;
-	for (let i = t1s.length - 1; i >= 0; i--) {
-		const p = placeholders.v1[i];
+	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,
+		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 = .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, v2, v3, t1s, t2s, t3s) {
-	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;
+const POSITIONAL_PAIR_SIMILARITY_THRESHOLD = .15;
+function positionallyAligned(genesis, cpLatest, meCurrent, gTables, cTables, mTables) {
+	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, table) {
 	return html.slice(table.tableStart, table.tableEnd).replace(/\s+/g, " ").trim();
 }
-function diffTableThreeWay(v1, v2, v3, t1, t2, t3, cellDiff) {
-	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);
+/**
+* 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 = .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, genesis, newHtml, oldTable, newTable) {
+	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) => {
+		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, oldHtml, newHtml, oldTables, newTables) {
+	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]));
+}
+function diffTableThreeWay(genesis, cpLatest, meCurrent, tG, tC, tM, cellDiff) {
+	if (sameDimensions(tG, tC) && sameDimensions(tC, tM)) return diffTablePositional(genesis, cpLatest, meCurrent, tG, tC, tM, cellDiff);
+	return diffTableStructural(genesis, cpLatest, meCurrent, tG, tC, tM, cellDiff);
 }
-function diffTablePositional(v1, v2, v3, t1, t2, t3, cellDiff) {
+function diffTablePositional(genesis, cpLatest, meCurrent, tG, tC, tM, cellDiff) {
 	const out = [];
-	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;
+	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(genesis.slice(cG.contentStart, cG.contentEnd), cpLatest.slice(cC.contentStart, cC.contentEnd), meCurrent.slice(cM.contentStart, cM.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, v2, v3, t1, t2, t3, cellDiff) {
-	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);
-	const v2Origin = new Array(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(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
-	};
-	const cpDelRowsAt = collectCpDelRowsAtBoundary(align1, t2.rows.length);
-	const meInsRowsAt = collectMeInsRowsAtBoundary(align2, t2.rows.length);
+function diffTableStructural(genesis, cpLatest, meCurrent, tG, tC, tM, cellDiff) {
+	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));
+	const alignCp = pairSimilarRowsThreeWay(lcsAlign(gKeys, cKeys), genesis, cpLatest, tG, tC);
+	const alignMe = pairSimilarRowsThreeWay(lcsAlign(gKeys, mKeys), genesis, meCurrent, tG, tM);
+	const gToCp = new Array(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(tG.rows.length).fill(-1);
+	for (const a of alignMe) if (a.oldIdx !== null && a.newIdx !== null) gToMe[a.oldIdx] = a.newIdx;
+	const cpInsAt = collectInsertedRowsAtBoundary(alignCp, tG.rows.length);
+	const meInsAt = collectInsertedRowsAtBoundary(alignMe, tG.rows.length);
 	const out = [];
-	out.push(tableHeaderSlice(v2, t2));
-	const emitBoundary = (i) => {
-		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"));
+	out.push(tableHeaderSlice(genesis, tG));
+	const emitBoundaryInsertions = (b) => {
+		const cIdxs = cpInsAt.get(b) ?? [];
+		const mIdxs = meInsAt.get(b) ?? [];
+		if (cIdxs.length === 0 && mIdxs.length === 0) return;
+		const remainingMe = new Set(mIdxs);
+		for (const cIdx of cIdxs) {
+			const cText = cKeys[cIdx];
+			let agreedMeIdx;
+			for (const mIdx of remainingMe) if (mKeys[mIdx] === cText) {
+				agreedMeIdx = mIdx;
+				break;
+			}
+			if (agreedMeIdx !== void 0) {
+				remainingMe.delete(agreedMeIdx);
+				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, v2, v3, v2Row, t1, t3, origin, fate, cellDiff) {
-	if (origin.kind === "cp-inserted" && fate.kind === "me-deleted") return emitFullRowAttributed(v2, v2Row, "del", "me", "cp");
-	if (origin.kind === "cp-inserted") return emitFullRowAttributed(v2, v2Row, "ins", "cp");
-	if (fate.kind === "me-deleted") return emitFullRowAttributed(v2, v2Row, "del", "me");
-	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) return diffRowPositional(v1, v2, v3, v1Row, v2Row, v3Row, cellDiff);
-	const out = [];
-	out.push(emitFullRowAttributed(v2, v2Row, "del", "me"));
-	out.push(emitFullRowAttributed(v3, v3Row, "ins", "me"));
-	return out.join("");
-}
-function diffRowPositional(v1, v2, v3, v1Row, v2Row, v3Row, cellDiff) {
-	const out = [];
-	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));
+	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) out.push(emitPreservedRow(genesis, cpLatest, meCurrent, tG.rows[g], tC.rows[cIdx], tM.rows[mIdx], cellDiff));
+		else if (cpDel && meDel) {} else if (cpDel) out.push(emitFullRowAttributed(meCurrent, tM.rows[mIdx], "del", "cp"));
+		else out.push(emitFullRowAttributed(cpLatest, tC.rows[cIdx], "del", "me"));
+	}
+	emitBoundaryInsertions(tG.rows.length);
+	out.push(tableFooterSlice(genesis, tG));
 	return out.join("");
 }
-function collectCpDelRowsAtBoundary(align, v2RowCount) {
-	const out = /* @__PURE__ */ new Map();
-	let nextV2Boundary = v2RowCount;
-	const pending = [];
-	for (let i = align.length - 1; i >= 0; i--) {
-		const a = align[i];
-		if (a.newIdx !== null) {
-			if (pending.length > 0) {
-				const existing = out.get(nextV2Boundary) ?? [];
-				existing.unshift(...pending.toReversed());
-				out.set(nextV2Boundary, existing);
-				pending.length = 0;
-			}
-			nextV2Boundary = a.newIdx;
-		} else if (a.oldIdx !== null) pending.push(a.oldIdx);
-	}
-	if (pending.length > 0) {
-		const existing = out.get(nextV2Boundary) ?? [];
-		existing.unshift(...pending.reverse());
-		out.set(nextV2Boundary, existing);
+function emitPreservedRow(genesis, cpLatest, meCurrent, rG, rC, rM, cellDiff) {
+	if (rG.cells.length === rC.cells.length && rC.cells.length === rM.cells.length) {
+		const out = [];
+		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 = cG.contentEnd;
+		}
+		out.push(genesis.slice(cursor, rG.rowEnd));
+		return out.join("");
+	}
+	const cpRestructured = rC.cells.length !== rG.cells.length;
+	const meRestructured = rM.cells.length !== rG.cells.length;
+	const blocks = [];
+	if (cpRestructured && meRestructured) {
+		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 out;
+	return blocks.join("");
 }
-function collectMeInsRowsAtBoundary(align, v2RowCount) {
+/**
+* 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, genesisRowCount) {
 	const out = /* @__PURE__ */ new Map();
-	let nextV2Boundary = v2RowCount;
+	let nextGenesisBoundary = genesisRowCount;
 	const pending = [];
 	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;
 }
@@ -1774,42 +1838,35 @@ function tableFooterSlice(html, 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, row, kind, author, rejectsAuthor) {
+function emitFullRowAttributed(html, row, kind, author) {
 	const trOpening = parseOpeningTagAt(html, row.rowStart);
-	if (!trOpening) return html.slice(html.length, html.length);
-	const out = [injectAuthorAttribution(html.slice(row.rowStart, trOpening.end), kind, author, rejectsAuthor)];
+	if (!trOpening) return html.slice(row.rowStart, row.rowEnd);
+	const out = [injectAuthorAttribution(html.slice(row.rowStart, trOpening.end), kind, author)];
 	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, cell, kind, author, rejectsAuthor) {
+function emitFullCellAttributed(html, cell, kind, author) {
 	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);
+	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_default.wrapText(innerContent, kind, `diff${kind}`, authorAttribution(author, rejectsAuthor));
+	const innerWrapped = innerContent.trim().length === 0 ? innerContent : Utils_default.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, kind, author, rejectsAuthor) {
-	const meta = authorAttribution(author, rejectsAuthor);
+function injectAuthorAttribution(openingTag, kind, author) {
+	const meta = authorAttribution(author);
 	return injectDataAttrs(injectClass(openingTag, `diff${kind} ${meta.extraClasses}`), meta.dataAttrs ?? {});
 }
 function injectDataAttrs(openingTag, dataAttrs) {
@@ -2014,6 +2071,37 @@ var BlockFinder = class {
 };
 //#endregion
 //#region src/HtmlDiff.ts
+/**
+* Opinionated options that align htmldiff's output with Microsoft Word's
+* track-changes rendering for legal-document rewrites.
+*
+* The library's bare default (`orphanMatchThreshold = 0`) keeps every
+* LCS match, however small — which fragments long sentence rewrites
+* into many tiny ins/del pairs around stray word matches ("of", "the",
+* "shall"). Word collapses those into a single coarse del+ins, which is
+* dramatically more readable for legal text.
+*
+* 0.25 was tuned empirically against a customer Word reference (US
+* Commercial One CP, May 2026):
+*   - short edits (typo / one-word insert): output identical to
+*     threshold=0 — inter-match distances are tiny so every match
+*     trivially clears the bar;
+*   - long rewrites (the "Specified Indebtedness" rewrite in the
+*     reference): previously produced 6 dels + 5 ins fragmented around
+*     stray matches; at 0.25 it condenses to 3 dels + 2 ins — close to
+*     Word's 1+1 and a major readability win;
+*   - higher values (0.3+) collapsed short edits containing inline
+*     formatting changes into a single block — too aggressive.
+*
+* Consumers rendering legal documents should spread this into their
+* options:
+*   `HtmlDiff.execute(old, new, { ...WORD_ALIGNED_OPTIONS })`
+*   `HtmlDiff.executeThreeWay(g, c, m, { ...WORD_ALIGNED_OPTIONS })`
+*
+* Other consumers (machine-readable diff, exact-token alignment) can
+* keep the bare default.
+*/
+const WORD_ALIGNED_OPTIONS = { orphanMatchThreshold: .25 };
 var HtmlDiff = class HtmlDiff {
 	/**
 	* This value defines balance between speed and memory utilization. The higher it is the faster it works and more memory consumes.
@@ -2089,6 +2177,16 @@ var HtmlDiff = class HtmlDiff {
 	newText;
 	oldText;
 	tablePreprocessDepth = 0;
+	/**
+	* 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.
+	*/
 	specialTagDiffStack = [];
 	newWords = [];
 	oldWords = [];
@@ -2156,8 +2254,23 @@ var HtmlDiff = class HtmlDiff {
 		this.oldText = oldText;
 		this.newText = newText;
 	}
-	static execute(oldText, newText) {
-		return new HtmlDiff(oldText, newText).build();
+	/**
+	* Two-way diff entry point. Accepts the same `AnalyzeOptions` bag as
+	* `executeThreeWay`, with two intentional exceptions documented
+	* inline below. Consumers wanting Word-aligned output should spread
+	* `WORD_ALIGNED_OPTIONS` into the third argument.
+	*
+	* Note: unlike `analyze`, `execute` runs `build()` which performs
+	* full table preprocessing — `tablePreprocessDepth` stays at 0 so
+	* the recursive cell diff can happen. Callers can't override that.
+	*/
+	static execute(oldText, newText, options = {}) {
+		const inner = new HtmlDiff(oldText, newText);
+		if (options.blockExpressions) for (const expr of options.blockExpressions) inner.addBlockExpression(expr);
+		if (options.repeatingWordsAccuracy !== void 0) inner.repeatingWordsAccuracy = options.repeatingWordsAccuracy;
+		if (options.orphanMatchThreshold !== void 0) inner.orphanMatchThreshold = options.orphanMatchThreshold;
+		if (options.ignoreWhitespaceDifferences !== void 0) inner.ignoreWhitespaceDifferences = options.ignoreWhitespaceDifferences;
+		return inner.build();
 	}
 	/**
 	* Analyse a two-way diff and return its raw building blocks: the word
@@ -2226,40 +2339,43 @@ var HtmlDiff = class HtmlDiff {
 		return HtmlDiff.shouldUseContentProjections(oldWords, newWords, oldProj, newProj);
 	}
 	/**
-	* Three-way HTML diff. Given V1 (the version Me last sent), V2 (the
-	* version CP sent back), and V3 (Me's current draft), produces a
-	* single attributed HTML output where CP's and Me's changes are
-	* distinguished by `data-author` ('cp' or 'me') and matching
-	* `class='diffins cp'` / `class='diffdel me'` etc. The "Me rejected
-	* CP's proposal" case (Me deleted text CP had inserted) gets a
-	* dedicated marker: `data-rejects='cp'` plus `class='... rejects-cp'`.
+	* 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.
 	*
-	* Coordinates the symmetric-projection decision (D1) across both
-	* internal `analyze` calls so V2 tokenises identically on each side
-	* of the spine. When `useProjections` is left undefined, the decision
-	* is the conjunction of both pair-wise heuristics — project iff both
-	* pairs would project on their own. Pass an explicit boolean to
-	* override.
+	* 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(v1, v2, v3, options = {}) {
-		return HtmlDiff.executeThreeWayWithDepth(v1, v2, v3, options, 0);
-	}
-	static executeThreeWayWithDepth(v1, v2, v3, options, depth) {
-		const tablePreprocess = depth < HtmlDiff.MaxThreeWayDepth ? preprocessTablesThreeWay(v1, v2, v3, (c1, c2, c3) => HtmlDiff.executeThreeWayWithDepth(c1, c2, c3, options, depth + 1)) : null;
-		const inV1 = tablePreprocess?.modifiedV1 ?? v1;
-		const inV2 = tablePreprocess?.modifiedV2 ?? v2;
-		const inV3 = tablePreprocess?.modifiedV3 ?? v3;
+	static executeThreeWay(genesis, cpLatest, meCurrent, options = {}) {
+		return HtmlDiff.executeThreeWayWithDepth(genesis, cpLatest, meCurrent, options, 0);
+	}
+	static executeThreeWayWithDepth(genesis, cpLatest, meCurrent, options, depth) {
+		const tablePreprocess = depth < HtmlDiff.MaxThreeWayDepth ? preprocessTablesThreeWay(genesis, cpLatest, meCurrent, (g, c, m) => HtmlDiff.executeThreeWayWithDepth(g, c, m, options, depth + 1)) : null;
+		const inGenesis = tablePreprocess?.modifiedGenesis ?? genesis;
+		const inCp = tablePreprocess?.modifiedCp ?? cpLatest;
+		const inMe = tablePreprocess?.modifiedMe ?? meCurrent;
 		const analyzeOpts = {
-			useProjections: options.useProjections ?? (HtmlDiff.evaluateProjectionApplicability(inV1, inV2) && HtmlDiff.evaluateProjectionApplicability(inV2, inV3)),
+			useProjections: options.useProjections ?? (HtmlDiff.evaluateProjectionApplicability(inGenesis, inCp) && HtmlDiff.evaluateProjectionApplicability(inGenesis, inMe)),
 			blockExpressions: options.blockExpressions,
 			repeatingWordsAccuracy: options.repeatingWordsAccuracy,
 			orphanMatchThreshold: options.orphanMatchThreshold,
 			ignoreWhitespaceDifferences: options.ignoreWhitespaceDifferences
 		};
-		const d1 = HtmlDiff.analyze(inV1, inV2, analyzeOpts);
-		const d2 = HtmlDiff.analyze(inV2, inV3, analyzeOpts);
-		if (d1.newDiffWords.length !== d2.oldDiffWords.length) throw new Error(`HtmlDiff.executeThreeWay: V2 tokenisation diverged across pair-wise analyses (${d1.newDiffWords.length} vs ${d2.oldDiffWords.length}). This indicates the symmetric-projection coordination has a bug.`);
-		const segments = buildSegments(d1, d2);
+		const dCp = HtmlDiff.analyze(inGenesis, inCp, analyzeOpts);
+		const dMe = HtmlDiff.analyze(inGenesis, inMe, analyzeOpts);
+		if (dCp.oldDiffWords.length !== dMe.oldDiffWords.length) throw new Error(`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(dCp, dMe);
 		const merged = HtmlDiff.emitSegments(segments);
 		return tablePreprocess ? restoreTablePlaceholders(merged, tablePreprocess.placeholderToDiff) : merged;
 	}
@@ -2269,6 +2385,25 @@ var HtmlDiff = class HtmlDiff {
 	* buffer. Reusing the instance keeps the formatting-tag stack
 	* (`specialTagDiffStack`) coherent across segments — a `<strong>`
 	* opened in one segment and closed in another stays balanced.
+	*
+	* Edge case: an ins/del segment can open a formatting wrap whose
+	* matching closer ends up in an equal segment (`<strong>` deleted
+	* by CP but `</strong>` kept by both — buildSegments emits the open
+	* as del-cp and the close as equal). Equal segments bypass
+	* `insertTag` and push raw, so the stack entry for the open is
+	* never popped. Rather than throw — which forces the caller's UI
+	* into an error boundary — close every leftover wrap with `</ins>`
+	* at the end of emission.
+	*
+	* Caveat: the `</ins>` close is honest for the mod-wrap that the
+	* opener pushed (every formatting opener emits an inner `<ins…>`
+	* postInject regardless of whether the outer segment is ins or
+	* del). For del-segment formatting openers the outer `<del>` may
+	* itself be left open by the same emission imbalance; this fixup
+	* doesn't address that. Downstream browsers/DOMParser normalise
+	* mildly-malformed HTML by closing dangling tags, so the rendered
+	* output is usually acceptable — but the warning IS the signal
+	* that the input had a real imbalance worth investigating.
 	*/
 	static emitSegments(segments) {
 		const emitter = new HtmlDiff("", "");
@@ -2280,7 +2415,13 @@ var HtmlDiff = class HtmlDiff {
 			const { tag, baseClass, metadata } = segmentEmissionShape(seg.attr);
 			emitter.insertTag(tag, baseClass, [...seg.words], metadata);
 		}
-		if (emitter.specialTagDiffStack.length > 0) throw new Error(`HtmlDiff.executeThreeWay: emission left ${emitter.specialTagDiffStack.length} unclosed formatting tag(s) on the stack — input may have unbalanced <strong>/<em>/etc. or there is a bug in segment emission.`);
+		if (emitter.specialTagDiffStack.length > 0) {
+			console.warn(`HtmlDiff.executeThreeWay: emission left ${emitter.specialTagDiffStack.length} unclosed formatting wrap(s) on the stack. Closing defensively. This usually means a formatting tag opens in a del/ins segment and its matching closer is in an equal segment.`);
+			while (emitter.specialTagDiffStack.length > 0) {
+				emitter.content.push("</ins>");
+				emitter.specialTagDiffStack.pop();
+			}
+		}
 		return emitter.content.join("");
 	}
 	/**
@@ -2536,38 +2677,52 @@ var HtmlDiff = class HtmlDiff {
 			if (words.length === 0) break;
 			const indexOfFirstNonTag = words.findIndex((x) => !Utils_default.isTag(x));
 			const indexLastTagInFirstTagBlock = indexOfFirstNonTag === -1 ? words.length - 1 : indexOfFirstNonTag - 1;
-			let specialCaseTagInjection = "";
-			let specialCaseTagInjectionIsBefore = false;
+			let preInject = "";
+			let postInject = "";
 			if (HtmlDiff.SpecialCaseOpeningTagRegex.test(words[0])) {
 				const tagNames = /* @__PURE__ */ new Set();
 				for (const word of words) if (Utils_default.isTag(word)) tagNames.add(Utils_default.getTagName(word));
 				const styledTagNames = Array.from(tagNames).join(" ");
-				this.specialTagDiffStack.push(words[0]);
-				specialCaseTagInjection = `<ins${Utils_default.composeTagAttributes(`mod ${styledTagNames}`, metadata ?? {})}>`;
+				const styledCssClass = `mod ${styledTagNames}`;
+				this.specialTagDiffStack.push({
+					tag: words[0],
+					styledTagNames,
+					cssClass: styledCssClass,
+					metadata
+				});
+				postInject = `<ins${Utils_default.composeTagAttributes(styledCssClass, metadata ?? {})}>`;
 				if (tag === HtmlDiff.DelTag) {
 					words.shift();
 					while (words.length > 0 && HtmlDiff.SpecialCaseOpeningTagRegex.test(words[0])) words.shift();
 				}
 			} else if (HtmlDiff.SpecialCaseClosingTagsSet.has(words[0].toLowerCase())) {
-				const openingTag = this.specialTagDiffStack.length === 0 ? null : this.specialTagDiffStack.pop();
 				let tagIndexToCompare = indexLastTagInFirstTagBlock;
 				if (tag === HtmlDiff.DelTag && indexOfFirstNonTag === -1) {
 					if (words.slice(0, indexLastTagInFirstTagBlock + 1).some((w) => !HtmlDiff.SpecialCaseClosingTagsSet.has(w.toLowerCase()))) tagIndexToCompare = 0;
 				}
-				const openingAndClosingTagsMatch = !!openingTag && Utils_default.getTagName(openingTag) === Utils_default.getTagName(words[tagIndexToCompare]);
-				if (openingTag && openingAndClosingTagsMatch) {
-					specialCaseTagInjection = "</ins>";
-					specialCaseTagInjectionIsBefore = true;
-				} else if (openingTag) this.specialTagDiffStack.push(openingTag);
+				const closingTagName = Utils_default.getTagName(words[tagIndexToCompare]);
+				let matchIdx = -1;
+				for (let i = this.specialTagDiffStack.length - 1; i >= 0; i--) if (Utils_default.getTagName(this.specialTagDiffStack[i].tag) === closingTagName) {
+					matchIdx = i;
+					break;
+				}
+				if (matchIdx >= 0) {
+					const aboveEntries = this.specialTagDiffStack.splice(matchIdx + 1);
+					this.specialTagDiffStack.pop();
+					preInject = "</ins>".repeat(aboveEntries.length + 1);
+					for (const entry of aboveEntries) {
+						postInject += `<ins${Utils_default.composeTagAttributes(entry.cssClass, entry.metadata ?? {})}>`;
+						this.specialTagDiffStack.push(entry);
+					}
+				}
 				if (tag === HtmlDiff.DelTag) {
 					words.shift();
 					while (words.length > 0 && HtmlDiff.SpecialCaseClosingTagsSet.has(words[0].toLowerCase())) words.shift();
 				}
 			}
-			if (words.length === 0 && specialCaseTagInjection.length === 0) break;
+			if (words.length === 0 && preInject.length === 0 && postInject.length === 0) break;
 			const isTagForExtraction = tag === HtmlDiff.DelTag ? (x) => Utils_default.isTag(x) && !HtmlDiff.SpecialCaseOpeningTagRegex.test(x) && !HtmlDiff.SpecialCaseClosingTagsSet.has(x.toLowerCase()) : Utils_default.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;
 			this.insertTag(tag, cssClass, words, metadata);
 			break;
@@ -2632,6 +2787,17 @@ var HtmlDiff = class HtmlDiff {
 				curr = next;
 				continue;
 			}
+			let allTags = true;
+			for (let i = curr.startInNew; i < curr.endInNew; i++) if (!Utils_default.isTag(wordsForDiffNew[i])) {
+				allTags = false;
+				break;
+			}
+			if (allTags) {
+				yield curr;
+				prev = curr;
+				curr = next;
+				continue;
+			}
 			let oldDistanceInChars = 0;
 			for (let i = prev.endInOld; i < next.startInOld; i++) oldDistanceInChars += wordsForDiffOld[i].length;
 			let newDistanceInChars = 0;
@@ -2674,6 +2840,6 @@ var HtmlDiff = class HtmlDiff {
 	}
 };
 //#endregion
-export { HtmlDiff as default };
+export { WORD_ALIGNED_OPTIONS, HtmlDiff as default };
 
 //# sourceMappingURL=HtmlDiff.mjs.map