@stll/folio-core 0.47.3 → 0.47.5

package/dist/ai-edits/headless.js

@@ -164,16 +164,49 @@ const FOLIO_RESOLVED_STORY_SERIALIZATION_MISMATCHES = Object.freeze({
 	blockProjection: "block-projection"
 });
 var FolioResolvedStorySerializationError = class extends TaggedError("FolioResolvedStorySerializationError") {};
+/** Blocks whose id folio minted, because the package names no id for them. */
+const mintedBlockOrdinals = (snapshot) => {
+	const ordinals = /* @__PURE__ */ new Set();
+	for (const [ordinal, block] of snapshot.blocks.entries()) if (block.idStability === "positional") ordinals.add(ordinal);
+	return ordinals;
+};
 /**
-* `idStability` records how an id entered the current snapshot. A synthesized
-* paraId is positional until save writes it into the package, then becomes an
-* authored stable id when reopened. Compare the persisted block projection
-* without changing that live snapshot identity contract.
+* What a block looks like once the story has been through the package.
+*
+* `idStability` is the snapshot's own fact rather than the package's, so it
+* goes. `minted` names the blocks whose id folio invented for a paragraph the
+* package gives no `w14:paraId`, and each of those stands down to its position.
+* A minted id is derived from the paragraph's text and ordinal, so resolving
+* its text can make an id-less paragraph derive a different id when reopened.
+* The two save paths also disagree about whether it reaches the file at all:
+* the selective patch keeps the author's id-less convention (see
+* `withoutMintedIds`) while a full repack writes the model's ids. Which path
+* ran is not what this check is about, so neither the id nor the choice between
+* them may decide it. An authored id is compared exactly as it is, and a block
+* that moved still fails.
 */
