@stll/folio-core 0.17.0 → 0.18.0

package/README.md

@@ -29,7 +29,8 @@ bun add @stll/folio-core
 | --------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
 | `@stll/folio-core`          | the headless public API — `createEmptyDocument`, `createDocx`, the document model, AI-suggestion primitives, ProseMirror plugins                                   |
 | `@stll/folio-core/markdown` | DOCX ↔ Markdown conversion                                                                                                                                         |
-| `@stll/folio-core/server`   | DOM-free helpers for server-side use (block-id derivation, document creation, re-zip)                                                                              |
+| `@stll/folio-core/server`   | DOM-free document review, explicit tracked edits, comparison, creation, and package helpers                                                                        |
+| `@stll/folio-core/redline`  | Compare two `.docx` buffers and generate a native Word redline                                                                                                     |
 | `@stll/folio-core/*`        | the source-mirrored module tree (e.g. `@stll/folio-core/types/document`, `@stll/folio-core/prosemirror/schema`) for adapters that need lower-level building blocks |
 
 ## New documents and reusable style sets
@@ -71,6 +72,28 @@ Extraction excludes document content, metadata, relationships, media, comments,
 and revision data. It keeps only the selected styles and the numbering, theme,
 font-table, and settings data required to reproduce their formatting.
 
+## Native Word redlines
+
+Generate a reviewable `.docx` whose text and supported inline-formatting
+differences are native tracked changes:
+
+```ts
+import { generateRedlineDocx } from "@stll/folio-core/redline";
+
+const result = await generateRedlineDocx(originalDocx, revisedDocx, {
+  author: "Reviewer",
+});
+
+await store(result.buffer);
+console.log(result.applied, result.skipped, result.unprocessedStories);
+```
+
+For deterministic operations against one document, use `FolioDocxReviewer`
+from `@stll/folio-core/server`. Its operations default to tracked changes and
+can be enumerated, accepted, or rejected before saving. `getChanges()` includes
+inline edits, formatting, paragraph marks, and paragraph, section, table, row,
+and cell property changes.
+
 ## License
 
 [Apache-2.0](./LICENSE)

package/dist/ai-edits/headless.d.ts

