@stll/folio-core 0.32.2 → 0.33.1

package/dist/ai-edits/snapshot.js

@@ -1,7 +1,46 @@
-import { deriveBlockId } from "../types/block-id.js";
+import { deriveBlankBlockId, deriveBlockId } from "../types/block-id.js";
 import { buildCleanBlockText } from "./clean-text.js";
+import { TableMap } from "prosemirror-tables";
 //#region src/ai-edits/snapshot.ts
 const normalizeFolioAIBlockText = (text) => text.replace(/\s+/gu, " ").trim();
+/**
+* Whether a block carries text a reader would see.
+*
+* The snapshot holds every paragraph, blank ones included: an empty cell is
+* part of a table's shape, an empty row is a row, and a comparison that cannot
+* address them cannot describe what changed around them. A reading surface
+* wants the opposite — a model shown a document should see its content, not a
+* line per blank paragraph.
+*
+* So the two needs are split here rather than in the walk: the snapshot is
+* complete, and every surface that reads it for a person or a model states
+* that it wants content by calling this. One helper, so "what counts as
+* content" has a single answer; five inline emptiness checks would drift.
+*/
+const isFolioAIContentBlock = ({ text }) => normalizeFolioAIBlockText(text).length > 0;
+/**
+* The block that content appended to the end of a story hangs from: the last
+* paragraph at body level.
+*
+* Not simply the last block. A story's last block is often inside a table, and
+* a paragraph cannot be appended after one: the insertion escapes to the
+* table's boundary, where the block it was anchored to is not adjacent to it
+* and its paragraph mark ends a different container's paragraph. Neither
+* container-edge rule then applies and the addition cannot be rejected
+* cleanly.
+*
+* A body always ends with a paragraph — a table may not be the last child of a
+* body or a cell, so a package that ends in a table carries a trailing, often
+* empty, paragraph after it — so this is only `null` for a story with no
+* body-level paragraph at all, which is a malformed document.
+*/
+const trailingBodyBlockId = ({ blocks }) => {
+	for (let index = blocks.length - 1; index >= 0; index--) {
+		const block = blocks[index];
+		if (block !== void 0 && block.table === void 0) return block.id;
+	}
+	return null;
+};
 const hashFolioAIBlockText = (text) => {
 	let hash = 5381;
 	for (const character of text) hash = (hash * 33 + (character.codePointAt(0) ?? 0)) % 2147483647;
@@ -19,63 +58,102 @@ const createFolioAITextRangeHandle = ({ blockId, text, startOffset, endOffset })
 	};
 };
 const TABLE_ROW_NODE_NAME = "tableRow";
+const TABLE_ROLE_TABLE = "table";
+const TABLE_ROLE_ROW = "row";
 /**
-* True when `pos`'s nearest `tableRow` ancestor is marked `hidden` (OOXML
-* `w:trPr/w:hidden` — Word never renders the row). A textblock inside such a
-* row must not surface its text to the AI/agent snapshot: an attacker DOCX
-* could otherwise smuggle prompt-injection instructions into a row that no
-* human ever sees.
+* True for a `tableRow` marked `hidden` (OOXML `w:trPr/w:hidden` — Word never
+* renders the row). Nothing inside such a row may surface its text to the
+* AI/agent snapshot: an attacker DOCX could otherwise smuggle prompt-injection
+* instructions into a row that no human ever sees. The walk skips the row's
+* whole subtree, so a table nested inside a hidden row is hidden with it.
 */
