@stll/folio-core 0.28.1 → 0.29.0

package/dist/prosemirror/numberedRefFields.js

@@ -0,0 +1,276 @@
+import { expectFieldAttrs, expectParagraphAttrs } from "./attrs/index.js";
+import { expectBookmarkBoundaryAttrs } from "./bookmarkBoundaryAttrs.js";
+import { advanceVisibleListMarker, createListCounterState, resolveListTemplateWithComponents } from "./listMarker.js";
+import { Fragment } from "prosemirror-model";
+//#region src/prosemirror/numberedRefFields.ts
+const MAX_FIELD_INSTRUCTION_CHARS = 2048;
+const MAX_BOOKMARK_NAME_CHARS = 256;
+const MAX_NUMBERED_REF_FIELDS = 1024;
+const MAX_BOOKMARK_TARGETS = 2048;
+function tokenizeInstruction(instruction) {
+	const tokens = [];
+	let index = 0;
+	while (index < instruction.length) {
+		while (/\s/u.test(instruction[index] ?? "")) index += 1;
+		if (index >= instruction.length) break;
+		if (instruction[index] === "\"") {
+			const close = instruction.indexOf("\"", index + 1);
+			if (close === -1) return null;
+			tokens.push(instruction.slice(index + 1, close));
+			index = close + 1;
+			continue;
+		}
+		let end = index;
+		while (end < instruction.length && !/\s/u.test(instruction[end] ?? "")) end += 1;
+		tokens.push(instruction.slice(index, end));
+		index = end;
+	}
+	return tokens;
+}
+function parseNumberedRefInstruction(instruction) {
+	if (instruction.length > MAX_FIELD_INSTRUCTION_CHARS) return null;
+	const tokens = tokenizeInstruction(instruction);
+	if (tokens === null || tokens.length < 3 || tokens.at(0)?.toUpperCase() !== "REF") return null;
+	const bookmark = tokens.at(1);
+	if (!bookmark || bookmark.length > MAX_BOOKMARK_NAME_CHARS || bookmark.startsWith("\\")) return null;
+	let numberSwitch = null;
+	for (let index = 2; index < tokens.length; index += 1) {
+		const token = tokens[index]?.toUpperCase();
+		if (token === "\\N" || token === "\\R" || token === "\\W") {
+			if (numberSwitch !== null) return null;
+			if (token === "\\N") numberSwitch = "n";
+			else if (token === "\\R") numberSwitch = "r";
+			else numberSwitch = "w";
+			continue;
+		}
+		if (token === "\\H") continue;
+		if (token === "\\*MERGEFORMAT") continue;
+		if (token === "\\*" && tokens[index + 1]?.toUpperCase() === "MERGEFORMAT") {
+			index += 1;
+			continue;
+		}
+		return null;
+	}
+	return numberSwitch === null ? null : {
+		bookmark,
+		numberSwitch
+	};
+}
+function trimTrailingPeriod(value) {
+	return value.length > 1 && value.endsWith(".") ? value.slice(0, -1) : value;
+}
+function firstReferencedLevel(template) {
+	let first = null;
+	for (const match of template.matchAll(/%(?<level>[1-9])/gu)) {
+		const level = Number.parseInt(match.groups?.["level"] ?? "", 10) - 1;
+		if (Number.isNaN(level)) continue;
+		first = first === null ? level : Math.min(first, level);
+	}
+	return first;
+}
+function numberTargetForParagraph(node, contextStreams, streams) {
+	const resolution = advanceVisibleListMarker(expectParagraphAttrs(node), streams);
+	let visibleTarget = null;
+	for (const advanced of resolution.advances) {
+		const target = numberTargetForAdvancedMarker(advanced.counterAttrs, advanced.marker, advanced.counterState, contextStreams[advanced.stream]);
+		if (advanced.stream === resolution.stream && advanced.counterAttrs === resolution.counterAttrs) visibleTarget = target;
+	}
+	return visibleTarget;
+}
+function numberTargetForAdvancedMarker(attrs, resolvedMarker, state, contexts) {
+	const numId = attrs.numPr?.numId;
+	if (numId === void 0 || numId === 0 || attrs.listIsBullet || attrs.listMarkerHidden || attrs.listNumFmt === "none" || !resolvedMarker) return null;
+	const marker = attrs.listMarkerAllCaps ? resolvedMarker.toLocaleUpperCase() : resolvedMarker;
+	const level = attrs.numPr?.ilvl ?? 0;
+	if (!Number.isInteger(level) || level < 0 || level > 8) return null;
+	const counters = state.counters.get(numId)?.slice(0, level + 1);
+	const levelFormats = attrs.listLevelNumFmts ?? (attrs.listNumFmt ? [attrs.listNumFmt] : void 0);
+	let renderedMarker = {
+		value: marker,
+		components: []
+	};
+	if (attrs.listMarker?.includes("%") && counters?.length === level + 1) {
+		const rendered = resolveListTemplateWithComponents({
+			template: attrs.listMarker,
+			counters,
+			levelFormats,
+			forceDecimal: attrs.listIsLegal
+		});
+		if ((attrs.listMarkerAllCaps ? rendered.value.toLocaleUpperCase() : rendered.value) === marker) renderedMarker = {
+			value: marker,
+			components: rendered.components
+		};
+	}
+	const abstractContexts = attrs.listAbstractNumId === void 0 ? void 0 : contexts.byAbstractNumId.get(attrs.listAbstractNumId);
+	const ownContexts = contexts.byNumId.get(numId) ?? [...abstractContexts ?? []];
+	const firstLevel = firstReferencedLevel(attrs.listMarker ?? "");
+	let renderedFull;
+	if (level === 0 || firstLevel === 0) renderedFull = renderedMarker;
+	else {
+		const parentLevel = (firstLevel ?? level) - 1;
+		const prefix = ownContexts[parentLevel] ?? abstractContexts?.[parentLevel];
+		renderedFull = prefix === void 0 ? null : {
+			value: `${prefix.value}${marker}`,
+			components: [...prefix.components, ...renderedMarker.components.map((component) => ({
+				level: component.level,
+				relativeStart: component.relativeStart + prefix.value.length,
+				start: component.start + prefix.value.length,
+				end: component.end + prefix.value.length
+			}))]
+		};
+	}
+	ownContexts[level] = renderedFull ?? void 0;
+	ownContexts.splice(level + 1);
+	contexts.byNumId.set(numId, ownContexts);
+	if (attrs.listAbstractNumId !== void 0) contexts.byAbstractNumId.set(attrs.listAbstractNumId, [...ownContexts]);
+	const path = counters?.length === level + 1 && counters.every(Number.isFinite) && renderedFull !== null ? {
+		scheme: attrs.listAbstractNumId === void 0 ? {
+			type: "instance",
+			id: numId
+		} : {
+			type: "abstract",
+			id: attrs.listAbstractNumId
+		},
+		counters,
+		rendered: renderedFull
+	} : null;
+	return {
+		current: trimTrailingPeriod(marker),
+		full: renderedFull === null ? null : trimTrailingPeriod(renderedFull.value),
+		path
+	};
+}
+function sameNumberingScheme(left, right) {
+	return left.type === right.type && left.id === right.id;
+}
+function relativeNumber(target, source) {
+	if (source === null || source.path === null || target.path === null) return target.full;
+	if (!sameNumberingScheme(source.path.scheme, target.path.scheme)) return target.full;
+	let sharedLevels = 0;
+	const comparedLevels = Math.min(source.path.counters.length, target.path.counters.length);
+	while (sharedLevels < comparedLevels && source.path.counters[sharedLevels] === target.path.counters[sharedLevels]) sharedLevels += 1;
+	if (sharedLevels === 0) return target.full;
+	if (sharedLevels >= target.path.counters.length) return null;
+	const firstRelativeComponent = target.path.rendered.components.find((component) => component.level >= sharedLevels);
+	if (firstRelativeComponent === void 0) return null;
+	const suffix = target.path.rendered.value.slice(firstRelativeComponent.relativeStart).replace(/^[\s,.:;/-]+/u, "");
+	return suffix.length === 0 ? null : trimTrailingPeriod(suffix);
+}
+function normalizeCachedResult(value) {
+	return value.replaceAll("\xA0", " ").replace(/\s+/gu, " ").trim();
+}
+function collectNumberedRefCandidates(doc, options) {
+	const fields = [];
+	doc.descendants((node) => {
+		if (node.type.name !== "field" && node.type.name !== "structuredField") return true;
+		if (fields.length >= MAX_NUMBERED_REF_FIELDS) return false;
+		const attrs = expectFieldAttrs(node);
+		if (attrs.fieldType !== "REF" || attrs.fldLock) return false;
+		const spec = parseNumberedRefInstruction(attrs.instruction);
+		if (spec !== null) fields.push({
+			node,
+			spec,
+			cached: attrs.displayText
+		});
+		return false;
+	});
+	if (fields.length === 0) return [];
+	const referencedBookmarks = new Set(fields.map(({ spec }) => spec.bookmark));
+	const fieldNodes = new Set(fields.map(({ node }) => node));
+	const sourceByField = /* @__PURE__ */ new WeakMap();
+	const targets = /* @__PURE__ */ new Map();
+	const streams = {
+		final: options.listCounterState ?? createListCounterState(),
+		original: options.originalListCounterState ?? createListCounterState()
+	};
+	const createContexts = () => ({
+		byNumId: /* @__PURE__ */ new Map(),
+		byAbstractNumId: /* @__PURE__ */ new Map()
+	});
+	const contextStreams = {
+		final: createContexts(),
+		original: createContexts()
+	};
+	doc.descendants((node) => {
+		if (node.type.name !== "paragraph") return true;
+		const target = numberTargetForParagraph(node, contextStreams, streams);
+		node.descendants((descendant) => {
+			if (descendant.type.name === "bookmarkBoundary") {
+				const attrs = expectBookmarkBoundaryAttrs(descendant);
+				if (attrs.type === "start" && targets.size < MAX_BOOKMARK_TARGETS && referencedBookmarks.has(attrs.name) && !targets.has(attrs.name)) targets.set(attrs.name, target);
+				return false;
+			}
+			if (descendant.type.name !== "field" && descendant.type.name !== "structuredField") return true;
+			if (fieldNodes.has(descendant)) sourceByField.set(descendant, target);
+			return true;
+		});
+		const paragraphAttrs = expectParagraphAttrs(node);
+		if (targets.size < MAX_BOOKMARK_TARGETS) {
+			for (const bookmark of paragraphAttrs.bookmarks ?? []) if (referencedBookmarks.has(bookmark.name) && !targets.has(bookmark.name)) targets.set(bookmark.name, target);
+		}
+		return false;
+	});
+	const candidates = [];
+	for (const field of fields) {
+		const target = targets.get(field.spec.bookmark);
+		if (target === void 0 || target === null) continue;
+		let value;
+		if (field.spec.numberSwitch === "n") value = target.current;
+		else if (field.spec.numberSwitch === "r") value = relativeNumber(target, sourceByField.get(field.node) ?? null);
+		else value = target.full;
+		if (value !== null) candidates.push({
+			node: field.node,
+			cached: field.cached,
+			value
+		});
+	}
+	return candidates;
+}
+const isCalibratedCandidate = ({ node, cached, value }) => {
+	const normalizedCache = normalizeCachedResult(cached);
+	const baseline = expectFieldAttrs(node)._numberedRefBaseline;
+	return normalizedCache.length === 0 || normalizedCache === normalizeCachedResult(value) || baseline !== void 0 && normalizedCache === normalizeCachedResult(baseline);
+};
+const mapDocument = (node, transform) => {
+	let mapped = node;
+	if (node.childCount > 0) {
+		const children = [];
+		let changed = false;
+		node.forEach((child) => {
+			const mappedChild = mapDocument(child, transform);
+			children.push(mappedChild);
+			changed ||= mappedChild !== child;
+		});
+		if (changed) mapped = node.copy(Fragment.fromArray(children));
+	}
+	return transform(mapped);
+};
+/** Stamp only proven numbered REF fields with clone-safe calibration state. */
+function stampNumberedRefFieldBaselines(doc) {
+	const baselines = /* @__PURE__ */ new WeakMap();
+	let hasBaselines = false;
+	for (const candidate of collectNumberedRefCandidates(doc, {})) if (isCalibratedCandidate(candidate)) {
+		baselines.set(candidate.node, candidate.cached);
+		hasBaselines = true;
+	}
+	if (!hasBaselines) return doc;
+	return mapDocument(doc, (node) => {
+		const baseline = baselines.get(node);
+		if (baseline === void 0 || node.type.name !== "field" && node.type.name !== "structuredField") return node;
+		return node.type.create({
+			...node.attrs,
+			_numberedRefBaseline: baseline
+		}, node.content, node.marks);
+	});
+}
+/**
+* Resolve bounded, numbered REF fields against bookmarks in the ProseMirror body story.
+* Unsupported or uncalibrated fields are absent from the returned map and retain their cache.
+*/
+function resolveNumberedRefFields(doc, options = {}) {
+	const results = /* @__PURE__ */ new Map();
+	for (const candidate of collectNumberedRefCandidates(doc, options)) if (isCalibratedCandidate(candidate)) results.set(candidate.node, candidate.value);
+	return results;
+}
+//#endregion
+export { parseNumberedRefInstruction, resolveNumberedRefFields, stampNumberedRefFieldBaselines };

