@stll/folio-core 0.56.0 → 0.57.0

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 { planCommentParts, serializeComments, serializeCommentsExtended } from "./serializer/commentSerializer.js";
+import { 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";
@@ -201,6 +201,7 @@ async function attemptSelectiveSave(doc, originalBuffer, options) {
 	if (!validateFolioDocumentModel(doc).valid) return null;
 	const comments = doc.package.document.comments ?? [];
 	const hasComments = comments.length > 0;
+	const ownsCommentsPart = hasOwnedCommentsPart(doc);
 	const commentPlan = planCommentParts(comments);
 	try {
 		const zip = await (await import("jszip")).default.loadAsync(originalBuffer);
@@ -259,25 +260,26 @@ async function attemptSelectiveSave(doc, originalBuffer, options) {
 				updates.set("word/document.xml", patchedDocXml);
 			}
 		}
-		const sourceCommentsFile = zip.file("word/comments.xml");
-		if (hasComments || sourceCommentsFile) {
+		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 commentsXml = serializeComments(commentPlan, sourceCommentsXml === void 0 ? void 0 : readRootNamespaceBindings(sourceCommentsXml));
-			if (commentsXml !== sourceCommentsXml) updates.set("word/comments.xml", commentsXml);
+			if (commentsXml !== sourceCommentsXml) updates.set(commentsPartPath, commentsXml);
 		}
-		if (hasComments) {
+		if (hasComments || ownsCommentsPart) {
 			const ctFile = zip.file("[Content_Types].xml");
 			if (ctFile) {
 				const ctXml = await ctFile.async("text");
-				if (!ctXml.includes("/word/comments.xml")) updates.set("[Content_Types].xml", ctXml.replace("</Types>", `<Override PartName="/word/comments.xml" ContentType="${COMMENTS_CONTENT_TYPE}"/></Types>`));
+				if (!ctXml.toLowerCase().includes("/word/comments.xml")) updates.set("[Content_Types].xml", ctXml.replace("</Types>", `<Override PartName="/${commentsPartPath}" ContentType="${COMMENTS_CONTENT_TYPE}"/></Types>`));
 			}
 			const relsPath = "word/_rels/document.xml.rels";
 			const relsFile = zip.file(relsPath);
 			if (relsFile) {
 				const relsXml = await relsFile.async("text");
-				if (!relsXml.includes("comments.xml")) {
+				if (!relsXml.toLowerCase().includes("comments.xml")) {
 					const maxId = findMaxRId(relsXml);
-					updates.set(relsPath, relsXml.replace("</Relationships>", `<Relationship Id="rId${maxId + 1}" Type="${RELATIONSHIP_TYPES.comments}" Target="comments.xml"/></Relationships>`));
+					updates.set(relsPath, relsXml.replace("</Relationships>", `<Relationship Id="rId${maxId + 1}" Type="${RELATIONSHIP_TYPES.comments}" Target="${commentsPartPath.slice(5)}"/></Relationships>`));
 				}
 			}
 		}

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

@@ -1,5 +1,8 @@
+import { document_d_exports } from "../../types/document.js";
 import { Comment } from "../../types/content.js";
 //#region src/docx/serializer/commentSerializer.d.ts
+/** An owned empty part survives deletion of its final thread. */
+declare const hasOwnedCommentsPart: (document: document_d_exports.Document) => boolean;
 /**
  * What every comment part is written from: one ordered list of comment ids, and
  * the facts each id carries.
@@ -52,4 +55,4 @@ declare function serializeComments({ order, byId }: CommentPartPlan, sourceBindi
  */
 declare function serializeCommentsExtended(plan: CommentPartPlan): string | null;
 //#endregion
-export { CommentPartPlan, planCommentParts, serializeComments, serializeCommentsExtended };
+export { CommentPartPlan, hasOwnedCommentsPart, planCommentParts, serializeComments, serializeCommentsExtended };

package/dist/docx/serializer/commentSerializer.js

@@ -5,12 +5,15 @@ import { serializeParagraph } from "./paragraphSerializer.js";
 import { serializePartElement } from "./partNamespaces.js";
 import { serializeTextFormatting } from "./textFormattingSerializer.js";
 import { escapeXmlAttribute } from "@stll/docx-core";
+import { COMMENT_PART_RELATIONSHIPS } from "@stll/docx-core/model";
 //#region src/docx/serializer/commentSerializer.ts
 /**
 * Comment Serializer
 *
 * Serializes Comment[] to OOXML comments.xml format.
 */
+/** 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>";
 const PARAGRAPH_PROPERTIES_END = "</w:pPr>";
 const serializeAnnotationReference = (formatting) => {
@@ -169,7 +172,7 @@ function buildCommentExtendedEntries({ order, byId, threadParaIdById, threadedId
 		entries.push({
 			paraId,
 			...parentParaId !== void 0 ? { paraIdParent: parentParaId } : {},
-			done: done ?? false
+			...done === void 0 ? {} : { done }
 		});
 	}
 	return entries.length > 0 ? entries : null;
@@ -185,7 +188,8 @@ function serializeCommentsExtended(plan) {
 	if (!entries) return null;
 	const body = entries.map((entry) => {
 		const parentAttr = entry.paraIdParent !== void 0 ? ` w15:paraIdParent="${escapeXmlAttribute(entry.paraIdParent)}"` : "";
-		return `<w15:commentEx w15:paraId="${escapeXmlAttribute(entry.paraId)}"${parentAttr} w15:done="${entry.done ? "1" : "0"}"/>`;
+		const doneAttr = entry.done === void 0 ? "" : ` w15:done="${entry.done ? "1" : "0"}"`;
+		return `<w15:commentEx w15:paraId="${escapeXmlAttribute(entry.paraId)}"${parentAttr}${doneAttr}/>`;
 	}).join("");
 	return XML_DECLARATION + serializePartElement({
 		partPath: "word/commentsExtended.xml",
@@ -196,4 +200,4 @@ function serializeCommentsExtended(plan) {
 	});
 }
 //#endregion
-export { planCommentParts, serializeComments, serializeCommentsExtended };
+export { hasOwnedCommentsPart, planCommentParts, serializeComments, serializeCommentsExtended };

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/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/i18n/messages/ar.gen.js

@@ -337,6 +337,10 @@ const messages = { "folio": {
 	"editor": {
 		"editing": "تحرير",
 		"editingDescription": "تحرير المستند مباشرةً",
+		"outlineDepthAll": "كل المستويات",
+		"outlineDepthLabel": "إظهار العناوين",
+		"outlineDepthThree": "المستويات 1–3",
+		"outlineDepthTwo": "المستويان 1–2",
 		"outlineTitle": "المخطط",
 		"showDocumentOutline": "مخطط المستند",
 		"suggesting": "تعقب التغييرات",