@stll/folio-core 0.55.0 → 0.57.0

package/dist/docx/serializer/paragraphSerializer.js

@@ -1,14 +1,14 @@
 import { modelParagraphFormattingEmission, serializeParagraphPropertySet } from "../../internal/paragraphFormattingSerialization.js";
 import { serializePreservedAttributes } from "../attributeRemainder.js";
-import { CONTAINER_CHILDREN } from "../containerChildren.gen.js";
+import { CONTAINER_CHILDREN, TRACKED_RUN_WORDPROCESSING_CHILDREN } from "../containerChildren.gen.js";
 import { fieldStateAttributes } from "../fieldState.js";
 import { serializeEmptyMarkProperties } from "../paragraphMarkPropertyPresence.js";
-import { getParagraphPropertySource, paragraphPropertySourceMatchesEmission } from "../paragraphPropertySource.js";
+import { getParagraphPropertySource, paragraphFormattingWithAuthoredIndentation, paragraphPropertySourceMatchesAuthoredIndentation, paragraphPropertySourceMatchesEmission } from "../paragraphPropertySource.js";
 import { ReviewResolutionProvenanceError, paragraphMarkResolutionJoinAttributes, serializeParagraphMarkResolutionJoin, serializeResolutionJoins } from "../reviewResolutionProvenance.js";
 import { DATE_UTC_ATTRIBUTE } from "../trackedChangeInfo.js";
 import { toTransitionalNamespaceUri } from "../transitionalSpelling.js";
 import { captureVerbatimXml, createCapturedXmlSanitizer } from "../verbatimCapture.js";
-import { NAMESPACES, OOXML_NAMESPACE_SCOPE, cloneElement, getChildElements, getLocalName, parseXml } from "../xmlParser.js";
+import { NAMESPACES, OOXML_NAMESPACE_SCOPE, WORDPROCESSINGML_NAMESPACE_URIS, cloneElement, getChildElements, getLocalName, parseXml } from "../xmlParser.js";
 import { writeGroupTextBoxesBack } from "./groupTextBoxWriteBack.js";
 import { markupRangeAttributes, moveBookmarkAttributes, serializeBookmarkMarker } from "./markupRangeAttributes.js";
 import { serializeRun, serializeShapeTextBody } from "./runSerializer.js";
@@ -248,7 +248,7 @@ const withParagraphMarkChange = (sourceXml, mark) => {
 	}
 	return captureVerbatimXml(cloneElement(root, { elements }));
 };
