@stll/folio-core 0.0.1-placeholder.0 → 0.1.1

package/dist/ai-edits/headless.js

@@ -0,0 +1,513 @@
+import { deterministicHexId } from "../utils/hexId.js";
+import { repackDocx } from "../docx/rezip.js";
+import { createFolioAIEditSnapshot } from "./snapshot.js";
+import { applyFolioAIEditOperations } from "./apply.js";
+import { createReply } from "../docx/replyToComment.js";
+import { attemptSelectiveSave } from "../docx/selectiveSave.js";
+import { parseDocx } from "../docx/parser.js";
+import { acceptAIEditRevision, acceptAllChanges, rejectAIEditRevision, rejectAllChanges } from "../prosemirror/commands/comments.js";
+import { updateDocumentContent } from "../prosemirror/conversion/fromProseDoc.js";
+import { getChangedParagraphIds, hasStructuralChanges, hasUntrackedChanges, ignoreTrackedChanges } from "../prosemirror/extensions/features/ParagraphChangeTrackerExtension.js";
+import { schema, singletonManager } from "../prosemirror/schema/index.js";
+import { toProseDoc } from "../prosemirror/conversion/toProseDoc.js";
+import { EditorState } from "prosemirror-state";
+//#region src/ai-edits/headless.ts
+/**
+* Headless `.docx` review path: buffer -> apply AI edits -> buffer, with
+* no `EditorView` and no DOM. A queue worker or agent can read a document,
+* apply `FolioAIEditOperation`s (tracked-changes or direct), and write a
+* reviewed `.docx` back out — the server-side counterpart to the React
+* editor's live apply flow.
+*
+* The operation applier is shared, not forked: {@link applyFolioAIEditOperations}
+* only needs a {@link FolioAIEditView} seam (`{ state, dispatch }`), which a
+* headless `EditorState` satisfies via `state.apply(tr)`. The React editor and
+* this reviewer therefore run byte-for-byte the same anchor resolution,
+* word-diff redlines, and tracked-change bookkeeping.
+*
+* Save mirrors the editor's own path: a selective patch of only the changed
+* paragraphs in `document.xml` (leaving every untouched part byte-exact), with
+* a full repack as the fallback for structural edits.
+*
+* Scope: BODY blocks. Footnote / endnote note-body apply is intentionally out
+* of scope here and can build on the note serialization work separately.
+*/
+/**
+* Standalone comment-id allocator for the reviewer. The React editor uses
+* `Date.now()`-seeded ids from `commentsHelpers`; that module is DOM-bound
+* (`EditorView`, `findBodyPmAnchors`) and unimportable here, so the reviewer
+* mints its own. Seeded once per realm and incremented so ids stay unique
+* across reviewers created within the same millisecond.
+*/
+let commentIdCursor = Date.now();
+/**
+* Build the note-free comment thread the apply layer references by id.
+* Mirrors `commentsHelpers.createComment` (a pure object literal there) so a
+* headless `commentOnBlock` / `comment` op serialises the same `comments.xml`
+* shape the editor produces.
+*/
+const createReviewerComment = (text, author) => ({
+	id: commentIdCursor++,
+	author,
+	date: (/* @__PURE__ */ new Date()).toISOString(),
+	content: [{
+		type: "paragraph",
+		formatting: {},
+		content: [{
+			type: "run",
+			formatting: {},
+			content: [{
+				type: "text",
+				text
+			}]
+		}]
+	}]
+});
+/**
+* Assign a stable `w14:paraId` to every body paragraph that lacks one (or
+* duplicates an earlier id), derived deterministically from the paragraph's
+* text plus its document ordinal. Re-parsing the SAME bytes mints the SAME ids,
+* so the block ids a snapshot exposes are reproducible across
+* {@link FolioDocxReviewer.fromBuffer} calls — the documented "snapshot on one
+* parse, apply on another" flow resolves instead of skipping every op as a
+* stale anchor. Word-authored paraIds are preserved; only gaps and collisions
+* get a fresh id.
+*
+* The shared `ParaIdAllocatorExtension` mints RANDOM ids (correct for freshly
+* typed paragraphs in the live editor); this load-time pass is deterministic so
+* a paraId-less corpus document anchors reproducibly. The transaction is marked
+* ignore-tracked so the change baseline stays clean.
+*/
+const ensureDeterministicParaIdsInState = (state) => {
+	const seen = /* @__PURE__ */ new Set();
+	const updates = [];
+	let ordinal = 0;
+	state.doc.descendants((node, pos) => {
+		if (node.type.name !== "paragraph") return;
+		ordinal += 1;
+		const existing = node.attrs["paraId"];
+		if (typeof existing === "string" && existing.length > 0 && !seen.has(existing)) {
+			seen.add(existing);
+			return false;
+		}
+		let paraId = deterministicHexId(`${node.textContent}:${ordinal}`);
+		for (let salt = 1; seen.has(paraId); salt++) paraId = deterministicHexId(`${node.textContent}:${ordinal}:${salt}`);
+		seen.add(paraId);
+		updates.push({
+			pos,
+			attrs: {
+				...node.attrs,
+				paraId
+			}
+		});
+		return false;
+	});
+	if (updates.length === 0) return state;
+	const tr = state.tr;
+	for (const update of updates) tr.setNodeMarkup(update.pos, void 0, update.attrs);
+	ignoreTrackedChanges(tr);
+	tr.setMeta("addToHistory", false);
+	return state.apply(tr);
+};
+/**
+* One LLM-ready line for a block: `[<blockId>] text`, with an `(h<level>)` tag
+* for headings and the list marker for list items, so a model can copy the
+* block id straight back into an operation.
+*/
+const formatBlockForLLM = (block) => {
+	const label = `[${block.id}]`;
+	if (block.kind === "heading") return `${label} (h${headingLevel(block)}) ${block.text}`;
+	if (block.kind === "listItem") return `${label} ${block.displayLabel ?? "•"} ${block.text}`;
+	return `${label} ${block.text}`;
+};
+const headingLevel = (block) => {
+	const digits = /(\d+)/u.exec(block.styleId ?? block.displayLabel ?? "")?.[1];
+	const level = digits ? Number.parseInt(digits, 10) : 1;
+	return level >= 1 && level <= 9 ? level : 1;
+};
+const revisionIdOf = (target) => typeof target === "number" ? target : target.id;
+const commentPlainText = (comment) => (comment.content ?? []).map(paragraphPlainText).join("\n");
+const paragraphPlainText = (paragraph) => {
+	const parts = [];
+	for (const item of paragraph.content ?? []) {
+		if (item.type !== "run") continue;
+		for (const runItem of item.content ?? []) if (runItem.type === "text") parts.push(runItem.text);
+	}
+	return parts.join("");
+};
+/**
+* Headless `.docx` reviewer. Parse a buffer, read blocks, apply
+* `FolioAIEditOperation`s against the document model, and write the reviewed
+* `.docx` back out — no editor instance, no DOM.
+*
+* @example
+* ```ts
+* const reviewer = await FolioDocxReviewer.fromBuffer(buffer, { author: "AI" });
+* const { blocks } = reviewer.snapshot();
+* reviewer.applyOperations([
+*   { id: "1", type: "replaceInBlock", blockId: blocks[0].id, find: "$50k", replace: "$500k" },
+* ]);
+* const reviewed = await reviewer.toBuffer();
+* ```
+*/
+var FolioDocxReviewer = class FolioDocxReviewer {
+	/** Default author for tracked changes and comments. */
+	author;
+	baseDocument;
+	originalBuffer;
+	state;
+	createdComments = [];
+	constructor(args) {
+		this.baseDocument = args.baseDocument;
+		this.originalBuffer = args.originalBuffer;
+		this.state = args.state;
+		this.author = args.author;
+	}
+	/** Parse a `.docx` buffer into a reviewer. */
+	static async fromBuffer(buffer, options = {}) {
+		const baseDocument = await parseDocx(buffer, {
+			detectVariables: false,
+			preloadFonts: false
+		});
+		const plugins = singletonManager.getPlugins();
+		return new FolioDocxReviewer({
+			baseDocument,
+			originalBuffer: buffer,
+			state: ensureDeterministicParaIdsInState(EditorState.create({
+				schema,
+				doc: toProseDoc(baseDocument),
+				plugins
+			})),
+			author: options.author ?? "AI"
+		});
+	}
+	/**
+	* Snapshot the current document into AI-facing blocks (id, kind, text) plus
+	* the anchor map the apply layer resolves operations against.
+	*/
+	snapshot() {
+		return createFolioAIEditSnapshot(this.state.doc);
+	}
+	/**
+	* Apply operations against the current state. Reuses the live-editor applier
+	* verbatim via a headless `{ state, dispatch }` seam; the resulting state
+	* (including any comments) is retained for {@link toBuffer}.
+	*/
+	applyOperations(operations, options = {}) {
+		const snapshot = options.snapshot ?? this.snapshot();
+		const view = {
+			state: this.state,
+			dispatch: (transaction) => {
+				view.state = view.state.apply(transaction);
+			}
+		};
+		const result = applyFolioAIEditOperations({
+			view,
+			snapshot,
+			operations,
+			mode: options.mode ?? "tracked-changes",
+			author: this.author,
+			createCommentId: (text) => {
+				const comment = createReviewerComment(text, this.author);
+				this.createdComments.push(comment);
+				return comment.id;
+			}
+		});
+		this.state = view.state;
+		return result;
+	}
+	/**
+	* The body blocks with their stable ids, in document order — the same
+	* `FolioAIBlock` shape {@link snapshot} builds, reused verbatim so the ids
+	* feed straight back into {@link applyOperations} and accept / reject.
+	*/
+	getContent() {
+		return this.snapshot().blocks;
+	}
+	/**
+	* The body as LLM-ready plain text: one line per block, each prefixed with
+	* its stable block id (`[<blockId>] text`). Copyable verbatim into a prompt
+	* without JSON quote-escaping.
+	*/
+	getContentAsText() {
+		return this.getContent().map(formatBlockForLLM).join("\n");
+	}
+	/**
+	* The tracked changes (insertions and deletions) present in the body, read
+	* from the same `insertion` / `deletion` marks the editor renders. Each
+	* carries the revision id {@link acceptChange} / {@link rejectChange} resolve
+	* against. Runs of one revision within a block fold into a single entry.
+	*/
+	getChanges(filter) {
+		const insertionType = this.state.schema.marks["insertion"];
+		const deletionType = this.state.schema.marks["deletion"];
+		const blockStarts = this.blockStartIds();
+		const grouped = /* @__PURE__ */ new Map();
+		let currentBlockId = null;
+		this.state.doc.descendants((node, pos) => {
+			if (node.isTextblock) {
+				currentBlockId = blockStarts.get(pos) ?? null;
+				return true;
+			}
+			if (!node.isInline || node.text === void 0) return;
+			const text = node.text;
+			for (const mark of node.marks) {
+				if (typeof mark.attrs["revisionId"] !== "number") continue;
+				let kind;
+				if (mark.type === insertionType) kind = "insertion";
+				else if (mark.type === deletionType) kind = "deletion";
+				else continue;
+				const revisionId = mark.attrs["revisionId"];
+				const key = `${currentBlockId ?? ""}:${kind}:${revisionId}`;
+				const existing = grouped.get(key);
+				if (existing) {
+					existing.text += text;
+					continue;
+				}
+				const author = mark.attrs["author"];
+				const date = mark.attrs["date"];
+				grouped.set(key, {
+					id: revisionId,
+					type: kind,
+					author: typeof author === "string" ? author : "",
+					date: typeof date === "string" ? date : null,
+					text,
+					blockId: currentBlockId
+				});
+			}
+		});
+		const changes = [...grouped.values()];
+		if (!filter) return changes;
+		return changes.filter((change) => (filter.author === void 0 || change.author === filter.author) && (filter.type === void 0 || change.type === filter.type));
+	}
+	/**
+	* The comment threads in the document — comments parsed from the package plus
+	* any the reviewer authored — with their anchored text and containing block
+	* id. Only run text is read from a comment body; richer comment content
+	* (nested tracked changes, hyperlinks) is out of scope.
+	*/
+	getComments(filter) {
+		const definitions = [...this.baseDocument.package.document.comments ?? [], ...this.createdComments];
+		if (definitions.length === 0) return [];
+		const anchors = this.commentAnchors();
+		const repliesByParent = /* @__PURE__ */ new Map();
+		const topLevel = [];
+		for (const comment of definitions) {
+			if (comment.parentId === void 0) {
+				topLevel.push(comment);
+				continue;
+			}
+			const siblings = repliesByParent.get(comment.parentId) ?? [];
+			siblings.push(comment);
+			repliesByParent.set(comment.parentId, siblings);
+		}
+		const threads = topLevel.map((comment) => {
+			const anchor = anchors.get(comment.id);
+			return {
+				id: comment.id,
+				author: comment.author,
+				date: comment.date ?? null,
+				text: commentPlainText(comment),
+				anchoredText: anchor?.text ?? "",
+				blockId: anchor?.blockId ?? null,
+				replies: (repliesByParent.get(comment.id) ?? []).map((reply) => ({
+					id: reply.id,
+					author: reply.author,
+					date: reply.date ?? null,
+					text: commentPlainText(reply)
+				})),
+				done: comment.done ?? false
+			};
+		});
+		if (!filter) return threads;
+		return threads.filter((thread) => (filter.author === void 0 || thread.author === filter.author) && (filter.done === void 0 || thread.done === filter.done));
+	}
+	/**
+	* Add a reply to a comment thread. Pass a {@link FolioReviewComment} from
+	* {@link getComments} or its id; the reply threads under that comment's root
+	* (Word threads are flat). On {@link toBuffer} the reply is written as a real
+	* Word reply — linked via `commentsExtended.xml` and given its own
+	* `commentRange` markers + reference anchored on the parent's range. Returns
+	* the created reply, or `null` when the target comment is absent.
+	*/
+	replyTo(target, input) {
+		const parentId = typeof target === "number" ? target : target.id;
+		const reply = createReply([...this.baseDocument.package.document.comments ?? [], ...this.createdComments], parentId, {
+			author: input.author ?? this.author,
+			text: input.text,
+			...input.initials !== void 0 ? { initials: input.initials } : {}
+		});
+		if (!reply) return null;
+		this.createdComments.push(reply);
+		return {
+			id: reply.id,
+			author: reply.author,
+			date: reply.date ?? null,
+			text: input.text
+		};
+	}
+	/**
+	* Accept an existing tracked change, keeping its text and dropping the
+	* redline. Pass a {@link FolioReviewChange} from {@link getChanges} or its
+	* revision id. Reuses the editor's own accept command headlessly, so the
+	* resolved state persists on {@link toBuffer}. Returns `false` when the
+	* revision is no longer present (already resolved, or never existed).
+	*/
+	acceptChange(target) {
+		return this.runCommand(acceptAIEditRevision(revisionIdOf(target)));
+	}
+	/**
+	* Reject an existing tracked change: an insertion's text is removed, a
+	* deletion's text is restored. See {@link acceptChange} for targeting.
+	*/
+	rejectChange(target) {
+		return this.runCommand(rejectAIEditRevision(revisionIdOf(target)));
+	}
+	/**
+	* 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.
+	*/
+	acceptAll() {
+		const count = this.countTrackedChanges();
+		this.runCommand(acceptAllChanges());
+		return count;
+	}
+	/** Reject every tracked change in the body. See {@link acceptAll}. */
+	rejectAll() {
+		const count = this.countTrackedChanges();
+		this.runCommand(rejectAllChanges());
+		return count;
+	}
+	/** The current document model with edits merged back in. */
+	toDocument() {
+		const document = updateDocumentContent(this.baseDocument, this.state.doc);
+		if (this.createdComments.length > 0) document.package.document.comments = [...document.package.document.comments ?? [], ...this.createdComments];
+		return document;
+	}
+	/**
+	* Serialise the reviewed document to a new `.docx` buffer. Tries a selective
+	* patch first (only changed paragraphs are rewritten; every other byte of the
+	* original package is preserved), falling back to a full repack for
+	* structural edits — the same two-tier path the editor's save uses.
+	*/
+	async toBuffer() {
+		const document = this.toDocument();
+		const selective = await this.trySelectiveSave(document);
+		if (selective) return selective;
+		return repackDocx({
+			...document,
+			originalBuffer: this.originalBuffer
+		});
+	}
+	/**
+	* Attempt the selective patch, treating a throw the same as a decline. Odd
+	* source XML can make the paragraph diff throw rather than return `null`; a
+	* full repack is the correct lossless fallback in both cases, so the fallback
+	* is the graceful handling — no separate error surface is needed here.
+	*/
+	async trySelectiveSave(document) {
+		try {
+			return await attemptSelectiveSave(document, this.originalBuffer, {
+				changedParaIds: getChangedParagraphIds(this.state),
+				structuralChange: hasStructuralChanges(this.state),
+				hasUntrackedChanges: hasUntrackedChanges(this.state)
+			});
+		} catch {
+			return null;
+		}
+	}
+	/**
+	* Count every tracked change an accept-all / reject-all sweep resolves: the
+	* inline insertion / deletion groups {@link getChanges} enumerates, plus
+	* paragraph-level changes (`pPrMark`, `_propertyChanges`) that live on
+	* paragraph attrs rather than inline marks.
+	*/
+	countTrackedChanges() {
+		let count = this.getChanges().length;
+		this.state.doc.descendants((node) => {
+			if (node.type.name !== "paragraph") return;
+			const pPrMark = node.attrs["pPrMark"];
+			if (pPrMark !== null && pPrMark !== void 0) count += 1;
+			const propertyChanges = node.attrs["_propertyChanges"];
+			if (Array.isArray(propertyChanges) && propertyChanges.length > 0) count += 1;
+			return false;
+		});
+		return count;
+	}
+	/** Map each snapshot block's start position to its stable id. */
+	blockStartIds() {
+		const starts = /* @__PURE__ */ new Map();
+		for (const anchor of Object.values(this.snapshot().anchors)) starts.set(anchor.from, anchor.id);
+		return starts;
+	}
+	/** Map each anchored comment id to its anchored text and containing block id. */
+	commentAnchors() {
+		const commentType = this.state.schema.marks["comment"];
+		const anchors = /* @__PURE__ */ new Map();
+		if (!commentType) return anchors;
+		const blockStarts = this.blockStartIds();
+		let currentBlockId = null;
+		this.state.doc.descendants((node, pos) => {
+			if (node.isTextblock) {
+				currentBlockId = blockStarts.get(pos) ?? null;
+				return true;
+			}
+			if (!node.isInline || node.text === void 0) return;
+			const text = node.text;
+			for (const mark of node.marks) {
+				if (mark.type !== commentType || typeof mark.attrs["commentId"] !== "number") continue;
+				const commentId = mark.attrs["commentId"];
+				const existing = anchors.get(commentId);
+				if (!existing) {
+					anchors.set(commentId, {
+						text,
+						blockId: currentBlockId
+					});
+					continue;
+				}
+				existing.text += text;
+				existing.blockId ??= currentBlockId;
+			}
+		});
+		return anchors;
+	}
+	/**
+	* Drive a ProseMirror command against the reviewer's headless state via the
+	* same `{ state, dispatch }` seam {@link applyOperations} uses, retaining the
+	* resulting state for {@link toBuffer}.
+	*/
+	runCommand(command) {
+		const view = {
+			state: this.state,
+			dispatch: (transaction) => {
+				view.state = view.state.apply(transaction);
+			}
+		};
+		const handled = command(view.state, view.dispatch);
+		this.state = view.state;
+		return handled;
+	}
+};
+/**
+* One-shot headless review: parse `buffer`, apply `operations`, and return the
+* reviewed `.docx` buffer alongside the applied / skipped breakdown. Convenience
+* wrapper over {@link FolioDocxReviewer} for callers that already hold the
+* operations to run.
+*/
+const applyFolioAIEditsToBuffer = async (buffer, operations, options = {}) => {
+	const reviewer = await FolioDocxReviewer.fromBuffer(buffer, { ...options.author !== void 0 && { author: options.author } });
+	const { applied, skipped } = reviewer.applyOperations(operations, {
+		...options.mode !== void 0 && { mode: options.mode },
+		...options.snapshot !== void 0 && { snapshot: options.snapshot }
+	});
+	return {
+		buffer: await reviewer.toBuffer(),
+		applied,
+		skipped
+	};
+};
+//#endregion
+export { FolioDocxReviewer, applyFolioAIEditsToBuffer };

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

