@stll/folio-core 0.47.4 → 0.47.5

package/dist/docx/normalizeBaseDirection.js

@@ -52,6 +52,10 @@ const normalizeCellBlock = (block, styles) => {
 	switch (block.type) {
 		case "paragraph": return normalizeParagraph(block, styles);
 		case "table": return normalizeTable(block, styles);
+		case "blockSdt": return {
+			...block,
+			content: block.content.map((child) => normalizeCellBlock(child, styles))
+		};
 		case "preservedBlock":
 		case "bookmarkStart":
 		case "bookmarkEnd": return block;

package/dist/docx/rezip.js

@@ -404,6 +404,7 @@ function collectNewImages(blocks) {
 			for (const sub of item.content) if (sub.type === "run") collectFromRun(sub);
 		}
 	} else if (block.type === "table") for (const row of block.rows) for (const cell of row.cells) images.push(...collectNewImages(cell.content));
+	else if (block.type === "blockSdt") images.push(...collectNewImages(block.content));
 	return images;
 }
 /** Map MIME type to file extension (inverse of getContentTypeForExtension) */

package/dist/docx/serializer/documentSerializer.js

@@ -5,6 +5,8 @@ import { serializePartElement } from "./partNamespaces.js";
 import { resetAutoIdCounter } from "./runSerializer.js";
 import { serializeSectionProperties } from "./sectionPropertiesSerializer.js";
 import { serializeTable } from "./tableSerializer.js";
