@stll/folio-core 0.54.2 → 0.56.0

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/settingsHeaderFooterUpdate.d.ts

@@ -0,0 +1,5 @@
+//#region src/docx/settingsHeaderFooterUpdate.d.ts
+/** Null means the source is malformed or outside the supported namespace profiles. */
+declare const updateEvenAndOddHeaders: (xml: string, enabled: boolean | undefined) => string | null;
+//#endregion
+export { updateEvenAndOddHeaders };

package/dist/docx/settingsHeaderFooterUpdate.js

@@ -0,0 +1,90 @@
+import { spliceXml } from "./selectiveXmlPatch.js";
+import { WORDPROCESSINGML_NAMESPACE_URIS, getChildElements, getLocalName, getNamespaceUri, parseXmlDocument } from "./xmlParser.js";
+import { panic } from "better-result";
+import { SETTINGS_CHILDREN } from "@stll/docx-core/schema";
+//#region src/docx/settingsHeaderFooterUpdate.ts
+/** Preserve producer settings while updating the document-wide header/footer switch. */
+const XML_TOKEN = /<!--[\s\S]*?-->|<!\[CDATA\[[\s\S]*?\]\]>|<\?[\s\S]*?\?>|<(?:"[^"]*"|'[^']*'|[^'">])*>/gu;
+const SETTINGS_CHILD_ORDINALS = new Map(SETTINGS_CHILDREN.map((name, index) => [name, index]));
+const EVEN_AND_ODD_HEADERS_ORDER = SETTINGS_CHILD_ORDINALS.get("evenAndOddHeaders");
+/** Null means the source is malformed or outside the supported namespace profiles. */
+const updateEvenAndOddHeaders = (xml, enabled) => {
+	const root = parseXmlDocument(xml);
+	if (!root || getLocalName(root.name) !== "settings" || !WORDPROCESSINGML_NAMESPACE_URIS.has(getNamespaceUri(root) ?? "")) return null;
+	const children = getChildElements(root);
+	const spans = [];
+	const stack = [];
+	let childIndex = 0;
+	let childStart = -1;
+	let rootEnd = -1;
+	let rootOpenEnd = -1;
+	let selfClosingRootStart = -1;
+	let firstFollowingChildStart = -1;
+	if (EVEN_AND_ODD_HEADERS_ORDER === void 0) panic("Generated CT_Settings schema does not define evenAndOddHeaders");
+	for (const token of xml.matchAll(XML_TOKEN)) {
+		const tag = token[0];
+		if (tag.startsWith("<!") || tag.startsWith("<?")) continue;
+		const closing = tag.startsWith("</");
+		const name = tag.slice(closing ? 2 : 1).split(/[\s/>]/u).at(0);
+		if (!name) return null;
+		if (closing) {
+			if (stack.pop() !== name) return null;
+			if (stack.length === 1) {
+				const child = children[childIndex++];
+				if (!child || childStart < 0) return null;
+				if (getLocalName(child.name) === "evenAndOddHeaders" && WORDPROCESSINGML_NAMESPACE_URIS.has(getNamespaceUri(child) ?? "")) spans.push({
+					start: childStart,
+					end: token.index + tag.length,
+					newXml: ""
+				});
+				childStart = -1;
+			}
+			if (stack.length === 0) rootEnd = token.index;
+			continue;
+		}
+		if (stack.length === 0) {
+			rootOpenEnd = token.index + tag.length;
+			if (tag.endsWith("/>")) selfClosingRootStart = token.index;
+		}
+		if (stack.length === 1) {
+			const child = children[childIndex];
+			if (child?.name !== name) return null;
+			if (firstFollowingChildStart < 0 && WORDPROCESSINGML_NAMESPACE_URIS.has(getNamespaceUri(child) ?? "") && (SETTINGS_CHILD_ORDINALS.get(getLocalName(child.name)) ?? -1) > EVEN_AND_ODD_HEADERS_ORDER) firstFollowingChildStart = token.index;
+			childStart = token.index;
+			if (tag.endsWith("/>")) {
+				childIndex += 1;
+				if (getLocalName(child.name) === "evenAndOddHeaders" && WORDPROCESSINGML_NAMESPACE_URIS.has(getNamespaceUri(child) ?? "")) spans.push({
+					start: token.index,
+					end: token.index + tag.length,
+					newXml: ""
+				});
+				childStart = -1;
+			}
+		}
+		if (!tag.endsWith("/>")) stack.push(name);
+	}
+	if (stack.length !== 0 || childIndex !== children.length) return null;
+	const flag = enabled === void 0 ? "" : `<folioW:evenAndOddHeaders xmlns:folioW="${getNamespaceUri(root)}"${enabled ? "" : " folioW:val=\"0\""}/>`;
+	if (selfClosingRootStart >= 0) {
+		if (!flag) return xml;
+		return spliceXml(xml, [{
+			start: rootOpenEnd - 2,
+			end: rootOpenEnd,
+			newXml: `>${flag}</${root.name}>`
+		}]);
+	}
+	if (rootEnd < 0) return null;
+	const existingFlag = spans.at(0);
+	if (flag && existingFlag) existingFlag.newXml = flag;
+	else if (flag) {
+		const insertAt = firstFollowingChildStart >= 0 ? firstFollowingChildStart : rootEnd;
+		spans.push({
+			start: insertAt,
+			end: insertAt,
+			newXml: flag
+		});
+	}
+	return spliceXml(xml, spans);
+};
+//#endregion
+export { updateEvenAndOddHeaders };

