@stll/folio-core 0.1.3 → 0.3.0

package/dist/prosemirror/utils/extractTrackedChanges.js

@@ -0,0 +1,379 @@
+//#region src/prosemirror/utils/extractTrackedChanges.ts
+const EMPTY_RESULT = {
+	entries: [],
+	commentToRevision: /* @__PURE__ */ new Map()
+};
+/**
+* Walk the PM doc and extract every tracked change as a flat list of
+* `TrackedChangeEntry` plus a comment→revision overlap map. Adjacent
+* inline marks coalesce by `(type, revisionId, author, date)`; a
+* deletion immediately followed by an insertion (same author + same
+* date) collapses into a single `replacement` entry; paragraph-mark
+* cards (`paragraphMarkInsertion` / `paragraphMarkDeletion`) are
+* hidden when an inline entry already covers their revision triple
+* (one Accept clears every site of one conceptual change).
+*
+* Pure and deterministic. Returns `EMPTY_RESULT` on null state.
+*
+* @public
+*/
+function extractTrackedChanges(state) {
+	if (!state) return EMPTY_RESULT;
+	const { doc, schema } = state;
+	const insertionType = schema.marks["insertion"];
+	const deletionType = schema.marks["deletion"];
+	const commentType = schema.marks["comment"];
+	if (!insertionType && !deletionType) return EMPTY_RESULT;
+	const raw = [];
+	const commentToRevision = /* @__PURE__ */ new Map();
+	const commentMetadata = /* @__PURE__ */ new Map();
+	doc.descendants((node, pos) => {
+		if (node.type.name === "paragraph") {
+			const ins = node.attrs["pPrIns"];
+			const del = node.attrs["pPrDel"];
+			if (ins) raw.push({
+				type: "paragraphMarkInsertion",
+				text: node.textContent || "",
+				author: ins.author || "",
+				date: ins.date ?? void 0,
+				from: pos,
+				to: pos + node.nodeSize,
+				revisionId: ins.revisionId
+			});
+			if (del) raw.push({
+				type: "paragraphMarkDeletion",
+				text: node.textContent || "",
+				author: del.author || "",
+				date: del.date ?? void 0,
+				from: pos,
+				to: pos + node.nodeSize,
+				revisionId: del.revisionId
+			});
+			const pPrChange = node.attrs["pPrChange"];
+			if (Array.isArray(pPrChange)) for (const entry of pPrChange) {
+				if (!entry?.info || typeof entry.info.id !== "number") continue;
+				raw.push({
+					type: "paragraphPropertiesChanged",
+					text: node.textContent || "",
+					author: entry.info.author || "",
+					date: entry.info.date ?? void 0,
+					from: pos,
+					to: pos + node.nodeSize,
+					revisionId: entry.info.id
+				});
+			}
+		}
+		if (node.type.name === "tableRow") {
+			const trIns = node.attrs["trIns"];
+			const trDel = node.attrs["trDel"];
+			if (trIns) raw.push({
+				type: "rowInserted",
+				text: node.textContent || "",
+				author: trIns.author || "",
+				date: trIns.date ?? void 0,
+				from: pos,
+				to: pos + node.nodeSize,
+				revisionId: trIns.revisionId
+			});
+			if (trDel) raw.push({
+				type: "rowDeleted",
+				text: node.textContent || "",
+				author: trDel.author || "",
+				date: trDel.date ?? void 0,
+				from: pos,
+				to: pos + node.nodeSize,
+				revisionId: trDel.revisionId
+			});
+			const trPrChange = node.attrs["trPrChange"];
+			if (Array.isArray(trPrChange)) for (const entry of trPrChange) {
+				if (!entry?.info || typeof entry.info.id !== "number") continue;
+				raw.push({
+					type: "rowPropertiesChanged",
+					text: node.textContent || "",
+					author: entry.info.author || "",
+					date: entry.info.date ?? void 0,
+					from: pos,
+					to: pos + node.nodeSize,
+					revisionId: entry.info.id
+				});
+			}
+		}
+		if (node.type.name === "tableCell" || node.type.name === "tableHeader") {
+			const cellMarker = node.attrs["cellMarker"];
+			if (cellMarker?.info && typeof cellMarker.info.revisionId === "number") {
+				const resolvedType = {
+					ins: "cellInserted",
+					del: "cellDeleted",
+					merge: "cellMerged"
+				}[cellMarker.kind];
+				if (resolvedType) raw.push({
+					type: resolvedType,
+					text: node.textContent || "",
+					author: cellMarker.info.author || "",
+					date: cellMarker.info.date ?? void 0,
+					from: pos,
+					to: pos + node.nodeSize,
+					revisionId: cellMarker.info.revisionId
+				});
+			}
+			const tcPrChange = node.attrs["tcPrChange"];
+			if (Array.isArray(tcPrChange)) for (const entry of tcPrChange) {
+				if (!entry?.info || typeof entry.info.id !== "number") continue;
+				raw.push({
+					type: "cellPropertiesChanged",
+					text: node.textContent || "",
+					author: entry.info.author || "",
+					date: entry.info.date ?? void 0,
+					from: pos,
+					to: pos + node.nodeSize,
+					revisionId: entry.info.id
+				});
+			}
+		}
+		if (node.type.name === "table") {
+			const tblPrChange = node.attrs["tblPrChange"];
+			if (Array.isArray(tblPrChange)) for (const entry of tblPrChange) {
+				if (!entry?.info || typeof entry.info.id !== "number") continue;
+				raw.push({
+					type: "tablePropertiesChanged",
+					text: "",
+					author: entry.info.author || "",
+					date: entry.info.date ?? void 0,
+					from: pos,
+					to: pos + node.nodeSize,
+					revisionId: entry.info.id
+				});
+			}
+			const firstRow = node.firstChild;
+			const firstIns = firstRow?.attrs["trIns"];
+			const firstDel = firstRow?.attrs["trDel"];
+			let sharedAttr = null;
+			if (firstIns) sharedAttr = "trIns";
+			else if (firstDel) sharedAttr = "trDel";
+			if (sharedAttr) {
+				const sharedRev = firstIns ?? firstDel;
+				let allShare = true;
+				const rowRevIds = [];
+				node.forEach((row) => {
+					if (row.type.name !== "tableRow") {
+						allShare = false;
+						return;
+					}
+					const v = row.attrs[sharedAttr];
+					if (!v || (v.author ?? "") !== (sharedRev.author ?? "") || (v.date ?? null) !== (sharedRev.date ?? null)) {
+						allShare = false;
+						return;
+					}
+					rowRevIds.push(v.revisionId);
+				});
+				if (allShare) {
+					let visibleText = "";
+					if (deletionType) node.descendants((child) => {
+						if (child.isText && !child.marks.some((m) => m.type === deletionType)) visibleText += child.text || "";
+					});
+					else visibleText = node.textContent || "";
+					const primaryId = sharedRev.revisionId;
+					const extraIds = rowRevIds.filter((id, idx) => id !== primaryId && rowRevIds.indexOf(id) === idx);
+					raw.push({
+						type: sharedAttr === "trIns" ? "tableInserted" : "tableDeleted",
+						text: visibleText,
+						author: sharedRev.author || "",
+						date: sharedRev.date ?? void 0,
+						from: pos,
+						to: pos + node.nodeSize,
+						revisionId: primaryId,
+						...extraIds.length > 0 ? { coalescedRevisionIds: extraIds } : {}
+					});
+				}
+			}
+		}
+		if (!node.isInline) return;
+		let inlineText;
+		if (node.isText) inlineText = node.text || "";
+		else if (node.type.name === "image") inlineText = node.attrs["alt"] || "image";
+		else inlineText = node.type.name;
+		let tcMark = null;
+		for (const mark of node.marks) if (mark.type === insertionType || mark.type === deletionType) {
+			raw.push({
+				type: mark.type === insertionType ? "insertion" : "deletion",
+				text: inlineText,
+				author: mark.attrs["author"] || "",
+				date: mark.attrs["date"],
+				from: pos,
+				to: pos + node.nodeSize,
+				revisionId: mark.attrs["revisionId"]
+			});
+			tcMark = mark;
+		}
+		if (commentType) {
+			const commentMark = node.marks.find((m) => m.type === commentType);
+			if (commentMark) {
+				const cid = commentMark.attrs["commentId"];
+				let meta = commentMetadata.get(cid);
+				if (!meta) {
+					meta = {
+						revisions: /* @__PURE__ */ new Set(),
+						hasCleanText: false
+					};
+					commentMetadata.set(cid, meta);
+				}
+				if (tcMark) meta.revisions.add(tcMark.attrs["revisionId"]);
+				else meta.hasCleanText = true;
+			}
+		}
+	});
+	for (const [cid, meta] of commentMetadata.entries()) if (!meta.hasCleanText && meta.revisions.size === 1) {
+		const rid = meta.revisions.values().next().value;
+		commentToRevision.set(cid, rid);
+	}
+	const STRUCTURAL_PRIORITY = {
+		tableInserted: 6,
+		tableDeleted: 6,
+		tablePropertiesChanged: 5,
+		rowInserted: 4,
+		rowDeleted: 4,
+		rowPropertiesChanged: 4,
+		cellInserted: 3,
+		cellDeleted: 3,
+		cellMerged: 3,
+		cellPropertiesChanged: 3,
+		paragraphMarkInsertion: 2,
+		paragraphMarkDeletion: 2,
+		paragraphPropertiesChanged: 2
+	};
+	const isStructuralType = (t) => t in STRUCTURAL_PRIORITY;
+	const slotByKey = /* @__PURE__ */ new Map();
+	const ordered = [];
+	const mergeIds = (survivor, dropped) => {
+		const ids = new Set(survivor.coalescedRevisionIds ?? []);
+		for (const id of dropped.coalescedRevisionIds ?? []) ids.add(id);
+		ids.add(dropped.revisionId);
+		ids.delete(survivor.revisionId);
+		return [...ids];
+	};
+	for (const entry of raw) {
+		if (!isStructuralType(entry.type)) {
+			ordered.push(entry);
+			continue;
+		}
+		const key = `${entry.author}|${entry.date ?? ""}`;
+		const slot = slotByKey.get(key);
+		if (slot === void 0) {
+			slotByKey.set(key, ordered.push(entry) - 1);
+			continue;
+		}
+		const existing = ordered[slot];
+		if ((STRUCTURAL_PRIORITY[entry.type] ?? 0) > (STRUCTURAL_PRIORITY[existing.type] ?? 0)) ordered[slot] = {
+			...entry,
+			coalescedRevisionIds: mergeIds(entry, existing)
+		};
+		else ordered[slot] = {
+			...existing,
+			coalescedRevisionIds: mergeIds(existing, entry)
+		};
+	}
+	const inlineGroups = /* @__PURE__ */ new Map();
+	const merged = [];
+	for (const entry of ordered) {
+		if (!(entry.type === "insertion" || entry.type === "deletion")) {
+			merged.push({ ...entry });
+			continue;
+		}
+		const key = `${entry.type}|${entry.author}|${entry.date ?? ""}`;
+		const group = inlineGroups.get(key);
+		if (group) {
+			const sep = group.to === entry.from ? "" : " ";
+			group.text += sep + entry.text;
+			group.to = entry.to;
+			if (entry.revisionId !== group.revisionId) {
+				const ids = new Set(group.coalescedRevisionIds ?? []);
+				for (const id of entry.coalescedRevisionIds ?? []) ids.add(id);
+				ids.add(entry.revisionId);
+				ids.delete(group.revisionId);
+				group.coalescedRevisionIds = ids.size > 0 ? [...ids] : void 0;
+			}
+		} else {
+			const copy = { ...entry };
+			inlineGroups.set(key, copy);
+			merged.push(copy);
+		}
+	}
+	const final = [];
+	for (let i = 0; i < merged.length; i++) {
+		const curr = merged[i];
+		const next = merged[i + 1];
+		if (curr.type === "deletion" && next && next.type === "insertion" && curr.author === next.author && curr.date === next.date && curr.to === next.from) {
+			final.push({
+				type: "replacement",
+				text: next.text,
+				deletedText: curr.text,
+				author: curr.author,
+				date: curr.date,
+				from: curr.from,
+				to: next.to,
+				revisionId: curr.revisionId,
+				insertionRevisionId: next.revisionId
+			});
+			i++;
+		} else final.push(curr);
+	}
+	const inlineByKey = /* @__PURE__ */ new Map();
+	for (const e of final) if (e.type === "insertion" || e.type === "deletion" || e.type === "replacement") {
+		const k = `${e.author}|${e.date ?? ""}`;
+		if (!inlineByKey.has(k)) inlineByKey.set(k, e);
+	}
+	for (const e of final) {
+		if (e.type !== "paragraphMarkInsertion" && e.type !== "paragraphMarkDeletion") continue;
+		const survivor = inlineByKey.get(`${e.author}|${e.date ?? ""}`);
+		if (!survivor) continue;
+		const ids = new Set(survivor.coalescedRevisionIds ?? []);
+		for (const id of e.coalescedRevisionIds ?? []) ids.add(id);
+		ids.add(e.revisionId);
+		ids.delete(survivor.revisionId);
+		if (survivor.type === "replacement" && survivor.insertionRevisionId != null) ids.delete(survivor.insertionRevisionId);
+		survivor.coalescedRevisionIds = ids.size > 0 ? [...ids] : void 0;
+	}
+	const emptyTableEntries = /* @__PURE__ */ new Set();
+	const tableByKey = /* @__PURE__ */ new Map();
+	for (const e of final) {
+		if (e.type !== "tableInserted" && e.type !== "tableDeleted") continue;
+		const key = `${e.author}|${e.date ?? ""}`;
+		if (e.text.trim().length > 0) continue;
+		emptyTableEntries.add(e);
+		if (!tableByKey.has(key)) tableByKey.set(key, e);
+	}
+	for (const e of final) {
+		if (e.type !== "paragraphMarkInsertion" && e.type !== "paragraphMarkDeletion") continue;
+		const survivor = tableByKey.get(`${e.author}|${e.date ?? ""}`);
+		if (!survivor) continue;
+		const ids = new Set(survivor.coalescedRevisionIds ?? []);
+		for (const id of e.coalescedRevisionIds ?? []) ids.add(id);
+		ids.add(e.revisionId);
+		ids.delete(survivor.revisionId);
+		survivor.coalescedRevisionIds = ids.size > 0 ? [...ids] : void 0;
+	}
+	const inlineHosts = final.filter((e) => e.type === "insertion" || e.type === "replacement");
+	const foldedPropChanges = /* @__PURE__ */ new Set();
+	for (const e of final) {
+		if (e.type !== "paragraphPropertiesChanged") continue;
+		const host = inlineHosts.find((c) => c.author === e.author && c.from < e.to && e.from < c.to);
+		if (!host) continue;
+		const ids = new Set(mergeIds(host, e));
+		if (host.type === "replacement" && host.insertionRevisionId != null) ids.delete(host.insertionRevisionId);
+		host.coalescedRevisionIds = ids.size > 0 ? [...ids] : void 0;
+		foldedPropChanges.add(e);
+	}
+	return {
+		entries: final.filter((e) => {
+			const key = `${e.author}|${e.date ?? ""}`;
+			if (e.type === "tableInserted" || e.type === "tableDeleted") return emptyTableEntries.has(e);
+			if (e.type === "paragraphMarkInsertion" || e.type === "paragraphMarkDeletion") return !inlineByKey.has(key) && !tableByKey.has(key);
+			if (e.type === "paragraphPropertiesChanged") return !foldedPropChanges.has(e);
+			if (e.type === "insertion" || e.type === "deletion" || e.type === "replacement") return !tableByKey.has(key);
+			return true;
+		}),
+		commentToRevision
+	};
+}
+//#endregion
+export { extractTrackedChanges };

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

