@stll/folio-core 0.46.0 → 0.47.0

package/dist/prosemirror/bookmarkBoundaryAttrs.d.ts

@@ -12,7 +12,15 @@ declare const isDisplacedByCustomXml: (value: unknown) => value is document_d_ex
 declare const bookmarkBoundaryDisplacement: (attrs: BookmarkBoundaryAttrs) => {
   displacedByCustomXml?: document_d_exports.DisplacedByCustomXml;
 };
+/**
+ * The model marker a boundary node carries, at either level.
+ *
+ * A paragraph, a hyperlink, a revision wrapper and a block container each
+ * rebuild the same two elements from the same attributes; spelling that out
+ * per caller is how one of them comes to forget `w:colFirst`.
+ */
+declare const bookmarkMarkerFromAttrs: (attrs: BookmarkBoundaryAttrs) => document_d_exports.BookmarkStart | document_d_exports.BookmarkEnd;
 declare const readBookmarkBoundaryAttrs: (node: Node) => ReadProseMirrorAttrsResult<BookmarkBoundaryAttrs>;
 declare const expectBookmarkBoundaryAttrs: (node: Node) => BookmarkBoundaryAttrs;
 //#endregion
-export { bookmarkBoundaryDisplacement, expectBookmarkBoundaryAttrs, isDisplacedByCustomXml, readBookmarkBoundaryAttrs };
+export { bookmarkBoundaryDisplacement, bookmarkMarkerFromAttrs, expectBookmarkBoundaryAttrs, isDisplacedByCustomXml, readBookmarkBoundaryAttrs };

package/dist/prosemirror/bookmarkBoundaryAttrs.js

@@ -8,11 +8,30 @@ const attrsCache = /* @__PURE__ */ new WeakMap();
 * that build either one share this rather than each remembering the attribute.
 */
 const bookmarkBoundaryDisplacement = (attrs) => attrs.displacedByCustomXml === void 0 ? {} : { displacedByCustomXml: attrs.displacedByCustomXml };
