@usejunior/docx-core 0.10.0 → 0.11.0

package/dist/baselines/atomizer/pipeline.d.ts

@@ -5,9 +5,11 @@
  * Integrates atomization, LCS comparison, move detection, format detection,
  * and document reconstruction.
  */
-import type { CompareResult, ReconstructionMode } from '../../compare-types.js';
-import type { MoveDetectionSettings, FormatDetectionSettings } from '../../core-types.js';
+import type { CompareResult, CompareStats, ReconstructionMode } from '../../compare-types.js';
+import type { ComparisonUnitAtom, MoveDetectionSettings, FormatDetectionSettings } from '../../core-types.js';
 import { type NumberingIntegrationOptions } from './numberingIntegration.js';
+export { hasFldCharInsideDel, validateFieldStructure, type FieldStory, } from '../../shared/field-structure.js';
+import { type FieldStory } from '../../shared/field-structure.js';
 /**
  * Options for the atomizer pipeline.
  */
@@ -40,18 +42,6 @@ export interface AtomizerOptions {
      */
     reconstructionMode?: ReconstructionMode;
 }
-/**
- * One story (a self-contained complex-field state machine): the main document
- * body, an individual footnote entry, or an individual endnote entry. `label`
- * is for diagnostics only; `xml` is the serialized fragment that gets parsed
- * and walked.
- *
- * @conformance ECMA-376 edition 5, Part 4 § 17.16.5
- */
-export interface FieldStory {
-    label: string;
-    xml: string;
-}
 /**
  * Split a docx into per-story XML fragments for field-closure validation.
  *
@@ -76,45 +66,6 @@ export interface FieldStory {
  * @see https://github.com/UseJunior/safe-docx/issues/212
  */
 export declare function splitStories(documentXml: string, footnotesXmls: ReadonlyArray<string | null>, endnotesXmls: ReadonlyArray<string | null>): FieldStory[];
-/**
- * Validate field structure integrity across one or more document stories.
- *
- * Enforces three constraints on complex fields **per story**:
- *   1. `w:fldChar` begin/end count balance within the story.
- *   2. Every `w:instrText` AND `w:delInstrText` sits inside an open field body
- *      (between `begin` and `separate`). Orphaned instruction text renders as
- *      literal text in Word.
- *   3. `w:delInstrText` is nested inside a `<w:del>` ancestor (DeletedFieldCode
- *      schema constraint), and conversely `w:fldChar` is NEVER inside `<w:del>`
- *      (Word treats this as fatal and discards the field state machine).
- *
- * Called on both pre-accept/reject combined XML (with track-change wrappers)
- * and on post-accept/reject XML (wrappers removed). Both cases must satisfy the
- * field placement check; constraint (3) is vacuous post-accept/reject.
- *
- * Accepts either a single XML string (legacy single-story call) or an array of
- * `FieldStory` fragments. Stories are validated independently and short-circuit
- * on the first failure.
- *
- * @conformance ECMA-376 edition 5, Part 4 § 17.16.5
- */
-/**
- * Targeted check for one of the constraints above: `w:fldChar` MUST NOT appear
- * inside any `<w:del>` element. Word treats this violation as fatal — the
- * field state machine is discarded and the field renders as literal-text
- * fallback.
- *
- * Used as a combined-output safety gate alongside the per-projection
- * `validateFieldStructure` checks. Kept narrower than the full structural
- * validation so that legacy shapes (e.g. `delInstrText` inside `<w:moveFrom>`)
- * don't trigger fallback when the inplace candidate is otherwise sound on its
- * accept/reject projections.
- *
- * @conformance ECMA-376 edition 5, Part 4 § 17.16.5
- * @see https://github.com/UseJunior/safe-docx/issues/217
- */
-export declare function hasFldCharInsideDel(documentXml: string): boolean;
-export declare function validateFieldStructure(input: string | FieldStory[]): boolean;
 /**
  * Compare two DOCX documents using the atomizer-based approach.
  *
@@ -141,4 +92,12 @@ export interface AuxiliaryMergeResult {
     mergedIds: Set<string>;
     createdPart: boolean;
 }
+/**
+ * Compute comparison statistics from merged atoms.
+ *
+ * Range counts are contiguous same-status runs in the merged atom stream, scoped
+ * to a paragraph. Atom counts remain available under explicit names for callers
+ * that need the old granular benchmark signal.
+ */
+export declare function computeAtomizerStats(mergedAtoms: ComparisonUnitAtom[]): CompareStats;
 //# sourceMappingURL=pipeline.d.ts.map

