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

package/dist/HtmlDiff.d.cts

@@ -202,22 +202,6 @@ declare class HtmlDiff {
    * why symmetry matters.
    */
   static evaluateProjectionApplicability(oldText: string, newText: string): boolean;
-  /**
-   * 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'`.
-   *
-   * 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.
-   */
   /**
    * Three-way HTML diff against a shared genesis. Produces attributed
    * HTML that distinguishes CP's accumulated changes (genesis → cpLatest)
@@ -245,6 +229,17 @@ declare 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. The resulting HTML has an extra
+   * `</ins>` next to the formatting closer; DOMParser-normalisation
+   * downstream produces sensible nesting.
    */
   private static emitSegments;
   /**

package/dist/HtmlDiff.d.mts

@@ -202,22 +202,6 @@ declare class HtmlDiff {
    * why symmetry matters.
    */
   static evaluateProjectionApplicability(oldText: string, newText: string): boolean;
-  /**
-   * 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'`.
-   *
-   * 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.
-   */
   /**
    * Three-way HTML diff against a shared genesis. Produces attributed
    * HTML that distinguishes CP's accumulated changes (genesis → cpLatest)
@@ -245,6 +229,17 @@ declare 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. The resulting HTML has an extra
+   * `</ins>` next to the formatting closer; DOMParser-normalisation
+   * downstream produces sensible nesting.
    */
   private static emitSegments;
   /**

package/dist/HtmlDiff.mjs

@@ -1580,7 +1580,7 @@ function preprocessByContent(genesis, cpLatest, meCurrent, gTables, cTables, mTa
 		placeholderToDiff
 	};
 }
-const POSITIONAL_PAIR_SIMILARITY_THRESHOLD = .5;
+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++) {
@@ -1695,7 +1695,20 @@ function emitPreservedRow(genesis, cpLatest, meCurrent, rG, rC, rM, cellDiff) {
 		out.push(genesis.slice(cursor, rG.rowEnd));
 		return out.join("");
 	}
-	return emitFullRowAttributed(genesis, rG, "del", "me") + emitFullRowAttributed(meCurrent, rM, "ins", "me");
+	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 blocks.join("");
 }
 /**
 * Returns map "genesis-row-boundary → list of new-side row indices
@@ -2191,22 +2204,6 @@ 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'`.
-	*
-	* 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.
-	*/
-	/**
 	* 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
@@ -2253,6 +2250,17 @@ 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. The resulting HTML has an extra
+	* `</ins>` next to the formatting closer; DOMParser-normalisation
+	* downstream produces sensible nesting.
 	*/
 	static emitSegments(segments) {
 		const emitter = new HtmlDiff("", "");
@@ -2264,7 +2272,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("");
 	}
 	/**