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

package/dist/HtmlDiff.mjs

@@ -1252,119 +1252,119 @@ 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`. 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, 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 && hasMe && tokenArraysEqual(cpIns, meIns)) {
+		appendSegment(segments, { kind: "equal" }, cpIns);
+		return;
+	}
+	if (hasCp) appendSegment(segments, {
+		kind: "ins",
+		author: "cp"
+	}, cpIns);
+	if (hasMe) appendSegment(segments, {
+		kind: "ins",
+		author: "me"
+	}, meIns);
+}
+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 +1381,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 +1390,338 @@ 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 = lcsAlign(gKeys, cKeys);
+	const alignMe = lcsAlign(gKeys, mKeys);
+	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;
+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);
+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 = lcsAlign(gKeys, cKeys);
+	const alignMe = lcsAlign(gKeys, mKeys);
+	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"));
+	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 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));
-	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("");
 	}
-	return out;
+	return emitFullRowAttributed(genesis, rG, "del", "me") + emitFullRowAttributed(meCurrent, rM, "ins", "me");
 }
-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 +1736,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) {
@@ -2241,25 +2196,44 @@ var HtmlDiff = class HtmlDiff {
 	* pairs would project on their own. Pass an explicit boolean to
 	* override.
 	*/
-	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;
+	/**
+	* 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, 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;
 	}