@@ -0,0 +1,6 @@
+import { FolioAIBlock, FolioAIBlockAnchor, FolioAIBlockKind, FolioAIBlockPreviewRun, FolioAIComment, FolioAIEditAppliedOperation, FolioAIEditApplyMode, FolioAIEditApplyResult, FolioAIEditOperation, FolioAIEditReviewMeta, FolioAIEditSeverity, FolioAIEditSkipReason, FolioAIEditSkippedOperation, FolioAIEditSnapshot, FolioAISignatureParty } from "./types.js";
+import { FolioAIEditView, applyFolioAIEditOperations } from "./apply.js";
+import { createFolioAIEditSnapshot, hashFolioAIBlockText, normalizeFolioAIBlockText } from "./snapshot.js";
+import { getFolioParaIdFromBlockId } from "../types/block-id.js";
+import { WordDiffSegment, diffWordSegments } from "./word-diff.js";
+export { type FolioAIBlock, type FolioAIBlockAnchor, type FolioAIBlockKind, type FolioAIBlockPreviewRun, type FolioAIComment, type FolioAIEditAppliedOperation, type FolioAIEditApplyMode, type FolioAIEditApplyResult, type FolioAIEditOperation, type FolioAIEditReviewMeta, type FolioAIEditSeverity, type FolioAIEditSkipReason, type FolioAIEditSkippedOperation, type FolioAIEditSnapshot, type FolioAIEditView, type FolioAISignatureParty, type WordDiffSegment, applyFolioAIEditOperations, createFolioAIEditSnapshot, diffWordSegments, getFolioParaIdFromBlockId, hashFolioAIBlockText, normalizeFolioAIBlockText };