-const serializeParagraphFormattingWithOptions = (formatting, { propertyChanges, paragraphMarkChange, propertySource, sectionProperties } = {}) => {
+const serializeParagraphFormattingWithOptions = (formatting, { propertyChanges, paragraphMarkChange, propertySource, sourceParagraph, sectionProperties } = {}) => {
 	const modeledFormatting = modelParagraphFormattingEmission(formatting);
 	const serializablePropertyChangeCount = propertyChanges?.length ?? 0;
 	if (serializablePropertyChangeCount > 1) panic("A paragraph cannot serialize more than one w:pPrChange", { count: serializablePropertyChangeCount });
@@ -260,13 +260,13 @@ const serializeParagraphFormattingWithOptions = (formatting, { propertyChanges,
 		sectionPropertiesXml,
 		...propertyChangesXml
 	].some((xml) => xml.includes(`${DATE_UTC_ATTRIBUTE}=`));
-	const verifiedSource = verifiedParagraphPropertySource(modeledFormatting, propertySource);
+	const verifiedSource = sourceParagraph && !paragraphPropertySourceMatchesAuthoredIndentation(sourceParagraph) ? null : verifiedParagraphPropertySource(modeledFormatting, propertySource);
 	if (verifiedSource !== null && (!composedChildrenUseDateUtc || !sourceShadowsDateUtcPrefix(verifiedSource))) {
 		const sourceWithMark = paragraphMarkChange ? withParagraphMarkChange(verifiedSource, paragraphMarkChange) : verifiedSource;
 		return withTrailingParagraphPropertyChildren(sourceWithMark, [sectionPropertiesXml, ...propertyChangesXml]);
 	}
 	return serializeParagraphPropertySet({
-		formatting,
+		formatting: sourceParagraph ? paragraphFormattingWithAuthoredIndentation(sourceParagraph) : formatting,
 		markPropertiesPrefixXml: paragraphMarkXml,
 		sectionPropertiesXml,
 		propertyChangesXml
@@ -320,15 +320,7 @@ function serializeHyperlink(hyperlink, disposition = "kept") {
 /** Serialize a simple field without changing its authored OOXML field form. */
 function serializeSimpleField(field) {
 	const attrs = [`w:instr="${escapeXmlAttribute(field.instruction)}"`, ...fieldStateAttributes(field)];
-	const contentXml = field.content.map((item) => {
-		switch (item.type) {
-			case "run": return serializeRun(item);
-			case "hyperlink": return serializeHyperlink(item);
-			case "inlineWrapper": return serializeParagraphContent(item);
-			case "preservedInline": return item.xml;
-			default: return item;
-		}
-	}).join("");
+	const contentXml = field.content.map((item) => serializeParagraphContent(item)).join("");
 	return `<w:fldSimple ${attrs.join(" ")}>${contentXml}</w:fldSimple>`;
 }
 const replayableFormFieldDataXml = createCapturedXmlSanitizer({
@@ -369,27 +361,67 @@ function serializeRemovedPreservedInline(item) {
 	if (item.foldedListNumber) throw new UnrepresentableTrackedCaptureError({ message: "A folded list-number field holds markup that cannot be written as deleted content." });
 	return item.xml;
 }
-var UnrepresentableTrackedSimpleFieldError = class extends TaggedError("UnrepresentableTrackedSimpleFieldError") {};
-/** A revision can contain run-level field characters, but not `w:fldSimple`. */
-function serializeTrackedSimpleField(field) {
-	const fieldResult = [];
+var UnrepresentableTrackedFieldChildError = class extends TaggedError("UnrepresentableTrackedFieldChildError") {};
+const TRACKED_FIELD_CAPTURE_NAMES = new Set(TRACKED_RUN_WORDPROCESSING_CHILDREN);
+const replayableFieldDataXml = createCapturedXmlSanitizer({
+	allowedLocalNames: /* @__PURE__ */ new Set(["fldData"]),
+	allowedNamespaceUris: WORDPROCESSINGML_NAMESPACE_URIS,
+	inheritedNamespaceScope: OOXML_NAMESPACE_SCOPE
+});
+/** Lower a tracked field into run-level structure before revision/link segmentation. */
+const trackedSimpleFieldContent = (field) => {
+	const formatting = field.content.find((item) => item.type === "run")?.formatting;
+	const structuralRun = (content) => ({
+		type: "run",
+		content,
+		...formatting && { formatting }
+	});
+	let fieldDataXml = null;
+	const result = [];
 	for (const item of field.content) {
-		if (item.type !== "run") throw new UnrepresentableTrackedSimpleFieldError({
-			message: `A tracked simple field with ${item.type} result content cannot be serialized as valid OOXML.`,
-			contentType: item.type
-		});
-		fieldResult.push(item);
+		if (item.type !== "preservedInline") {
+			result.push(item);
+			continue;
+		}
+		const captured = parseXml(item.xml, OOXML_NAMESPACE_SCOPE);
+		const root = captured.elements?.at(0);
+		if (captured.elements?.length !== 1 || !root || !WORDPROCESSINGML_NAMESPACE_URIS.has(root.namespaceUri ?? "")) throw new UnrepresentableTrackedFieldChildError({ message: "A tracked field capture has no representable revision-level home." });
+		const name = getLocalName(root.name);
+		if (name === "fldData") {
+			const data = replayableFieldDataXml(item.xml);
+			if (!data || fieldDataXml !== null) throw new UnrepresentableTrackedFieldChildError({ message: "A tracked field requires at most one valid fldData child." });
+			fieldDataXml = data;
+			continue;
+		}
+		if (!TRACKED_FIELD_CAPTURE_NAMES.has(name)) throw new UnrepresentableTrackedFieldChildError({ message: `A tracked field capture cannot lower ${name} into a revision wrapper.` });
+		result.push(item);
 	}
-	return serializeComplexField({
-		type: "complexField",
-		instruction: field.instruction,
-		fieldType: field.fieldType,
-		fieldCode: [],
-		fieldResult,
-		...field.fldLock !== void 0 && { fldLock: field.fldLock },
-		...field.dirty !== void 0 && { dirty: field.dirty }
-	});
-}
+	return [
+		fieldDataXml ? structuralRun([{
+			type: "preservedXml",
+			text: "",
+			xml: `<w:fldChar w:fldCharType="begin"${fieldStateAttributes(field).map((attr) => ` ${attr}`).join("")}>${fieldDataXml}</w:fldChar>`
+		}]) : structuralRun([{
+			type: "fieldChar",
+			charType: "begin",
+			...field.fldLock !== void 0 && { fldLock: field.fldLock },
+			...field.dirty !== void 0 && { dirty: field.dirty }
+		}]),
+		...field.instruction.length ? [structuralRun([{
+			type: "instrText",
+			text: field.instruction
+		}])] : [],
+		structuralRun([{
+			type: "fieldChar",
+			charType: "separate"
+		}]),
+		...result,
+		structuralRun([{
+			type: "fieldChar",
+			charType: "end"
+		}])
+	];
+};
 /**
 * Serialize an inline SDT (w:sdt).
 *
@@ -459,63 +491,143 @@ function trackedChangeTag(change) {
 	}
 }
 function serializeTrackedChange(tag, change) {
-	if (change.resolutionJoins !== void 0 && change.content.some((item) => item.type === "hyperlink")) throw new ReviewResolutionProvenanceError({
+	return emitTrackedInlineSegments(trackedChangeSegments({
+		tag,
+		change
+	}));
+}
+const emitTrackedInlineSegments = (segments) => segments.map((segment) => {
+	switch (segment.type) {
+		case "plain": return segment.xml;
+		case "hyperlink": return `<w:hyperlink${hyperlinkAttributes(segment.hyperlink)}>${segment.xml}</w:hyperlink>`;
+		default: return segment;
+	}
+}).join("");
+/** Wrap contiguous plain content once, and carry wrappers inside each lifted link. */
+const wrapTrackedInlineSegments = (segments, wrap) => {
+	if (segments.length === 0) return [{
+		type: "plain",
+		xml: wrap("")
+	}];
+	const result = [];
+	const pending = [];
+	const flush = () => {
+		if (pending.length === 0) return;
+		result.push({
+			type: "plain",
+			xml: wrap(pending.join(""))
+		});
+		pending.length = 0;
+	};
+	for (const segment of segments) switch (segment.type) {
+		case "plain":
+			pending.push(segment.xml);
+			break;
+		case "hyperlink":
+			flush();
+			result.push({
+				type: "hyperlink",
+				hyperlink: segment.hyperlink,
+				xml: wrap(segment.xml)
+			});
+			break;
+		default: return segment;
+	}
+	flush();
+	return result;
+};
+const trackedChangeSegments = ({ tag, change }) => {
+	const disposition = tag === "del" || tag === "moveFrom" ? "removed" : "kept";
+	const segments = walkTrackedInlineContent(change.content, disposition);
+	if (change.resolutionJoins !== void 0 && segments.some((segment) => segment.type === "hyperlink")) throw new ReviewResolutionProvenanceError({
 		attribute: "resolutionJoins",
 		reason: "unrepresentable",
 		message: "Tracked-resolution provenance cannot be repartitioned across serialized hyperlinks."
 	});
 	const attrs = serializeTrackedChangeAttributes(change.info) + serializeResolutionJoins(change.resolutionJoins);
-	const disposition = tag === "del" || tag === "moveFrom" ? "removed" : "kept";
-	const serializeContentRun = (run) => serializeInlineRun(run, disposition);
-	const serializeWrappedItem = (item) => {
-		switch (item.type) {
-			case "run": return serializeContentRun(item);
-			case "simpleField":
-			case "complexField": {
-				const xml = item.type === "simpleField" ? serializeTrackedSimpleField(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":
-			case "bookmarkEnd": return serializeBookmarkMarker(item);
-			case "moveFromRangeStart": return serializeMoveRangeStart("moveFromRangeStart", item);
-			case "moveFromRangeEnd": return `<w:moveFromRangeEnd ${markupRangeAttributes(item).join(" ")}/>`;
-			case "moveToRangeStart": return serializeMoveRangeStart("moveToRangeStart", item);
-			case "moveToRangeEnd": return `<w:moveToRangeEnd ${markupRangeAttributes(item).join(" ")}/>`;
-			case "preservedInline": return disposition === "removed" ? serializeRemovedPreservedInline(item) : item.xml;
-			case "inlineWrapper":
-			case "inlineSdt": return serializeParagraphContent(item, disposition);
-			default: return item;
-		}
-	};
-	const open = `<w:${tag} ${attrs}>`;
-	const close = `</w:${tag}>`;
-	const wrap = (inner) => inner.length === 0 ? "" : `${open}${inner}${close}`;
-	if (change.content.length === 0) return `${open}${close}`;
+	return wrapTrackedInlineSegments(segments, (xml) => `<w:${tag} ${attrs}>${xml}</w:${tag}>`);
+};
+var UnrepresentableNestedHyperlinkError = class extends TaggedError("UnrepresentableNestedHyperlinkError") {};
+/** One exhaustive recursive owner for all containers inside a tracked revision. */
+const walkTrackedInlineContent = (content, disposition) => {
 	const segments = [];
-	const pending = [];
-	const flushPending = () => {
-		if (pending.length > 0) {
-			segments.push(wrap(pending.join("")));
-			pending.length = 0;
+	for (const item of content) switch (item.type) {
+		case "hyperlink": {
+			const children = walkTrackedInlineContent(item.children, disposition);
+			if (children.some((child) => child.type === "hyperlink")) throw new UnrepresentableNestedHyperlinkError({ message: "A tracked hyperlink cannot contain another hyperlink." });
+			segments.push({
+				type: "hyperlink",
+				hyperlink: item,
+				xml: emitTrackedInlineSegments(children)
+			});
+			break;
 		}
-	};
-	for (const item of change.content) {
-		if (item.type === "hyperlink") {
-			flushPending();
-			const childrenXml = item.children.map((child) => serializeHyperlinkChild(child, disposition)).join("");
-			segments.push(`<w:hyperlink${hyperlinkAttributes(item)}>${open}${childrenXml}${close}</w:hyperlink>`);
-			continue;
+		case "simpleField":
+			segments.push(...walkTrackedInlineContent(trackedSimpleFieldContent(item), disposition));
+			break;
+		case "insertion":
+		case "deletion":
+		case "moveFrom":
+		case "moveTo":
+			segments.push(...trackedChangeSegments({
+				tag: trackedChangeTag(item),
+				change: item
+			}));
+			break;
+		case "inlineWrapper":
+			segments.push(...wrapTrackedInlineSegments(walkTrackedInlineContent(item.content, disposition), (xml) => serializeInlineWrapperMarkup(item, xml)));
+			break;
+		case "inlineSdt":
+			segments.push({
+				type: "plain",
+				xml: serializeSdtWrapper(item.properties, emitTrackedInlineSegments(walkTrackedInlineContent(item.content, disposition)))
+			});
+			break;
+		case "complexField": {
+			const xml = serializeComplexField(item);
+			segments.push({
+				type: "plain",
+				xml: disposition === "removed" ? rewriteRunTextAsDeleted(xml) : xml
+			});
+			break;
+		}
+		case "preservedInline": {
+			const pending = getChildElements(parseXml(item.xml, OOXML_NAMESPACE_SCOPE));
+			while (pending.length > 0) {
+				const captured = pending.pop();
+				if (!captured) continue;
+				const wordprocessing = WORDPROCESSINGML_NAMESPACE_URIS.has(captured.namespaceUri ?? "");
+				const name = getLocalName(captured.name);
+				if (wordprocessing && (name === "p" || name === "sdt")) continue;
+				if (wordprocessing && name === "hyperlink") throw new UnrepresentableTrackedCaptureError({ message: "A tracked capture containing a hyperlink requires typed content for lifting." });
+				pending.push(...getChildElements(captured));
+			}
+			segments.push({
+				type: "plain",
+				xml: disposition === "removed" ? serializeRemovedPreservedInline(item) : item.xml
+			});
+			break;
 		}
-		pending.push(serializeWrappedItem(item));
+		case "run":
+		case "mathEquation":
+		case "bookmarkStart":
+		case "bookmarkEnd":
+		case "moveFromRangeStart":
+		case "moveFromRangeEnd":
+		case "moveToRangeStart":
+		case "moveToRangeEnd":
+		case "commentRangeStart":
+		case "commentRangeEnd":
+		case "commentReference":
+			segments.push({
+				type: "plain",
+				xml: serializeParagraphContent(item, disposition)
+			});
+			break;
+		default: return item;
 	}
-	flushPending();
-	return segments.join("");
-}
+	return segments;
+};
 /** The properties element each tagged wrapper declares ahead of its content. */
 const TAGGED_WRAPPER_PROPERTIES = {
 	smartTag: "smartTagPr",
@@ -552,6 +664,17 @@ function serializeTaggedWrapper(kind, wrapper, inner) {
 function serializeCommentReferenceRun(id) {
 	return `<w:r><w:rPr><w:rStyle w:val="CommentReference"/></w:rPr><w:commentReference w:id="${id}"/></w:r>`;
 }
+function serializeInlineWrapperMarkup(content, inner) {
+	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}>`;
+		}
+		case "smartTag": return serializeTaggedWrapper("smartTag", content, inner);
+		case "customXml": return serializeTaggedWrapper("customXml", content, inner);
+		default: return content;
+	}
+}
 /**
 * Serialize a single paragraph content item.
 *
@@ -580,18 +703,7 @@ function serializeParagraphContent(content, disposition = "kept") {
 		case "moveFromRangeEnd": return `<w:moveFromRangeEnd ${markupRangeAttributes(content).join(" ")}/>`;
 		case "moveToRangeStart": return serializeMoveRangeStart("moveToRangeStart", content);
 		case "moveToRangeEnd": return `<w:moveToRangeEnd ${markupRangeAttributes(content).join(" ")}/>`;
-		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}>`;
-				}
-				case "smartTag": return serializeTaggedWrapper("smartTag", content, inner);
-				case "customXml": return serializeTaggedWrapper("customXml", content, inner);
-				default: return content;
-			}
-		}
+		case "inlineWrapper": return serializeInlineWrapperMarkup(content, content.content.map((child) => serializeParagraphContent(child, disposition)).join(""));
 		case "mathEquation": return content.ommlXml || "";
 		case "preservedInline": return content.xml;
 		default: return "";
@@ -617,6 +729,7 @@ function serializeParagraph(paragraph) {
 		propertyChanges: paragraph.propertyChanges,
 		paragraphMarkChange: paragraph.pPrMark,
 		propertySource: getParagraphPropertySource(paragraph),
+		sourceParagraph: paragraph,
 		sectionProperties: paragraph.sectionProperties
 	}));
 	let pendingRenderedPageBreak = paragraph.renderedPageBreakBefore === true;

package/dist/docx/server/applyDocxXmlPatchProposal.js

@@ -3,6 +3,7 @@ import { FOLIO_DOCX_XML_PATCH_PROPOSAL_PROFILE, InvalidFolioDocxXmlPatchProposal
 import { FOLIO_DOCX_CONFORMANCE_PROFILE, validateDocxConformance } from "./validateDocxConformance.js";
 import { TaggedError, panic } from "better-result";
 import { createHash } from "node:crypto";
+import { writeZipPart } from "@stll/docx-core/zip";
 import JSZip from "jszip";
 //#region src/docx/server/applyDocxXmlPatchProposal.ts
 const FOLIO_DOCX_XML_PATCH_APPLICATION_VERSION = 1;
@@ -92,15 +93,19 @@ const applyReplacements = async ({ bytes, proposal }) => {
 			message: "An evaluated package part was unavailable during replacement.",
 			stage: "replace"
 		});
-		zip.file(replacement.path, new TextEncoder().encode(replacement.replacementXml), {
-			binary: true,
-			date: current.date,
-			comment: current.comment,
-			createFolders: false,
-			unixPermissions: current.unixPermissions,
-			dosPermissions: current.dosPermissions,
-			compression: "DEFLATE",
-			compressionOptions: { level: 6 }
+		writeZipPart({
+			zip,
+			path: replacement.path,
+			data: new TextEncoder().encode(replacement.replacementXml),
+			options: {
+				binary: true,
+				date: current.date,
+				comment: current.comment,
+				unixPermissions: current.unixPermissions,
+				dosPermissions: current.dosPermissions,
+				compression: "DEFLATE",
+				compressionOptions: { level: 6 }
+			}
 		});
 	}
 	try {

package/dist/docx/server/materializeYjsDocx.js

@@ -1,6 +1,6 @@
 import { fromProseDoc } from "../../prosemirror/conversion/fromProseDoc.js";
 import { schema } from "../../prosemirror/schema/index.js";
-import { applyAttrSchemaMigrations, readYjsAttrSchemaVersion, readYjsParagraphSourceContract, withParagraphSourceContract } from "../../prosemirror/yjsDocumentMetadata.js";
+import { FolioYjsNoteReferenceSchemaError, applyAttrSchemaMigrations, readYjsAttrSchemaVersion, readYjsParagraphSourceContract, withParagraphSourceContract } from "../../prosemirror/yjsDocumentMetadata.js";
 import { ParagraphPropertySourceValidationError } from "../paragraphPropertySource.js";
 import { parseDocx } from "../parser.js";
 import { repackDocx } from "../rezip.js";
@@ -55,11 +55,19 @@ const readProseMirrorDocument = (yjsUpdate) => {
 			});
 			return withParagraphSourceContract(initProseMirrorDoc(fragment, schema).doc, contract);
 		},
-		catch: (cause) => cause instanceof FolioYjsDocxMaterializationError ? cause : new FolioYjsDocxMaterializationError({
-			code: "invalid_update",
-			message: "Yjs update is not a valid Folio collaboration snapshot.",
-			cause
-		})
+		catch: (cause) => {
+			if (cause instanceof FolioYjsDocxMaterializationError) return cause;
+			if (cause instanceof FolioYjsNoteReferenceSchemaError) return new FolioYjsDocxMaterializationError({
+				code: "stale_attr_schema",
+				message: cause.message,
+				cause
+			});
+			return new FolioYjsDocxMaterializationError({
+				code: "invalid_update",
+				message: "Yjs update is not a valid Folio collaboration snapshot.",
+				cause
+			});
+		}
 	});
 	ydoc.destroy();
 	if (parsed.isOk()) return parsed.value;

package/dist/docx/server/migrateYjsAttrSchema.js

@@ -1,4 +1,4 @@
-import { applyAttrSchemaMigrations, readYjsAttrSchemaVersion } from "../../prosemirror/yjsDocumentMetadata.js";
+import { FolioYjsNoteReferenceSchemaError, applyAttrSchemaMigrations, readYjsAttrSchemaVersion } from "../../prosemirror/yjsDocumentMetadata.js";
 import { FOLIO_YJS_PROSEMIRROR_FRAGMENT_NAME } from "./materializeYjsDocx.js";
 import { Result, TaggedError } from "better-result";
 import * as Y from "yjs";
@@ -72,22 +72,34 @@ const migrateFolioYjsSnapshot = (update) => {
 		}));
 	}
 	const fromVersion = read.value;
-	if (fromVersion === 11) {
+	const migratedAttrs = Result.try({
+		try: () => applyAttrSchemaMigrations(ydoc, ydoc.getXmlFragment(FOLIO_YJS_PROSEMIRROR_FRAGMENT_NAME), fromVersion),
+		catch: (cause) => new FolioYjsSnapshotMigrationError({
+			cause,
+			code: "unsupported_version",
+			message: cause instanceof FolioYjsNoteReferenceSchemaError ? cause.message : "Cannot migrate the collaboration attribute schema."
+		})
+	});
+	if (migratedAttrs.isErr()) {
+		ydoc.destroy();
+		return Result.err(migratedAttrs.error);
+	}
+	if (fromVersion === 12) {
 		ydoc.destroy();
 		return Result.ok({
 			fromVersion,
 			paragraphsRewritten: 0,
-			toVersion: 11,
+			toVersion: 12,
 			update
 		});
 	}
-	const paragraphsRewritten = applyAttrSchemaMigrations(ydoc, ydoc.getXmlFragment(FOLIO_YJS_PROSEMIRROR_FRAGMENT_NAME), fromVersion);
+	const paragraphsRewritten = migratedAttrs.value;
 	const migrated = Y.encodeStateAsUpdate(ydoc);
 	ydoc.destroy();
 	return Result.ok({
 		fromVersion,
 		paragraphsRewritten,
-		toVersion: 11,
+		toVersion: 12,
 		update: migrated
 	});
 };

package/dist/docx/storyBlockReplay.d.ts

@@ -1,11 +1,31 @@
 import { document_d_exports } from "../types/document.js";
+import { XmlElement } from "./xmlParser.js";
 //#region src/docx/storyBlockReplay.d.ts
+type MaterializeReplayFragmentOptions = {
+  xml: string;
+  element: XmlElement;
+  sourceNamespace: string;
+  generatedRoot?: XmlElement;
+};
+/** Bind a replay fragment once, retaining existing local declarations and compatibility tokens. */
+declare const materializeReplayFragment: ({ xml, element, sourceNamespace, generatedRoot }: MaterializeReplayFragmentOptions) => string | null;
 type StoryBlockReplayOptions = {
   sourceXml: string;
   baselineContent: readonly document_d_exports.BlockContent[];
   currentContent: readonly document_d_exports.BlockContent[];
   serializedXml: string;
+  ignoredChild?: string;
 };
 declare const buildStoryBlockReplay: (options: StoryBlockReplayOptions) => string | null;
+/** Validate source/model correspondence before replaying an unchanged complete part. */
+declare const canReplayDocumentSource: (sourceXml: string, baseline: document_d_exports.DocumentBody) => boolean;
+type DocumentBlockReplayOptions = {
+  sourceXml: string;
+  serializedXml: string;
+  baseline: document_d_exports.DocumentBody;
+  current: document_d_exports.DocumentBody;
+};
+/** Replay body blocks and modeled document metadata inside the authored part shell. */
+declare const buildDocumentBlockReplay: ({ sourceXml, serializedXml, baseline, current }: DocumentBlockReplayOptions) => string | null;
 //#endregion
-export { buildStoryBlockReplay };
+export { buildDocumentBlockReplay, buildStoryBlockReplay, canReplayDocumentSource, materializeReplayFragment };