+import { escapeXmlAttribute } from "@stll/docx-core";
+import { themeColorToken } from "@stll/docx-core/model";
 //#region src/docx/serializer/documentSerializer.ts
 /**
 * Prefixes document.xml declares whether or not the body uses them.
@@ -55,6 +57,19 @@ function serializeBlockContent(block) {
 function serializeBodyContent(content) {
 	return content.map((block) => serializeBlockContent(block)).join("");
 }
+/** Serialize the optional page background that precedes `w:body`. */
+function serializeDocumentBackground(background) {
+	if (background === void 0) return "";
+	const attributes = [];
+	if (background.color?.auto) attributes.push("w:color=\"auto\"");
+	else if (background.color?.rgb !== void 0) attributes.push(`w:color="${escapeXmlAttribute(background.color.rgb)}"`);
+	if (background.themeColor !== void 0) attributes.push(`w:themeColor="${escapeXmlAttribute(themeColorToken(background.themeColor))}"`);
+	if (background.themeTint !== void 0) attributes.push(`w:themeTint="${escapeXmlAttribute(background.themeTint)}"`);
+	if (background.themeShade !== void 0) attributes.push(`w:themeShade="${escapeXmlAttribute(background.themeShade)}"`);
+	const attributeText = attributes.length === 0 ? "" : ` ${attributes.join(" ")}`;
+	const drawing = background.drawing?.rawXml;
+	return drawing === void 0 ? `<w:background${attributeText}/>` : `<w:background${attributeText}>${drawing}</w:background>`;
+}
 /**
 * Serialize a DocumentBody to document.xml body content
 *
@@ -77,7 +92,7 @@ function serializeDocumentBody(body) {
 */
 function serializeDocument(doc, sourceBindings) {
 	resetAutoIdCounter();
-	const body = `<w:body>${serializeDocumentBody(doc.package.document)}</w:body>`;
+	const body = serializeDocumentBackground(doc.package.document.background) + `<w:body>${serializeDocumentBody(doc.package.document)}</w:body>`;
 	return "<?xml version=\"1.0\" encoding=\"UTF-8\" standalone=\"yes\"?>" + serializePartElement({
 		partPath: "word/document.xml",
 		rootName: "w:document",

package/dist/docx/serializer/paragraphSerializer.js

@@ -358,6 +358,10 @@ function serializeInlineSdt(sdt, disposition = "kept") {
 			case "inlineWrapper": return serializeParagraphContent(item, disposition);
 			case "bookmarkStart": return serializeBookmarkMarker(item);
 			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 "insertion": return serializeTrackedChange("ins", item);
 			case "deletion": return serializeTrackedChange("del", item);
 			case "moveFrom": return serializeTrackedChange("moveFrom", item);
@@ -420,6 +424,10 @@ function serializeTrackedChange(tag, change) {
 			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 item.xml;
 			case "inlineWrapper":
 			case "inlineSdt": return serializeParagraphContent(item, disposition);

package/dist/docx/serializer/tableSerializer.js

@@ -6,6 +6,7 @@ import { TRANSITIONAL_NAME_BY_STRICT_NAME } from "../strictNames.gen.js";
 import { TABLE_LOOK_FLAGS } from "../tableLook.js";
 import { parseTableCellProperties, parseTableGrid, parseTableProperties, parseTablePropertyExceptions, parseTableRowProperties } from "../tableParser.js";
 import { OOXML_NAMESPACE_SCOPE, parseXml } from "../xmlParser.js";
+import { serializeBlockSdt } from "./blockSdtSerializer.js";
 import { serializeBorder } from "./borderSerializer.js";
 import { serializeBookmarkMarker } from "./markupRangeAttributes.js";
 import { serializeSdtWrapper } from "./sdtPropertiesSerializer.js";
@@ -511,16 +512,18 @@ const preservedChild = (xml, child) => ({
 * Serialize cell content (paragraphs, nested tables)
 */
 function serializeCellContent(content, serializeParagraph) {
-	const parts = content.map((block) => {
+	const serializeCellBlock = (block) => {
 		switch (block.type) {
 			case "paragraph": return serializeParagraph(block);
 			case "table": return serializeTable(block, serializeParagraph);
+			case "blockSdt": return serializeBlockSdt(block, serializeCellBlock);
 			case "preservedBlock": return block.xml;
 			case "bookmarkStart":
 			case "bookmarkEnd": return serializeBookmarkMarker(block);
 			default: return block;
 		}
-	});
+	};
+	const parts = content.map(serializeCellBlock);
 	if (parts.length === 0) parts.push("<w:p/>");
 	return parts.join("");
 }

package/dist/docx/server/createBilingualDocument.js

@@ -464,30 +464,39 @@ const remapListRendering = (rendering, cloner) => {
 };
 const collectTableParagraphs = (table) => {
 	const out = [];
-	for (const row of table.rows) for (const cell of row.cells) for (const item of cell.content) if (item.type === "paragraph") out.push(item);
-	else if (item.type === "table") out.push(...collectTableParagraphs(item));
+	const collectBlocks = (blocks) => {
+		for (const item of blocks) if (item.type === "paragraph") out.push(item);
+		else if (item.type === "table") out.push(...collectTableParagraphs(item));
+		else if (item.type === "blockSdt") collectBlocks(item.content);
+	};
+	for (const row of table.rows) for (const cell of row.cells) collectBlocks(cell.content);
 	return out;
 };
 const cloneTableForTarget = ({ table, editableParagraphIds, paraIds, styleCloner, cloner, bookmarkIds }) => {
 	const paragraphs = [];
+	const cloneBlocks = (blocks) => blocks.map((item) => {
+		if (item.type === "table") return cloneTable(item);
+		if (item.type === "blockSdt") return {
+			...structuredClone(item),
+			content: cloneBlocks(item.content)
+		};
+		if (item.type !== "paragraph") return structuredClone(item);
+		const targetParaId = paraIds.mint(item.paraId);
+		const copy = cloneParagraphForTarget(item, targetParaId, styleCloner, cloner, bookmarkIds);
+		if (isTranslatableParagraph(item, editableParagraphIds)) paragraphs.push({
+			sourceParaId: item.paraId,
+			targetParaId,
+			sourceText: getParagraphText(item)
+		});
+		return copy;
+	});
 	const cloneTable = (source) => ({
 		...structuredClone(source),
 		rows: source.rows.map((row) => ({
 			...structuredClone(row),
 			cells: row.cells.map((cell) => ({
 				...structuredClone(cell),
-				content: cell.content.map((item) => {
-					if (item.type === "table") return cloneTable(item);
-					if (item.type !== "paragraph") return structuredClone(item);
-					const targetParaId = paraIds.mint(item.paraId);
-					const copy = cloneParagraphForTarget(item, targetParaId, styleCloner, cloner, bookmarkIds);
-					if (isTranslatableParagraph(item, editableParagraphIds)) paragraphs.push({
-						sourceParaId: item.paraId,
-						targetParaId,
-						sourceText: getParagraphText(item)
-					});
-					return copy;
-				})
+				content: cloneBlocks(cell.content)
 			}))
 		}))
 	});

package/dist/docx/tableParser.js

@@ -766,81 +766,104 @@ function withContainerXmlns(options, element) {
 	};
 }
 function parseCellContent(tcElement, styles, theme, numbering, rels, media, options) {
-	const modelled = [];
-	const captured = [];
-	const dispatchCellChildren = (element, childOptions) => {
-		const preserved = dispatchChildren({
-			element,
-			container: "block-content",
-			capturePosition: () => modelled.length,
-			undeclared: { AlternateContent: (child) => {
-				const selectedBranch = selectAlternateContentBranch(child);
-				if (!selectedBranch) return;
-				dispatchCellChildren(selectedBranch, withContainerXmlns(withContainerXmlns(childOptions, child), selectedBranch));
-			} },
-			handlers: {
-				p: (child) => {
-					const para = parseParagraph(child, styles, theme, numbering, rels, media, {
-						...childOptions,
-						runConsolidation: "deferred"
-					});
-					enrichParagraphTextBoxes(para, child, styles, theme, numbering, rels, media, parseTable);
-					modelled.push(para);
-				},
-				tbl: (child) => {
-					const table = parseTable(child, styles, theme, numbering, rels, media, childOptions);
-					if (!table) return;
-					modelled.push(table);
-				},
-				sdt: (child) => {
-					const sdtContent = findWordprocessingChild(child, "sdtContent");
-					if (!sdtContent) return;
-					dispatchCellChildren(sdtContent, withContainerXmlns(withContainerXmlns(childOptions, child), sdtContent));
-				},
-				bookmarkStart: (child) => {
-					modelled.push(parseBookmarkStart(child));
-				},
-				bookmarkEnd: (child) => {
-					modelled.push(parseBookmarkEnd(child));
-				},
-				tcPr: CELL_PROPERTIES_OWNER,
-				sectPr: CAPTURE,
-				altChunk: CAPTURE,
-				commentRangeEnd: CAPTURE,
-				commentRangeStart: CAPTURE,
-				customXml: CAPTURE,
-				customXmlDelRangeEnd: CAPTURE,
-				customXmlDelRangeStart: CAPTURE,
-				customXmlInsRangeEnd: CAPTURE,
-				customXmlInsRangeStart: CAPTURE,
-				customXmlMoveFromRangeEnd: CAPTURE,
-				customXmlMoveFromRangeStart: CAPTURE,
-				customXmlMoveToRangeEnd: CAPTURE,
-				customXmlMoveToRangeStart: CAPTURE,
-				del: CAPTURE,
-				ins: CAPTURE,
-				moveFrom: CAPTURE,
-				moveFromRangeEnd: CAPTURE,
-				moveFromRangeStart: CAPTURE,
-				moveTo: CAPTURE,
-				moveToRangeEnd: CAPTURE,
-				moveToRangeStart: CAPTURE,
-				permEnd: CAPTURE,
-				permStart: CAPTURE,
-				proofErr: CAPTURE
+	const findLastFlowBlock = (blocks) => {
+		for (let index = blocks.length - 1; index >= 0; index -= 1) {
+			const block = blocks[index];
+			if (block?.type === "paragraph" || block?.type === "table") return block;
+			if (block?.type === "blockSdt") {
+				const nested = findLastFlowBlock(block.content);
+				if (nested) return nested;
 			}
-		});
-		if (preserved?.children) captured.push(...preserved.children);
+		}
 	};
-	dispatchCellChildren(tcElement, options);
-	if (modelled.findLast((block) => block.type === "paragraph" || block.type === "table")?.type !== "paragraph") modelled.push({
-		type: "paragraph",
-		content: []
-	});
-	return withPreservedChildren(modelled, { children: captured }, (xml) => ({
-		type: "preservedBlock",
-		xml
-	}));
+	const parseCellChildren = (element, childOptions, requireTrailingParagraph) => {
+		const modelled = [];
+		const captured = [];
+		const dispatchCellChildren = (childContainer, nestedOptions) => {
+			const preserved = dispatchChildren({
+				element: childContainer,
+				container: "block-content",
+				capturePosition: () => modelled.length,
+				undeclared: { AlternateContent: (child) => {
+					const selectedBranch = selectAlternateContentBranch(child);
+					if (!selectedBranch) return;
+					dispatchCellChildren(selectedBranch, withContainerXmlns(withContainerXmlns(nestedOptions, child), selectedBranch));
+				} },
+				handlers: {
+					p: (child) => {
+						const para = parseParagraph(child, styles, theme, numbering, rels, media, {
+							...nestedOptions,
+							runConsolidation: "deferred"
+						});
+						enrichParagraphTextBoxes(para, child, styles, theme, numbering, rels, media, parseTable);
+						modelled.push(para);
+					},
+					tbl: (child) => {
+						const table = parseTable(child, styles, theme, numbering, rels, media, nestedOptions);
+						if (!table) return;
+						modelled.push(table);
+					},
+					sdt: (child) => {
+						const properties = parseSdtProperties(findWordprocessingChild(child, "sdtPr"), findWordprocessingChild(child, "sdtEndPr"));
+						const siblings = captureSdtSiblingMarkers(child);
+						if (siblings.before.length > 0) properties.rawSdtChildrenBeforeContent = siblings.before;
+						if (siblings.after.length > 0) properties.rawSdtChildrenAfterContent = siblings.after;
+						const sdtContent = findWordprocessingChild(child, "sdtContent");
+						if (!sdtContent) return CAPTURE;
+						modelled.push({
+							type: "blockSdt",
+							properties,
+							content: parseCellChildren(sdtContent, withContainerXmlns(withContainerXmlns(nestedOptions, child), sdtContent), false)
+						});
+					},
+					bookmarkStart: (child) => {
+						modelled.push(parseBookmarkStart(child));
+					},
+					bookmarkEnd: (child) => {
+						modelled.push(parseBookmarkEnd(child));
+					},
+					tcPr: CELL_PROPERTIES_OWNER,
+					sectPr: CAPTURE,
+					altChunk: CAPTURE,
+					commentRangeEnd: CAPTURE,
+					commentRangeStart: CAPTURE,
+					customXml: CAPTURE,
+					customXmlDelRangeEnd: CAPTURE,
+					customXmlDelRangeStart: CAPTURE,
+					customXmlInsRangeEnd: CAPTURE,
+					customXmlInsRangeStart: CAPTURE,
+					customXmlMoveFromRangeEnd: CAPTURE,
+					customXmlMoveFromRangeStart: CAPTURE,
+					customXmlMoveToRangeEnd: CAPTURE,
+					customXmlMoveToRangeStart: CAPTURE,
+					del: CAPTURE,
+					ins: CAPTURE,
+					moveFrom: CAPTURE,
+					moveFromRangeEnd: CAPTURE,
+					moveFromRangeStart: CAPTURE,
+					moveTo: CAPTURE,
+					moveToRangeEnd: CAPTURE,
+					moveToRangeStart: CAPTURE,
+					permEnd: CAPTURE,
+					permStart: CAPTURE,
+					proofErr: CAPTURE
+				}
+			});
+			if (preserved?.children) captured.push(...preserved.children);
+		};
+		dispatchCellChildren(element, childOptions);
+		if (requireTrailingParagraph) {
+			if (findLastFlowBlock(modelled)?.type !== "paragraph") modelled.push({
+				type: "paragraph",
+				content: []
+			});
+		}
+		return withPreservedChildren(modelled, { children: captured }, (xml) => ({
+			type: "preservedBlock",
+			xml
+		}));
+	};
+	return parseCellChildren(tcElement, options, true);
 }
 /**
 * Parse a table cell (w:tc)
@@ -993,12 +1016,15 @@ function parseTableRow(trElement, styles, theme, numbering, rels, media, options
 function parseTableGrid(tblGridElement) {
 	if (!tblGridElement) return;
 	const widths = [];
+	let hasExplicitZero = false;
 	const gridCols = findChildren(tblGridElement, "w", "gridCol");
 	for (const col of gridCols) {
-		const width = parseNumericAttribute(col, "w", "w") ?? 0;
+		const statedWidth = parseNumericAttribute(col, "w", "w");
+		hasExplicitZero ||= statedWidth === 0;
+		const width = statedWidth ?? 0;
 		widths.push(width);
 	}
-	if (widths.length > 0 && widths.every((width) => width <= 0)) return;
+	if (widths.length > 0 && widths.every((width) => width <= 0) && !hasExplicitZero) return;
 	return widths.length > 0 ? widths : void 0;
 }
 /**

package/dist/markdown/renderRuns.js

@@ -165,6 +165,10 @@ function renderTrackedWrapper(ctx, pkg, wrapper, paraId) {
 			case "complexField": return renderParagraphInline(ctx, pkg, [child], paraId);
 			case "bookmarkStart":
 			case "bookmarkEnd":
+			case "moveFromRangeStart":
+			case "moveFromRangeEnd":
+			case "moveToRangeStart":
+			case "moveToRangeEnd":
 			case "preservedInline": return "";
 			default: return child;
 		}

package/dist/markdown/renderTable.js

@@ -17,10 +17,11 @@ function needsHtmlFallback(rows) {
 	for (const row of rows) for (const cell of row.cells) {
 		if ((cell.formatting?.gridSpan ?? 1) > 1) return true;
 		if (cell.formatting?.vMerge) return true;
-		if (cell.content.some((b) => b.type === "table")) return true;
+		if (containsTable(cell.content)) return true;
 	}
 	return false;
 }
+const containsTable = (blocks) => blocks.some((block) => block.type === "table" || block.type === "blockSdt" && containsTable(block.content));
 function renderGfmTable(ctx, pkg, rows, firstRowIsHeader) {
 	const cellTexts = rows.map((row) => renderGfmRow(ctx, pkg, row));
 	let maxCols = 0;
@@ -55,10 +56,24 @@ function renderGfmRow(ctx, pkg, row) {
 }
 function renderGfmCell(ctx, pkg, cell) {
 	const blocks = [];
-	for (const item of cell.content) if (item.type === "paragraph") {
-		const md = renderParagraph(ctx, pkg, item);
-		if (md.trim()) blocks.push(md);
-	}
+	const renderBlocks = (content) => {
+		for (const item of content) switch (item.type) {
+			case "paragraph": {
+				const md = renderParagraph(ctx, pkg, item);
+				if (md.trim()) blocks.push(md);
+				break;
+			}
+			case "blockSdt":
+				renderBlocks(item.content);
+				break;
+			case "table":
+			case "preservedBlock":
+			case "bookmarkStart":
+			case "bookmarkEnd": break;
+			default: return item;
+		}
+	};
+	renderBlocks(cell.content);
 	return escapeTableCell(blocks.join("\n"));
 }
 function renderHtmlTable(ctx, pkg, rows, firstRowIsHeader) {
@@ -111,13 +126,28 @@ function cellAtGridColumn(row, gridCol) {
 }
 function renderHtmlCell(ctx, pkg, cell) {
 	const parts = [];
-	for (const item of cell.content) if (item.type === "paragraph") {
-		const inner = renderHtmlInline(ctx, pkg, item.content, item.paraId);
-		if (inner) parts.push(inner);
-	} else if (item.type === "table") {
-		const nested = renderHtmlTable(ctx, pkg, item.rows, true);
-		if (nested) parts.push(nested);
-	}
+	const renderBlocks = (content) => {
+		for (const item of content) switch (item.type) {
+			case "paragraph": {
+				const inner = renderHtmlInline(ctx, pkg, item.content, item.paraId);
+				if (inner) parts.push(inner);
+				break;
+			}
+			case "table": {
+				const nested = renderHtmlTable(ctx, pkg, item.rows, true);
+				if (nested) parts.push(nested);
+				break;
+			}
+			case "blockSdt":
+				renderBlocks(item.content);
+				break;
+			case "preservedBlock":
+			case "bookmarkStart":
+			case "bookmarkEnd": break;
+			default: return item;
+		}
+	};
+	renderBlocks(cell.content);
 	return parts.join("<br>");
 }
 function escapeHtml(text) {
@@ -175,6 +205,10 @@ function renderHtmlChildren(ctx, pkg, children, paraId) {
 			case "moveTo": return renderHtmlInline(ctx, pkg, [child], paraId);
 			case "bookmarkStart":
 			case "bookmarkEnd":
+			case "moveFromRangeStart":
+			case "moveFromRangeEnd":
+			case "moveToRangeStart":
+			case "moveToRangeEnd":
 			case "preservedInline": return "";
 			default: return child;
 		}

package/dist/prosemirror/attrs/index.js

@@ -868,6 +868,11 @@ const taggedLayerValidator = (label) => (layer, path, issues) => {
 		path: `${path}.${key}`,
 		message: "Expected a string."
 	});
+	const propertiesXml = layer["propertiesXml"];
+	if (typeof propertiesXml === "string" && !isSafePreservedChildXml(propertiesXml)) issues.push({
+		path: `${path}.propertiesXml`,
+		message: "Expected one bounded, well-formed XML element."
+	});
 	for (const key of Object.keys(layer)) if (!TAGGED_LAYER_KEYS.has(key)) issues.push({
 		path: `${path}.${key}`,
 		message: `Unexpected ${label} wrapper property.`
@@ -894,6 +899,19 @@ const INLINE_WRAPPER_LAYER_VALIDATORS = {
 const inlineWrapperLayerValidator = (kind) => {
 	return typeof kind === "string" ? INLINE_WRAPPER_LAYER_VALIDATORS[kind] : void 0;
 };
+const inlineWrapperProperties = function* (layers) {
+	for (let index = 0; index < layers.length; index += 1) {
+		const layer = layers[index];
+		yield { xml: isRecord(layer) && typeof layer["propertiesXml"] === "string" ? layer["propertiesXml"] : "" };
+	}
+};
+const emptyHyperlinkWrapperProperties = function* (stacks) {
+	for (let stackIndex = 0; stackIndex < stacks.length; stackIndex += 1) {
+		const stack = stacks[stackIndex];
+		yield {};
+		if (Array.isArray(stack)) yield* inlineWrapperProperties(stack);
+	}
+};
 const validateInlineWrapperStack = (value, path, issues) => {
 	if (!Array.isArray(value)) {
 		issues.push({
@@ -909,6 +927,13 @@ const validateInlineWrapperStack = (value, path, issues) => {
 		});
 		return;
 	}
+	if (!isWithinPreservedMarkupBudget(inlineWrapperProperties(value))) {
+		issues.push({
+			path,
+			message: "Inline wrapper stack exceeds its resource budget."
+		});
+		return;
+	}
 	for (const [index, layer] of value.entries()) {
 		const layerPath = `${path}[${index}]`;
 		if (!isRecord(layer)) {
@@ -950,6 +975,22 @@ const readInlineWrapperMarkAttrs = (mark) => {
 	const issues = [];
 	expectMarkType(mark, "inlineWrapper", issues);
 	validateInlineWrapperStack(attrs["stack"], "inlineWrapper.attrs.stack", issues);
+	const hyperlinkIndex = attrs["_docxHyperlinkIndex"];
+	const stackStart = attrs["_docxInsideHyperlinkStackStart"];
+	const hasHyperlinkIndex = hyperlinkIndex !== void 0 && hyperlinkIndex !== null;
+	const hasStackStart = stackStart !== void 0 && stackStart !== null;
+	if (hasHyperlinkIndex !== hasStackStart) issues.push({
+		path: "inlineWrapper.attrs",
+		message: "Hyperlink wrapper provenance requires both an index and stack start."
+	});
+	else if (hasHyperlinkIndex && hasStackStart) {
+		validateNonNegativeInteger(hyperlinkIndex, "inlineWrapper.attrs._docxHyperlinkIndex", issues);
+		validateNonNegativeInteger(stackStart, "inlineWrapper.attrs._docxInsideHyperlinkStackStart", issues);
+		if (typeof stackStart === "number" && Array.isArray(attrs["stack"]) && stackStart >= attrs["stack"].length) issues.push({
+			path: "inlineWrapper.attrs._docxInsideHyperlinkStackStart",
+			message: "Expected a stack position inside the wrapper stack."
+		});
+	}
 	return attrsResult(attrs, issues);
 };
 const expectInlineWrapperMarkAttrs = (mark) => expectCachedMarkAttrs(mark, inlineWrapperAttrsCache, readInlineWrapperMarkAttrs, "inline wrapper attrs");
@@ -1745,7 +1786,7 @@ const optionalPositionedBookmarks = (attrs, path, issues) => {
 			});
 			continue;
 		}
-		requiredNumber(entry, "index", `${entryPath}.index`, issues);
+		validateNonNegativeSafeInteger(entry["index"], `${entryPath}.index`, issues);
 		const marker = entry["marker"];
 		if (!isRecord(marker)) {
 			issues.push({
@@ -1762,7 +1803,7 @@ const optionalPositionedBookmarks = (attrs, path, issues) => {
 			});
 			continue;
 		}
-		requiredNumber(marker, "id", `${entryPath}.marker.id`, issues);
+		validateNonNegativeSafeInteger(marker["id"], `${entryPath}.marker.id`, issues);
 		if (type === "bookmarkStart") requiredString(marker, "name", `${entryPath}.marker.name`, issues);
 		optionalContentControls(entry, `${entryPath}.contentControls`, issues);
 	}
@@ -2574,11 +2615,17 @@ const validateNonNegativeInteger = (value, path, issues) => {
 		});
 		return;
 	}
-	if (!Number.isInteger(value) || value < 0) issues.push({
+	if (!Number.isSafeInteger(value) || value < 0) issues.push({
 		path,
 		message: "Expected a non-negative integer."
 	});
 };
+const validateNonNegativeSafeInteger = (value, path, issues) => {
+	if (typeof value !== "number" || !Number.isSafeInteger(value) || value < 0) issues.push({
+		path,
+		message: "Expected a non-negative safe integer."
+	});
+};
 const optionalBookmarkArray = (value, issues) => {
 	if (value === void 0 || value === null) return;
 	if (!Array.isArray(value)) {
@@ -2633,6 +2680,23 @@ const optionalEmptyHyperlinkArray = (value, issues) => {
 		optionalString(item, "target", `${itemPath}.target`, issues);
 		optionalBoolean(item, "history", `${itemPath}.history`, issues);
 		optionalString(item, "docLocation", `${itemPath}.docLocation`, issues);
+		const wrapperStacks = item["_docxEmptyWrapperStacks"];
+		if (wrapperStacks === void 0 || wrapperStacks === null) continue;
+		if (!Array.isArray(wrapperStacks)) {
+			issues.push({
+				path: `${itemPath}._docxEmptyWrapperStacks`,
+				message: "Expected an array of inline wrapper stacks."
+			});
+			continue;
+		}
+		if (!isWithinPreservedMarkupBudget(emptyHyperlinkWrapperProperties(wrapperStacks))) {
+			issues.push({
+				path: `${itemPath}._docxEmptyWrapperStacks`,
+				message: "Empty inline wrapper stacks exceed their aggregate resource budget."
+			});
+			continue;
+		}
+		for (const [stackIndex, stack] of wrapperStacks.entries()) validateInlineWrapperStack(stack, `${itemPath}._docxEmptyWrapperStacks[${stackIndex}]`, issues);
 	}
 };
 //#endregion

package/dist/prosemirror/commentReferenceAttrs.js

@@ -8,9 +8,9 @@ const readCommentReferenceAttrs = (node) => {
 		message: `Expected commentReference, got ${node.type.name}.`
 	});
 	const commentId = node.attrs["commentId"];
-	if (typeof commentId !== "number" || !Number.isInteger(commentId) || commentId < 0) issues.push({
+	if (typeof commentId !== "number" || !Number.isSafeInteger(commentId)) issues.push({
 		path: "commentReference.attrs.commentId",
-		message: "Expected a non-negative integer."
+		message: "Expected a safe integer."
 	});
 	if (issues.length > 0 || typeof commentId !== "number") return {
 		ok: false,

package/dist/prosemirror/commentReferenceIntegrity.d.ts

@@ -10,13 +10,17 @@
  * a comment mark creates none — so the repair is computed here and applied by
  * the extension's `appendTransaction`, rather than left to each call site.
  */
-type CommentReferenceOccurrence = {
-  commentId: number;
+type PositionedReference = {
   position: number;
   /** Node size, so a caller can delete the node without re-reading it. */
   size: number;
-  malformed: boolean;
 };
+type CommentReferenceOccurrence = (PositionedReference & {
+  status: "valid";
+  commentId: number;
+}) | (PositionedReference & {
+  status: "malformed";
+});
 /** Where a comment's mark last covers content, and how far that content runs. */
 type CommentMarkExtent = {
   commentId: number;

package/dist/prosemirror/commentReferenceIntegrity.js

@@ -10,7 +10,15 @@ const planCommentReferenceRepairs = ({ references, markExtents }) => {
 	const deletions = [];
 	const keptIds = /* @__PURE__ */ new Set();
 	for (const reference of references) {
-		if (reference.malformed || !markedIds.has(reference.commentId)) {
+		if (reference.status === "malformed") {
+			deletions.push({
+				type: "delete",
+				position: reference.position,
+				size: reference.size
+			});
+			continue;
+		}
+		if (!markedIds.has(reference.commentId)) {
 			deletions.push({
 				type: "delete",
 				position: reference.position,