@stll/folio-core 0.52.0 → 0.53.0

package/dist/prosemirror/sectionMarkEdits.js

@@ -0,0 +1,59 @@
+import { sectionPropertiesOf } from "./sectionCarrier.js";
+import { Mapping, ReplaceStep } from "prosemirror-transform";
+//#region src/prosemirror/sectionMarkEdits.ts
+const isParagraph = (node) => node.type.name === "paragraph";
+/** Read `transactions`, applied in order and ending at `finalDoc`. */
+const sectionMarkEditsOf = (transactions, finalDoc) => {
+	const deletedMarks = /* @__PURE__ */ new Set();
+	const carriers = [];
+	const replacements = [];
+	const mapping = new Mapping();
+	for (const transaction of transactions) for (const [index, step] of transaction.steps.entries()) {
+		const doc = transaction.docs[index];
+		if (step instanceof ReplaceStep && step.from < step.to && doc) replacements.push({
+			step,
+			doc,
+			mapIndex: mapping.maps.length
+		});
+		const map = transaction.mapping.maps[index];
+		if (map) mapping.appendMap(map);
+	}
+	for (const { step, doc, mapIndex } of replacements) {
+		const { from, to } = step;
+		doc.nodesBetween(from, to, (node, position) => {
+			if (!isParagraph(node)) return true;
+			const record = sectionPropertiesOf(node);
+			const markFrom = position + node.nodeSize - 1;
+			if (record && markFrom >= from && markFrom + 1 <= to) deletedMarks.add(record);
+			return false;
+		});
+		const $from = doc.resolve(from);
+		const $to = doc.resolve(to);
+		if (!isParagraph($from.parent) || !isParagraph($to.parent) || $from.start() === $to.start()) continue;
+		const leftRecord = sectionPropertiesOf($from.parent);
+		const rightRecord = sectionPropertiesOf($to.parent);
+		if (leftRecord === null && rightRecord === null) continue;
+		const after = mapping.slice(mapIndex);
+		const left = after.mapResult(from, -1);
+		const right = after.mapResult(to, 1);
+		if (right.deleted) continue;
+		const $right = finalDoc.resolve(right.pos);
+		if (!isParagraph($right.parent)) continue;
+		carriers.push({
+			position: $right.before(),
+			record: rightRecord
+		});
+		if (left.deleted) continue;
+		const $left = finalDoc.resolve(left.pos);
+		if (isParagraph($left.parent) && $left.start() !== $right.start()) carriers.push({
+			position: $left.before(),
+			record: null
+		});
+	}
+	return {
+		deletedMarks,
+		carriers
+	};
+};
+//#endregion
+export { sectionMarkEditsOf };

package/dist/prosemirror/storyListNumbering.d.ts

@@ -0,0 +1,17 @@
+import { document_d_exports } from "../types/document.js";
+import { Node } from "prosemirror-model";
+import { EditorState } from "prosemirror-state";
+//#region src/prosemirror/storyListNumbering.d.ts
+type StoryListNumbering = {
+  /** The story with every colliding list moved to its own ids. */
+  doc: Node;
+  /** `numbering` plus the lists the story defines. */
+  numbering: document_d_exports.NumberingDefinitions | undefined;
+};
+/**
+ * The story in `state` as it should be written into a package whose numbering
+ * is now `numbering`, and that numbering completed with the story's lists.
+ */
+declare const storyListNumbering: (state: EditorState, numbering: document_d_exports.NumberingDefinitions | undefined) => StoryListNumbering;
+//#endregion
+export { storyListNumbering };

package/dist/prosemirror/storyListNumbering.js

