@stll/folio-core 0.51.0 → 0.53.0

package/dist/redline.js

@@ -1,4 +1,4 @@
-import { FolioDocxReviewer, isFolioResolvedReviewedView } from "./ai-edits/headless.js";
+import { FolioDocxReviewer, getFolioDocxComparisonAccess, isFolioResolvedReviewedView } from "./ai-edits/headless.js";
 import { createFolioAITextRangeHandle, trailingBodyBlockId } from "./ai-edits/snapshot.js";
 import { createScopedWordDiffOptions } from "./ai-edits/word-diff.js";
 import { FolioContentInlinePresentationProjectionError } from "./compare/content.js";
@@ -77,6 +77,7 @@ const buildRedlineOperations = ({ baseSnapshot, revisedBlocks, nextOperationId }
 	const operations = [];
 	const trailingAdditions = [];
 	const lastBaseBlockId = trailingBodyBlockId(baseSnapshot);
+	const baseBlocksById = new Map(baseSnapshot.blocks.map((block) => [block.id, block]));
 	events.forEach((event, eventIndex) => {
 		if (event.type === "pair") {
 			if (event.baseBlock.text !== event.revisedBlock.text) operations.push({
@@ -102,10 +103,7 @@ const buildRedlineOperations = ({ baseSnapshot, revisedBlocks, nextOperationId }
 		}
 		const anchorId = anchorIds[eventIndex] ?? null;
 		if (anchorId === null) {
-			trailingAdditions.push({
-				text: event.block.text,
-				...event.block.styleId !== void 0 && { styleId: event.block.styleId }
-			});
+			trailingAdditions.push(event.block);
 			return;
 		}
 		operations.push({
@@ -113,7 +111,7 @@ const buildRedlineOperations = ({ baseSnapshot, revisedBlocks, nextOperationId }
 			type: "insertBeforeBlock",
 			blockId: anchorId,
 			text: event.block.text,
-			...event.block.styleId !== void 0 && { styleId: event.block.styleId }
+			...insertedParagraphProperties(event.block, baseBlocksById.get(anchorId))
 		});
 	});
 	for (const addition of trailingAdditions) operations.push({
@@ -121,10 +119,85 @@ const buildRedlineOperations = ({ baseSnapshot, revisedBlocks, nextOperationId }
 		type: "insertAfterBlock",
 		blockId: lastBaseBlockId ?? "redline-unanchored",
 		text: addition.text,
-		...addition.styleId !== void 0 && { styleId: addition.styleId }
+		...insertedParagraphProperties(addition, lastBaseBlockId === null ? void 0 : baseBlocksById.get(lastBaseBlockId))
 	});
 	return operations;
 };
+/**
+* The revised value, or `null` to clear one the anchor would pass on, or
+* `undefined` when neither has one: an explicit `null` costs a restyle pass.
+*/
+const statedOrCleared = (revised, anchor) => revised ?? (anchor === void 0 ? void 0 : null);
+/**
+* The paragraph properties an inserted block states. An insertion that says
+* nothing takes the properties of its anchor, which is whichever base block
+* happens to follow it, so whatever the anchor states and the revised block
+* does not is cleared: a list item keeps its numbering, and a plain paragraph
+* beside a list item stays plain.
+*/
+const insertedParagraphProperties = (block, anchor) => {
+	const properties = {};
+	const styleId = statedOrCleared(block.styleId, anchor?.styleId);
+	if (styleId !== void 0) properties.styleId = styleId;
+	const alignment = statedOrCleared(block.directAlignment, anchor?.directAlignment);
+	if (alignment !== void 0) properties.alignment = alignment;
+	const spacing = statedOrCleared(block.directSpacing, anchor?.directSpacing);
+	if (spacing !== void 0) properties.spacing = spacing;
+	const indentation = statedOrCleared(block.directIndentation, anchor?.directIndentation);
+	if (indentation !== void 0) properties.indentation = indentation;
+	if (block.listReference !== void 0 || anchor?.listReference !== void 0 || anchor?.listLevel !== void 0) {
+		properties.numbering = block.listReference ?? null;
+		properties.listLevel = block.listLevel ?? null;
+	} else if (block.listLevel !== void 0) properties.listLevel = block.listLevel;
+	return properties;
+};
+const insertedNumbering = (operation) => {
+	if (operation.type !== "insertBeforeBlock" && operation.type !== "insertAfterBlock") return null;
+	const numbering = operation.numbering;
+	return numbering && !("start" in numbering) ? numbering : null;
+};
+/** The `w:numId`s whose `w:num` and abstract definition both exist. */
+const definedNumIds = (numbering) => {
+	const abstractIds = new Set(numbering?.abstractNums.map((entry) => entry.abstractNumId));
+	return new Set((numbering?.nums ?? []).filter((entry) => abstractIds.has(entry.abstractNumId)).map((entry) => entry.numId));
+};
+/**
+* Rebind every inserted list item to numbering the redline package defines.
+* The redline is the base package, where the revised version's `w:numId` may
+* name nothing, or another list: the referenced definitions are copied in,
+* under a fresh id wherever the base uses that one for different numbering.
+* A reference the revised package cannot resolve shows no number there
+* either, and is inserted without one.
+*/
+const bindInsertedNumbering = (baseReviewer, revisedReviewer, operationsByStory) => {
+	const baseAccess = getFolioDocxComparisonAccess(baseReviewer);
+	const revisedNumbering = getFolioDocxComparisonAccess(revisedReviewer).numberingDefinitions();
+	const resolvable = definedNumIds(revisedNumbering);
+	const references = operationsByStory.flatMap((operations) => operations.flatMap((operation) => {
+		const numbering = insertedNumbering(operation);
+		return numbering && resolvable.has(numbering.numId) ? [numbering] : [];
+	}));
+	const remapped = baseAccess.planTargetNumberingReferences(revisedNumbering, references) ?? panic("Resolvable revised numbering references could not be planned");
+	baseAccess.stageTargetNumbering(revisedNumbering, references, remapped);
+	const defined = definedNumIds(baseAccess.numberingDefinitions());
+	return operationsByStory.map((operations) => operations.map((operation) => {
+		const numbering = insertedNumbering(operation);
+		if (numbering === null) return operation;
+		const numId = remapped.get(numbering.numId) ?? numbering.numId;
+		if (!resolvable.has(numbering.numId) || !defined.has(numId)) return {
+			...operation,
+			numbering: null,
+			listLevel: null
+		};
+		return {
+			...operation,
+			numbering: {
+				numId,
+				level: numbering.level
+			}
+		};
+	}));
+};
 const resolveInputView = (value, option) => {
 	if (value === void 0) return "final";
 	if (!isFolioResolvedReviewedView(value)) throw new InvalidGenerateRedlineDocxOptionsError({
@@ -155,6 +228,7 @@ const generateRedlineDocx = async (base, revised, options = {}) => {
 		if (operationSequence >= 1e4) throw new GenerateRedlineDocxOperationLimitError({ message: "The document comparison exceeds the generated operation limit." });
 		return `redline-${++operationSequence}`;
 	};
+	const plannedStories = [];
 	for (const pair of pairFolioDocumentStories(baseStories, revisedStories)) {
 		if (!pair.baseStory) {
 			unprocessedStories.push({
@@ -182,15 +256,25 @@ const generateRedlineDocx = async (base, revised, options = {}) => {
 			nextOperationId
 		});
 		if (operations.length === 0) continue;
-		const result = baseReviewer.applyDocumentOperationsToStory({
+		plannedStories.push({
 			story: pair.baseStory,
 			snapshot: baseSnapshot,
+			operations
+		});
+	}
+	const boundOperations = bindInsertedNumbering(baseReviewer, revisedReviewer, plannedStories.map(({ operations }) => operations));
+	for (const [index, { story, snapshot }] of plannedStories.entries()) {
+		const operations = boundOperations[index] ?? panic("A planned story lost its operations");
+		const result = baseReviewer.applyDocumentOperationsToStory({
+			story,
+			snapshot,
 			batch: {
 				version: 1,
 				mode: "tracked-changes",
 				operations
 			},
-			wordDiff
+			wordDiff,
+			undefinedStyles: "keep"
 		});
 		applied.push(...result.applied);
 		skipped.push(...result.skipped);

package/dist/render-dom/BodySelectionOverlay.d.ts

@@ -1,3 +1,4 @@
+import { DisplayMode } from "../managers/EditorModeManager.js";
 import { EditorState } from "prosemirror-state";
 //#region src/render-dom/BodySelectionOverlay.d.ts
 type BodySelectionOverlayResult = {
@@ -10,6 +11,8 @@ type BodySelectionOverlayResult = {
 type SyncBodySelectionOverlayOptions = {
   pagesContainer: HTMLElement;
   state: EditorState;
+  /** The review view the pages were laid out for; a caret in text it hides paints at its edge. */
+  markupView: DisplayMode;
   zoom: number;
   zIndex?: number;
   caretColor?: string;
@@ -17,7 +20,7 @@ type SyncBodySelectionOverlayOptions = {
 };
 declare class BodySelectionOverlay {
   clear(pagesContainer: HTMLElement): void;
-  sync({ pagesContainer, state, zoom, zIndex, caretColor, selectionColor }: SyncBodySelectionOverlayOptions): BodySelectionOverlayResult;
+  sync({ pagesContainer, state, markupView, zoom, zIndex, caretColor, selectionColor }: SyncBodySelectionOverlayOptions): BodySelectionOverlayResult;
 }
 //#endregion
 export { BodySelectionOverlay, BodySelectionOverlayResult, SyncBodySelectionOverlayOptions };

package/dist/render-dom/BodySelectionOverlay.js

@@ -2,6 +2,7 @@ import { applyCellSelectionHighlight } from "../layout-bridge/cellSelectionHighl
 import { getCaretPositionFromDom, getSelectionRectsFromDom } from "../layout-bridge/dom/clickToPositionDom.js";
 import { findBodyPmAnchor } from "../layout-bridge/dom/findBodyPmSpans.js";
 import { findImageElement } from "../layout-painter/imageLayout.js";
+import { projectMarkupView, visibleCaretPosition } from "../prosemirror/markupViewProjection.js";
 import { NodeSelection } from "prosemirror-state";
 //#region src/render-dom/BodySelectionOverlay.ts
 /**
@@ -23,7 +24,7 @@ var BodySelectionOverlay = class {
 	clear(pagesContainer) {
 		for (const element of pagesContainer.querySelectorAll(OWNED_OVERLAY_SELECTOR)) element.remove();
 	}
-	sync({ pagesContainer, state, zoom, zIndex = 10, caretColor = "var(--doc-caret, #000)", selectionColor = "var(--doc-selection, rgba(66, 133, 244, 0.3))" }) {
+	sync({ pagesContainer, state, markupView, zoom, zIndex = 10, caretColor = "var(--doc-caret, #000)", selectionColor = "var(--doc-selection, rgba(66, 133, 244, 0.3))" }) {
 		this.clear(pagesContainer);
 		applyCellSelectionHighlight(pagesContainer, state);
 		const { selection } = state;
@@ -37,7 +38,7 @@ var BodySelectionOverlay = class {
 			};
 		}
 		if (selection.empty) {
-			const caret = getCaretPositionFromDom(pagesContainer, selection.from, pagesContainer.getBoundingClientRect());
+			const caret = getCaretPositionFromDom(pagesContainer, visibleCaretPosition(projectMarkupView(state, markupView), selection.from), pagesContainer.getBoundingClientRect());
 			if (!caret) return { type: "text" };
 			const element = pagesContainer.ownerDocument.createElement("div");
 			element.className = CARET_CLASS;

package/dist/shaping/shaper.d.ts

@@ -14,6 +14,9 @@
  * the Unicode data that engine needs, and a document in Latin, Cyrillic or
  * Greek needs none of it: `getShaper` is called only once a run in a shaping
  * script is about to be measured or painted, and never before.
+ *
+ * The same artifact resolves the bidirectional algorithm, because splitting a
+ * line into runs that each read one way is what shaping needs first.
  */
 /** Which way a run advances. Resolved by the producer, never guessed here. */
 declare const SHAPING_DIRECTION: {
@@ -57,22 +60,62 @@ type ShapedRun = {
   /** Design units per em, so a caller scales without re-reading the face. */
   readonly unitsPerEm: number;
 };
+/** The paragraph direction of a line whose bidirectional levels are resolved. */
+declare const BIDI_DIRECTION: {
+  readonly leftToRight: "ltr";
+  readonly rightToLeft: "rtl";
+  /** Rules P2 and P3: the first strong character outside an isolate decides. */
+  readonly auto: "auto";
+};
+type BidiDirection = (typeof BIDI_DIRECTION)[keyof typeof BIDI_DIRECTION];
+type ResolveBidiRequest = {
+  /** One paragraph laid out as one line; a paragraph separator does not split it. */
+  readonly text: string;
+  readonly direction: BidiDirection;
+};
+/**
+ * One line after the Unicode Bidirectional Algorithm (UAX #9), rules P2
+ * through L2. Indices count code points, not UTF-16 units.
+ */
+type BidiLine = {
+  /** 0 when the paragraph reads left to right, 1 when right to left. */
+  readonly paragraphLevel: number;
+  /**
+   * Embedding level per code point, after rule L1; odd levels read right to
+   * left. Characters rule X9 removes (explicit formatting characters such as
+   * isolates) carry a level but draw nothing.
+   */
+  readonly levels: readonly number[];
+  /** Code-point indices in visual order, left to right (rule L2). */
+  readonly visualOrder: readonly number[];
+};
 type Shaper = {
   readonly shapeRun: (request: ShapeRunRequest) => ShapedRun;
+  readonly resolveBidi: (request: ResolveBidiRequest) => BidiLine;
 };
 declare const ShaperError_base: import("better-result").TaggedErrorClass<"ShaperError">;
 declare class ShaperError extends ShaperError_base<{
   message: string;
   cause?: unknown;
 }> {}
+/**
+ * Where the artifact comes from when the caller already holds it: a runtime
+ * that cannot fetch its own package files (a single-file executable, an
+ * embedded asset) hands over the WebAssembly bytes instead.
+ */
+type ShaperSource = {
+  readonly wasm: Uint8Array | ArrayBuffer;
+};
 /**
  * Loads the shaper, once, and hands back the single implementation both the
  * measurer and the PDF backend use.
  *
- * Calling this is what fetches the artifact, so a caller asks for it only after
- * establishing that some run actually needs shaping.
+ * Calling this without a source is what fetches the artifact, so a caller asks
+ * for it only after establishing that some run actually needs shaping. With a
+ * source, the bytes given are instantiated and nothing is fetched. Either way
+ * the first successful load is the one every later call shares.
  */
-declare const getShaper: () => Promise<Shaper>;
+declare const getShaper: (source?: ShaperSource) => Promise<Shaper>;
 /**
  * Whether the artifact has been loaded in this process.
  *
@@ -89,4 +132,4 @@ declare const shaperLoaded: () => boolean;
  */
 declare const resolvedShaper: () => Shaper | null;
 //#endregion
-export { SHAPING_DIRECTION, ShapeRunRequest, ShapedGlyph, ShapedRun, Shaper, ShaperError, ShapingDirection, getShaper, resolvedShaper, shaperLoaded };
+export { BIDI_DIRECTION, BidiDirection, BidiLine, ResolveBidiRequest, SHAPING_DIRECTION, ShapeRunRequest, ShapedGlyph, ShapedRun, Shaper, ShaperError, ShaperSource, ShapingDirection, getShaper, resolvedShaper, shaperLoaded };

package/dist/shaping/shaper.js

@@ -1,4 +1,4 @@
-import __wbg_init, { shapeRun } from "../generated/text_shaper.js";
+import __wbg_init, { resolveBidi, shapeRun } from "../generated/text_shaper.js";
 import { TaggedError } from "better-result";
 //#region src/shaping/shaper.ts
 /**
@@ -16,12 +16,22 @@ import { TaggedError } from "better-result";
 * the Unicode data that engine needs, and a document in Latin, Cyrillic or
 * Greek needs none of it: `getShaper` is called only once a run in a shaping
 * script is about to be measured or painted, and never before.
+*
+* The same artifact resolves the bidirectional algorithm, because splitting a
+* line into runs that each read one way is what shaping needs first.
 */
 /** Which way a run advances. Resolved by the producer, never guessed here. */
 const SHAPING_DIRECTION = {
 	leftToRight: "ltr",
 	rightToLeft: "rtl"
 };
+/** The paragraph direction of a line whose bidirectional levels are resolved. */
+const BIDI_DIRECTION = {
+	leftToRight: "ltr",
+	rightToLeft: "rtl",
+	/** Rules P2 and P3: the first strong character outside an isolate decides. */
+	auto: "auto"
+};
 var ShaperError = class extends TaggedError("ShaperError") {};
 /**
 * The flat buffer the WebAssembly entry returns:
@@ -51,26 +61,47 @@ const decode = (buffer) => {
 		unitsPerEm
 	};
 };
-const shaper = { shapeRun: ({ font, faceIndex = 0, text, direction, script = "", language = "", featuresOn = [], featuresOff = [] }) => {
-	try {
-		return decode(shapeRun(font, faceIndex, text, direction === SHAPING_DIRECTION.rightToLeft, script, language, [...featuresOn], [...featuresOff]));
-	} catch (cause) {
-		throw new ShaperError({
-			message: "Could not shape a run of text",
-			cause
-		});
+/** `[paragraphLevel, count, level * count, visualIndex * count]`. */
+const decodeBidi = (buffer) => {
+	const count = buffer[1] ?? 0;
+	const levelsAt = HEADER_FIELDS;
+	const orderAt = HEADER_FIELDS + count;
+	return {
+		paragraphLevel: buffer[0] ?? 0,
+		levels: Array.from(buffer.subarray(levelsAt, orderAt)),
+		visualOrder: Array.from(buffer.subarray(orderAt, orderAt + count))
+	};
+};
+const RIGHT_TO_LEFT_BY_BIDI_DIRECTION = {
+	ltr: false,
+	rtl: true,
+	auto: void 0
+};
+const shaper = {
+	resolveBidi: ({ text, direction }) => decodeBidi(resolveBidi(text, RIGHT_TO_LEFT_BY_BIDI_DIRECTION[direction])),
+	shapeRun: ({ font, faceIndex = 0, text, direction, script = "", language = "", featuresOn = [], featuresOff = [] }) => {
+		try {
+			return decode(shapeRun(font, faceIndex, text, direction === SHAPING_DIRECTION.rightToLeft, script, language, [...featuresOn], [...featuresOff]));
+		} catch (cause) {
+			throw new ShaperError({
+				message: "Could not shape a run of text",
+				cause
+			});
+		}
 	}
-} };
+};
 let loading;
 /**
 * Loads the shaper, once, and hands back the single implementation both the
 * measurer and the PDF backend use.
 *
-* Calling this is what fetches the artifact, so a caller asks for it only after
-* establishing that some run actually needs shaping.
+* Calling this without a source is what fetches the artifact, so a caller asks
+* for it only after establishing that some run actually needs shaping. With a
+* source, the bytes given are instantiated and nothing is fetched. Either way
+* the first successful load is the one every later call shares.
 */
-const getShaper = () => {
-	loading ??= __wbg_init().then(() => {
+const getShaper = (source) => {
+	loading ??= __wbg_init(source === void 0 ? void 0 : { module_or_path: source.wasm }).then(() => {
 		resolved = shaper;
 		return shaper;
 	}).catch((cause) => {
@@ -99,4 +130,4 @@ let resolved = null;
 */
 const resolvedShaper = () => resolved;
 //#endregion
-export { SHAPING_DIRECTION, ShaperError, getShaper, resolvedShaper, shaperLoaded };
+export { BIDI_DIRECTION, SHAPING_DIRECTION, ShaperError, getShaper, resolvedShaper, shaperLoaded };

package/dist/text-shaping.d.ts

@@ -0,0 +1,4 @@
+import { BIDI_DIRECTION, BidiLine, ResolveBidiRequest, SHAPING_DIRECTION, ShapeRunRequest, ShapedRun, Shaper, ShaperSource, getShaper } from "./shaping/shaper.js";
+import { SfntFont, parseSfnt } from "./fonts/sfnt/parse.js";
+import { TrueTypeSubset, subsetTrueType } from "./fonts/sfnt/subset.js";
+export { BIDI_DIRECTION, type BidiLine, type ResolveBidiRequest, SHAPING_DIRECTION, type SfntFont, type ShapeRunRequest, type ShapedRun, type Shaper, type ShaperSource, type TrueTypeSubset, getShaper, parseSfnt, subsetTrueType };

package/dist/text-shaping.js

@@ -0,0 +1,4 @@
+import { parseSfnt } from "./fonts/sfnt/parse.js";
+import { subsetTrueType } from "./fonts/sfnt/subset.js";
+import { BIDI_DIRECTION, SHAPING_DIRECTION, getShaper } from "./shaping/shaper.js";
+export { BIDI_DIRECTION, SHAPING_DIRECTION, getShaper, parseSfnt, subsetTrueType };

package/dist/utils/findReplace.js

@@ -66,7 +66,7 @@ const forEachParagraph = (blocks, visit) => {
 				walkTable(block);
 				continue;
 			}
-			if (isBlockSdt(block)) walkBlocks(block.content);
+			if (isBlockContainer(block)) walkBlocks(block.content);
 		}
 	};
 	const walkTable = (table) => {
@@ -172,6 +172,6 @@ const isParagraph = (value) => isRecord(value) && value["type"] === "paragraph"
 const isTable = (value) => isRecord(value) && value["type"] === "table" && Array.isArray(value["rows"]);
 const isTableRow = (value) => isRecord(value) && Array.isArray(value["cells"]);
 const isTableCell = (value) => isRecord(value) && Array.isArray(value["content"]);
-const isBlockSdt = (value) => isRecord(value) && value["type"] === "blockSdt" && Array.isArray(value["content"]);
+const isBlockContainer = (value) => isRecord(value) && (value["type"] === "blockSdt" || value["type"] === "blockCustomXml") && Array.isArray(value["content"]);
 //#endregion
 export { createDefaultFindOptions, createSearchPattern, escapeRegexString, findAllMatches, findInDocument, findInParagraph };

package/dist/utils/mergeDocumentContent.js

@@ -86,7 +86,7 @@ function mergeDocumentContent(target, source) {
 function remapBlock(block, numIdRemap, abstractNumIdRemap) {
 	if (block.type === "paragraph") return remapParagraph(block, numIdRemap, abstractNumIdRemap);
 	if (block.type === "table") return remapTable(block, numIdRemap, abstractNumIdRemap);
-	if (block.type === "blockSdt" && Array.isArray(block.content)) return {
+	if ((block.type === "blockSdt" || block.type === "blockCustomXml") && Array.isArray(block.content)) return {
 		...block,
 		content: block.content.map((child) => remapBlock(child, numIdRemap, abstractNumIdRemap))
 	};

package/dist/utils/noteReferenceLabels.d.ts

@@ -0,0 +1,36 @@
+//#region src/utils/noteReferenceLabels.d.ts
+/**
+ * How a reader shows a footnote or endnote reference.
+ *
+ * A reference's `w:id` is a package key, not something a reader sees: the
+ * rendered document numbers notes by the order they are first referenced
+ * (1, 2, 3 …), whatever ids the package gave them. Every reader that puts a reference in a line of
+ * text — the Markdown export, `getContent()`, the AI snapshot and the agent
+ * tools built on it — numbers through {@link createNoteReferenceNumbering}, so
+ * the same reference reads as the same marker everywhere.
+ *
+ * Footnotes and endnotes are numbered in separate sequences; an
+ * endnote's token carries an `e` so the two sequences never collide
+ * (`[^1]` is footnote 1, `[^e1]` is endnote 1).
+ */
+type NoteReferenceKind = "footnote" | "endnote";
+/** The bare token: `1` for footnote 1, `e1` for endnote 1. */
+declare const noteReferenceToken: (kind: NoteReferenceKind, displayNumber: number) => string;
+/** The marker a text reader shows in the line: `[^1]`, `[^e1]`. */
+declare const noteReferenceMarker: (kind: NoteReferenceKind, displayNumber: number) => string;
+type NoteReferenceNumber = {
+  displayNumber: number;
+  /** Whether this is the note's first reference in reading order. */
+  first: boolean;
+};
+type NoteReferenceNumbering = {
+  /** Number one reference, in reading order. */
+  next: (kind: NoteReferenceKind, noteId: string | number) => NoteReferenceNumber;
+};
+/**
+ * A reading-order numbering: each note takes the next number of its kind the
+ * first time it is referenced, and a repeated reference reuses it.
+ */
+declare const createNoteReferenceNumbering: () => NoteReferenceNumbering;
+//#endregion
+export { NoteReferenceKind, NoteReferenceNumber, NoteReferenceNumbering, createNoteReferenceNumbering, noteReferenceMarker, noteReferenceToken };

package/dist/utils/noteReferenceLabels.js

@@ -0,0 +1,32 @@
+//#region src/utils/noteReferenceLabels.ts
+/** The bare token: `1` for footnote 1, `e1` for endnote 1. */
+const noteReferenceToken = (kind, displayNumber) => kind === "endnote" ? `e${displayNumber}` : String(displayNumber);
+/** The marker a text reader shows in the line: `[^1]`, `[^e1]`. */
+const noteReferenceMarker = (kind, displayNumber) => `[^${noteReferenceToken(kind, displayNumber)}]`;
+/**
+* A reading-order numbering: each note takes the next number of its kind the
+* first time it is referenced, and a repeated reference reuses it.
+*/
+const createNoteReferenceNumbering = () => {
+	const numbers = /* @__PURE__ */ new Map();
+	const counts = {
+		footnote: 0,
+		endnote: 0
+	};
+	return { next: (kind, noteId) => {
+		const key = `${kind}:${String(noteId)}`;
+		const existing = numbers.get(key);
+		if (existing !== void 0) return {
+			displayNumber: existing,
+			first: false
+		};
+		counts[kind] += 1;
+		numbers.set(key, counts[kind]);
+		return {
+			displayNumber: counts[kind],
+			first: true
+		};
+	} };
+};
+//#endregion
+export { createNoteReferenceNumbering, noteReferenceMarker, noteReferenceToken };

package/dist/utils/replaceText.js

@@ -49,7 +49,7 @@ function getParagraphByIndex(body, paragraphIndex) {
 				}
 				continue;
 			}
-			if (block.type !== "blockSdt") continue;
+			if (block.type !== "blockSdt" && block.type !== "blockCustomXml") continue;
 			const found = walkBlocks(block.content);
 			if (found !== null) return found;
 		}

package/dist/version-comparison.d.ts

@@ -46,6 +46,7 @@ declare const INLINE_FORMAT_PROPERTIES: {
 declare const PARAGRAPH_FORMAT_PROPERTIES: {
   readonly indentation: true;
   readonly styleId: true;
+  readonly outlineLevel: true;
   readonly listLevel: true;
   readonly listReference: true;
   readonly alignment: true;

package/dist/version-comparison.js

@@ -88,6 +88,7 @@ const INLINE_FORMAT_PROPERTIES = {
 const PARAGRAPH_FORMAT_PROPERTIES = {
 	indentation: true,
 	styleId: true,
+	outlineLevel: true,
 	listLevel: true,
 	listReference: true,
 	alignment: true,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@stll/folio-core",
-  "version": "0.51.0",
+  "version": "0.53.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",
@@ -106,6 +106,11 @@
       "types": "./dist/docx/documentClone.d.ts",
       "import": "./dist/docx/documentClone.js"
     },
+    "./text-shaping": {
+      "types": "./dist/text-shaping.d.ts",
+      "import": "./dist/text-shaping.js"
+    },
+    "./text-shaping/wasm": "./dist/generated/text_shaper_bg.wasm",
     "./docx/paragraphPropertySource": null,
     "./internal/*": null,
     "./*": {
@@ -122,13 +127,14 @@
     "pack:dry-run": "bun pm pack --dry-run",
     "typecheck": "bun ../../scripts/tsc-native.ts --noEmit -p tsconfig.build.json",
     "test": "bun test src scripts",
+    "test:conformance:full": "FOLIO_CONFORMANCE=full bun test src/__tests__/editorCommandConformance.test.ts",
     "wasm:check": "bun ../../scripts/build-shaper-wasm.ts --check",
     "wasm:generate": "bun ../../scripts/build-shaper-wasm.ts --write",
     "test:property": "bun test $(grep -rlF 'fc.assert' src --include='*.test.ts')",
     "perf": "bun scripts/profile-editor.ts"
   },
   "dependencies": {
-    "@stll/docx-core": "^0.28.0",
+    "@stll/docx-core": "^0.28.1",
     "@stll/docx-utils": "^0.1.0",
     "@stll/template-conditions": ">=0.4.0 <1.0.0",
     "better-result": "3.0.1",

package/dist/internal/headlessRevisionResolution.d.ts

@@ -1,23 +0,0 @@
-import { RunStyleResolver } from "../prosemirror/runStyleFormatting.js";
-import { Transaction } from "prosemirror-state";
-import { MarkType } from "prosemirror-model";
-//#region src/internal/headlessRevisionResolution.d.ts
-type HeadlessRevisionResolutionMode = "accept" | "reject";
-type HeadlessRange = {
-  from: number;
-  to: number;
-};
-type HeadlessInlineChangeTracking = {
-  ranges: readonly HeadlessRange[];
-  mappingFrom: number;
-};
-type AppendHeadlessInlineResolutionOptions = {
-  tr: Transaction;
-  mode: HeadlessRevisionResolutionMode;
-  keepType: MarkType | undefined;
-  removeType: MarkType | undefined;
-  styleResolver: RunStyleResolver | null;
-};
-declare const appendHeadlessInlineResolution: ({ tr, mode, keepType, removeType, styleResolver }: AppendHeadlessInlineResolutionOptions) => HeadlessInlineChangeTracking | null;
-//#endregion
-export { HeadlessInlineChangeTracking, HeadlessRevisionResolutionMode, appendHeadlessInlineResolution };