@@ -275,10 +275,7 @@ declare class FolioDocxReviewer {
   rejectChange(target: FolioReviewChange | number): boolean;
   /**
    * Accept every tracked change in the body. Returns the number of changes
-   * present before the sweep. Runs unconditionally: the underlying command also
-   * resolves paragraph-level changes (`w:pPrChange`, paragraph-boundary
-   * ins/del) that {@link getChanges} does not enumerate. Note-body changes are
-   * out of scope.
+   * present before the sweep. Note-body changes are out of scope.
    */
   acceptAll(): number;
   /** Reject every tracked change in the body. See {@link acceptAll}. */
@@ -307,15 +304,6 @@ declare class FolioDocxReviewer {
   private getHeaderFooterStoryText;
   private getNoteStoryText;
   private mergeEditedSecondaryStories;
-  /**
-   * Count every tracked change an accept-all / reject-all sweep resolves: the
-   * inline insertion / deletion groups {@link getChanges} enumerates, plus the
-   * property-change records living on node attrs rather than inline marks —
-   * paragraph-level (`pPrMark`, `_propertyChanges`, the inline sectPr's
-   * `propertyChanges`) and table-level (`tblPrChange` / `trPrChange` /
-   * `tcPrChange`).
-   */
-  private countTrackedChanges;
   /** Apply any {@link resolveComment} overrides recorded for these comments. */
   private withResolvedOverrides;
   /** Map each anchored comment id to its anchored text and containing block id. */

package/dist/ai-edits/headless.js

@@ -647,19 +647,16 @@ var FolioDocxReviewer = class FolioDocxReviewer {
 	}
 	/**
 	* Accept every tracked change in the body. Returns the number of changes
-	* present before the sweep. Runs unconditionally: the underlying command also
-	* resolves paragraph-level changes (`w:pPrChange`, paragraph-boundary
-	* ins/del) that {@link getChanges} does not enumerate. Note-body changes are
-	* out of scope.
+	* present before the sweep. Note-body changes are out of scope.
 	*/
 	acceptAll() {
-		const count = this.countTrackedChanges();
+		const count = this.getChanges().length;
 		this.runCommand(acceptAllChanges());
 		return count;
 	}
 	/** Reject every tracked change in the body. See {@link acceptAll}. */
 	rejectAll() {
-		const count = this.countTrackedChanges();
+		const count = this.getChanges().length;
 		this.runCommand(rejectAllChanges());
 		return count;
 	}
@@ -823,32 +820,6 @@ var FolioDocxReviewer = class FolioDocxReviewer {
 		if (footnotes) document.package.footnotes = footnotes;
 		if (endnotes) document.package.endnotes = endnotes;
 	}
-	/**
-	* Count every tracked change an accept-all / reject-all sweep resolves: the
-	* inline insertion / deletion groups {@link getChanges} enumerates, plus the
-	* property-change records living on node attrs rather than inline marks —
-	* paragraph-level (`pPrMark`, `_propertyChanges`, the inline sectPr's
-	* `propertyChanges`) and table-level (`tblPrChange` / `trPrChange` /
-	* `tcPrChange`).
-	*/
-	countTrackedChanges() {
-		const hasEntries = (value) => Array.isArray(value) && value.length > 0;
-		let count = this.getChanges().length;
-		this.state.doc.descendants((node) => {
-			const typeName = node.type.name;
-			if (typeName === "table" && hasEntries(node.attrs["tblPrChange"])) count += 1;
-			if (typeName === "tableRow" && hasEntries(node.attrs["trPrChange"])) count += 1;
-			if ((typeName === "tableCell" || typeName === "tableHeader") && hasEntries(node.attrs["tcPrChange"])) count += 1;
-			if (typeName !== "paragraph") return;
-			const pPrMark = node.attrs["pPrMark"];
-			if (pPrMark !== null && pPrMark !== void 0) count += 1;
-			if (hasEntries(node.attrs["_propertyChanges"])) count += 1;
-			const sectionProperties = node.attrs["_sectionProperties"];
-			if (hasEntries(sectionProperties?.propertyChanges)) count += 1;
-			return false;
-		});
-		return count;
-	}
 	/** Apply any {@link resolveComment} overrides recorded for these comments. */
 	withResolvedOverrides(comments) {
 		if (this.resolvedOverrides.size === 0) return [...comments];

package/dist/ai-edits/read.d.ts

@@ -1,6 +1,7 @@
+import { FolioNodeRevisionKind } from "../prosemirror/revisionCarriers.js";
 import { Node } from "prosemirror-model";
 //#region src/ai-edits/read.d.ts
-type FolioReviewChangeKind = "insertion" | "deletion" | "formatting" | "rowInserted" | "rowDeleted" | "cellInserted" | "cellDeleted" | "cellMerged";
+type FolioReviewChangeKind = "insertion" | "deletion" | "formatting" | "rowInserted" | "rowDeleted" | "cellInserted" | "cellDeleted" | "cellMerged" | FolioNodeRevisionKind;
 /** A tracked change discovered in the document body. */
 type FolioReviewChange = {
   /**

package/dist/ai-edits/read.js

@@ -1,4 +1,5 @@
 import { expectRunPropertyChangeMarkAttrs } from "../prosemirror/attrs/index.js";
+import { getFolioNodeRevisionCarriers } from "../prosemirror/revisionCarriers.js";
 import { getTableCellMergeChange } from "../prosemirror/tableCellMergeRevision.js";
 import { createFolioAIEditSnapshot } from "./snapshot.js";
 //#region src/ai-edits/read.ts
@@ -30,6 +31,24 @@ const getTrackedChangesFromDoc = (doc) => {
 	const structuralChangeCellPositions = /* @__PURE__ */ new Map();
 	let currentBlockId = null;
 	doc.descendants((node, pos) => {
+		const nodeRevisionCarriers = getFolioNodeRevisionCarriers(node, pos);
+		if (nodeRevisionCarriers.length > 0) {
+			const blockId = node.isTextblock ? blockStarts.get(pos) ?? null : firstBlockIdWithin({
+				node,
+				nodePos: pos,
+				blockStarts
+			});
+			nodeRevisionCarriers.forEach((carrier, carrierIndex) => {
+				grouped.set(`node:${String(pos)}:${carrier.type}:${String(carrier.id)}:${String(carrierIndex)}`, {
+					id: carrier.id,
+					type: carrier.type,
+					author: carrier.author,
+					date: carrier.date,
+					text: carrier.text,
+					blockId
+				});
+			});
+		}
 		if (node.type.name === "tableRow") for (const [attrName, kind] of [["trIns", "rowInserted"], ["trDel", "rowDeleted"]]) {
 			const marker = node.attrs[attrName];
 			if (typeof marker !== "object" || marker === null || !("revisionId" in marker) || typeof marker.revisionId !== "number") continue;

package/dist/docx/rezip.js

@@ -18,7 +18,8 @@ import { serializeStylesXml } from "./serializer/stylesSerializer.js";
 import { serializeThemeXml } from "./serializer/themeSerializer.js";
 import { escapeXml } from "./serializer/xmlUtils.js";
 import { isPreservableDocxEntry } from "./unzip.js";
-import { findChild, getChildElements, matchesName, parseXml } from "./xmlParser.js";
+import { findChild, getChildElements, getLocalName, getNamespaceUri, matchesName, parseXml } from "./xmlParser.js";
+import { assertXmlResourceLimits } from "./xmlResourceLimits.js";
 import { panic } from "better-result";
 import JSZip from "jszip";
 //#region src/docx/rezip.ts
@@ -69,7 +70,28 @@ function findMaxRId(relsXml) {
 	}
 	return maxId;
 }
-const countDocumentSections = (xml) => Array.from(xml.matchAll(/<w:sectPr\b/gu)).length;
+const WORDPROCESSINGML_NAMESPACES = /* @__PURE__ */ new Set(["http://schemas.openxmlformats.org/wordprocessingml/2006/main", "http://purl.oclc.org/ooxml/wordprocessingml/main"]);
+const isWordprocessingElement = (element, localName) => getLocalName(element.name) === localName && WORDPROCESSINGML_NAMESPACES.has(getNamespaceUri(element) ?? "");
+const countDocumentSections = (xml) => {
+	assertXmlResourceLimits(xml);
+	let count = 0;
+	const pending = [{
+		element: parseXml(xml),
+		insidePropertyChange: false
+	}];
+	while (pending.length > 0) {
+		const current = pending.pop();
+		if (!current) break;
+		const { element, insidePropertyChange } = current;
+		const isPropertyChange = isWordprocessingElement(element, "sectPrChange");
+		if (!insidePropertyChange && isWordprocessingElement(element, "sectPr")) count += 1;
+		for (const child of getChildElements(element)) pending.push({
+			element: child,
+			insidePropertyChange: insidePropertyChange || isPropertyChange
+		});
+	}
+	return count;
+};
 const extractHeaderFooterReferences = (xml) => {
 	const references = [];
 	for (const match of xml.matchAll(/<w:(?<element>headerReference|footerReference)\b[^>]*>/gu)) {

package/dist/docx/streamingXmlParser.js

@@ -1,3 +1,4 @@
+import { FOLIO_XML_RESOURCE_LIMITS } from "./xmlResourceLimits.js";
 //#region src/docx/streamingXmlParser.ts
 const BUILT_IN_ENTITIES = {
 	amp: "&",
@@ -59,7 +60,7 @@ const parseStreamingXml = (xml) => {
 		const parent = stack.at(-1)?.element ?? root;
 		appendElement(parent, parsedTag.element);
 		if (!parsedTag.selfClosing) {
-			if (stack.length >= 100) return { status: "unsupported" };
+			if (stack.length >= FOLIO_XML_RESOURCE_LIMITS.maxDepth) return { status: "unsupported" };
 			stack.push({
 				element: parsedTag.element,
 				name: parsedTag.name

package/dist/docx/unzip.js

@@ -1,5 +1,6 @@
 import { DOCX_CONTAINER_TYPES, detectDocxContainerType } from "./encryption/containerFormat.js";
 import { openDocxBuffer } from "./encryption/openEncryptedDocx.js";
+import { FOLIO_XML_RESOURCE_LIMITS } from "./xmlResourceLimits.js";
 import JSZip from "jszip";
 //#region src/docx/unzip.ts
 /**
@@ -53,7 +54,7 @@ const MEBIBYTE = 1024 * 1024;
 const DEFAULT_UNZIP_LIMITS = {
 	maxInputBytes: 50 * MEBIBYTE,
 	maxFiles: 5e3,
-	maxXmlBytes: 128 * MEBIBYTE,
+	maxXmlBytes: FOLIO_XML_RESOURCE_LIMITS.maxBytes,
 	maxMediaBytes: 25 * MEBIBYTE,
 	maxFontBytes: 10 * MEBIBYTE,
 	maxTotalUncompressedBytes: 250 * MEBIBYTE,

package/dist/docx/xmlResourceLimits.d.ts

@@ -0,0 +1,27 @@
+//#region src/docx/xmlResourceLimits.d.ts
+/** Shared bounds for XML parts parsed by Folio. */
+declare const FOLIO_XML_RESOURCE_LIMITS: {
+  readonly maxBytes: number;
+  readonly maxDepth: 100;
+  readonly maxNodes: 1000000;
+};
+type XmlResourceLimits = {
+  maxBytes: number;
+  maxDepth: number;
+  maxNodes: number;
+};
+type XmlResourceLimitKind = "bytes" | "depth" | "nodes" | "syntax";
+declare const XmlResourceLimitError_base: import("better-result").TaggedErrorClass<"XmlResourceLimitError", {
+  message: string;
+  limit: XmlResourceLimitKind;
+}>;
+/** XML input exceeded a parser resource bound or could not be scanned safely. */
+declare class XmlResourceLimitError extends XmlResourceLimitError_base {}
+/**
+ * Bound XML bytes, element count, and nesting before building an object tree.
+ * The lexical scan is iterative, so deeply nested input cannot consume the JS
+ * call stack before the depth limit is enforced.
+ */
+declare const assertXmlResourceLimits: (xml: string, limits?: XmlResourceLimits) => void;
+//#endregion
+export { FOLIO_XML_RESOURCE_LIMITS, XmlResourceLimitError, assertXmlResourceLimits };

package/dist/docx/xmlResourceLimits.js

@@ -0,0 +1,108 @@
+import { TaggedError } from "better-result";
+/** Shared bounds for XML parts parsed by Folio. */
+const FOLIO_XML_RESOURCE_LIMITS = {
+	maxBytes: 128 * (1024 * 1024),
+	maxDepth: 100,
+	maxNodes: 1e6
+};
+/** XML input exceeded a parser resource bound or could not be scanned safely. */
+var XmlResourceLimitError = class extends TaggedError("XmlResourceLimitError")() {};
+const exceedsUtf8ByteLimit = (value, maxBytes) => {
+	let bytes = 0;
+	for (let index = 0; index < value.length; index += 1) {
+		const codeUnit = value.charCodeAt(index);
+		if (codeUnit <= 127) bytes += 1;
+		else if (codeUnit <= 2047) bytes += 2;
+		else if (codeUnit >= 55296 && codeUnit <= 56319 && index + 1 < value.length && value.charCodeAt(index + 1) >= 56320 && value.charCodeAt(index + 1) <= 57343) {
+			bytes += 4;
+			index += 1;
+		} else bytes += 3;
+		if (bytes > maxBytes) return true;
+	}
+	return false;
+};
+const isXmlWhitespace = (code) => code === 9 || code === 10 || code === 13 || code === 32;
+const findTagClose = (xml, start) => {
+	let quote = 0;
+	for (let cursor = start; cursor < xml.length; cursor += 1) {
+		const code = xml.charCodeAt(cursor);
+		if (quote !== 0) {
+			if (code === quote) quote = 0;
+			continue;
+		}
+		if (code === 34 || code === 39) {
+			quote = code;
+			continue;
+		}
+		if (code === 62) return cursor;
+	}
+	return -1;
+};
+const throwSyntaxLimit = () => {
+	throw new XmlResourceLimitError({
+		message: "XML resource preflight could not safely scan malformed markup",
+		limit: "syntax"
+	});
+};
+/**
+* Bound XML bytes, element count, and nesting before building an object tree.
+* The lexical scan is iterative, so deeply nested input cannot consume the JS
+* call stack before the depth limit is enforced.
+*/
+const assertXmlResourceLimits = (xml, limits = FOLIO_XML_RESOURCE_LIMITS) => {
+	if (exceedsUtf8ByteLimit(xml, limits.maxBytes)) throw new XmlResourceLimitError({
+		message: `XML part exceeds ${String(limits.maxBytes)} bytes`,
+		limit: "bytes"
+	});
+	let cursor = 0;
+	let depth = 0;
+	let nodes = 0;
+	while (cursor < xml.length) {
+		const open = xml.indexOf("<", cursor);
+		if (open === -1) break;
+		if (xml.startsWith("<!--", open)) {
+			const close = xml.indexOf("-->", open + 4);
+			if (close === -1) throwSyntaxLimit();
+			cursor = close + 3;
+			continue;
+		}
+		if (xml.startsWith("<![CDATA[", open)) {
+			const close = xml.indexOf("]]>", open + 9);
+			if (close === -1) throwSyntaxLimit();
+			cursor = close + 3;
+			continue;
+		}
+		if (xml.startsWith("<?", open)) {
+			const close = xml.indexOf("?>", open + 2);
+			if (close === -1) throwSyntaxLimit();
+			cursor = close + 2;
+			continue;
+		}
+		if (xml.startsWith("<!", open)) throwSyntaxLimit();
+		const close = findTagClose(xml, open + 1);
+		if (close === -1) throwSyntaxLimit();
+		if (xml.charCodeAt(open + 1) === 47) {
+			if (depth === 0) throwSyntaxLimit();
+			depth -= 1;
+			cursor = close + 1;
+			continue;
+		}
+		nodes += 1;
+		if (nodes > limits.maxNodes) throw new XmlResourceLimitError({
+			message: `XML part contains more than ${String(limits.maxNodes)} elements`,
+			limit: "nodes"
+		});
+		let lastContent = close - 1;
+		while (lastContent > open && isXmlWhitespace(xml.charCodeAt(lastContent))) lastContent -= 1;
+		const elementDepth = depth + 1;
+		if (elementDepth > limits.maxDepth) throw new XmlResourceLimitError({
+			message: `XML part is nested deeper than ${String(limits.maxDepth)} elements`,
+			limit: "depth"
+		});
+		if (xml.charCodeAt(lastContent) !== 47) depth = elementDepth;
+		cursor = close + 1;
+	}
+	if (depth !== 0) throwSyntaxLimit();
+};
+//#endregion
+export { FOLIO_XML_RESOURCE_LIMITS, XmlResourceLimitError, assertXmlResourceLimits };

package/dist/layout-painter/renderParagraph.js

@@ -1074,10 +1074,11 @@ function renderLine(block, line, alignment, doc, options) {
 	if (alignment === "justify" && options) {
 		if (!options.isLastLine || options.paragraphEndsWithLineBreak) {
 			const firstLineIndentPx = options.isFirstLine ? options.firstLineIndentPx ?? 0 : 0;
+			const firstLinePositiveIndentPx = Math.max(0, firstLineIndentPx);
 			const firstLineHangingPx = Math.max(0, -firstLineIndentPx);
 			const hasVisibleListMarker = options.isFirstLine && block.attrs?.listMarker && !block.attrs.listMarkerHidden;
 			const firstLineHangingExpansionPx = hasVisibleListMarker ? Math.min(firstLineHangingPx, Math.max(0, options.leftIndentPx ?? 0)) : firstLineHangingPx;
-			const justifyCapacityPx = options.availableWidth + firstLineHangingExpansionPx;
+			const justifyCapacityPx = options.availableWidth - firstLinePositiveIndentPx + firstLineHangingExpansionPx;
 			const overfullPx = line.width - justifyCapacityPx;
 			const shrinkableSpaces = countShrinkableSpaces(runsForLine.filter((run) => !isTextRun(run) || !isCollapsedLineEdgeSpaceRun(run)), options.context);
 			if (overfullPx > RIGHT_EDGE_EPSILON_PX && shrinkableSpaces > 0) {

package/dist/prosemirror/commands/comments.d.ts

@@ -38,12 +38,10 @@ declare function acceptAllChanges(): Command;
  */
 declare function rejectAllChanges(): Command;
 /**
- * Find the document range covered by all inline revision marks
- * carrying any of the given AI-edit `revisionIds`. Returns null when
- * none of those marks are present (already accepted/rejected, or
- * never existed). A replace operation typically passes two ids (one
- * for its deletion side, one for its insertion side); inserts and
- * standalone deletions and formatting changes pass a single id.
+ * Find the document range covered by all revision carriers with any of the
+ * given ids. Returns null when none are present (already accepted/rejected, or
+ * never existed). A replace operation typically passes two ids; standalone
+ * text, formatting, paragraph, section, and table revisions pass a single id.
  */
 declare function findAIEditRevisionRange(state: EditorState, revisionIds: number | readonly number[]): {
   from: number;

package/dist/prosemirror/commands/comments.js

@@ -1,6 +1,7 @@
 import { expectRunPropertyChangeMarkAttrs } from "../attrs/index.js";
 import { textFormattingToMarks } from "../conversion/toProseDoc.js";
 import { markStructuralChange } from "../extensions/features/ParagraphChangeTrackerExtension.js";
+import { getFolioNodeRevisionCarriers } from "../revisionCarriers.js";
 import { RUN_FORMATTING_MARK_NAMES } from "../runFormattingMarkNames.js";
 import { getTableCellMergeChange } from "../tableCellMergeRevision.js";
 import { paragraphRejectAttrPatch, paragraphRejectOriginalFormatting, sectionRejectProperties, tableCellRejectAttrPatch, tableRejectAttrPatch, tableRowRejectAttrPatch } from "./propertyChangeScope.js";
@@ -454,12 +455,10 @@ function rejectAllChanges() {
 	return (state, dispatch) => rejectChange(0, state.doc.content.size)(state, dispatch);
 }
 /**
-* Find the document range covered by all inline revision marks
-* carrying any of the given AI-edit `revisionIds`. Returns null when
-* none of those marks are present (already accepted/rejected, or
-* never existed). A replace operation typically passes two ids (one
-* for its deletion side, one for its insertion side); inserts and
-* standalone deletions and formatting changes pass a single id.
+* Find the document range covered by all revision carriers with any of the
+* given ids. Returns null when none are present (already accepted/rejected, or
+* never existed). A replace operation typically passes two ids; standalone
+* text, formatting, paragraph, section, and table revisions pass a single id.
 */
 function findAIEditRevisionRange(state, revisionIds) {
 	const insertionType = state.schema.marks["insertion"];
@@ -470,14 +469,16 @@ function findAIEditRevisionRange(state, revisionIds) {
 		from: null,
 		to: null
 	};
+	const includeRange = (from, to) => {
+		if (range.from === null || from < range.from) range.from = from;
+		if (range.to === null || to > range.to) range.to = to;
+	};
 	state.doc.descendants((node, pos) => {
+		for (const carrier of getFolioNodeRevisionCarriers(node, pos)) if (idSet.has(carrier.id)) includeRange(carrier.from, carrier.to);
 		if (node.type.name === "tableRow") for (const attrName of ["trIns", "trDel"]) {
 			const marker = node.attrs[attrName];
 			if (isTableRowRevisionAttr(marker) && idSet.has(marker.revisionId)) {
-				const start = pos;
-				const end = pos + node.nodeSize;
-				if (range.from === null || start < range.from) range.from = start;
-				if (range.to === null || end > range.to) range.to = end;
+				includeRange(pos, pos + node.nodeSize);
 				return false;
 			}
 		}
@@ -490,27 +491,18 @@ function findAIEditRevisionRange(state, revisionIds) {
 				return change !== null && idSet.has(change.info.id);
 			});
 			if (hasDirectRevision || hasCollapsedRevision) {
-				const start = pos;
-				const end = pos + node.nodeSize;
-				if (range.from === null || start < range.from) range.from = start;
-				if (range.to === null || end > range.to) range.to = end;
+				includeRange(pos, pos + node.nodeSize);
 				return false;
 			}
 		}
 		if (!node.isInline) return;
 		for (const mark of node.marks) {
 			if (mark.type === runPropertyChangeType && expectRunPropertyChangeMarkAttrs(mark).changes.some((change) => idSet.has(change.info.id))) {
-				const start = pos;
-				const end = pos + node.nodeSize;
-				if (range.from === null || start < range.from) range.from = start;
-				if (range.to === null || end > range.to) range.to = end;
+				includeRange(pos, pos + node.nodeSize);
 				break;
 			}
 			if ((mark.type === insertionType || mark.type === deletionType) && typeof mark.attrs["revisionId"] === "number" && idSet.has(mark.attrs["revisionId"])) {
-				const start = pos;
-				const end = pos + node.nodeSize;
-				if (range.from === null || start < range.from) range.from = start;
-				if (range.to === null || end > range.to) range.to = end;
+				includeRange(pos, pos + node.nodeSize);
 				break;
 			}
 		}

package/dist/prosemirror/revisionCarriers.d.ts

@@ -0,0 +1,19 @@
+import { Node } from "prosemirror-model";
+//#region src/prosemirror/revisionCarriers.d.ts
+type FolioNodeRevisionKind = "paragraphMarkInserted" | "paragraphMarkDeleted" | "paragraphPropertiesChanged" | "sectionPropertiesChanged" | "tablePropertiesChanged" | "rowPropertiesChanged" | "cellPropertiesChanged";
+type FolioNodeRevisionCarrier = {
+  id: number;
+  type: FolioNodeRevisionKind;
+  author: string;
+  date: string | null;
+  text: string;
+  from: number;
+  to: number;
+};
+/**
+ * Read revision records stored on ProseMirror node attributes and return the
+ * exact range the shared accept/reject command requires for each carrier.
+ */
+declare const getFolioNodeRevisionCarriers: (node: Node, nodePos: number) => FolioNodeRevisionCarrier[];
+//#endregion
+export { FolioNodeRevisionCarrier, FolioNodeRevisionKind, getFolioNodeRevisionCarriers };

package/dist/prosemirror/revisionCarriers.js

@@ -0,0 +1,105 @@
+//#region src/prosemirror/revisionCarriers.ts
+const isObjectRecord = (value) => typeof value === "object" && value !== null;
+const revisionMetadata = (value) => {
+	if (!isObjectRecord(value) || typeof value["id"] !== "number") return null;
+	return {
+		id: value["id"],
+		author: typeof value["author"] === "string" ? value["author"] : "",
+		date: typeof value["date"] === "string" ? value["date"] : null
+	};
+};
+const appendPropertyCarriers = ({ carriers, changes, type, node, from, to }) => {
+	if (!Array.isArray(changes)) return;
+	let text = null;
+	for (const change of changes) {
+		if (!isObjectRecord(change)) continue;
+		const metadata = revisionMetadata(change["info"]);
+		if (!metadata) continue;
+		text ??= node.textContent;
+		carriers.push({
+			...metadata,
+			type,
+			text,
+			from,
+			to
+		});
+	}
+};
+/**
+* Read revision records stored on ProseMirror node attributes and return the
+* exact range the shared accept/reject command requires for each carrier.
+*/
+const getFolioNodeRevisionCarriers = (node, nodePos) => {
+	const carriers = [];
+	if (node.type.name === "paragraph") {
+		const from = nodePos + node.nodeSize - 1;
+		const to = nodePos + node.nodeSize;
+		const paragraphMark = node.attrs["pPrMark"];
+		if (isObjectRecord(paragraphMark) && (paragraphMark["kind"] === "ins" || paragraphMark["kind"] === "del")) {
+			const metadata = revisionMetadata(paragraphMark["info"]);
+			if (metadata) carriers.push({
+				...metadata,
+				type: paragraphMark["kind"] === "ins" ? "paragraphMarkInserted" : "paragraphMarkDeleted",
+				text: node.textContent,
+				from,
+				to
+			});
+		}
+		appendPropertyCarriers({
+			carriers,
+			changes: node.attrs["_propertyChanges"],
+			type: "paragraphPropertiesChanged",
+			node,
+			from,
+			to
+		});
+		const sectionProperties = node.attrs["_sectionProperties"];
+		appendPropertyCarriers({
+			carriers,
+			changes: isObjectRecord(sectionProperties) ? sectionProperties["propertyChanges"] : null,
+			type: "sectionPropertiesChanged",
+			node,
+			from,
+			to
+		});
+		return carriers;
+	}
+	const range = {
+		from: nodePos,
+		to: nodePos + node.nodeSize
+	};
+	switch (node.type.name) {
+		case "table":
+			appendPropertyCarriers({
+				carriers,
+				changes: node.attrs["tblPrChange"],
+				type: "tablePropertiesChanged",
+				node,
+				...range
+			});
+			break;
+		case "tableRow":
+			appendPropertyCarriers({
+				carriers,
+				changes: node.attrs["trPrChange"],
+				type: "rowPropertiesChanged",
+				node,
+				...range
+			});
+			break;
+		case "tableCell":
+		case "tableHeader":
+			appendPropertyCarriers({
+				carriers,
+				changes: node.attrs["tcPrChange"],
+				type: "cellPropertiesChanged",
+				node,
+				...range
+			});
+			break;
+		default: break;
+	}
+	return carriers;
+};
+//#endregion
+export { getFolioNodeRevisionCarriers };

package/dist/redline.d.ts

@@ -18,10 +18,15 @@ declare const InvalidGenerateRedlineDocxOptionsError_base: import("better-result
   option: "baseView" | "revisedView";
   receivedValue: unknown;
 }>;
+/** Raised when a resolved input view is not `"original"` or `"final"`. */
 declare class InvalidGenerateRedlineDocxOptionsError extends InvalidGenerateRedlineDocxOptionsError_base {}
+/** A document story that could not be paired across the two input packages. */
 type GenerateRedlineUnprocessedStory = {
+  /** Story in the base package, or `null` when it exists only in the revision. */
   baseStory: FolioDocumentStoryHandle | null;
+  /** Story in the revised package, or `null` when it exists only in the base. */
   revisedStory: FolioDocumentStoryHandle | null;
+  /** Why the story could not be represented in the generated redline. */
   reason: "missing-base-story" | "missing-revised-story";
 };
 /** Result of {@link generateRedlineDocx}. */

package/dist/redline.js

@@ -1,4 +1,5 @@
 import { FolioDocxReviewer, isFolioResolvedReviewedView } from "./ai-edits/headless.js";
+import { createFolioAITextRangeHandle } from "./ai-edits/snapshot.js";
 import "./document-operations.js";
 import { pairFolioDocumentStories } from "./document-stories.js";
 import { resolveFolioDocumentPrivacyTransforms, rewriteDocxMetadataPrivacy } from "./docx/metadataPrivacy.js";
@@ -7,13 +8,16 @@ import { TaggedError, panic } from "better-result";
 //#region src/redline.ts
 /**
 * Compare two `.docx` buffers and produce a third buffer whose text
-* differences are represented as tracked changes.
+* and supported inline-formatting differences are represented as tracked changes.
 *
 * Each matched editable story is processed independently through the shared
 * block alignment and document-operation paths. Package parts that exist on
 * only one side are reported because creating or removing those parts is a
 * distinct package-level operation.
+*
+* @packageDocumentation
 */
+/** Raised when a resolved input view is not `"original"` or `"final"`. */
 var InvalidGenerateRedlineDocxOptionsError = class extends TaggedError("InvalidGenerateRedlineDocxOptionsError")() {};
 const nextBaseBlockIdByIndex = (events) => {
 	const nextIds = Array.from({ length: events.length });
@@ -26,6 +30,86 @@ const nextBaseBlockIdByIndex = (events) => {
 	}
 	return nextIds;
 };
+const changedSupportedFormatting = (base, revised) => ({
+	...Boolean(base.bold) !== Boolean(revised.bold) && { bold: Boolean(revised.bold) },
+	...Boolean(base.italic) !== Boolean(revised.italic) && { italic: Boolean(revised.italic) },
+	...Boolean(base.underline) !== Boolean(revised.underline) && { underline: Boolean(revised.underline) }
+});
+const sameInlineFormatting = (left, right) => left.bold === right.bold && left.italic === right.italic && left.underline === right.underline;
+const hasInlineFormatting = (formatting) => formatting.bold !== void 0 || formatting.italic !== void 0 || formatting.underline !== void 0;
+const previewRunsForBlock = (block) => {
+	const runs = block.previewRuns ?? [{ text: block.text }];
+	return runs.map(({ text }) => text).join("") === block.text ? runs : null;
+};
+const formattingSegments = (baseBlock, revisedBlock) => {
+	const baseRuns = previewRunsForBlock(baseBlock);
+	const revisedRuns = previewRunsForBlock(revisedBlock);
+	if (!baseRuns || !revisedRuns || baseBlock.text.length === 0) return [];
+	const segments = [];
+	let baseRunIndex = 0;
+	let revisedRunIndex = 0;
+	let baseRunOffset = 0;
+	let revisedRunOffset = 0;
+	let textOffset = 0;
+	while (baseRunIndex < baseRuns.length && revisedRunIndex < revisedRuns.length) {
+		const baseRun = baseRuns[baseRunIndex];
+		const revisedRun = revisedRuns[revisedRunIndex];
+		if (!baseRun || !revisedRun) break;
+		const length = Math.min(baseRun.text.length - baseRunOffset, revisedRun.text.length - revisedRunOffset);
+		if (length <= 0) {
+			if (baseRunOffset >= baseRun.text.length) {
+				baseRunIndex++;
+				baseRunOffset = 0;
+			}
+			if (revisedRunOffset >= revisedRun.text.length) {
+				revisedRunIndex++;
+				revisedRunOffset = 0;
+			}
+			continue;
+		}
+		const formatting = changedSupportedFormatting(baseRun, revisedRun);
+		if (hasInlineFormatting(formatting)) {
+			const previous = segments.at(-1);
+			if (previous && previous.endOffset === textOffset && sameInlineFormatting(previous.formatting, formatting)) previous.endOffset += length;
+			else segments.push({
+				startOffset: textOffset,
+				endOffset: textOffset + length,
+				formatting
+			});
+		}
+		textOffset += length;
+		baseRunOffset += length;
+		revisedRunOffset += length;
+		if (baseRunOffset >= baseRun.text.length) {
+			baseRunIndex++;
+			baseRunOffset = 0;
+		}
+		if (revisedRunOffset >= revisedRun.text.length) {
+			revisedRunIndex++;
+			revisedRunOffset = 0;
+		}
+	}
+	return segments;
+};
+const buildFormattingRedlineOperations = ({ baseBlock, revisedBlock, nextOperationId }) => {
+	const operations = [];
+	for (const { startOffset, endOffset, formatting } of formattingSegments(baseBlock, revisedBlock)) {
+		const range = createFolioAITextRangeHandle({
+			blockId: baseBlock.id,
+			text: baseBlock.text,
+			startOffset,
+			endOffset
+		});
+		if (!range) panic("An aligned formatting range could not be represented");
+		operations.push({
+			id: nextOperationId(),
+			type: "formatRange",
+			range,
+			formatting
+		});
+	}
+	return operations;
+};
 const buildRedlineOperations = ({ baseSnapshot, revisedBlocks, nextOperationId }) => {
 	const events = alignFolioBlocks(baseSnapshot.blocks, revisedBlocks);
 	const anchorIds = nextBaseBlockIdByIndex(events);
@@ -40,6 +124,11 @@ const buildRedlineOperations = ({ baseSnapshot, revisedBlocks, nextOperationId }
 				blockId: event.baseBlock.id,
 				text: event.revisedBlock.text
 			});
+			else operations.push(...buildFormattingRedlineOperations({
+				baseBlock: event.baseBlock,
+				revisedBlock: event.revisedBlock,
+				nextOperationId
+			}));
 			return;
 		}
 		if (event.type === "baseOnly") {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@stll/folio-core",
-  "version": "0.17.0",
+  "version": "0.18.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",
@@ -9,6 +9,8 @@
     "ooxml",
     "pagination",
     "prosemirror",
+    "redline",
+    "tracked-changes",
     "word"
   ],
   "homepage": "https://github.com/stella/folio",
@@ -37,6 +39,10 @@
       "types": "./dist/server.d.ts",
       "import": "./dist/server.js"
     },
+    "./redline": {
+      "types": "./dist/redline.d.ts",
+      "import": "./dist/redline.js"
+    },
     "./ai-edits": {
       "types": "./dist/ai-edits/index.d.ts",
       "import": "./dist/ai-edits/index.js"
@@ -107,7 +113,7 @@
     "perf": "bun scripts/profile-editor.ts"
   },
   "dependencies": {
-    "@stll/docx-core": "^0.13.0",
+    "@stll/docx-core": "^0.14.0",
     "@stll/docx-utils": "^0.1.0",
     "@stll/template-conditions": "^0.1.0",
     "better-result": "2.10.0",