@stll/folio-core 0.59.0 → 0.60.0

package/dist/docx/importedIdCollisions.js

@@ -0,0 +1,215 @@
+import { paraIdAttribute, textIdAttribute } from "./paraIdAttribute.js";
+import { REVISION_ELEMENT_NAMES } from "./revisionIdNormalization.js";
+import { scanSelectedStreamingXmlElements } from "./selectedXmlIdentityScan.js";
+import { OOXML_NAMESPACES } from "./serializer/partNamespaces.js";
+import { toTransitionalNamespaceUri } from "./transitionalSpelling.js";
+import { resolveNamespaceUri } from "./xmlNamespaceContext.js";
+import { NAMESPACES, getLocalName, getNamespaceUri } from "./xmlParser.js";
+import { panic } from "better-result";
+import { IMPORTED_ID_COLLISION_KINDS, PARSE_WARNING_CODES } from "@stll/docx-core/model";
+//#region src/docx/importedIdCollisions.ts
+const WORD_2010_NAMESPACE = "http://schemas.microsoft.com/office/word/2010/wordml";
+const PACKAGE_RELATIONSHIP_NAMESPACE = "http://schemas.openxmlformats.org/package/2006/relationships";
+const paragraphIdentityForKind = (kind, element) => {
+	switch (kind) {
+		case IMPORTED_ID_COLLISION_KINDS.paraId: return paraIdAttribute(element);
+		case IMPORTED_ID_COLLISION_KINDS.textId: return textIdAttribute(element);
+		default: return;
+	}
+};
+/** Definition sites only: paired markers and references never claim an identity. */
+const IMPORTED_ID_COLLISION_REGISTRY = {
+	bookmark: {
+		kind: IMPORTED_ID_COLLISION_KINDS.bookmark,
+		scope: "part",
+		sites: [{
+			namespace: NAMESPACES.w,
+			elements: /* @__PURE__ */ new Set(["bookmarkStart"])
+		}],
+		attribute: "id",
+		attributeNamespace: NAMESPACES.w,
+		encoding: "decimal"
+	},
+	comment: {
+		kind: IMPORTED_ID_COLLISION_KINDS.comment,
+		scope: "part",
+		sites: [{
+			namespace: NAMESPACES.w,
+			elements: /* @__PURE__ */ new Set(["comment"])
+		}],
+		attribute: "id",
+		attributeNamespace: NAMESPACES.w,
+		encoding: "decimal"
+	},
+	footnote: {
+		kind: IMPORTED_ID_COLLISION_KINDS.footnote,
+		scope: "part",
+		sites: [{
+			namespace: NAMESPACES.w,
+			elements: /* @__PURE__ */ new Set(["footnote"])
+		}],
+		attribute: "id",
+		attributeNamespace: NAMESPACES.w,
+		encoding: "decimal"
+	},
+	endnote: {
+		kind: IMPORTED_ID_COLLISION_KINDS.endnote,
+		scope: "part",
+		sites: [{
+			namespace: NAMESPACES.w,
+			elements: /* @__PURE__ */ new Set(["endnote"])
+		}],
+		attribute: "id",
+		attributeNamespace: NAMESPACES.w,
+		encoding: "decimal"
+	},
+	revision: {
+		kind: IMPORTED_ID_COLLISION_KINDS.revision,
+		scope: "package",
+		sites: [{
+			namespace: NAMESPACES.w,
+			elements: REVISION_ELEMENT_NAMES
+		}],
+		attribute: "id",
+		attributeNamespace: NAMESPACES.w,
+		encoding: "decimal"
+	},
+	paraId: {
+		kind: IMPORTED_ID_COLLISION_KINDS.paraId,
+		scope: "part",
+		sites: [
+			{
+				namespace: NAMESPACES.w,
+				elements: /* @__PURE__ */ new Set(["p"])
+			},
+			{
+				namespace: NAMESPACES.w15,
+				elements: /* @__PURE__ */ new Set(["commentEx"])
+			},
+			{
+				namespace: OOXML_NAMESPACES.w16cex.uri,
+				elements: /* @__PURE__ */ new Set(["comment"])
+			}
+		],
+		attribute: "paraId",
+		attributeNamespace: WORD_2010_NAMESPACE,
+		encoding: "hex"
+	},
+	textId: {
+		kind: IMPORTED_ID_COLLISION_KINDS.textId,
+		scope: "part",
+		sites: [{
+			namespace: NAMESPACES.w,
+			elements: /* @__PURE__ */ new Set(["p"])
+		}],
+		attribute: "textId",
+		attributeNamespace: WORD_2010_NAMESPACE,
+		encoding: "hex"
+	},
+	numId: {
+		kind: IMPORTED_ID_COLLISION_KINDS.numId,
+		scope: "part",
+		sites: [{
+			namespace: NAMESPACES.w,
+			elements: /* @__PURE__ */ new Set(["num"])
+		}],
+		attribute: "numId",
+		attributeNamespace: NAMESPACES.w,
+		encoding: "decimal"
+	},
+	abstractNumId: {
+		kind: IMPORTED_ID_COLLISION_KINDS.abstractNumId,
+		scope: "part",
+		sites: [{
+			namespace: NAMESPACES.w,
+			elements: /* @__PURE__ */ new Set(["abstractNum"])
+		}],
+		attribute: "abstractNumId",
+		attributeNamespace: NAMESPACES.w,
+		encoding: "decimal"
+	},
+	drawing: {
+		kind: IMPORTED_ID_COLLISION_KINDS.drawing,
+		scope: "package",
+		sites: [{
+			namespace: NAMESPACES.wp,
+			elements: /* @__PURE__ */ new Set(["docPr"])
+		}],
+		attribute: "id",
+		attributeNamespace: null,
+		encoding: "decimal"
+	},
+	relationship: {
+		kind: IMPORTED_ID_COLLISION_KINDS.relationship,
+		scope: "part",
+		sites: [{
+			namespace: PACKAGE_RELATIONSHIP_NAMESPACE,
+			elements: /* @__PURE__ */ new Set(["Relationship"])
+		}],
+		attribute: "Id",
+		attributeNamespace: null,
+		encoding: "string"
+	}
+};
+const normalizedIdentity = (value, encoding) => {
+	if (encoding === "string") return value;
+	if (encoding === "hex") return /^[0-9a-f]{8}$/iu.test(value) ? value.toUpperCase() : void 0;
+	const spelling = value.trim();
+	if (!/^[+-]?\d+$/u.test(spelling)) return void 0;
+	const digits = spelling.replace(/^[+-]?0*/u, "");
+	return digits === "" ? "0" : `${spelling.startsWith("-") ? "-" : ""}${digits}`;
+};
+/** Reports repeated source definitions without changing the package or choosing a winner. */
+const diagnoseImportedIdCollisions = (parts, context) => {
+	const rules = Object.values(IMPORTED_ID_COLLISION_REGISTRY);
+	const packageSeen = /* @__PURE__ */ new Map();
+	for (const [part, xml] of parts) {
+		const partSeen = /* @__PURE__ */ new Map();
+		const scoped = context.scoped({ part });
+		scanSelectedStreamingXmlElements(xml, ({ element, attributeValueSpans }) => {
+			if (element.name === void 0) return;
+			const namespace = toTransitionalNamespaceUri(getNamespaceUri(element) ?? "");
+			const localName = getLocalName(element.name);
+			for (const rule of rules) {
+				const kind = rule.kind;
+				if (!rule.sites.some((site) => namespace === site.namespace && site.elements.has(localName))) continue;
+				const paragraphIdentity = paragraphIdentityForKind(kind, element);
+				const seen = rule.scope === "package" ? packageSeen : partSeen;
+				for (const [name, rawValue] of Object.entries(element.attributes ?? {})) {
+					if (getLocalName(name) !== rule.attribute || rawValue === void 0) continue;
+					const colon = name.indexOf(":");
+					const attributeNamespace = colon < 0 ? null : toTransitionalNamespaceUri(resolveNamespaceUri(element.namespaceScope, name.slice(0, colon)) ?? "");
+					if (rule.encoding === "hex") {
+						if (String(rawValue) !== paragraphIdentity) continue;
+					} else if (attributeNamespace !== rule.attributeNamespace) continue;
+					const value = String(rawValue);
+					const identity = normalizedIdentity(value, rule.encoding);
+					if (identity === void 0) continue;
+					const key = `${kind}:${identity}`;
+					const span = attributeValueSpans.get(name);
+					if (span === void 0) panic("Missing imported identity source span");
+					const offset = span.start;
+					const first = seen.get(key);
+					if (first === void 0) {
+						seen.set(key, {
+							part,
+							offset
+						});
+						break;
+					}
+					scoped.warn({
+						code: PARSE_WARNING_CODES.duplicateImportedId,
+						identityKind: kind,
+						element: element.name,
+						at: `offset ${offset}`,
+						value,
+						detail: `${kind} identity repeats the definition at offset ${first.offset} in ${first.part}.`
+					});
+					break;
+				}
+			}
+		});
+	}
+};
+//#endregion
+export { IMPORTED_ID_COLLISION_REGISTRY, diagnoseImportedIdCollisions };