@@ -0,0 +1,102 @@
+import { getCachedNumberingMap, isBulletLevel } from "../docx/numberingParser.js";
+import { paragraphNumberingLevel, paragraphNumberingReference, paragraphNumberingReferenceId } from "../docx/numberingReference.js";
+import { expectParagraphAttrs } from "./attrs/index.js";
+import { completeNumberingForDoc, paragraphListReferences } from "./listInstanceReferences.js";
+import { paragraphNumberingAttr } from "./numberingAttr.js";
+import { getPackageNumberingDefinitions } from "./plugins/documentNumbering.js";
+import { Transform } from "prosemirror-transform";
+//#region src/prosemirror/storyListNumbering.ts
+const remappedNumPr = (numPr, numIds) => {
+	const numId = paragraphNumberingReferenceId(numPr ?? void 0);
+	const next = numId === void 0 ? void 0 : numIds.get(numId);
+	if (next === void 0) return numPr;
+	const ilvl = paragraphNumberingLevel(numPr ?? void 0);
+	return paragraphNumberingAttr(paragraphNumberingReference(ilvl === void 0 ? { numId: next } : {
+		numId: next,
+		ilvl
+	}));
+};
+const remappedAbstractNumId = (abstractNumId, remap) => {
+	if (abstractNumId === null || abstractNumId === void 0 || remap.baseAbstractNumIds.has(abstractNumId)) return abstractNumId;
+	let next = remap.abstractNumIds.get(abstractNumId);
+	if (next === void 0) {
+		next = remap.nextAbstractNumId++;
+		remap.abstractNumIds.set(abstractNumId, next);
+	}
+	return next;
+};
+const maxOf = (ids, floor) => {
+	let max = floor;
+	for (const id of ids) max = Math.max(max, id);
+	return max;
+};
+/**
+* The story in `state` as it should be written into a package whose numbering
+* is now `numbering`, and that numbering completed with the story's lists.
+*/
+const storyListNumbering = (state, numbering) => {
+	const packageDefinitions = getPackageNumberingDefinitions(state);
+	const storyBase = new Set((packageDefinitions?.nums ?? []).map(({ numId }) => numId));
+	const defined = new Set((numbering?.nums ?? []).map(({ numId }) => numId));
+	const definedMap = numbering ? getCachedNumberingMap(numbering) : null;
+	const referenced = /* @__PURE__ */ new Set();
+	const colliding = /* @__PURE__ */ new Set();
+	state.doc.descendants((node) => {
+		if (node.type.name !== "paragraph") return true;
+		for (const numId of paragraphListReferences(node)) referenced.add(numId);
+		const attrs = expectParagraphAttrs(node);
+		const numId = paragraphNumberingReferenceId(attrs.numPr);
+		if (numId !== void 0 && !storyBase.has(numId) && definedMap?.hasNumbering(numId)) {
+			const level = definedMap.getLevel(numId, paragraphNumberingLevel(attrs.numPr) ?? 0);
+			if (!(level !== null && isBulletLevel(level) === (attrs.listIsBullet === true) && (attrs.listAbstractNumId ?? void 0) === (definedMap.getAbstractNumId(numId) ?? void 0))) colliding.add(numId);
+		}
+		return false;
+	});
+	if (colliding.size === 0) return {
+		doc: state.doc,
+		numbering: completeNumberingForDoc(numbering, state.doc)
+	};
+	let nextNumId = maxOf([...defined, ...referenced], 0) + 1;
+	const remap = {
+		numIds: new Map([...colliding].map((numId) => [numId, nextNumId++])),
+		baseAbstractNumIds: new Set((packageDefinitions?.abstractNums ?? []).map(({ abstractNumId }) => abstractNumId)),
+		abstractNumIds: /* @__PURE__ */ new Map(),
+		nextAbstractNumId: maxOf((numbering?.abstractNums ?? []).map(({ abstractNumId }) => abstractNumId), -1) + 1
+	};
+	const tr = new Transform(state.doc);
+	state.doc.descendants((node, pos) => {
+		if (node.type.name !== "paragraph") return true;
+		const attrs = expectParagraphAttrs(node);
+		const numId = paragraphNumberingReferenceId(attrs.numPr);
+		const moves = numId !== void 0 && remap.numIds.has(numId);
+		const changes = attrs._propertyChanges?.map((change) => {
+			const previous = change.previousFormatting;
+			const previousNumId = paragraphNumberingReferenceId(previous?.numPr ?? void 0);
+			if (!previous || previousNumId === void 0 || !remap.numIds.has(previousNumId)) return change;
+			return {
+				...change,
+				previousFormatting: {
+					...previous,
+					numPr: remappedNumPr(previous.numPr, remap.numIds),
+					listAbstractNumId: remappedAbstractNumId(previous.listAbstractNumId, remap) ?? void 0
+				}
+			};
+		});
+		const changesMoved = changes?.some((change, index) => change !== attrs._propertyChanges?.[index]);
+		if (moves || changesMoved) tr.setNodeMarkup(pos, void 0, {
+			...node.attrs,
+			...moves ? {
+				numPr: remappedNumPr(attrs.numPr, remap.numIds),
+				listAbstractNumId: remappedAbstractNumId(attrs.listAbstractNumId, remap) ?? null
+			} : {},
+			...changesMoved ? { _propertyChanges: changes } : {}
+		});
+		return false;
+	});
+	return {
+		doc: tr.doc,
+		numbering: completeNumberingForDoc(numbering, tr.doc)
+	};
+};
+//#endregion
+export { storyListNumbering };

package/dist/prosemirror/tableGridMutation.d.ts

@@ -1,6 +1,38 @@
-import { Transaction } from "prosemirror-state";
 import { Node } from "prosemirror-model";
+import { Transaction } from "prosemirror-state";
+import { TableMap } from "prosemirror-tables";
 //#region src/prosemirror/tableGridMutation.d.ts
