@stll/folio-core 0.51.0 → 0.53.0

package/dist/prosemirror/extensions/features/ParagraphChangeTrackerExtension.js

@@ -1,8 +1,13 @@
+import { withTrackedSectionEndpointRemoval } from "../../../internal/sectionEndpointResolution.js";
 import { canonicalJson } from "../../../utils/canonicalJson.js";
+import { enclosingParagraphIndexed, nodeAtIndexed, nodesBetweenIndexed } from "../../indexedNodeLookup.js";
+import { sweepPositions } from "../../positionSweep.js";
 import { sectionPropertiesOf } from "../../sectionCarrier.js";
+import { sectionMarkEditsOf } from "../../sectionMarkEdits.js";
 import { createExtension } from "../create.js";
 import { AddMarkStep, AddNodeMarkStep, AttrStep, RemoveMarkStep, RemoveNodeMarkStep } from "prosemirror-transform";
 import { Plugin, PluginKey } from "prosemirror-state";
+import { isHistoryTransaction } from "prosemirror-history";
 //#region src/prosemirror/extensions/features/ParagraphChangeTrackerExtension.ts
 const paragraphChangeTrackerKey = new PluginKey("paragraphChangeTracker");
 const CLEAR_META = "clear";
@@ -10,14 +15,16 @@ const IGNORE_META = "ignore";
 const STRUCTURAL_META = "structural";
 const CHANGED_PARAGRAPH_RANGES_META = "folioChangedParagraphRanges";
 const SECTION_ENDPOINT_REMOVAL_META = "folioSectionEndpointRemoval";
+const SECTION_EDIT_META = "folioSectionEdit";
 const isChangedParagraphRangesMeta = (value) => typeof value === "object" && value !== null && "type" in value && value.type === "changed-paragraph-ranges";
 const isRemovedSectionReference = (value) => typeof value === "object" && value !== null && "part" in value && (value.part === "header" || value.part === "footer") && "type" in value && (value.type === "default" || value.type === "first" || value.type === "even") && "relationshipId" in value && typeof value.relationshipId === "string";
 const isTrackedSectionEndpointRemoval = (value) => typeof value === "object" && value !== null && "type" in value && value.type === "tracked-section-endpoint-removal" && "sourceParagraphEndpointCount" in value && typeof value.sourceParagraphEndpointCount === "number" && Number.isSafeInteger(value.sourceParagraphEndpointCount) && "expectedParagraphEndpointCount" in value && typeof value.expectedParagraphEndpointCount === "number" && Number.isSafeInteger(value.expectedParagraphEndpointCount) && value.sourceParagraphEndpointCount > value.expectedParagraphEndpointCount && value.expectedParagraphEndpointCount >= 0 && "sourceEndpointFingerprint" in value && typeof value.sourceEndpointFingerprint === "string" && "expectedEndpointFingerprint" in value && typeof value.expectedEndpointFingerprint === "string" && "removedReferences" in value && Array.isArray(value.removedReferences) && value.removedReferences.every(isRemovedSectionReference);
 const isTrackedSectionEndpointRemovalMeta = (value) => typeof value === "object" && value !== null && "type" in value && value.type === "tracked-section-endpoint-removal-meta" && "authorization" in value && isTrackedSectionEndpointRemoval(value.authorization);