@@ -0,0 +1,27 @@
+import { EditorView } from "prosemirror-view";
+
+//#region src/prosemirror/utils/visualLineNavigation.d.ts
+/** @internal */
+type VisualLineState = {
+  stickyX: number | null;
+  lastVisualLineIndex: number;
+};
+/** @internal */
+declare function createVisualLineState(): VisualLineState;
+/** @internal */
+declare function getCaretClientX(container: HTMLElement, pmPos: number): number | null;
+/** @internal */
+declare function findLineElementAtPosition(container: HTMLElement, pmPos: number): HTMLElement | null;
+/** @internal */
+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
+ * its default behaviour. Mutates `state` so consecutive presses
+ * keep the same sticky X.
+ *
+ * @internal
+ */
+declare function handleVisualLineKeyDown(state: VisualLineState, view: EditorView, event: KeyboardEvent, container: HTMLElement | null): boolean;
+//#endregion
+export { VisualLineState, createVisualLineState, findLineElementAtPosition, findPositionOnLineAtClientX, getCaretClientX, handleVisualLineKeyDown };

package/dist/prosemirror/utils/visualLineNavigation.js

@@ -0,0 +1,217 @@
+import { findVerticalScrollParent } from "../../utils/findVerticalScrollParent.js";
+import { 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";
+/** @internal */
+function createVisualLineState() {
+	return {
+		stickyX: null,
+		lastVisualLineIndex: -1
+	};
+}
+function scrollIntoViewIfNeeded(el) {
+	const container = findVerticalScrollParent(el);
+	if (!container) return;
+	const elRect = el.getBoundingClientRect();
+	const containerRect = container.getBoundingClientRect();
+	const margin = 40;
+	if (elRect.bottom > containerRect.bottom - margin) container.scrollTop += elRect.bottom - containerRect.bottom + margin;
+	else if (elRect.top < containerRect.top + margin) container.scrollTop -= containerRect.top - elRect.top + margin;
+}
+/** @internal */
+function getCaretClientX(container, pmPos) {
+	const spans = container.querySelectorAll("span[data-pm-start][data-pm-end]");
+	for (const span of Array.from(spans)) {
+		const spanEl = span;
+		const pmStart = Number(spanEl.dataset["pmStart"]);
+		const pmEnd = Number(spanEl.dataset["pmEnd"]);
+		if (spanEl.classList.contains("layout-run-tab")) {
+			if (pmPos >= pmStart && pmPos < pmEnd) return spanEl.getBoundingClientRect().left;
+			continue;
+		}
+		if (pmPos >= pmStart && pmPos <= pmEnd && span.firstChild?.nodeType === Node.TEXT_NODE) {
+			const textNode = span.firstChild;
+			const charIndex = Math.min(pmPos - pmStart, textNode.length);
+			const ownerDoc = spanEl.ownerDocument;
+			if (!ownerDoc) continue;
+			const range = ownerDoc.createRange();
+			range.setStart(textNode, charIndex);
+			range.setEnd(textNode, charIndex);
+			return range.getBoundingClientRect().left;
+		}
+	}
+	const emptyRuns = container.querySelectorAll(".layout-empty-run");
+	for (const emptyRun of Array.from(emptyRuns)) {
+		const paragraph = emptyRun.closest(".layout-paragraph");
+		if (!paragraph) continue;
+		const pmStart = Number(paragraph.dataset["pmStart"]);
+		const pmEnd = Number(paragraph.dataset["pmEnd"]);
+		if (pmPos >= pmStart && pmPos <= pmEnd) return emptyRun.getBoundingClientRect().left;
+	}
+	return null;
+}
+/** @internal */
+function findLineElementAtPosition(container, pmPos) {
+	const allLines = container.querySelectorAll(CONTENT_LINE_SELECTOR);
+	for (const line of Array.from(allLines)) {
+		const lineEl = line;
+		const spans = lineEl.querySelectorAll("span[data-pm-start][data-pm-end]");
+		for (const span of Array.from(spans)) {
+			const s = span;
+			const start = Number(s.dataset["pmStart"]);
+			const end = Number(s.dataset["pmEnd"]);
+			if (pmPos >= start && pmPos <= end) return lineEl;
+		}
+	}
+	for (const line of Array.from(allLines)) {
+		const lineEl = line;
+		const paragraph = lineEl.closest(".layout-paragraph");
+		if (!paragraph) continue;
+		const pStart = Number(paragraph.dataset["pmStart"]);
+		const pEnd = Number(paragraph.dataset["pmEnd"]);
+		if (pmPos >= pStart && pmPos <= pEnd) {
+			if (paragraph.querySelector(".layout-line") === lineEl) return lineEl;
+		}
+	}
+	return null;
+}
+/** @internal */
+function findPositionOnLineAtClientX(lineEl, clientX) {
+	const spans = lineEl.querySelectorAll("span[data-pm-start][data-pm-end]");
+	if (spans.length === 0) {
+		const paragraph = lineEl.closest(".layout-paragraph");
+		if (paragraph?.dataset["pmStart"]) return Number(paragraph.dataset["pmStart"]) + 1;
+		return null;
+	}
+	for (const span of Array.from(spans)) {
+		const spanEl = span;
+		const rect = spanEl.getBoundingClientRect();
+		const pmStart = Number(spanEl.dataset["pmStart"]);
+		const pmEnd = Number(spanEl.dataset["pmEnd"]);
+		if (spanEl.classList.contains("layout-run-tab")) {
+			if (clientX >= rect.left && clientX <= rect.right) return clientX < (rect.left + rect.right) / 2 ? pmStart : pmEnd;
+			continue;
+		}
+		if (clientX >= rect.left && clientX <= rect.right) {
+			const textNode = spanEl.firstChild;
+			if (!textNode || textNode.nodeType !== Node.TEXT_NODE) return pmStart;
+			const text = textNode;
+			const ownerDoc = spanEl.ownerDocument;
+			if (!ownerDoc) return pmStart;
+			let lo = 0;
+			let hi = text.length;
+			while (lo < hi) {
+				const mid = Math.floor((lo + hi) / 2);
+				const r = ownerDoc.createRange();
+				r.setStart(text, mid);
+				r.setEnd(text, mid);
+				if (clientX < r.getBoundingClientRect().left) hi = mid;
+				else lo = mid + 1;
+			}
+			if (lo > 0 && lo <= text.length) {
+				const r = ownerDoc.createRange();
+				r.setStart(text, lo - 1);
+				r.setEnd(text, lo - 1);
+				const leftX = r.getBoundingClientRect().left;
+				r.setStart(text, Math.min(lo, text.length));
+				r.setEnd(text, Math.min(lo, text.length));
+				const rightX = r.getBoundingClientRect().left;
+				if (Math.abs(clientX - leftX) < Math.abs(clientX - rightX)) return pmStart + (lo - 1);
+			}
+			return pmStart + Math.min(lo, pmEnd - pmStart);
+		}
+	}
+	let closestSpan = null;
+	let closestDist = Infinity;
+	for (const span of Array.from(spans)) {
+		const spanEl = span;
+		const rect = spanEl.getBoundingClientRect();
+		const dist = clientX < rect.left ? rect.left - clientX : clientX - rect.right;
+		if (dist < closestDist) {
+			closestDist = dist;
+			closestSpan = spanEl;
+		}
+	}
+	if (!closestSpan) return null;
+	return clientX < closestSpan.getBoundingClientRect().left ? Number(closestSpan.dataset["pmStart"]) : Number(closestSpan.dataset["pmEnd"]);
+}
+/**
+* Handle PM ArrowUp / ArrowDown with visual-line awareness + sticky
+* X. Returns true if the event was handled and PM should not run
+* its default behaviour. Mutates `state` so consecutive presses
+* keep the same sticky X.
+*
+* @internal
+*/
+function handleVisualLineKeyDown(state, view, event, container) {
+	if (event.key !== "ArrowUp" && event.key !== "ArrowDown") {
+		if ([
+			"ArrowLeft",
+			"ArrowRight",
+			"Home",
+			"End"
+		].includes(event.key) || event.key.length === 1 && !event.ctrlKey && !event.metaKey) {
+			state.stickyX = null;
+			state.lastVisualLineIndex = -1;
+		}
+		return false;
+	}
+	if (event.ctrlKey || event.metaKey) {
+		state.stickyX = null;
+		state.lastVisualLineIndex = -1;
+		return false;
+	}
+	if (!container) return false;
+	const allLines = Array.from(container.querySelectorAll(CONTENT_LINE_SELECTOR));
+	if (allLines.length === 0) return false;
+	const { from, anchor } = view.state.selection;
+	if (state.stickyX === null) {
+		const clientX = getCaretClientX(container, from);
+		if (clientX === null) return false;
+		state.stickyX = clientX;
+	}
+	let currentIndex;
+	if (state.lastVisualLineIndex >= 0 && state.lastVisualLineIndex < allLines.length) currentIndex = state.lastVisualLineIndex;
+	else {
+		const currentLine = findLineElementAtPosition(container, from);
+		if (!currentLine) return false;
+		currentIndex = allLines.indexOf(currentLine);
+		if (currentIndex === -1) return false;
+	}
+	const targetIndex = event.key === "ArrowUp" ? currentIndex - 1 : currentIndex + 1;
+	if (targetIndex < 0 || targetIndex >= allLines.length) {
+		state.lastVisualLineIndex = -1;
+		return false;
+	}
+	const targetLine = allLines[targetIndex];
+	const newPos = findPositionOnLineAtClientX(targetLine, state.stickyX);
+	if (newPos === null) return false;
+	state.lastVisualLineIndex = targetIndex;
+	const { state: pmState, dispatch } = view;
+	const clampedPos = Math.max(0, Math.min(newPos, pmState.doc.content.size));
+	try {
+		const sel = event.shiftKey ? TextSelection.create(pmState.doc, anchor, clampedPos) : TextSelection.create(pmState.doc, clampedPos);
+		dispatch(pmState.tr.setSelection(sel));
+	} catch {
+		const $newPos = pmState.doc.resolve(clampedPos);
+		const sel = event.shiftKey ? TextSelection.between(pmState.doc.resolve(anchor), $newPos) : TextSelection.near($newPos);
+		dispatch(pmState.tr.setSelection(sel));
+	}
+	scrollIntoViewIfNeeded(targetLine);
+	return true;
+}
+//#endregion
+export { createVisualLineState, findLineElementAtPosition, findPositionOnLineAtClientX, getCaretClientX, handleVisualLineKeyDown };

package/dist/server.d.ts

@@ -1,5 +1,6 @@
 import { FolioAIBlock, FolioAIBlockAnchor, FolioAIBlockKind, FolioAIBlockPreviewRun, FolioAIComment, FolioAIEditApplyMode, FolioAIEditApplyResult, FolioAIEditOperation, FolioAIEditSnapshot } from "./ai-edits/types.js";
-import { ApplyFolioAIEditsToBufferOptions, ApplyFolioAIEditsToBufferResult, FolioApplyOperationsOptions, FolioDocxReviewer, FolioDocxReviewerOptions, FolioReviewChange, FolioReviewChangeFilter, FolioReviewChangeKind, FolioReviewComment, FolioReviewCommentFilter, FolioReviewCommentReply, FolioReviewReplyInput, applyFolioAIEditsToBuffer } from "./ai-edits/headless.js";
+import { FolioReviewChange, FolioReviewChangeKind } from "./ai-edits/read.js";
+import { ApplyFolioAIEditsToBufferOptions, ApplyFolioAIEditsToBufferResult, FolioApplyOperationsOptions, FolioDocxReviewer, FolioDocxReviewerOptions, FolioReviewChangeFilter, FolioReviewComment, FolioReviewCommentFilter, FolioReviewCommentReply, FolioReviewReplyInput, applyFolioAIEditsToBuffer } from "./ai-edits/headless.js";
 import { DeriveBlockIdInput, FolioBlockId, deriveBlockId, getFolioParaIdFromBlockId, isFolioBlockId, isSequentialFolioBlockId } from "./types/block-id.js";
 import { CreateCommentReplyInput, replyToComment } from "./docx/replyToComment.js";
 import { createDocx } from "./docx/rezip.js";

package/dist/style-engine/index.d.ts

@@ -1,3 +1,3 @@
-import { ResolvedParagraphStyle } from "../prosemirror/styles/styleResolver.js";
+import { ResolvedParagraphStyle, TableCellParagraphSpacingOverlay } from "../prosemirror/styles/styleResolver.js";
 import { StyleEngine, StyleEngineCacheStats, StyleEngineOptions, createStyleEngine } from "./styleEngine.js";
-export { type ResolvedParagraphStyle, type StyleEngine, type StyleEngineCacheStats, type StyleEngineOptions, createStyleEngine };
+export { type ResolvedParagraphStyle, type StyleEngine, type StyleEngineCacheStats, type StyleEngineOptions, type TableCellParagraphSpacingOverlay, createStyleEngine };

package/dist/style-engine/styleEngine.d.ts

@@ -1,5 +1,5 @@
 import { document_d_exports } from "../types/document.js";
-import { ResolvedParagraphStyle } from "../prosemirror/styles/styleResolver.js";
+import { ResolvedParagraphStyle, TableCellParagraphSpacingOverlay } from "../prosemirror/styles/styleResolver.js";
 
 //#region src/style-engine/styleEngine.d.ts
 /** Engine construction options. */
@@ -41,6 +41,19 @@ type StyleEngine = {
    * Returned object is cached and must not be mutated.
    */
   resolveParagraphStyle: (styleId: string | undefined | null) => ResolvedParagraphStyle;
+  /**
+   * Resolve the paragraph cascade for a paragraph inside a table cell,
+   * layering the enclosing table style's paragraph-spacing fields between
+   * docDefaults and the paragraph's own style chain — see
+   * {@link StyleResolver.resolveParagraphStyleInTable}.
+   *
+   * Pass the *same* `tableParagraphOverlay` object reference for every
+   * paragraph governed by the same table style region (folio's table
+   * conversion already computes it once per region) — the cache below keys
+   * on object identity, so a fresh object per call defeats memoization.
+   * Returned object is cached and must not be mutated.
+   */
+  resolveParagraphStyleInTable: (styleId: string | undefined | null, tableParagraphOverlay: TableCellParagraphSpacingOverlay | undefined) => ResolvedParagraphStyle;
   /**
    * Resolve a run/character style with docDefaults applied.
    * Returns `undefined` when the cascade yields nothing.