-const resolvedStoryBlockProjection = (block) => {
+const resolvedStoryBlockProjection = (block, ordinal, minted) => {
 	const persisted = { ...block };
 	delete persisted.idStability;
-	return persisted;
+	return minted.has(ordinal) ? {
+		...persisted,
+		id: `minted-${String(ordinal)}`
+	} : persisted;
+};
+/**
+* The two halves of the expectation, from one projection.
+*
+* The reading text carries each block's id, so it has to be built from the
+* same projected blocks the block comparison uses; formatting the raw snapshot
+* instead would put a minted id back into the text and fail the check the
+* block projection just passed.
+*/
+const resolvedStoryProjection = (snapshot, minted) => {
+	const blocks = snapshot.blocks.map((block, ordinal) => resolvedStoryBlockProjection(block, ordinal, minted));
+	return {
+		text: blocks.filter(isFolioAIContentBlock).map(formatBlockForLLM).join("\n"),
+		blocks
+	};
 };
 const numberingLevelsOf = (numbering) => {
 	if (!numbering) return [];
@@ -735,10 +768,11 @@ var FolioDocxReviewer = class FolioDocxReviewer {
 		const resolvedState = resolveReviewedState(sourceState, view);
 		this.setEditableStoryState(story, resolvedState);
 		const snapshot = createStateSnapshot(resolvedState);
+		const minted = mintedBlockOrdinals(snapshot);
 		this.resolvedStoryExpectations.set(editableStoryKey(story), {
 			story,
-			text: formatStorySnapshotForLLM(snapshot, false),
-			blocks: snapshot.blocks.map(resolvedStoryBlockProjection)
+			minted,
+			...resolvedStoryProjection(snapshot, minted)
 		});
 		return snapshot;
 	}
@@ -1356,13 +1390,14 @@ var FolioDocxReviewer = class FolioDocxReviewer {
 	async assertResolvedStoriesSerialized(buffer, expectations) {
 		if (expectations.length === 0) return;
 		const reopened = await FolioDocxReviewer.fromBuffer(buffer);
-		for (const { story, text, blocks } of expectations) {
+		for (const { story, text, blocks, minted } of expectations) {
 			const serialized = reopened.readReviewedStory({
 				story,
 				view: "current-markup"
 			});
-			const serializedText = serialized ? formatStorySnapshotForLLM(serialized.snapshot, false) : null;
-			const serializedBlocks = serialized ? serialized.snapshot.blocks.map(resolvedStoryBlockProjection) : null;
+			const persisted = serialized ? resolvedStoryProjection(serialized.snapshot, minted) : null;
+			const serializedText = persisted?.text ?? null;
+			const serializedBlocks = persisted?.blocks ?? null;
 			const mismatches = [];
 			if (!serialized) mismatches.push(FOLIO_RESOLVED_STORY_SERIALIZATION_MISMATCHES.storyMissing);
 			else {

package/dist/compare/inline-atoms.js

@@ -1,9 +1,11 @@
 import { buildCleanBlockText } from "../ai-edits/clean-text.js";
 import { sourceDocumentOf } from "../ai-edits/snapshot.js";
 import { resolveAllChangesInHeadlessStateWithMapping } from "../prosemirror/commands/comments.js";
+import { runFormattingInlineAtomResultText } from "../prosemirror/runFormattingInlineCarriers.js";
 import { canonicalJson } from "../utils/canonicalJson.js";
 import { prepareTargetInlineAtom } from "./inline-atom-resources.js";
 //#region src/compare/inline-atoms.ts
+const actionRangeCount = (action) => action.kind === "replace-text" && action.textDisposition === "retained" || action.kind === "replace-atom" && action.atomDisposition === "retained" ? 2 : 1;
 const MAX_INLINE_ATOM_LCS_CELLS = 16384;
 const isSupportedAtom = (node) => node.isInline && node.isAtom && (node.type.name === "field" || node.type.name === "image" || node.type.name === "pageBreakRun");
 const hasSupportedAtom = (doc) => {
@@ -72,8 +74,8 @@ const atomKey = (node) => canonicalJson({
 	attrs: documentFactAttrs(node),
 	content: node.content.toJSON()
 });
-const atomBlockOf = ({ node, from }) => {
-	const clean = buildCleanBlockText(node, from, { fieldResults: "omitted" });
+const atomBlockOf = ({ node, from }, fieldResults) => {
+	const clean = buildCleanBlockText(node, from, { fieldResults });
 	const supported = [];
 	const unsupportedTopology = [];
 	node.descendants((child, relativePosition) => {
@@ -86,12 +88,18 @@ const atomBlockOf = ({ node, from }) => {
 		});
 		if (!isSupportedAtom(child)) {
 			if (child.type.name === "renderedPageBreak") return false;
-			unsupportedTopology.push(`${offset}:${child.type.name}:${canonicalJson(documentFactAttrs(child))}`);
+			unsupportedTopology.push({
+				offset,
+				key: `${child.type.name}:${canonicalJson(documentFactAttrs(child))}`
+			});
 			return false;
 		}
 		const prepared = prepareTargetInlineAtom(child);
 		if (!prepared) {
-			unsupportedTopology.push(`${offset}:${child.type.name}:${canonicalJson(documentFactAttrs(child))}`);
+			unsupportedTopology.push({
+				offset,
+				key: `${child.type.name}:${canonicalJson(documentFactAttrs(child))}`
+			});
 			return false;
 		}
 		supported.push({
@@ -130,8 +138,33 @@ const targetBlockIdLookup = (snapshot) => {
 		return owner?.id;
 	};
 };
-const atomBlocksOf = (doc) => textBlocksOf(doc).map(atomBlockOf);
-const sameBlockTopology = (left, right) => left.node.type === right.node.type && left.cleanText === right.cleanText && canonicalJson(left.unsupportedTopology) === canonicalJson(right.unsupportedTopology);
+const atomBlocksOf = (doc, fieldResults) => textBlocksOf(doc).map((block) => atomBlockOf(block, fieldResults));
+const sameBlockTopology = (left, right) => {
+	if (left.node.type !== right.node.type || left.cleanText !== right.cleanText) return false;
+	const supportedOffsets = /* @__PURE__ */ new Set([...left.supported.map(({ offset }) => offset), ...right.supported.map(({ offset }) => offset)]);
+	const relevantTopology = ({ unsupportedTopology }) => unsupportedTopology.filter(({ offset }) => supportedOffsets.has(offset));
+	return canonicalJson(relevantTopology(left)) === canonicalJson(relevantTopology(right));
+};
+const supportedAtomProjection = (block) => canonicalJson(block.supported.map(({ offset, key }) => ({
+	offset,
+	key
+})));
+const sameSupportedAtoms = (left, right) => left.node.type === right.node.type && supportedAtomProjection(left) === supportedAtomProjection(right);
+const fieldResultOwnershipOf = (atoms) => {
+	const ownership = /* @__PURE__ */ new Map();
+	for (const atom of atoms) {
+		const resultText = runFormattingInlineAtomResultText(atom.node);
+		if (!resultText) continue;
+		let resultsAtOffset = ownership.get(atom.offset);
+		if (!resultsAtOffset) {
+			resultsAtOffset = /* @__PURE__ */ new Set();
+			ownership.set(atom.offset, resultsAtOffset);
+		}
+		resultsAtOffset.add(resultText);
+	}
+	return ownership;
+};
+const ownsFieldResult = ({ ownership, offset, resultText }) => ownership.get(offset)?.has(resultText) ?? false;
 const matchingAtomGroup = ({ live, target, liveStart, targetStart }) => {
 	if (live.length === target.length && live.every((atom, index) => atom.key === target[index]?.key)) return live.map((_, index) => [liveStart + index, targetStart + index]);
 	if (live.length === 0 || target.length === 0) return [];
@@ -246,14 +279,58 @@ const sourceTextBlockIds = (source) => {
 	}
 	return blocks;
 };
-const sameParagraphSourcePosition = ({ sourceBlocks, reviewed, offset }) => {
+const sameParagraphSourcePosition = ({ sourceBlocks, reviewed, offset, fieldResults }) => {
 	const paraId = reviewed.node.attrs["paraId"];
 	if (typeof paraId !== "string" || paraId.length === 0) return null;
 	const source = sourceBlocks.get(paraId);
 	if (!source || source.node.type !== reviewed.node.type) return null;
-	const clean = buildCleanBlockText(source.node, source.from, { fieldResults: "omitted" });
+	const clean = buildCleanBlockText(source.node, source.from, { fieldResults });
 	return clean.text === reviewed.cleanText ? clean.offsets[offset] ?? null : null;
 };
+const textRangeDisposition = ({ doc, from, to, expectedText, originalRevisionIdSeed }) => {
+	if (from >= to || doc.textBetween(from, to) !== expectedText) return null;
+	let disposition;
+	let covered = 0;
+	let invalid = false;
+	doc.nodesBetween(from, to, (node, position) => {
+		if (!node.isText) {
+			if (position > from && position < to) invalid = true;
+			return !invalid;
+		}
+		const overlapFrom = Math.max(from, position);
+		const overlapTo = Math.min(to, position + node.nodeSize);
+		if (overlapFrom >= overlapTo) return false;
+		covered += overlapTo - overlapFrom;
+		if (node.marks.some(({ type }) => type.name === "deletion")) {
+			invalid = true;
+			return false;
+		}
+		const insertion = node.marks.find(({ type }) => type.name === "insertion");
+		let current = "retained";
+		if (insertion) {
+			const revisionId = insertion.attrs["revisionId"];
+			if (typeof revisionId !== "number" || revisionId < originalRevisionIdSeed) {
+				invalid = true;
+				return false;
+			}
+			current = "inserted";
+		}
+		if (disposition !== void 0 && disposition !== current) {
+			invalid = true;
+			return false;
+		}
+		disposition = current;
+		return false;
+	});
+	return !invalid && covered === to - from ? disposition ?? null : null;
+};
+const atomDisposition = ({ atom, originalRevisionIdSeed }) => {
+	if (atom.node.marks.some(({ type }) => type.name === "deletion")) return null;
+	const insertion = atom.node.marks.find(({ type }) => type.name === "insertion");
+	if (!insertion) return "retained";
+	const revisionId = insertion.attrs["revisionId"];
+	return typeof revisionId === "number" && revisionId >= originalRevisionIdSeed ? "inserted" : null;
+};
 /**
 * Restore field, image, and page-break atoms omitted by text-only comparison operations.
 * Positions come from the legacy review resolver's mapping, never a guessed
@@ -272,15 +349,38 @@ const matchInlineAtoms = ({ state, targetSnapshot, revisionStamp, originalRevisi
 	const reviewed = resolveAllChangesInHeadlessStateWithMapping(state, "accept");
 	const targetBlockIdAt = targetBlockIdLookup(targetSnapshot);
 	let sourceBlocks;
-	const liveBlocks = atomBlocksOf(reviewed.state.doc);
-	const targetBlocks = atomBlocksOf(targetDocument);
+	const liveBlocks = atomBlocksOf(reviewed.state.doc, "text");
+	const targetBlocks = atomBlocksOf(targetDocument, "text");
 	if (liveBlocks.length !== targetBlocks.length) return { status: "unalignable" };
 	const actions = [];
-	for (const [index, live] of liveBlocks.entries()) {
-		const target = targetBlocks[index];
-		if (!target) return { status: "unalignable" };
-		if (live.supported.length === 0 && target.supported.length === 0) continue;
-		if (!sameBlockTopology(live, target)) return { status: "unalignable" };
+	let rangeCount = 0;
+	const planAction = (action) => {
+		const nextRangeCount = rangeCount + actionRangeCount(action);
+		if (nextRangeCount > maxRanges) return false;
+		rangeCount = nextRangeCount;
+		actions.push(action);
+		return true;
+	};
+	let omittedLiveBlocks;
+	let omittedTargetBlocks;
+	for (const [index, fullLive] of liveBlocks.entries()) {
+		const fullTarget = targetBlocks[index];
+		if (!fullTarget) return { status: "unalignable" };
+		if (fullLive.supported.length === 0 && fullTarget.supported.length === 0) continue;
+		if (sameSupportedAtoms(fullLive, fullTarget)) continue;
+		let live = fullLive;
+		let target = fullTarget;
+		let fieldResults = "text";
+		if (!sameBlockTopology(live, target)) {
+			omittedLiveBlocks ??= atomBlocksOf(reviewed.state.doc, "omitted");
+			omittedTargetBlocks ??= atomBlocksOf(targetDocument, "omitted");
+			const omittedLive = omittedLiveBlocks[index];
+			const omittedTarget = omittedTargetBlocks[index];
+			if (!omittedLive || !omittedTarget || !sameBlockTopology(omittedLive, omittedTarget)) return { status: "unalignable" };
+			live = omittedLive;
+			target = omittedTarget;
+			fieldResults = "omitted";
+		}
 		const matches = matchingAtoms({
 			live: live.supported,
 			target: target.supported
@@ -292,6 +392,8 @@ const matchInlineAtoms = ({ state, targetSnapshot, revisionStamp, originalRevisi
 			target: target.supported,
 			matches
 		});
+		const liveFieldResultOwnership = fieldResultOwnershipOf(live.supported);
+		const targetFieldResultOwnership = fieldResultOwnershipOf(target.supported);
 		for (const [liveIndex, atom] of live.supported.entries()) {
 			if (matchedLive.has(liveIndex)) continue;
 			const from = mappedSourcePosition({
@@ -299,12 +401,34 @@ const matchInlineAtoms = ({ state, targetSnapshot, revisionStamp, originalRevisi
 				position: atom.from
 			});
 			if (from === null) return { status: "unalignable" };
-			actions.push({
+			const resultText = runFormattingInlineAtomResultText(atom.node);
+			if (fieldResults === "text" && resultText && !ownsFieldResult({
+				ownership: targetFieldResultOwnership,
+				offset: atom.offset,
+				resultText
+			})) {
+				const disposition = atomDisposition({
+					atom,
+					originalRevisionIdSeed
+				});
+				if (disposition === null) return { status: "unalignable" };
+				if (!planAction({
+					kind: "replace-atom",
+					from,
+					to: from + atom.node.nodeSize,
+					text: resultText,
+					atomDisposition: disposition,
+					marks: atom.node.marks,
+					targetBlockId: targetBlockIdAt(target.from)
+				})) return { status: "budget-exceeded" };
+				continue;
+			}
+			if (!planAction({
 				kind: "delete",
 				from,
 				to: from + atom.node.nodeSize,
 				targetBlockId: targetBlockIdAt(target.from)
-			});
+			})) return { status: "budget-exceeded" };
 		}
 		for (const [targetIndex, atom] of target.supported.entries()) {
 			if (matchedTarget.has(targetIndex)) continue;
@@ -316,18 +440,48 @@ const matchInlineAtoms = ({ state, targetSnapshot, revisionStamp, originalRevisi
 			}) ?? sameParagraphSourcePosition({
 				sourceBlocks: sourceBlocks ??= sourceTextBlockIds(state.doc),
 				reviewed: live,
-				offset: atom.offset
+				offset: atom.offset,
+				fieldResults
 			});
 			if (from === null) return { status: "unalignable" };
-			actions.push({
+			const resultText = runFormattingInlineAtomResultText(atom.node);
+			if (fieldResults === "text" && resultText && !ownsFieldResult({
+				ownership: liveFieldResultOwnership,
+				offset: atom.offset,
+				resultText
+			})) {
+				const reviewedTo = live.offsets[atom.offset + resultText.length];
+				const to = reviewedTo === void 0 ? null : mappedSourcePosition({
+					mapping: reviewed.mapping,
+					position: reviewedTo
+				});
+				if (to === null) return { status: "unalignable" };
+				const textDisposition = textRangeDisposition({
+					doc: state.doc,
+					from,
+					to,
+					expectedText: resultText,
+					originalRevisionIdSeed
+				});
+				if (textDisposition === null) return { status: "unalignable" };
+				if (!planAction({
+					kind: "replace-text",
+					from,
+					to,
+					node: atom.node,
+					textDisposition,
+					targetBlockId: targetBlockIdAt(target.from)
+				})) return { status: "budget-exceeded" };
+				continue;
+			}
+			if (!planAction({
 				kind: "insert",
 				from,
 				node: atom.node,
 				targetBlockId: targetBlockIdAt(target.from)
-			});
+			})) return { status: "budget-exceeded" };
 		}
 	}
-	if (actions.length > maxRanges) return { status: "budget-exceeded" };
 	const insertionType = state.schema.marks["insertion"];
 	const deletionType = state.schema.marks["deletion"];
 	if (!insertionType || !deletionType) return { status: "unalignable" };
@@ -347,6 +501,45 @@ const matchInlineAtoms = ({ state, targetSnapshot, revisionStamp, originalRevisi
 			if (action.targetBlockId) changedTargetBlockIds.add(action.targetBlockId);
 			continue;
 		}
+		if (action.kind === "replace-text") {
+			const from = transaction.mapping.map(action.from, 1);
+			const to = transaction.mapping.map(action.to, -1);
+			if (from >= to) return { status: "unalignable" };
+			if (action.textDisposition === "inserted") transaction.delete(from, to);
+			else transaction.addMark(from, to, deletionType.create({
+				revisionId: nextRevisionId++,
+				author,
+				date: revisionStamp.date
+			}));
+			const at = transaction.mapping.map(action.from, -1);
+			transaction.insert(at, action.node.mark(insertionType.create({
+				revisionId: nextRevisionId++,
+				author,
+				date: revisionStamp.date
+			}).addToSet(action.node.marks)));
+			if (action.targetBlockId) changedTargetBlockIds.add(action.targetBlockId);
+			continue;
+		}
+		if (action.kind === "replace-atom") {
+			const from = transaction.mapping.map(action.from, 1);
+			const to = transaction.mapping.map(action.to, -1);
+			const node = transaction.doc.nodeAt(from);
+			if (!node || node.nodeSize !== to - from || node.type.name !== "field") return { status: "unalignable" };
+			if (action.atomDisposition === "inserted") transaction.delete(from, to);
+			else transaction.addMark(from, to, deletionType.create({
+				revisionId: nextRevisionId++,
+				author,
+				date: revisionStamp.date
+			}));
+			const at = transaction.mapping.map(action.from, -1);
+			transaction.insert(at, state.schema.text(action.text, insertionType.create({
+				revisionId: nextRevisionId++,
+				author,
+				date: revisionStamp.date
+			}).addToSet(action.marks)));
+			if (action.targetBlockId) changedTargetBlockIds.add(action.targetBlockId);
+			continue;
+		}
 		const from = transaction.mapping.map(action.from, 1);
 		const to = transaction.mapping.map(action.to, -1);
 		const node = transaction.doc.nodeAt(from);
@@ -372,25 +565,19 @@ const matchInlineAtoms = ({ state, targetSnapshot, revisionStamp, originalRevisi
 		transaction,
 		nextRevisionId,
 		changedTargetBlockIds: [...changedTargetBlockIds],
-		rangeCount: actions.length
+		rangeCount
 	};
 };
 /** Compare supported inline atom identity after accept or reject projection. */
 const sameInlineAtoms = (leftDocument, rightDocument) => {
 	if (!hasSupportedAtom(leftDocument) && !hasSupportedAtom(rightDocument)) return true;
-	const leftBlocks = atomBlocksOf(leftDocument);
-	const rightBlocks = atomBlocksOf(rightDocument);
+	const leftBlocks = atomBlocksOf(leftDocument, "omitted");
+	const rightBlocks = atomBlocksOf(rightDocument, "omitted");
 	if (leftBlocks.length !== rightBlocks.length) return false;
 	return leftBlocks.every((left, index) => {
 		const right = rightBlocks[index];
 		if (left.supported.length === 0 && right?.supported.length === 0) return true;
-		return right !== void 0 && sameBlockTopology(left, right) && canonicalJson(left.supported.map(({ offset, key }) => ({
-			offset,
-			key
-		}))) === canonicalJson(right.supported.map(({ offset, key }) => ({
-			offset,
-			key
-		})));
+		return right !== void 0 && left.cleanText === right.cleanText && sameSupportedAtoms(left, right);
 	});
 };
 //#endregion

package/dist/compare/section-boundary-properties.js

@@ -12,6 +12,7 @@ const boundaryChildrenOf = (document) => {
 	let hasChangeHistory = false;
 	document.forEach((node, position) => {
 		if (node.type.name !== "paragraph") {
+			if (node.type.name === "preservedBlock") return;
 			children.push({
 				type: "other",
 				nodeType: node.type.name

package/dist/content-controls/mutateContentControls.js

@@ -162,11 +162,9 @@ function mapBlock(block, match) {
 			...row,
 			cells: row.cells.map((cell) => {
 				const transformed = transformBlocks(cell.content, match);
-				const cellContent = [];
-				for (const child of transformed) if (child.type === "paragraph" || child.type === "table") cellContent.push(child);
 				return {
 					...cell,
-					content: cellContent
+					content: transformed
 				};
 			})
 		}));

package/dist/docx/commentRangeIntegrity.js

@@ -204,6 +204,13 @@ const withoutOrphanTableCellBlockMarkers = (blocks, validCommentIds) => {
 const withoutOrphanTableCellBlockMarker = (block, validCommentIds) => {
 	if (block.type === "paragraph") return withoutOrphanParagraphMarkers(block, validCommentIds);
 	if (block.type === "table") return withoutOrphanTableMarkers(block, validCommentIds);
+	if (block.type === "blockSdt") {
+		const content = withoutOrphanTableCellBlockMarkers(block.content, validCommentIds);
+		return content ? {
+			...block,
+			content
+		} : block;
+	}
 	return block;
 };
 const withoutOrphanParagraphMarkers = (paragraph, validCommentIds) => {

package/dist/docx/documentParser.js

@@ -2,7 +2,9 @@ import { parseBlockContent } from "./blockContentParser.js";
 import { getParagraphText } from "./paragraphParser.js";
 import { getDefaultSectionProperties, parseSectionProperties } from "./sectionParser.js";
 import { parseStreamingXml } from "./streamingXmlParser.js";
-import { collectXmlnsDeclarations, findChild, getLocalName, parseXml } from "./xmlParser.js";
+import { parseThemeColorAttribute } from "./themeColorAttribute.js";
+import { captureVerbatimXml } from "./verbatimCapture.js";
+import { WORDPROCESSINGML_NAMESPACE_URIS, collectXmlnsDeclarations, findChild, findChildByNamespaceUri, getAttributeByNamespaceUri, getLocalName, parseXml } from "./xmlParser.js";
 //#region src/docx/documentParser.ts
 /**
 * Regular expression to match template variables {{...}}
@@ -38,6 +40,8 @@ function extractAllTemplateVariables(content) {
 	} else if (block.type === "table") {
 		const tableVars = extractTableVariables(block);
 		for (const v of tableVars) if (!variables.includes(v)) variables.push(v);
+	} else if (block.type === "blockSdt") {
+		for (const v of extractAllTemplateVariables(block.content)) if (!variables.includes(v)) variables.push(v);
 	}
 	return variables;
 }
@@ -52,6 +56,8 @@ function extractTableVariables(table) {
 	} else if (cellContent.type === "table") {
 		const nestedVars = extractTableVariables(cellContent);
 		for (const v of nestedVars) if (!variables.includes(v)) variables.push(v);
+	} else if (cellContent.type === "blockSdt") {
+		for (const v of extractAllTemplateVariables(cellContent.content)) if (!variables.includes(v)) variables.push(v);
 	}
 	return variables;
 }
@@ -108,6 +114,28 @@ function canonicalizeLeadingBodySectionProperties(bodyElement, body) {
 	}
 	body.finalSectionProperties = nextProperties;
 }
+/** Read the page background declared directly under `w:document`. */
+function parseDocumentBackground(documentEl, context) {
+	const element = findChildByNamespaceUri(documentEl, WORDPROCESSINGML_NAMESPACE_URIS, "background");
+	if (!element) return;
+	const background = {};
+	const color = getAttributeByNamespaceUri(element, WORDPROCESSINGML_NAMESPACE_URIS, "color");
+	if (color === "auto") background.color = { auto: true };
+	else if (color !== null) background.color = { rgb: color };
+	const themeColor = parseThemeColorAttribute({
+		raw: getAttributeByNamespaceUri(element, WORDPROCESSINGML_NAMESPACE_URIS, "themeColor"),
+		element: element.name ?? "w:background",
+		context
+	});
+	if (themeColor !== void 0) background.themeColor = themeColor;
+	const themeTint = getAttributeByNamespaceUri(element, WORDPROCESSINGML_NAMESPACE_URIS, "themeTint");
+	if (themeTint !== null) background.themeTint = themeTint;
+	const themeShade = getAttributeByNamespaceUri(element, WORDPROCESSINGML_NAMESPACE_URIS, "themeShade");
+	if (themeShade !== null) background.themeShade = themeShade;
+	const drawing = findChildByNamespaceUri(element, WORDPROCESSINGML_NAMESPACE_URIS, "drawing");
+	if (drawing) background.drawing = { rawXml: captureVerbatimXml(drawing) };
+	return background;
+}
 /**
 * Parse document.xml body content
 *
@@ -125,6 +153,8 @@ function parseDocumentBody(xml, styles = null, theme = null, numbering = null, r
 	const streamed = parseStreamingXml(xml);
 	const documentEl = ((streamed.status === "parsed" ? streamed.value : parseXml(xml)).elements ?? []).find((el) => el.type === "element" && (el.name === "w:document" || el.name?.endsWith(":document")));
 	if (!documentEl) return result;
+	const background = parseDocumentBackground(documentEl, context);
+	if (background !== void 0) result.background = background;
 	const bodyEl = findChild(documentEl, "w", "body");
 	if (!bodyEl) return result;
 	result.content = parseBlockContent(bodyEl, styles, theme, numbering, rels, media, {
@@ -144,8 +174,16 @@ function getAllParagraphs(body) {
 	const paragraphs = [];
 	for (const block of body.content) if (block.type === "paragraph") paragraphs.push(block);
 	else if (block.type === "table") paragraphs.push(...getTableParagraphs(block));
+	else if (block.type === "blockSdt") paragraphs.push(...getParagraphsFromBlocks(block.content));
 	return paragraphs;
 }
+const getParagraphsFromBlocks = (blocks) => {
+	const paragraphs = [];
+	for (const block of blocks) if (block.type === "paragraph") paragraphs.push(block);
+	else if (block.type === "table") paragraphs.push(...getTableParagraphs(block));
+	else if (block.type === "blockSdt") paragraphs.push(...getParagraphsFromBlocks(block.content));
+	return paragraphs;
+};
 /**
 * Get all paragraphs from a table (recursively)
 */
@@ -153,6 +191,7 @@ function getTableParagraphs(table) {
 	const paragraphs = [];
 	for (const row of table.rows) for (const cell of row.cells) for (const content of cell.content) if (content.type === "paragraph") paragraphs.push(content);
 	else if (content.type === "table") paragraphs.push(...getTableParagraphs(content));
+	else if (content.type === "blockSdt") paragraphs.push(...getParagraphsFromBlocks(content.content));
 	return paragraphs;
 }
 /**
@@ -163,9 +202,15 @@ function getAllTables(body) {
 	for (const block of body.content) if (block.type === "table") {
 		tables.push(block);
 		tables.push(...getNestedTables(block));
-	}
+	} else if (block.type === "blockSdt") tables.push(...getTablesFromBlocks(block.content));
 	return tables;
 }
+const getTablesFromBlocks = (blocks) => {
+	const tables = [];
+	for (const block of blocks) if (block.type === "table") tables.push(block, ...getNestedTables(block));
+	else if (block.type === "blockSdt") tables.push(...getTablesFromBlocks(block.content));
+	return tables;
+};
 /**
 * Get nested tables from a table (recursively)
 */
@@ -174,7 +219,7 @@ function getNestedTables(table) {
 	for (const row of table.rows) for (const cell of row.cells) for (const content of cell.content) if (content.type === "table") {
 		tables.push(content);
 		tables.push(...getNestedTables(content));
-	}
+	} else if (content.type === "blockSdt") tables.push(...getTablesFromBlocks(content.content));
 	return tables;
 }
 /**
@@ -184,8 +229,14 @@ function getDocumentText(body) {
 	const lines = [];
 	for (const block of body.content) if (block.type === "paragraph") lines.push(getParagraphText(block));
 	else if (block.type === "table") lines.push(getTableText(block));
+	else if (block.type === "blockSdt") lines.push(getTextFromBlocks(block.content));
 	return lines.join("\n");
 }
+const getTextFromBlocks = (blocks) => blocks.flatMap((block) => {
+	if (block.type === "paragraph") return [getParagraphText(block)];
+	if (block.type === "table") return [getTableText(block)];
+	return block.type === "blockSdt" ? [getTextFromBlocks(block.content)] : [];
+}).join("\n");
 /**
 * Get plain text from a table
 */
@@ -197,6 +248,7 @@ function getTableText(table) {
 			const cellTexts = [];
 			for (const content of cell.content) if (content.type === "paragraph") cellTexts.push(getParagraphText(content));
 			else if (content.type === "table") cellTexts.push(getTableText(content));
+			else if (content.type === "blockSdt") cellTexts.push(getTextFromBlocks(content.content));
 			rowTexts.push(cellTexts.join("\n"));
 		}
 		lines.push(rowTexts.join("	"));