@stll/folio-core 0.61.0 → 0.63.0

package/dist/prosemirror/textBoxHostCollapse.d.ts

@@ -0,0 +1,8 @@
+import { EditorState } from "prosemirror-state";
+//#region src/prosemirror/textBoxHostCollapse.d.ts
+/**
+ * `state` with every paragraph that hosts only text boxes folded into them,
+ * or `state` itself when there is none.
+ */
+export declare const collapseEmptyTextBoxHosts: (state: EditorState) => EditorState;
+//#endregion

package/dist/prosemirror/textBoxHostCollapse.js

@@ -0,0 +1,79 @@
+import { anchoredTextBoxId, endOfParagraphWithItsTextBoxes, textBoxAnchorIdOf } from "./anchoredTextBoxes.js";
+import { expectTextBoxAttrs } from "./attrs/index.js";
+import { hostParagraphAttrs } from "./conversion/toProseDoc.js";
+import { Fragment } from "prosemirror-model";
+//#region src/prosemirror/textBoxHostCollapse.ts
+/**
+* The projection of a paragraph that holds nothing but text boxes.
+*
+* Opening a package folds such a paragraph into its boxes: the parser keeps
+* the wrapper only when it carries a section break, a property change, a
+* bookmark or an empty hyperlink, and the first box then stands in for it
+* (`_docxPlacement: "standalone"`). A document edited in place can leave a
+* paragraph in that state without having been opened that way, for instance
+* once its text is rejected. Folding it the same way keeps the edited
+* document and the package it saves to one projection, positions included.
+*/
+const carriesValue = (value) => Array.isArray(value) ? value.length > 0 : value !== null && value !== void 0;
+/** Whether `node` is a paragraph of text box anchors that the parser would not keep. */
+const isEmptyTextBoxHost = (node) => {
+	if (node.type.name !== "paragraph" || node.childCount === 0) return false;
+	let onlyAnchors = true;
+	node.forEach((child) => {
+		if (textBoxAnchorIdOf(child) === void 0) onlyAnchors = false;
+	});
+	if (!onlyAnchors) return false;
+	return !(carriesValue(node.attrs["_sectionProperties"]) || carriesValue(node.attrs["_propertyChanges"]) || carriesValue(node.attrs["bookmarks"]) || carriesValue(node.attrs["_emptyHyperlinks"]) || carriesValue(node.attrs["pPrMark"]) || carriesValue(node.attrs["_suggestedInsert"]) || carriesValue(node.attrs["reviewCarrier"]));
+};
+/** The host folded into the boxes drawn in it, or `undefined` when it is not whole. */
+const foldedBoxes = (host, boxes) => {
+	const anchors = /* @__PURE__ */ new Set();
+	host.forEach((child) => {
+		const anchorId = textBoxAnchorIdOf(child);
+		if (anchorId !== void 0) anchors.add(anchorId);
+	});
+	const ids = boxes.map((box) => anchoredTextBoxId(box));
+	if (boxes.length === 0 || ids.some((id) => id === void 0 || !anchors.has(id)) || new Set(ids).size !== anchors.size) return;
+	return boxes.map((box, index) => {
+		const attrs = expectTextBoxAttrs(box);
+		const preserved = host.attrs["_preservedAttributes"];
+		return box.type.create({
+			...box.attrs,
+			_docxPlacement: "standalone",
+			...index === 0 ? {
+				_docxHostParagraph: hostParagraphAttrs(host.attrs),
+				...Array.isArray(preserved) && preserved.length > 0 ? { _preservedAttributes: preserved } : { _preservedAttributes: attrs._preservedAttributes }
+			} : {}
+		}, box.content, box.marks);
+	});
+};
+/**
+* `state` with every paragraph that hosts only text boxes folded into them,
+* or `state` itself when there is none.
+*/
+const collapseEmptyTextBoxHosts = (state) => {
+	const hosts = [];
+	state.doc.descendants((node, position) => {
+		if (!isEmptyTextBoxHost(node)) return !node.isTextblock;
+		const end = endOfParagraphWithItsTextBoxes(state.doc, position);
+		const boxes = [];
+		state.doc.nodesBetween(position + node.nodeSize, end, (child, at) => {
+			if (at >= position + node.nodeSize && child.type.name === "textBox") boxes.push(child);
+			return false;
+		});
+		const folded = foldedBoxes(node, boxes);
+		if (folded) hosts.push({
+			from: position,
+			to: end,
+			boxes: folded
+		});
+		return false;
+	});
+	if (hosts.length === 0) return state;
+	const tr = state.tr;
+	for (const { from, to, boxes } of hosts.toReversed()) tr.replaceWith(from, to, Fragment.fromArray(boxes));
+	tr.setMeta("addToHistory", false);
+	return state.apply(tr);
+};
+//#endregion
+export { collapseEmptyTextBoxHosts };

