open-agreements 0.7.6 → 0.8.0

package/node_modules/@usejunior/docx-core/dist/baselines/atomizer/documentReconstructor.js

@@ -8,8 +8,11 @@ import { XMLSerializer } from '@xmldom/xmldom';
 import { parseXml } from '../../primitives/xml.js';
 import { CorrelationStatus } from '../../core-types.js';
 import { getLeafText, childElements, findChildByTagName } from '../../primitives/index.js';
+import { allocateRevisionId, buildPPrChangeElement, convertSerializedDeletionContent, createRevisionContext, createRevisionIdState, escapeXmlAttr, formatDate, wrapSerializedContentWithDel, wrapSerializedContentWithIns, } from '../../primitives/track-changes-emitter.js';
 import { serializeToXml, cloneElement } from './xmlToWmlElement.js';
-import { EMPTY_PARAGRAPH_TAG } from '../../atomizer.js';
+import { EMPTY_PARAGRAPH_TAG, isParagraphLevelLeaf, nearestHyperlinkAncestor } from '../../atomizer.js';
+import { enforceConsumerCompatibility } from './consumerCompatibility.js';
+import { placeParagraphMarkRevisionMarker } from './inPlaceModifier-wrappers.js';
 import { areRunPropertiesEqual } from '../../format-detection.js';
 import { debug } from './debug.js';
 const SYNTHETIC_DOC = parseXml('<root xmlns:w="http://schemas.openxmlformats.org/wordprocessingml/2006/main"/>');
@@ -21,21 +24,6 @@ function createEl(tag, attrs) {
             el.setAttribute(k, v);
     return el;
 }
-/**
- * Create initial revision ID state.
- */
-function createRevisionIdState() {
-    return {
-        nextId: 1,
-        moveRangeIds: new Map(),
-    };
-}
-/**
- * Allocate a new revision ID.
- */
-function allocateRevisionId(state) {
-    return state.nextId++;
-}
 /**
  * Get or allocate move range IDs for a move name.
  */
@@ -50,12 +38,6 @@ function getMoveRangeIds(state, moveName) {
     }
     return ids;
 }
