@stll/folio-core 0.56.0 → 0.57.0

package/dist/internal/revisionResolutionInline.js

@@ -3,9 +3,11 @@ import { expectFieldAttrs, expectRunPropertyChangeMarkAttrs, expectTrackedChange
 import { resolutionRemovesControl, withoutResolvedEnclosures } from "../prosemirror/contentControlRevisions.js";
 import { resolveEmptyFieldResultRuns } from "../prosemirror/emptyFieldResultRuns.js";
 import "../prosemirror/extensions/nodes/SdtExtension.js";
+import { canonicalFieldNode } from "../prosemirror/fieldRepresentation.js";
+import { resolvedPreservedXmlAttrs } from "../prosemirror/preservedXmlReview.js";
 import { continuedRunMarks } from "../prosemirror/rejoinRunCarriers.js";
 import { RUN_FORMATTING_MARK_NAMES } from "../prosemirror/runFormattingMarkNames.js";
-import { reconstructRejectedRunFormattingMarks } from "../prosemirror/runPropertyChangeResolution.js";
+import { reconstructRejectedRunFormattingMarks, restoreHistoricalRunFormatting } from "../prosemirror/runPropertyChangeResolution.js";
 import { paragraphRunStyleContext } from "../prosemirror/runStyleFormatting.js";
 import { recordNodeResolution } from "./revisionResolutionEdits.js";
 import { panic } from "better-result";
@@ -35,6 +37,11 @@ const rebuildNode = (source, attrs, content, marks = source.marks) => recreatePr
 const resolveInlineNode = ({ node, context, paragraphScope }) => {
 	let marks = node.marks;
 	let attrs = node.attrs;
+	if (context.mode === "reject" && node.marks.some((mark) => mark.type === context.keepType && expectTrackedChangeMarkAttrs(mark)._historicalFormatting)) marks = restoreHistoricalRunFormatting({
+		node,
+		paragraphContext: resolveParagraphRunStyleScope(paragraphScope, context.styleResolver),
+		styleResolver: context.styleResolver
+	});
 	const runPropertyChangeMark = marks.find((mark) => mark.type.name === "runPropertyChange");
 	if (runPropertyChangeMark) {
 		const { changes } = expectRunPropertyChangeMarkAttrs(runPropertyChangeMark);
@@ -64,6 +71,7 @@ const resolveInlineNode = ({ node, context, paragraphScope }) => {
 	}
 	if (node.marks.some((mark) => (mark.type.name === "insertion" || mark.type.name === "deletion") && expectTrackedChangeMarkAttrs(mark)._docxRevisionAncestors?.some((layer) => context.mode === "accept" ? layer.type === "deletion" || layer.type === "moveFrom" : layer.type === "insertion" || layer.type === "moveTo")) || context.removeType && node.marks.some((mark) => mark.type === context.removeType)) return null;
 	if (context.keepType) marks = marks.filter((mark) => mark.type !== context.keepType);
+	if (attrs === node.attrs) attrs = resolvedPreservedXmlAttrs(node, marks);
 	if (attrs !== node.attrs) return rebuildNode(node, attrs, node.content, marks);
 	return marksEqual(marks, node.marks) ? node : node.mark(marks);
 };
@@ -172,7 +180,7 @@ const resolveInlineContent = ({ node, position, context, inheritedParagraphScope
 		context
 	});
 	let resolvedContent = Fragment.fromArray(children);
-	if (!resolvedNode.type.validContent(resolvedContent)) {
+	if (!resolvedNode.type.validContent(resolvedContent) && !(resolvedNode.type.name === "structuredField" && resolvedContent.size === 0)) {
 		const fitted = resolvedNode.type.createAndFill(resolvedNode.attrs, resolvedContent, resolvedNode.marks);
 		if (!fitted || !resolvedNode.type.validContent(fitted.content)) {
 			if (!resolvedNode.isInline) return panic(`Revision inline resolution invalidated ${resolvedNode.type.name} content`);
@@ -195,7 +203,21 @@ const resolveInlineContent = ({ node, position, context, inheritedParagraphScope
 		from: position,
 		to: position + resolvedNode.nodeSize
 	});
-	return rebuildNode(node, resolvedAttrs, resolvedContent, resolvedNode.marks);
+	const rebuilt = rebuildNode(node, resolvedAttrs, resolvedContent, resolvedNode.marks);
+	const canonical = canonicalFieldNode(rebuilt);
+	if (canonical !== rebuilt && canonical.type === rebuilt.type) recordNodeResolution({
+		before: rebuilt,
+		after: canonical,
+		position,
+		steps: context.steps
+	});
+	else if (canonical !== rebuilt) context.replacementRanges.splice(replacementRangeStart, context.replacementRanges.length - replacementRangeStart, {
+		from: position,
+		to: position + node.nodeSize,
+		newSize: canonical.nodeSize,
+		slice: new Slice(Fragment.from(canonical), 0, 0)
+	});
+	return canonical;
 };
 const coalesceReplacementRanges = (replacementRanges) => {
 	const coalesced = [];

package/dist/markdown/renderRuns.js

@@ -490,17 +490,7 @@ function renderParagraphInline(ctx, pkg, content, paraId, edges = {
 			case "simpleField":
 			case "complexField": {
 				const runs = item.type === "simpleField" ? item.content : item.fieldResult;
-				for (const child of runs) {
-					if (child.type === "run") {
-						out += renderRuns(ctx, pkg, [child], paraId);
-						continue;
-					}
-					if (child.type === "hyperlink") {
-						out += renderHyperlink(ctx, pkg, child, paraId);
-						continue;
-					}
-					out += child.type === "inlineWrapper" ? renderParagraphInline(ctx, pkg, child.content, paraId, UNKNOWN_NEIGHBORS) : child.text;
-				}
+				for (const child of runs) out += child.type === "preservedInline" ? child.text : renderParagraphInline(ctx, pkg, [child], paraId, UNKNOWN_NEIGHBORS);
 				break;
 			}
 			case "inlineSdt":

package/dist/panel-layout.d.ts

@@ -5,17 +5,17 @@
  *
  * The editor measures the width it has once, and this module decides how
  * each panel is presented. Every track the page shares the row with is
- * counted here, so the page, the outline and the comments cannot overlap:
- * a panel either gets a track of its own or becomes a drawer the user opens
- * on purpose. A drawer takes no track.
+ * counted here, so the page, the outline and the comments cannot overlap.
+ * Explicitly opening the outline gives it a clamped track beside the viewport;
+ * comments keep their existing column-or-drawer behavior.
  *
  * Space goes to the page first, then the outline rail, then the comments
  * column, then the full outline column:
  *
  * - comments: a column when the page, the comments and the outline rail fit;
  *   otherwise a drawer.
- * - outline: a column when it fits beside the page and the comments column;
- *   otherwise a rail of heading ticks when that fits; otherwise a drawer.
+ * - outline: a column when it fits beside the page and comments; otherwise a
+ *   rail of heading ticks when that fits, or a toolbar toggle for the opened track.
  *
  * The tier names the result: `wide` when every panel has its full column,
  * `medium` when the outline is a rail, `narrow` when a panel is a drawer.
@@ -29,6 +29,8 @@ declare const PANEL_METRICS: {
   readonly outlineColumnWidth: 256;
   /** The outline rail in the `medium` tier, border included. */
   readonly outlineRailWidth: 32;
+  /** Minimum width and height of a shared panel control. */
+  readonly controlMinimumSize: 32;
   /** A comment card column. */
   readonly commentsWidth: 280;
   /** Space between the page edge and the comment cards, and after them. */
@@ -41,8 +43,8 @@ declare const PANEL_METRICS: {
 /** Width the comments take beside the page: gap, cards, gap. */
 declare const COMMENTS_TRACK_WIDTH: number;
 type PanelLayoutTier = "wide" | "medium" | "narrow";
-/** How the outline is shown: a column, a rail of ticks, a drawer, or not at all. */
-type OutlinePresentation = "none" | "column" | "rail" | "drawer";
+/** How the outline is shown: a column, tick rail, drawer, or explicitly opened track. */
+type OutlinePresentation = "none" | "column" | "rail" | "drawer" | "expanded";
 /** How the comments are shown: a column beside the page, a drawer, or not at all. */
 type CommentsPresentation = "hidden" | "column" | "drawer";
 type PanelLayoutInput = {
@@ -50,8 +52,8 @@ type PanelLayoutInput = {
   availableWidth: number;
   /** Width of the widest page at the current zoom. */
   pageWidth: number;
-  /** Whether the document has an outline to show. */
-  outline: "absent" | "available";
+  /** Whether the document outline is absent, available, or explicitly opened. */
+  outline: "absent" | "available" | "expanded";
   /** Whether the user (or the auto-open) wants the comments shown. */
   comments: "closed" | "open";
 };

package/dist/panel-layout.js

@@ -5,17 +5,17 @@
 *
 * The editor measures the width it has once, and this module decides how
 * each panel is presented. Every track the page shares the row with is
-* counted here, so the page, the outline and the comments cannot overlap:
-* a panel either gets a track of its own or becomes a drawer the user opens
-* on purpose. A drawer takes no track.
+* counted here, so the page, the outline and the comments cannot overlap.
+* Explicitly opening the outline gives it a clamped track beside the viewport;
+* comments keep their existing column-or-drawer behavior.
 *
 * Space goes to the page first, then the outline rail, then the comments
 * column, then the full outline column:
 *
 * - comments: a column when the page, the comments and the outline rail fit;
 *   otherwise a drawer.
-* - outline: a column when it fits beside the page and the comments column;
-*   otherwise a rail of heading ticks when that fits; otherwise a drawer.
+* - outline: a column when it fits beside the page and comments; otherwise a
+*   rail of heading ticks when that fits, or a toolbar toggle for the opened track.
 *
 * The tier names the result: `wide` when every panel has its full column,
 * `medium` when the outline is a rail, `narrow` when a panel is a drawer.
@@ -29,6 +29,8 @@ const PANEL_METRICS = {
 	outlineColumnWidth: 256,
 	/** The outline rail in the `medium` tier, border included. */
 	outlineRailWidth: 32,
+	/** Minimum width and height of a shared panel control. */
+	controlMinimumSize: 32,
 	/** A comment card column. */
 	commentsWidth: 280,
 	/** Space between the page edge and the comment cards, and after them. */
@@ -49,7 +51,7 @@ const pageTrackWidth = (pageWidth) => pageWidth + 2 * PANEL_METRICS.pageMargin;
 const panelLayoutThresholds = ({ pageWidth, outline, comments }) => {
 	const page = pageTrackWidth(pageWidth);
 	const commentsTrack = comments === "open" ? COMMENTS_TRACK_WIDTH : 0;
-	const hasOutline = outline === "available";
+	const hasOutline = outline !== "absent";
 	return {
 		wide: page + commentsTrack + (hasOutline ? PANEL_METRICS.outlineColumnWidth : 0),
 		medium: page + commentsTrack + (hasOutline ? PANEL_METRICS.outlineRailWidth : 0)
@@ -62,7 +64,7 @@ const OUTLINE_TRACK_WIDTH = {
 	drawer: 0
 };
 const tierFor = (outline, comments) => {
-	if (outline === "drawer" || comments === "drawer") return "narrow";
+	if (outline === "drawer" || outline === "expanded" || comments === "drawer") return "narrow";
 	if (outline === "rail") return "medium";
 	return "wide";
 };
@@ -73,11 +75,13 @@ const computePanelLayout = (input) => {
 	const page = pageTrackWidth(input.pageWidth);
 	const comments = (() => {
 		if (input.comments === "closed") return "hidden";
-		return availableWidth >= thresholds.medium ? "column" : "drawer";
+		const requiredWidth = input.outline === "expanded" ? thresholds.wide : thresholds.medium;
+		return availableWidth >= requiredWidth ? "column" : "drawer";
 	})();
 	const commentsGutter = comments === "column" ? COMMENTS_TRACK_WIDTH : 0;
 	const outline = (() => {
 		if (input.outline === "absent") return "none";
+		if (input.outline === "expanded") return "expanded";
 		const beside = page + commentsGutter;
 		if (availableWidth >= thresholds.wide) return "column";
 		if (availableWidth >= beside + PANEL_METRICS.outlineRailWidth) return "rail";
@@ -87,7 +91,7 @@ const computePanelLayout = (input) => {
 		tier: tierFor(outline, comments),
 		outline,
 		comments,
-		outlineTrackWidth: OUTLINE_TRACK_WIDTH[outline],
+		outlineTrackWidth: outline === "expanded" ? Math.min(PANEL_METRICS.outlineColumnWidth, Math.max(PANEL_METRICS.controlMinimumSize, (availableWidth - commentsGutter) / 2)) : OUTLINE_TRACK_WIDTH[outline],
 		commentsGutter,
 		thresholds
 	};

package/dist/prosemirror/addTrackedDeletionMark.d.ts

@@ -0,0 +1,18 @@
+import { Mark } from "prosemirror-model";
+import { Transform } from "prosemirror-transform";
+//#region src/prosemirror/addTrackedDeletionMark.d.ts
+type AddTrackedDeletionMarkOptions = {
+  tr: Transform;
+  from: number;
+  to: number;
+  mark: Mark;
+  insertionPolicy: "preserve-pending" | "retract-own";
+};
+/**
+ * Already deleted runs keep their revision identity and enclosing insertion path.
+ * An own insertion containing deleted descendants is marked rather than retracted:
+ * removing its carrier would also remove another pending revision.
+ */
+declare const addTrackedDeletionMark: ({ tr, from, to, mark, insertionPolicy }: AddTrackedDeletionMarkOptions) => void;
+//#endregion
+export { addTrackedDeletionMark };

package/dist/prosemirror/addTrackedDeletionMark.js

@@ -0,0 +1,87 @@
+import { expectTrackedChangeMarkAttrs } from "./attrs/index.js";
+import { trackedRevisionLayerOf } from "./trackedRevisionPath.js";
+import { canCarryTrackedRunMark } from "./trackedRunInlineAtoms.js";
+import { panic } from "better-result";
+//#region src/prosemirror/addTrackedDeletionMark.ts
+/**
+* Already deleted runs keep their revision identity and enclosing insertion path.
+* An own insertion containing deleted descendants is marked rather than retracted:
+* removing its carrier would also remove another pending revision.
+*/
+const addTrackedDeletionMark = ({ tr, from, to, mark, insertionPolicy }) => {
+	if (mark.type.name !== "deletion") panic("A tracked deletion requires a deletion mark");
+	const preservedDeletions = [];
+	const protectedCarriers = /* @__PURE__ */ new Set();
+	tr.doc.nodesBetween(from, to, (node, position) => {
+		const existing = node.marks.find(({ type }) => type.name === "deletion");
+		if (node.isInline && existing) {
+			const start = Math.max(from, position);
+			const end = Math.min(to, position + node.nodeSize);
+			if (start < end) preservedDeletions.push({
+				from: start,
+				to: end,
+				mark: existing
+			});
+			const at = tr.doc.resolve(position);
+			for (let depth = 1; depth <= at.depth; depth++) {
+				const ancestor = at.node(depth);
+				if (canCarryTrackedRunMark(ancestor)) protectedCarriers.add(ancestor);
+			}
+		}
+		return true;
+	});
+	const mapFrom = tr.mapping.maps.length;
+	const ranges = [];
+	const descendantDeletions = [];
+	const deletionFor = (node) => {
+		const insertion = node.marks.find(({ type }) => type.name === "insertion");
+		const ancestors = insertion ? expectTrackedChangeMarkAttrs(insertion)._docxRevisionAncestors : null;
+		return insertion && ancestors?.length ? mark.type.create({
+			...mark.attrs,
+			_docxRevisionAncestors: [...ancestors, trackedRevisionLayerOf(insertion, node)]
+		}) : mark;
+	};
+	tr.doc.nodesBetween(from, to, (node, position) => {
+		if (!canCarryTrackedRunMark(node)) return true;
+		if (node.marks.some(({ type }) => type.name === "deletion")) return false;
+		const start = Math.max(from, position);
+		const end = Math.min(to, position + node.nodeSize);
+		if (start >= end) return false;
+		const insertion = node.marks.find(({ type }) => type.name === "insertion");
+		const ownInsertion = insertion !== void 0 && insertion.attrs["author"] === mark.attrs["author"];
+		const deletion = deletionFor(node);
+		const disposition = insertionPolicy === "retract-own" && ownInsertion && !protectedCarriers.has(node) ? "retract" : "mark";
+		const previous = ranges.at(-1);
+		if (previous?.to === start && previous.disposition === disposition && previous.mark.eq(deletion)) previous.to = end;
+		else ranges.push({
+			from: start,
+			to: end,
+			mark: deletion,
+			disposition
+		});
+		if (disposition === "mark") node.descendants((child, offset) => {
+			if (child.marks.some(({ type }) => type.name === "deletion")) return false;
+			const childDeletion = deletionFor(child);
+			if (childDeletion === mark) return true;
+			const childStart = Math.max(from, position + 1 + offset);
+			const childEnd = Math.min(to, position + 1 + offset + child.nodeSize);
+			if (childStart < childEnd) descendantDeletions.push({
+				from: childStart,
+				to: childEnd,
+				mark: childDeletion
+			});
+			return true;
+		});
+		return false;
+	});
+	for (const range of ranges.toReversed()) if (range.disposition === "retract") tr.delete(range.from, range.to);
+	else tr.addMark(range.from, range.to, range.mark);
+	const mapping = tr.mapping.slice(mapFrom);
+	for (const preserved of [...descendantDeletions, ...preservedDeletions]) {
+		const start = mapping.map(preserved.from);
+		const end = mapping.map(preserved.to);
+		if (start < end) tr.addMark(start, end, preserved.mark);
+	}
+};
+//#endregion
+export { addTrackedDeletionMark };

package/dist/prosemirror/attrs/index.js

@@ -8,6 +8,7 @@ import { attrsRecord, attrsResult, expectAttrs, expectCachedNodeAttrs, expectNod
 import { COUNTER_FORMAT_VALUES, EMPHASIS_MARK_VALUES, FIELD_TYPE_VALUES, FONT_HINT_VALUES, FONT_THEME_VALUES, HIGHLIGHT_COLOR_VALUES, IMAGE_HORIZONTAL_ALIGNMENT_VALUES, IMAGE_HORIZONTAL_RELATIVE_TO_VALUES, IMAGE_VERTICAL_ALIGNMENT_VALUES, IMAGE_VERTICAL_RELATIVE_TO_VALUES, IMAGE_WRAP_TEXT_VALUES, IMAGE_WRAP_TYPE_VALUES, LINE_SPACING_RULE_VALUES, OUTLINE_STYLE_ATTR_VALUES, PARAGRAPH_ALIGNMENT_VALUES, POSITIONAL_TAB_ALIGNMENT_VALUES, POSITIONAL_TAB_LEADER_VALUES, POSITIONAL_TAB_RELATIVE_TO_VALUES, SDT_LOCK_VALUES, SDT_TYPE_VALUES, SHADING_PATTERN_VALUES, TABLE_CELL_VERTICAL_ALIGNMENT_VALUES, TABLE_JUSTIFICATION_VALUES, TABLE_ROW_HEIGHT_RULE_VALUES, TABLE_WIDTH_TYPE_VALUES, TAB_LEADER_VALUES, TAB_STOP_ALIGNMENT_VALUES, TEXT_DIRECTION_VALUES, TEXT_EFFECT_VALUES, UNDERLINE_STYLE_VALUES } from "../../types/documentEnumValues.js";
 import { canonicalJson } from "../../utils/canonicalJson.js";
 import { normalizeHorizontalScalePercent } from "../../utils/horizontalScale.js";
+import { isNoteReferenceOccurrenceId } from "../noteReferenceOccurrenceId.js";
 import { paragraphNumberingFromAttrValue } from "../numberingAttr.js";
 import { outlineLevelFromAttrValue } from "../outlineLevelAttr.js";
 import { isParagraphDirection } from "../paragraphDirection.js";
@@ -953,6 +954,10 @@ const readFootnoteRefMarkAttrs = (mark) => {
 	const issues = [];
 	expectMarkType(mark, "footnoteRef", issues);
 	requiredStringOrNumber(attrs, "id", "footnoteRef.attrs.id", issues);
+	if (!isNoteReferenceOccurrenceId(attrs["occurrenceId"])) issues.push({
+		path: "footnoteRef.attrs.occurrenceId",
+		message: "Expected a nonblank occurrence identity."
+	});
 	optionalOneOf(attrs, "noteType", "footnoteRef.attrs.noteType", issues, NOTE_TYPES);
 	optionalOneOf(attrs, "vertAlign", "footnoteRef.attrs.vertAlign", issues, NOTE_REF_VERT_ALIGNS);
 	optionalBoolean(attrs, "customMarkFollows", "footnoteRef.attrs.customMarkFollows", issues);

package/dist/prosemirror/commands/comments.js

@@ -10,20 +10,23 @@ import { resolveEmptyFieldResultRuns } from "../emptyFieldResultRuns.js";
 import { JOINED_RUNS_RESTYLED_META } from "../extensions/features/JoinedRunStyleExtension.js";
 import { markChangedParagraphRanges, markStructuralChange, markTrackedSectionEndpointRemoval } from "../extensions/features/ParagraphChangeTrackerExtension.js";
 import "../extensions/nodes/SdtExtension.js";
+import { canonicalFieldNode } from "../fieldRepresentation.js";
 import { resolveStateStory } from "../markupViewProjection.js";
 import { joinAtParagraphMark } from "../paragraphMarkJoin.js";
 import { getDocumentNumbering } from "../plugins/documentNumbering.js";
 import { getDocumentStyleResolver } from "../plugins/documentStyleState.js";
+import { resolvedPreservedXmlAttrs } from "../preservedXmlReview.js";
 import { rebaseParagraphRuns, setParagraphAttrsWithRebasedRunFormatting } from "../rebaseParagraphRunFormatting.js";
 import { rejoinRunsAt } from "../rejoinRunCarriers.js";
 import { getFolioNodeRevisionCarriers, nodePropertyRevisionSites } from "../revisionCarriers.js";
 import { RUN_FORMATTING_MARK_NAMES } from "../runFormattingMarkNames.js";
-import { reconstructRejectedRunFormattingMarks } from "../runPropertyChangeResolution.js";
+import { reconstructRejectedRunFormattingMarks, restoreHistoricalRunFormatting } from "../runPropertyChangeResolution.js";
 import { paragraphRunStyleContext, paragraphRunStyleContextAt } from "../runStyleFormatting.js";
 import { getTableCellMergeChange } from "../tableCellMergeRevision.js";
 import { isTableCellRetainedInReviewView } from "../tableCellRevisionVisibility.js";
 import { markRowEmptiedInBatch, reconcileTableGridAfterColumnRemoval, removeRowsWithoutCellsAfterBatch, removeTableRow } from "../tableGridMutation.js";
 import { runInCellPending, runParagraphIntoTable } from "../tableRunIn.js";
+import { retainedTrackedRevisionMark, trackedRevisionPathOf } from "../trackedRevisionPath.js";
 import { holdsNoContent } from "../zeroWidthAnchors.js";
 import { inlineBookmarksForParagraphJoin } from "./paragraphBookmarkJoin.js";
 import { hasSerializableParagraphPropertyChange, paragraphPropertiesSnapshot } from "./propertyChangeScope.js";
@@ -32,10 +35,16 @@ import { resolveParagraphChangeAttrs } from "./resolveParagraphProperties.js";
 import { hasMatchingCollapsedTableCellMerge, resolveCollapsedTableCellMerge, resolveVisibleTableCellMerge } from "./tableCellMergeResolution.js";
 import { panic } from "better-result";
 import { PARAGRAPH_MARK_CHANGE_KINDS, REVIEW_CARRIERS } from "@stll/docx-core/model";
+import { Fragment } from "prosemirror-model";
 import { TableMap } from "prosemirror-tables";
 import { Mapping } from "prosemirror-transform";
 //#region src/prosemirror/commands/comments.ts
 /**
+* Comment and Track Changes Commands
+*
+* PM commands for adding/removing comments and accepting/rejecting tracked changes.
+*/
+/**
 * Add a comment mark to the current selection.
 */
 function addCommentMark(commentId) {
@@ -67,21 +76,6 @@ function removeCommentMark(commentId) {
 		return true;
 	};
 }
-const revisionLayerOf = (mark) => {
-	const attrs = expectTrackedChangeMarkAttrs(mark);
-	let type;
-	if (mark.type.name === "insertion") type = attrs.moveKind === "moveTo" ? "moveTo" : "insertion";
-	else type = attrs.moveKind === "moveFrom" ? "moveFrom" : "deletion";
-	return {
-		type,
-		revisionId: attrs.revisionId,
-		author: attrs.author,
-		...attrs.date ? { date: attrs.date } : {},
-		...attrs.utcDate ? { utcDate: attrs.utcDate } : {},
-		...attrs.initials ? { initials: attrs.initials } : {},
-		outerWrapperCount: attrs._docxOuterWrapperCount ?? 0
-	};
-};
 const revisionLayerRemovesContent = (layer, mode) => mode === "accept" ? layer.type === "deletion" || layer.type === "moveFrom" : layer.type === "insertion" || layer.type === "moveTo";
 /**
 * Resolve a tracked change: accept or reject.
@@ -189,6 +183,19 @@ function resolveChange(from, to, mode, revisionIds) {
 				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 (removesNode || runPropertyChangeMark !== void 0 || node.marks.some((mark) => (mark.type === insertionType || mark.type === deletionType) && matchesRevision(mark))) resolvedBoundaries.push(rangeFrom, rangeTo);
+				if (mode === "reject" && node.marks.find((mark) => mark.type === keepType && matchesRevision(mark) && expectTrackedChangeMarkAttrs(mark)._historicalFormatting && !expectTrackedChangeMarkAttrs(mark)._docxRevisionAncestors?.some((layer) => (layer.type === "deletion" || layer.type === "moveFrom") && revisionSet !== null && !revisionSet.has(layer.revisionId))) && !removesNode) {
+					const nextMarks = restoreHistoricalRunFormatting({
+						node,
+						paragraphContext: paragraphRunStyleContextAt({
+							doc: tr.doc,
+							pos: rangeFrom,
+							styleResolver
+						}),
+						styleResolver
+					});
+					for (const mark of node.marks) if (RUN_FORMATTING_MARK_NAMES.has(mark.type.name)) tr.removeMark(rangeFrom, rangeTo, mark);
+					for (const mark of nextMarks) if (RUN_FORMATTING_MARK_NAMES.has(mark.type.name)) tr.addMark(rangeFrom, rangeTo, mark);
+				}
 				if (runPropertyChangeMark) resolveRunPropertyChange({
 					tr,
 					node,
@@ -201,7 +208,7 @@ function resolveChange(from, to, mode, revisionIds) {
 				});
 				const nestedMark = node.marks.find((mark) => (mark.type === insertionType || mark.type === deletionType) && (expectTrackedChangeMarkAttrs(mark)._docxRevisionAncestors?.length ?? 0) > 0);
 				if (nestedMark) {
-					const path = [...expectTrackedChangeMarkAttrs(nestedMark)._docxRevisionAncestors ?? [], revisionLayerOf(nestedMark)];
+					const path = trackedRevisionPathOf(nestedMark);
 					const selected = (layer) => revisionSet === null || revisionSet.has(layer.revisionId);
 					if (path.some(selected)) if (path.some((layer) => selected(layer) && revisionLayerRemovesContent(layer, mode))) deleteRanges.push({
 						from: rangeFrom,
@@ -209,23 +216,13 @@ function resolveChange(from, to, mode, revisionIds) {
 					});
 					else {
 						tr.removeMark(rangeFrom, rangeTo, nestedMark);
-						const remaining = path.filter((layer) => !selected(layer));
-						const active = remaining.at(-1);
-						if (active) {
-							const type = active.type === "insertion" || active.type === "moveTo" ? insertionType : deletionType;
-							if (!type) panic("A nested tracked revision has no editor mark type");
-							tr.addMark(rangeFrom, rangeTo, type.create({
-								revisionId: active.revisionId,
-								author: active.author,
-								date: active.date ?? null,
-								utcDate: active.utcDate ?? null,
-								initials: active.initials ?? null,
-								moveKind: active.type === "moveTo" || active.type === "moveFrom" ? active.type : null,
-								_historicalFormatting: active.type === "deletion" || active.type === "moveFrom" ? true : null,
-								_docxOuterWrapperCount: active.outerWrapperCount,
-								_docxRevisionAncestors: remaining.length > 1 ? remaining.slice(0, -1) : null
-							}));
-						}
+						const retained = retainedTrackedRevisionMark(nestedMark, (layer) => !selected(layer));
+						if (retained) tr.addMark(rangeFrom, rangeTo, retained);
+					}
+					const current = tr.doc.nodeAt(pos);
+					if (current) {
+						const attrs = resolvedPreservedXmlAttrs(node, current.marks);
+						if (attrs !== node.attrs) tr.setNodeMarkup(pos, void 0, attrs);
 					}
 					return true;
 				}
@@ -233,6 +230,10 @@ function resolveChange(from, to, mode, revisionIds) {
 					from: rangeFrom,
 					to: rangeTo
 				});
+				if (!removesNode && keepType && node.marks.some((mark) => mark.type === keepType && matchesRevision(mark))) {
+					const attrs = resolvedPreservedXmlAttrs(node, node.marks.filter((mark) => !(mark.type === keepType && matchesRevision(mark))));
+					if (attrs !== node.attrs) tr.setNodeMarkup(pos, void 0, attrs);
+				}
 				if (!removeKeptMarksInBulk) {
 					for (const mark of node.marks) if (keepType && mark.type === keepType && matchesRevision(mark)) tr.removeMark(rangeFrom, rangeTo, mark);
 				}
@@ -255,7 +256,17 @@ function resolveChange(from, to, mode, revisionIds) {
 				}
 				rangesToDelete = coalescedDeleteRanges;
 			}
-			for (const range of rangesToDelete.toReversed()) tr.delete(range.from, range.to);
+			for (const range of rangesToDelete.toReversed()) {
+				const start = tr.doc.resolve(range.from);
+				const field = start.parent;
+				if (field.type.name === "structuredField" && start.parentOffset === 0 && range.to === start.end()) {
+					const position = start.before();
+					const empty = canonicalFieldNode(field.copy(Fragment.empty));
+					tr.replaceWith(position, position + field.nodeSize, empty);
+					continue;
+				}
+				tr.delete(range.from, range.to);
+			}
 			if (deleteTextBoxesAnchoredAt(tr, droppedTextBoxAnchorIds(state.doc, tr.doc))) markStructuralChange(tr);
 			tableRowStructuralOps.sort((left, right) => right.rowPos - left.rowPos);
 			let resolvedTableRowStructure = false;
@@ -418,6 +429,20 @@ function resolveChange(from, to, mode, revisionIds) {
 				boundaries: resolvedBoundaries.map((position) => tr.mapping.map(position)).filter((position) => !seams.has(position)),
 				styleResolver
 			});
+			const resolvedFields = [];
+			tr.doc.descendants((node, position) => {
+				const canonical = canonicalFieldNode(node);
+				if (canonical !== node) resolvedFields.push({
+					node: canonical,
+					position
+				});
+			});
+			for (const { node, position } of resolvedFields.toReversed()) {
+				const field = tr.doc.nodeAt(position);
+				if (!field) continue;
+				if (field.type === node.type) tr.setNodeMarkup(position, void 0, node.attrs, node.marks);
+				else tr.replaceWith(position, position + field.nodeSize, node);
+			}
 			if (tr.steps.length > 0) dispatch(tr);
 		}
 		return true;

package/dist/prosemirror/commands/propertyChangeScope.js

@@ -4,6 +4,7 @@ import { readParagraphNumberingAttr } from "../numberingAttr.js";
 import { directParagraphAlignment } from "../paragraphAlignment.js";
 import { directionFromBidi } from "../paragraphDirection.js";
 import { PARAGRAPH_FORMATTING_WRITE_BACK, STYLE_RESOLVED_PARAGRAPH_FIELDS } from "../paragraphFormattingProvenance.js";
+import { directParagraphIndentation } from "../paragraphIndentation.js";
 import { directParagraphSpacing, paragraphSpacingAttrPatch, paragraphSpacingFromFormatting } from "../paragraphSpacing.js";
 import { sameFormattingValue } from "../runFormattingFromMarks.js";
 //#region src/prosemirror/commands/propertyChangeScope.ts
@@ -127,18 +128,14 @@ const paragraphPropertiesSnapshot = (node) => {
 	const attrs = expectParagraphAttrs(node);
 	const snapshot = {};
 	for (const key of PPR_CHANGE_SCOPED_ATTR_KEYS) {
-		if (key === "alignment" || PPR_SPACING_ATTR_KEYS.has(key) || key === "numPr" && isStyleSourcedParagraphNumbering(attrs.numPr, attrs.numPrFromStyle)) continue;
+		if (key === "alignment" || key === "indentLeft" || key === "indentRight" || key === "indentFirstLine" || key === "hangingIndent" || PPR_SPACING_ATTR_KEYS.has(key) || key === "numPr" && isStyleSourcedParagraphNumbering(attrs.numPr, attrs.numPrFromStyle)) continue;
 		if (styleSuppliedParagraphValue(attrs, key)) continue;
-		if (key === "hangingIndent" && styleSuppliedParagraphValue(attrs, "indentFirstLine")) continue;
-		if (styleSuppliedParagraphValue(attrs, key)) continue;
-		if (key === "hangingIndent" && styleSuppliedParagraphValue(attrs, "indentFirstLine")) continue;
 		const value = attrs[key];
-		if (key === "hangingIndent" && value === false && attrs._originalFormatting?.hangingIndent === void 0) continue;
 		if (value !== null && value !== void 0) snapshot[key] = value;
 	}
 	const directAlignment = directParagraphAlignment(attrs);
 	if (directAlignment !== void 0) snapshot["alignment"] = directAlignment;
-	Object.assign(snapshot, directParagraphSpacing(attrs));
+	Object.assign(snapshot, directParagraphSpacing(attrs), directParagraphIndentation(attrs));
 	return snapshot;
 };
 /**

package/dist/prosemirror/commands/resolveParagraphProperties.js

@@ -2,8 +2,9 @@ import { resolveParagraphNumbering } from "../../docx/numberingReference.js";
 import { expectParagraphAttrs } from "../attrs/index.js";
 import { rejectedListRenderingPatch } from "../listRendering.js";
 import { paragraphNumberingAttr } from "../numberingAttr.js";
-import { styleResolvedParagraphFormatting } from "../paragraphFormattingProvenance.js";
+import { paragraphIndentationFromFormatting } from "../paragraphIndentation.js";
 import { resolveParagraphDefaultTextFormatting } from "../styles/paragraphStyleCascade.js";
+import { listIndentationProvenancePatch } from "../styles/resolvedStyleAttrs.js";
 import { paragraphRejectAttrPatch, paragraphRejectOriginalFormatting, removeParagraphPropertyChanges, sectionRejectProperties } from "./propertyChangeScope.js";
 //#region src/prosemirror/commands/resolveParagraphProperties.ts
 /** Resolve paragraph and section property records before resolving their inline content. */
@@ -27,24 +28,32 @@ const resolveParagraphChangeAttrs = ({ node, boundaryCovered, mode, revisionSet,
 				const inheritedAlignment = currentAttrs.alignmentFromStyle;
 				const restoredStyleId = rejection.previousFormatting?.styleId ?? void 0;
 				const sameStyle = restoredStyleId === (currentAttrs.styleId ?? void 0);
-				let previousFormattingFromStyle;
-				let resolvedFromStyle = sameStyle ? currentAttrs._resolvedFormatting : void 0;
-				if (styleResolver) {
-					previousFormattingFromStyle = styleResolver.resolveParagraphStyle(restoredStyleId).paragraphFormatting;
-					if (!sameStyle) {
-						resolvedFromStyle = styleResolvedParagraphFormatting(previousFormattingFromStyle);
-						nextAttrs["_resolvedFormatting"] = resolvedFromStyle;
-					}
-				} else if (inheritedAlignment !== void 0) previousFormattingFromStyle = { alignment: inheritedAlignment };
-				const inheritedFormatting = previousFormattingFromStyle === void 0 && resolvedFromStyle === void 0 ? void 0 : {
+				let previousFormattingFromStyle = sameStyle ? currentAttrs._styleResolvedFormatting : void 0;
+				if (styleResolver) previousFormattingFromStyle = styleResolver.resolveParagraphStyle(restoredStyleId).paragraphFormatting;
+				else if (inheritedAlignment !== void 0) previousFormattingFromStyle = {
 					...previousFormattingFromStyle,
-					...resolvedFromStyle
+					alignment: inheritedAlignment
 				};
 				let styleNumbering = previousFormattingFromStyle?.numPr;
 				if (!styleResolver && sameStyle) styleNumbering = currentAttrs.numPrFromStyle ?? void 0;
 				const inheritedNumbering = styleNumbering == null ? null : paragraphNumberingAttr(resolveParagraphNumbering(styleNumbering));
 				const recordedNumbering = rejection.previousFormatting?.numPr;
 				const restoredNumbering = recordedNumbering ?? inheritedNumbering;
+				const restoredFormatting = paragraphRejectOriginalFormatting(rejection.previousFormatting, node.attrs["_originalFormatting"]);
+				const indentation = listIndentationProvenancePatch({
+					direct: paragraphIndentationFromFormatting(restoredFormatting ?? void 0),
+					styleFormatting: previousFormattingFromStyle,
+					numberingSource: recordedNumbering == null ? "style" : "paragraph",
+					numPr: restoredNumbering?.kind === "reference" ? {
+						numId: restoredNumbering.numId,
+						ilvl: restoredNumbering.ilvl ?? 0
+					} : void 0,
+					numbering
+				});
+				const inheritedFormatting = {
+					...previousFormattingFromStyle,
+					...indentation._resolvedFormatting
+				};
 				Object.assign(nextAttrs, paragraphRejectAttrPatch(rejection.previousFormatting, inheritedFormatting), rejectedListRenderingPatch({
 					current: expectParagraphAttrs(node),
 					previousFormatting: rejection.previousFormatting,
@@ -54,7 +63,7 @@ const resolveParagraphChangeAttrs = ({ node, boundaryCovered, mode, revisionSet,
 					numPr: restoredNumbering,
 					numPrFromStyle: recordedNumbering == null ? inheritedNumbering : null
 				});
-				const restoredFormatting = paragraphRejectOriginalFormatting(rejection.previousFormatting, node.attrs["_originalFormatting"]);
+				Object.assign(nextAttrs, indentation);
 				nextAttrs["_originalFormatting"] = restoredFormatting;
 				if (styleResolver) nextAttrs["defaultTextFormatting"] = resolveParagraphDefaultTextFormatting(rejection.previousFormatting?.styleId, restoredFormatting ?? void 0, styleResolver) ?? null;
 			}

package/dist/prosemirror/commentOps.js

@@ -1,6 +1,14 @@
+import { addTrackedDeletionMark } from "./addTrackedDeletionMark.js";
 import { findTextInPmParagraph } from "./paraText.js";
 import { findParagraphByParaId } from "./utils/findParagraphByParaId.js";
 //#region src/prosemirror/commentOps.ts
+/**
+* Comment + tracked-change (proposeChange) PM transaction builders shared by
+* the React and Vue adapters. They locate the target range, apply the mark(s),
+* dispatch, and return a result. ID allocation lives in `commentIdAllocator.ts`
+* and is injected. Adapter-specific state mutation, event emission, and sidebar
+* UI stay in each adapter.
+*/
 /** Build a Comment object with a freshly-allocated ID. */
 function createComment(allocator, text, authorName, parentId) {
 	return {
@@ -95,7 +103,13 @@ function applyProposedChange(view, options, allocator) {
 		date
 	});
 	let tr = view.state.tr;
-	if (!isInsertion) tr = tr.addMark(textFrom, textTo, deletionMark);
+	if (!isInsertion) addTrackedDeletionMark({
+		insertionPolicy: "preserve-pending",
+		tr,
+		from: textFrom,
+		to: textTo,
+		mark: deletionMark
+	});
 	if (!isDeletion) tr = tr.insert(textTo, schema.text(options.replaceWith, [insertionMark]));
 	view.dispatch(tr);
 	return true;