+/**
+* The model marker a boundary node carries, at either level.
+*
+* A paragraph, a hyperlink, a revision wrapper and a block container each
+* rebuild the same two elements from the same attributes; spelling that out
+* per caller is how one of them comes to forget `w:colFirst`.
+*/
+const bookmarkMarkerFromAttrs = (attrs) => attrs.type === "start" ? {
+	type: "bookmarkStart",
+	id: attrs.id,
+	name: attrs.name,
+	...attrs.colFirst !== void 0 ? { colFirst: attrs.colFirst } : {},
+	...attrs.colLast !== void 0 ? { colLast: attrs.colLast } : {},
+	...bookmarkBoundaryDisplacement(attrs)
+} : {
+	type: "bookmarkEnd",
+	id: attrs.id,
+	...bookmarkBoundaryDisplacement(attrs)
+};
 const readBookmarkBoundaryAttrs = (node) => {
 	const issues = [];
-	if (node.type.name !== "bookmarkBoundary") issues.push({
+	if (node.type.name !== "bookmarkBoundary" && node.type.name !== "blockBookmarkBoundary") issues.push({
 		path: "bookmarkBoundary.type.name",
-		message: `Expected bookmarkBoundary, got ${node.type.name}.`
+		message: `Expected a bookmark boundary, got ${node.type.name}.`
 	});
 	const type = node.attrs["type"];
 	if (type !== "start" && type !== "end") issues.push({
@@ -78,4 +97,4 @@ const expectBookmarkBoundaryAttrs = (node) => {
 	return result.value;
 };
 //#endregion
-export { bookmarkBoundaryDisplacement, expectBookmarkBoundaryAttrs, isDisplacedByCustomXml, readBookmarkBoundaryAttrs };
+export { bookmarkBoundaryDisplacement, bookmarkMarkerFromAttrs, expectBookmarkBoundaryAttrs, isDisplacedByCustomXml, readBookmarkBoundaryAttrs };

package/dist/prosemirror/commands/comments.js

@@ -1,3 +1,4 @@
+import { sameStatedParagraphNumbering as sameStatedParagraphNumbering$1 } from "../../docx/numberingReference.js";
 import { joinProseParagraphsWithRightPropertySource } from "../../docx/paragraphPropertySource.js";
 import { appendHeadlessInlineResolution } from "../../internal/headlessRevisionResolution.js";
 import { stateAllowsHeadlessRevisionResolution } from "../../internal/headlessRevisionResolutionGuard.js";
@@ -5,9 +6,10 @@ import { expectParagraphAttrs, expectRunPropertyChangeMarkAttrs } from "../attrs
 import { addedBreakCarrierBefore, finalParagraphsOf, paragraphEndsItsContainer } from "../containerFinalParagraph.js";
 import { resolveParagraphDefaultTextFormatting } from "../conversion/toProseDoc.js";
 import { markChangedParagraphRanges, markStructuralChange, markTrackedSectionEndpointRemoval } from "../extensions/features/ParagraphChangeTrackerExtension.js";
+import "../extensions/nodes/SdtExtension.js";
 import { getDocumentStyleResolver } from "../plugins/documentStyles.js";
 import { setParagraphAttrsWithRebasedRunFormatting } from "../rebaseParagraphRunFormatting.js";
-import { getFolioNodeRevisionCarriers } from "../revisionCarriers.js";
+import { getFolioNodeRevisionCarriers, nodePropertyRevisionSites, propertyRevisionMetadata, propertyRevisionRecords } from "../revisionCarriers.js";
 import { RUN_FORMATTING_MARK_NAMES } from "../runFormattingMarkNames.js";
 import { reconstructRejectedRunFormattingMarks } from "../runPropertyChangeResolution.js";
 import { paragraphRunStyleContextAt } from "../runStyleFormatting.js";
@@ -15,11 +17,11 @@ import { getTableCellMergeChange } from "../tableCellMergeRevision.js";
 import { isTableCellRetainedInReviewView } from "../tableCellRevisionVisibility.js";
 import { reconcileTableGridAfterColumnRemoval } from "../tableGridMutation.js";
 import { holdsNoContent } from "../zeroWidthAnchors.js";
-import { hasSerializableParagraphPropertyChange, paragraphPropertiesSnapshot, paragraphRejectAttrPatch, paragraphRejectOriginalFormatting, removeParagraphPropertyChanges, sectionRejectProperties, tableCellRejectAttrPatch, tableRejectAttrPatch, tableRowRejectAttrPatch } from "./propertyChangeScope.js";
+import { hasSerializableParagraphPropertyChange, paragraphPropertiesSnapshot, paragraphRejectAttrPatch, paragraphRejectOriginalFormatting, removeParagraphPropertyChanges, sectionRejectProperties, tableCellRejectAttrPatch, tablePropertyExceptionsRejectAttrPatch, tableRejectAttrPatch, tableRowRejectAttrPatch } from "./propertyChangeScope.js";
 import { hasMatchingCollapsedTableCellMerge, resolveCollapsedTableCellMerge, resolveVisibleTableCellMerge } from "./tableCellMergeResolution.js";
+import { PARAGRAPH_MARK_CHANGE_KINDS, REVIEW_CARRIERS } from "@stll/docx-core/model";
 import { TableMap, removeRow } from "prosemirror-tables";
 import { Mapping } from "prosemirror-transform";
-import { PARAGRAPH_MARK_CHANGE_KINDS, REVIEW_CARRIERS } from "@stll/docx-core/model";
 //#region src/prosemirror/commands/comments.ts
 /**
 * Add a comment mark to the current selection.
@@ -131,7 +133,6 @@ function resolveChange(from, to, mode, revisionIds, execution = "legacy") {
 							if (remaining.length > 0) restored.propertyChanges = remaining;
 							nextAttrs = nextAttrs ?? { ...node.attrs };
 							nextAttrs["_sectionProperties"] = restored;
-							nextAttrs["sectionBreakType"] = sectionBreakTypeFromSectionStart(restored.sectionStart);
 						}
 					}
 					if (nextAttrs) if (nextAttrs["styleId"] !== node.attrs["styleId"] && styleResolver) setParagraphAttrsWithRebasedRunFormatting({
@@ -153,10 +154,10 @@ function resolveChange(from, to, mode, revisionIds, execution = "legacy") {
 					if (op) tableRowStructuralOps.push(op);
 				}
 				if ((node.type.name === "tableCell" || node.type.name === "tableHeader") && rangeCoversNode(from, to, pos, node)) tableCellStructuralOps.push(...collectTableCellStructuralOps(node, pos, mode, revisionSet));
-				const tableChangeAttrName = TABLE_PROPERTY_CHANGE_ATTR_BY_NODE[node.type.name];
-				if (tableChangeAttrName !== void 0) {
-					if (rangeCoversNode(from, to, pos, node)) {
-						const nextAttrs = resolveTablePropertyChangeAttrs(node, tableChangeAttrName, mode, revisionSet);
+				const nodeAttrSites = nodePropertyRevisionSites(node.type.name).filter((site) => site.resolution === "node-attrs");
+				if (nodeAttrSites.length > 0) {
+					if (rangeCoversNode(from, to, pos, node)) for (const site of nodeAttrSites) {
+						const nextAttrs = resolveNodePropertyChangeAttrs(tr.doc.nodeAt(pos) ?? node, site, mode, revisionSet);
 						if (nextAttrs) {
 							tr.setNodeMarkup(pos, void 0, nextAttrs);
 							markStructuralChange(tr);
@@ -169,6 +170,13 @@ function resolveChange(from, to, mode, revisionIds, execution = "legacy") {
 				const nodeEnd = pos + node.nodeSize;
 				const rangeFrom = Math.max(from, pos);
 				const rangeTo = Math.min(to, nodeEnd);
+				if (node.type.name === "sdt" && removeType !== void 0 && rangeCoversNode(from, to, pos, node) && revisionCoversWholeControl(node, removeType, matchesRevision)) {
+					deleteRanges.push({
+						from: pos,
+						to: nodeEnd
+					});
+					return false;
+				}
 				const runPropertyChangeMark = node.marks.find((mark) => mark.type.name === "runPropertyChange");
 				const removesNode = removeType !== void 0 && node.marks.some((mark) => mark.type === removeType && matchesRevision(mark));
 				if (runPropertyChangeMark) resolveRunPropertyChange({
@@ -248,7 +256,6 @@ function resolveChange(from, to, mode, revisionIds, execution = "legacy") {
 				const joinedAttrs = {
 					...(emptyFirstParagraph ? nextNode : paragraph).attrs,
 					pPrMark: nextNode.attrs["pPrMark"],
-					sectionBreakType: nextNode.attrs["sectionBreakType"],
 					_sectionProperties: nextNode.attrs["_sectionProperties"]
 				};
 				try {
@@ -554,42 +561,64 @@ function rangeCoversParagraphBoundary(from, to, pos, node) {
 function rangeCoversNode(from, to, pos, node) {
 	return from <= pos && to >= pos + node.nodeSize;
 }
-const SECTION_BREAK_TYPE_VALUES = [
-	"nextPage",
-	"continuous",
-	"oddPage",
-	"evenPage"
-];
-function sectionBreakTypeFromSectionStart(sectionStart) {
-	return SECTION_BREAK_TYPE_VALUES.find((value) => value === sectionStart) ?? null;
+/**
+* Whether a revision covers everything an inline content control holds.
+*
+* The save leg writes such a revision around the control (`w:ins > w:sdt`),
+* so resolving it is an operation over the control itself: a reader who
+* rejects an inserted control gets no control, not an empty one standing
+* where it was. A revision over part of the content is a revision over that
+* part, and a control that holds nothing is covered by nothing.
+*/
+function revisionCoversWholeControl(node, removeType, matchesRevision) {
+	if (node.childCount === 0) return false;
+	for (let index = 0; index < node.childCount; index += 1) {
+		const child = node.child(index);
+		if (child.marks.some((mark) => mark.type === removeType && matchesRevision(mark))) continue;
+		if (child.type.name !== "sdt" || !revisionCoversWholeControl(child, removeType, matchesRevision)) return false;
+	}
+	return true;
 }
-/** PM node type name → the attr its tracked property-change records live on. */
-const TABLE_PROPERTY_CHANGE_ATTR_BY_NODE = {
-	table: "tblPrChange",
-	tableRow: "trPrChange",
-	tableCell: "tcPrChange",
-	tableHeader: "tcPrChange"
+/**
+* The attrs a reject restores for each property revision the shared node-attr
+* pass owns. Total over those kinds, so a revision the model gains either
+* declares a different resolution or states here what rejecting it restores.
+*
+* Each patch narrows the stored set to the property set its own element
+* carries. The casts are the ProseMirror attrs boundary: attrs are untyped,
+* and a record reached through the site filed under a kind is the one that
+* kind's parser and converter wrote.
+*/
+const NODE_ATTRS_REJECT_PATCHES = {
+	tablePropertyChange: (previousFormatting) => tableRejectAttrPatch(previousFormatting),
+	tablePropertyExceptionChange: (previousFormatting) => tablePropertyExceptionsRejectAttrPatch(previousFormatting),
+	tableRowPropertyChange: (previousFormatting) => tableRowRejectAttrPatch(previousFormatting),
+	tableCellPropertyChange: (previousFormatting, node) => tableCellRejectAttrPatch(previousFormatting, node.attrs["_originalFormatting"])
 };
 /**
-* Resolve the tracked property-change records on one table / row / cell node.
+* Resolve the tracked property-change records one site carries on a node.
 * Accept keeps the live formatting and clears the matched records; reject
 * additionally restores the stored previous formatting wholesale (the change
 * element stores the complete old property set — see propertyChangeScope.ts).
 * Returns the next attrs, or `null` when no record matches.
 */
-function resolveTablePropertyChangeAttrs(node, attrName, mode, revisionSet) {
-	const changes = node.attrs[attrName];
-	if (!Array.isArray(changes) || changes.length === 0) return null;
-	const matches = changes.filter((c) => revisionSet === null || c.info && revisionSet.has(c.info.id));
+function resolveNodePropertyChangeAttrs(node, site, mode, revisionSet) {
+	const changes = propertyRevisionRecords(node, site);
+	if (changes.length === 0) return null;
+	const matches = changes.filter((change) => {
+		const metadata = propertyRevisionMetadata(change.info);
+		return revisionSet === null || metadata !== null && revisionSet.has(metadata.id);
+	});
 	if (matches.length === 0) return null;
-	const remaining = changes.filter((c) => revisionSet !== null && (!c.info || !revisionSet.has(c.info.id)));
+	const remaining = revisionSet === null ? [] : changes.filter((change) => !matches.includes(change));
 	const nextAttrs = {
 		...node.attrs,
-		[attrName]: remaining.length > 0 ? remaining : null
+		[site.attr]: remaining.length > 0 ? remaining : null
 	};
-	if (mode === "reject") for (const change of matches.toReversed()) if (attrName === "tblPrChange") Object.assign(nextAttrs, tableRejectAttrPatch(change.previousFormatting));
-	else if (attrName === "trPrChange") Object.assign(nextAttrs, tableRowRejectAttrPatch(change.previousFormatting));
-	else Object.assign(nextAttrs, tableCellRejectAttrPatch(change.previousFormatting, node.attrs["_originalFormatting"]));
+	if (mode === "reject") {
+		const rejectPatch = NODE_ATTRS_REJECT_PATCHES[site.kind];
+		for (const change of matches.toReversed()) Object.assign(nextAttrs, rejectPatch(change.previousFormatting, node));
+	}
 	return nextAttrs;
 }
 function isPPrMarkAttr(value) {
@@ -607,10 +636,7 @@ function isPPrMarkAttr(value) {
 * the two ends belong together, not because they resolve differently.
 */
 const paragraphMarkWasAdded = (kind) => kind === "ins" || kind === "moveTo";
-const ownsSectionEndpoint = (paragraph) => {
-	const attrs = expectParagraphAttrs(paragraph);
-	return attrs._sectionProperties !== void 0 || attrs.sectionBreakType !== void 0;
-};
+const ownsSectionEndpoint = (paragraph) => expectParagraphAttrs(paragraph)._sectionProperties !== void 0;
 const sectionReferencesOf = (paragraph) => {
 	const sectionProperties = expectParagraphAttrs(paragraph)._sectionProperties;
 	if (!sectionProperties) return [];
@@ -632,23 +658,12 @@ function readRevisionInfo(info) {
 	if (typeof info?.id === "number") revision.revisionId = info.id;
 	return revision;
 }
-function getListPropertyChangeType(attrs, change) {
+function getListPropertyChangeType(node, change) {
 	const previousFormatting = change.previousFormatting;
 	if (previousFormatting == null || !Object.hasOwn(previousFormatting, "numPr")) return null;
-	const currentNumPr = attrs["numPr"];
-	const previousNumPr = previousFormatting["numPr"];
-	if (previousNumPr == null && currentNumPr != null) return "insertion";
-	if (previousNumPr != null && currentNumPr == null) return "deletion";
-	if (!areNumPrValuesEqual(previousNumPr, currentNumPr)) return currentNumPr == null ? "deletion" : "insertion";
-	return null;
-}
-function areNumPrValuesEqual(left, right) {
-	if (left == null || right == null) return left == right;
-	if (!isObjectRecord(left) || !isObjectRecord(right)) return Object.is(left, right);
-	return left["numId"] === right["numId"] && left["ilvl"] === right["ilvl"];
-}
-function isObjectRecord(value) {
-	return typeof value === "object" && value !== null;
+	const current = expectParagraphAttrs(node).numPr;
+	if (sameStatedParagraphNumbering$1(previousFormatting["numPr"] ?? void 0, current)) return null;
+	return current === void 0 ? "deletion" : "insertion";
 }
 function toParagraphBoundaryChange(node, pos, type, info) {
 	return {
@@ -668,7 +683,7 @@ function findParagraphBoundaryChangeAtPosition(state, pos) {
 	const propertyChanges = expectParagraphAttrs(node)._propertyChanges;
 	if (!Array.isArray(propertyChanges)) return null;
 	for (const change of propertyChanges) {
-		const type = getListPropertyChangeType(node.attrs, change);
+		const type = getListPropertyChangeType(node, change);
 		if (type) return toParagraphBoundaryChange(node, paragraphPos, type, change.info);
 	}
 	return null;

package/dist/prosemirror/commands/contentControls.js

@@ -1,6 +1,7 @@
 import { checkboxDisplayContent } from "../../content-controls/checkboxDisplay.js";
 import { ContentControlBoundError, ContentControlLockedError, ContentControlTypeError } from "../../content-controls/errors.js";
 import { formatDate } from "../../docx/fieldParser.js";
+import { preservedSdtChild, withoutPreservedSdtChild } from "../../docx/sdtProperties.js";
 import { expectBlockSdtAttrs } from "../attrs/index.js";
 import { SUGGESTION_BYPASS_META } from "../plugins/suggestionMode.js";
 //#region src/prosemirror/commands/contentControls.ts
@@ -112,19 +113,26 @@ function ensureSdtNotLocked(node, options) {
 	const lock = node.attrs["lock"];
 	if (lock === "sdtLocked" || lock === "sdtContentLocked") throwLockedNode(node, lock);
 }
-const DATA_BINDING_RE = /<\w+:dataBinding\b(?<attrs>[^>]*)\/?>/iu;
 /**
-* Refuse content mutations on bound SDTs unless force; on force, return
-* the stripped rawPropertiesXml so the caller can persist it on the new
-* node attrs. Mirrors the headless `ensureContentNotBound` helper.
+* The control's preserved `w:sdtPr` children, off the node's attrs.
+*
+* `readBlockSdtAttrs` validates the shape at the document boundary, so this
+* is the same record the model carries rather than a second parse of it.
+*/
+const preservedOf = (node) => {
+	const value = node.attrs["_preserved"];
+	return value === null || value === void 0 ? void 0 : value;
+};
+/**
+* Refuse content mutations on bound SDTs unless force; on force, return the
+* attrs override that drops the `w:dataBinding` child, so the caller can
+* persist it on the new node. Mirrors the headless `ensureContentNotBound`.
 */
 function ensureContentNotBound(node, options) {
-	const raw = node.attrs["rawPropertiesXml"];
-	if (typeof raw !== "string") return { strippedRawPropertiesXml: void 0 };
-	const match = DATA_BINDING_RE.exec(raw);
-	if (!match) return { strippedRawPropertiesXml: void 0 };
+	const preserved = preservedOf(node);
+	const attrs = preservedSdtChild(preserved, "dataBinding");
+	if (attrs === void 0) return {};
 	if (!options.force) {
-		const attrs = match.groups?.["attrs"] ?? "";
 		const xpathMatch = /\bxpath="(?<xpath>[^"]*)"/iu.exec(attrs);
 		const storeMatch = /\bstoreItemID="(?<storeItemID>[^"]*)"/iu.exec(attrs);
 		const props = attrsToProperties(node);
@@ -136,7 +144,7 @@ function ensureContentNotBound(node, options) {
 			...props.alias !== void 0 ? { alias: props.alias } : {}
 		});
 	}
-	return { strippedRawPropertiesXml: raw.replaceAll(/<\w+:dataBinding\b[^>]*\/?>(?:[\s\S]*?<\/\w+:dataBinding>)?/giu, "") };
+	return { _preserved: withoutPreservedSdtChild(preserved, "dataBinding") ?? null };
 }
 function paragraphFromText(schema, text) {
 	if (text.length === 0) return schema.node("paragraph", {}, []);
@@ -158,13 +166,13 @@ function setContentControlContentTr(state, filter, input, options = {}) {
 	const match = findBlockSdtMatch(state.doc, filter);
 	if (!match) return null;
 	ensureContentNotLocked(match.node, options);
-	const { strippedRawPropertiesXml } = ensureContentNotBound(match.node, options);
+	const bindingOverride = ensureContentNotBound(match.node, options);
 	if (typeof input !== "string") throw new ContentControlTypeError({
 		message: "Block-content fill must go through `setContentControlContentBlocksTr` (avoids a schema/plugin import cycle); pass a string here.",
 		sdtType: match.node.attrs["sdtType"] ?? "richText",
 		reason: "PM-direct path takes string input only"
 	});
-	return replaceBlockSdtChildren(state, match, [paragraphFromText(state.schema, input)], strippedRawPropertiesXml !== void 0 ? { rawPropertiesXml: strippedRawPropertiesXml } : {});
+	return replaceBlockSdtChildren(state, match, [paragraphFromText(state.schema, input)], bindingOverride);
 }
 /**
 * Internal helper for the block-content fill variant. Lives in this module
@@ -176,15 +184,13 @@ function replaceBlockSdtChildrenForFill(state, filter, children, options = {}) {
 	const match = findBlockSdtMatch(state.doc, filter);
 	if (!match) return null;
 	ensureContentNotLocked(match.node, options);
-	const { strippedRawPropertiesXml } = ensureContentNotBound(match.node, options);
-	return replaceBlockSdtChildren(state, match, children, strippedRawPropertiesXml !== void 0 ? { rawPropertiesXml: strippedRawPropertiesXml } : {});
+	return replaceBlockSdtChildren(state, match, children, ensureContentNotBound(match.node, options));
 }
 function setContentControlValueTr(state, filter, input, options = {}) {
 	const match = findBlockSdtMatch(state.doc, filter);
 	if (!match) return null;
 	ensureContentNotLocked(match.node, options);
-	const { strippedRawPropertiesXml } = ensureContentNotBound(match.node, options);
-	const bindingOverride = strippedRawPropertiesXml !== void 0 ? { rawPropertiesXml: strippedRawPropertiesXml } : {};
+	const bindingOverride = ensureContentNotBound(match.node, options);
 	const sdtType = match.node.attrs["sdtType"];
 	if (input.kind === "dropdown") {
 		if (sdtType !== "dropdown" && sdtType !== "comboBox") throw new ContentControlTypeError({
@@ -221,7 +227,7 @@ function setContentControlValueTr(state, filter, input, options = {}) {
 			sdtType,
 			reason: "kind=checkbox requires sdtType=checkbox"
 		});
-		const display = checkboxDisplayContent(typeof match.node.attrs["rawPropertiesXml"] === "string" ? match.node.attrs["rawPropertiesXml"] : void 0, input.checked);
+		const display = checkboxDisplayContent(preservedSdtChild(preservedOf(match.node), "checkbox"), input.checked);
 		let content = display.type === "symbol" ? state.schema.node("symbol", {
 			font: display.font,
 			char: display.char
@@ -278,8 +284,7 @@ function parseSdtDate(iso) {
 	return Number.isNaN(parsed.getTime()) ? null : parsed;
 }
 function isRepeatingSection(node) {
-	const raw = node.attrs["rawPropertiesXml"];
-	return typeof raw === "string" && /<\w+:repeatingSection\b/u.test(raw);
+	return preservedSdtChild(preservedOf(node), "repeatingSection") !== void 0;
 }
 function removeContentControlTr(state, filter, options = {}) {
 	const match = findBlockSdtMatch(state.doc, filter);

package/dist/prosemirror/commands/image.d.ts

@@ -26,7 +26,7 @@ type ImagePropertiesInput = {
 };
 type ImageTransformAction = "rotateCW" | "rotateCCW" | "flipH" | "flipV";
 type ResolvedImageWrap = {
-  wrapType: ImageAttrs["wrapType"];
+  wrapType: NonNullable<ImageAttrs["wrapType"]>;
   displayMode: ImageAttrs["displayMode"];
   cssFloat: ImageAttrs["cssFloat"];
 };

package/dist/prosemirror/commands/image.js

@@ -1,4 +1,5 @@
 import { FOLIO_INSERTED_PICTURE_FRAME_LOCKS } from "../../docx/graphicFrameLocks.js";
+import { wrapPolygonFor } from "../../docx/wrapPolygon.js";
 import { IMAGE_HORIZONTAL_ALIGNMENT_VALUES, IMAGE_HORIZONTAL_RELATIVE_TO_VALUES, IMAGE_VERTICAL_ALIGNMENT_VALUES, IMAGE_VERTICAL_RELATIVE_TO_VALUES } from "../../types/documentEnumValues.js";
 import { isSafeImageFile } from "../../utils/imageValidation.js";
 import { sanitizeImageSrc } from "../../utils/sanitizeImageSrc.js";
@@ -128,10 +129,12 @@ const applyImageWrapType = (view, pos, wrapType) => {
 	if (!node) return false;
 	const resolved = resolveImageWrap(wrapType);
 	if (!resolved) return false;
+	const authoredPolygon = expectImageAttrs(node).wrapPolygon;
 	const tr = view.state.tr.setNodeMarkup(pos, void 0, mergeImageAttrs(node, {
 		wrapType: resolved.wrapType,
 		displayMode: resolved.displayMode,
-		cssFloat: resolved.cssFloat
+		cssFloat: resolved.cssFloat,
+		wrapPolygon: wrapPolygonFor(resolved.wrapType, authoredPolygon) ?? authoredPolygon
 	}));
 	view.dispatch(tr.scrollIntoView());
 	return true;

package/dist/prosemirror/commands/paragraph.d.ts

@@ -1,4 +1,5 @@
 import { document_d_exports } from "../../types/document.js";
+import { SectionBreakType } from "../sectionCarrier.js";
 import { GenerateTableOfContentsOptions, ResolvedStyleAttrs, getParagraphAlignment, getParagraphBidi, getParagraphTabs, getStyleId } from "../extensions/core/ParagraphExtension.js";
 import { getListInfo, isInList } from "../extensions/features/ListExtension.js";
 import { Command } from "prosemirror-state";
@@ -26,7 +27,7 @@ declare function setSpaceBefore(twips: number): Command;
 declare function setSpaceAfter(twips: number): Command;
 declare function applyStyle(styleId: string, resolvedAttrs?: ResolvedStyleAttrs): Command;
 declare const clearStyle: Command;
-declare function insertSectionBreak(breakType: "nextPage" | "continuous" | "oddPage" | "evenPage"): Command;
+declare function insertSectionBreak(breakType: SectionBreakType): Command;
 declare const removeSectionBreak: Command;
 declare function addTabStop(position: number, alignment?: document_d_exports.TabStopAlignment, leader?: document_d_exports.TabLeader): Command;
 declare function removeTabStop(position: number): Command;

package/dist/prosemirror/commands/propertyChangeScope.d.ts

@@ -32,9 +32,9 @@ declare const removeParagraphPropertyChanges: (changes: readonly ParagraphProper
  * stored record resets to the schema default (`null`).
  *
  * Deliberately OUT of scope (preserved across a reject):
- * - identity/structure: `paraId`, `textId`, `sectionBreakType`,
- *   `_sectionProperties`, `_propertyChanges`, `pPrMark`, `bookmarks`,
- *   `_emptyHyperlinks`, `renderedPageBreakBefore`
+ * - identity/structure: `paraId`, `textId`, `_sectionProperties`,
+ *   `_propertyChanges`, `pPrMark`, `bookmarks`, `_emptyHyperlinks`,
+ *   `renderedPageBreakBefore`
  * - paragraph-mark run properties — `pPr/rPr` is CT_PPr-only, not part of the
  *   CT_PPrBase payload a pPrChange stores: `defaultTextFormatting`,
  *   `runInWithNext` (`w:specVanish` lives in that rPr)
@@ -83,6 +83,14 @@ declare function sectionRejectProperties({ live, previousProperties, previousRef
  * and is untouched.
  */
 declare function tableRejectAttrPatch(previousFormatting: document_d_exports.TableFormatting | undefined): AttrPatch;
+/**
+ * Attr patch for rejecting a `w:tblPrExChange`: the stored old `w:tblPrEx`
+ * wholesale. The exceptions ride the row node whole rather than as attrs (the
+ * editor surfaces none of the nine properties), so restoring the previous set
+ * is restoring that one attr — and a record with no stored set says the row
+ * overrode nothing, which is the element's absence, not an empty one.
+ */
+declare function tablePropertyExceptionsRejectAttrPatch(previousFormatting: document_d_exports.TablePropertyExceptionFormatting | undefined): AttrPatch;
 /** Attr patch for rejecting a `w:trPrChange`: the stored old trPr wholesale. */
 declare function tableRowRejectAttrPatch(previousFormatting: document_d_exports.TableRowFormatting | undefined): AttrPatch;
 /**
@@ -96,4 +104,4 @@ declare function tableRowRejectAttrPatch(previousFormatting: document_d_exports.
  */
 declare function tableCellRejectAttrPatch(previousFormatting: document_d_exports.TableCellFormatting | undefined, liveOriginalFormatting: document_d_exports.TableCellFormatting | null | undefined): AttrPatch;
 //#endregion
-export { PPR_CHANGE_SCOPED_ATTR_KEYS, ParagraphPropertyChangeRemoval, hasSerializableParagraphPropertyChange, paragraphPropertiesSnapshot, paragraphRejectAttrPatch, paragraphRejectOriginalFormatting, removeParagraphPropertyChanges, sectionRejectProperties, tableCellRejectAttrPatch, tableRejectAttrPatch, tableRowRejectAttrPatch };
+export { PPR_CHANGE_SCOPED_ATTR_KEYS, ParagraphPropertyChangeRemoval, hasSerializableParagraphPropertyChange, paragraphPropertiesSnapshot, paragraphRejectAttrPatch, paragraphRejectOriginalFormatting, removeParagraphPropertyChanges, sectionRejectProperties, tableCellRejectAttrPatch, tablePropertyExceptionsRejectAttrPatch, tableRejectAttrPatch, tableRowRejectAttrPatch };

package/dist/prosemirror/commands/propertyChangeScope.js

@@ -1,4 +1,5 @@
 import { expectParagraphAttrs } from "../attrs/index.js";
+import { readParagraphNumberingAttr } from "../numberingAttr.js";
 import { directParagraphAlignment } from "../paragraphAlignment.js";
 import { directionFromBidi } from "../paragraphDirection.js";
 import { directParagraphSpacing, paragraphSpacingAttrPatch, paragraphSpacingFromFormatting } from "../paragraphSpacing.js";
@@ -56,9 +57,9 @@ const removeParagraphPropertyChanges = (changes, shouldRemove) => {
 * stored record resets to the schema default (`null`).
 *
 * Deliberately OUT of scope (preserved across a reject):
-* - identity/structure: `paraId`, `textId`, `sectionBreakType`,
-*   `_sectionProperties`, `_propertyChanges`, `pPrMark`, `bookmarks`,
-*   `_emptyHyperlinks`, `renderedPageBreakBefore`
+* - identity/structure: `paraId`, `textId`, `_sectionProperties`,
+*   `_propertyChanges`, `pPrMark`, `bookmarks`, `_emptyHyperlinks`,
+*   `renderedPageBreakBefore`
 * - paragraph-mark run properties — `pPr/rPr` is CT_PPr-only, not part of the
 *   CT_PPrBase payload a pPrChange stores: `defaultTextFormatting`,
 *   `runInWithNext` (`w:specVanish` lives in that rPr)
@@ -214,6 +215,9 @@ function paragraphRejectOriginalFormatting(previousFormatting, liveOriginal) {
 		const value = Object.hasOwn(prev, key) ? prev[key] : void 0;
 		if (value != null) Object.assign(result, { [key]: value });
 	}
+	const numbering = readParagraphNumberingAttr(prev.numPr);
+	if (numbering === null) Reflect.deleteProperty(result, "numPr");
+	else result.numPr = numbering;
 	const live = isRecord(liveOriginal) ? liveOriginal : {};
 	if (live["runProperties"] != null) Object.assign(result, { runProperties: live["runProperties"] });
 	if (live["runInWithNext"] != null) Object.assign(result, { runInWithNext: live["runInWithNext"] });
@@ -249,6 +253,16 @@ function tableRejectAttrPatch(previousFormatting) {
 		_originalFormatting: previousFormatting ?? null
 	};
 }
+/**
+* Attr patch for rejecting a `w:tblPrExChange`: the stored old `w:tblPrEx`
+* wholesale. The exceptions ride the row node whole rather than as attrs (the
+* editor surfaces none of the nine properties), so restoring the previous set
+* is restoring that one attr — and a record with no stored set says the row
+* overrode nothing, which is the element's absence, not an empty one.
+*/
+function tablePropertyExceptionsRejectAttrPatch(previousFormatting) {
+	return { _tablePropertyExceptions: previousFormatting ?? null };
+}
 /** Attr patch for rejecting a `w:trPrChange`: the stored old trPr wholesale. */
 function tableRowRejectAttrPatch(previousFormatting) {
 	return {
@@ -277,6 +291,10 @@ function tableCellRejectAttrPatch(previousFormatting, liveOriginalFormatting) {
 	return {
 		width: previousFormatting?.width?.value ?? null,
 		widthType: previousFormatting?.width?.type ?? null,
+		_authoredWidth: previousFormatting?.width ? {
+			value: previousFormatting.width.value,
+			type: previousFormatting.width.type
+		} : null,
 		verticalAlign: previousFormatting?.verticalAlign ?? null,
 		backgroundColor: previousFormatting?.shading?.fill?.rgb ?? null,
 		textDirection: previousFormatting?.textDirection ?? null,
@@ -306,4 +324,4 @@ function isRecord(value) {
 	return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 //#endregion
-export { PPR_CHANGE_SCOPED_ATTR_KEYS, hasSerializableParagraphPropertyChange, paragraphPropertiesSnapshot, paragraphRejectAttrPatch, paragraphRejectOriginalFormatting, removeParagraphPropertyChanges, sectionRejectProperties, tableCellRejectAttrPatch, tableRejectAttrPatch, tableRowRejectAttrPatch };
+export { PPR_CHANGE_SCOPED_ATTR_KEYS, hasSerializableParagraphPropertyChange, paragraphPropertiesSnapshot, paragraphRejectAttrPatch, paragraphRejectOriginalFormatting, removeParagraphPropertyChanges, sectionRejectProperties, tableCellRejectAttrPatch, tablePropertyExceptionsRejectAttrPatch, tableRejectAttrPatch, tableRowRejectAttrPatch };

package/dist/prosemirror/commands/sectionBreak.d.ts

@@ -1,5 +1,37 @@
+import { SectionBreakType } from "../sectionCarrier.js";
 import { Command } from "prosemirror-state";
 //#region src/prosemirror/commands/sectionBreak.d.ts
+/**
+ * Run a command, keeping every section break on the paragraph whose mark
+ * survived it.
+ *
+ * A section break is a property of a paragraph *mark*. The transfer is keyed on
+ * the mark's position surviving the transaction, not on which command ran, so
+ * deleting a section-ending paragraph outright still removes its section: that
+ * mark is gone, and nothing inherits it.
+ */
+declare const keepSectionBreaksOnSurvivingMarks: (command: Command) => Command;
+/**
+ * End the selection's sections with `breakType`.
+ *
+ * A paragraph that already ends a section keeps its page size, margins,
+ * columns and header references and changes only `w:type` (§17.6.22), which is
+ * the one field the type names; a paragraph that ends none mints a record
+ * stating that type alone, and inherits the rest from the section that follows
+ * it.
+ */
+declare const setSectionBreakType: (breakType: SectionBreakType) => Command;
+/**
+ * Remove the section break the selection's paragraphs carry.
+ *
+ * The record goes, and with it the section boundary: the paragraphs it
+ * governed become part of the section that follows, whose `w:sectPr` governs
+ * them from then on. That is Word's own rule for deleting a section break, and
+ * it is what §17.6.18 says a paragraph with no `w:sectPr` means — nothing has
+ * to be merged into the following record, because the following record already
+ * states the whole of the section it heads.
+ */
+declare const removeSectionBreakAtSelection: Command;
 /**
  * Insert a "next page" section break at the cursor — starts a new section on a
  * new page.
@@ -11,4 +43,4 @@ declare const insertSectionBreakNextPage: Command;
  */
 declare const insertSectionBreakContinuous: Command;
 //#endregion
-export { insertSectionBreakContinuous, insertSectionBreakNextPage };
+export { insertSectionBreakContinuous, insertSectionBreakNextPage, keepSectionBreaksOnSurvivingMarks, removeSectionBreakAtSelection, setSectionBreakType };