package/dist/docx/settingsParser.d.ts

@@ -1,7 +1,6 @@
 import { document_d_exports } from "../types/document.js";
+import { DEFAULT_TAB_STOP_TWIPS } from "@stll/docx-core/model";
 //#region src/docx/settingsParser.d.ts
-/** OOXML default per §17.6.13 when `w:defaultTabStop` is absent. */
-declare const DEFAULT_TAB_STOP_TWIPS = 720;
 declare function parseSettings(xml: string | null): document_d_exports.DocumentSettings;
 //#endregion
 export { DEFAULT_TAB_STOP_TWIPS, parseSettings };

package/dist/docx/settingsParser.js

@@ -1,8 +1,7 @@
 import { parseEndnoteProperties } from "./notePropertiesParser.js";
 import { WORDPROCESSINGML_NAMESPACE_URIS, findChild, findChildByNamespaceUri, findChildren, getAttribute, parseBooleanElement, parseXmlDocument } from "./xmlParser.js";
+import { DEFAULT_TAB_STOP_TWIPS, DEFAULT_TAB_STOP_TWIPS as DEFAULT_TAB_STOP_TWIPS$1 } from "@stll/docx-core/model";
 //#region src/docx/settingsParser.ts
-/** OOXML default per §17.6.13 when `w:defaultTabStop` is absent. */
-const DEFAULT_TAB_STOP_TWIPS = 720;
 /**
 * Sanity cap on `w:defaultTabStop`. Word's maximum margin is ~22 inches
 * (31 680 twips); anything past that is corruption or a hostile input and
@@ -111,13 +110,13 @@ function parseKinsokuOverride(root, name) {
 	};
 }
 function parseDefaultTabStop(root) {
-	if (!root) return 720;
+	if (!root) return DEFAULT_TAB_STOP_TWIPS$1;
 	const el = findChild(root, "w", "defaultTabStop");
-	if (!el) return 720;
+	if (!el) return DEFAULT_TAB_STOP_TWIPS$1;
 	const raw = getAttribute(el, "w", "val");
-	if (raw === null) return 720;
+	if (raw === null) return DEFAULT_TAB_STOP_TWIPS$1;
 	const parsed = Number.parseInt(raw, 10);
-	if (!Number.isFinite(parsed) || parsed < MIN_TAB_STOP_TWIPS || parsed > MAX_TAB_STOP_TWIPS) return 720;
+	if (!Number.isFinite(parsed) || parsed < MIN_TAB_STOP_TWIPS || parsed > MAX_TAB_STOP_TWIPS) return DEFAULT_TAB_STOP_TWIPS$1;
 	return parsed;
 }
 //#endregion

package/dist/docx/storyBlockReplay.d.ts

@@ -0,0 +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 { buildDocumentBlockReplay, buildStoryBlockReplay, canReplayDocumentSource, materializeReplayFragment };

package/dist/docx/storyBlockReplay.js

@@ -0,0 +1,471 @@
+import { canonicalJson } from "../utils/canonicalJson.js";
+import { spliceXml } from "./selectiveXmlPatch.js";
+import { getXmlSourceRange, parseStreamingXmlWithSourceRanges } from "./streamingXmlParser.js";
+import { TRANSITIONAL_NAMESPACE_BY_STRICT_URI } from "./strictValueEncodings.gen.js";
+import { captureSourceProfileXml, isSafeCapturedXmlDocument } from "./verbatimCapture.js";
+import { WORDPROCESSINGML_NAMESPACE_URIS, getAttributeByNamespaceUri, getChildElements, getLocalName, getNamespaceUri } from "./xmlParser.js";
+import { escapeXmlAttribute } from "@stll/docx-core";
+import { DOCX_CONFORMANCE_CLASSES } from "@stll/docx-core/model";
+//#region src/docx/storyBlockReplay.ts
+const BLOCK_ELEMENT_NAMES = {
+	paragraph: "p",
+	table: "tbl",
+	blockSdt: "sdt",
+	blockCustomXml: "customXml",
+	preservedBlock: null,
+	bookmarkStart: "bookmarkStart",
+	bookmarkEnd: "bookmarkEnd"
+};
+const modelMatchesElement = ({ value, element, mode }) => {
+	if (value === void 0) return false;
+	if (mode === "source" && getLocalName(element.name) === "AlternateContent" && getNamespaceUri(element) === "http://schemas.openxmlformats.org/markup-compatibility/2006" && (value.type === "paragraph" || value.type === "table")) return true;
+	const name = BLOCK_ELEMENT_NAMES[value.type];
+	if (name !== null) return getLocalName(element.name) === name && WORDPROCESSINGML_NAMESPACE_URIS.has(getNamespaceUri(element) ?? "");
+	if (value.type !== "preservedBlock") return false;
+	const parsed = parseStreamingXmlWithSourceRanges(value.xml, element.namespaceScope);
+	if (parsed.status !== "parsed") return false;
+	const roots = getChildElements(parsed.value);
+	const root = roots.at(0);
+	const normalize = (uri) => uri === void 0 ? void 0 : TRANSITIONAL_NAMESPACE_BY_STRICT_URI.get(uri) ?? uri;
+	return roots.length === 1 && root !== void 0 && getLocalName(root.name) === getLocalName(element.name) && normalize(getNamespaceUri(root)) === normalize(getNamespaceUri(element));
+};
+const XML_TOKEN = /<!--[\s\S]*?-->|<!\[CDATA\[[\s\S]*?\]\]>|<\?[\s\S]*?\?>|<(?:"[^"]*"|'[^']*'|[^'">])*>/gu;
+const XML_ATTRIBUTE = /([^\s=<>/]+)(\s*=\s*)(["'])(.*?)\3/gsu;
+const readStory = (xml, scope, ignoredChild) => {
+	const parsed = parseStreamingXmlWithSourceRanges(xml, scope);
+	if (parsed.status !== "parsed") return null;
+	const roots = getChildElements(parsed.value);
+	const root = roots.at(0);
+	if (roots.length !== 1 || !root || !WORDPROCESSINGML_NAMESPACE_URIS.has(getNamespaceUri(root) ?? "")) return null;
+	if (root.elements?.some((child) => child.type === "text" && String(child.text ?? "").trim() !== "")) return null;
+	const children = getChildElements(root);
+	const blocks = [];
+	for (const element of children) {
+		if (getLocalName(element.name) === ignoredChild && WORDPROCESSINGML_NAMESPACE_URIS.has(getNamespaceUri(element) ?? "")) continue;
+		const range = getXmlSourceRange(element);
+		if (!range) return null;
+		blocks.push({
+			element,
+			...range
+		});
+	}
+	const range = getXmlSourceRange(root);
+	return range ? {
+		root,
+		blocks,
+		range
+	} : null;
+};
+const effectiveBindings = (element) => {
+	const bindings = /* @__PURE__ */ new Map();
+	let scope = element.namespaceScope;
+	while (scope) {
+		for (const [prefix, uri] of scope.bindings) if (!bindings.has(prefix)) bindings.set(prefix, uri);
+		scope = scope.parent;
+	}
+	return bindings;
+};
+/** Bind a replay fragment once, retaining existing local declarations and compatibility tokens. */
+const materializeReplayFragment = ({ xml, element, sourceNamespace, generatedRoot }) => {
+	const strict = TRANSITIONAL_NAMESPACE_BY_STRICT_URI.has(sourceNamespace);
+	const first = [...xml.matchAll(XML_TOKEN)].at(0);
+	if (!first || first.index !== 0 || first[0].startsWith("<!") || first[0].startsWith("<?")) return null;
+	const opening = first[0];
+	const additions = [];
+	const bindings = effectiveBindings(element);
+	const markupCompatibilityUri = "http://schemas.openxmlformats.org/markup-compatibility/2006";
+	const ignorableUris = /* @__PURE__ */ new Set([markupCompatibilityUri]);
+	const inheritedIgnorable = generatedRoot === void 0 ? null : getAttributeByNamespaceUri(generatedRoot, ignorableUris, "Ignorable");
+	const localIgnorable = getAttributeByNamespaceUri(element, ignorableUris, "Ignorable");
+	const ignorable = [...new Set(`${inheritedIgnorable ?? ""} ${localIgnorable ?? ""}`.trim().split(/\s+/u).filter(Boolean))];
+	let ignorableAttribute;
+	if (ignorable.length > 0) {
+		const localAttribute = Object.keys(element.attributes ?? {}).find((name) => {
+			const colon = name.indexOf(":");
+			return colon > 0 && getLocalName(name) === "Ignorable" && bindings.get(name.slice(0, colon)) === markupCompatibilityUri;
+		});
+		const compatibilityPrefix = localAttribute?.slice(0, localAttribute.indexOf(":")) ?? [...bindings].find(([prefix, uri]) => prefix !== "" && uri === markupCompatibilityUri)?.[0];
+		if (compatibilityPrefix === void 0 || ignorable.some((prefix) => !bindings.has(prefix))) return null;
+		ignorableAttribute = `${compatibilityPrefix}:Ignorable`;
+		if (localIgnorable === null) additions.push(` ${ignorableAttribute}="${escapeXmlAttribute(ignorable.join(" "))}"`);
+	}
+	for (const [prefix, uri] of bindings) {
+		const name = prefix === "" ? "xmlns" : `xmlns:${prefix}`;
+		if (element.attributes?.[name] !== void 0) continue;
+		additions.push(` ${name}="${escapeXmlAttribute(uri)}"`);
+	}
+	let replacedOpening = opening.replace(XML_ATTRIBUTE, (match, name, assignment, quote) => name === ignorableAttribute ? `${name}${assignment}${quote}${escapeXmlAttribute(ignorable.join(" "))}${quote}` : match);
+	const close = opening.endsWith("/>") ? replacedOpening.length - 2 : replacedOpening.length - 1;
+	replacedOpening = replacedOpening.slice(0, close) + additions.join("") + replacedOpening.slice(close);
+	const materialized = replacedOpening + xml.slice(opening.length);
+	if (!isSafeCapturedXmlDocument(materialized)) return null;
+	if (!strict) return materialized;
+	const parsed = parseStreamingXmlWithSourceRanges(materialized);
+	if (parsed.status !== "parsed") return null;
+	const root = getChildElements(parsed.value).at(0);
+	return root === void 0 ? null : captureSourceProfileXml(root, DOCX_CONFORMANCE_CLASSES.STRICT);
+};
+const paragraphIdentity = (value) => value.type === "paragraph" ? value.paraId?.toUpperCase() : void 0;
+const addCandidate = ({ map, key, index }) => {
+	const queue = map.get(key);
+	if (queue) queue.indices.push(index);
+	else map.set(key, {
+		indices: [index],
+		cursor: 0
+	});
+};
+const takeCandidate = (queue, used) => {
+	if (!queue) return void 0;
+	while (queue.cursor < queue.indices.length) {
+		const candidate = queue.indices[queue.cursor];
+		queue.cursor += 1;
+		if (candidate !== void 0 && !used.has(candidate)) return candidate;
+	}
+};
+/** Replace only mapped block ranges, retaining authored root syntax and every intervening gap. */
+const replayBlocks = ({ sourceXml, baselineContent, currentContent, serializedXml, ignoredChild }, scope) => {
+	const source = readStory(sourceXml, scope?.source, ignoredChild);
+	const generated = readStory(serializedXml, scope?.generated, ignoredChild);
+	if (!source || !generated || getLocalName(source.root.name) !== getLocalName(generated.root.name) || source.blocks.length !== baselineContent.length || generated.blocks.length !== currentContent.length) return null;
+	if (source.blocks.some((block, index) => !modelMatchesElement({
+		value: baselineContent[index],
+		element: block.element,
+		mode: "source"
+	})) || generated.blocks.some((block, index) => !modelMatchesElement({
+		value: currentContent[index],
+		element: block.element,
+		mode: "generated"
+	}))) return null;
+	const generatedRoot = scope?.generatedRoot ?? generated.root;
+	const fingerprints = baselineContent.map(canonicalJson);
+	const identities = /* @__PURE__ */ new Map();
+	const byFingerprint = /* @__PURE__ */ new Map();
+	for (const [index, block] of baselineContent.entries()) {
+		const fingerprint = fingerprints[index];
+		if (fingerprint === void 0) return null;
+		addCandidate({
+			map: byFingerprint,
+			key: fingerprint,
+			index
+		});
+		const identity = paragraphIdentity(block);
+		if (identity !== void 0) addCandidate({
+			map: identities,
+			key: identity,
+			index
+		});
+	}
+	const used = /* @__PURE__ */ new Set();
+	const fragments = [];
+	for (const [index, block] of currentContent.entries()) {
+		const fingerprint = canonicalJson(block);
+		const identity = paragraphIdentity(block);
+		let originalIndex = takeCandidate(identity === void 0 ? void 0 : identities.get(identity), used) ?? takeCandidate(byFingerprint.get(fingerprint), used);
+		if (originalIndex === void 0 && (block.type === "table" || block.type === "blockSdt" || block.type === "blockCustomXml") && !used.has(index)) {
+			if (baselineContent[index]?.type === block.type) originalIndex = index;
+		}
+		if (originalIndex !== void 0) used.add(originalIndex);
+		const original = originalIndex === void 0 ? void 0 : source.blocks[originalIndex];
+		if (originalIndex !== void 0 && original && fingerprints[originalIndex] === fingerprint) {
+			fragments.push(sourceXml.slice(original.start, original.end));
+			continue;
+		}
+		const replacement = generated.blocks[index];
+		if (!replacement) return null;
+		if (original && originalIndex !== void 0) {
+			const nested = replayNestedBlock({
+				sourceXml,
+				serializedXml,
+				sourceElement: original.element,
+				generatedElement: replacement.element,
+				baseline: baselineContent[originalIndex],
+				current: block,
+				generatedRoot
+			});
+			if (nested !== null) {
+				fragments.push(nested);
+				continue;
+			}
+		}
+		const fragment = materializeReplayFragment({
+			xml: serializedXml.slice(replacement.start, replacement.end),
+			element: replacement.element,
+			sourceNamespace: getNamespaceUri(source.root) ?? "",
+			generatedRoot
+		});
+		if (fragment === null) return null;
+		fragments.push(fragment);
+	}
+	const splices = source.blocks.map((block, index) => ({
+		start: block.start,
+		end: block.end,
+		newXml: index === source.blocks.length - 1 ? fragments.slice(index).join("") : fragments[index] ?? ""
+	}));
+	if (source.blocks.length === 0 && fragments.length > 0) {
+		const opening = [...sourceXml.slice(source.range.start, source.range.end).matchAll(XML_TOKEN)].at(0)?.[0];
+		if (!opening || !source.root.name) return null;
+		if (opening.endsWith("/>")) splices.push({
+			start: source.range.start,
+			end: source.range.end,
+			newXml: `${opening.slice(0, -2)}>${fragments.join("")}</${source.root.name}>`
+		});
+		else {
+			const ignored = ignoredChild === void 0 ? void 0 : getChildElements(source.root).find((child) => getLocalName(child.name) === ignoredChild && WORDPROCESSINGML_NAMESPACE_URIS.has(getNamespaceUri(child) ?? ""));
+			const close = (ignored && getXmlSourceRange(ignored)?.start) ?? sourceXml.lastIndexOf("</", source.range.end);
+			if (close < source.range.start) return null;
+			splices.push({
+				start: close,
+				end: close,
+				newXml: fragments.join("")
+			});
+		}
+	}
+	return spliceXml(sourceXml, splices);
+};
+const buildStoryBlockReplay = (options) => replayBlocks(options);
+const withoutChildren = (value, key) => Object.fromEntries(Object.entries(value).filter(([name]) => name !== key));
+const wordChildren = (element, name) => getChildElements(element).filter((child) => getLocalName(child.name) === name && WORDPROCESSINGML_NAMESPACE_URIS.has(getNamespaceUri(child) ?? ""));
+const replayNestedBlock = ({ sourceXml, serializedXml, sourceElement, generatedElement, baseline, current, generatedRoot }) => {
+	if (baseline === void 0 || baseline.type !== current.type) return null;
+	const sourceRange = getXmlSourceRange(sourceElement);
+	if (!sourceRange) return null;
+	const splices = [];
+	const nestedContent = (sourceContainer, generatedContainer, before, after) => {
+		const sourceContentRange = getXmlSourceRange(sourceContainer);
+		const generatedContentRange = getXmlSourceRange(generatedContainer);
+		if (!sourceContentRange || !generatedContentRange) return false;
+		const patched = replayBlocks({
+			sourceXml: sourceXml.slice(sourceContentRange.start, sourceContentRange.end),
+			serializedXml: serializedXml.slice(generatedContentRange.start, generatedContentRange.end),
+			baselineContent: before,
+			currentContent: after
+		}, {
+			source: sourceContainer.namespaceScope,
+			generated: generatedContainer.namespaceScope,
+			generatedRoot
+		});
+		if (patched === null) return false;
+		splices.push({
+			start: sourceContentRange.start - sourceRange.start,
+			end: sourceContentRange.end - sourceRange.start,
+			newXml: patched
+		});
+		return true;
+	};
+	switch (current.type) {
+		case "blockSdt":
+		case "blockCustomXml": {
+			if (baseline.type !== "blockSdt" && baseline.type !== "blockCustomXml" || canonicalJson(withoutChildren(baseline, "content")) !== canonicalJson(withoutChildren(current, "content"))) return null;
+			if (current.type === "blockCustomXml") {
+				if (!nestedContent(sourceElement, generatedElement, baseline.content, current.content)) return null;
+				break;
+			}
+			const sourceChildren = wordChildren(sourceElement, "sdtContent");
+			const generatedChildren = wordChildren(generatedElement, "sdtContent");
+			const sourceContainer = sourceChildren.at(0);
+			const generatedContainer = generatedChildren.at(0);
+			if (sourceChildren.length !== 1 || generatedChildren.length !== 1 || !sourceContainer || !generatedContainer || !nestedContent(sourceContainer, generatedContainer, baseline.content, current.content)) return null;
+			break;
+		}
+		case "table": {
+			if (baseline.type !== "table" || baseline.rows.length !== current.rows.length || canonicalJson(withoutChildren(baseline, "rows")) !== canonicalJson(withoutChildren(current, "rows"))) return null;
+			const sourceRows = wordChildren(sourceElement, "tr");
+			const generatedRows = wordChildren(generatedElement, "tr");
+			if (sourceRows.length !== current.rows.length || generatedRows.length !== current.rows.length) return null;
+			for (const [rowIndex, row] of current.rows.entries()) {
+				const beforeRow = baseline.rows[rowIndex];
+				const sourceRow = sourceRows[rowIndex];
+				const generatedRow = generatedRows[rowIndex];
+				if (beforeRow === void 0 || beforeRow.cells.length !== row.cells.length || canonicalJson(withoutChildren(beforeRow, "cells")) !== canonicalJson(withoutChildren(row, "cells")) || !sourceRow || !generatedRow) return null;
+				const sourceCells = wordChildren(sourceRow, "tc");
+				const generatedCells = wordChildren(generatedRow, "tc");
+				if (sourceCells.length !== row.cells.length || generatedCells.length !== row.cells.length) return null;
+				for (const [cellIndex, cell] of row.cells.entries()) {
+					const beforeCell = beforeRow.cells[cellIndex];
+					const sourceCell = sourceCells[cellIndex];
+					const generatedCell = generatedCells[cellIndex];
+					if (beforeCell === void 0 || canonicalJson(withoutChildren(beforeCell, "content")) !== canonicalJson(withoutChildren(cell, "content")) || !sourceCell || !generatedCell) return null;
+					if (!replayCellContent({
+						sourceXml,
+						serializedXml,
+						sourceCell,
+						generatedCell,
+						before: beforeCell.content,
+						after: cell.content,
+						sourceRangeStart: sourceRange.start,
+						splices,
+						generatedRoot
+					})) return null;
+				}
+			}
+			break;
+		}
+		case "paragraph":
+		case "preservedBlock":
+		case "bookmarkStart":
+		case "bookmarkEnd": return null;
+		default: return current;
+	}
+	return spliceXml(sourceXml.slice(sourceRange.start, sourceRange.end), splices);
+};
+const replayCellContent = ({ sourceXml, serializedXml, sourceCell, generatedCell, before, after, sourceRangeStart, splices, generatedRoot }) => {
+	const sourceRange = getXmlSourceRange(sourceCell);
+	const generatedRange = getXmlSourceRange(generatedCell);
+	if (!sourceRange || !generatedRange) return false;
+	const sourceProperties = wordChildren(sourceCell, "tcPr");
+	const generatedProperties = wordChildren(generatedCell, "tcPr");
+	if (sourceProperties.length > 1 || generatedProperties.length > 1) return false;
+	const sourceProperty = sourceProperties.at(0);
+	const generatedProperty = generatedProperties.at(0);
+	const sourceView = sourceXml.slice(sourceRange.start, sourceRange.end);
+	let generatedView = serializedXml.slice(generatedRange.start, generatedRange.end);
+	const baselineContent = [...before];
+	const currentContent = [...after];
+	if (sourceProperty !== void 0) {
+		if (getChildElements(sourceCell).at(0) !== sourceProperty || !generatedProperty || getChildElements(generatedCell).at(0) !== generatedProperty) return false;
+		const range = getXmlSourceRange(sourceProperty);
+		if (!range) return false;
+		const propertyXml = materializeReplayFragment({
+			xml: sourceXml.slice(range.start, range.end),
+			element: sourceProperty,
+			sourceNamespace: getNamespaceUri(sourceCell) ?? ""
+		});
+		if (propertyXml === null) return false;
+		const property = {
+			type: "preservedBlock",
+			xml: propertyXml
+		};
+		baselineContent.unshift(property);
+		currentContent.unshift(property);
+	} else if (generatedProperty !== void 0) {
+		const range = getXmlSourceRange(generatedProperty);
+		if (!range) return false;
+		const stripped = spliceXml(generatedView, [{
+			start: range.start - generatedRange.start,
+			end: range.end - generatedRange.start,
+			newXml: ""
+		}]);
+		if (stripped === null) return false;
+		generatedView = stripped;
+	}
+	const patched = replayBlocks({
+		sourceXml: sourceView,
+		serializedXml: generatedView,
+		baselineContent,
+		currentContent
+	}, {
+		source: sourceCell.namespaceScope,
+		generated: generatedCell.namespaceScope,
+		generatedRoot
+	});
+	if (patched === null) return false;
+	splices.push({
+		start: sourceRange.start - sourceRangeStart,
+		end: sourceRange.end - sourceRangeStart,
+		newXml: patched
+	});
+	return true;
+};
+const readDocumentStory = (xml) => {
+	const document = readStory(xml);
+	if (!document || getLocalName(document.root.name) !== "document") return null;
+	const bodies = wordChildren(document.root, "body");
+	const body = bodies.at(0);
+	if (bodies.length !== 1 || !body || wordChildren(body, "sectPr").length > 1 || wordChildren(document.root, "background").length > 1) return null;
+	const range = getXmlSourceRange(body);
+	return range ? {
+		document,
+		body,
+		range
+	} : null;
+};
+/** Validate source/model correspondence before replaying an unchanged complete part. */
+const canReplayDocumentSource = (sourceXml, baseline) => {
+	const source = readDocumentStory(sourceXml);
+	if (!source) return false;
+	const body = readStory(sourceXml.slice(source.range.start, source.range.end), source.body.namespaceScope, "sectPr");
+	return body !== null && body.blocks.length === baseline.content.length && body.blocks.every((block, index) => modelMatchesElement({
+		value: baseline.content[index],
+		element: block.element,
+		mode: "source"
+	}));
+};
+/** Replay body blocks and modeled document metadata inside the authored part shell. */
+const buildDocumentBlockReplay = ({ sourceXml, serializedXml, baseline, current }) => {
+	const sourceStory = readDocumentStory(sourceXml);
+	const generatedStory = readDocumentStory(serializedXml);
+	if (!sourceStory || !generatedStory) return null;
+	const { body: sourceBody, range: sourceRange } = sourceStory;
+	const { document: generated, body: generatedBody, range: generatedRange } = generatedStory;
+	let bodyXml = replayBlocks({
+		sourceXml: sourceXml.slice(sourceRange.start, sourceRange.end),
+		serializedXml: serializedXml.slice(generatedRange.start, generatedRange.end),
+		baselineContent: baseline.content,
+		currentContent: current.content,
+		ignoredChild: "sectPr"
+	}, {
+		source: sourceBody.namespaceScope,
+		generated: generatedBody.namespaceScope,
+		generatedRoot: generated.root
+	});
+	if (bodyXml === null) return null;
+	const replaceMetadata = (xml, sourceContainer, generatedContainer, name) => {
+		const before = wordChildren(sourceContainer, name);
+		const after = wordChildren(generatedContainer, name);
+		if (before.length > 1 || after.length > 1) return null;
+		const old = before.at(0);
+		const next = after.at(0);
+		const containerRange = getXmlSourceRange(sourceContainer);
+		const oldRange = old && getXmlSourceRange(old);
+		const nextRange = next && getXmlSourceRange(next);
+		if (!containerRange || old && !oldRange || next && !nextRange) return null;
+		const replacement = next && nextRange ? materializeReplayFragment({
+			xml: serializedXml.slice(nextRange.start, nextRange.end),
+			element: next,
+			sourceNamespace: getNamespaceUri(sourceContainer) ?? "",
+			generatedRoot: generated.root
+		}) : "";
+		if (replacement === null) return null;
+		if (oldRange) return spliceXml(xml, [{
+			start: oldRange.start - containerRange.start,
+			end: oldRange.end - containerRange.start,
+			newXml: replacement
+		}]);
+		if (!next) return xml;
+		const insertion = name === "background" ? [...xml.matchAll(XML_TOKEN)].at(0)?.[0].length ?? -1 : xml.lastIndexOf("</");
+		if (insertion < 0) return null;
+		return spliceXml(xml, [{
+			start: insertion,
+			end: insertion,
+			newXml: replacement
+		}]);
+	};
+	if (canonicalJson(baseline.finalSectionProperties) !== canonicalJson(current.finalSectionProperties)) {
+		const reparsed = parseStreamingXmlWithSourceRanges(bodyXml, sourceBody.namespaceScope);
+		if (reparsed.status !== "parsed") return null;
+		const root = getChildElements(reparsed.value).at(0);
+		if (!root) return null;
+		bodyXml = replaceMetadata(bodyXml, root, generatedBody, "sectPr");
+		if (bodyXml === null) return null;
+	}
+	let result = spliceXml(sourceXml, [{
+		start: sourceRange.start,
+		end: sourceRange.end,
+		newXml: bodyXml
+	}]);
+	if (result === null) return null;
+	if (canonicalJson(baseline.background) !== canonicalJson(current.background)) {
+		const reparsed = readStory(result);
+		if (!reparsed) return null;
+		const replaced = replaceMetadata(result.slice(reparsed.range.start, reparsed.range.end), reparsed.root, generated.root, "background");
+		if (replaced === null) return null;
+		result = spliceXml(result, [{
+			start: reparsed.range.start,
+			end: reparsed.range.end,
+			newXml: replaced
+		}]);
+	}
+	return result;
+};
+//#endregion
+export { buildDocumentBlockReplay, buildStoryBlockReplay, canReplayDocumentSource, materializeReplayFragment };