@stll/folio-core 0.45.0 → 0.46.0

package/dist/docx/selectiveXmlPatch.js

@@ -1,3 +1,4 @@
+import { patchBreaksCommentRangeBalance } from "./commentRangeIntegrity.js";
 import { captureVerbatimXml } from "./verbatimCapture.js";
 import { WORDPROCESSINGML_NAMESPACE_URIS, cloneElement, findAttributeByNamespaceUri, getAttributeByNamespaceUri, getChildElements, getLocalName, getNamespacePrefix, getNamespaceUri, parseXmlDocument } from "./xmlParser.js";
 //#region src/docx/selectiveXmlPatch.ts
@@ -237,10 +238,27 @@ function buildPatchedNoteXml(originalXml, serializedXml, changedIds) {
 	return spliceChangedParagraphs(originalXml, serializedXml, changedIds);
 }
 /**
+* Apply `splices` to `xml`, end-to-start so earlier offsets stay valid.
+*
+* Every selective patch is a splice, and every splice goes through here, so
+* the refusal below is a property of the operation rather than a check each
+* site has to remember. A patch rewrites the regions an edit touched and keeps
+* the rest of the part byte-for-byte, so it can write half a comment range:
+* invalid OOXML that anchors the comment to nothing. Answers null when it
+* would, leaving the caller to rewrite a wider region — ultimately the whole
+* part from the model, which is balanced with itself.
+*/
+const spliceXml = (xml, splices) => {
+	let result = xml;
+	for (const { start, end, newXml } of [...splices].toSorted((a, b) => b.start - a.start)) result = result.slice(0, start) + newXml + result.slice(end);
+	return patchBreaksCommentRangeBalance(xml, result) ? null : result;
+};
+/**
 * Replace each changed paragraph in `originalXml` with its re-serialized form
-* extracted from `serializedXml`, splicing end-to-start so earlier offsets stay
-* valid. Assumes safety has already been validated. Returns null if an offset
-* or extraction unexpectedly fails.
+* extracted from `serializedXml`. Assumes safety has already been validated.
+* Returns null if an offset or extraction unexpectedly fails, or if
+* {@link spliceXml} refuses the result; the caller then falls back to a full
+* repack, whose parts are all re-serialized from one model.
 */
 function spliceChangedParagraphs(originalXml, serializedXml, changedIds) {
 	const replacements = [];
@@ -255,10 +273,7 @@ function spliceChangedParagraphs(originalXml, serializedXml, changedIds) {
 			newXml
 		});
 	}