-const isInHiddenTableRow = (doc, pos) => {
-	const $pos = doc.resolve(pos);
-	for (let depth = $pos.depth; depth > 0; depth--) {
-		const ancestor = $pos.node(depth);
-		if (ancestor.type.name === TABLE_ROW_NODE_NAME) return ancestor.attrs["hidden"] === true;
+const isHiddenTableRow = (node) => node.type.name === TABLE_ROW_NODE_NAME && node.attrs["hidden"] === true;
+/**
+* Locate the block inside its innermost enclosing table, or `undefined` when
+* it sits outside every table.
+*/
+const getTableLocation = ({ path, blockIndex, tableIndexByStart }) => {
+	for (let cellDepth = path.length - 1; cellDepth > 1; cellDepth--) {
+		const cell = path[cellDepth];
+		if (!cell) continue;
+		const role = cell.node.type.spec["tableRole"];
+		if (role !== "cell" && role !== "header_cell") continue;
+		const row = path[cellDepth - 1];
+		const table = path[cellDepth - 2];
+		if (!row || !table || row.node.type.spec["tableRole"] !== TABLE_ROLE_ROW || table.node.type.spec["tableRole"] !== TABLE_ROLE_TABLE) return;
+		const tableIndex = tableIndexByStart.get(table.start);
+		const outerTable = path.find((entry) => entry.node.type.spec["tableRole"] === TABLE_ROLE_TABLE);
+		const outerTableIndex = outerTable === void 0 ? void 0 : tableIndexByStart.get(outerTable.start);
+		if (tableIndex === void 0 || outerTableIndex === void 0) return;
+		const rectangle = TableMap.get(table.node).findCell(cell.start - table.start - 1);
+		return {
+			outerTableIndex,
+			tableIndex,
+			rowIndex: row.index,
+			cellIndex: cell.index,
+			gridColumnIndex: rectangle.left,
+			columnSpan: rectangle.right - rectangle.left,
+			rowSpan: rectangle.bottom - rectangle.top,
+			paragraphIndex: blockIndex
+		};
 	}
-	return false;
 };
 const createFolioAIEditSnapshot = (doc) => {
 	const draftBlocks = [];
 	const hashCounts = /* @__PURE__ */ new Map();
 	const usedBlockIds = /* @__PURE__ */ new Set();
-	const emptyAnchorState = {
-		candidate: null,
-		textblockCount: 0
-	};
+	const tableIndexByStart = /* @__PURE__ */ new Map();
+	const path = [];
 	let blockIndex = 0;
-	doc.descendants((node, pos, parent) => {
-		if (!node.isTextblock) return true;
-		if (isInHiddenTableRow(doc, pos)) return false;
-		const { text } = buildCleanBlockText(node, pos);
-		const normalizedText = normalizeFolioAIBlockText(text);
-		if (normalizedText.length === 0) {
-			if (parent?.type !== doc.type) return true;
-			emptyAnchorState.textblockCount++;
-			if (emptyAnchorState.candidate === null) {
-				const paraIdAttr = node.attrs["paraId"];
-				emptyAnchorState.candidate = {
-					from: pos,
-					to: pos + node.nodeSize,
-					paraId: typeof paraIdAttr === "string" && paraIdAttr.length > 0 ? paraIdAttr : null
-				};
-			}
+	let blankIndex = 0;
+	doc.descendants((node, pos, _parent, index) => {
+		while (pos >= (path.at(-1)?.end ?? Number.POSITIVE_INFINITY)) path.pop();
+		if (!node.isTextblock) {
+			if (isHiddenTableRow(node)) return false;
+			if (node.type.spec["tableRole"] === TABLE_ROLE_TABLE) tableIndexByStart.set(pos, tableIndexByStart.size);
+			if (!node.isLeaf) path.push({
+				node,
+				start: pos,
+				end: pos + node.nodeSize,
+				index
+			});
 			return true;
 		}
+		const { text } = buildCleanBlockText(node, pos);
+		const normalizedText = normalizeFolioAIBlockText(text);
 		const textHash = hashFolioAIBlockText(normalizedText);
 		hashCounts.set(textHash, (hashCounts.get(textHash) ?? 0) + 1);
-		blockIndex++;
 		const paraIdAttr = node.attrs["paraId"];
-		const id = deriveBlockId({
-			paraId: typeof paraIdAttr === "string" && paraIdAttr.length > 0 ? paraIdAttr : null,
-			index: blockIndex,
-			taken: usedBlockIds
-		});
+		const paraId = typeof paraIdAttr === "string" && paraIdAttr.length > 0 ? paraIdAttr : null;
+		const isBlank = normalizedText.length === 0;
+		let id;
+		if (isBlank) {
+			blankIndex++;
+			id = deriveBlankBlockId({
+				paraId,
+				index: blankIndex,
+				taken: usedBlockIds
+			});
+		} else {
+			blockIndex++;
+			id = deriveBlockId({
+				paraId,
+				index: blockIndex,
+				taken: usedBlockIds
+			});
+		}
 		usedBlockIds.add(id);
 		const headingLevel = getHeadingLevel(node);
 		const kind = getBlockKind(node, headingLevel);
 		const displayLabel = getDisplayLabel(node);
 		const styleId = getStyleId(node);
+		const listLevel = getListLevel(node);
 		const previewRuns = getPreviewRuns(node);
+		const table = getTableLocation({
+			path,
+			blockIndex: index,
+			tableIndexByStart
+		});
 		draftBlocks.push({
 			block: {
 				id,
@@ -84,7 +162,9 @@ const createFolioAIEditSnapshot = (doc) => {
 				...headingLevel !== void 0 && { headingLevel },
 				...displayLabel !== void 0 && { displayLabel },
 				...styleId !== void 0 && { styleId },
-				...previewRuns !== void 0 && { previewRuns }
+				...listLevel !== void 0 && { listLevel },
+				...previewRuns !== void 0 && { previewRuns },
+				...table !== void 0 && { table }
 			},
 			anchor: {
 				id,
@@ -106,30 +186,9 @@ const createFolioAIEditSnapshot = (doc) => {
 			hashOccurrenceCount: hashCounts.get(draft.anchor.textHash) ?? 0
 		};
 	}
-	const emptyAnchorCandidate = emptyAnchorState.candidate;
-	if (blocks.length > 0 || emptyAnchorCandidate === null) return {
-		blocks,
-		anchors
-	};
-	const emptyDocumentAnchorId = deriveBlockId({
-		paraId: emptyAnchorCandidate.paraId,
-		index: 1,
-		taken: usedBlockIds
-	});
-	const normalizedText = "";
-	anchors[emptyDocumentAnchorId] = {
-		id: emptyDocumentAnchorId,
-		from: emptyAnchorCandidate.from,
-		to: emptyAnchorCandidate.to,
-		text: "",
-		normalizedText,
-		textHash: hashFolioAIBlockText(normalizedText),
-		hashOccurrenceCount: emptyAnchorState.textblockCount
-	};
 	return {
 		blocks,
-		anchors,
-		emptyDocumentAnchorId
+		anchors
 	};
 };
 const getBlockKind = (node, headingLevel) => {
@@ -153,6 +212,12 @@ const getDisplayLabel = (node) => {
 	const styleId = node.attrs["styleId"];
 	if (typeof styleId === "string" && /^heading/iu.test(styleId)) return styleId;
 };
+const getListLevel = (node) => {
+	const numPr = node.attrs["numPr"];
+	if (typeof numPr !== "object" || numPr === null || !("ilvl" in numPr)) return;
+	const { ilvl } = numPr;
+	return typeof ilvl === "number" && Number.isInteger(ilvl) && ilvl >= 0 ? ilvl : void 0;
+};
 const getStyleId = (node) => {
 	const styleId = node.attrs["styleId"];
 	return typeof styleId === "string" && styleId.length > 0 ? styleId : void 0;
@@ -267,4 +332,4 @@ const getColorFromAttrs = (attrs) => {
 const samePreviewRunStyle = (run, style) => run.bold === style.bold && run.italic === style.italic && run.underline === style.underline && run.strike === style.strike && run.fontFamily === style.fontFamily && run.fontSizePt === style.fontSizePt && run.color === style.color;
 const isUnstyledPreviewRun = ({ bold, italic, underline, strike, fontFamily, fontSizePt, color }) => bold === void 0 && italic === void 0 && underline === void 0 && strike === void 0 && fontFamily === void 0 && fontSizePt === void 0 && color === void 0;
 //#endregion
-export { createFolioAIEditSnapshot, createFolioAITextRangeHandle, hashFolioAIBlockText, normalizeFolioAIBlockText };
+export { createFolioAIEditSnapshot, createFolioAITextRangeHandle, hashFolioAIBlockText, isFolioAIContentBlock, isHiddenTableRow, normalizeFolioAIBlockText, trailingBodyBlockId };

package/dist/ai-edits/table-row-column-mutations.d.ts

@@ -9,6 +9,17 @@ type TableRowInsertion = {
   rowType: Node["type"];
   cells: readonly Node[];
   rowspanUpdates: readonly number[];
+  /**
+   * The table's column count, which is not `cells.length`. One cell can occupy
+   * several columns (a `colspan`), and one column can have no cell in this row
+   * at all (a `rowspan` from a row above reaches down into it).
+   *
+   * It is what `cellTexts` is SIZED against — the most cells any row of this
+   * table could have — while the texts themselves fill the new row's cells in
+   * order. Sizing against `cells.length` refused a row the table can hold
+   * whenever a span made this row narrower than the table.
+   */
+  columnCount: number;
 };
 type TableRowDeletion = Omit<TableRowTarget, "table">;
 type TableColumnInsertion = {
@@ -74,5 +85,17 @@ type ApplyTableRowDeletionOptions = {
   revision: TableStructureRevision | null;
 };
 declare const applyTableRowDeletion: ({ tr, deletion, revision }: ApplyTableRowDeletionOptions) => TableRowColumnMutationResult;
+/**
+ * Split one cell's text into the paragraphs it describes, one string each.
+ *
+ * A cell holds paragraphs, not lines: a line break starts a new one, and a
+ * blank line is a blank paragraph, exactly as `text: ""` is for an insertion.
+ *
+ * This is deliberately not the prose rule `insertAfterBlock` follows, where a
+ * blank line between two model-written clauses is formatting noise and is
+ * dropped. A cell's text is read off a cell that HAS those paragraphs, so
+ * dropping one would lose a block that was there.
+ */
+declare const splitCellParagraphTexts: (text: string) => string[];
 //#endregion
-export { TableColumnDeletion, TableColumnInsertion, TableRowDeletion, TableRowInsertion, TableStructureRevision, applyTableColumnDeletion, applyTableColumnInsertion, applyTableRowDeletion, applyTableRowInsertion, findTableColumnInsertion, findTableRowInsertion, getTableColumnCoordinateKey };
+export { TableColumnDeletion, TableColumnInsertion, TableRowDeletion, TableRowInsertion, TableStructureRevision, applyTableColumnDeletion, applyTableColumnInsertion, applyTableRowDeletion, applyTableRowInsertion, findTableColumnInsertion, findTableRowInsertion, getTableColumnCoordinateKey, splitCellParagraphTexts };

package/dist/ai-edits/table-row-column-mutations.js

@@ -46,8 +46,74 @@ const applyTableRowInsertion = ({ tr, insertion, cellTexts, revision }) => {
 	const rowAttrs = revision ? { trIns: revision } : null;
 	const row = insertion.rowType.create(rowAttrs, insertion.cells);
 	tr.insert(insertion.rowPosition, populateTableRow(row, cellTexts));
+	if (revision) markTableRowContent({
+		tr,
+		rowPosition: insertion.rowPosition,
+		kind: "insertion",
+		revision
+	});
 	return applied(tr, revision);
 };
+/**
+* Mark the runs inside a row whose structural revision was just written.
+*
+* Word records a tracked row insertion or deletion twice: on the row
+* (`w:trPr/w:ins` | `w:trPr/w:del`) AND around every run in its cells
+* (`w:ins` | `w:del`, the latter with `w:delText`). A consumer that reads only
+* run-level revisions — which is most of them — keeps a deleted row's text on
+* accept and an inserted row's text on reject when the row marker stands
+* alone, so the two must always be written together.
+*
+* Two kinds of run stay unmarked. A run that already carries a revision keeps
+* it, because OOXML nests `w:ins`/`w:del` but the editable model holds one
+* wrapper per run and overwriting would drop the earlier revision. A cell that
+* spans into the row below survives the deletion — `removeRow` moves it down
+* and shortens its span — so marking its text would delete content the
+* accepted document must still hold.
+*/
+const markTableRowContent = ({ tr, rowPosition, kind, revision }) => {
+	const row = tr.doc.nodeAt(rowPosition);
+	const markType = tr.doc.type.schema.marks[kind];
+	if (!row || row.type.spec["tableRole"] !== "row" || !markType) return;
+	const mark = markType.create({
+		revisionId: revision.revisionId,
+		author: revision.author,
+		date: revision.date,
+		...revision.initials != null && { initials: revision.initials },
+		...revision.provenance != null && { provenance: revision.provenance },
+		...revision.suggestionId != null && { suggestionId: revision.suggestionId }
+	});
+	const contentFrom = rowPosition + 1;
+	const markable = [];
+	let wholeRowMarkable = true;
+	row.descendants((node, offset) => {
+		if (isRowSpanningCell(node)) {
+			wholeRowMarkable = false;
+			return false;
+		}
+		if (!node.isInline) return true;
+		if (node.marks.some(isTrackedChangeMark)) {
+			wholeRowMarkable = false;
+			return false;
+		}
+		const from = contentFrom + offset;
+		markable.push({
+			from,
+			to: from + node.nodeSize
+		});
+		return false;
+	});
+	if (wholeRowMarkable) {
+		tr.addMark(contentFrom, rowPosition + row.nodeSize - 1, mark);
+		return;
+	}
+	for (const range of markable) tr.addMark(range.from, range.to, mark);
+};
+const isTrackedChangeMark = (mark) => mark.type.name === "insertion" || mark.type.name === "deletion";
+const isRowSpanningCell = (node) => {
+	const role = node.type.spec["tableRole"];
+	return (role === "cell" || role === "header_cell") && Number(node.attrs["rowspan"]) > 1;
+};
 const applyTableColumnInsertion = ({ tr, insertion, cellTexts, revision }) => {
 	const tablePosition = tr.mapping.map(insertion.tablePosition, 1);
 	const table = tr.doc.nodeAt(tablePosition);
@@ -123,6 +189,12 @@ const applyTableRowDeletion = ({ tr, deletion, revision }) => {
 		const row = tr.doc.nodeAt(rowPosition);
 		if (!row || row.type.spec["tableRole"] !== "row" || row.attrs["trIns"] != null || row.attrs["trDel"] != null) return { type: "unsupported" };
 		tr.setNodeAttribute(rowPosition, "trDel", revision);
+		markTableRowContent({
+			tr,
+			rowPosition,
+			kind: "deletion",
+			revision
+		});
 		markStructuralChange(tr);
 		return applied(tr, revision);
 	}
@@ -194,22 +266,42 @@ const buildTableRowInsertion = ({ map, table, tableStart, rowIndex }) => {
 		rowPosition,
 		rowType: tableNodeTypes(table.type.schema).row,
 		cells,
-		rowspanUpdates
+		rowspanUpdates,
+		columnCount: map.width
 	};
 };
+const CELL_LINE_BREAK_PATTERN = /\r\n|\r|\n/;
+/**
+* Split one cell's text into the paragraphs it describes, one string each.
+*
+* A cell holds paragraphs, not lines: a line break starts a new one, and a
+* blank line is a blank paragraph, exactly as `text: ""` is for an insertion.
+*
+* This is deliberately not the prose rule `insertAfterBlock` follows, where a
+* blank line between two model-written clauses is formatting noise and is
+* dropped. A cell's text is read off a cell that HAS those paragraphs, so
+* dropping one would lose a block that was there.
+*/
+const splitCellParagraphTexts = (text) => text.split(CELL_LINE_BREAK_PATTERN);
+/**
+* Fill the new row's cells from `cellTexts`, in order: the nth text goes in
+* the nth cell the row actually has, which is how a caller reading the row
+* through the block snapshot counts them (`table.cellIndex`). Cells the caller
+* did not name stay empty.
+*/
 const populateTableRow = (row, cellTexts) => {
 	if (cellTexts === void 0) return row;
 	const cells = [];
 	row.forEach((cell, _offset, index) => {
+		const text = cellTexts[index] ?? "";
 		const paragraph = cell.firstChild;
 		if (!paragraph?.isTextblock) {
 			cells.push(cell);
 			return;
 		}
-		const text = cellTexts[index] ?? "";
-		const content = text.length > 0 ? row.type.schema.text(text) : null;
-		const nextParagraph = paragraph.type.create(stripBlockIdentityAttrs(paragraph.attrs), content);
-		cells.push(cell.type.create(cell.attrs, nextParagraph));
+		const attrs = stripBlockIdentityAttrs(paragraph.attrs);
+		const paragraphs = splitCellParagraphTexts(text).map((line) => paragraph.type.create(attrs, line.length > 0 ? row.type.schema.text(line) : null));
+		cells.push(cell.type.create(cell.attrs, paragraphs));
 	});
 	return row.type.create(row.attrs, cells);
 };
@@ -297,4 +389,4 @@ const getTableColumnDeletionCellPositions = ({ map, table, columnIndex }) => {
 	return [...positions];
 };
 //#endregion
-export { applyTableColumnDeletion, applyTableColumnInsertion, applyTableRowDeletion, applyTableRowInsertion, findTableColumnInsertion, findTableRowInsertion, getTableColumnCoordinateKey };
+export { applyTableColumnDeletion, applyTableColumnInsertion, applyTableRowDeletion, applyTableRowInsertion, findTableColumnInsertion, findTableRowInsertion, getTableColumnCoordinateKey, splitCellParagraphTexts };

package/dist/ai-edits/table-targets.d.ts

@@ -22,10 +22,19 @@ type TableCellTarget = {
   topRowIndex: number;
   bottomRowIndex: number;
 };
-/** Resolve the nearest enclosing table boundary for block-adjacent insertions. */
-declare const findEnclosingTableBoundary: (doc: Node, blockFrom: number) => TableBoundary | null;
+/**
+ * The boundary a block-adjacent insertion escapes to: the outermost table the
+ * anchor sits in, so the new block lands as a peer of that table at document
+ * level.
+ *
+ * The nearest table is the wrong answer once tables nest. Escaping one level
+ * out of a table inside a cell leaves the insertion in the enclosing cell,
+ * which is still "inside a table" and is never what a block-level insertion
+ * meant.
+ */
+declare const findOutermostTableBoundary: (doc: Node, blockFrom: number) => TableBoundary | null;
 declare const findEnclosingTableRow: (doc: Node, blockFrom: number) => TableRowTarget | null;
 declare const findEnclosingTableCell: (doc: Node, blockFrom: number) => TableCellTarget | null;
 declare const tableRectangleCutsMergedCell: (map: TableMap, rectangle: TableRectangle) => boolean;
 //#endregion
-export { TableBoundary, TableCellTarget, TableRowTarget, findEnclosingTableBoundary, findEnclosingTableCell, findEnclosingTableRow, tableRectangleCutsMergedCell };
+export { TableBoundary, TableCellTarget, TableRowTarget, findEnclosingTableCell, findEnclosingTableRow, findOutermostTableBoundary, tableRectangleCutsMergedCell };

package/dist/ai-edits/table-targets.js

@@ -1,13 +1,23 @@
 import { TableMap } from "prosemirror-tables";
 //#region src/ai-edits/table-targets.ts
-/** Resolve the nearest enclosing table boundary for block-adjacent insertions. */
-const findEnclosingTableBoundary = (doc, blockFrom) => {
+/**
+* The boundary a block-adjacent insertion escapes to: the outermost table the
+* anchor sits in, so the new block lands as a peer of that table at document
+* level.
+*
+* The nearest table is the wrong answer once tables nest. Escaping one level
+* out of a table inside a cell leaves the insertion in the enclosing cell,
+* which is still "inside a table" and is never what a block-level insertion
+* meant.
+*/
+const findOutermostTableBoundary = (doc, blockFrom) => {
 	const resolved = doc.resolve(blockFrom);
-	for (let depth = resolved.depth; depth > 0; depth--) if (resolved.node(depth).type.name === "table") return {
+	let boundary = null;
+	for (let depth = resolved.depth; depth > 0; depth--) if (resolved.node(depth).type.name === "table") boundary = {
 		before: resolved.before(depth),
 		after: resolved.after(depth)
 	};
-	return null;
+	return boundary;
 };
 const findEnclosingTableRow = (doc, blockFrom) => {
 	const resolved = doc.resolve(blockFrom);
@@ -67,4 +77,4 @@ const tableRectangleCutsMergedCell = (map, rectangle) => {
 	return false;
 };
 //#endregion
-export { findEnclosingTableBoundary, findEnclosingTableCell, findEnclosingTableRow, tableRectangleCutsMergedCell };
+export { findEnclosingTableCell, findEnclosingTableRow, findOutermostTableBoundary, tableRectangleCutsMergedCell };