package/dist/prosemirror/textBoxHostParagraph.d.ts

@@ -8,6 +8,5 @@ import { Node } from "prosemirror-model";
  * Building the node runs the carried attributes through the paragraph schema,
  * so every consumer reads them with the validation any paragraph's get.
  */
-declare const textBoxHostParagraph: (textBox: Node) => Node | undefined;
-//#endregion
-export { textBoxHostParagraph };
+export declare const textBoxHostParagraph: (textBox: Node) => Node | undefined;
+//#endregion

package/dist/prosemirror/textInput.d.ts

@@ -12,19 +12,25 @@ type TextInput = {
   from: number;
   to: number;
 };
-declare const dispatchEditorTextInput: <TView extends TextInputDispatchTarget<TView>>(view: TView, input: string | TextInput) => void;
-declare const getEditorInputTargetRange: (view: EditorView, event: InputEvent) => {
+type FormattingMarksBesideLockedControlOptions = {
+  state: EditorState;
+  from: number;
+  to: number;
+};
+export declare const formattingMarksBesideLockedControl: ({ state, from, to }: FormattingMarksBesideLockedControlOptions) => import("prosemirror-model").Mark[] | undefined;
+export declare const dispatchEditorTextInput: <TView extends TextInputDispatchTarget<TView>>(view: TView, input: string | TextInput) => void;
+export declare const getEditorInputTargetRange: (view: EditorView, event: InputEvent) => {
   from: number;
   to: number;
 } | null;
 /** Shared DOM boundary for editor runtimes and standalone suggestion views. */
-declare const handleEditorBeforeInput: (view: EditorView, event: InputEvent) => boolean;
+export declare const handleEditorBeforeInput: (view: EditorView, event: InputEvent) => boolean;
 /**
  * Plugin compositionend handlers run before ProseMirror queues its final DOM
  * flush. A second microtask runs after that flush and sees the committed state.
  */
-declare const afterNativeCompositionFlush: (callback: () => void) => void;
+export declare const afterNativeCompositionFlush: (callback: () => void) => void;
 /** Route committed text through the model before the browser mutates mark spans. */
-declare const createTextInputPlugin: () => Plugin<any>;
+export declare const createTextInputPlugin: () => Plugin<any>;
 //#endregion
-export { afterNativeCompositionFlush, createTextInputPlugin, dispatchEditorTextInput, getEditorInputTargetRange, handleEditorBeforeInput };
+export {};

package/dist/prosemirror/textInput.js

@@ -1,12 +1,36 @@
+import { RUN_FORMATTING_MARK_NAMES } from "./runFormattingMarkNames.js";
 import { AllSelection, Plugin, Selection, TextSelection } from "prosemirror-state";
 //#region src/prosemirror/textInput.ts
+const LOCKED_CONTROL_LOCKS = /* @__PURE__ */ new Set(["contentLocked", "sdtContentLocked"]);
+const isLockedControl = (node) => node?.type.name === "sdt" && LOCKED_CONTROL_LOCKS.has(node.attrs["lock"]);
+const formattingMarksBesideLockedControl = ({ state, from, to }) => {
+	if (from !== to || state.storedMarks !== null) return void 0;
+	const $from = state.doc.resolve(from);
+	const { parent } = $from;
+	if (!parent.isTextblock) return void 0;
+	const before = $from.nodeBefore;
+	const control = [before, $from.nodeAfter].find(isLockedControl);
+	if (!control) return void 0;
+	const afterControl = before === control;
+	const controlIndex = afterControl ? $from.index() - 1 : $from.index();
+	const adjacent = parent.maybeChild(controlIndex + (afterControl ? 1 : -1)) ?? parent.maybeChild(controlIndex + (afterControl ? -1 : 1));
+	if (!adjacent?.isText || adjacent.marks.some((mark) => mark.type.name === "deletion" || mark.type.name === "moveFrom")) return [];
+	return adjacent.marks.filter((mark) => RUN_FORMATTING_MARK_NAMES.has(mark.type.name));
+};
 const dispatchEditorTextInput = (view, input) => {
 	const { from, to } = typeof input === "string" ? view.state.selection : input;
 	const text = typeof input === "string" ? input : input.text;
 	const defaultTransaction = () => {
 		const { selection } = view.state;
 		if (!(selection instanceof AllSelection)) {
-			const tr = view.state.tr.insertText(text, from, to);
+			const formattingMarks = formattingMarksBesideLockedControl({
+				state: view.state,
+				from,
+				to
+			});
+			const tr = view.state.tr;
+			if (formattingMarks !== void 0) tr.setStoredMarks(formattingMarks);
+			tr.insertText(text, from, to);
 			return !selection.empty && selection.from === from && selection.to === to ? tr.setSelection(TextSelection.create(tr.doc, from + text.length)) : tr;
 		}
 		const start = Selection.atStart(view.state.doc);
@@ -78,4 +102,4 @@ const createTextInputPlugin = () => {
 	} } });
 };
 //#endregion