package/dist/ai-edits/index.js

@@ -0,0 +1,5 @@
+import { getFolioParaIdFromBlockId } from "../types/block-id.js";
+import { createFolioAIEditSnapshot, hashFolioAIBlockText, normalizeFolioAIBlockText } from "./snapshot.js";
+import { diffWordSegments } from "./word-diff.js";
+import { applyFolioAIEditOperations } from "./apply.js";
+export { applyFolioAIEditOperations, createFolioAIEditSnapshot, diffWordSegments, getFolioParaIdFromBlockId, hashFolioAIBlockText, normalizeFolioAIBlockText };

package/dist/ai-edits/inline-emphasis.d.ts

@@ -0,0 +1,38 @@
+//#region src/ai-edits/inline-emphasis.d.ts
+/**
+ * Turn the bold / bold-italic markdown the chat model sometimes emits inside
+ * inserted or replaced block text ("**Date:**", "***Term***") into structured
+ * runs the editor renders as real Word formatting.
+ *
+ * The active-docx-edit tool gives the model no inline run-formatting channel —
+ * only paragraph-level `styleId`. When the model wants a bold label or party
+ * name mid-sentence it improvises with markdown, and because DOCX has no notion
+ * of markdown those markers otherwise reach the document as literal asterisks.
+ *
+ * Deliberately conservative: only paired `**bold**` and `***bold italic***`
+ * asterisk markers with non-space inner content count as emphasis. Underscores
+ * are always literal — `__Borrower__` / snake_case placeholders are common in
+ * legal templates, and a lone `*` is far more likely a multiplication sign than
+ * a delimiter. Nesting is not interpreted; inner content is taken verbatim.
+ * Backslashes are ordinary characters (no markdown escapes), so Windows paths
+ * and regex survive intact.
+ */
+type InlineEmphasisRun = {
+  text: string;
+  bold: boolean;
+  italic: boolean;
+};
+declare const parseInlineEmphasisRuns: (input: string) => InlineEmphasisRun[];
+/** True when `input` contains at least one bold / italic span worth promoting
+ *  to real marks; lets callers skip the run rebuild for plain text. */
+declare const hasInlineEmphasis: (input: string) => boolean;
+/**
+ * Drop emphasis markers without reconstructing formatting. Used on the
+ * tracked-changes replace path, where the word-diff redline cannot carry inline
+ * marks; stripping at least keeps literal `**` out of the document. Returns the
+ * input verbatim when no real span is present, so plain prose (and stray
+ * single `*` / escaped `\*`) is never reshaped.
+ */
+declare const stripInlineEmphasisMarkers: (input: string) => string;
+//#endregion
+export { InlineEmphasisRun, hasInlineEmphasis, parseInlineEmphasisRuns, stripInlineEmphasisMarkers };

