@stll/folio-core 0.54.0 → 0.54.2

package/dist/prosemirror/extensions/core/ParagraphExtension.js

@@ -1,3 +1,4 @@
+import { mintBookmarkId, reserveProseBookmarkIds } from "../../../docx/bookmarkIds.js";
 import { BUILT_IN_STYLE_NAME } from "../../../docx/builtInStyles.js";
 import { PROSE_PARAGRAPH_SOURCE_TOKEN_ATTR } from "../../../docx/paragraphPropertySource.js";
 import { isStyleSourcedParagraphNumbering } from "../../../internal/paragraphFormattingSerialization.js";
@@ -671,6 +672,7 @@ const ParagraphExtension = createNodeExtension({
 				if (!dispatch) return true;
 				const { schema: s } = state;
 				const tr = state.tr;
+				reserveProseBookmarkIds(state.doc);
 				const bookmarkEntries = [];
 				for (const h of headings) {
 					const bookmarkName = `_Toc${Math.floor(1e8 + Math.random() * 9e8)}`;
@@ -683,7 +685,7 @@ const ParagraphExtension = createNodeExtension({
 					const paragraphNode = tr.doc.resolve(mappedPos).nodeAfter;
 					if (paragraphNode && paragraphNode.type.name === "paragraph") {
 						const newBookmarks = [...(paragraphNode.attrs["bookmarks"] ?? []).filter((b) => !b.name.startsWith("_Toc")), {
-							id: Math.floor(Math.random() * 2147483647),
+							id: mintBookmarkId(),
 							name: bookmarkName
 						}];
 						tr.setNodeMarkup(mappedPos, void 0, {

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

@@ -1,5 +1,6 @@
 import { mergeTextFormatting } from "../../../utils/textFormattingMerge.js";
 import { expectCharacterStyleMarkAttrs, expectRunFormattingOverrideMarkAttrs } from "../../attrs/index.js";
+import { clearIndentOnBackspace } from "../../commands/clearParagraphIndent.js";
 import { keepSectionBreaksOnSurvivingMarks } from "../../commands/sectionBreak.js";
 import { getDocumentStyleResolver } from "../../plugins/documentStyleState.js";
 import { RUN_FORMATTING_MARK_NAMES } from "../../runFormattingMarkNames.js";
@@ -8,6 +9,7 @@ import { paragraphAttrsFromResolvedStyle } from "../../styles/resolvedStyleAttrs
 import { createExtension } from "../create.js";
 import { marksToTextFormatting, textFormattingToMarks } from "../marks/markUtils.js";
 import { Priority } from "../types.js";
+import { EditorState, TextSelection } from "prosemirror-state";
 import { baseKeymap, deleteSelection, joinBackward, joinForward, selectAll, selectParentNode, splitBlock } from "prosemirror-commands";
 //#region src/prosemirror/extensions/features/BaseKeymapExtension.ts
 /**
@@ -22,31 +24,6 @@ function chainCommands(...commands) {
 	};
 }
 /**
-* Backspace at the start of a paragraph clears first-line indent / hanging indent
-* before joining with the previous paragraph (matches Word behavior).
-*/
-const clearIndentOnBackspace = (state, dispatch) => {
-	const { $cursor } = state.selection;
-	if (!$cursor) return false;
-	if ($cursor.parentOffset !== 0) return false;
-	if ($cursor.parent.type.name !== "paragraph") return false;
-	const attrs = $cursor.parent.attrs;
-	const hasFirstLine = attrs["indentFirstLine"] !== null && attrs["indentFirstLine"] > 0;
-	const hasHanging = !!attrs["hangingIndent"];
-	const hasIndentLeft = attrs["indentLeft"] !== null && attrs["indentLeft"] > 0;
-	if (!hasFirstLine && !hasHanging && !hasIndentLeft) return false;
-	if (dispatch) {
-		const pos = $cursor.before();
-		dispatch(state.tr.setNodeMarkup(pos, void 0, {
-			...attrs,
-			indentFirstLine: null,
-			hangingIndent: null,
-			indentLeft: null
-		}).scrollIntoView());
-	}
-	return true;
-};
-/**
 * Custom Enter handler: splits the block, inherits style-related attrs,
 * clears paragraph borders, and preserves run formatting on the new paragraph.
 *
@@ -117,16 +94,33 @@ function applyNextParagraphStyle(tr, sourcePara, newPara, resolver) {
 	tr.setStoredMarks(resolved.runFormatting ? textFormattingToMarks(resolved.runFormatting, tr.doc.type.schema) : []);
 	return true;
 }
+const blockBoundaryDeletion = (state) => {
+	if (!(state.selection instanceof TextSelection) || state.selection.empty) return null;
+	const tr = state.tr.deleteSelection();
+	return tr.doc.resolve(tr.mapping.map(state.selection.from)).parent.isTextblock ? null : tr;
+};
 const splitBlockClearBorders = (state, dispatch, view) => {
-	const { $from: preSplitFrom } = state.selection;
+	const deletion = blockBoundaryDeletion(state);
+	const splitState = deletion ? EditorState.create({
+		doc: deletion.doc,
+		selection: deletion.selection,
+		storedMarks: deletion.storedMarks
+	}) : state;
+	const { $from: preSplitFrom } = splitState.selection;
 	const sourcePara = preSplitFrom.parent.type.name === "paragraph" ? preSplitFrom.parent : null;
-	const caretFormattingMarks = (state.storedMarks || preSplitFrom.marks()).filter((mark) => RUN_FORMATTING_MARK_NAMES.has(mark.type.name));
+	const caretFormattingMarks = (splitState.storedMarks || preSplitFrom.marks()).filter((mark) => RUN_FORMATTING_MARK_NAMES.has(mark.type.name));
 	const resolver = getDocumentStyleResolver(state);
 	const splitResult = { tr: null };
-	if (!splitBlock(state, dispatch ? (tr) => {
+	if (!splitBlock(splitState, dispatch ? (tr) => {
 		splitResult.tr = tr;
 	} : void 0, view)) return false;
 	if (dispatch && splitResult.tr !== null) {
+		if (deletion) {
+			for (const step of splitResult.tr.steps) deletion.step(step);
+			deletion.setSelection(splitResult.tr.selection.getBookmark().resolve(deletion.doc));
+			deletion.setStoredMarks(splitResult.tr.storedMarks);
+			splitResult.tr = deletion;
+		}
 		const tr = splitResult.tr;
 		const { $from } = tr.selection;
 		const newPara = $from.parent;

package/dist/prosemirror/extensions/nodes/ShapeExtension.js

@@ -268,9 +268,9 @@ function createShapeElement(type, w, h, adjustments) {
 		case "straightConnector1": {
 			const el = document.createElementNS(SVG_NS, "line");
 			setNum(el, "x1", 0);
-			setNum(el, "y1", h / 2);
+			setNum(el, "y1", 0);
 			setNum(el, "x2", w);
-			setNum(el, "y2", h / 2);
+			setNum(el, "y2", h);
 			return el;
 		}
 		case "rightBrace": {
@@ -537,9 +537,11 @@ const ShapeExtension = createNodeExtension({
 			const strokeWidth = finiteNumber(attrs.outlineWidth) ?? 1;
 			const svg = document.createElementNS(SVG_NS, "svg");
 			svg.setAttribute("xmlns", SVG_NS);
-			setNum(svg, "width", w);
-			setNum(svg, "height", h);
-			svg.setAttribute("viewBox", `0 0 ${w} ${h}`);
+			const viewportWidth = w === 0 ? 1 : w;
+			const viewportHeight = h === 0 ? 1 : h;
+			setNum(svg, "width", viewportWidth);
+			setNum(svg, "height", viewportHeight);
+			svg.setAttribute("viewBox", `0 0 ${viewportWidth} ${viewportHeight}`);
 			let gradient = null;
 			let fillAttr;
 			if (attrs.fillType === "gradient" && attrs.gradientStops) {
@@ -548,7 +550,7 @@ const ShapeExtension = createNodeExtension({
 				fillAttr = gradient ? `url(#${gradId})` : safeFillColor;
 			} else fillAttr = attrs.fillType === "none" ? "none" : safeFillColor;
 			const strokeAttr = attrs.outlineStyle === "none" ? "none" : safeStrokeColor;
-			svg.setAttribute("style", `fill:${fillAttr};stroke:${strokeAttr};stroke-width:${strokeWidth}`);
+			svg.setAttribute("style", `fill:${fillAttr};stroke:${strokeAttr};stroke-width:${strokeWidth};overflow:visible`);
 			if (gradient) {
 				const defs = document.createElementNS(SVG_NS, "defs");
 				defs.append(gradient);

package/dist/prosemirror/listNumbering.js

@@ -7,6 +7,7 @@ import { listRenderingFor, recordsListRendering } from "./listRendering.js";
 import { LIST_RENDERING_ATTR_KEYS } from "./listRenderingAttrs.js";
 import { directParagraphIndentation } from "./paragraphIndentation.js";
 import { getDocumentNumbering } from "./plugins/documentNumbering.js";
+import { getDocumentStyleResolver } from "./plugins/documentStyleState.js";
 import { SUGGESTION_META, makeRevisionInfo } from "./plugins/suggestionMode.js";
 import { listAttrsFromNumbering, listLevelIndentAttrPatch } from "./styles/resolvedStyleAttrs.js";
 //#region src/prosemirror/listNumbering.ts
@@ -20,22 +21,15 @@ const PARAGRAPH_NODE = "paragraph";
 */
 const listChangeSnapshot = (node, attrs) => {
 	const previousFormatting = paragraphPropertiesSnapshot(node.type.create(attrs, node.content, node.marks));
-	previousFormatting["numPr"] = attrs["numPr"] ?? null;
+	previousFormatting["numPr"] ??= null;
 	for (const key of LIST_RENDERING_ATTR_KEYS) previousFormatting[key] = attrs[key] ?? null;
 	return previousFormatting;
 };
-/**
-* The original state a pending record describes, completed with the list
-* attrs it may not state. A record written by a list command states them all.
-* One written for another property (or read from a file) states the scope
-* only: its numbering is the original's, and an absent one means the original
-* had none, so the rendering is recomputed from it rather than copied from
-* the live paragraph, whose list may since have changed.
-*/
-const originalListFormatting = (record, numbering) => {
+const originalListFormatting = ({ record, numbering, styleResolver }) => {
 	const original = { ...record };
 	if (recordsListRendering(record)) return original;
-	Object.assign(original, listRenderingFor(record.numPr, numbering));
+	const inherited = styleResolver?.resolveParagraphStyle(record.styleId ?? void 0).paragraphFormatting?.numPr;
+	Object.assign(original, listRenderingFor(record.numPr ?? inherited, numbering));
 	original["numPr"] = record.numPr ?? null;
 	return original;
 };
@@ -54,12 +48,16 @@ const canonicalJson = (value) => JSON.stringify(value, (_key, nested) => nested
 * the file) keeps its author, id and date: the change joins that revision
 * rather than re-attributing it, and it is never dropped.
 */
-const trackListChange = ({ current, next, rev, numbering }) => {
+const trackListChange = ({ current, next, rev, numbering, styleResolver }) => {
 	const currentAttrs = expectParagraphAttrs(current);
 	const existing = currentAttrs._propertyChanges ?? [];
 	const pending = existing.find(({ info }) => info.provenance !== "suggested");
 	const retained = existing.filter((change) => change !== pending);
-	const previousFormatting = pending?.previousFormatting ? originalListFormatting(pending.previousFormatting, numbering) : listChangeSnapshot(current, currentAttrs);
+	const previousFormatting = pending?.previousFormatting ? originalListFormatting({
+		record: pending.previousFormatting,
+		numbering,
+		styleResolver
+	}) : listChangeSnapshot(current, currentAttrs);
 	const ownPending = pending !== void 0 && pending.info.author === rev.author;
 	if (ownPending && canonicalJson(previousFormatting) === canonicalJson(listChangeSnapshot(current, next))) return {
 		...next,
@@ -198,12 +196,14 @@ const listItemAttrs = (attrs, { numId, ilvl }, numbering) => ({
 const applyParagraphUpdates = ({ tr, state, updates }) => {
 	const rev = makeRevisionInfo(state);
 	const numbering = getDocumentNumbering(state);
+	const styleResolver = getDocumentStyleResolver(state);
 	for (const { pos, node, next } of updates) {
 		const attrs = rev ? trackListChange({
 			current: node,
 			next,
 			rev,
-			numbering
+			numbering,
+			styleResolver
 		}) : next;
 		tr.setNodeMarkup(pos, void 0, attrs);
 	}

package/dist/prosemirror/listRendering.d.ts

@@ -1,11 +1,12 @@
 import { ParagraphAttrs, ParagraphPropertyChangeAttrs } from "./schema/nodes.js";
 import { NumberingMap } from "../docx/numberingParser.js";
+import { ParagraphNumberingOverride } from "../docx/numberingReference.js";
 //#region src/prosemirror/listRendering.d.ts
 type PreviousFormatting = NonNullable<ParagraphPropertyChangeAttrs["previousFormatting"]>;
 /** Whether a `w:pPrChange` record states the list rendering it had (a list command's does). */
 declare const recordsListRendering: (record: PreviousFormatting) => boolean;
 /** Every list-rendering attr for `numPr`: its level's, or all cleared when it numbers nothing. */
-declare const listRenderingFor: (numPr: PreviousFormatting["numPr"], numbering: NumberingMap | null) => Record<string, unknown>;
+declare const listRenderingFor: (numPr: ParagraphNumberingOverride | null | undefined, numbering: NumberingMap | null) => Record<string, unknown>;
 /**
  * The list rendering a paragraph takes when a `w:pPrChange` is rejected. A
  * reject restores the recorded numbering, but the rendering attrs sit outside
@@ -21,7 +22,8 @@ type RejectedListRenderingOptions = {
   /** The previous state the rejected record restores. */
   previousFormatting: PreviousFormatting | null | undefined;
   numbering: NumberingMap | null;
+  restoredNumbering: ParagraphAttrs["numPr"] | null;
 };
-declare const rejectedListRenderingPatch: ({ current, previousFormatting, numbering }: RejectedListRenderingOptions) => Record<string, unknown>;
+declare const rejectedListRenderingPatch: ({ current, previousFormatting, numbering, restoredNumbering }: RejectedListRenderingOptions) => Record<string, unknown>;
 //#endregion
 export { RejectedListRenderingOptions, listRenderingFor, recordsListRendering, rejectedListRenderingPatch };

package/dist/prosemirror/listRendering.js

@@ -16,10 +16,9 @@ const listRenderingFor = (numPr, numbering) => {
 	for (const key of LIST_RENDERING_ATTR_KEYS) attrs[key] = rendering[key] ?? null;
 	return attrs;
 };
-const rejectedListRenderingPatch = ({ current, previousFormatting, numbering }) => {
-	const record = previousFormatting ?? {};
-	if (recordsListRendering(record)) return {};
-	const restored = record.numPr ?? void 0;
+const rejectedListRenderingPatch = ({ current, previousFormatting, numbering, restoredNumbering }) => {
+	if (recordsListRendering(previousFormatting ?? {})) return {};
+	const restored = restoredNumbering ?? void 0;
 	if (sameStatedParagraphNumbering(restored, current.numPr ?? void 0)) return {};
 	return listRenderingFor(restored, numbering);
 };

package/dist/prosemirror/paragraphPropertyCarry.js

@@ -86,7 +86,7 @@ const carryParagraphProperties = ({ tr, position, source, styleResolver, numberi
 };
 /**
 * Whether the carried numbering is the paragraph's own or its style's: the
-* record holds `numPr` as the paragraph reads it, and a style's numbering
+* record holds only stated numbering, and a style's numbering
 * stays the style's rather than becoming the paragraph's own `w:numPr`.
 */
 const carriedNumberingProvenance = (source, target, keep) => ({ numPrFromStyle: expectParagraphAttrs(keep?.has("numPr") ? target : source).numPrFromStyle });
@@ -112,10 +112,7 @@ const paragraphLeftAfter = ({ doc, paragraphPos, removedBreakPositions }) => {
 		node = next;
 	}
 };
-const recordedFormatting = (node) => ({
-	...paragraphPropertiesSnapshot(node),
-	numPr: expectParagraphAttrs(node).numPr ?? null
-});
+const recordedFormatting = paragraphPropertiesSnapshot;
 /**
 * A paragraph now holds the break another one had (a split, or a paste into
 * it, leaves that break on the last part) but reads with other properties:

package/dist/prosemirror/plugins/revisionIds.d.ts

@@ -1,31 +1,35 @@
 import { Node } from "prosemirror-model";
 //#region src/prosemirror/plugins/revisionIds.d.ts
+declare const RevisionIdAllocationError_base: import("better-result").TaggedErrorClass<"RevisionIdAllocationError">;
+declare class RevisionIdAllocationError extends RevisionIdAllocationError_base<{
+  message: string;
+  first: number;
+  next: number;
+}> {}
+/** Deterministic package-local batches prefer ids above loaded revisions, then a free interval. */
+declare const revisionIdSeedAbove: (existingIds: Iterable<number>) => number;
+/** The next free id, including after the signed 32-bit boundary wraps. */
+declare const nextRevisionId: () => number;
 /**
- * Mint the next tracked-revision id (`w:id`). Strictly monotonic per realm,
- * and always inside the range serialized `w:id` may occupy.
+ * A shared batch increments its seed locally, so a single free id is not
+ * enough: start in the largest free interval. Every contiguous batch that
+ * can fit anywhere fits here, including after loaded ids shorten the tail.
+ * Continue within this interval until another producer changes the cursor.
  */
+declare const nextRevisionIdRange: () => number;
+/** Reserve a deterministic batch without changing its caller-supplied ids. */
+declare const reserveRevisionIds: (first: number, next: number) => void;
+/** Shared producers must never cross a loaded or already issued id on wrap. */
+declare const claimRevisionIds: (first: number, next: number) => void;
+/** Mint a bounded id without reusing loaded or previously issued ids. */
 declare function mintRevisionId(): number;
-/**
- * Raise the counter above `maxId` so freshly minted ids cannot collide with
- * ids already present in a loaded document. Only ever raises.
- *
- * `maxId` is derived from file content, so it is untrusted: a malformed or
- * out-of-range value is ignored outright rather than folded into range.
- */
+/** Reserve a valid loaded id and prefer the range above it. */
 declare function seedRevisionIdsAbove(maxId: number): void;
-/**
- * The highest id in `doc` from any part of the annotation space.
- *
- * A revision, a comment and a bookmark draw their `w:id` from one space, so a
- * counter seeded above its own kind alone still mints over another kind's id.
- * Both allocators seed from this, and the save-time normalization avoids the
- * same space, so the three agree on what is taken.
- */
-declare function maxAnnotationIdInDoc(doc: Node): number;
+declare const maxAnnotationIdInDoc: (doc: Node) => number;
 /**
  * Raise the counter above every annotation id already present in `doc`.
  * Called from the suggestion-mode plugin's `state.init`.
  */
 declare function seedRevisionIdsFromDoc(doc: Node): void;
 //#endregion
-export { maxAnnotationIdInDoc, mintRevisionId, seedRevisionIdsAbove, seedRevisionIdsFromDoc };
+export { RevisionIdAllocationError, claimRevisionIds, maxAnnotationIdInDoc, mintRevisionId, nextRevisionId, nextRevisionIdRange, reserveRevisionIds, revisionIdSeedAbove, seedRevisionIdsAbove, seedRevisionIdsFromDoc };

package/dist/prosemirror/plugins/revisionIds.js

@@ -1,3 +1,4 @@
+import { TaggedError } from "better-result";
 import { MAX_REVISION_ID } from "@stll/docx-core/model";
 //#region src/prosemirror/plugins/revisionIds.ts
 /**
@@ -9,23 +10,98 @@ import { MAX_REVISION_ID } from "@stll/docx-core/model";
 * int consumers read `w:id` into.
 */
 let counter = 1;
+const occupiedIds = /* @__PURE__ */ new Set();
+var RevisionIdAllocationError = class extends TaggedError("RevisionIdAllocationError") {};
+/** Batches use contiguous ids; on rollover prefer the largest unused interval. */
+const largestFreeIntervalStart = (reservedIds) => {
+	let first = 1;
+	let bestFirst = 1;
+	let bestSize = 0;
+	const boundaries = [...reservedIds].filter((id) => id > 0).toSorted((a, b) => a - b);
+	boundaries.push(MAX_REVISION_ID + 1);
+	for (const boundary of boundaries) {
+		const size = boundary - first;
+		if (size > bestSize) {
+			bestFirst = first;
+			bestSize = size;
+		}
+		first = boundary + 1;
+	}
+	if (bestSize === 0) throw new RevisionIdAllocationError({
+		message: "Revision id space exhausted",
+		first: 1,
+		next: 1
+	});
+	return bestFirst;
+};
+/** Deterministic package-local batches prefer ids above loaded revisions, then a free interval. */
+const revisionIdSeedAbove = (existingIds) => {
+	const reservedIds = /* @__PURE__ */ new Set();
+	let maxId = 0;
+	for (const id of existingIds) {
+		if (!Number.isInteger(id) || id < 0 || id > MAX_REVISION_ID) continue;
+		reservedIds.add(id);
+		maxId = Math.max(maxId, id);
+	}
+	return maxId < MAX_REVISION_ID ? maxId + 1 : largestFreeIntervalStart(reservedIds);
+};
+/** The next free id, including after the signed 32-bit boundary wraps. */
+const nextRevisionId = () => {
+	if (counter > MAX_REVISION_ID) counter = largestFreeIntervalStart(occupiedIds);
+	while (occupiedIds.has(counter)) {
+		counter += 1;
+		if (counter > MAX_REVISION_ID) counter = largestFreeIntervalStart(occupiedIds);
+		if (occupiedIds.size >= MAX_REVISION_ID) throw new RevisionIdAllocationError({
+			message: "Revision id space exhausted",
+			first: counter,
+			next: counter
+		});
+	}
+	return counter;
+};
 /**
-* Mint the next tracked-revision id (`w:id`). Strictly monotonic per realm,
-* and always inside the range serialized `w:id` may occupy.
+* A shared batch increments its seed locally, so a single free id is not
+* enough: start in the largest free interval. Every contiguous batch that
+* can fit anywhere fits here, including after loaded ids shorten the tail.
+* Continue within this interval until another producer changes the cursor.
 */
+const nextRevisionIdRange = () => {
+	counter = largestFreeIntervalStart(occupiedIds);
+	return counter;
+};
+const validateRevisionIdRange = (first, next) => {
+	if (!Number.isInteger(first) || !Number.isInteger(next) || first < 0 || next < first || next > MAX_REVISION_ID + 1) throw new RevisionIdAllocationError({
+		message: "Revision id range exceeds the OOXML limit",
+		first,
+		next
+	});
+};
+/** Reserve a deterministic batch without changing its caller-supplied ids. */
+const reserveRevisionIds = (first, next) => {
+	validateRevisionIdRange(first, next);
+	for (let id = first; id < next; id += 1) occupiedIds.add(id);
+	if (next > counter) counter = next;
+};
+/** Shared producers must never cross a loaded or already issued id on wrap. */
+const claimRevisionIds = (first, next) => {
+	validateRevisionIdRange(first, next);
+	for (let id = first; id < next && id <= MAX_REVISION_ID; id += 1) if (occupiedIds.has(id)) throw new RevisionIdAllocationError({
+		message: "Revision id range overlaps an occupied id",
+		first,
+		next
+	});
+	reserveRevisionIds(first, next);
+};
+/** Mint a bounded id without reusing loaded or previously issued ids. */
 function mintRevisionId() {
-	if (counter > MAX_REVISION_ID) counter = 1;
-	return counter++;
+	const id = nextRevisionId();
+	claimRevisionIds(id, id + 1);
+	return id;
 }
-/**
-* Raise the counter above `maxId` so freshly minted ids cannot collide with
-* ids already present in a loaded document. Only ever raises.
-*
-* `maxId` is derived from file content, so it is untrusted: a malformed or
-* out-of-range value is ignored outright rather than folded into range.
-*/
+/** Reserve a valid loaded id and prefer the range above it. */
 function seedRevisionIdsAbove(maxId) {
-	if (!Number.isInteger(maxId) || maxId < 0 || maxId >= MAX_REVISION_ID) return;
+	if (!Number.isInteger(maxId) || maxId < 0 || maxId > MAX_REVISION_ID) return;
+	occupiedIds.add(maxId);
 	if (maxId >= counter) counter = maxId + 1;
 }
 /** Node attrs that carry a revision id directly (`revisionId` field). */
@@ -33,40 +109,45 @@ const DIRECT_REVISION_ATTR_KEYS = ["trIns", "trDel"];
 /**
 * The highest id in `doc` from any part of the annotation space.
 *
-* A revision, a comment and a bookmark draw their `w:id` from one space, so a
-* counter seeded above its own kind alone still mints over another kind's id.
-* Both allocators seed from this, and the save-time normalization avoids the
-* same space, so the three agree on what is taken.
+* Preserve the editor's conservative annotation seeding: revisions reserve
+* comment and bookmark ids too, although OOXML defines separate id spaces.
 */
-function maxAnnotationIdInDoc(doc) {
+const visitAnnotationIds = (doc, visit) => {
 	let max = 0;
 	const consider = (id) => {
-		if (typeof id === "number" && Number.isInteger(id) && id > max && id <= MAX_REVISION_ID) max = id;
+		if (typeof id === "number" && Number.isInteger(id) && id >= 0 && id <= MAX_REVISION_ID) {
+			visit(id);
+			max = Math.max(max, id);
+		}
+	};
+	const considerMetadata = (value) => {
+		if (typeof value !== "object" || value === null) return;
+		for (const [key, child] of Object.entries(value)) if (key === "id" || key === "revisionId" || key === "commentId") consider(child);
+		else considerMetadata(child);
 	};
 	doc.descendants((node) => {
 		for (const mark of node.marks) {
 			consider(mark.attrs["revisionId"]);
 			consider(mark.attrs["commentId"]);
+			considerMetadata(mark.attrs["_docxRevisionAncestors"]);
+			considerMetadata(mark.attrs["changes"]);
 		}
 		if (node.type.name === "bookmarkBoundary") consider(node.attrs["id"]);
 		const attrs = node.attrs;
-		const pPrMark = attrs["pPrMark"];
-		if (pPrMark?.info) consider(pPrMark.info.id);
-		for (const key of DIRECT_REVISION_ATTR_KEYS) {
-			const value = attrs[key];
-			if (value) consider(value.revisionId);
-		}
-		const cellMarker = attrs["cellMarker"];
-		if (cellMarker?.info) consider(cellMarker.info.revisionId);
+		considerMetadata(attrs["_propertyChanges"]);
+		considerMetadata(attrs["pPrMark"]);
+		for (const key of DIRECT_REVISION_ATTR_KEYS) considerMetadata(attrs[key]);
+		considerMetadata(attrs["cellMarker"]);
 	});
 	return max;
-}
+};
+const maxAnnotationIdInDoc = (doc) => visitAnnotationIds(doc, () => {});
 /**
 * Raise the counter above every annotation id already present in `doc`.
 * Called from the suggestion-mode plugin's `state.init`.
 */
 function seedRevisionIdsFromDoc(doc) {
-	seedRevisionIdsAbove(maxAnnotationIdInDoc(doc));
+	visitAnnotationIds(doc, seedRevisionIdsAbove);
 }
 //#endregion
-export { maxAnnotationIdInDoc, mintRevisionId, seedRevisionIdsAbove, seedRevisionIdsFromDoc };
+export { RevisionIdAllocationError, claimRevisionIds, maxAnnotationIdInDoc, mintRevisionId, nextRevisionId, nextRevisionIdRange, reserveRevisionIds, revisionIdSeedAbove, seedRevisionIdsAbove, seedRevisionIdsFromDoc };

package/dist/prosemirror/plugins/suggestionMode.d.ts

@@ -66,8 +66,8 @@ declare function handleSuggestionEnter(view: EditorView, pluginState: Suggestion
  * - Delete-at-paragraph-end     → current paragraph.
  *
  * Returns `null` when there is no adjacent sibling paragraph (the join would
- * not produce paragraph-mark merging — e.g. doc start, doc end, or sibling
- * is a table). The default merge path then runs unchanged.
+ * not produce paragraph-mark merging, e.g. doc start, doc end, or a table).
+ * Bookmark markers at an edge do not hide the adjacent paragraph break.
  */
 declare function paragraphBoundaryTarget(state: EditorState, direction: "backward" | "forward"): number | null;
 /** Apply the editor's selected-content deletion path for a host cut action. */