package/dist/baselines/atomizer/pipeline.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"pipeline.d.ts","sourceRoot":"","sources":["../../../src/baselines/atomizer/pipeline.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAKH,OAAO,KAAK,EACV,aAAa,EAeb,kBAAkB,EACnB,MAAM,wBAAwB,CAAC;AAChC,OAAO,KAAK,EAEV,qBAAqB,EACrB,uBAAuB,EAExB,MAAM,qBAAqB,CAAC;AAkC7B,OAAO,EAEL,KAAK,2BAA2B,EAEjC,MAAM,2BAA2B,CAAC;AAGnC;;GAEG;AACH,MAAM,WAAW,eAAe;IAC9B,2DAA2D;IAC3D,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,yDAAyD;IACzD,IAAI,CAAC,EAAE,IAAI,CAAC;IACZ,8BAA8B;IAC9B,aAAa,CAAC,EAAE,OAAO,CAAC,qBAAqB,CAAC,CAAC;IAC/C,gCAAgC;IAChC,eAAe,CAAC,EAAE,OAAO,CAAC,uBAAuB,CAAC,CAAC;IACnD,qCAAqC;IACrC,SAAS,CAAC,EAAE,OAAO,CAAC,2BAA2B,CAAC,CAAC;IACjD;;;;;;;OAOG;IACH,YAAY,CAAC,EAAE,OAAO,CAAC;IACvB;;;;;;OAMG;IACH,kBAAkB,CAAC,EAAE,kBAAkB,CAAC;CACzC;AAkPD;;;;;;;GAOG;AACH,MAAM,WAAW,UAAU;IACzB,KAAK,EAAE,MAAM,CAAC;IACd,GAAG,EAAE,MAAM,CAAC;CACb;AAED;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,wBAAgB,YAAY,CAC1B,WAAW,EAAE,MAAM,EACnB,aAAa,EAAE,aAAa,CAAC,MAAM,GAAG,IAAI,CAAC,EAC3C,YAAY,EAAE,aAAa,CAAC,MAAM,GAAG,IAAI,CAAC,GACzC,UAAU,EAAE,CA4Bd;AAED;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,mBAAmB,CAAC,WAAW,EAAE,MAAM,GAAG,OAAO,CA4BhE;AAED,wBAAgB,sBAAsB,CAAC,KAAK,EAAE,MAAM,GAAG,UAAU,EAAE,GAAG,OAAO,CAQ5E;AA4LD;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,wBAAsB,wBAAwB,CAC5C,QAAQ,EAAE,MAAM,EAChB,OAAO,EAAE,MAAM,EACf,OAAO,GAAE,eAAoB,GAC5B,OAAO,CAAC,aAAa,CAAC,CAwUxB;AAsBD,MAAM,WAAW,oBAAoB;IACnC,SAAS,EAAE,GAAG,CAAC,MAAM,CAAC,CAAC;IACvB,WAAW,EAAE,OAAO,CAAC;CACtB"}
+{"version":3,"file":"pipeline.d.ts","sourceRoot":"","sources":["../../../src/baselines/atomizer/pipeline.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAKH,OAAO,KAAK,EACV,aAAa,EACb,YAAY,EAeZ,kBAAkB,EACnB,MAAM,wBAAwB,CAAC;AAChC,OAAO,KAAK,EACV,kBAAkB,EAClB,qBAAqB,EACrB,uBAAuB,EAExB,MAAM,qBAAqB,CAAC;AAkC7B,OAAO,EAEL,KAAK,2BAA2B,EAEjC,MAAM,2BAA2B,CAAC;AAEnC,OAAO,EACL,mBAAmB,EACnB,sBAAsB,EACtB,KAAK,UAAU,GAChB,MAAM,iCAAiC,CAAC;AACzC,OAAO,EAGL,KAAK,UAAU,EAChB,MAAM,iCAAiC,CAAC;AAUzC;;GAEG;AACH,MAAM,WAAW,eAAe;IAC9B,2DAA2D;IAC3D,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,yDAAyD;IACzD,IAAI,CAAC,EAAE,IAAI,CAAC;IACZ,8BAA8B;IAC9B,aAAa,CAAC,EAAE,OAAO,CAAC,qBAAqB,CAAC,CAAC;IAC/C,gCAAgC;IAChC,eAAe,CAAC,EAAE,OAAO,CAAC,uBAAuB,CAAC,CAAC;IACnD,qCAAqC;IACrC,SAAS,CAAC,EAAE,OAAO,CAAC,2BAA2B,CAAC,CAAC;IACjD;;;;;;;OAOG;IACH,YAAY,CAAC,EAAE,OAAO,CAAC;IACvB;;;;;;OAMG;IACH,kBAAkB,CAAC,EAAE,kBAAkB,CAAC;CACzC;AAkPD;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,wBAAgB,YAAY,CAC1B,WAAW,EAAE,MAAM,EACnB,aAAa,EAAE,aAAa,CAAC,MAAM,GAAG,IAAI,CAAC,EAC3C,YAAY,EAAE,aAAa,CAAC,MAAM,GAAG,IAAI,CAAC,GACzC,UAAU,EAAE,CA4Bd;AAqHD;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,wBAAsB,wBAAwB,CAC5C,QAAQ,EAAE,MAAM,EAChB,OAAO,EAAE,MAAM,EACf,OAAO,GAAE,eAAoB,GAC5B,OAAO,CAAC,aAAa,CAAC,CAwWxB;AAYD,MAAM,WAAW,oBAAoB;IACnC,SAAS,EAAE,GAAG,CAAC,MAAM,CAAC,CAAC;IACvB,WAAW,EAAE,OAAO,CAAC;CACtB;AAwgBD;;;;;;GAMG;AACH,wBAAgB,oBAAoB,CAAC,WAAW,EAAE,kBAAkB,EAAE,GAAG,YAAY,CAyDpF"}

package/dist/baselines/atomizer/pipeline.js

@@ -21,6 +21,10 @@ import { modifyRevisedDocument, ContainerResolutionError } from './inPlaceModifi
 import { acceptAllChanges, rejectAllChanges, extractTextWithParagraphs, compareTexts, } from './trackChangesAcceptorAst.js';
 import { virtualizeNumberingLabels, DEFAULT_NUMBERING_OPTIONS, } from './numberingIntegration.js';
 import { premergeAdjacentRuns } from './premergeRuns.js';
+export { hasFldCharInsideDel, validateFieldStructure, } from '../../shared/field-structure.js';
+import { hasFldCharInsideDel, validateFieldStructure, } from '../../shared/field-structure.js';
+import { AUXILIARY_PARTS, parseEntries, renumberCollidingAuxiliaryIds, restampCollidingCommentParaIds, } from './auxiliaryIdCollision.js';
+import { maybeCaptureEmittedDocumentXml } from '../../primitives/schema-corpus-capture.js';
 function arraysEqual(a, b) {
     if (a.length !== b.length)
         return false;
@@ -264,160 +268,6 @@ export function splitStories(documentXml, footnotesXmls, endnotesXmls) {
     collectEntries(endnotesXmls, 'w:endnote', 'endnote');
     return stories;
 }
-/**
- * Validate field structure integrity across one or more document stories.
- *
- * Enforces three constraints on complex fields **per story**:
- *   1. `w:fldChar` begin/end count balance within the story.
- *   2. Every `w:instrText` AND `w:delInstrText` sits inside an open field body
- *      (between `begin` and `separate`). Orphaned instruction text renders as
- *      literal text in Word.
- *   3. `w:delInstrText` is nested inside a `<w:del>` ancestor (DeletedFieldCode
- *      schema constraint), and conversely `w:fldChar` is NEVER inside `<w:del>`
- *      (Word treats this as fatal and discards the field state machine).
- *
- * Called on both pre-accept/reject combined XML (with track-change wrappers)
- * and on post-accept/reject XML (wrappers removed). Both cases must satisfy the
- * field placement check; constraint (3) is vacuous post-accept/reject.
- *
- * Accepts either a single XML string (legacy single-story call) or an array of
- * `FieldStory` fragments. Stories are validated independently and short-circuit
- * on the first failure.
- *
- * @conformance ECMA-376 edition 5, Part 4 § 17.16.5
- */
-/**
- * Targeted check for one of the constraints above: `w:fldChar` MUST NOT appear
- * inside any `<w:del>` element. Word treats this violation as fatal — the
- * field state machine is discarded and the field renders as literal-text
- * fallback.
- *
- * Used as a combined-output safety gate alongside the per-projection
- * `validateFieldStructure` checks. Kept narrower than the full structural
- * validation so that legacy shapes (e.g. `delInstrText` inside `<w:moveFrom>`)
- * don't trigger fallback when the inplace candidate is otherwise sound on its
- * accept/reject projections.
- *
- * @conformance ECMA-376 edition 5, Part 4 § 17.16.5
- * @see https://github.com/UseJunior/safe-docx/issues/217
- */
-export function hasFldCharInsideDel(documentXml) {
-    const root = parseDocumentXml(documentXml);
-    let insideDelDepth = 0;
-    let violation = false;
-    function scan(node) {
-        if (violation)
-            return;
-        for (let child = node.firstChild; child; child = child.nextSibling) {
-            if (child.nodeType !== 1)
-                continue;
-            const el = child;
-            const tag = el.tagName;
-            if (tag === 'w:del') {
-                insideDelDepth++;
-                scan(el);
-                insideDelDepth--;
-                if (violation)
-                    return;
-                continue;
-            }
-            if (tag === 'w:fldChar' && insideDelDepth > 0) {
-                violation = true;
-                return;
-            }
-            scan(el);
-            if (violation)
-                return;
-        }
-    }
-    scan(root);
-    return violation;
-}
-export function validateFieldStructure(input) {
-    if (typeof input === 'string') {
-        return validateFieldStructureForStory(input);
-    }
-    for (const story of input) {
-        if (!validateFieldStructureForStory(story.xml))
-            return false;
-    }
-    return true;
-}
-function validateFieldStructureForStory(documentXml) {
-    const root = parseDocumentXml(documentXml);
-    const allFldChars = findAllByTagName(root, 'w:fldChar');
-    const allInstrTexts = findAllByTagName(root, 'w:instrText');
-    const allDelInstrTexts = findAllByTagName(root, 'w:delInstrText');
-    // Constraint (1): global fldChar begin/end balance.
-    let begins = 0;
-    let ends = 0;
-    for (const fc of allFldChars) {
-        const type = fc.getAttribute('w:fldCharType');
-        if (type === 'begin')
-            begins++;
-        else if (type === 'end')
-            ends++;
-    }
-    if (begins !== ends)
-        return false;
-    if (allFldChars.length === 0 &&
-        allInstrTexts.length === 0 &&
-        allDelInstrTexts.length === 0) {
-        return true;
-    }
-    // Depth-first scan tracking field nesting (for constraint 2) and <w:del>
-    // ancestor nesting (for constraint 3).
-    let depth = 0;
-    const pastSeparatorAtDepth = [];
-    let insideDelDepth = 0;
-    function scan(node) {
-        for (let child = node.firstChild; child; child = child.nextSibling) {
-            if (child.nodeType !== 1)
-                continue;
-            const el = child;
-            const tag = el.tagName;
-            if (tag === 'w:del') {
-                insideDelDepth++;
-                const ok = scan(el);
-                insideDelDepth--;
-                if (!ok)
-                    return false;
-                continue;
-            }
-            if (tag === 'w:fldChar') {
-                if (insideDelDepth > 0)
-                    return false;
-                const type = el.getAttribute('w:fldCharType');
-                if (type === 'begin') {
-                    depth++;
-                    pastSeparatorAtDepth[depth] = 0;
-                }
-                else if (type === 'separate') {
-                    if (depth > 0)
-                        pastSeparatorAtDepth[depth] = 1;
-                }
-                else if (type === 'end') {
-                    if (depth > 0)
-                        depth--;
-                }
-            }
-            else if (tag === 'w:instrText') {
-                if (depth === 0 || pastSeparatorAtDepth[depth])
-                    return false;
-            }
-            else if (tag === 'w:delInstrText') {
-                if (insideDelDepth === 0)
-                    return false;
-                if (depth === 0 || pastSeparatorAtDepth[depth])
-                    return false;
-            }
-            if (!scan(el))
-                return false;
-        }
-        return true;
-    }
-    return scan(root);
-}
 function evaluateSafetyChecks(originalTextForRoundTrip, revisedTextForRoundTrip, originalBookmarkDiagnostics, revisedBookmarkDiagnostics, candidateXml, auxiliarySidecars) {
     const acceptedXml = acceptAllChanges(candidateXml);
     const rejectedXml = rejectAllChanges(candidateXml);
@@ -526,6 +376,14 @@ export async function compareDocumentsAtomizer(original, revised, options = {})
     // Step 1: Load DOCX archives
     const originalArchive = await DocxArchive.load(original);
     const revisedArchive = await DocxArchive.load(revised);
+    // Step 1b: Resolve auxiliary ID collisions. When both sides define
+    // different content under the same comment/footnote/endnote w:id or the
+    // same comment paraId, rewrite the revised side so no anchor or ancillary
+    // row in the merged output can bind to the other document's definition.
+    // Must run before any document.xml extraction so every downstream step sees
+    // the rewritten archive.
+    await renumberCollidingAuxiliaryIds(originalArchive, revisedArchive);
+    await restampCollidingCommentParaIds(originalArchive, revisedArchive);
     // Step 2: Extract document.xml
     const originalXml = await originalArchive.getDocumentXml();
     const revisedXml = await revisedArchive.getDocumentXml();
@@ -718,6 +576,23 @@ export async function compareDocumentsAtomizer(original, revised, options = {})
     else {
         comparisonResult = runComparisonPass({ atomizeParagraphLevelMarkers: true }, 'rebuild');
     }
+    // Rebuild output gets the same safety screening as inplace attempts, whether
+    // rebuild was requested directly or reached via inplace fallback. Rebuild is
+    // the terminal strategy, so failures are surfaced in diagnostics rather than
+    // blocking the output.
+    // @see https://github.com/UseJunior/safe-docx/issues/226
+    let rebuildSafetyDiagnostics;
+    if (comparisonResult.outputMode === 'rebuild') {
+        const safety = evaluateRoundTripSafety(comparisonResult.newDocumentXml);
+        if (!safety.safe) {
+            rebuildSafetyDiagnostics = {
+                checks: safety.checks,
+                failedChecks: safety.failedChecks,
+                failureDetails: safety.failureDetails,
+                firstDiffSummary: safety.failureSummary,
+            };
+        }
+    }
     const { mergedAtoms, newDocumentXml } = comparisonResult;
     // Step 12: Clone appropriate archive and update document.xml.
     // Use the revised archive only for true inplace output.
@@ -729,6 +604,7 @@ export async function compareDocumentsAtomizer(original, revised, options = {})
     // auxiliary part that the revised side introduced (issue #94).
     const mergeSourceArchive = comparisonResult.outputMode === 'inplace' ? originalArchive : revisedArchive;
     const resultArchive = await baseArchive.clone();
+    maybeCaptureEmittedDocumentXml(newDocumentXml);
     resultArchive.setDocumentXml(newDocumentXml);
     // Step 12b: Merge auxiliary part definitions (footnotes, endnotes, comments).
     // Reconstruction may insert content (deleted in inplace, added in rebuild)
@@ -740,13 +616,14 @@ export async function compareDocumentsAtomizer(original, revised, options = {})
     // Gated on root comment IDs in the *result* document (not on what the
     // generic merge appended), so the pass runs even when the original already
     // contains the root and revised only adds replies under it (issue #108).
-    const rootCommentIds = collectReferenceIds(newDocumentXml, 'w:commentReference');
+    // Comments anchored on footnote/endnote text count as roots too.
+    const rootCommentIds = await collectStoryReferenceIds(resultArchive, newDocumentXml, 'w:commentReference', null);
     if (rootCommentIds.size > 0) {
         await mergeCommentAncillaryParts(mergeSourceArchive, resultArchive, rootCommentIds);
     }
     // Step 13: Save result and compute stats
     const resultBuffer = await resultArchive.save();
-    const stats = computeStats(mergedAtoms);
+    const stats = computeAtomizerStats(mergedAtoms);
     return {
         document: resultBuffer,
         stats,
@@ -755,37 +632,29 @@ export async function compareDocumentsAtomizer(original, revised, options = {})
         reconstructionModeUsed: comparisonResult.outputMode,
         fallbackReason,
         fallbackDiagnostics,
+        rebuildSafetyDiagnostics,
     };
 }
-const AUXILIARY_PARTS = [
-    {
-        label: 'footnote',
-        partPath: 'word/footnotes.xml',
-        referenceTag: 'w:footnoteReference',
-        entryTag: 'w:footnote',
-        rootTag: 'w:footnotes',
-        contentType: 'application/vnd.openxmlformats-officedocument.wordprocessingml.footnotes+xml',
-        relationshipType: 'http://schemas.openxmlformats.org/officeDocument/2006/relationships/footnotes',
-    },
-    {
-        label: 'endnote',
-        partPath: 'word/endnotes.xml',
-        referenceTag: 'w:endnoteReference',
-        entryTag: 'w:endnote',
-        rootTag: 'w:endnotes',
-        contentType: 'application/vnd.openxmlformats-officedocument.wordprocessingml.endnotes+xml',
-        relationshipType: 'http://schemas.openxmlformats.org/officeDocument/2006/relationships/endnotes',
-    },
-    {
-        label: 'comment',
-        partPath: 'word/comments.xml',
-        referenceTag: 'w:commentReference',
-        entryTag: 'w:comment',
-        rootTag: 'w:comments',
-        contentType: 'application/vnd.openxmlformats-officedocument.wordprocessingml.comments+xml',
-        relationshipType: 'http://schemas.openxmlformats.org/officeDocument/2006/relationships/comments',
-    },
-];
+/**
+ * Collect reference IDs across every result story that can host anchors: the
+ * merged document.xml plus the result archive's footnote/endnote parts (Word
+ * allows comments anchored on note text). `excludePartPath` skips the part
+ * whose own definitions are being merged — entries can't reference
+ * themselves.
+ */
+async function collectStoryReferenceIds(resultArchive, documentXml, referenceTag, excludePartPath) {
+    const ids = collectReferenceIds(documentXml, referenceTag);
+    for (const storyPath of ['word/footnotes.xml', 'word/endnotes.xml']) {
+        if (storyPath === excludePartPath)
+            continue;
+        const storyXml = await resultArchive.getFile(storyPath);
+        if (!storyXml)
+            continue;
+        for (const id of collectReferenceIds(storyXml, referenceTag))
+            ids.add(id);
+    }
+    return ids;
+}
 /**
  * Collect reference IDs from document.xml using DOM parsing.
  */
@@ -800,21 +669,6 @@ function collectReferenceIds(documentXml, referenceTag) {
     }
     return ids;
 }
-/**
- * Parse an auxiliary part and extract entry elements by ID.
- */
-function parseEntries(xml, entryTag) {
-    const doc = parseXml(xml);
-    const entries = new Map();
-    const elements = doc.getElementsByTagName(entryTag);
-    for (let i = 0; i < elements.length; i++) {
-        const el = elements[i];
-        const id = el.getAttribute('w:id');
-        if (id)
-            entries.set(id, el);
-    }
-    return { doc, entries };
-}
 /**
  * Merge auxiliary part definitions (footnotes, endnotes, comments) from the
  * source archive into the result archive. The source archive is whichever
@@ -824,7 +678,11 @@ function parseEntries(xml, entryTag) {
  */
 async function mergeAuxiliaryPartDefinitions(sourceArchive, resultArchive, documentXml, descriptor) {
     const result = { mergedIds: new Set(), createdPart: false };
-    const referencedIds = collectReferenceIds(documentXml, descriptor.referenceTag);
+    // Anchors may live in the merged body or on note text in the result's
+    // footnote/endnote stories. AUXILIARY_PARTS merges notes before comments,
+    // so by the comment pass the note stories already carry any merged-in
+    // comment anchors.
+    const referencedIds = await collectStoryReferenceIds(resultArchive, documentXml, descriptor.referenceTag, descriptor.partPath);
     if (referencedIds.size === 0)
         return result;
     const sourcePartXml = await sourceArchive.getFile(descriptor.partPath);
@@ -1154,6 +1012,7 @@ const COMMENTS_EXTENDED_DESCRIPTOR = {
     rootTag: 'w15:commentsEx',
     contentType: 'application/vnd.ms-word.commentsExtended+xml',
     relationshipType: 'http://schemas.microsoft.com/office/2011/relationships/commentsExtended',
+    idBearingTags: [], // keyed by w15:paraId, not w:id
 };
 const PEOPLE_DESCRIPTOR = {
     label: 'people',
@@ -1163,6 +1022,7 @@ const PEOPLE_DESCRIPTOR = {
     rootTag: 'w15:people',
     contentType: 'application/vnd.ms-word.people+xml',
     relationshipType: 'http://schemas.microsoft.com/office/2011/relationships/people',
+    idBearingTags: [], // keyed by w15:author, not w:id
 };
 async function mergePeople(sourceArchive, resultArchive, mergedAuthors) {
     if (mergedAuthors.size === 0)
@@ -1219,47 +1079,82 @@ async function mergePeople(sourceArchive, resultArchive, mergedAuthors) {
     resultArchive.setFile('word/people.xml', serializer.serializeToString(newDoc));
     await ensureOpcMetadata(resultArchive, PEOPLE_DESCRIPTOR);
 }
+const fallbackParagraphStatsKeys = new WeakMap();
+let nextFallbackParagraphStatsKey = 0;
+function paragraphStatsKey(atom) {
+    if (atom.paragraphIndex !== undefined) {
+        return `${atom.part.uri}:${atom.paragraphIndex}`;
+    }
+    const pAncestor = atom.ancestorElements.find((a) => a.tagName === 'w:p');
+    if (!pAncestor)
+        return undefined;
+    let key = fallbackParagraphStatsKeys.get(pAncestor);
+    if (!key) {
+        key = `${atom.part.uri}:paragraph-ref:${nextFallbackParagraphStatsKey++}`;
+        fallbackParagraphStatsKeys.set(pAncestor, key);
+    }
+    return key;
+}
 /**
  * Compute comparison statistics from merged atoms.
+ *
+ * Range counts are contiguous same-status runs in the merged atom stream, scoped
+ * to a paragraph. Atom counts remain available under explicit names for callers
+ * that need the old granular benchmark signal.
  */
-function computeStats(mergedAtoms) {
+export function computeAtomizerStats(mergedAtoms) {
     const reconstructionStats = computeReconstructionStats(mergedAtoms);
-    // Count unique paragraphs for modifications
-    // A modification is when we have both deleted and inserted atoms in the same paragraph
-    const modifiedParagraphs = new Set();
-    let currentParagraph = '';
-    let hasDeleted = false;
-    let hasInserted = false;
+    let insertedRanges = 0;
+    let deletedRanges = 0;
+    let formatChanges = 0;
+    let previousRangeStatus = null;
+    let previousRangeParagraph;
+    const paragraphs = new Map();
     for (const atom of mergedAtoms) {
-        // Detect paragraph boundaries
-        const pAncestor = atom.ancestorElements.find((a) => a.tagName === 'w:p');
-        const paragraphId = pAncestor
-            ? `${atom.part.uri}:${atom.ancestorElements.indexOf(pAncestor)}`
-            : '';
-        if (paragraphId !== currentParagraph) {
-            // Check previous paragraph
-            if (currentParagraph && hasDeleted && hasInserted) {
-                modifiedParagraphs.add(currentParagraph);
+        const paragraphKey = paragraphStatsKey(atom);
+        const status = atom.correlationStatus;
+        const rangeStatus = status === CorrelationStatus.Inserted ||
+            status === CorrelationStatus.Deleted ||
+            status === CorrelationStatus.FormatChanged
+            ? status
+            : null;
+        if (rangeStatus) {
+            if (rangeStatus !== previousRangeStatus || paragraphKey !== previousRangeParagraph) {
+                if (rangeStatus === CorrelationStatus.Inserted)
+                    insertedRanges++;
+                if (rangeStatus === CorrelationStatus.Deleted)
+                    deletedRanges++;
+                if (rangeStatus === CorrelationStatus.FormatChanged)
+                    formatChanges++;
             }
-            currentParagraph = paragraphId;
-            hasDeleted = false;
-            hasInserted = false;
+            previousRangeStatus = rangeStatus;
+            previousRangeParagraph = paragraphKey;
         }
-        if (atom.correlationStatus === CorrelationStatus.Deleted) {
-            hasDeleted = true;
+        else {
+            previousRangeStatus = null;
+            previousRangeParagraph = undefined;
         }
-        else if (atom.correlationStatus === CorrelationStatus.Inserted) {
-            hasInserted = true;
+        if (paragraphKey && (status === CorrelationStatus.Deleted || status === CorrelationStatus.Inserted)) {
+            const flags = paragraphs.get(paragraphKey) ?? { hasDeleted: false, hasInserted: false };
+            if (status === CorrelationStatus.Deleted)
+                flags.hasDeleted = true;
+            if (status === CorrelationStatus.Inserted)
+                flags.hasInserted = true;
+            paragraphs.set(paragraphKey, flags);
         }
     }
-    // Check last paragraph
-    if (currentParagraph && hasDeleted && hasInserted) {
-        modifiedParagraphs.add(currentParagraph);
-    }
+    const modifiedParagraphs = Array.from(paragraphs.values()).filter((flags) => flags.hasDeleted && flags.hasInserted).length;
     return {
-        insertions: reconstructionStats.insertions,
-        deletions: reconstructionStats.deletions,
-        modifications: modifiedParagraphs.size + reconstructionStats.formatChanges,
+        insertions: insertedRanges,
+        deletions: deletedRanges,
+        modifications: modifiedParagraphs,
+        insertedRanges,
+        deletedRanges,
+        insertedAtoms: reconstructionStats.insertions,
+        deletedAtoms: reconstructionStats.deletions,
+        modifiedParagraphs,
+        formatChanges,
+        formatChangeAtoms: reconstructionStats.formatChanges,
     };
 }
 //# sourceMappingURL=pipeline.js.map