package/dist/ai-edits/inline-emphasis.js

@@ -0,0 +1,78 @@
+//#region src/ai-edits/inline-emphasis.ts
+const MARKERS = [{
+	marker: "***",
+	bold: true,
+	italic: true
+}, {
+	marker: "**",
+	bold: true,
+	italic: false
+}];
+const isSpace = (ch) => ch === void 0 || ch === " " || ch === "	" || ch === "\n";
+const matchMarkerAt = (input, at) => MARKERS.find((m) => input.startsWith(m.marker, at));
+const appendLiteral = (runs, text) => {
+	if (text.length === 0) return;
+	const last = runs.at(-1);
+	if (last && !last.bold && !last.italic) {
+		last.text += text;
+		return;
+	}
+	runs.push({
+		text,
+		bold: false,
+		italic: false
+	});
+};
+const parseInlineEmphasisRuns = (input) => {
+	const runs = [];
+	let buffer = "";
+	let i = 0;
+	const flushBuffer = () => {
+		appendLiteral(runs, buffer);
+		buffer = "";
+	};
+	while (i < input.length) {
+		const ch = input[i];
+		const matched = matchMarkerAt(input, i);
+		if (!matched) {
+			buffer += ch;
+			i += 1;
+			continue;
+		}
+		const contentStart = i + matched.marker.length;
+		const closeIdx = input.indexOf(matched.marker, contentStart);
+		const content = closeIdx === -1 ? "" : input.slice(contentStart, closeIdx);
+		if (!(closeIdx !== -1 && content.length > 0 && !isSpace(content[0]) && !isSpace(content.at(-1)))) {
+			buffer += ch;
+			i += 1;
+			continue;
+		}
+		flushBuffer();
+		runs.push({
+			text: content,
+			bold: matched.bold,
+			italic: matched.italic
+		});
+		i = closeIdx + matched.marker.length;
+	}
+	flushBuffer();
+	return runs;
+};
+const hasEmphasis = (runs) => runs.some((run) => run.bold || run.italic);
+/** True when `input` contains at least one bold / italic span worth promoting
+*  to real marks; lets callers skip the run rebuild for plain text. */
+const hasInlineEmphasis = (input) => hasEmphasis(parseInlineEmphasisRuns(input));
+/**
+* Drop emphasis markers without reconstructing formatting. Used on the
+* tracked-changes replace path, where the word-diff redline cannot carry inline
+* marks; stripping at least keeps literal `**` out of the document. Returns the
+* input verbatim when no real span is present, so plain prose (and stray
+* single `*` / escaped `\*`) is never reshaped.
+*/
+const stripInlineEmphasisMarkers = (input) => {
+	const runs = parseInlineEmphasisRuns(input);
+	if (!hasEmphasis(runs)) return input;
+	return runs.map((run) => run.text).join("");
+};
+//#endregion
+export { hasInlineEmphasis, parseInlineEmphasisRuns, stripInlineEmphasisMarkers };

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

@@ -0,0 +1,9 @@
+import { FolioAIEditSnapshot } from "./types.js";
+import { Node } from "prosemirror-model";
+
+//#region src/ai-edits/snapshot.d.ts
+declare const normalizeFolioAIBlockText: (text: string) => string;
+declare const hashFolioAIBlockText: (text: string) => string;
+declare const createFolioAIEditSnapshot: (doc: Node) => FolioAIEditSnapshot;
+//#endregion
+export { createFolioAIEditSnapshot, hashFolioAIBlockText, normalizeFolioAIBlockText };