-export { afterNativeCompositionFlush, createTextInputPlugin, dispatchEditorTextInput, getEditorInputTargetRange, handleEditorBeforeInput };
+export { afterNativeCompositionFlush, createTextInputPlugin, dispatchEditorTextInput, formattingMarksBesideLockedControl, getEditorInputTargetRange, handleEditorBeforeInput };

package/dist/prosemirror/trackedRevisionPath.d.ts

@@ -2,9 +2,9 @@ import { InlineWrapperLayer, TrackedRevisionAncestor } from "./schema/marks.js";
 import { Mark, Node } from "prosemirror-model";
 //#region src/prosemirror/trackedRevisionPath.d.ts
 /** The wrappers `node` sits inside, outermost first; empty when it sits in none. */
-declare const inlineWrapperStackOf: (node: Node) => readonly InlineWrapperLayer[];
+export declare const inlineWrapperStackOf: (node: Node) => readonly InlineWrapperLayer[];
 /** One layer of the path used to write and enumerate a tracked run. */
-declare const trackedRevisionLayerOf: (mark: Mark, node: Node) => TrackedRevisionAncestor;
+export declare const trackedRevisionLayerOf: (mark: Mark, node: Node) => TrackedRevisionAncestor;
 type EnclosingInsertionAncestorsOptions = {
   /** The insertion a deletion mark shares its text with, if any. */
   insertionMark: Mark | undefined;
@@ -12,10 +12,10 @@ type EnclosingInsertionAncestorsOptions = {
   node: Node;
 };
 /** The deletion's ancestor path, with the insertion it sits in as the outermost layer. */
-declare const enclosingInsertionAncestors: ({ insertionMark, ancestors, node }: EnclosingInsertionAncestorsOptions) => readonly TrackedRevisionAncestor[];
+export declare const enclosingInsertionAncestors: ({ insertionMark, ancestors, node }: EnclosingInsertionAncestorsOptions) => readonly TrackedRevisionAncestor[];
 /** The authored revision layers already owned by a mark, outermost first. */
-declare const trackedRevisionPathOf: (mark: Mark) => readonly TrackedRevisionAncestor[];
+export declare const trackedRevisionPathOf: (mark: Mark) => readonly TrackedRevisionAncestor[];
 /** Promote a surviving existing layer; callers cannot supply a fresh identity. */
-declare const retainedTrackedRevisionMark: (mark: Mark, keepLayer: (layer: TrackedRevisionAncestor) => boolean) => Mark | null;
+export declare const retainedTrackedRevisionMark: (mark: Mark, keepLayer: (layer: TrackedRevisionAncestor) => boolean) => Mark | null;
 //#endregion
-export { enclosingInsertionAncestors, inlineWrapperStackOf, retainedTrackedRevisionMark, trackedRevisionLayerOf, trackedRevisionPathOf };
+export {};

package/dist/prosemirror/trackedRevisionPath.js

@@ -26,9 +26,9 @@ const trackedRevisionLayerOf = (mark, node) => {
 /** The deletion's ancestor path, with the insertion it sits in as the outermost layer. */
 const enclosingInsertionAncestors = ({ insertionMark, ancestors, node }) => {
 	if (!insertionMark) return ancestors;
-	const attrs = expectTrackedChangeMarkAttrs(insertionMark);
-	if (ancestors.some(({ revisionId }) => revisionId === attrs.revisionId)) return ancestors;
-	return [trackedRevisionLayerOf(insertionMark, node), ...ancestors];
+	const layer = trackedRevisionLayerOf(insertionMark, node);
+	if (ancestors.some(({ revisionId, type }) => revisionId === layer.revisionId && type === layer.type)) return ancestors;
+	return [layer, ...ancestors];
 };
 const revisionLayerOf = (mark) => {
 	const attrs = expectTrackedChangeMarkAttrs(mark);
@@ -55,6 +55,8 @@ const retainedTrackedRevisionMark = (mark, keepLayer) => {
 	const name = active.type === "insertion" || active.type === "moveTo" ? "insertion" : "deletion";
 	const type = mark.type.schema.marks[name];
 	if (!type) panic("A nested tracked revision has no editor mark type");
+	const attrs = expectTrackedChangeMarkAttrs(mark);
+	const commentRangeBoundaries = attrs._docxCommentRangeBoundaries?.map((boundary) => Object.assign({}, boundary, { owner: boundary.owner === "revision" && active.revisionId !== attrs.revisionId ? "parent" : boundary.owner }));
 	return type.create({
 		revisionId: active.revisionId,
 		author: active.author,
@@ -64,7 +66,8 @@ const retainedTrackedRevisionMark = (mark, keepLayer) => {
 		moveKind: active.type === "moveTo" || active.type === "moveFrom" ? active.type : null,
 		_historicalFormatting: active.type === "deletion" || active.type === "moveFrom" ? true : null,
 		_docxOuterWrapperCount: active.outerWrapperCount,
-		_docxRevisionAncestors: remaining.length > 1 ? remaining.slice(0, -1) : null
+		_docxRevisionAncestors: remaining.length > 1 ? remaining.slice(0, -1) : null,
+		_docxCommentRangeBoundaries: commentRangeBoundaries && commentRangeBoundaries.length > 0 ? commentRangeBoundaries : void 0
 	});
 };
 //#endregion

package/dist/prosemirror/trackedRunInlineAtoms.d.ts

@@ -1,6 +1,6 @@
 import { Node } from "prosemirror-model";
 //#region src/prosemirror/trackedRunInlineAtoms.d.ts
-type TrackedRunInlineAtomDisposition = "carry" | "field-carrier" | "outside-wrapper" | "page-break-carrier" | "text-carrier" | "transparent";
+export type TrackedRunInlineAtomDisposition = "carry" | "field-carrier" | "outside-wrapper" | "page-break-carrier" | "text-carrier" | "transparent";
 /**
  * How every inline atom in the editor schema participates in an OOXML
  * run-level tracked-change wrapper.
@@ -9,9 +9,10 @@ type TrackedRunInlineAtomDisposition = "carry" | "field-carrier" | "outside-wrap
  * to its complete inline-atom set. The lookup also panics on a missing entry:
  * a new atom cannot silently lose revision ownership before that test runs.
  */
-declare const TRACKED_RUN_INLINE_ATOM_DISPOSITIONS: Readonly<{
+export declare const TRACKED_RUN_INLINE_ATOM_DISPOSITIONS: Readonly<{
   readonly bookmarkBoundary: "carry";
-  readonly commentReference: "transparent";
+  readonly commentReference: "carry";
+  readonly commentRangeBoundary: "carry";
   readonly field: "field-carrier";
   readonly hardBreak: "carry";
   readonly image: "carry";
@@ -20,8 +21,8 @@ declare const TRACKED_RUN_INLINE_ATOM_DISPOSITIONS: Readonly<{
   readonly noteMarker: "carry";
   readonly pageBreakRun: "page-break-carrier";
   readonly preservedXml: "carry";
-  readonly rangeAnchor: "transparent";
-  readonly renderedPageBreak: "transparent";
+  readonly rangeAnchor: "carry";
+  readonly renderedPageBreak: "carry";
   readonly shape: "carry";
   readonly structuredField: "carry";
   readonly symbol: "carry";
@@ -29,8 +30,7 @@ declare const TRACKED_RUN_INLINE_ATOM_DISPOSITIONS: Readonly<{
   readonly text: "text-carrier";
   readonly textBoxAnchor: "carry";
 }>;
-declare const trackedRunInlineAtomDisposition: (node: Node) => TrackedRunInlineAtomDisposition | null;
+export declare const trackedRunInlineAtomDisposition: (node: Node) => TrackedRunInlineAtomDisposition | null;
 /** Whether an editor node can own an insertion/deletion mark as one run carrier. */
-declare const canCarryTrackedRunMark: (node: Node) => boolean;
-//#endregion
-export { TRACKED_RUN_INLINE_ATOM_DISPOSITIONS, TrackedRunInlineAtomDisposition, canCarryTrackedRunMark, trackedRunInlineAtomDisposition };
+export declare const canCarryTrackedRunMark: (node: Node) => boolean;
+//#endregion

package/dist/prosemirror/trackedRunInlineAtoms.js

@@ -10,7 +10,8 @@ import { panic } from "better-result";
 */
 const TRACKED_RUN_INLINE_ATOM_DISPOSITIONS = Object.freeze({
 	bookmarkBoundary: "carry",
-	commentReference: "transparent",
+	commentReference: "carry",
+	commentRangeBoundary: "carry",
 	field: "field-carrier",
 	hardBreak: "carry",
 	image: "carry",
@@ -19,8 +20,8 @@ const TRACKED_RUN_INLINE_ATOM_DISPOSITIONS = Object.freeze({
 	noteMarker: "carry",
 	pageBreakRun: "page-break-carrier",
 	preservedXml: "carry",
-	rangeAnchor: "transparent",
-	renderedPageBreak: "transparent",
+	rangeAnchor: "carry",
+	renderedPageBreak: "carry",
 	shape: "carry",
 	structuredField: "carry",
 	symbol: "carry",

package/dist/prosemirror/utils/extractTrackedChanges.d.ts

@@ -8,7 +8,7 @@ import { EditorState } from "prosemirror-state";
  *
  * @public
  */
-type TrackedChangeEntry = {
+export type TrackedChangeEntry = {
   /**
    * Revision shape. Inline shapes (`insertion`, `deletion`, `replacement`)
    * wrap text runs; the rest are structural revisions on node attrs.
@@ -80,7 +80,7 @@ type TrackedChangeEntry = {
  *
  * @public
  */
-type TrackedChangesResult = {
+export type TrackedChangesResult = {
   /** Tracked-change entries, sorted by document position, with adjacent same-revision entries merged. */
   entries: TrackedChangeEntry[];
   /**
@@ -103,6 +103,5 @@ type TrackedChangesResult = {
  *
  * @public
  */
-declare function extractTrackedChanges(state: EditorState | null): TrackedChangesResult;
-//#endregion
-export { TrackedChangeEntry, TrackedChangesResult, extractTrackedChanges };
+export declare function extractTrackedChanges(state: EditorState | null): TrackedChangesResult;
+//#endregion

package/dist/prosemirror/utils/findParagraphByParaId.d.ts

@@ -11,7 +11,7 @@ import { Node } from "prosemirror-model";
  *
  * Returns null if no textblock with that paraId exists.
  */
-declare const findParagraphByParaId: (doc: Node, paraId: string) => {
+export declare const findParagraphByParaId: (doc: Node, paraId: string) => {
   node: Node;
   from: number;
   to: number;
@@ -20,6 +20,5 @@ declare const findParagraphByParaId: (doc: Node, paraId: string) => {
  * Sugar over {@link findParagraphByParaId} when callers only need the
  * `from` position (e.g. to feed `scrollToPosition`).
  */
-declare const findStartPosForParaId: (doc: Node, paraId: string) => number | null;
-//#endregion
-export { findParagraphByParaId, findStartPosForParaId };
+export declare const findStartPosForParaId: (doc: Node, paraId: string) => number | null;
+//#endregion

package/dist/prosemirror/utils/tabCalculator.js

@@ -1,2 +1 @@
-import { DEFAULT_TAB_INTERVAL_TWIPS, PIXELS_PER_INCH, TWIPS_PER_INCH, calculateSimpleTabWidth, calculateTabWidth, computeTabStops, pixelsToTwips, twipsToPixels } from "../../layout-engine/measure/tabCalculator.js";
-export { DEFAULT_TAB_INTERVAL_TWIPS, PIXELS_PER_INCH, TWIPS_PER_INCH, calculateSimpleTabWidth, calculateTabWidth, computeTabStops, pixelsToTwips, twipsToPixels };
+export { DEFAULT_TAB_INTERVAL_TWIPS, PIXELS_PER_INCH, TWIPS_PER_INCH, calculateSimpleTabWidth, calculateTabWidth, computeTabStops, pixelsToTwips, twipsToPixels } from "../../layout-engine/measure/tabCalculator.js";

package/dist/prosemirror/utils/visualLineNavigation.d.ts

@@ -16,7 +16,7 @@ type VisualLineStep = {
   pmPos: number;
 };
 /** @internal */
-type VisualLineState = {
+export type VisualLineState = {
   /**
    * Only describes the caret while it is still at `step.pmPos`. Any other move
    * (a click, a find result, an agent edit, typing) leaves the caret elsewhere,
@@ -26,13 +26,13 @@ type VisualLineState = {
   step: VisualLineStep | null;
 };
 /** @internal */
-declare function createVisualLineState(): VisualLineState;
+export declare function createVisualLineState(): VisualLineState;
 /** @internal */
-declare function getCaretClientX(container: HTMLElement, pmPos: number): number | null;
+export declare function getCaretClientX(container: HTMLElement, pmPos: number): number | null;
 /** @internal */
-declare function findLineElementAtPosition(container: HTMLElement, pmPos: number): HTMLElement | null;
+export declare function findLineElementAtPosition(container: HTMLElement, pmPos: number): HTMLElement | null;
 /** @internal */
-declare function findPositionOnLineAtClientX(lineEl: HTMLElement, clientX: number): number | null;
+export declare function findPositionOnLineAtClientX(lineEl: HTMLElement, clientX: number): number | null;
 /**
  * Handle PM ArrowUp / ArrowDown with visual-line awareness + sticky
  * X. Returns true if the event was handled and PM should not run
@@ -41,6 +41,6 @@ declare function findPositionOnLineAtClientX(lineEl: HTMLElement, clientX: numbe
  *
  * @internal
  */
-declare function handleVisualLineKeyDown(state: VisualLineState, view: EditorView, event: KeyboardEvent, container: HTMLElement | null): boolean;
+export declare function handleVisualLineKeyDown(state: VisualLineState, view: EditorView, event: KeyboardEvent, container: HTMLElement | null): boolean;
 //#endregion
-export { VisualLineState, createVisualLineState, findLineElementAtPosition, findPositionOnLineAtClientX, getCaretClientX, handleVisualLineKeyDown };
+export {};

package/dist/prosemirror/utils/visualLineNavigation.js

@@ -4,19 +4,6 @@ import { createTextStreamRange, descendantTextNodes, totalTextLength } from "../
 import { scrollEditorElementIntoView } from "../../paged-layout/editorScrollRoot.js";
 import { Selection, TextSelection } from "prosemirror-state";
 //#region src/prosemirror/utils/visualLineNavigation.ts
-/**
-* Visual line navigation helpers — implements Word/Google-Docs-style
-* ArrowUp / ArrowDown with sticky X across visual lines (not just
-* paragraphs). Lifted from packages/react/src/paged-editor/
-* useVisualLineNavigation.ts so both adapters share the algorithm.
-*
-* Frontend-agnostic: takes a `getContainer: () => HTMLElement | null`
-* callback and a mutable sticky-state object, returns the same
-* function quartet React's hook returns.
-*
-* @packageDocumentation
-* @internal
-*/
 const CONTENT_LINE_SELECTOR = ".layout-page-content .layout-line";
 const PM_SPAN_SELECTOR = "span[data-pm-start][data-pm-end]";
 /** @internal */
@@ -111,7 +98,8 @@ function findPositionOnLineAtClientX(lineEl, clientX) {
 			continue;
 		}
 		if (clientX >= rect.left && clientX <= rect.right) {
-			const textLength = totalTextLength(descendantTextNodes(spanEl));
+			const textNodes = descendantTextNodes(spanEl);
+			const textLength = totalTextLength(textNodes);
 			if (textLength === 0) return pmStart;
 			let lo = 0;
 			let hi = textLength;

package/dist/prosemirror/validation.d.ts

@@ -1,19 +1,18 @@
 import { Node } from "prosemirror-model";
 //#region src/prosemirror/validation.d.ts
-type ProseMirrorDocumentValidationIssue = {
+export type ProseMirrorDocumentValidationIssue = {
   path: string;
   message: string;
 };
-type ValidateProseMirrorDocumentResult = {
+export type ValidateProseMirrorDocumentResult = {
   valid: boolean;
   issues: ProseMirrorDocumentValidationIssue[];
 };
-declare class ProseMirrorDocumentValidationError extends Error {
+export declare class ProseMirrorDocumentValidationError extends Error {
   readonly issues: ProseMirrorDocumentValidationIssue[];
   constructor(context: string, issues: ProseMirrorDocumentValidationIssue[]);
 }
-declare const validateProseMirrorDocument: (doc: Node) => ValidateProseMirrorDocumentResult;
-declare const assertValidProseMirrorDocument: (doc: Node, context: string) => void;
-declare const formatProseMirrorDocumentIssues: (issues: ProseMirrorDocumentValidationIssue[]) => string[];
-//#endregion
-export { ProseMirrorDocumentValidationError, ProseMirrorDocumentValidationIssue, ValidateProseMirrorDocumentResult, assertValidProseMirrorDocument, formatProseMirrorDocumentIssues, validateProseMirrorDocument };
+export declare const validateProseMirrorDocument: (doc: Node) => ValidateProseMirrorDocumentResult;
+export declare const assertValidProseMirrorDocument: (doc: Node, context: string) => void;
+export declare const formatProseMirrorDocumentIssues: (issues: ProseMirrorDocumentValidationIssue[]) => string[];
+//#endregion

package/dist/prosemirror/validation.js

@@ -1,12 +1,28 @@
 import { readNoteMarkerAttrs } from "../internal/noteMarkerAttrs.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 { readCommentRangeBoundaryAttrs } from "./commentRangeBoundaryAttrs.js";
 import { readCommentReferenceAttrs } from "./commentReferenceAttrs.js";
 import { fieldRequiresStructuredContent } from "./fieldRepresentation.js";
 import { readMoveRangeBoundaryAttrs } from "./moveRangeBoundaryAttrs.js";
 import { readRangeAnchorAttrs } from "./rangeAnchorAttrs.js";
+import { isRunContentInlineNodeName } from "./runContentProjection.js";
+import { RUN_FORMATTING_MARK_NAMES } from "./runFormattingMarkNames.js";
+import { RUN_IDENTITY_MARK_NAME } from "./runIdentity.js";
+import { PRESERVED_XML_LEVELS } from "./schema/nodes.js";
 import { readTextBoxAnchorAttrs } from "./textBoxAnchorAttrs.js";
 //#region src/prosemirror/validation.ts
+const COMPLEX_FIELD_RESULT_MARK_NAMES = /* @__PURE__ */ new Set([
+	...RUN_FORMATTING_MARK_NAMES,
+	RUN_IDENTITY_MARK_NAME,
+	"runPropertyChange",
+	"footnoteRef"
+]);
+const hasUnsupportedComplexFieldResultContent = (node) => node.content.content.some((child) => {
+	if (child.type.name === "bookmarkBoundary") return false;
+	const preservedXmlAttrs = child.type.name === "preservedXml" ? readPreservedXmlAttrs(child) : void 0;
+	return preservedXmlAttrs?.ok && preservedXmlAttrs.value.level === PRESERVED_XML_LEVELS.inline || !isRunContentInlineNodeName(child.type.name) || child.marks.some((mark) => !COMPLEX_FIELD_RESULT_MARK_NAMES.has(mark.type.name));
+});
 var ProseMirrorDocumentValidationError = class extends Error {
 	issues;
 	constructor(context, issues) {
@@ -192,10 +208,14 @@ const validateNodeAttrs = (node, path, issues) => {
 		case "commentReference":
 			appendAttrIssues(path, readCommentReferenceAttrs(node), issues);
 			return;
+		case "commentRangeBoundary":
+			appendAttrIssues(path, readCommentRangeBoundaryAttrs(node), issues);
+			return;
 		case "rangeAnchor":
 			appendAttrIssues(path, readRangeAnchorAttrs(node), issues);
 			return;
 		case "moveRangeBoundary":
+		case "blockMoveRangeBoundary":
 			appendAttrIssues(path, readMoveRangeBoundaryAttrs(node), issues);
 			return;
 		case "tab":
@@ -248,27 +268,22 @@ const validateNodeAttrs = (node, path, issues) => {
 				appendAttrIssues(path, fieldAttrs, issues);
 				if (fieldAttrs.ok) {
 					const hasStructuredHyperlink = node.content.content.some((child) => child.marks.some((mark) => mark.type.name === "hyperlink"));
-					const hasPageBreakCarrier = node.content.content.some((child) => child.type.name === "pageBreakRun");
-					if (fieldAttrs.value.fieldKind === "complex" && !hasPageBreakCarrier) issues.push({
+					if (!fieldRequiresStructuredContent(node.content.content)) issues.push({
 						path: `${path}.content`,
-						message: "Complex fields cannot contain structured result children."
+						message: "Structured fields require run metadata, distinct run marks or inline structure."
 					});
 					else if (fieldAttrs.value.fieldKind === "complex" && hasStructuredHyperlink) issues.push({
 						path: `${path}.content`,
 						message: "Complex field results cannot contain hyperlink content."
 					});
-					else if (!fieldRequiresStructuredContent(node.content.content)) issues.push({
+					else if (fieldAttrs.value.fieldKind === "complex" && hasUnsupportedComplexFieldResultContent(node)) issues.push({
 						path: `${path}.content`,
-						message: "Structured simple fields require non-text, hyperlink, wrapper or tracked content."
+						message: "Complex field results can contain only run-representable content."
 					});
 					node.forEach((child, _offset, index) => {
 						const childPath = `${path}.content[${index}]`;
 						const hasHyperlink = child.marks.some((mark) => mark.type.name === "hyperlink");
-						if (fieldAttrs.value.fieldKind === "complex" && child.type.name === "textBoxAnchor") issues.push({
-							path: childPath,
-							message: "Complex field results cannot contain text-box anchors."
-						});
-						else if (fieldAttrs.value.fieldKind === "complex" && child.type.name === "bookmarkBoundary") issues.push({
+						if (fieldAttrs.value.fieldKind === "complex" && child.type.name === "bookmarkBoundary") issues.push({
 							path: childPath,
 							message: "Complex field results cannot contain bookmark boundaries."
 						});

package/dist/prosemirror/yjsDocumentMetadata.d.ts

@@ -8,22 +8,22 @@ import * as Y from "yjs";
  */
 type AttrSchemaMigrationStep = (fragment: Y.XmlFragment) => number;
 /** Every attr-schema version this build reads, oldest first, with no gaps. */
-declare const FOLIO_YJS_ATTR_SCHEMA_VERSIONS: readonly [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13];
+declare const FOLIO_YJS_ATTR_SCHEMA_VERSIONS: readonly [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14];
 /** An attr-schema version this build can read. */
-type FolioYjsAttrSchemaVersion = (typeof FOLIO_YJS_ATTR_SCHEMA_VERSIONS)[number];
+export type FolioYjsAttrSchemaVersion = (typeof FOLIO_YJS_ATTR_SCHEMA_VERSIONS)[number];
 /**
  * The attr-schema version this build writes. Derived against the migration map
  * so the constant and the map cannot disagree.
  */
-declare const FOLIO_YJS_ATTR_SCHEMA_VERSION = 13;
+export declare const FOLIO_YJS_ATTR_SCHEMA_VERSION = 14;
 declare const FolioYjsNoteReferenceSchemaError_base: import("better-result").TaggedErrorClass<"FolioYjsNoteReferenceSchemaError">;
-declare class FolioYjsNoteReferenceSchemaError extends FolioYjsNoteReferenceSchemaError_base<{
+export declare class FolioYjsNoteReferenceSchemaError extends FolioYjsNoteReferenceSchemaError_base<{
   message: string;
   schemaVersion: FolioYjsAttrSchemaVersion;
   requiredSchemaVersion: FolioYjsAttrSchemaVersion;
 }> {}
 declare const FolioYjsNumberingSourceSchemaError_base: import("better-result").TaggedErrorClass<"FolioYjsNumberingSourceSchemaError">;
-declare class FolioYjsNumberingSourceSchemaError extends FolioYjsNumberingSourceSchemaError_base<{
+export declare class FolioYjsNumberingSourceSchemaError extends FolioYjsNumberingSourceSchemaError_base<{
   message: string;
   schemaVersion: FolioYjsAttrSchemaVersion;
   requiredSchemaVersion: FolioYjsAttrSchemaVersion;
@@ -33,7 +33,7 @@ declare class FolioYjsNumberingSourceSchemaError extends FolioYjsNumberingSource
  * {@link FOLIO_YJS_ATTR_SCHEMA_VERSION}, in order. Empty when the snapshot is
  * already current.
  */
-declare const attrSchemaMigrationSteps: (fromVersion: FolioYjsAttrSchemaVersion) => readonly AttrSchemaMigrationStep[];
+export declare const attrSchemaMigrationSteps: (fromVersion: FolioYjsAttrSchemaVersion) => readonly AttrSchemaMigrationStep[];
 /**
  * Carry a fragment this build is about to read or write up to the attr shape
  * this build writes, and stamp the marker.
@@ -48,10 +48,10 @@ declare const attrSchemaMigrationSteps: (fromVersion: FolioYjsAttrSchemaVersion)
  *
  * Returns how many elements the steps rewrote.
  */
-declare const applyAttrSchemaMigrations: (ydoc: Y.Doc, fragment: Y.XmlFragment, fromVersion: FolioYjsAttrSchemaVersion) => number;
+export declare const applyAttrSchemaMigrations: (ydoc: Y.Doc, fragment: Y.XmlFragment, fromVersion: FolioYjsAttrSchemaVersion) => number;
 declare const FolioYjsAttrSchemaVersionError_base: import("better-result").TaggedErrorClass<"FolioYjsAttrSchemaVersionError">;
 /** Raised when a snapshot's attr-schema marker is ahead of the running code. */
-declare class FolioYjsAttrSchemaVersionError extends FolioYjsAttrSchemaVersionError_base<{
+export declare class FolioYjsAttrSchemaVersionError extends FolioYjsAttrSchemaVersionError_base<{
   message: string;
   /** The marker exactly as stored, so the host can log what it refused. */
   marker: unknown;
@@ -68,18 +68,18 @@ declare class FolioYjsAttrSchemaVersionError extends FolioYjsAttrSchemaVersionEr
  * be a silent misread: ProseMirror copies unknown attr values into the node
  * verbatim and drops unknown keys without a trace. It fails instead.
  */
-declare const readYjsAttrSchemaVersion: (ydoc: Y.Doc) => Result<FolioYjsAttrSchemaVersion, FolioYjsAttrSchemaVersionError>;
-declare const proseDocumentParagraphSourceContract: (document: Node) => string | null;
+export declare const readYjsAttrSchemaVersion: (ydoc: Y.Doc) => Result<FolioYjsAttrSchemaVersion, FolioYjsAttrSchemaVersionError>;
+export declare const proseDocumentParagraphSourceContract: (document: Node) => string | null;
 /** Stamp the attr-schema version of the build that wrote the current fragment. */
-declare const writeYjsAttrSchemaVersion: (ydoc: Y.Doc) => void;
+export declare const writeYjsAttrSchemaVersion: (ydoc: Y.Doc) => void;
 /**
  * Write both metadata bindings for a freshly seeded collaboration document.
  * The attr-schema version is written unconditionally; the paragraph-source
  * contract only when the seeding document carries one, because a document
  * built in memory rather than parsed from a package has no source to bind to.
  */
-declare const writeYjsDocumentMetadata: (ydoc: Y.Doc, document: Node) => void;
-declare const readYjsParagraphSourceContract: (ydoc: Y.Doc) => string | null;
-declare const withParagraphSourceContract: (document: Node, contract: string) => Node;
+export declare const writeYjsDocumentMetadata: (ydoc: Y.Doc, document: Node) => void;
+export declare const readYjsParagraphSourceContract: (ydoc: Y.Doc) => string | null;
+export declare const withParagraphSourceContract: (document: Node, contract: string) => Node;
 //#endregion
-export { FOLIO_YJS_ATTR_SCHEMA_VERSION, FolioYjsAttrSchemaVersion, FolioYjsAttrSchemaVersionError, FolioYjsNoteReferenceSchemaError, FolioYjsNumberingSourceSchemaError, applyAttrSchemaMigrations, attrSchemaMigrationSteps, proseDocumentParagraphSourceContract, readYjsAttrSchemaVersion, readYjsParagraphSourceContract, withParagraphSourceContract, writeYjsAttrSchemaVersion, writeYjsDocumentMetadata };
+export {};