-	replacements.sort((a, b) => b.start - a.start);
-	let result = originalXml;
-	for (const { start, end, newXml } of replacements) result = result.slice(0, start) + newXml + result.slice(end);
-	return result;
+	return spliceXml(originalXml, replacements);
 }
 /**
 * Depth-count the end of the element that opens at `start` (an `<openLiteral…>`
@@ -424,11 +439,6 @@ const collectChangedNoteParaIds = (baselineXml, currentXml) => {
 	}
 	return changed;
 };
-const replaceRanges = (xml, replacements) => {
-	let result = xml;
-	for (const { start, end, newXml } of [...replacements].toSorted((a, b) => b.start - a.start)) result = result.slice(0, start) + newXml + result.slice(end);
-	return result;
-};
 /**
 * Patch an existing note part from its model serialization.
 *
@@ -440,56 +450,79 @@ const replaceRanges = (xml, replacements) => {
 * notes, and unaffected equal-shape paragraphs remain byte-exact.
 * `replacementXml` also supplies synthesized automatic note-reference marks,
 * which the parsed model intentionally omits.
+*
+* A comment can be anchored on a note's own text, so its range spans that
+* note's paragraphs and an edit inside the span moves a range half from one
+* paragraph to another. Replacing only the dirty paragraph then drops the half
+* it held and leaves the other standing, so {@link spliceXml} refuses the
+* result and the changed notes are rewritten whole instead — model content on
+* both sides of the range, with every other note still byte-exact.
 */
 function buildPatchedNotePartXml({ originalXml, baselineXml, serializedXml, replacementXml, elementName, changedParaIds }) {
 	const currentElements = collectNoteElementSyntax(serializedXml, elementName);
 	const originalElements = collectNoteElementSyntax(originalXml, elementName);
 	const replacementElements = collectNoteElementSyntax(replacementXml, elementName);
 	const replacementXmlnsDeclarations = collectXmlnsFromOpeningTag(replacementXml);
-	const ordinalReplacements = [];
+	const paragraphSplices = [];
+	/** The same edits at note granularity, should the paragraph splices be refused. */
+	const noteSplices = [];
 	const serializedParaIds = collectParaIds(serializedXml);
 	const effectiveChangedParaIds = changedParaIds ?? collectChangedNoteParaIds(baselineXml, serializedXml);
 	const unroutedChangedParaIds = new Set([...effectiveChangedParaIds].filter((paraId) => serializedParaIds.has(paraId)));
 	for (const [id, currentSyntaxEntries] of currentElements) {
 		const originalSyntaxEntries = originalElements.get(id);
 		const replacementSyntaxEntries = replacementElements.get(id);
-		if (currentSyntaxEntries.length !== 1 || originalSyntaxEntries?.length !== 1 || replacementSyntaxEntries?.length !== 1) return null;
+		if (currentSyntaxEntries.length !== 1 || originalSyntaxEntries?.length !== 1 || replacementSyntaxEntries?.length !== 1) return {
+			type: "refused",
+			reason: "unroutable-paragraph"
+		};
 		const currentSyntax = currentSyntaxEntries[0];
 		const originalSyntax = originalSyntaxEntries[0];
 		const replacementSyntax = replacementSyntaxEntries[0];
-		if (!currentSyntax || !originalSyntax || !replacementSyntax) return null;
+		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 null;
+		if (!currentNote || !originalOffsets || !replacementNote) return {
+			type: "refused",
+			reason: "unroutable-paragraph"
+		};
 		const originalNote = originalXml.slice(originalOffsets.start, originalOffsets.end);
 		const currentParagraphs = paragraphRanges(currentNote, currentSyntax.elementPrefix);
 		const originalParagraphs = paragraphRanges(originalNote, originalSyntax.elementPrefix);
 		const replacementParagraphs = paragraphRanges(replacementNote, replacementSyntax.elementPrefix);
 		const noteChangedParaIds = [...collectParaIds(currentNote).keys()].filter((paraId) => unroutedChangedParaIds.has(paraId));
 		if (noteChangedParaIds.length === 0) continue;
+		const wholeNoteSplice = {
+			start: originalOffsets.start,
+			end: originalOffsets.end,
+			newXml: rewriteWordprocessingPrefixes(replacementNote, {
+				source: replacementSyntax,
+				target: originalSyntax,
+				sourceXmlnsDeclarations: replacementXmlnsDeclarations
+			})
+		};
+		noteSplices.push(wholeNoteSplice);
 		if (currentParagraphs.length !== originalParagraphs.length || currentParagraphs.length !== replacementParagraphs.length) {
 			for (const paraId of noteChangedParaIds) unroutedChangedParaIds.delete(paraId);
-			ordinalReplacements.push({
-				start: originalOffsets.start,
-				end: originalOffsets.end,
-				newXml: rewriteWordprocessingPrefixes(replacementNote, {
-					source: replacementSyntax,
-					target: originalSyntax,
-					sourceXmlnsDeclarations: replacementXmlnsDeclarations
-				})
-			});
+			paragraphSplices.push(wholeNoteSplice);
 			continue;
 		}
 		for (let index = 0; index < currentParagraphs.length; index++) {
 			const currentRange = currentParagraphs[index];
 			const originalRange = originalParagraphs[index];
 			const replacementRange = replacementParagraphs[index];
-			if (!currentRange || !originalRange || !replacementRange) return null;
+			if (!currentRange || !originalRange || !replacementRange) return {
+				type: "refused",
+				reason: "unroutable-paragraph"
+			};
 			const routedIds = [...collectParaIds(currentNote.slice(currentRange.start, currentRange.end)).keys()].filter((paraId) => unroutedChangedParaIds.has(paraId));
 			if (routedIds.length === 0) continue;
 			for (const paraId of routedIds) unroutedChangedParaIds.delete(paraId);
-			ordinalReplacements.push({
+			paragraphSplices.push({
 				start: originalOffsets.start + originalRange.start,
 				end: originalOffsets.start + originalRange.end,
 				newXml: rewriteWordprocessingPrefixes(replacementNote.slice(replacementRange.start, replacementRange.end), {
@@ -500,8 +533,23 @@ function buildPatchedNotePartXml({ originalXml, baselineXml, serializedXml, repl
 			});
 		}
 	}
-	if (unroutedChangedParaIds.size > 0) return null;
-	return replaceRanges(originalXml, ordinalReplacements);
+	if (unroutedChangedParaIds.size > 0) return {
+		type: "refused",
+		reason: "unroutable-paragraph"
+	};
+	const patched = spliceXml(originalXml, paragraphSplices);
+	if (patched !== null) return {
+		type: "patched",
+		xml: patched
+	};
+	const wholeNotes = spliceXml(originalXml, noteSplices);
+	return wholeNotes === null ? {
+		type: "refused",
+		reason: "comment-range-balance"
+	} : {
+		type: "patched",
+		xml: wholeNotes
+	};
 }
 /**
 * The full range of the first `<openLiteral …>…</closeTag>` element, or null.
@@ -695,17 +743,19 @@ function restoreLevelNumFmts(originalDefXml, currentDefXml) {
 			...collectXmlnsFromOpeningTag(origLevel)
 		});
 		else replacement = reconstructCustomNumFmt(currentWidth);
-		const restoredLevel = curLevel.slice(0, synthetic.index) + replacement + curLevel.slice(synthetic.index + synthetic[0].length);
+		const restoredLevel = spliceXml(curLevel, [{
+			start: synthetic.index,
+			end: synthetic.index + synthetic[0].length,
+			newXml: replacement
+		}]);
+		if (restoredLevel === null) continue;
 		replacements.push({
 			start: curOffsets.start,
 			end: curOffsets.end,
 			newXml: restoredLevel
 		});
 	}
-	replacements.sort((a, b) => b.start - a.start);
-	let result = currentDefXml;
-	for (const { start, end, newXml } of replacements) result = result.slice(0, start) + newXml + result.slice(end);
-	return result;
+	return spliceXml(currentDefXml, replacements) ?? currentDefXml;
 }
 /**
 * Build a patched `word/numbering.xml` by splicing the changed `w:abstractNum` /
@@ -733,10 +783,7 @@ function buildPatchedNumberingXml(originalXml, currentXml, changed) {
 		return true;
 	};
 	if (!collect("abstractNum", changed.abstractNums) || !collect("num", changed.nums)) return null;
-	replacements.sort((a, b) => b.start - a.start);
-	let result = originalXml;
-	for (const { start, end, newXml } of replacements) result = result.slice(0, start) + newXml + result.slice(end);
-	return result;
+	return spliceXml(originalXml, replacements);
 }
 /**
 * Numbering definitions present in `currentXml` (the model's serialization)
@@ -872,4 +919,4 @@ function escapeRegExp(str) {
 	return str.replace(/[.*+?^${}()|[\]\\]/gu, "\\$&");
 }
 //#endregion
-export { appendNumberingDefs, buildParagraphOffsetIndex, buildPatchedDocumentXml, buildPatchedNotePartXml, buildPatchedNoteXml, buildPatchedNumberingXml, collectAddedNumberingDefs, collectChangedNoteParaIds, collectChangedNumberingDefs, collectParaIds, countParagraphElements, extractParagraphXml, findParagraphOffsets, isXmlNameBoundary, patchNumberingDefinitions, validatePatchSafety };
+export { appendNumberingDefs, buildParagraphOffsetIndex, buildPatchedDocumentXml, buildPatchedNotePartXml, buildPatchedNoteXml, buildPatchedNumberingXml, collectAddedNumberingDefs, collectChangedNoteParaIds, collectChangedNumberingDefs, collectParaIds, countParagraphElements, extractParagraphXml, findParagraphOffsets, isXmlNameBoundary, patchNumberingDefinitions, spliceXml, validatePatchSafety };

package/dist/docx/serializer/borderSerializer.js

@@ -34,8 +34,8 @@ function serializeBorder(input, elementName) {
 		if (themeTint) attrs.push(`w:themeTint="${escapeXmlAttribute(themeTint)}"`);
 		if (themeShade) attrs.push(`w:themeShade="${escapeXmlAttribute(themeShade)}"`);
 	}
-	if (shadow) attrs.push("w:shadow=\"true\"");
-	if (frame) attrs.push("w:frame=\"true\"");
+	if (shadow !== void 0) attrs.push(`w:shadow="${shadow ? "1" : "0"}"`);
+	if (frame !== void 0) attrs.push(`w:frame="${frame ? "1" : "0"}"`);
 	if (artRelationshipId) attrs.push(`r:id="${escapeXmlAttribute(artRelationshipId)}"`);
 	if (topLeftArtRelationshipId) attrs.push(`r:topLeft="${escapeXmlAttribute(topLeftArtRelationshipId)}"`);
 	if (topRightArtRelationshipId) attrs.push(`r:topRight="${escapeXmlAttribute(topRightArtRelationshipId)}"`);

package/dist/docx/serializer/commentSerializer.js

@@ -1,5 +1,6 @@
 import { deterministicHexId } from "../../utils/hexId.js";
 import { commentThreadParaId } from "../commentThreadKey.js";
+import { serializeWithPreservedChildren } from "../containerChildren.js";
 import { serializeParagraph } from "./paragraphSerializer.js";
 import { serializePartElement } from "./partNamespaces.js";
 import { serializeTextFormatting } from "./textFormattingSerializer.js";
@@ -30,13 +31,10 @@ function serializeComment(comment) {
 	const attrs = [`w:id="${comment.id}"`, `w:author="${escapeXmlAttribute(comment.author)}"`];
 	if (comment.initials !== void 0) attrs.push(`w:initials="${escapeXmlAttribute(comment.initials)}"`);
 	if (comment.date) attrs.push(`w:date="${escapeXmlAttribute(comment.date)}"`);
-	let xml = `<w:comment ${attrs.join(" ")}>`;
-	if (comment.content.length > 0) {
-		xml += serializeParagraphWithAnnotationRef(comment.content[0], comment.annotationReferenceFormatting);
-		for (let i = 1; i < comment.content.length; i++) xml += serializeParagraph(comment.content[i]);
-	} else xml += `<w:p>${serializeAnnotationReference(comment.annotationReferenceFormatting)}</w:p>`;
-	xml += "</w:comment>";
-	return xml;
+	const paragraphs = comment.content.map((paragraph, index) => index === 0 ? serializeParagraphWithAnnotationRef(paragraph, comment.annotationReferenceFormatting) : serializeParagraph(paragraph));
+	if (paragraphs.length === 0 && comment.preserved === void 0) paragraphs.push(`<w:p>${serializeAnnotationReference(comment.annotationReferenceFormatting)}</w:p>`);
+	const body = serializeWithPreservedChildren(paragraphs, comment.preserved);
+	return `<w:comment ${attrs.join(" ")}>${body}</w:comment>`;
 }
 const COMMENTS_BASELINE_PREFIXES = [
 	"wpc",

package/dist/docx/serializer/documentSerializer.js

@@ -1,4 +1,3 @@
-import { withBlockRangeMarkers } from "../blockRangeMarkers.js";
 import { serializeBlockSdt } from "./blockSdtSerializer.js";
 import { serializeParagraph } from "./paragraphSerializer.js";
 import { serializePartElement } from "./partNamespaces.js";
@@ -37,17 +36,15 @@ const DOCUMENT_BASELINE_PREFIXES = [
 	"wpg",
 	"wps"
 ];
-/**
-* Serialize a single block content item (paragraph, table, or block-level SDT).
-*/
+/** Serialize a single block, whether or not folio models what is in it. */
 function serializeBlockContent(block) {
-	return withBlockRangeMarkers(block, serializeBlockBody(block));
-}
-/** The block itself, without the range markers that stood around it. */
-function serializeBlockBody(block) {
-	if (block.type === "paragraph") return serializeParagraph(block);
-	if (block.type === "table") return serializeTable(block, serializeParagraph);
-	return serializeBlockSdt(block, serializeBlockContent);
+	switch (block.type) {
+		case "paragraph": return serializeParagraph(block);
+		case "table": return serializeTable(block, serializeParagraph);
+		case "blockSdt": return serializeBlockSdt(block, serializeBlockContent);
+		case "preservedBlock": return block.xml;
+		default: return block;
+	}
 }
 /**
 * Serialize document body content

package/dist/docx/serializer/headerFooterSerializer.js

@@ -1,4 +1,3 @@
-import { withBlockRangeMarkers } from "../blockRangeMarkers.js";
 import { canReplayHeaderFooterVerbatim, getHeaderFooterVerbatimXml } from "../headerFooterVerbatim.js";
 import { isEmptyParagraph } from "../paragraphParser.js";
 import { captureVerbatimXml } from "../verbatimCapture.js";
@@ -37,13 +36,13 @@ const HEADER_FOOTER_BASELINE_PREFIXES = [
 * header/footer.
 */
 function serializeBlock(block) {
-	return withBlockRangeMarkers(block, serializeBlockBody(block));
-}
-/** The block itself, without the range markers that stood around it. */
-function serializeBlockBody(block) {
-	if (block.type === "paragraph") return serializeParagraph(block);
-	if (block.type === "table") return serializeTable(block, serializeParagraph);
-	return serializeBlockSdt(block, serializeBlock);
+	switch (block.type) {
+		case "paragraph": return serializeParagraph(block);
+		case "table": return serializeTable(block, serializeParagraph);
+		case "blockSdt": return serializeBlockSdt(block, serializeBlock);
+		case "preservedBlock": return block.xml;
+		default: return block;
+	}
 }
 /**
 * Serialize a HeaderFooter object to valid OOXML XML
@@ -71,7 +70,6 @@ function serializeHeaderFooter(hf, source) {
 		});
 		contentXml = blocksXml.slice(0, watermarkInsertIndex).join("") + (mergesIntoRetainedHost ? "" : watermarkXml) + blocksXml.slice(watermarkInsertIndex).join("");
 	} else contentXml = blocksXml.join("");
-	if (!contentXml) contentXml = "<w:p><w:pPr/></w:p>";
 	return "<?xml version=\"1.0\" encoding=\"UTF-8\" standalone=\"yes\"?>\n" + serializePartElement({
 		partPath: source?.path ?? `word/${hf.type}.xml`,
 		rootName: rootTag,

package/dist/docx/serializer/noteSerializer.js

@@ -1,4 +1,3 @@
-import { withBlockRangeMarkers } from "../blockRangeMarkers.js";
 import { serializeBlockSdt } from "./blockSdtSerializer.js";
 import { serializeParagraph } from "./paragraphSerializer.js";
 import { serializePartElement } from "./partNamespaces.js";
@@ -39,13 +38,13 @@ const serializeNotePart = (elementName, body) => "<?xml version=\"1.0\" encoding
 * note body.
 */
 function serializeBlock(block) {
-	return withBlockRangeMarkers(block, serializeBlockBody(block));
-}
-/** The block itself, without the range markers that stood around it. */
-function serializeBlockBody(block) {
-	if (block.type === "paragraph") return serializeParagraph(block);
-	if (block.type === "table") return serializeTable(block, serializeParagraph);
-	return serializeBlockSdt(block, serializeBlock);
+	switch (block.type) {
+		case "paragraph": return serializeParagraph(block);
+		case "table": return serializeTable(block, serializeParagraph);
+		case "blockSdt": return serializeBlockSdt(block, serializeBlock);
+		case "preservedBlock": return block.xml;
+		default: return block;
+	}
 }
 /**
 * Serialize a single note element. Footnotes and endnotes share the same
@@ -63,6 +62,7 @@ function serializeRequiredNoteSeparators(elementName) {
 	return `<w:${elementName} w:type="separator" w:id="-1">${NOTE_SEPARATOR_BODY}<w:r><w:separator/></w:r></w:p></w:${elementName}><w:${elementName} w:type="continuationSeparator" w:id="0">${NOTE_SEPARATOR_BODY}<w:r><w:continuationSeparator/></w:r></w:p></w:${elementName}>`;
 }
 function insertNoteReferenceMark(xml, elementName) {
+	if (xml.includes(`<w:${elementName}Ref`)) return xml;
 	const paragraphOpen = /<w:p(?=[\s>])[^>]*>/u.exec(xml);
 	if (!paragraphOpen) return `${`<w:p><w:r><w:rPr><w:rStyle w:val="${elementName === "footnote" ? "FootnoteReference" : "EndnoteReference"}"/></w:rPr><w:${elementName}Ref/></w:r></w:p>`}${xml}`;
 	const paragraphStart = paragraphOpen.index + paragraphOpen[0].length;

package/dist/docx/serializer/paragraphSerializer.js

@@ -1,4 +1,6 @@
 import { modelParagraphFormattingEmission } from "../../internal/paragraphFormattingSerialization.js";
+import { serializePreservedAttributes } from "../attributeRemainder.js";
+import { fieldStateAttributes } from "../fieldState.js";
 import { getParagraphPropertySource, paragraphPropertySourceMatchesEmission } from "../paragraphPropertySource.js";
 import { reconcileRawSdtPr } from "../sdtPropertiesPatch.js";
 import { DATE_UTC_ATTRIBUTE } from "../trackedChangeInfo.js";
@@ -344,13 +346,14 @@ function hyperlinkAttributes(hyperlink) {
 /** One `w:hyperlink` child, with the caller deciding how a run is written. */
 function serializeHyperlinkChild(child, serializeChildRun) {
 	if (child.type === "run") return serializeChildRun(child);
-	return child.type === "bookmarkStart" ? serializeBookmarkStart(child) : serializeBookmarkEnd(child);
+	if (child.type === "bookmarkStart") return serializeBookmarkStart(child);
+	return child.type === "bookmarkEnd" ? serializeBookmarkEnd(child) : child.xml;
 }
 /**
 * Serialize a hyperlink (w:hyperlink)
 */
-function serializeHyperlink(hyperlink) {
-	const childrenXml = hyperlink.children.map((child) => serializeHyperlinkChild(child, serializeRun)).join("");
+function serializeHyperlink(hyperlink, disposition = "kept") {
+	const childrenXml = hyperlink.children.map((child) => serializeHyperlinkChild(child, (run) => serializeInlineRun(run, disposition))).join("");
 	return `<w:hyperlink${hyperlinkAttributes(hyperlink)}>${childrenXml}</w:hyperlink>`;
 }
 /**
@@ -367,10 +370,11 @@ function serializeBookmarkEnd(bookmark) {
 }
 /** Serialize a simple field without changing its authored OOXML field form. */
 function serializeSimpleField(field) {
-	const attrs = [`w:instr="${escapeXmlAttribute(field.instruction)}"`];
-	if (field.fldLock) attrs.push("w:fldLock=\"true\"");
-	if (field.dirty) attrs.push("w:dirty=\"true\"");
-	const contentXml = field.content.map((item) => item.type === "run" ? serializeRun(item) : serializeHyperlink(item)).join("");
+	const attrs = [`w:instr="${escapeXmlAttribute(field.instruction)}"`, ...fieldStateAttributes(field)];
+	const contentXml = field.content.map((item) => {
+		if (item.type === "run") return serializeRun(item);
+		return item.type === "hyperlink" ? serializeHyperlink(item) : item.xml;
+	}).join("");
 	return `<w:fldSimple ${attrs.join(" ")}>${contentXml}</w:fldSimple>`;
 }
 /**
@@ -382,9 +386,7 @@ function serializeComplexField(field) {
 	const parts = [];
 	const structuralFormatting = field.formatting ?? field.fieldResult[0]?.formatting;
 	const rPrXml = structuralFormatting ? serializeTextFormatting(structuralFormatting) : "";
-	const beginAttrs = ["w:fldCharType=\"begin\""];
-	if (field.fldLock) beginAttrs.push("w:fldLock=\"true\"");
-	if (field.dirty) beginAttrs.push("w:dirty=\"true\"");
+	const beginAttrs = ["w:fldCharType=\"begin\"", ...fieldStateAttributes(field)];
 	parts.push(`<w:r>${rPrXml}<w:fldChar ${beginAttrs.join(" ")}/></w:r>`);
 	if (field.fieldCode.length > 0) parts.push(...field.fieldCode.map((run) => serializeRun(run)));
 	else if (field.instruction.length > 0) {
@@ -455,20 +457,22 @@ function synthesizeInlineSdtPr(props) {
 * the properties block was re-synthesized from the modeled projection alone,
 * silently dropping every unmodeled feature (and `w:sdtEndPr`) on save.
 */
-function serializeInlineSdt(sdt) {
+function serializeInlineSdt(sdt, disposition = "kept") {
 	const props = sdt.properties;
 	const contentXml = sdt.content.map((item) => {
 		switch (item.type) {
-			case "run": return serializeRun(item);
-			case "hyperlink": return serializeHyperlink(item);
+			case "run": return serializeInlineRun(item, disposition);
+			case "hyperlink": return serializeHyperlink(item, disposition);
 			case "simpleField": return serializeSimpleField(item);
 			case "complexField": return serializeComplexField(item);
-			case "inlineSdt": return serializeInlineSdt(item);
+			case "inlineSdt": return serializeInlineSdt(item, disposition);
+			case "inlineWrapper": return serializeParagraphContent(item, disposition);
 			case "insertion": return serializeTrackedChange("ins", item);
 			case "deletion": return serializeTrackedChange("del", item);
 			case "moveFrom": return serializeTrackedChange("moveFrom", item);
 			case "moveTo": return serializeTrackedChange("moveTo", item);
 			case "mathEquation": return item.ommlXml || "";
+			case "preservedInline": return item.xml;
 			default: return item;
 		}
 	}).join("");
@@ -489,6 +493,22 @@ function serializeMoveRangeStart(tag, marker) {
 function rewriteRunTextAsDeleted(xml) {
 	return xml.replace(/<w:t\b/gu, "<w:delText").replace(/<\/w:t>/gu, "</w:delText>").replace(/<w:instrText\b/gu, "<w:delInstrText").replace(/<\/w:instrText>/gu, "</w:delInstrText>");
 }
+function serializeDeletedRun(run) {
+	const xml = serializeRun(run);
+	if (!run.content.some((c) => c.type === "drawing" || c.type === "shape")) return rewriteRunTextAsDeleted(xml);
+	if (!run.content.some((c) => c.type !== "drawing" && c.type !== "shape")) return xml;
+	return run.content.map((content) => {
+		const contentXml = serializeRun({
+			...run,
+			content: [content]
+		});
+		if (content.type === "drawing" || content.type === "shape") return contentXml;
+		return rewriteRunTextAsDeleted(contentXml);
+	}).join("");
+}
+function serializeInlineRun(run, disposition) {
+	return disposition === "removed" ? serializeDeletedRun(run) : serializeRun(run);
+}
 function trackedChangeTag(change) {
 	switch (change.type) {
 		case "insertion": return "ins";
@@ -499,29 +519,28 @@ function trackedChangeTag(change) {
 }
 function serializeTrackedChange(tag, change) {
 	const attrs = serializeTrackedChangeAttributes(change.info);
-	const serializeDeletedRun = (run) => {
-		const xml = serializeRun(run);
-		if (!run.content.some((c) => c.type === "drawing" || c.type === "shape")) return rewriteRunTextAsDeleted(xml);
-		if (!run.content.some((c) => c.type !== "drawing" && c.type !== "shape")) return xml;
-		return run.content.map((content) => {
-			const contentXml = serializeRun({
-				...run,
-				content: [content]
-			});
-			if (content.type === "drawing" || content.type === "shape") return contentXml;
-			return rewriteRunTextAsDeleted(contentXml);
-		}).join("");
-	};
-	const serializeContentRun = (run) => tag === "del" || tag === "moveFrom" ? serializeDeletedRun(run) : serializeRun(run);
+	const disposition = tag === "del" || tag === "moveFrom" ? "removed" : "kept";
+	const serializeContentRun = (run) => serializeInlineRun(run, disposition);
 	const serializeWrappedItem = (item) => {
-		if (item.type === "run") return serializeContentRun(item);
-		if (item.type === "simpleField" || item.type === "complexField") {
-			const xml = item.type === "simpleField" ? serializeSimpleField(item) : serializeComplexField(item);
-			return tag === "del" || tag === "moveFrom" ? rewriteRunTextAsDeleted(xml) : xml;
+		switch (item.type) {
+			case "run": return serializeContentRun(item);
+			case "simpleField":
+			case "complexField": {
+				const xml = item.type === "simpleField" ? serializeSimpleField(item) : serializeComplexField(item);
+				return disposition === "removed" ? rewriteRunTextAsDeleted(xml) : xml;
+			}
+			case "mathEquation": return item.ommlXml;
+			case "insertion":
+			case "deletion":
+			case "moveFrom":
+			case "moveTo": return serializeTrackedChange(trackedChangeTag(item), item);
+			case "bookmarkStart": return serializeBookmarkStart(item);
+			case "bookmarkEnd": return serializeBookmarkEnd(item);
+			case "preservedInline": return item.xml;
+			case "inlineWrapper":
+			case "inlineSdt": return serializeParagraphContent(item, disposition);
+			default: return item;
 		}
-		if (item.type === "mathEquation") return item.ommlXml;
-		if (item.type === "insertion" || item.type === "deletion" || item.type === "moveFrom" || item.type === "moveTo") return serializeTrackedChange(trackedChangeTag(item), item);
-		return item.type === "bookmarkStart" ? serializeBookmarkStart(item) : serializeBookmarkEnd(item);
 	};
 	const open = `<w:${tag} ${attrs}>`;
 	const close = `</w:${tag}>`;
@@ -554,27 +573,22 @@ function serializeCommentReferenceRun(id) {
 /**
 * Serialize a single paragraph content item.
 *
-* `explicitCommentReferenceIds` holds the comment ids that already have their
-* own `commentReference` node in this paragraph (the parsed-from-Word shape).
-* For those, the `commentRangeEnd` marker must NOT also synthesize a reference
-* run, or a save→parse round-trip doubles the `<w:commentReference>`. The
-* editor (fromProseDoc) path emits range markers with no reference node, so the
-* synthetic run is still written when the id is absent from the set.
+* A `commentRangeEnd` writes an end and nothing else. Where the comment's
+* reference run goes is authored data the model carries as its own item, and
+* `completeCommentReferences` fills it in for a model that arrived without
+* one; a guess made here from one paragraph cannot see the rest of the story.
 */
-function serializeParagraphContent(content, explicitCommentReferenceIds) {
+function serializeParagraphContent(content, disposition = "kept") {
 	switch (content.type) {
-		case "run": return serializeRun(content);
-		case "hyperlink": return serializeHyperlink(content);
+		case "run": return serializeInlineRun(content, disposition);
+		case "hyperlink": return serializeHyperlink(content, disposition);
 		case "bookmarkStart": return serializeBookmarkStart(content);
 		case "bookmarkEnd": return serializeBookmarkEnd(content);
 		case "simpleField": return serializeSimpleField(content);
 		case "complexField": return serializeComplexField(content);
-		case "inlineSdt": return serializeInlineSdt(content);
+		case "inlineSdt": return serializeInlineSdt(content, disposition);
 		case "commentRangeStart": return `<w:commentRangeStart ${markupRangeAttributes(content).join(" ")}/>`;
-		case "commentRangeEnd": {
-			const end = `<w:commentRangeEnd ${markupRangeAttributes(content).join(" ")}/>`;
-			return explicitCommentReferenceIds.has(content.id) ? end : `${end}${serializeCommentReferenceRun(content.id)}`;
-		}
+		case "commentRangeEnd": return `<w:commentRangeEnd ${markupRangeAttributes(content).join(" ")}/>`;
 		case "commentReference": return serializeCommentReferenceRun(content.id);
 		case "insertion": return serializeTrackedChange("ins", content);
 		case "deletion": return serializeTrackedChange("del", content);
@@ -584,11 +598,18 @@ function serializeParagraphContent(content, explicitCommentReferenceIds) {
 		case "moveFromRangeEnd": return `<w:moveFromRangeEnd ${markupRangeAttributes(content).join(" ")}/>`;
 		case "moveToRangeStart": return serializeMoveRangeStart("moveToRangeStart", content);
 		case "moveToRangeEnd": return `<w:moveToRangeEnd ${markupRangeAttributes(content).join(" ")}/>`;
-		case "bidiWrapper": {
-			const tag = content.control === "override" ? "bdo" : "dir";
-			return `<w:${tag}${content.direction === void 0 ? "" : ` w:val="${escapeXmlAttribute(content.direction)}"`}>${content.content.map((child) => serializeParagraphContent(child, explicitCommentReferenceIds)).join("")}</w:${tag}>`;
+		case "inlineWrapper": {
+			const inner = content.content.map((child) => serializeParagraphContent(child, disposition)).join("");
+			switch (content.kind) {
+				case "bidi": {
+					const tag = content.control === "override" ? "bdo" : "dir";
+					return `<w:${tag}${content.direction === void 0 ? "" : ` w:val="${escapeXmlAttribute(content.direction)}"`}>${inner}</w:${tag}>`;
+				}
+				default: return content.kind;
+			}
 		}
 		case "mathEquation": return content.ommlXml || "";
+		case "preservedInline": return content.xml;
 		default: return "";
 	}
 }
@@ -604,18 +625,17 @@ function serializeParagraph(paragraph) {
 	if (paragraph.paraId) attrs.push(`w14:paraId="${escapeXmlAttribute(paragraph.paraId)}"`);
 	if (paragraph.textId) attrs.push(`w14:textId="${escapeXmlAttribute(paragraph.textId)}"`);
 	if (paragraph.reviewCarrier) attrs.push(`folio:reviewCarrier="${paragraph.reviewCarrier}"`);
-	const attrsStr = attrs.length > 0 ? ` ${attrs.join(" ")}` : "";
+	const written = serializePreservedAttributes(attrs, paragraph.preservedAttributes);
+	const attrsStr = written.length > 0 ? ` ${written.join(" ")}` : "";
 	parts.push(serializeParagraphFormattingWithOptions(paragraph.formatting, {
 		propertyChanges: paragraph.propertyChanges,
 		paragraphMarkChange: paragraph.pPrMark,
 		propertySource: getParagraphPropertySource(paragraph),
 		sectionProperties: paragraph.sectionProperties
 	}));
-	const explicitCommentReferenceIds = /* @__PURE__ */ new Set();
-	for (const content of paragraph.content) if (content.type === "commentReference") explicitCommentReferenceIds.add(content.id);
 	let pendingRenderedPageBreak = paragraph.renderedPageBreakBefore === true;
 	for (const content of paragraph.content) {
-		let contentXml = serializeParagraphContent(content, explicitCommentReferenceIds);
+		let contentXml = serializeParagraphContent(content);
 		if (contentXml) {
 			if (pendingRenderedPageBreak) {
 				const next = injectRenderedPageBreakIntoFirstRun(contentXml);