package/dist/docx/numberingParser.js

@@ -398,9 +398,9 @@ function getCachedNumberingMap(definitions) {
 */
 function createNumberingMap(definitions) {
 	const abstractMap = /* @__PURE__ */ new Map();
-	for (const abs of definitions.abstractNums) abstractMap.set(abs.abstractNumId, abs);
+	for (const abs of definitions.abstractNums) if (!abstractMap.has(abs.abstractNumId)) abstractMap.set(abs.abstractNumId, abs);
 	const numMap = /* @__PURE__ */ new Map();
-	for (const num of definitions.nums) numMap.set(num.numId, num);
+	for (const num of definitions.nums) if (!numMap.has(num.numId)) numMap.set(num.numId, num);
 	return {
 		definitions,
 		getLevel(numId, ilvl) {

package/dist/docx/paragraphPropertySource.js

@@ -5,7 +5,6 @@ import { parseParagraphProperties } from "./paragraphProperties.js";
 import { visitDocxParagraphs } from "./paragraphTraversal.js";
 import { parseXmlDocument } from "./xmlParser.js";
 import { TaggedError, panic } from "better-result";
-import { PluginKey } from "prosemirror-state";
 //#region src/docx/paragraphPropertySource.ts
 const paragraphPropertySourceEmissionFingerprint = Symbol("paragraphPropertySourceEmissionFingerprint");
 const paragraphPropertySourceIndentationBaseline = Symbol("paragraphPropertySourceIndentationBaseline");
@@ -793,7 +792,7 @@ const createProseParagraphWithPropertySource = (nodeType, sourceParagraph, optio
 	linkProseParagraphPropertySource(paragraph, sourceParagraph);
 	return paragraph;
 };
-const paragraphPropertySourceTransfersKey = new PluginKey("paragraphPropertySourceTransfers");
+const paragraphPropertySourceTransfersKey = "stll.folio.meta.paragraphPropertySourceTransfers";
 /** Join adjacent paragraphs when revision semantics deliberately select the right owner. */
 const joinProseParagraphsWithRightPropertySource = ({ attrs, pos, transaction }) => {
 	const $pos = transaction.doc.resolve(pos);

package/dist/docx/parseContext.d.ts

@@ -1,8 +1,9 @@
-import { ParseWarning, ParseWarningCode } from "@stll/docx-core/model";
+import { ImportedIdCollisionKind, ParseWarning, ParseWarningCode } from "@stll/docx-core/model";
 //#region src/docx/parseContext.d.ts
 /** What a call site states; the collector supplies the rest. */
 type ParseWarningReport = {
   code: ParseWarningCode;
+  identityKind?: ImportedIdCollisionKind;
   /** The element as written, prefix included. */
   element?: string;
   /** The best position this part can name, e.g. `style "Heading1"`. */

package/dist/docx/parseContext.js

@@ -30,6 +30,7 @@ const createParseWarningCollector = (part = PACKAGE_PART) => {
 		retainedByCode.set(report.code, kept + 1);
 		retained.push({
 			code: report.code,
+			...report.identityKind === void 0 ? {} : { identityKind: report.identityKind },
 			location: {
 				...location,
 				...report.element === void 0 ? {} : { element: report.element },

package/dist/docx/parseWarningMessage.js

@@ -22,6 +22,7 @@ const PARSE_WARNING_MESSAGES = {
 	[PARSE_WARNING_CODES.documentPartMissing]: () => "No document.xml found in DOCX",
 	[PARSE_WARNING_CODES.documentModelIssue]: (warning) => warning.detail ?? "The document model reported an issue.",
 	[PARSE_WARNING_CODES.duplicateCommentId]: (warning) => `Dropped ${plural(warning.count, "comment")} repeating a w:id another comment already defines.`,
+	[PARSE_WARNING_CODES.duplicateImportedId]: (warning) => `Repeated imported identity${quoted(warning.value)}${where(warning)}: ${warning.detail ?? "multiple definitions share an identity."}`,
 	[PARSE_WARNING_CODES.missingCommentId]: (warning) => `Dropped ${plural(warning.count, "comment")} with no readable w:id.`,
 	[PARSE_WARNING_CODES.duplicateNoteId]: (warning) => `Dropped ${plural(warning.count, "note")} repeating a w:id another note already defines.`,
 	[PARSE_WARNING_CODES.danglingCommentReference]: (warning) => `Removed ${plural(warning.count, "dangling comment reference marker")} whose comments.xml entries are missing.`,

package/dist/docx/parser.js

@@ -2,6 +2,7 @@ import { toArrayBuffer } from "../utils/docxInput.js";
 import { loadFontsWithMapping } from "../utils/fontLoader.js";
 import { MAX_PACKAGE_TIFF_PIXELS, convertTiffToPngDataUrl, isTiffMimeType } from "../utils/tiffConverter.js";
 import { ALT_CHUNK_PLAIN_TEXT_LIMIT_BYTES, getAltChunkRelationshipId, isAltChunkMarkup } from "./altChunk.js";
+import { normalizeBookmarkIdsInXmlParts } from "./bookmarkIdNormalization.js";
 import { DUPLICATE_COMMENT_ID_WARNING, normalizeCommentIds } from "./commentIdNormalization.js";
 import { parseComments } from "./commentParser.js";
 import { DANGLING_COMMENT_REFERENCE_WARNING, UNBALANCED_COMMENT_RANGE_WARNING, normalizeCommentReferences } from "./commentReferenceNormalization.js";
@@ -16,6 +17,7 @@ import { parseEndnotes, parseFootnotes } from "./footnoteParser.js";
 import { parseFooter, parseHeader } from "./headerFooterParser.js";
 import { DANGLING_FOOTER_REFERENCE_WARNING, DANGLING_HEADER_REFERENCE_WARNING, assignHeaderFooterRoles, normalizeHeaderFooterReferences } from "./headerFooterReferenceNormalization.js";
 import { assignHeaderFooterVerbatimXml, canReplayHeaderFooterVerbatim, captureDocumentSourceBaseline, captureHeaderFooterPackageBaselines, refreshHeaderFooterVerbatimFingerprint } from "./headerFooterVerbatim.js";
+import { diagnoseImportedIdCollisions } from "./importedIdCollisions.js";
 import { extractMetafileRaster, isMetafileMimeType } from "./metafileRaster.js";
 import { renderEmfSvg } from "./metafileSvg.js";
 import { DocxModelValidationError, formatDocumentModelIssues, validateFolioDocumentModel } from "./modelValidation.js";
@@ -34,7 +36,7 @@ import { parseSettings } from "./settingsParser.js";
 import { parseStylesPackage } from "./styleParser.js";
 import { applyThemeFontLang, parseTheme } from "./themeParser.js";
 import { UNBALANCED_MOVE_RANGE_WARNING, normalizeTrackedMoveRanges } from "./trackedMoveRangeNormalization.js";
-import { getEntryUncompressedSize, getMediaMimeType, mediaToDataUrl, unzipDocx } from "./unzip.js";
+import { getEntryUncompressedSize, getMediaMimeType, mediaToDataUrl, replaceRawDocxXmlParts, unzipDocx } from "./unzip.js";
 import { getAttribute, getChildElements, getLocalName, parseXml, parseXmlDocument } from "./xmlParser.js";
 import { FOLIO_XML_RESOURCE_LIMITS } from "./xmlResourceLimits.js";
 import { TaggedError, panic } from "better-result";
@@ -192,6 +194,8 @@ async function parseDocxWithPreviewBudget(input, options, previewBudget) {
 			password,
 			extractAllXml: false
 		}));
+		diagnoseImportedIdCollisions(raw.allXml, parseContext);
+		await replaceRawDocxXmlParts(raw, normalizeBookmarkIdsInXmlParts(raw.allXml));
 		const repairedDocumentTree = await normalizeRawDocxNumericIds(raw);
 		const paragraphPropertySourceDigest = sha256Hex(raw.originalBuffer);
 		if (raw.wasEncrypted) parseContext.warn({ code: PARSE_WARNING_CODES.packageDecrypted });

package/dist/docx/relsParser.js

@@ -86,7 +86,7 @@ function parseRelationships(relsXml) {
 		};
 		if (targetMode === "External") relationship.targetMode = "External";
 		else if (targetMode === "Internal") relationship.targetMode = "Internal";
-		map.set(id, relationship);
+		if (!map.has(id)) map.set(id, relationship);
 	}
 	return map;
 }

package/dist/docx/rezip.js

@@ -25,7 +25,7 @@ import { RELATIONSHIP_TYPES, parseRelationships, resolveRelativePath } from "./r
 import { removeResolvedHeaderFooterParts } from "./removeHeaderFooterParts.js";
 import { normalizeRevisionIdsInXmlParts } from "./revisionIdNormalization.js";
 import { buildPatchedNotePartXml, collectChangedNoteParaIds, collectParaIds, patchNumberingDefinitions, spliceXml } from "./selectiveXmlPatch.js";
-import { hasOwnedCommentsPart, planCommentParts, serializeComments, serializeCommentsExtended } from "./serializer/commentSerializer.js";
+import { canReplayCommentsPart, hasOwnedCommentsPart, planCommentParts, serializeComments, serializeCommentsExtended } from "./serializer/commentSerializer.js";
 import { serializeDocument } from "./serializer/documentSerializer.js";
 import { serializeFontTableXml } from "./serializer/fontTableSerializer.js";
 import { serializeHeaderFooter } from "./serializer/headerFooterSerializer.js";
@@ -201,6 +201,7 @@ async function serializeCommentsToZip(doc, zip, compressionLevel) {
 	const comments = doc.package.document.comments ?? [];
 	const sourceCommentsFile = findZipEntryCaseInsensitive(zip, "word/comments.xml");
 	const sourceCommentsXml = sourceCommentsFile ? await sourceCommentsFile.async("text") : void 0;
+	if (sourceCommentsXml !== void 0 && canReplayCommentsPart(doc, sourceCommentsXml)) return;
 	if (comments.length === 0) {
 		const ownsCommentsPart = hasOwnedCommentsPart(doc);
 		if (sourceCommentsXml === void 0 ? !ownsCommentsPart : !hasCommentEntries(sourceCommentsXml)) return;

package/dist/docx/selectedXmlIdentityScan.d.ts

@@ -0,0 +1,10 @@
+import { scanStreamingXmlElements } from "./streamingXmlParser.js";
+//#region src/docx/selectedXmlIdentityScan.d.ts
+/** Identity census follows the parser's first-Choice, otherwise-Fallback policy. */
+declare const scanSelectedStreamingXmlElements: (xml: string, visitor: Parameters<typeof scanStreamingXmlElements>[1]) => {
+  status: "unsupported";
+} | {
+  status: "scanned";
+};
+//#endregion
+export { scanSelectedStreamingXmlElements };

package/dist/docx/selectedXmlIdentityScan.js

@@ -0,0 +1,36 @@
+import { scanStreamingXmlElements } from "./streamingXmlParser.js";
+import { NAMESPACES, getLocalName, getNamespaceUri, selectAlternateContentBranch } from "./xmlParser.js";
+//#region src/docx/selectedXmlIdentityScan.ts
+const isCompatibilityElement = (element, name) => getNamespaceUri(element) === NAMESPACES.mc && getLocalName(element.name) === name;
+/** Identity census follows the parser's first-Choice, otherwise-Fallback policy. */
+const scanSelectedStreamingXmlElements = (xml, visitor) => {
+	if (!xml.includes("AlternateContent")) return scanStreamingXmlElements(xml, visitor);
+	const alternatives = /* @__PURE__ */ new Map();
+	const positions = /* @__PURE__ */ new WeakMap();
+	const scanned = scanStreamingXmlElements(xml, ({ element, parent, nameEnd }) => {
+		positions.set(element, nameEnd);
+		if (isCompatibilityElement(element, "AlternateContent")) {
+			element.elements = [];
+			alternatives.set(nameEnd, element);
+		}
+		if (!parent || !isCompatibilityElement(parent, "AlternateContent")) return;
+		parent.elements?.push(element);
+	});
+	if (scanned.status === "unsupported") return scanned;
+	const selectedPositions = /* @__PURE__ */ new Map();
+	for (const [position, alternative] of alternatives) {
+		const selected = selectAlternateContentBranch(alternative);
+		selectedPositions.set(position, selected === void 0 ? void 0 : positions.get(selected));
+	}
+	const active = /* @__PURE__ */ new WeakMap();
+	return scanStreamingXmlElements(xml, (entry) => {
+		const { element, parent, nameEnd } = entry;
+		positions.set(element, nameEnd);
+		let included = parent === void 0 || active.get(parent) === true;
+		if (parent && isCompatibilityElement(parent, "AlternateContent")) included &&= nameEnd === selectedPositions.get(positions.get(parent) ?? -1);
+		active.set(element, included);
+		if (included) visitor(entry);
+	});
+};
+//#endregion
+export { scanSelectedStreamingXmlElements };

package/dist/docx/selectiveSave.js

@@ -10,7 +10,7 @@ import { RELATIONSHIP_TYPES } from "./relsParser.js";
 import { COMMENTS_CONTENT_TYPE, COMMENTS_EXTENDED_PART_LOWER, addCommentsExtendedOverride, addCommentsExtendedRelationship, applyUpdatesToZip, collectHeaderFooterUpdates, findMaxRId, hasModelDrivenPictureWatermark, hasUnmaterializedHeaderFooter, hasUnmaterializedHyperlinkBindings, hasUnmaterializedInlineResources, planAddedStyles, publishCanonicalImageResources, updateCoreProperties, withoutAttachedTemplate } from "./rezip.js";
 import "./selectiveSaveFlags.js";
 import { buildPatchedDocumentXml, buildPatchedNoteXml, collectAddedNumberingDefs, collectParaIds, patchNumberingDefinitions } from "./selectiveXmlPatch.js";
-import { hasOwnedCommentsPart, planCommentParts, serializeComments, serializeCommentsExtended } from "./serializer/commentSerializer.js";
+import { canReplayCommentsPart, hasOwnedCommentsPart, planCommentParts, serializeComments, serializeCommentsExtended } from "./serializer/commentSerializer.js";
 import { serializeDocument } from "./serializer/documentSerializer.js";
 import { serializeEndnotes, serializeFootnotes } from "./serializer/noteSerializer.js";
 import { serializeNumberingXml } from "./serializer/numberingSerializer.js";
@@ -262,8 +262,9 @@ async function attemptSelectiveSave(doc, originalBuffer, options) {
 		}
 		const sourceCommentsFile = findZipEntryCaseInsensitive(zip, "word/comments.xml");
 		const commentsPartPath = sourceCommentsFile?.name ?? "word/comments.xml";
-		if (hasComments || ownsCommentsPart || sourceCommentsFile) {
-			const sourceCommentsXml = sourceCommentsFile ? await sourceCommentsFile.async("text") : void 0;
+		const sourceCommentsXml = sourceCommentsFile ? await sourceCommentsFile.async("text") : void 0;
+		const commentsUnchanged = sourceCommentsXml !== void 0 && canReplayCommentsPart(doc, sourceCommentsXml);
+		if (!commentsUnchanged && (hasComments || ownsCommentsPart || sourceCommentsFile)) {
 			const commentsXml = serializeComments(commentPlan, sourceCommentsXml === void 0 ? void 0 : readRootNamespaceBindings(sourceCommentsXml));
 			if (commentsXml !== sourceCommentsXml) updates.set(commentsPartPath, commentsXml);
 		}
@@ -283,7 +284,7 @@ async function attemptSelectiveSave(doc, originalBuffer, options) {
 				}
 			}
 		}
-		if (!await patchCommentsExtended(zip, commentPlan, updates)) return null;
+		if (!commentsUnchanged && !await patchCommentsExtended(zip, commentPlan, updates)) return null;
 		if (!await patchNumberingPart(zip, doc, updates)) return null;
 		const styles = await planAddedStyles(doc, zip);
 		switch (styles.type) {

package/dist/docx/selectiveXmlPatch.js

@@ -1,6 +1,7 @@
 import { patchBreaksCommentRangeBalance } from "./commentRangeIntegrity.js";
 import { resolveParagraphIdentities } from "./paraIdAttribute.js";
 import { readRootNamespaceBindings } from "./serializer/partNamespaces.js";
+import { scanStreamingXmlElements } from "./streamingXmlParser.js";
 import { captureVerbatimXml } from "./verbatimCapture.js";
 import { PARAGRAPH_SCAN_NAMES, hasCanonicalWordprocessingPrefixes, matchCloseTag, matchOpenTag, resolveSelectiveScanPrefixes, splicesAsCanonical } from "./wordprocessingPrefixes.js";
 import { resolveNamespaceUri } from "./xmlNamespaceContext.js";
@@ -650,36 +651,32 @@ function extractElementByIdAttr(xml, openLiteral, closeTag, idAttr, id) {
 const qualifiedName = (prefix, localName) => prefix.length === 0 ? localName : `${prefix}:${localName}`;
 const collectNoteElementSyntax = (xml, elementName) => {
 	const byId = /* @__PURE__ */ new Map();
-	const root = parseXmlDocument(xml);
-	for (const element of getChildElements(root)) {
-		if (getLocalName(element.name) !== elementName || !WORDPROCESSINGML_NAMESPACE_URIS.has(getNamespaceUri(element) ?? "")) continue;
+	let root;
+	scanStreamingXmlElements(xml, ({ element, parent, nameEnd }) => {
+		if (parent === void 0) {
+			root = element;
+			return;
+		}
+		if (parent !== root || getLocalName(element.name) !== elementName || !WORDPROCESSINGML_NAMESPACE_URIS.has(getNamespaceUri(element) ?? "")) return;
 		const idAttribute = findAttributeByNamespaceUri(element, WORDPROCESSINGML_NAMESPACE_URIS, "id");
-		if (!element.name || !idAttribute) continue;
+		if (!element.name || !idAttribute) return;
+		const spelling = idAttribute.value.trim();
+		if (!/^[+-]?\d+$/u.test(spelling) || !Number.isSafeInteger(Number(spelling))) return;
+		const id = String(Number(spelling));
+		const offsets = scanElementRange(xml, nameEnd - element.name.length - 1, `<${element.name}`, `</${element.name}>`);
+		if (!offsets) return;
 		const syntax = {
-			elementName: element.name,
-			idAttributeName: idAttribute.name,
+			offsets,
 			elementPrefix: getNamespacePrefix(element.name) ?? "",
 			attributePrefix: getNamespacePrefix(idAttribute.name) ?? ""
 		};
-		const entries = byId.get(idAttribute.value);
+		const entries = byId.get(id);
 		if (entries) entries.push(syntax);
-		else byId.set(idAttribute.value, [syntax]);
-	}
+		else byId.set(id, [syntax]);
+	});
 	return byId;
 };
-const syntaxLiteral = (syntax) => ({
-	openLiteral: `<${syntax.elementName}`,
-	closeTag: `</${syntax.elementName}>`,
-	idAttr: syntax.idAttributeName
-});
-const extractNoteElement = (xml, syntax, id) => {
-	const { openLiteral, closeTag, idAttr } = syntaxLiteral(syntax);
-	return extractElementByIdAttr(xml, openLiteral, closeTag, idAttr, id);
-};
-const findNoteElement = (xml, syntax, id) => {
-	const { openLiteral, closeTag, idAttr } = syntaxLiteral(syntax);
-	return findElementByIdAttr(xml, openLiteral, closeTag, idAttr, id);
-};
+const extractNoteElement = (xml, syntax) => xml.slice(syntax.offsets.start, syntax.offsets.end);
 const rewriteWordprocessingPrefixes = (xml, { source, target, sourceXmlnsDeclarations }) => {
 	let rewritten = "";
 	let quote = null;
@@ -824,7 +821,7 @@ function buildPatchedNotePartXml({ originalXml, baselineXml, serializedXml, repl
 		const replacementSyntaxEntries = replacementElements.get(id);
 		if (originalSyntaxEntries === void 0) {
 			const replacementSyntax = currentSyntaxEntries.length === 1 && replacementSyntaxEntries?.length === 1 ? replacementSyntaxEntries[0] : void 0;
-			const replacementNote = replacementSyntax ? extractNoteElement(replacementXml, replacementSyntax, id) : null;
+			const replacementNote = replacementSyntax ? extractNoteElement(replacementXml, replacementSyntax) : null;
 			if (!replacementSyntax || !replacementNote) return {
 				type: "refused",
 				reason: "unroutable-paragraph"
@@ -836,24 +833,20 @@ function buildPatchedNotePartXml({ originalXml, baselineXml, serializedXml, repl
 			});
 			continue;
 		}
-		if (currentSyntaxEntries.length !== 1 || originalSyntaxEntries?.length !== 1 || replacementSyntaxEntries?.length !== 1) return {
+		if (currentSyntaxEntries.length !== 1 || !originalSyntaxEntries?.length || replacementSyntaxEntries?.length !== 1) return {
 			type: "refused",
 			reason: "unroutable-paragraph"
 		};
 		const currentSyntax = currentSyntaxEntries[0];
-		const originalSyntax = originalSyntaxEntries[0];
+		const originalSyntax = originalSyntaxEntries.at(0);
 		const replacementSyntax = replacementSyntaxEntries[0];
 		if (!currentSyntax || !originalSyntax || !replacementSyntax) return {
 			type: "refused",
 			reason: "unroutable-paragraph"
 		};
-		const currentNote = extractNoteElement(serializedXml, currentSyntax, id);
-		const originalOffsets = findNoteElement(originalXml, originalSyntax, id);
-		const replacementNote = extractNoteElement(replacementXml, replacementSyntax, id);
-		if (!currentNote || !originalOffsets || !replacementNote) return {
-			type: "refused",
-			reason: "unroutable-paragraph"
-		};
+		const currentNote = extractNoteElement(serializedXml, currentSyntax);
+		const originalOffsets = originalSyntax.offsets;
+		const replacementNote = extractNoteElement(replacementXml, replacementSyntax);
 		const originalNote = originalXml.slice(originalOffsets.start, originalOffsets.end);
 		const currentParagraphs = paragraphRanges(currentNote, currentSyntax.elementPrefix);
 		const originalParagraphs = paragraphRanges(originalNote, originalSyntax.elementPrefix);
@@ -861,7 +854,7 @@ function buildPatchedNotePartXml({ originalXml, baselineXml, serializedXml, repl
 		const noteChangedParaIds = [...collectParaIds(currentNote).keys()].filter((paraId) => unroutedChangedParaIds.has(paraId));
 		const baselineSyntaxEntries = baselineElements.get(id);
 		const baselineSyntax = baselineSyntaxEntries?.length === 1 ? baselineSyntaxEntries[0] : void 0;
-		const baselineNote = baselineSyntax ? extractNoteElement(baselineXml, baselineSyntax, id) : null;
+		const baselineNote = baselineSyntax ? extractNoteElement(baselineXml, baselineSyntax) : null;
 		const reshaped = baselineSyntax !== void 0 && baselineNote !== null && baselineNote !== currentNote && noteShapeChanged({
 			note: baselineNote,
 			prefix: baselineSyntax.elementPrefix
@@ -910,26 +903,29 @@ function buildPatchedNotePartXml({ originalXml, baselineXml, serializedXml, repl
 	for (const [id, baselineSyntaxEntries] of baselineElements) {
 		if (currentElements.has(id) || baselineSyntaxEntries.length !== 1) continue;
 		const originalSyntaxEntries = originalElements.get(id);
-		const originalSyntax = originalSyntaxEntries?.length === 1 ? originalSyntaxEntries[0] : void 0;
-		const originalOffsets = originalSyntax && findNoteElement(originalXml, originalSyntax, id);
-		if (!originalOffsets) return {
+		if (!originalSyntaxEntries?.length) return {
 			type: "refused",
 			reason: "unroutable-paragraph"
 		};
-		const removal = {
-			start: originalOffsets.start,
-			end: originalOffsets.end,
-			newXml: ""
-		};
-		paragraphSplices.push(removal);
-		noteSplices.push(removal);
+		for (const { offsets } of originalSyntaxEntries) {
+			const removal = {
+				...offsets,
+				newXml: ""
+			};
+			paragraphSplices.push(removal);
+			noteSplices.push(removal);
+		}
 	}
 	if (unroutedChangedParaIds.size > 0) return {
 		type: "refused",
 		reason: "unroutable-paragraph"
 	};
 	if (addedNotes.length > 0) {
-		const appended = appendNotesSplice(originalXml, originalElements, addedNotes, { sourceXmlnsDeclarations: replacementXmlnsDeclarations });
+		const appended = appendNotesSplice({
+			originalElements,
+			addedNotes,
+			sourceXmlnsDeclarations: replacementXmlnsDeclarations
+		});
 		if (!appended) return {
 			type: "refused",
 			reason: "unroutable-paragraph"
@@ -951,15 +947,11 @@ function buildPatchedNotePartXml({ originalXml, baselineXml, serializedXml, repl
 		xml: wholeNotes
 	};
 }
-/**
-* Insert new notes after the part's last note, spelled with that note's
-* prefixes. Null when the part holds no note to follow.
-*/
-const appendNotesSplice = (originalXml, originalElements, addedNotes, { sourceXmlnsDeclarations }) => {
+const appendNotesSplice = ({ originalElements, addedNotes, sourceXmlnsDeclarations }) => {
 	let last = null;
-	for (const [id, entries] of originalElements) for (const syntax of entries) {
-		const offsets = findNoteElement(originalXml, syntax, id);
-		if (offsets && (!last || offsets.end > last.end)) last = {
+	for (const entries of originalElements.values()) for (const syntax of entries) {
+		const offsets = syntax.offsets;
+		if (!last || offsets.end > last.end) last = {
 			end: offsets.end,
 			syntax
 		};

package/dist/docx/serializer/commentSerializer.d.ts

@@ -1,6 +1,8 @@
 import { document_d_exports } from "../../types/document.js";
 import { Comment } from "../../types/content.js";
 //#region src/docx/serializer/commentSerializer.d.ts
+/** An unrelated body edit must retain unmodelled duplicate comment definitions. */
+declare const canReplayCommentsPart: (document: document_d_exports.Document, sourceXml: string) => boolean;
 /** An owned empty part survives deletion of its final thread. */
 declare const hasOwnedCommentsPart: (document: document_d_exports.Document) => boolean;
 /**
@@ -55,4 +57,4 @@ declare function serializeComments({ order, byId }: CommentPartPlan, sourceBindi
  */
 declare function serializeCommentsExtended(plan: CommentPartPlan): string | null;
 //#endregion
-export { CommentPartPlan, hasOwnedCommentsPart, planCommentParts, serializeComments, serializeCommentsExtended };
+export { CommentPartPlan, canReplayCommentsPart, hasOwnedCommentsPart, planCommentParts, serializeComments, serializeCommentsExtended };

package/dist/docx/serializer/commentSerializer.js

@@ -1,10 +1,13 @@
+import { canonicalJson } from "../../utils/canonicalJson.js";
 import { deterministicHexId } from "../../utils/hexId.js";
 import { commentThreadParaId } from "../commentThreadKey.js";
 import { serializeWithPreservedChildren } from "../containerChildren.js";
+import { getDocumentSourceBaseline } from "../headerFooterVerbatim.js";
 import { serializeParagraph } from "./paragraphSerializer.js";
 import { serializePartElement } from "./partNamespaces.js";
 import { serializeTextFormatting } from "./textFormattingSerializer.js";
-import { escapeXmlAttribute } from "@stll/docx-core";
+import { Result } from "better-result";
+import { assertValidOoxmlNumericIds, escapeXmlAttribute } from "@stll/docx-core";
 import { COMMENT_PART_RELATIONSHIPS } from "@stll/docx-core/model";
 //#region src/docx/serializer/commentSerializer.ts
 /**
@@ -12,6 +15,12 @@ import { COMMENT_PART_RELATIONSHIPS } from "@stll/docx-core/model";
 *
 * Serializes Comment[] to OOXML comments.xml format.
 */
+/** An unrelated body edit must retain unmodelled duplicate comment definitions. */
+const canReplayCommentsPart = (document, sourceXml) => {
+	if (Result.try(() => assertValidOoxmlNumericIds(sourceXml, "word/comments.xml")).isErr()) return false;
+	const baseline = getDocumentSourceBaseline(document);
+	return baseline.type === "captured" && canonicalJson(document.package.document.comments ?? []) === canonicalJson(baseline.body.comments ?? []);
+};
 /** An owned empty part survives deletion of its final thread. */
 const hasOwnedCommentsPart = (document) => [...document.package.relationships?.values() ?? []].some(({ type }) => type === COMMENT_PART_RELATIONSHIPS.comments.type);
 const DEFAULT_ANNOTATION_REFERENCE_PROPERTIES = "<w:rPr><w:rStyle w:val=\"CommentReference\"/></w:rPr>";
@@ -200,4 +209,4 @@ function serializeCommentsExtended(plan) {
 	});
 }
 //#endregion
-export { hasOwnedCommentsPart, planCommentParts, serializeComments, serializeCommentsExtended };
+export { canReplayCommentsPart, hasOwnedCommentsPart, planCommentParts, serializeComments, serializeCommentsExtended };