-/**
- * Format date for OOXML (ISO 8601).
- */
-function formatDate(date) {
-    return date.toISOString().replace(/\.\d{3}Z$/, 'Z');
-}
 /**
  * Reconstruct document.xml from merged atoms with track changes.
  *
@@ -87,7 +69,7 @@ export function reconstructDocument(mergedAtoms, originalXml, options) {
     const emptyCounters = getEmptyParagraphCounters();
     debug('reconstructor', `Empty paragraphs: inserted=${emptyCounters.inserted}, deleted=${emptyCounters.deleted}, equal=${emptyCounters.equal}, other=${emptyCounters.other}`);
     // Reconstruct the document, preserving original body structure (tables, SDTs, etc.)
-    return buildDocumentPreservingStructure(originalXml, paragraphXmls, paragraphGroups);
+    return buildDocumentPreservingStructure(originalXml, paragraphXmls, paragraphGroups, () => allocateRevisionId(revState));
 }
 /**
  * Group atoms by paragraph based on their ancestor chain.
@@ -342,8 +324,14 @@ function shouldStartNewRunGroup(currentGroup, atom) {
     if (currentGroup.moveName !== atom.moveName) {
         return true;
     }
-    // Skip rPr splitting for MovedSource/MovedDestination to avoid
-    // duplicate move range markers (moveFromRangeStart/End)
+    // Skip rPr splitting for MovedSource/MovedDestination: every moved run
+    // group is wrapped by wrapWithMoveFrom/wrapWithMoveTo, so splitting one
+    // move into several groups would emit moveFromRangeStart/End (resp.
+    // moveToRangeStart/End) once per slice with the same w:name and range ids.
+    // This stays required now that explicit move-range markers atomize: the
+    // synthetic-range suppression keyed off those markers is per paragraph, so
+    // a detected move in a marker-free paragraph still synthesizes one range
+    // pair per moved run group.
     if (currentGroup.status === CorrelationStatus.MovedSource ||
         currentGroup.status === CorrelationStatus.MovedDestination) {
         return false;
@@ -419,10 +407,28 @@ function isEmptyParagraphGroup(group) {
     }
     return group.runGroups.length > 0;
 }
+const NO_EXPLICIT_MOVE_MARKERS = { moveFrom: false, moveTo: false };
+function collectExplicitMoveMarkers(group) {
+    let moveFrom = false;
+    let moveTo = false;
+    for (const runGroup of group.runGroups) {
+        for (const atom of runGroup.atoms) {
+            const tag = atom.contentElement.tagName;
+            if (tag === 'w:moveFromRangeStart' || tag === 'w:moveFromRangeEnd') {
+                moveFrom = true;
+            }
+            else if (tag === 'w:moveToRangeStart' || tag === 'w:moveToRangeEnd') {
+                moveTo = true;
+            }
+        }
+    }
+    return { moveFrom, moveTo };
+}
 /**
  * Build XML for a single paragraph with track changes.
  */
 function buildParagraphXml(group, author, dateStr, revState) {
+    const revisionCtx = createRevisionContext({ author, date: dateStr, idState: revState });
     // Track empty paragraph statuses for debugging
     if (isEmptyParagraphGroup(group)) {
         const status = group.runGroups[0]?.atoms[0]?.correlationStatus;
@@ -460,33 +466,25 @@ function buildParagraphXml(group, author, dateStr, revState) {
     // entirely (instead of leaving behind a stub <w:p> break).
     if (isEntireParagraphWithStatus(group, CorrelationStatus.Inserted)) {
         const paraId = allocateRevisionId(revState);
-        const runId = allocateRevisionId(revState);
-        const pPrChangeEl = buildPPrChangeElement(group.pPr, author, dateStr, revState);
+        const insertedRunXml = paragraphHasHyperlinkAtoms(group)
+            ? buildWholeParagraphRevisionContent(group, (runs) => wrapSerializedContentWithIns(runs, revisionCtx))
+            : wrapSerializedContentWithIns(group.runGroups.map((runGroup) => buildRunContentAsPlainRun(runGroup)).join(''), revisionCtx);
+        const pPrChangeEl = buildPPrChangeElement(group.pPr, revisionCtx);
         const parts = [];
         parts.push('<w:p>');
         parts.push(serializePPrWithParaRevisionMarker(group.pPr, 'w:ins', paraId, author, dateStr, pPrChangeEl));
-        parts.push(`<w:ins w:id="${runId}" w:author="${escapeXmlAttr(author)}" w:date="${dateStr}">`);
-        for (const runGroup of group.runGroups) {
-            parts.push(buildRunContentAsPlainRun(runGroup));
-        }
-        parts.push('</w:ins>');
+        parts.push(insertedRunXml);
         parts.push('</w:p>');
         return parts.join('');
     }
     if (isEntireParagraphWithStatus(group, CorrelationStatus.Deleted)) {
         const paraId = allocateRevisionId(revState);
-        const runId = allocateRevisionId(revState);
         const parts = [];
         parts.push('<w:p>');
         parts.push(serializePPrWithParaRevisionMarker(group.pPr, 'w:del', paraId, author, dateStr));
-        parts.push(`<w:del w:id="${runId}" w:author="${escapeXmlAttr(author)}" w:date="${dateStr}">`);
-        for (const runGroup of group.runGroups) {
-            const plainRun = buildRunContentAsPlainRun(runGroup);
-            parts.push(plainRun
-                .replace(/<w:t([^>]*)>([^<]*)<\/w:t>/g, '<w:delText$1>$2</w:delText>')
-                .replace(/<w:instrText([^>]*)>([^<]*)<\/w:instrText>/g, '<w:delInstrText$1>$2</w:delInstrText>'));
-        }
-        parts.push('</w:del>');
+        parts.push(paragraphHasHyperlinkAtoms(group)
+            ? buildWholeParagraphRevisionContent(group, (runs) => wrapSerializedContentWithDel(runs, revisionCtx))
+            : wrapSerializedContentWithDel(group.runGroups.map((runGroup) => buildRunContentAsPlainRun(runGroup)).join(''), revisionCtx));
         parts.push('</w:p>');
         return parts.join('');
     }
@@ -495,7 +493,7 @@ function buildParagraphXml(group, author, dateStr, revState) {
     // marker inside w:pPr > w:rPr.
     if (isEmptyParagraphWithStatus(group, CorrelationStatus.Inserted)) {
         const paraId = allocateRevisionId(revState);
-        const pPrChangeEl = buildPPrChangeElement(group.pPr, author, dateStr, revState);
+        const pPrChangeEl = buildPPrChangeElement(group.pPr, revisionCtx);
         const pPrXml = serializePPrWithParaRevisionMarker(group.pPr, 'w:ins', paraId, author, dateStr, pPrChangeEl);
         return `<w:p>${pPrXml}</w:p>`;
     }
@@ -511,10 +509,18 @@ function buildParagraphXml(group, author, dateStr, revState) {
     if (group.pPr) {
         parts.push(serializeToXml(group.pPr));
     }
-    // Add run groups with track changes
-    for (const runGroup of group.runGroups) {
-        const runXml = buildRunGroupXml(runGroup, author, dateStr, revState);
-        parts.push(runXml);
+    // Add run groups with track changes, restoring w:hyperlink wrappers when
+    // the paragraph contains hyperlink atoms (issue #368). Hyperlink-free
+    // paragraphs keep the legacy per-group emission byte-identical.
+    const explicitMoveMarkers = collectExplicitMoveMarkers(group);
+    if (paragraphHasHyperlinkAtoms(group)) {
+        parts.push(buildRunGroupsWithHyperlinks(group.runGroups, author, dateStr, revState, explicitMoveMarkers));
+    }
+    else {
+        for (const runGroup of group.runGroups) {
+            const runXml = buildRunGroupXml(runGroup, author, dateStr, revState, explicitMoveMarkers);
+            parts.push(runXml);
+        }
     }
     parts.push('</w:p>');
     return parts.join('');
@@ -542,43 +548,25 @@ function serializePPrWithParaRevisionMarker(pPr, markerTag, id, author, dateStr,
             effectivePPr.appendChild(rPr);
         }
     }
-    // Insert revision marker at start of rPr.
-    const marker = createEl(markerTag, {
-        'w:id': String(id),
-        'w:author': author,
-        'w:date': dateStr,
-    });
-    rPr.insertBefore(marker, rPr.firstChild);
+    // Reuse a pre-existing paragraph-mark marker of the same kind cloned from the
+    // source pPr (issue #452): CT_ParaRPr allows at most one of each tracked-change
+    // child, and the source revision's metadata (author/date/id) outranks a
+    // synthetic duplicate. Either way the marker is placed in its schema-correct
+    // slot ahead of formatting children.
+    const existingMarker = findChildByTagName(rPr, markerTag);
+    const marker = existingMarker ??
+        createEl(markerTag, {
+            'w:id': String(id),
+            'w:author': author,
+            'w:date': dateStr,
+        });
+    placeParagraphMarkRevisionMarker(rPr, marker, markerTag);
     // Append pPrChange at end if provided.
     if (pPrChangeEl) {
         effectivePPr.appendChild(pPrChangeEl);
     }
     return serializeToXml(effectivePPr);
 }
-/**
- * Build a `<w:pPrChange>` Element from a pPr DOM element.
- *
- * The child `<w:pPr>` conforms to CT_PPrBase — it excludes w:rPr, w:sectPr,
- * w:rPrChange, and w:pPrChange.
- */
-function buildPPrChangeElement(pPr, author, dateStr, revState) {
-    const id = allocateRevisionId(revState);
-    const EXCLUDED = new Set(['w:rPr', 'w:rPrChange', 'w:pPrChange', 'w:sectPr']);
-    const pPrChange = createEl('w:pPrChange', {
-        'w:id': String(id),
-        'w:author': author,
-        'w:date': dateStr,
-    });
-    const oldPPr = createEl('w:pPr');
-    if (pPr) {
-        for (const child of childElements(pPr)) {
-            if (!EXCLUDED.has(child.tagName))
-                oldPPr.appendChild(child.cloneNode(true));
-        }
-    }
-    pPrChange.appendChild(oldPPr);
-    return pPrChange;
-}
 /**
  * Returns true if every atom in the paragraph is of the specified status
  * (ignoring EMPTY_PARAGRAPH_TAG markers).
@@ -622,6 +610,11 @@ function buildRunContentAsPlainRun(group) {
     const contentAtoms = group.atoms.filter((atom) => atom.contentElement.tagName !== EMPTY_PARAGRAPH_TAG);
     if (contentAtoms.length === 0)
         return '';
+    // Paragraph-level markers must sit outside <w:r>; route through the
+    // marker-aware helper which buffers run atoms and flushes on each marker.
+    if (groupHasParagraphLevelAtoms(group)) {
+        return buildRunContentWithParagraphMarkers(group);
+    }
     // If group has explicit rPr, emit a single run
     if (group.rPr !== null) {
         return buildSingleRun(group.atoms, group.rPr);
@@ -632,8 +625,12 @@ function buildRunContentAsPlainRun(group) {
 }
 /**
  * Build XML for a run group with appropriate track changes wrapper.
+ *
+ * `explicitMoveMarkers` reports whether the surrounding paragraph's atom
+ * stream already carries explicit moveFromRange / moveToRange markers; moved
+ * groups then skip synthetic range emission (see ExplicitMoveMarkers).
  */
-function buildRunGroupXml(group, author, dateStr, revState) {
+function buildRunGroupXml(group, author, dateStr, revState, explicitMoveMarkers = NO_EXPLICIT_MOVE_MARKERS) {
     const runContent = buildRunContent(group);
     // If run content is empty (e.g., only empty paragraph atoms), return empty string
     // This avoids generating empty track changes wrappers
@@ -649,9 +646,9 @@ function buildRunGroupXml(group, author, dateStr, revState) {
         case CorrelationStatus.Deleted:
             return wrapWithDel(runContent, author, dateStr, revState);
         case CorrelationStatus.MovedSource:
-            return wrapWithMoveFrom(runContent, author, dateStr, group.moveName || 'move1', revState);
+            return wrapWithMoveFrom(runContent, author, dateStr, group.moveName || 'move1', revState, explicitMoveMarkers.moveFrom);
         case CorrelationStatus.MovedDestination:
-            return wrapWithMoveTo(runContent, author, dateStr, group.moveName || 'move1', revState);
+            return wrapWithMoveTo(runContent, author, dateStr, group.moveName || 'move1', revState, explicitMoveMarkers.moveTo);
         case CorrelationStatus.FormatChanged:
             // For format changes, we include the run with rPrChange
             return buildFormatChangeRun(group, author, dateStr, revState);
@@ -707,6 +704,244 @@ function subGroupByRPr(atoms) {
     result.push({ rPr: currentRPr, atoms: currentAtoms });
     return result;
 }
+/**
+ * Attribute fingerprint of a w:hyperlink element, used to recognize "the
+ * same" hyperlink across the original and revised trees (equal/deleted atoms
+ * reference the original tree's element, inserted atoms the revised tree's).
+ */
+function hyperlinkKey(el) {
+    const parts = [];
+    for (let i = 0; i < el.attributes.length; i++) {
+        const attr = el.attributes.item(i);
+        if (attr.name.startsWith('xmlns'))
+            continue;
+        parts.push(`${attr.name}=${attr.value}`);
+    }
+    return parts.sort().join('\u0000');
+}
+/**
+ * Resolve the hyperlink wrapper an atom belongs to, preferring the
+ * original-tree element so the re-emitted r:id resolves against the
+ * original-based rebuild package: deleted atoms carry original ancestry
+ * directly; equal atoms (revised tree) reach it via comparisonUnitAtomBefore.
+ *
+ * @conformance ECMA-376 edition 5, Part 1 § 17.16.22
+ * @see https://github.com/UseJunior/safe-docx/issues/368
+ */
+function resolveHyperlinkForAtom(atom) {
+    const own = nearestHyperlinkAncestor(atom);
+    if (!own)
+        return null;
+    if (atom.sourceDocument === 'original') {
+        return { element: own, key: hyperlinkKey(own), fromOriginal: true };
+    }
+    const before = atom.comparisonUnitAtomBefore;
+    const beforeHyperlink = before ? nearestHyperlinkAncestor(before) : null;
+    // Attribute to the original wrapper only when both trees agree on the
+    // hyperlink's attributes. When they differ (e.g. the revision retargeted
+    // the link to a new r:id), emitting the original wrapper would pin the
+    // still-equal link text to the STALE target in the accepted document —
+    // worse than dropping the wrapper. Such atoms fall through to the
+    // revised-only policy below instead.
+    // TODO(#376): the faithful tracked representation of a retargeted link
+    // is delete-old-link + insert-new-link (what Word emits), which needs the
+    // hyperlink fingerprint in atom identity so the LCS stops matching text
+    // across different link targets.
+    if (beforeHyperlink && hyperlinkKey(beforeHyperlink) === hyperlinkKey(own)) {
+        return { element: beforeHyperlink, key: hyperlinkKey(beforeHyperlink), fromOriginal: true };
+    }
+    // Revised-only attribution (purely inserted hyperlink). Emitting its r:id
+    // would dangle against the original-based package, so the caller only
+    // wraps when the hyperlink carries no relationship reference (anchor-only).
+    return { element: own, key: hyperlinkKey(own), fromOriginal: false };
+}
+/**
+ * Whether a resolved hyperlink is safe to re-emit. Original-attributed
+ * wrappers always are; revised-only wrappers are safe only without an r:id
+ * (internal anchor links), because the rebuild package ships the ORIGINAL
+ * document.xml.rels and a revised-only r:id would be a dangling reference
+ * (Word treats those as a corrupt package). Revised-only r:id hyperlinks
+ * keep today's behavior — content emitted unwrapped.
+ */
+function isEmittableHyperlink(resolved) {
+    return resolved.fromOriginal || resolved.element.getAttribute('r:id') === null;
+}
+/**
+ * True when any atom in the paragraph sits inside a w:hyperlink. Gates the
+ * hyperlink-aware emission paths so hyperlink-free paragraphs keep the
+ * byte-identical legacy output.
+ */
+function paragraphHasHyperlinkAtoms(group) {
+    return group.runGroups.some((rg) => rg.atoms.some((atom) => nearestHyperlinkAncestor(atom) !== null));
+}
+/**
+ * Split a RunGroup into contiguous hyperlink-pure sub-groups.
+ *
+ * Moved groups are returned whole: splitting them would emit
+ * moveFromRangeStart/End once per slice, corrupting the move ranges. A move
+ * spanning a hyperlink keeps today's unwrapped emission.
+ */
+function splitRunGroupByHyperlink(group) {
+    if (group.status === CorrelationStatus.MovedSource ||
+        group.status === CorrelationStatus.MovedDestination) {
+        return [{ group, hyperlink: null }];
+    }
+    const segments = [];
+    let current = null;
+    for (const atom of group.atoms) {
+        // Emit-ability is decided per merged bucket, not per atom: an inserted
+        // atom inside an otherwise-original hyperlink folds into the adjacent
+        // original-attributed bucket via the shared key.
+        const resolved = resolveHyperlinkForAtom(atom);
+        const key = resolved?.key ?? null;
+        if (current && (current.hyperlink?.key ?? null) === key) {
+            current.group.atoms.push(atom);
+            // Prefer an original-attributed representative within the segment.
+            if (resolved?.fromOriginal && current.hyperlink && !current.hyperlink.fromOriginal) {
+                current.hyperlink = resolved;
+            }
+        }
+        else {
+            current = {
+                group: { ...group, atoms: [atom] },
+                hyperlink: resolved,
+            };
+            segments.push(current);
+        }
+    }
+    return segments;
+}
+/**
+ * Serialize the opening tag of a re-emitted w:hyperlink wrapper, copying the
+ * source element's attributes verbatim (r:id, w:anchor, w:history, ...).
+ */
+function serializeHyperlinkOpenTag(el) {
+    const attrs = [];
+    for (let i = 0; i < el.attributes.length; i++) {
+        const attr = el.attributes.item(i);
+        if (attr.name.startsWith('xmlns'))
+            continue;
+        attrs.push(` ${attr.name}="${escapeXmlAttr(attr.value)}"`);
+    }
+    return `<w:hyperlink${attrs.join('')}>`;
+}
+/**
+ * Merge adjacent segments that resolve to the same hyperlink fingerprint, so
+ * an equal/deleted/inserted sequence inside one link shares one wrapper.
+ */
+function mergeAdjacentHyperlinkSegments(segments) {
+    const buckets = [];
+    for (const segment of segments) {
+        const last = buckets[buckets.length - 1];
+        if (last && (last.hyperlink?.key ?? null) === (segment.hyperlink?.key ?? null)) {
+            last.groups.push(segment.group);
+            if (segment.hyperlink?.fromOriginal && last.hyperlink && !last.hyperlink.fromOriginal) {
+                last.hyperlink = segment.hyperlink;
+            }
+        }
+        else {
+            buckets.push({ hyperlink: segment.hyperlink, groups: [segment.group] });
+        }
+    }
+    return buckets;
+}
+/**
+ * Emit a paragraph's run groups with w:hyperlink wrappers restored around the
+ * runs whose atoms came from inside a hyperlink. Track-change wrappers nest
+ * INSIDE the hyperlink (`<w:hyperlink><w:ins>…`): CT_Hyperlink admits
+ * EG_RunLevelElts (w:ins / w:del / range markers), while CT_RunTrackChange
+ * does not admit w:hyperlink.
+ *
+ * @conformance ECMA-376 edition 5, Part 1 § 17.16.22
+ * @see https://github.com/UseJunior/safe-docx/issues/368
+ */
+function buildRunGroupsWithHyperlinks(runGroups, author, dateStr, revState, explicitMoveMarkers = NO_EXPLICIT_MOVE_MARKERS) {
+    const buckets = mergeAdjacentHyperlinkSegments(runGroups.flatMap(splitRunGroupByHyperlink));
+    const parts = [];
+    for (const bucket of buckets) {
+        const content = bucket.groups
+            .map((g) => buildRunGroupXml(g, author, dateStr, revState, explicitMoveMarkers))
+            .join('');
+        if (!content)
+            continue;
+        parts.push(bucket.hyperlink && isEmittableHyperlink(bucket.hyperlink)
+            ? `${serializeHyperlinkOpenTag(bucket.hyperlink.element)}${content}</w:hyperlink>`
+            : content);
+    }
+    return parts.join('');
+}
+/**
+ * Whole-paragraph insert/delete emission with hyperlink wrappers restored.
+ * Each bucket gets its own revision wrapper so the hyperlink can stay
+ * OUTSIDE the w:ins / w:del (see buildRunGroupsWithHyperlinks).
+ */
+function buildWholeParagraphRevisionContent(group, wrap) {
+    const buckets = mergeAdjacentHyperlinkSegments(group.runGroups.flatMap(splitRunGroupByHyperlink));
+    const parts = [];
+    for (const bucket of buckets) {
+        const runs = bucket.groups.map((g) => buildRunContentAsPlainRun(g)).join('');
+        if (!runs)
+            continue;
+        const wrapped = wrap(runs);
+        parts.push(bucket.hyperlink && isEmittableHyperlink(bucket.hyperlink)
+            ? `${serializeHyperlinkOpenTag(bucket.hyperlink.element)}${wrapped}</w:hyperlink>`
+            : wrapped);
+    }
+    return parts.join('');
+}
+/**
+ * Returns true when any atom in the group is a paragraph-level marker
+ * (commentRange / bookmark / moveFromRange / moveToRange / perm) that must
+ * be emitted outside <w:r>.
+ */
+function groupHasParagraphLevelAtoms(group) {
+    for (const atom of group.atoms) {
+        if (isParagraphLevelLeaf(atom.contentElement))
+            return true;
+    }
+    return false;
+}
+/**
+ * Marker-aware emission for run groups containing paragraph-level atoms.
+ *
+ * Walks atoms left-to-right. Run-level atoms accumulate in a buffer; on
+ * encountering a paragraph-level atom (or end of group) the buffer is flushed
+ * via subGroupByRPr + buildSingleRun (one <w:r> per contiguous rPr) and the
+ * marker is emitted as a bare element.
+ *
+ * group.rPr is intentionally ignored here — RunGroup.rPr is captured from the
+ * first atom in groupAtomsByParagraph(), and for moved groups
+ * shouldStartNewRunGroup() suppresses rPr-based splitting. Always re-deriving
+ * rPr per atom prevents formatting bleed and bogus rPr inheritance from
+ * illegally nested markers.
+ */
+function buildRunContentWithParagraphMarkers(group) {
+    const parts = [];
+    let runBuffer = [];
+    const flush = () => {
+        if (runBuffer.length === 0)
+            return;
+        for (const sg of subGroupByRPr(runBuffer)) {
+            const run = buildSingleRun(sg.atoms, sg.rPr);
+            if (run)
+                parts.push(run);
+        }
+        runBuffer = [];
+    };
+    for (const atom of group.atoms) {
+        if (atom.contentElement.tagName === EMPTY_PARAGRAPH_TAG)
+            continue;
+        if (isParagraphLevelLeaf(atom.contentElement)) {
+            flush();
+            parts.push(serializeAtomElement(atom.contentElement));
+        }
+        else {
+            runBuffer.push(atom);
+        }
+    }
+    flush();
+    return parts.join('');
+}
 /**
  * Build a single <w:r> element from a set of atoms with the given rPr.
  * Preserves pendingText coalescing, collapsedFieldAtoms expansion,
@@ -801,6 +1036,11 @@ function buildRunContent(group) {
     if (contentAtoms.length === 0) {
         return '';
     }
+    // Paragraph-level markers must sit outside <w:r>; route through the
+    // marker-aware helper which buffers run atoms and flushes on each marker.
+    if (groupHasParagraphLevelAtoms(group)) {
+        return buildRunContentWithParagraphMarkers(group);
+    }
     // If group has explicit rPr, emit a single run
     if (group.rPr !== null) {
         return buildSingleRun(group.atoms, group.rPr);
@@ -813,38 +1053,49 @@ function buildRunContent(group) {
  * Wrap content with w:ins element.
  */
 function wrapWithIns(content, author, dateStr, revState) {
-    const id = allocateRevisionId(revState);
-    return `<w:ins w:id="${id}" w:author="${escapeXmlAttr(author)}" w:date="${dateStr}">${content}</w:ins>`;
+    return wrapSerializedContentWithIns(content, createRevisionContext({ author, date: dateStr, idState: revState }));
 }
 /**
  * Wrap content with w:del element.
  */
 function wrapWithDel(content, author, dateStr, revState) {
-    const id = allocateRevisionId(revState);
-    // For deletions, convert w:t to w:delText and w:instrText to w:delInstrText
-    const delContent = content
-        .replace(/<w:t([^>]*)>([^<]*)<\/w:t>/g, '<w:delText$1>$2</w:delText>')
-        .replace(/<w:instrText([^>]*)>([^<]*)<\/w:instrText>/g, '<w:delInstrText$1>$2</w:delInstrText>');
-    return `<w:del w:id="${id}" w:author="${escapeXmlAttr(author)}" w:date="${dateStr}">${delContent}</w:del>`;
+    return wrapSerializedContentWithDel(content, createRevisionContext({ author, date: dateStr, idState: revState }));
 }
 /**
  * Wrap content with w:moveFrom elements.
+ *
+ * When `suppressRangeMarkers` is true the paragraph's atom stream already
+ * carries explicit w:moveFromRangeStart/End markers (re-emitted by
+ * buildRunContentWithParagraphMarkers), so only the w:moveFrom wrapper is
+ * synthesized — emitting a second range pair would corrupt the move ranges.
+ *
+ * @see https://github.com/UseJunior/safe-docx/issues/110
  */
-function wrapWithMoveFrom(content, author, dateStr, moveName, revState) {
+function wrapWithMoveFrom(content, author, dateStr, moveName, revState, suppressRangeMarkers = false) {
+    if (suppressRangeMarkers) {
+        const moveId = allocateRevisionId(revState);
+        const delContent = convertSerializedDeletionContent(content);
+        return `<w:moveFrom w:id="${moveId}" w:author="${escapeXmlAttr(author)}" w:date="${dateStr}">${delContent}</w:moveFrom>`;
+    }
     const ids = getMoveRangeIds(revState, moveName);
     const moveId = allocateRevisionId(revState);
-    // Convert w:t to w:delText and w:instrText to w:delInstrText for moved-from content
-    const delContent = content
-        .replace(/<w:t([^>]*)>([^<]*)<\/w:t>/g, '<w:delText$1>$2</w:delText>')
-        .replace(/<w:instrText([^>]*)>([^<]*)<\/w:instrText>/g, '<w:delInstrText$1>$2</w:delInstrText>');
+    const delContent = convertSerializedDeletionContent(content);
     return (`<w:moveFromRangeStart w:id="${ids.sourceRangeId}" w:name="${moveName}" w:author="${escapeXmlAttr(author)}" w:date="${dateStr}"/>` +
         `<w:moveFrom w:id="${moveId}" w:author="${escapeXmlAttr(author)}" w:date="${dateStr}">${delContent}</w:moveFrom>` +
         `<w:moveFromRangeEnd w:id="${ids.sourceRangeId}"/>`);
 }
 /**
  * Wrap content with w:moveTo elements.
+ *
+ * When `suppressRangeMarkers` is true the paragraph's atom stream already
+ * carries explicit w:moveToRangeStart/End markers, so only the w:moveTo
+ * wrapper is synthesized (see wrapWithMoveFrom).
  */
-function wrapWithMoveTo(content, author, dateStr, moveName, revState) {
+function wrapWithMoveTo(content, author, dateStr, moveName, revState, suppressRangeMarkers = false) {
+    if (suppressRangeMarkers) {
+        const moveId = allocateRevisionId(revState);
+        return `<w:moveTo w:id="${moveId}" w:author="${escapeXmlAttr(author)}" w:date="${dateStr}">${content}</w:moveTo>`;
+    }
     const ids = getMoveRangeIds(revState, moveName);
     const moveId = allocateRevisionId(revState);
     return (`<w:moveToRangeStart w:id="${ids.destRangeId}" w:name="${moveName}" w:author="${escapeXmlAttr(author)}" w:date="${dateStr}"/>` +
@@ -869,7 +1120,13 @@ function buildFormatChangeRun(group, author, dateStr, revState) {
                 }
             }
         }
-        // Add rPrChange with old properties (wrapped in w:rPr per OOXML spec)
+        // Add rPrChange with old properties (wrapped in w:rPr per OOXML spec).
+        // Kept as the original per-child serialization (NOT delegated to
+        // buildRPrChangeElement) to preserve byte-identical output: xmldom emits
+        // inline `xmlns:w="..."` declarations when serializing detached children,
+        // and downstream consumers may pin on that exact serialized form. The
+        // DOM-aware buildRPrChangeElement helper exists for new primitive code
+        // paths (#136 onward).
         const formatChange = group.atoms[0]?.formatChange;
         if (formatChange?.oldRunProperties) {
             const id = allocateRevisionId(revState);
@@ -946,7 +1203,7 @@ function isRootedGroup(group) {
  * <w:p> slots, inserted paragraphs are placed adjacent to their context, and
  * all structural wrappers (tables, SDTs, etc.) are preserved.
  */
-function buildDocumentPreservingStructure(originalXml, paragraphXmls, paragraphGroups) {
+function buildDocumentPreservingStructure(originalXml, paragraphXmls, paragraphGroups, allocateRevisionId) {
     const { doc, body, slots } = parseOriginalBodyStructure(originalXml);
     let slotCursor = 0;
     let lastEmittedNode = null;
@@ -1020,15 +1277,44 @@ function buildDocumentPreservingStructure(originalXml, paragraphXmls, paragraphG
         const slot = slots[i];
         slot.parent.removeChild(slot.element);
     }
-    // Strip inter-paragraph bookmark/comment range markers from the scaffold.
-    // These are bookmarkStart/End, commentRangeStart/End elements that were
-    // siblings of <w:p> in the original body. The paragraph rebuilder handles
-    // its own bookmark logic, so keeping these orphaned markers causes
-    // unmatched bookmark IDs.
+    // Strip inter-paragraph bookmark/comment/move-range/permission markers from
+    // the scaffold. These are bookmarkStart/End, commentRangeStart/End,
+    // moveFromRange*/moveToRange*, and permStart/End elements that were siblings
+    // of <w:p> in the original body. The paragraph rebuilder handles its own
+    // bookmark logic, so keeping these orphaned markers causes unmatched
+    // bookmark IDs. Body-level move-range markers are likewise scaffold
+    // remnants: in-paragraph markers travel through the atom stream, and
+    // detected moves synthesize fresh range pairs inside the reconstructed
+    // paragraphs, so a leftover body-level pair would either dangle or double an
+    // emitted range.
+    //
+    // Comment range markers are treated differently: a sibling-level
+    // commentRangeStart/End is the legitimate shape for a comment range that
+    // spans whole paragraphs, and such markers never enter the atom stream
+    // (see isParagraphLevelLeaf in atomizer.ts), so nothing re-emits them.
+    // Stripping them unconditionally destroys multi-paragraph comment ranges
+    // (issue #103). Instead, strip a sibling-level comment range marker only
+    // when its counterpart (same w:id) is absent from the rebuilt body —
+    // i.e., it is a genuinely orphaned scaffold remnant.
     const SCAFFOLD_STRIP_TAGS = new Set([
         'w:bookmarkStart', 'w:bookmarkEnd',
         'w:commentRangeStart', 'w:commentRangeEnd',
+        'w:moveFromRangeStart', 'w:moveFromRangeEnd',
+        'w:moveToRangeStart', 'w:moveToRangeEnd',
+        'w:permStart', 'w:permEnd',
     ]);
+    const COMMENT_RANGE_TAGS = new Set(['w:commentRangeStart', 'w:commentRangeEnd']);
+    const commentRangeStartIds = new Set();
+    const commentRangeEndIds = new Set();
+    for (const el of Array.from(body.getElementsByTagName('*'))) {
+        const id = el.getAttribute('w:id');
+        if (id == null)
+            continue;
+        if (el.tagName === 'w:commentRangeStart')
+            commentRangeStartIds.add(id);
+        else if (el.tagName === 'w:commentRangeEnd')
+            commentRangeEndIds.add(id);
+    }
     const toRemove = [];
     for (const el of Array.from(body.getElementsByTagName('*'))) {
         if (SCAFFOLD_STRIP_TAGS.has(el.tagName) && el.parentNode) {
@@ -1042,14 +1328,28 @@ function buildDocumentPreservingStructure(originalXml, paragraphXmls, paragraphG
                 }
                 ancestor = ancestor.parentNode;
             }
-            if (!insideParagraph) {
-                toRemove.push(el);
+            if (insideParagraph)
+                continue;
+            if (COMMENT_RANGE_TAGS.has(el.tagName)) {
+                const id = el.getAttribute('w:id');
+                const counterpartIds = el.tagName === 'w:commentRangeStart'
+                    ? commentRangeEndIds
+                    : commentRangeStartIds;
+                if (id != null && counterpartIds.has(id))
+                    continue;
             }
+            toRemove.push(el);
         }
     }
     for (const el of toRemove) {
         el.parentNode.removeChild(el);
     }
+    // Balance bookmarks and enforce consumer-compatibility invariants on the
+    // rebuilt body. This dedupes bookmark Names/IDs, hoists bookmarkStart/End
+    // out of <w:ins>/<w:del> wrappers (so they survive accept/reject), and
+    // synthesizes recovery markers for orphaned starts/ends. Mirrors the
+    // post-processing applied in inplace mode (inPlaceModifier.ts).
+    enforceConsumerCompatibility(body, allocateRevisionId);
     // Serialize modified body and splice back into original envelope
     const serializer = new XMLSerializer();
     let newBodyXml = serializer.serializeToString(body);
@@ -1106,16 +1406,6 @@ function escapeXmlText(text) {
         .replace(/</g, '&lt;')
         .replace(/>/g, '&gt;');
 }
-/**
- * Escape XML attribute value.
- */
-function escapeXmlAttr(text) {
-    return text
-        .replace(/&/g, '&amp;')
-        .replace(/</g, '&lt;')
-        .replace(/>/g, '&gt;')
-        .replace(/"/g, '&quot;');
-}
 /**
  * Count statistics from merged atoms.
  */