package/dist/prosemirror/paraText.js

@@ -3,9 +3,15 @@
 function getVanillaNodeText(node) {
 	const parts = [];
 	node.descendants((child) => {
-		if (!child.isText || !child.text) return true;
 		if (child.marks.some((m) => m.type.name === "insertion")) return false;
-		parts.push(child.text);
+		if (child.isText && child.text) {
+			parts.push(child.text);
+			return false;
+		}
+		if (child.isLeaf && child.textContent) {
+			parts.push(child.textContent);
+			return false;
+		}
 		return true;
 	});
 	return parts.join("");
@@ -15,11 +21,18 @@ function getVanillaTextBetween(doc, from, to) {
 	if (from >= to) return "";
 	const parts = [];
 	doc.nodesBetween(from, to, (child, pos) => {
-		if (!child.isText || !child.text) return;
-		if (child.marks.some((m) => m.type.name === "insertion")) return;
-		const start = Math.max(from, pos);
-		const end = Math.min(to, pos + child.text.length);
-		if (start < end) parts.push(child.text.slice(start - pos, end - pos));
+		if (child.marks.some((m) => m.type.name === "insertion")) return false;
+		if (child.isText && child.text) {
+			const start = Math.max(from, pos);
+			const end = Math.min(to, pos + child.text.length);
+			if (start < end) parts.push(child.text.slice(start - pos, end - pos));
+			return false;
+		}
+		if (child.isLeaf && child.textContent) {
+			parts.push(child.textContent);
+			return false;
+		}
+		return true;
 	});
 	return parts.join("");
 }
@@ -41,25 +54,51 @@ function findTextInPmParagraph(doc, paragraphFrom, paragraphTo, searchText) {
 	let fullText = "";
 	const textPositions = [];
 	doc.nodesBetween(paragraphFrom, paragraphTo, (node, pos) => {
-		if (!node.isText || !node.text) return;
-		if (node.marks.some((m) => m.type.name === "insertion")) return;
-		textPositions.push({
-			pos,
-			len: node.text.length
-		});
-		fullText += node.text;
+		if (node.marks.some((m) => m.type.name === "insertion")) return false;
+		if (node.isText && node.text) {
+			textPositions.push({
+				text: node.text,
+				pos,
+				pmLength: node.text.length,
+				atomic: false
+			});
+			fullText += node.text;
+			return false;
+		}
+		if (node.isLeaf && node.textContent) {
+			textPositions.push({
+				text: node.textContent,
+				pos,
+				pmLength: node.nodeSize,
+				atomic: true
+			});
+			fullText += node.textContent;
+			return false;
+		}
+		return true;
 	});
 	const firstMatch = fullText.indexOf(searchText);
 	if (firstMatch === -1) return null;
 	if (fullText.indexOf(searchText, firstMatch + 1) !== -1) return null;
+	const matchEnd = firstMatch + searchText.length;
+	let segmentStart = 0;
+	for (const position of textPositions) {
+		const segmentEnd = segmentStart + position.text.length;
+		if (position.atomic && (segmentStart < firstMatch && firstMatch < segmentEnd || segmentStart < matchEnd && matchEnd < segmentEnd)) return null;
+		segmentStart = segmentEnd;
+	}
 	let charOffset = 0;
 	let fromPos = paragraphFrom;
 	let toPos = paragraphFrom;
 	for (const tp of textPositions) {
-		const segEnd = charOffset + tp.len;
-		if (charOffset <= firstMatch && firstMatch < segEnd) fromPos = tp.pos + (firstMatch - charOffset);
+		const segEnd = charOffset + tp.text.length;
+		if (charOffset <= firstMatch && firstMatch < segEnd) {
+			const localOffset = firstMatch - charOffset;
+			fromPos = tp.atomic ? tp.pos : tp.pos + localOffset;
+		}
 		if (charOffset <= firstMatch + searchText.length && firstMatch + searchText.length <= segEnd) {
-			toPos = tp.pos + (firstMatch + searchText.length - charOffset);
+			const localOffset = firstMatch + searchText.length - charOffset;
+			toPos = tp.atomic ? tp.pos + tp.pmLength : tp.pos + localOffset;
 			break;
 		}
 		charOffset = segEnd;

package/dist/prosemirror/plugins/anonymizationDecorations.js

@@ -36,7 +36,7 @@ const buildMatches = (doc, terms) => {
 			let match = regex.exec(joined);
 			while (match !== null) {
 				const from = offsetToDocPos(chunks, match.index);
-				const to = offsetToDocPos(chunks, match.index + match[0].length);
+				const to = offsetToDocPos(chunks, match.index + match[0].length, "end");
 				matches.push({
 					from,
 					to,

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

@@ -4,6 +4,8 @@ type TextChunk = {
   text: string;
   /** PM doc position where this chunk's first char lives. */
   start: number;
+  /** PM position after this chunk; differs from text length for atomic fields. */
+  end?: number;
 };
 /**
  * Collect every block-level node's text content as an array of
@@ -12,7 +14,7 @@ type TextChunk = {
  */
 declare const collectBlockChunks: (doc: Node) => TextChunk[][];
 /** Map a joined-string offset back to its PM doc position. */
-declare const offsetToDocPos: (chunks: TextChunk[], offset: number) => number;
+declare const offsetToDocPos: (chunks: TextChunk[], offset: number, bias?: "start" | "end") => number;
 /** Join a block's chunks into the single string callers scan. */
 declare const joinChunks: (chunks: TextChunk[]) => string;
 //#endregion

package/dist/prosemirror/plugins/pmTextScan.js

@@ -10,10 +10,24 @@ const collectBlockChunks = (doc) => {
 		if (node.isTextblock) {
 			const chunks = [];
 			node.descendants((child, offset) => {
-				if (child.isText && child.text !== void 0) chunks.push({
-					text: child.text,
-					start: pos + 1 + offset
-				});
+				if (child.isText && child.text !== void 0) {
+					const start = pos + 1 + offset;
+					chunks.push({
+						text: child.text,
+						start,
+						end: start + child.text.length
+					});
+					return false;
+				}
+				if (child.isLeaf && child.textContent) {
+					const start = pos + 1 + offset;
+					chunks.push({
+						text: child.textContent,
+						start,
+						end: start + child.nodeSize
+					});
+					return false;
+				}
 				return true;
 			});
 			if (chunks.length > 0) blocks.push(chunks);
@@ -24,14 +38,21 @@ const collectBlockChunks = (doc) => {
 	return blocks;
 };
 /** Map a joined-string offset back to its PM doc position. */
-const offsetToDocPos = (chunks, offset) => {
+const offsetToDocPos = (chunks, offset, bias = "start") => {
 	let consumed = 0;
 	for (const chunk of chunks) {
-		if (offset <= consumed + chunk.text.length) return chunk.start + (offset - consumed);
+		if (offset <= consumed + chunk.text.length) {
+			const localOffset = offset - consumed;
+			const end = chunk.end ?? chunk.start + chunk.text.length;
+			if (end - chunk.start === chunk.text.length) return chunk.start + localOffset;
+			if (localOffset === 0) return chunk.start;
+			if (localOffset === chunk.text.length || bias === "end") return end;
+			return chunk.start;
+		}
 		consumed += chunk.text.length;
 	}
 	const last = chunks.at(-1);
-	return last ? last.start + last.text.length : 0;
+	return last ? last.end ?? last.start + last.text.length : 0;
 };
 /** Join a block's chunks into the single string callers scan. */
 const joinChunks = (chunks) => chunks.map((c) => c.text).join("");

package/dist/prosemirror/plugins/templateDirectives.js

@@ -71,7 +71,7 @@ const scanDirectives = (doc) => {
 			const last = chunks.at(-1);
 			ranges.push({
 				from: chunks[0]?.start ?? 0,
-				to: last ? last.start + last.text.length : 0,
+				to: last ? last.end ?? last.start + last.text.length : 0,
 				kind: sole.meta.kind,
 				expr: directiveExpr(sole.meta),
 				block: true
@@ -82,7 +82,7 @@ const scanDirectives = (doc) => {
 			const clauseVersion = marker.meta.kind === "clause" ? marker.meta.version : void 0;
 			ranges.push({
 				from: offsetToDocPos(chunks, marker.start),
-				to: offsetToDocPos(chunks, marker.end),
+				to: offsetToDocPos(chunks, marker.end, "end"),
 				kind: marker.meta.kind,
 				expr: directiveExpr(marker.meta),
 				block: false,

package/dist/prosemirror/schema/index.d.ts

@@ -1,5 +1,5 @@
 import { CharacterSpacingAttrs, CharacterStyleAttrs, CommentAttrs, EmphasisMarkAttrs, FontFamilyAttrs, FontSizeAttrs, FootnoteRefAttrs, HighlightAttrs, HyperlinkAttrs, LanguageAttrs, RunFormattingOverrideAttrs, RunPropertyChangeMarkAttrs, RunShadingAttrs, StrikeAttrs, TextColorAttrs, TextEffectAttrs, TrackedChangeMarkAttrs, UnderlineAttrs } from "./marks.js";
-import { BlockSdtAttrs, FieldAttrs, HardBreakAttrs, ImageAttrs, ImagePositionAttrs, MathAttrs, ParagraphAttrs, ParagraphPropertyChangeAttrs, SdtAttrs, ShapeAttrs, SymbolAttrs, TabAttrs, TableAttrs, TableCellAttrs, TableRowAttrs, TextBoxAttrs } from "./nodes.js";
+import { BlockSdtAttrs, BookmarkBoundaryAttrs, FieldAttrs, HardBreakAttrs, ImageAttrs, ImagePositionAttrs, MathAttrs, ParagraphAttrs, ParagraphPropertyChangeAttrs, SdtAttrs, ShapeAttrs, SymbolAttrs, TabAttrs, TableAttrs, TableCellAttrs, TableRowAttrs, TextBoxAttrs } from "./nodes.js";
 import { ExtensionManager } from "../extensions/ExtensionManager.js";
 //#region src/prosemirror/schema/index.d.ts
 declare const singletonManager: ExtensionManager;
@@ -11,4 +11,4 @@ type DocxSchema = typeof schema;
 type DocxNode = ReturnType<typeof schema.node>;
 type DocxMark = ReturnType<typeof schema.mark>;
 //#endregion
-export { type BlockSdtAttrs, type CharacterSpacingAttrs, type CharacterStyleAttrs, type CommentAttrs, DocxMark, DocxNode, DocxSchema, type EmphasisMarkAttrs, type FieldAttrs, type FontFamilyAttrs, type FontSizeAttrs, type FootnoteRefAttrs, type HardBreakAttrs, type HighlightAttrs, type HyperlinkAttrs, type ImageAttrs, type ImagePositionAttrs, type LanguageAttrs, type MathAttrs, type ParagraphAttrs, type ParagraphPropertyChangeAttrs, type RunFormattingOverrideAttrs, type RunPropertyChangeMarkAttrs, type RunShadingAttrs, type SdtAttrs, type ShapeAttrs, type StrikeAttrs, type SymbolAttrs, type TabAttrs, type TableAttrs, type TableCellAttrs, type TableRowAttrs, type TextBoxAttrs, type TextColorAttrs, type TextEffectAttrs, type TrackedChangeMarkAttrs, type UnderlineAttrs, schema, singletonManager };
+export { type BlockSdtAttrs, type BookmarkBoundaryAttrs, type CharacterSpacingAttrs, type CharacterStyleAttrs, type CommentAttrs, DocxMark, DocxNode, DocxSchema, type EmphasisMarkAttrs, type FieldAttrs, type FontFamilyAttrs, type FontSizeAttrs, type FootnoteRefAttrs, type HardBreakAttrs, type HighlightAttrs, type HyperlinkAttrs, type ImageAttrs, type ImagePositionAttrs, type LanguageAttrs, type MathAttrs, type ParagraphAttrs, type ParagraphPropertyChangeAttrs, type RunFormattingOverrideAttrs, type RunPropertyChangeMarkAttrs, type RunShadingAttrs, type SdtAttrs, type ShapeAttrs, type StrikeAttrs, type SymbolAttrs, type TabAttrs, type TableAttrs, type TableCellAttrs, type TableRowAttrs, type TextBoxAttrs, type TextColorAttrs, type TextEffectAttrs, type TrackedChangeMarkAttrs, type UnderlineAttrs, schema, singletonManager };

package/dist/prosemirror/schema/nodes.d.ts

@@ -15,6 +15,16 @@ type SymbolAttrs = {
   font: string;
   char: string;
 };
+type BookmarkBoundaryAttrs = {
+  type: "start";
+  id: number;
+  name: string;
+  colFirst?: number;
+  colLast?: number;
+} | {
+  type: "end";
+  id: number;
+};
 /**
  * Paragraph node attributes - maps to ParagraphFormatting
  */
@@ -292,6 +302,8 @@ type FieldAttrs = {
   instruction: string;
   /** Current/cached display text */
   displayText: string;
+  /** Imported cache that proved numbered REF resolution for this field. */
+  _numberedRefBaseline?: string;
   /** Whether the field came from w:fldSimple or a complex fldChar range */
   fieldKind: "simple" | "complex";
   /** Field is locked */
@@ -706,4 +718,4 @@ type TableCellAttrs = {
   _docxVMergeContinuationCells?: document_d_exports.TableCell[];
 };
 //#endregion
-export { BlockSdtAttrs, FieldAttrs, HardBreakAttrs, ImageAttrs, ImagePositionAttrs, MathAttrs, ParagraphAttrs, ParagraphPropertyChangeAttrs, SdtAttrs, ShapeAttrs, SuggestedStructuralMarker, SymbolAttrs, TabAttrs, TableAttrs, TableCellAttrs, TableRowAttrs, TextBoxAnchorAttrs, TextBoxAttrs };
+export { BlockSdtAttrs, BookmarkBoundaryAttrs, FieldAttrs, HardBreakAttrs, ImageAttrs, ImagePositionAttrs, MathAttrs, ParagraphAttrs, ParagraphPropertyChangeAttrs, SdtAttrs, ShapeAttrs, SuggestedStructuralMarker, SymbolAttrs, TabAttrs, TableAttrs, TableCellAttrs, TableRowAttrs, TextBoxAnchorAttrs, TextBoxAttrs };

package/dist/prosemirror/validation.js

@@ -1,4 +1,5 @@
 import { readBlockSdtAttrs, readCharacterSpacingMarkAttrs, readCharacterStyleMarkAttrs, readCommentMarkAttrs, readEmphasisMarkAttrs, readFieldAttrs, readFontFamilyMarkAttrs, readFontSizeMarkAttrs, readFootnoteRefMarkAttrs, readHardBreakAttrs, readHighlightMarkAttrs, readHyperlinkMarkAttrs, readImageAttrs, readLanguageMarkAttrs, readMathAttrs, readParagraphAttrs, readRunFormattingOverrideMarkAttrs, 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 { readTextBoxAnchorAttrs } from "./textBoxAnchorAttrs.js";
 //#region src/prosemirror/validation.ts
 var ProseMirrorDocumentValidationError = class extends Error {
@@ -18,11 +19,71 @@ const validateProseMirrorDocument = (doc) => {
 		message: `Expected doc, got ${doc.type.name}.`
 	});
 	validateNode(doc, "doc", issues);
+	validateBookmarkBoundaryStructure(doc, issues);
 	return {
 		valid: issues.length === 0,
 		issues
 	};
 };
+const validateBookmarkBoundaryStructure = (doc, issues) => {
+	const open = /* @__PURE__ */ new Map();
+	const startedIds = /* @__PURE__ */ new Set();
+	const registerStart = (id, path) => {
+		if (startedIds.has(id)) {
+			issues.push({
+				path,
+				message: `Bookmark id ${id} has more than one start boundary.`
+			});
+			return;
+		}
+		startedIds.add(id);
+		open.set(id, {
+			id,
+			path
+		});
+	};
+	const registerEnd = (id, path) => {
+		if (!open.get(id)) {
+			issues.push({
+				path,
+				message: `Bookmark id ${id} has no open start boundary.`
+			});
+			return;
+		}
+		open.delete(id);
+	};
+	const visit = (node, path) => {
+		const paragraphAttrs = node.type.name === "paragraph" ? readParagraphAttrs(node) : null;
+		if (paragraphAttrs?.ok) for (const [index, bookmark] of (paragraphAttrs.value.bookmarks ?? []).entries()) registerStart(bookmark.id, `${path}.paragraph.attrs.bookmarks[${index}]`);
+		if (node.type.name === "bookmarkBoundary") {
+			const result = readBookmarkBoundaryAttrs(node);
+			if (result.ok) {
+				const attrs = result.value;
+				const hasHyperlink = node.marks.some((mark) => mark.type.name === "hyperlink");
+				const trackedChanges = node.marks.filter((mark) => mark.type.name === "insertion" || mark.type.name === "deletion");
+				if (trackedChanges.length > 1) issues.push({
+					path,
+					message: "Bookmark boundaries cannot carry multiple tracked-change parents."
+				});
+				else if (trackedChanges.length === 1 && !hasHyperlink) issues.push({
+					path,
+					message: "Bookmark boundaries inside tracked changes require a hyperlink serialization parent."
+				});
+				if (attrs.type === "start") registerStart(attrs.id, path);
+				else registerEnd(attrs.id, path);
+			}
+		}
+		node.forEach((child, _offset, index) => {
+			visit(child, `${path}.content[${index}]`);
+		});
+		if (paragraphAttrs?.ok) for (const [index, bookmark] of (paragraphAttrs.value.bookmarks ?? []).entries()) registerEnd(bookmark.id, `${path}.paragraph.attrs.bookmarks[${index}]`);
+	};
+	visit(doc, "doc");
+	for (const boundary of open.values()) issues.push({
+		path: boundary.path,
+		message: `Bookmark id ${boundary.id} has no matching end boundary.`
+	});
+};
 const assertValidProseMirrorDocument = (doc, context) => {
 	if (validDocumentCache.has(doc)) return;
 	const validation = validateProseMirrorDocument(doc);
@@ -50,6 +111,9 @@ const validateNodeAttrs = (node, path, issues) => {
 		case "horizontalRule":
 		case "pageBreak":
 		case "renderedPageBreak": return;
+		case "bookmarkBoundary":
+			appendAttrIssues(path, readBookmarkBoundaryAttrs(node), issues);
+			return;
 		case "tab":
 			appendAttrIssues(path, readTabAttrs(node), issues);
 			return;
@@ -77,6 +141,35 @@ const validateNodeAttrs = (node, path, issues) => {
 			return;
 		case "field":
 			appendAttrIssues(path, readFieldAttrs(node), issues);
+			if (node.childCount > 0) issues.push({
+				path: `${path}.content`,
+				message: "Ordinary fields cannot contain structured result children."
+			});
+			return;
+		case "structuredField":
+			{
+				const fieldAttrs = readFieldAttrs(node);
+				appendAttrIssues(path, fieldAttrs, issues);
+				if (fieldAttrs.ok) {
+					const hasStructuredHyperlink = node.content.content.some((child) => child.marks.some((mark) => mark.type.name === "hyperlink"));
+					if (fieldAttrs.value.fieldKind === "complex") issues.push({
+						path: `${path}.content`,
+						message: "Complex fields cannot contain structured result children."
+					});
+					else if (!hasStructuredHyperlink) issues.push({
+						path: `${path}.content`,
+						message: "Structured simple fields require hyperlink content."
+					});
+					node.forEach((child, _offset, index) => {
+						const childPath = `${path}.content[${index}]`;
+						const hasHyperlink = child.marks.some((mark) => mark.type.name === "hyperlink");
+						if (child.type.name === "bookmarkBoundary" && !hasHyperlink) issues.push({
+							path: childPath,
+							message: "Bookmark boundaries inside fields require a hyperlink parent."
+						});
+					});
+				}
+			}
 			return;
 		case "math":
 			appendAttrIssues(path, readMathAttrs(node), issues);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@stll/folio-core",
-  "version": "0.28.1",
+  "version": "0.29.0",
   "description": "Headless, framework-neutral core of folio: the OOXML (.docx) parser, document model, ProseMirror integration, and page-layout engine. No React.",
   "keywords": [
     "document-model",