+const isSectionEditMeta = (value) => typeof value === "object" && value !== null && "type" in value && value.type === "section-edit-meta" && "authorization" in value && (value.authorization === null || isTrackedSectionEndpointRemoval(value.authorization)) && "expectedEndpointFingerprint" in value && typeof value.expectedEndpointFingerprint === "string";
 /** Count the structural values the tracker compares for every transaction. */
 function countDocumentStructure(doc) {
 	let paragraphs = 0;
-	let sectionEndpoints = 0;
+	const sectionRecords = /* @__PURE__ */ new Set();
 	const blockRecords = [];
 	const endpointRecords = [];
 	const visit = (parent, parentPath) => {
@@ -36,7 +43,7 @@ function countDocumentStructure(doc) {
 				paragraphs++;
 				const sectionProperties = sectionPropertiesOf(node);
 				if (sectionProperties !== null) {
-					sectionEndpoints++;
+					sectionRecords.add(sectionProperties);
 					endpointRecords.push({
 						path: parentPath.length === 0 ? `${index}` : `${parentPath}.${index}`,
 						paraId: node.attrs["paraId"] ?? null,
@@ -51,11 +58,21 @@ function countDocumentStructure(doc) {
 	visit(doc, "");
 	return {
 		blockStructureFingerprint: JSON.stringify(blockRecords),
+		sectionRecords,
 		paragraphs,
-		sectionEndpoints,
+		sectionEndpoints: sectionRecords.size,
 		sectionEndpointFingerprint: canonicalJson(endpointRecords)
 	};
 }
+/**
+* Whether a transaction left every section record in place, by identity: the
+* same sections, however their paragraphs moved around them. An edit before a
+* section break (a paragraph inserted, a split, a paraId allocated) moves the
+* endpoint without changing which sections the package states, so a removal
+* authorized earlier still describes the saved section count exactly. A record
+* edited, added or dropped is a new transition the authorization never saw.
+*/
+const holdsTheSameSections = (previous, next) => previous.sectionRecords.size === next.sectionRecords.size && [...next.sectionRecords].every((record) => previous.sectionRecords.has(record));
 const isUsableParaId = (value) => typeof value === "string" && value.length > 0 && value !== "00000000";
 /**
 * Collect paraIds of all paragraphs that overlap with the given range
@@ -64,7 +81,8 @@ function collectAffectedParaIds(doc, from, to) {
 	const ids = /* @__PURE__ */ new Set();
 	const positions = /* @__PURE__ */ new Set();
 	let hasUntracked = false;
-	doc.nodesBetween(from, to, (node, pos) => {
+	const start = Math.max(0, Math.min(from, doc.content.size));
+	nodesBetweenIndexed(doc, start, Math.max(start, Math.min(to, doc.content.size)), (node, pos) => {
 		if (node.type.name === "paragraph") {
 			positions.add(pos);
 			const paraId = node.attrs["paraId"];
@@ -88,17 +106,14 @@ function collectAffectedParaIdsFromMarkLikeStep(doc, from, to) {
 	const hi = Math.max(from, to);
 	const primary = collectAffectedParaIds(doc, lo, hi > lo ? hi : lo + 1);
 	if (primary.ids.size > 0 || primary.hasUntracked) return primary;
-	const $p = doc.resolve(lo);
-	for (let depth = $p.depth; depth > 0; depth--) {
-		const node = $p.node(depth);
-		if (node.type.name === "paragraph") {
-			const paraId = node.attrs["paraId"];
-			return {
-				ids: new Set(isUsableParaId(paraId) ? [paraId] : []),
-				positions: /* @__PURE__ */ new Set([$p.before(depth)]),
-				hasUntracked: !isUsableParaId(paraId)
-			};
-		}
+	const paragraph = enclosingParagraphIndexed(doc, lo);
+	if (paragraph) {
+		const paraId = paragraph.node.attrs["paraId"];
+		return {
+			ids: new Set(isUsableParaId(paraId) ? [paraId] : []),
+			positions: /* @__PURE__ */ new Set([paragraph.pos]),
+			hasUntracked: !isUsableParaId(paraId)
+		};
 	}
 	return {
 		ids: /* @__PURE__ */ new Set(),
@@ -106,25 +121,78 @@ function collectAffectedParaIdsFromMarkLikeStep(doc, from, to) {
 		hasUntracked: false
 	};
 }
-/** Map an edited paragraph's interior so markup replacement retains its ownership. */
-const mapParagraphPosition = (tr, position) => {
-	const mapped = tr.mapping.mapResult(position + 1, 1);
-	if (mapped.deletedAcross) return null;
-	const $position = tr.doc.resolve(mapped.pos);
-	for (let depth = $position.depth; depth > 0; depth--) if ($position.node(depth).type.name === "paragraph") return $position.before(depth);
-	return null;
-};
+/**
+* Map edited paragraphs' interiors so markup replacement retains their
+* ownership: each position's paragraph in `tr.doc`, or null once deleted. The
+* positions go through the transaction together (see `sweepPositions`).
+*/
+const mapParagraphPositions = (tr, positions) => sweepPositions([tr.mapping], positions.map((position) => ({
+	pos: position + 1,
+	assoc: 1,
+	from: 0
+}))).map((mapped) => mapped.deletedAcross ? null : enclosingParagraphIndexed(tr.doc, mapped.pos)?.pos ?? null);
 const mapAffectedParagraphPositions = (tr, positions) => {
 	const mappedPositions = /* @__PURE__ */ new Set();
-	for (const position of positions) {
-		const mapped = mapParagraphPosition(tr, position);
-		if (mapped !== null) mappedPositions.add(mapped);
-	}
+	for (const mapped of mapParagraphPositions(tr, [...positions])) if (mapped !== null) mappedPositions.add(mapped);
 	return mappedPositions;
 };
-function mapStepPosition(remap, pos, assoc) {
-	return remap.map(pos, assoc);
-}
+/**
+* Every position the step loop reads, each entering the sweep at the step
+* after the one that produced it: the transaction is mapped once rather than
+* sliced and walked again for every step.
+*/
+const mapStepTouches = (tr, batches) => {
+	const queries = [];
+	const touches = [];
+	const addRange = (kind, from, to, at) => {
+		touches.push({
+			kind,
+			query: queries.length
+		});
+		queries.push({
+			pos: from,
+			assoc: 1,
+			from: at
+		}, {
+			pos: to,
+			assoc: -1,
+			from: at
+		});
+	};
+	const replacedStepMaps = /* @__PURE__ */ new Set();
+	for (const batch of batches) {
+		if (batch.replacesStepMapAt !== void 0) replacedStepMaps.add(batch.replacesStepMapAt);
+		for (const range of batch.ranges) addRange("mark-range", range.from, range.to, batch.mappingFrom);
+	}
+	for (let stepIndex = 0; stepIndex < tr.steps.length; stepIndex++) {
+		if (replacedStepMaps.has(stepIndex)) continue;
+		const step = tr.steps[stepIndex];
+		const at = stepIndex + 1;
+		if (step instanceof AddMarkStep || step instanceof RemoveMarkStep) {
+			addRange("mark-range", step.from, step.to, at);
+			continue;
+		}
+		if (step instanceof AddNodeMarkStep || step instanceof RemoveNodeMarkStep || step instanceof AttrStep) {
+			touches.push({
+				kind: "node",
+				query: queries.length
+			});
+			queries.push({
+				pos: step.pos,
+				assoc: 1,
+				from: at
+			});
+			continue;
+		}
+		step.getMap().forEach((_oldStart, _oldEnd, newStart, newEnd) => {
+			addRange("replaced-range", newStart, newEnd, at);
+		});
+	}
+	return {
+		touches,
+		mapped: sweepPositions([tr.mapping], queries)
+	};
+};
 function createParagraphChangeTrackerPlugin() {
 	return new Plugin({
 		key: paragraphChangeTrackerKey,
@@ -141,6 +209,7 @@ function createParagraphChangeTrackerPlugin() {
 					paragraphCount: counts.paragraphs,
 					sectionEndpointCount: counts.sectionEndpoints,
 					sectionEndpointFingerprint: counts.sectionEndpointFingerprint,
+					sectionRecords: counts.sectionRecords,
 					sectionEndpointRemoval: null
 				};
 			},
@@ -148,6 +217,7 @@ function createParagraphChangeTrackerPlugin() {
 				const meta = tr.getMeta(paragraphChangeTrackerKey);
 				const changedParagraphRangesMeta = tr.getMeta(CHANGED_PARAGRAPH_RANGES_META);
 				const sectionEndpointRemovalMeta = tr.getMeta(SECTION_ENDPOINT_REMOVAL_META);
+				const sectionEditMeta = tr.getMeta(SECTION_EDIT_META);
 				if (meta === CLEAR_META) {
 					const counts = countDocumentStructure(tr.doc);
 					return {
@@ -160,6 +230,7 @@ function createParagraphChangeTrackerPlugin() {
 						paragraphCount: counts.paragraphs,
 						sectionEndpointCount: counts.sectionEndpoints,
 						sectionEndpointFingerprint: counts.sectionEndpointFingerprint,
+						sectionRecords: counts.sectionRecords,
 						sectionEndpointRemoval: null
 					};
 				}
@@ -170,7 +241,7 @@ function createParagraphChangeTrackerPlugin() {
 					const changedParaIds = /* @__PURE__ */ new Set();
 					let unresolvedChanges = prevState.hasUntrackedSourceChanges;
 					for (const position of affectedParagraphPositions) {
-						const paraId = tr.doc.nodeAt(position)?.attrs["paraId"];
+						const paraId = nodeAtIndexed(tr.doc, position)?.attrs["paraId"];
 						if (isUsableParaId(paraId)) changedParaIds.add(paraId);
 						else unresolvedChanges = true;
 					}
@@ -182,25 +253,32 @@ function createParagraphChangeTrackerPlugin() {
 						blockStructureFingerprint: counts.blockStructureFingerprint,
 						paragraphCount: counts.paragraphs,
 						sectionEndpointCount: counts.sectionEndpoints,
-						sectionEndpointRemoval: counts.sectionEndpointFingerprint === prevState.sectionEndpointFingerprint ? prevState.sectionEndpointRemoval : null,
-						sectionEndpointFingerprint: counts.sectionEndpointFingerprint
+						sectionEndpointRemoval: holdsTheSameSections(prevState, counts) ? prevState.sectionEndpointRemoval : null,
+						sectionEndpointFingerprint: counts.sectionEndpointFingerprint,
+						sectionRecords: counts.sectionRecords
 					};
 				}
-				if (!tr.docChanged) return prevState;
+				if (!tr.docChanged) return isSectionEditMeta(sectionEditMeta) && sectionEditMeta.expectedEndpointFingerprint === prevState.sectionEndpointFingerprint ? {
+					...prevState,
+					sectionEndpointRemoval: sectionEditMeta.authorization
+				} : prevState;
 				const counts = countDocumentStructure(tr.doc);
 				const newCount = counts.paragraphs;
 				let sectionEndpointRemoval = prevState.sectionEndpointRemoval;
-				if (counts.sectionEndpointFingerprint !== prevState.sectionEndpointFingerprint) if (isTrackedSectionEndpointRemovalMeta(sectionEndpointRemovalMeta) && sectionEndpointRemovalMeta.authorization.sourceEndpointFingerprint === prevState.sectionEndpointFingerprint && sectionEndpointRemovalMeta.authorization.expectedEndpointFingerprint === counts.sectionEndpointFingerprint && sectionEndpointRemovalMeta.authorization.sourceParagraphEndpointCount === prevState.sectionEndpointCount && sectionEndpointRemovalMeta.authorization.expectedParagraphEndpointCount === counts.sectionEndpoints && counts.sectionEndpoints < prevState.sectionEndpointCount) {
-					const authorization = sectionEndpointRemovalMeta.authorization;
-					sectionEndpointRemoval = {
-						type: "tracked-section-endpoint-removal",
-						sourceParagraphEndpointCount: prevState.sectionEndpointRemoval?.expectedParagraphEndpointCount === authorization.sourceParagraphEndpointCount ? prevState.sectionEndpointRemoval.sourceParagraphEndpointCount : authorization.sourceParagraphEndpointCount,
-						expectedParagraphEndpointCount: authorization.expectedParagraphEndpointCount,
-						sourceEndpointFingerprint: prevState.sectionEndpointRemoval?.expectedParagraphEndpointCount === authorization.sourceParagraphEndpointCount ? prevState.sectionEndpointRemoval.sourceEndpointFingerprint : authorization.sourceEndpointFingerprint,
-						expectedEndpointFingerprint: authorization.expectedEndpointFingerprint,
-						removedReferences: [...prevState.sectionEndpointRemoval?.expectedParagraphEndpointCount === authorization.sourceParagraphEndpointCount ? prevState.sectionEndpointRemoval.removedReferences : [], ...authorization.removedReferences]
-					};
-				} else sectionEndpointRemoval = null;
+				if (counts.sectionEndpointFingerprint !== prevState.sectionEndpointFingerprint) {
+					if (isTrackedSectionEndpointRemovalMeta(sectionEndpointRemovalMeta) && sectionEndpointRemovalMeta.authorization.sourceEndpointFingerprint === prevState.sectionEndpointFingerprint && sectionEndpointRemovalMeta.authorization.expectedEndpointFingerprint === counts.sectionEndpointFingerprint && sectionEndpointRemovalMeta.authorization.sourceParagraphEndpointCount === prevState.sectionEndpointCount && sectionEndpointRemovalMeta.authorization.expectedParagraphEndpointCount === counts.sectionEndpoints && counts.sectionEndpoints < prevState.sectionEndpointCount) {
+						const authorization = sectionEndpointRemovalMeta.authorization;
+						sectionEndpointRemoval = {
+							type: "tracked-section-endpoint-removal",
+							sourceParagraphEndpointCount: prevState.sectionEndpointRemoval?.expectedParagraphEndpointCount === authorization.sourceParagraphEndpointCount ? prevState.sectionEndpointRemoval.sourceParagraphEndpointCount : authorization.sourceParagraphEndpointCount,
+							expectedParagraphEndpointCount: authorization.expectedParagraphEndpointCount,
+							sourceEndpointFingerprint: prevState.sectionEndpointRemoval?.expectedParagraphEndpointCount === authorization.sourceParagraphEndpointCount ? prevState.sectionEndpointRemoval.sourceEndpointFingerprint : authorization.sourceEndpointFingerprint,
+							expectedEndpointFingerprint: authorization.expectedEndpointFingerprint,
+							removedReferences: [...prevState.sectionEndpointRemoval?.expectedParagraphEndpointCount === authorization.sourceParagraphEndpointCount ? prevState.sectionEndpointRemoval.removedReferences : [], ...authorization.removedReferences]
+						};
+					} else if (!holdsTheSameSections(prevState, counts)) sectionEndpointRemoval = null;
+				}
+				if (isSectionEditMeta(sectionEditMeta) && sectionEditMeta.expectedEndpointFingerprint === counts.sectionEndpointFingerprint) sectionEndpointRemoval = sectionEditMeta.authorization;
 				const newState = {
 					affectedParagraphPositions: mapAffectedParagraphPositions(tr, prevState.affectedParagraphPositions),
 					hasUntrackedSourceChanges: prevState.hasUntrackedSourceChanges,
@@ -211,71 +289,129 @@ function createParagraphChangeTrackerPlugin() {
 					paragraphCount: newCount,
 					sectionEndpointCount: counts.sectionEndpoints,
 					sectionEndpointFingerprint: counts.sectionEndpointFingerprint,
+					sectionRecords: counts.sectionRecords,
 					sectionEndpointRemoval
 				};
-				if (isChangedParagraphRangesMeta(changedParagraphRangesMeta)) for (const batch of changedParagraphRangesMeta.batches) {
-					const remap = tr.mapping.slice(batch.mappingFrom);
-					for (const range of batch.ranges) {
-						const from = mapStepPosition(remap, range.from, 1);
-						const to = mapStepPosition(remap, range.to, -1);
-						if (to <= from) continue;
-						const { ids, positions, hasUntracked } = collectAffectedParaIdsFromMarkLikeStep(tr.doc, from, to);
-						for (const position of positions) newState.affectedParagraphPositions.add(position);
-						for (const id of ids) newState.changedParaIds.add(id);
-						if (hasUntracked) newState.hasUntrackedChanges = true;
-					}
-				}
-				if (prevState.blockStructureFingerprint !== counts.blockStructureFingerprint) newState.structuralChange = true;
-				for (let stepIndex = 0; stepIndex < tr.steps.length; stepIndex++) {
-					const step = tr.steps[stepIndex];
-					const remap = tr.mapping.slice(stepIndex + 1);
-					if (step instanceof AddMarkStep || step instanceof RemoveMarkStep) {
-						const from = mapStepPosition(remap, step.from, 1);
-						const to = mapStepPosition(remap, step.to, -1);
-						if (to <= from) continue;
-						const { ids, positions, hasUntracked } = collectAffectedParaIdsFromMarkLikeStep(tr.doc, from, to);
-						for (const position of positions) newState.affectedParagraphPositions.add(position);
-						for (const id of ids) newState.changedParaIds.add(id);
-						if (hasUntracked) newState.hasUntrackedChanges = true;
+				const recordAffected = ({ ids, positions, hasUntracked }) => {
+					for (const position of positions) newState.affectedParagraphPositions.add(position);
+					for (const id of ids) newState.changedParaIds.add(id);
+					if (hasUntracked) newState.hasUntrackedChanges = true;
+				};
+				const { touches, mapped } = mapStepTouches(tr, isChangedParagraphRangesMeta(changedParagraphRangesMeta) ? changedParagraphRangesMeta.batches : []);
+				for (const touch of touches) {
+					const from = mapped[touch.query].pos;
+					if (touch.kind === "node") {
+						if (mapped[touch.query].deletedAcross) continue;
+						const node = nodeAtIndexed(tr.doc, from);
+						if (node) recordAffected(collectAffectedParaIds(tr.doc, from, from + node.nodeSize));
 						continue;
 					}
-					if (step instanceof AddNodeMarkStep || step instanceof RemoveNodeMarkStep || step instanceof AttrStep) {
-						const pos = mapStepPosition(remap, step.pos, 1);
-						const node = tr.doc.nodeAt(pos);
-						if (!node) continue;
-						const end = pos + node.nodeSize;
-						const { ids, positions, hasUntracked } = collectAffectedParaIds(tr.doc, pos, end);
-						for (const position of positions) newState.affectedParagraphPositions.add(position);
-						for (const id of ids) newState.changedParaIds.add(id);
-						if (hasUntracked) newState.hasUntrackedChanges = true;
+					const to = mapped[touch.query + 1].pos;
+					if (touch.kind === "mark-range") {
+						if (to > from) recordAffected(collectAffectedParaIdsFromMarkLikeStep(tr.doc, from, to));
 						continue;
 					}
-					step.getMap().forEach((_oldStart, _oldEnd, newStart, newEnd) => {
-						const from = mapStepPosition(remap, newStart, 1);
-						const to = mapStepPosition(remap, newEnd, -1);
-						if (to < from) return;
-						const { ids, positions, hasUntracked } = collectAffectedParaIds(tr.doc, from, to);
-						for (const position of positions) newState.affectedParagraphPositions.add(position);
-						for (const id of ids) newState.changedParaIds.add(id);
-						if (hasUntracked) newState.hasUntrackedChanges = true;
-					});
+					if (to >= from) recordAffected(collectAffectedParaIds(tr.doc, from, to));
 				}
-				if (newState.hasUntrackedChanges || prevState.blockStructureFingerprint !== counts.blockStructureFingerprint) tr.before.descendants((node, position) => {
-					if (node.type.name !== "paragraph") return true;
-					if (!isUsableParaId(node.attrs["paraId"])) {
-						const mapped = mapParagraphPosition(tr, position);
-						if (mapped === null || newState.affectedParagraphPositions.has(mapped)) {
-							newState.hasUntrackedSourceChanges = true;
-							newState.hasUntrackedChanges = true;
-						}
+				if (prevState.blockStructureFingerprint !== counts.blockStructureFingerprint) newState.structuralChange = true;
+				if (newState.hasUntrackedChanges || prevState.blockStructureFingerprint !== counts.blockStructureFingerprint) {
+					const unidentified = [];
+					tr.before.descendants((node, position) => {
+						if (node.type.name !== "paragraph") return true;
+						if (!isUsableParaId(node.attrs["paraId"])) unidentified.push(position);
+						return false;
+					});
+					for (const survivor of mapParagraphPositions(tr, unidentified)) if (survivor === null || newState.affectedParagraphPositions.has(survivor)) {
+						newState.hasUntrackedSourceChanges = true;
+						newState.hasUntrackedChanges = true;
 					}
-					return false;
-				});
+				}
 				return newState;
 			}
-		}
+		},
+		appendTransaction: (transactions, oldState, newState) => sectionEditTransaction(transactions, oldState, newState)
 	});
 }
+const referencesOf = (records) => {
+	const references = [];
+	for (const record of records) {
+		for (const { type, rId } of record.headerReferences ?? []) references.push({
+			part: "header",
+			type,
+			relationshipId: rId
+		});
+		for (const { type, rId } of record.footerReferences ?? []) references.push({
+			part: "footer",
+			type,
+			relationshipId: rId
+		});
+	}
+	return references;
+};
+/** `references` without one occurrence of each of `restored`. */
+const withoutReferences = (references, restored) => {
+	const remaining = [...references];
+	for (const reference of restored) {
+		const index = remaining.findIndex((candidate) => candidate.part === reference.part && candidate.type === reference.type && candidate.relationshipId === reference.relationshipId);
+		if (index !== -1) remaining.splice(index, 1);
+	}
+	return remaining;
+};
+/**
+* Carry section breaks through an ordinary edit, and record the ones it
+* deleted.
+*
+* Deleting the mark of a section-ending paragraph (Backspace or Delete across
+* it, a selection, a cut or a paste over it, a join) deletes the break, and
+* the section's content joins the following section: the same outcome as
+* deleting the paragraph as a block, or accepting its tracked deletion. The
+* appended transaction moves each joined paragraph's record to the one its
+* surviving mark carries (see `sectionMarkEditsOf`) and states the removal
+* the save is to accept.
+*
+* Only a record whose mark a replacement deleted counts as removed on
+* purpose. A record that goes any other way (an attribute cleared, a record
+* swapped for another) leaves the edit unauthorized, and the save refuses the
+* smaller package as it always did. Records coming back (an undo) take their
+* removal back out of the authorization.
+*/
+const sectionEditTransaction = (transactions, oldState, newState) => {
+	if (!transactions.some((transaction) => transaction.docChanged && transaction.getMeta(paragraphChangeTrackerKey) !== IGNORE_META) || transactions.some((transaction) => transaction.getMeta(SECTION_EDIT_META) !== void 0 || transaction.getMeta(SECTION_ENDPOINT_REMOVAL_META) !== void 0 || transaction.getMeta(paragraphChangeTrackerKey) === CLEAR_META)) return null;
+	const base = paragraphChangeTrackerKey.getState(oldState);
+	if (!base) return null;
+	if (base.sectionRecords.size === 0) return null;
+	const edits = sectionMarkEditsOf(transactions, newState.doc);
+	const tr = newState.tr;
+	const restoring = transactions.some((transaction) => isHistoryTransaction(transaction));
+	for (const { position, record } of restoring ? [] : edits.carriers) {
+		const paragraph = tr.doc.nodeAt(position);
+		if (paragraph?.type.name === "paragraph" && sectionPropertiesOf(paragraph) !== record) tr.setNodeAttribute(position, "_sectionProperties", record);
+	}
+	const after = countDocumentStructure(tr.doc);
+	if (holdsTheSameSections(base, after)) return tr.docChanged ? tr.setMeta(SECTION_EDIT_META, {
+		type: "section-edit-meta",
+		authorization: base.sectionEndpointRemoval,
+		expectedEndpointFingerprint: after.sectionEndpointFingerprint
+	}) : null;
+	const removed = [...base.sectionRecords].filter((record) => !after.sectionRecords.has(record));
+	const added = [...after.sectionRecords].filter((record) => !base.sectionRecords.has(record));
+	if (removed.some((record) => !edits.deletedMarks.has(record))) return tr.docChanged ? tr : null;
+	const prior = base.sectionEndpointRemoval;
+	const sourceParagraphEndpointCount = prior?.sourceParagraphEndpointCount ?? base.sectionEndpointCount;
+	const authorization = after.sectionEndpoints < sourceParagraphEndpointCount ? {
+		type: "tracked-section-endpoint-removal",
+		sourceParagraphEndpointCount,
+		expectedParagraphEndpointCount: after.sectionEndpoints,
+		sourceEndpointFingerprint: prior?.sourceEndpointFingerprint ?? base.sectionEndpointFingerprint,
+		expectedEndpointFingerprint: after.sectionEndpointFingerprint,
+		removedReferences: withoutReferences([...prior?.removedReferences ?? [], ...referencesOf(removed)], referencesOf(added))
+	} : null;
+	return tr.setMeta(SECTION_EDIT_META, {
+		type: "section-edit-meta",
+		authorization,
+		expectedEndpointFingerprint: after.sectionEndpointFingerprint
+	});
+};
 /**
 * Get the change tracker state from an EditorState
 */
@@ -304,6 +440,24 @@ function hasUntrackedChanges(state) {
 function getTrackedSectionEndpointRemoval(state) {
 	return getChangeTrackerState(state)?.sectionEndpointRemoval ?? null;
 }
+/**
+* Run an editor save's full repack with the section removals the editor's own
+* edits made.
+*
+* A save refuses a package with fewer sections than its source unless it is
+* told which removals were meant: deleting the paragraph that ends a section,
+* or accepting its tracked deletion, removes that section on purpose. The
+* tracker records exactly those removals; without them the repack throws and
+* the edit cannot be saved.
+*/
+const repackWithEditorSectionRemovals = ({ state, document, repack }) => {
+	const resolution = getTrackedSectionEndpointRemoval(state);
+	return resolution === null ? repack() : withTrackedSectionEndpointRemoval({
+		document,
+		resolution,
+		repack
+	});
+};
 /** Record only a complete, internally consistent endpoint-removal transition. */
 function markTrackedSectionEndpointRemoval(tr, { sourceDoc, removedEndpointCount, removedReferences }) {
 	const sourceStructure = countDocumentStructure(sourceDoc);
@@ -324,6 +478,23 @@ function markTrackedSectionEndpointRemoval(tr, { sourceDoc, removedEndpointCount
 	});
 }
 /**
+* Record that `tr` removed section breaks on purpose: a command whose job is
+* to remove the break (not to delete its paragraph mark, which the tracker
+* reads for itself). Only a plain removal is recorded; a transaction that also
+* adds or replaces a record is left as it is.
+*/
+function markSectionBreakRemoval(tr, sourceDoc) {
+	const before = countDocumentStructure(sourceDoc).sectionRecords;
+	const after = countDocumentStructure(tr.doc).sectionRecords;
+	const removed = [...before].filter((record) => !after.has(record));
+	if (removed.length === 0 || [...after].some((record) => !before.has(record))) return tr;
+	return markTrackedSectionEndpointRemoval(tr, {
+		sourceDoc,
+		removedEndpointCount: removed.length,
+		removedReferences: referencesOf(removed)
+	});
+}
+/**
 * Create a transaction that clears the change tracker
 */
 function clearTrackedChanges(state) {
@@ -352,4 +523,4 @@ const ParagraphChangeTrackerExtension = createExtension({
 	}
 });
 //#endregion
-export { ParagraphChangeTrackerExtension, clearTrackedChanges, getChangeTrackerState, getChangedParagraphIds, getTrackedSectionEndpointRemoval, hasStructuralChanges, hasUntrackedChanges, ignoreTrackedChanges, markChangedParagraphRanges, markStructuralChange, markTrackedSectionEndpointRemoval, paragraphChangeTrackerKey };
+export { ParagraphChangeTrackerExtension, clearTrackedChanges, getChangeTrackerState, getChangedParagraphIds, getTrackedSectionEndpointRemoval, hasStructuralChanges, hasUntrackedChanges, ignoreTrackedChanges, markChangedParagraphRanges, markSectionBreakRemoval, markStructuralChange, markTrackedSectionEndpointRemoval, paragraphChangeTrackerKey, repackWithEditorSectionRemovals };

package/dist/prosemirror/extensions/features/PasteCleanupExtension.js

@@ -3,6 +3,7 @@ import { createExtension } from "../create.js";
 import { Priority } from "../types.js";
 import { cleanPastedHtml, removeUnpairedBookmarkBoundaries, removeUnpairedMoveRangeBoundaries } from "./pasteCleanup.js";
 import { retargetPastedHeadingStyles } from "./pastedHeadingStyles.js";
+import { flattenPastedHtmlLists, numberPastedHtmlLists } from "./pastedHtmlLists.js";
 import { Plugin } from "prosemirror-state";
 //#region src/prosemirror/extensions/features/PasteCleanupExtension.ts
 /**
@@ -30,9 +31,9 @@ const PasteCleanupExtension = createExtension({
 			plugins: [new Plugin({ props: {
 				transformPastedHTML(html) {
 					const internalClipboardToken = options.getInternalClipboardToken?.();
-					return cleanPastedHtml(html, { ...internalClipboardToken ? { internalClipboardToken } : {} });
+					return flattenPastedHtmlLists(cleanPastedHtml(html, { ...internalClipboardToken ? { internalClipboardToken } : {} }));
 				},
-				transformPasted: (slice, view) => retargetPastedHeadingStyles(removeUnpairedMoveRangeBoundaries(removeUnpairedBookmarkBoundaries(slice)), view)
+				transformPasted: (slice, view) => numberPastedHtmlLists(retargetPastedHeadingStyles(removeUnpairedMoveRangeBoundaries(removeUnpairedBookmarkBoundaries(slice)), view), view)
 			} })],
 			keyboardShortcuts: { "Mod-Alt-v": pasteWithoutFormatting }
 		};

package/dist/prosemirror/extensions/features/pasteCleanup.js

@@ -128,6 +128,7 @@ const BOOKMARK_BOUNDARY_ATTR = /\s+data-docx-bookmark-(?:boundary|id|name|col-fi
 const RANGE_ANCHOR_ATTR = /\s+data-docx-range-anchor(?:="[^"]*"|='[^']*'|=[^\s>]+)?/gi;
 const MOVE_RANGE_BOUNDARY_ATTR = /\s+data-docx-move-range-boundary(?:="[^"]*"|='[^']*'|=[^\s>]+)?/gi;
 const STRUCTURED_FIELD_ATTR = /\s+data-field-structured(?:="[^"]*"|='[^']*'|=[^\s>]+)?/gi;
+const FIELD_CODE_ATTR = /\s+data-field-code(?:="[^"]*"|'[^']*'|=[^\s>]+)?/gi;
 /**
 * Treat reconstruction attributes as internal only when the HTML carries the
 * unguessable capability created with this editor schema. `data-pm-slice`
@@ -153,7 +154,7 @@ function stripForeignRangeCarriers(html, internal) {
 }
 function stripForeignStructuredFields(html, internal) {
 	if (internal) return html;
-	return html.replace(STRUCTURED_FIELD_ATTR, "");
+	return html.replace(STRUCTURED_FIELD_ATTR, "").replace(FIELD_CODE_ATTR, "");
 }
 /**
 * Remove empty spans left behind after stripping `mso-*` styles. Only truly

package/dist/prosemirror/extensions/features/pastedHtmlLists.d.ts

@@ -0,0 +1,12 @@
+import { Slice } from "prosemirror-model";
+import { EditorView } from "prosemirror-view";
+//#region src/prosemirror/extensions/features/pastedHtmlLists.d.ts
+/**
+ * Flatten only list containers. Other HTML remains in place for the normal
+ * clipboard parser, including tables and inline formatting inside list items.
+ */
+declare const flattenPastedHtmlLists: (html: string) => string;
+/** Resolve clipboard-only list hints against fresh document numbering ids. */
+declare const numberPastedHtmlLists: (slice: Slice, view: EditorView) => Slice;
+//#endregion
+export { flattenPastedHtmlLists, numberPastedHtmlLists };