+type RemoveTableRowOptions = {
+  map: TableMap;
+  table: Node;
+  tableStart: number;
+};
+/**
+ * Remove one row, keeping every vertical merge that touches it whole: a merge
+ * reaching through the row from above closes one row sooner, and a cell that
+ * starts in the row and spans down moves into the row below, one row shorter.
+ *
+ * `prosemirror-tables` exports the same operation as `removeRow`, but its walk
+ * across the row skips a cell's extra columns without moving its map index
+ * along with them, so after a cell wider than one column it reads the wrong
+ * slots: a merge reaching through the row further right is never shortened,
+ * and the table is left one row shorter than that merge.
+ */
+declare const removeTableRow: (tr: Transaction, { map, table, tableStart }: RemoveTableRowOptions, row: number) => void;
+/**
+ * Remove every row a structural edit left without a cell of its own, closing
+ * the vertical merges that reached through it over one row fewer.
+ *
+ * Deleting the only column a row still had a cell in, or merging whole rows
+ * together, leaves a row holding nothing but the merges from above. The
+ * editable model can carry such a row, but nothing else agrees with it: a
+ * package spells it as a row of `w:vMerge` continuations, which the reader
+ * gives a cell of its own by splitting the merge apart, so the reopened table
+ * differs from the one the operation reported. Accepting the same deletion
+ * tracked removes the cells one at a time and the row with its last one,
+ * which is this result; the two modes have to leave the same table.
+ */
+declare const removeRowsWithoutCells: (tr: Transaction, tablePosition: number) => void;
 type ReconcileTableGridAfterColumnRemovalOptions = {
   tr: Transaction;
   tablePosition: number;
@@ -16,5 +48,19 @@ type ReconcileTableGridAfterColumnRemovalOptions = {
  * the old grid; reopening then has to interpret surviving cells as spans.
  */
 declare const reconcileTableGridAfterColumnRemoval: ({ tr, tablePosition, previousTable, removedColumn }: ReconcileTableGridAfterColumnRemovalOptions) => void;
+type ReconcileTableGridAfterColumnInsertionOptions = {
+  tr: Transaction;
+  tablePosition: number;
+  previousTable: Node;
+  insertedColumn: number;
+};
+/**
+ * The same for a physical column insertion: the new grid column takes the
+ * width of the column beside it, and the table grows by it.
+ *
+ * Without it the table keeps the grid it had, so every row spans one column
+ * more than `w:tblGrid` declares.
+ */
+declare const reconcileTableGridAfterColumnInsertion: ({ tr, tablePosition, previousTable, insertedColumn }: ReconcileTableGridAfterColumnInsertionOptions) => void;
 //#endregion
-export { reconcileTableGridAfterColumnRemoval };
+export { reconcileTableGridAfterColumnInsertion, reconcileTableGridAfterColumnRemoval, removeRowsWithoutCells, removeTableRow };

package/dist/prosemirror/tableGridMutation.js

@@ -2,6 +2,77 @@ import { expectTableAttrs, mergeTableAttrs } from "./attrs/index.js";
 import { TableMap } from "prosemirror-tables";
 //#region src/prosemirror/tableGridMutation.ts
 /**
+* Remove one row, keeping every vertical merge that touches it whole: a merge
+* reaching through the row from above closes one row sooner, and a cell that
+* starts in the row and spans down moves into the row below, one row shorter.
+*
+* `prosemirror-tables` exports the same operation as `removeRow`, but its walk
+* across the row skips a cell's extra columns without moving its map index
+* along with them, so after a cell wider than one column it reads the wrong
+* slots: a merge reaching through the row further right is never shortened,
+* and the table is left one row shorter than that merge.
+*/
+const removeTableRow = (tr, { map, table, tableStart }, row) => {
+	let rowPosition = 0;
+	for (let index = 0; index < row; index++) rowPosition += table.child(index).nodeSize;
+	const nextRow = rowPosition + table.child(row).nodeSize;
+	const mapFrom = tr.mapping.maps.length;
+	tr.delete(tableStart + rowPosition, tableStart + nextRow);
+	for (let column = 0; column < map.width;) {
+		const index = row * map.width + column;
+		const position = map.map[index];
+		const cell = position === void 0 ? null : table.nodeAt(position);
+		if (position === void 0 || !cell) {
+			column += 1;
+			continue;
+		}
+		const colspan = Math.max(1, Number(cell.attrs["colspan"]) || 1);
+		const rowspan = Math.max(1, Number(cell.attrs["rowspan"]) || 1);
+		if (row > 0 && position === map.map[index - map.width]) tr.setNodeMarkup(tr.mapping.slice(mapFrom).map(tableStart + position), null, {
+			...cell.attrs,
+			rowspan: rowspan - 1
+		});
+		else if (row + 1 < map.height && position === map.map[index + map.width]) {
+			const moved = cell.type.create({
+				...cell.attrs,
+				rowspan: rowspan - 1
+			}, cell.content);
+			const below = map.positionAt(row + 1, column, table);
+			tr.insert(tr.mapping.slice(mapFrom).map(tableStart + below), moved);
+		}
+		column += colspan;
+	}
+};
+/**
+* Remove every row a structural edit left without a cell of its own, closing
+* the vertical merges that reached through it over one row fewer.
+*
+* Deleting the only column a row still had a cell in, or merging whole rows
+* together, leaves a row holding nothing but the merges from above. The
+* editable model can carry such a row, but nothing else agrees with it: a
+* package spells it as a row of `w:vMerge` continuations, which the reader
+* gives a cell of its own by splitting the merge apart, so the reopened table
+* differs from the one the operation reported. Accepting the same deletion
+* tracked removes the cells one at a time and the row with its last one,
+* which is this result; the two modes have to leave the same table.
+*/
+const removeRowsWithoutCells = (tr, tablePosition) => {
+	for (;;) {
+		const table = tr.doc.nodeAt(tablePosition);
+		if (!table || table.type.spec["tableRole"] !== "table" || table.childCount < 2) return;
+		let emptyRow = -1;
+		table.forEach((row, _offset, index) => {
+			if (emptyRow === -1 && row.childCount === 0) emptyRow = index;
+		});
+		if (emptyRow === -1) return;
+		removeTableRow(tr, {
+			map: TableMap.get(table),
+			table,
+			tableStart: tablePosition + 1
+		}, emptyRow);
+	}
+};
+/**
 * Keep the editable table grid aligned with a physical column removal.
 *
 * `prosemirror-tables` owns cell topology, but Folio separately retains the
@@ -18,6 +89,40 @@ const reconcileTableGridAfterColumnRemoval = ({ tr, tablePosition, previousTable
 	const removedColumnCount = previousColumnCount - columnCount;
 	const previousWidths = expectTableAttrs(previousTable).columnWidths;
 	const columnWidths = previousWidths?.length === previousColumnCount ? previousWidths.toSpliced(removedColumn, removedColumnCount) : void 0;
+	setTableGrid({
+		tr,
+		tablePosition,
+		table,
+		columnWidths,
+		columnCount
+	});
+};
+/**
+* The same for a physical column insertion: the new grid column takes the
+* width of the column beside it, and the table grows by it.
+*
+* Without it the table keeps the grid it had, so every row spans one column
+* more than `w:tblGrid` declares.
+*/
+const reconcileTableGridAfterColumnInsertion = ({ tr, tablePosition, previousTable, insertedColumn }) => {
+	const previousColumnCount = TableMap.get(previousTable).width;
+	const table = tr.doc.nodeAt(tablePosition);
+	if (!table || table.type.spec["tableRole"] !== "table") return;
+	const columnCount = TableMap.get(table).width;
+	if (columnCount <= previousColumnCount) return;
+	const insertedColumnCount = columnCount - previousColumnCount;
+	const previousWidths = expectTableAttrs(previousTable).columnWidths;
+	const neighbourWidth = previousWidths?.[Math.max(0, Math.min(insertedColumn, previousColumnCount) - 1)] ?? previousWidths?.[0];
+	const columnWidths = previousWidths?.length === previousColumnCount && neighbourWidth !== void 0 ? previousWidths.toSpliced(insertedColumn, 0, ...Array.from({ length: insertedColumnCount }, () => neighbourWidth)) : void 0;
+	setTableGrid({
+		tr,
+		tablePosition,
+		table,
+		columnWidths,
+		columnCount
+	});
+};
+const setTableGrid = ({ tr, tablePosition, table, columnWidths, columnCount }) => {
 	const formatting = expectTableAttrs(table)._originalFormatting;
 	const originalFormatting = formatting ? { ...formatting } : void 0;
 	if (originalFormatting) delete originalFormatting.gridSourceXml;
@@ -27,4 +132,4 @@ const reconcileTableGridAfterColumnRemoval = ({ tr, tablePosition, previousTable
 	}));
 };
 //#endregion
-export { reconcileTableGridAfterColumnRemoval };
+export { reconcileTableGridAfterColumnInsertion, reconcileTableGridAfterColumnRemoval, removeRowsWithoutCells, removeTableRow };

package/dist/prosemirror/validation.js

@@ -1,4 +1,4 @@
-import { readBlockSdtAttrs, readCharacterSpacingMarkAttrs, readCharacterStyleMarkAttrs, readCommentMarkAttrs, readEmphasisMarkAttrs, readFieldAttrs, readFontFamilyMarkAttrs, readFontSizeMarkAttrs, readFootnoteRefMarkAttrs, readHardBreakAttrs, readHighlightMarkAttrs, readHyperlinkMarkAttrs, readImageAttrs, readInlineWrapperMarkAttrs, readLanguageMarkAttrs, readMathAttrs, readPageBreakRunAttrs, readParagraphAttrs, readPreservedBlockAttrs, readPreservedXmlAttrs, readRunFormattingOverrideMarkAttrs, readRunIdentityMarkAttrs, readRunPropertyChangeMarkAttrs, readRunShadingMarkAttrs, readSdtAttrs, readShapeAttrs, readStrikeMarkAttrs, readSymbolAttrs, readTabAttrs, readTableAttrs, readTableCellAttrs, readTableRowAttrs, readTextBoxAttrs, readTextColorMarkAttrs, readTextEffectMarkAttrs, readTrackedChangeMarkAttrs, readUnderlineMarkAttrs } from "./attrs/index.js";
+import { readBlockCustomXmlAttrs, readBlockSdtAttrs, readCharacterSpacingMarkAttrs, readCharacterStyleMarkAttrs, readCommentMarkAttrs, readEmphasisMarkAttrs, readFieldAttrs, readFontFamilyMarkAttrs, readFontSizeMarkAttrs, readFootnoteRefMarkAttrs, readHardBreakAttrs, readHighlightMarkAttrs, readHyperlinkMarkAttrs, readImageAttrs, readInlineWrapperMarkAttrs, readLanguageMarkAttrs, readMathAttrs, readPageBreakRunAttrs, readParagraphAttrs, readPreservedBlockAttrs, readPreservedXmlAttrs, readRunFormattingOverrideMarkAttrs, readRunIdentityMarkAttrs, readRunPropertyChangeMarkAttrs, readRunShadingMarkAttrs, readSdtAttrs, readShapeAttrs, readStrikeMarkAttrs, readSymbolAttrs, readTabAttrs, readTableAttrs, readTableCellAttrs, readTableRowAttrs, readTextBoxAttrs, readTextColorMarkAttrs, readTextEffectMarkAttrs, readTrackedChangeMarkAttrs, readUnderlineMarkAttrs } from "./attrs/index.js";
 import { readBookmarkBoundaryAttrs } from "./bookmarkBoundaryAttrs.js";
 import { readCommentReferenceAttrs } from "./commentReferenceAttrs.js";
 import { INLINE_WRAPPER_MARK_NAME } from "./extensions/marks/InlineWrapperExtension.js";
@@ -288,6 +288,10 @@ const validateNodeAttrs = (node, path, issues) => {
 			appendAttrIssues(path, readBlockSdtAttrs(node), issues);
 			for (let i = 0; i < node.childCount; i += 1) validateNode(node.child(i), `${path}.content[${i}]`, issues);
 			return;
+		case "blockCustomXml":
+			appendAttrIssues(path, readBlockCustomXmlAttrs(node), issues);
+			for (let i = 0; i < node.childCount; i += 1) validateNode(node.child(i), `${path}.content[${i}]`, issues);
+			return;
 		case "shape":
 			appendAttrIssues(path, readShapeAttrs(node), issues);
 			return;

package/dist/redline.js

@@ -1,4 +1,4 @@
-import { FolioDocxReviewer, isFolioResolvedReviewedView } from "./ai-edits/headless.js";
+import { FolioDocxReviewer, getFolioDocxComparisonAccess, isFolioResolvedReviewedView } from "./ai-edits/headless.js";
 import { createFolioAITextRangeHandle, trailingBodyBlockId } from "./ai-edits/snapshot.js";
 import { createScopedWordDiffOptions } from "./ai-edits/word-diff.js";
 import { FolioContentInlinePresentationProjectionError } from "./compare/content.js";
@@ -77,6 +77,7 @@ const buildRedlineOperations = ({ baseSnapshot, revisedBlocks, nextOperationId }
 	const operations = [];
 	const trailingAdditions = [];
 	const lastBaseBlockId = trailingBodyBlockId(baseSnapshot);
+	const baseBlocksById = new Map(baseSnapshot.blocks.map((block) => [block.id, block]));
 	events.forEach((event, eventIndex) => {
 		if (event.type === "pair") {
 			if (event.baseBlock.text !== event.revisedBlock.text) operations.push({
@@ -102,10 +103,7 @@ const buildRedlineOperations = ({ baseSnapshot, revisedBlocks, nextOperationId }
 		}
 		const anchorId = anchorIds[eventIndex] ?? null;
 		if (anchorId === null) {
-			trailingAdditions.push({
-				text: event.block.text,
-				...event.block.styleId !== void 0 && { styleId: event.block.styleId }
-			});
+			trailingAdditions.push(event.block);
 			return;
 		}
 		operations.push({
@@ -113,7 +111,7 @@ const buildRedlineOperations = ({ baseSnapshot, revisedBlocks, nextOperationId }
 			type: "insertBeforeBlock",
 			blockId: anchorId,
 			text: event.block.text,
-			...event.block.styleId !== void 0 && { styleId: event.block.styleId }
+			...insertedParagraphProperties(event.block, baseBlocksById.get(anchorId))
 		});
 	});
 	for (const addition of trailingAdditions) operations.push({
@@ -121,10 +119,85 @@ const buildRedlineOperations = ({ baseSnapshot, revisedBlocks, nextOperationId }
 		type: "insertAfterBlock",
 		blockId: lastBaseBlockId ?? "redline-unanchored",
 		text: addition.text,
-		...addition.styleId !== void 0 && { styleId: addition.styleId }
+		...insertedParagraphProperties(addition, lastBaseBlockId === null ? void 0 : baseBlocksById.get(lastBaseBlockId))
 	});
 	return operations;
 };
+/**
+* The revised value, or `null` to clear one the anchor would pass on, or
+* `undefined` when neither has one: an explicit `null` costs a restyle pass.
+*/
+const statedOrCleared = (revised, anchor) => revised ?? (anchor === void 0 ? void 0 : null);
+/**
+* The paragraph properties an inserted block states. An insertion that says
+* nothing takes the properties of its anchor, which is whichever base block
+* happens to follow it, so whatever the anchor states and the revised block
+* does not is cleared: a list item keeps its numbering, and a plain paragraph
+* beside a list item stays plain.
+*/
+const insertedParagraphProperties = (block, anchor) => {
+	const properties = {};
+	const styleId = statedOrCleared(block.styleId, anchor?.styleId);
+	if (styleId !== void 0) properties.styleId = styleId;
+	const alignment = statedOrCleared(block.directAlignment, anchor?.directAlignment);
+	if (alignment !== void 0) properties.alignment = alignment;
+	const spacing = statedOrCleared(block.directSpacing, anchor?.directSpacing);
+	if (spacing !== void 0) properties.spacing = spacing;
+	const indentation = statedOrCleared(block.directIndentation, anchor?.directIndentation);
+	if (indentation !== void 0) properties.indentation = indentation;
+	if (block.listReference !== void 0 || anchor?.listReference !== void 0 || anchor?.listLevel !== void 0) {
+		properties.numbering = block.listReference ?? null;
+		properties.listLevel = block.listLevel ?? null;
+	} else if (block.listLevel !== void 0) properties.listLevel = block.listLevel;
+	return properties;
+};
+const insertedNumbering = (operation) => {
+	if (operation.type !== "insertBeforeBlock" && operation.type !== "insertAfterBlock") return null;
+	const numbering = operation.numbering;
+	return numbering && !("start" in numbering) ? numbering : null;
+};
+/** The `w:numId`s whose `w:num` and abstract definition both exist. */
+const definedNumIds = (numbering) => {
+	const abstractIds = new Set(numbering?.abstractNums.map((entry) => entry.abstractNumId));
+	return new Set((numbering?.nums ?? []).filter((entry) => abstractIds.has(entry.abstractNumId)).map((entry) => entry.numId));
+};
+/**
+* Rebind every inserted list item to numbering the redline package defines.
+* The redline is the base package, where the revised version's `w:numId` may
+* name nothing, or another list: the referenced definitions are copied in,
+* under a fresh id wherever the base uses that one for different numbering.
+* A reference the revised package cannot resolve shows no number there
+* either, and is inserted without one.
+*/
+const bindInsertedNumbering = (baseReviewer, revisedReviewer, operationsByStory) => {
+	const baseAccess = getFolioDocxComparisonAccess(baseReviewer);
+	const revisedNumbering = getFolioDocxComparisonAccess(revisedReviewer).numberingDefinitions();
+	const resolvable = definedNumIds(revisedNumbering);
+	const references = operationsByStory.flatMap((operations) => operations.flatMap((operation) => {
+		const numbering = insertedNumbering(operation);
+		return numbering && resolvable.has(numbering.numId) ? [numbering] : [];
+	}));
+	const remapped = baseAccess.planTargetNumberingReferences(revisedNumbering, references) ?? panic("Resolvable revised numbering references could not be planned");
+	baseAccess.stageTargetNumbering(revisedNumbering, references, remapped);
+	const defined = definedNumIds(baseAccess.numberingDefinitions());
+	return operationsByStory.map((operations) => operations.map((operation) => {
+		const numbering = insertedNumbering(operation);
+		if (numbering === null) return operation;
+		const numId = remapped.get(numbering.numId) ?? numbering.numId;
+		if (!resolvable.has(numbering.numId) || !defined.has(numId)) return {
+			...operation,
+			numbering: null,
+			listLevel: null
+		};
+		return {
+			...operation,
+			numbering: {
+				numId,
+				level: numbering.level
+			}
+		};
+	}));
+};
 const resolveInputView = (value, option) => {
 	if (value === void 0) return "final";
 	if (!isFolioResolvedReviewedView(value)) throw new InvalidGenerateRedlineDocxOptionsError({
@@ -155,6 +228,7 @@ const generateRedlineDocx = async (base, revised, options = {}) => {
 		if (operationSequence >= 1e4) throw new GenerateRedlineDocxOperationLimitError({ message: "The document comparison exceeds the generated operation limit." });
 		return `redline-${++operationSequence}`;
 	};
+	const plannedStories = [];
 	for (const pair of pairFolioDocumentStories(baseStories, revisedStories)) {
 		if (!pair.baseStory) {
 			unprocessedStories.push({
@@ -182,15 +256,25 @@ const generateRedlineDocx = async (base, revised, options = {}) => {
 			nextOperationId
 		});
 		if (operations.length === 0) continue;
-		const result = baseReviewer.applyDocumentOperationsToStory({
+		plannedStories.push({
 			story: pair.baseStory,
 			snapshot: baseSnapshot,
+			operations
+		});
+	}
+	const boundOperations = bindInsertedNumbering(baseReviewer, revisedReviewer, plannedStories.map(({ operations }) => operations));
+	for (const [index, { story, snapshot }] of plannedStories.entries()) {
+		const operations = boundOperations[index] ?? panic("A planned story lost its operations");
+		const result = baseReviewer.applyDocumentOperationsToStory({
+			story,
+			snapshot,
 			batch: {
 				version: 1,
 				mode: "tracked-changes",
 				operations
 			},
-			wordDiff
+			wordDiff,
+			undefinedStyles: "keep"
 		});
 		applied.push(...result.applied);
 		skipped.push(...result.skipped);

package/dist/render-dom/BodySelectionOverlay.d.ts

@@ -1,3 +1,4 @@
+import { DisplayMode } from "../managers/EditorModeManager.js";
 import { EditorState } from "prosemirror-state";
 //#region src/render-dom/BodySelectionOverlay.d.ts
 type BodySelectionOverlayResult = {
@@ -10,6 +11,8 @@ type BodySelectionOverlayResult = {
 type SyncBodySelectionOverlayOptions = {
   pagesContainer: HTMLElement;
   state: EditorState;
+  /** The review view the pages were laid out for; a caret in text it hides paints at its edge. */
+  markupView: DisplayMode;
   zoom: number;
   zIndex?: number;
   caretColor?: string;
@@ -17,7 +20,7 @@ type SyncBodySelectionOverlayOptions = {
 };
 declare class BodySelectionOverlay {
   clear(pagesContainer: HTMLElement): void;
-  sync({ pagesContainer, state, zoom, zIndex, caretColor, selectionColor }: SyncBodySelectionOverlayOptions): BodySelectionOverlayResult;
+  sync({ pagesContainer, state, markupView, zoom, zIndex, caretColor, selectionColor }: SyncBodySelectionOverlayOptions): BodySelectionOverlayResult;
 }
 //#endregion
 export { BodySelectionOverlay, BodySelectionOverlayResult, SyncBodySelectionOverlayOptions };

package/dist/render-dom/BodySelectionOverlay.js

@@ -2,6 +2,7 @@ import { applyCellSelectionHighlight } from "../layout-bridge/cellSelectionHighl
 import { getCaretPositionFromDom, getSelectionRectsFromDom } from "../layout-bridge/dom/clickToPositionDom.js";
 import { findBodyPmAnchor } from "../layout-bridge/dom/findBodyPmSpans.js";
 import { findImageElement } from "../layout-painter/imageLayout.js";
+import { projectMarkupView, visibleCaretPosition } from "../prosemirror/markupViewProjection.js";
 import { NodeSelection } from "prosemirror-state";
 //#region src/render-dom/BodySelectionOverlay.ts
 /**
@@ -23,7 +24,7 @@ var BodySelectionOverlay = class {
 	clear(pagesContainer) {
 		for (const element of pagesContainer.querySelectorAll(OWNED_OVERLAY_SELECTOR)) element.remove();
 	}
-	sync({ pagesContainer, state, zoom, zIndex = 10, caretColor = "var(--doc-caret, #000)", selectionColor = "var(--doc-selection, rgba(66, 133, 244, 0.3))" }) {
+	sync({ pagesContainer, state, markupView, zoom, zIndex = 10, caretColor = "var(--doc-caret, #000)", selectionColor = "var(--doc-selection, rgba(66, 133, 244, 0.3))" }) {
 		this.clear(pagesContainer);
 		applyCellSelectionHighlight(pagesContainer, state);
 		const { selection } = state;
@@ -37,7 +38,7 @@ var BodySelectionOverlay = class {
 			};
 		}
 		if (selection.empty) {
-			const caret = getCaretPositionFromDom(pagesContainer, selection.from, pagesContainer.getBoundingClientRect());
+			const caret = getCaretPositionFromDom(pagesContainer, visibleCaretPosition(projectMarkupView(state, markupView), selection.from), pagesContainer.getBoundingClientRect());
 			if (!caret) return { type: "text" };
 			const element = pagesContainer.ownerDocument.createElement("div");
 			element.className = CARET_CLASS;

package/dist/utils/findReplace.js

@@ -66,7 +66,7 @@ const forEachParagraph = (blocks, visit) => {
 				walkTable(block);
 				continue;
 			}
-			if (isBlockSdt(block)) walkBlocks(block.content);
+			if (isBlockContainer(block)) walkBlocks(block.content);
 		}
 	};
 	const walkTable = (table) => {
@@ -172,6 +172,6 @@ const isParagraph = (value) => isRecord(value) && value["type"] === "paragraph"
 const isTable = (value) => isRecord(value) && value["type"] === "table" && Array.isArray(value["rows"]);
 const isTableRow = (value) => isRecord(value) && Array.isArray(value["cells"]);
 const isTableCell = (value) => isRecord(value) && Array.isArray(value["content"]);
-const isBlockSdt = (value) => isRecord(value) && value["type"] === "blockSdt" && Array.isArray(value["content"]);
+const isBlockContainer = (value) => isRecord(value) && (value["type"] === "blockSdt" || value["type"] === "blockCustomXml") && Array.isArray(value["content"]);
 //#endregion
 export { createDefaultFindOptions, createSearchPattern, escapeRegexString, findAllMatches, findInDocument, findInParagraph };

package/dist/utils/mergeDocumentContent.js

@@ -86,7 +86,7 @@ function mergeDocumentContent(target, source) {
 function remapBlock(block, numIdRemap, abstractNumIdRemap) {
 	if (block.type === "paragraph") return remapParagraph(block, numIdRemap, abstractNumIdRemap);
 	if (block.type === "table") return remapTable(block, numIdRemap, abstractNumIdRemap);
-	if (block.type === "blockSdt" && Array.isArray(block.content)) return {
+	if ((block.type === "blockSdt" || block.type === "blockCustomXml") && Array.isArray(block.content)) return {
 		...block,
 		content: block.content.map((child) => remapBlock(child, numIdRemap, abstractNumIdRemap))
 	};

package/dist/utils/noteReferenceLabels.d.ts

@@ -0,0 +1,36 @@
+//#region src/utils/noteReferenceLabels.d.ts
+/**
+ * How a reader shows a footnote or endnote reference.
+ *
+ * A reference's `w:id` is a package key, not something a reader sees: the
+ * rendered document numbers notes by the order they are first referenced
+ * (1, 2, 3 …), whatever ids the package gave them. Every reader that puts a reference in a line of
+ * text — the Markdown export, `getContent()`, the AI snapshot and the agent
+ * tools built on it — numbers through {@link createNoteReferenceNumbering}, so
+ * the same reference reads as the same marker everywhere.
+ *
+ * Footnotes and endnotes are numbered in separate sequences; an
+ * endnote's token carries an `e` so the two sequences never collide
+ * (`[^1]` is footnote 1, `[^e1]` is endnote 1).
+ */
+type NoteReferenceKind = "footnote" | "endnote";
+/** The bare token: `1` for footnote 1, `e1` for endnote 1. */
+declare const noteReferenceToken: (kind: NoteReferenceKind, displayNumber: number) => string;
+/** The marker a text reader shows in the line: `[^1]`, `[^e1]`. */
+declare const noteReferenceMarker: (kind: NoteReferenceKind, displayNumber: number) => string;
+type NoteReferenceNumber = {
+  displayNumber: number;
+  /** Whether this is the note's first reference in reading order. */
+  first: boolean;
+};
+type NoteReferenceNumbering = {
+  /** Number one reference, in reading order. */
+  next: (kind: NoteReferenceKind, noteId: string | number) => NoteReferenceNumber;
+};
+/**
+ * A reading-order numbering: each note takes the next number of its kind the
+ * first time it is referenced, and a repeated reference reuses it.
+ */
+declare const createNoteReferenceNumbering: () => NoteReferenceNumbering;
+//#endregion
+export { NoteReferenceKind, NoteReferenceNumber, NoteReferenceNumbering, createNoteReferenceNumbering, noteReferenceMarker, noteReferenceToken };