@stll/folio-core 0.63.0 → 0.64.0

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

@@ -11,6 +11,7 @@ import { FolioReviewChange, FolioReviewChangeKind } from "./read.js";
 import { FolioStoryTable } from "./snapshot.js";
 import { TableGeometryPairing } from "./table-geometry.js";
 import { Node } from "prosemirror-model";
+import { TaggedErrorClass } from "better-result";
 //#region src/ai-edits/headless.d.ts
 /** Options for {@link FolioDocxReviewer.fromBuffer}. */
 export type FolioDocxReviewerOptions = {
@@ -134,13 +135,13 @@ export type FolioReviewedStory = {
   text: string;
   changes: FolioReviewChange[];
 };
-declare const UnsupportedFolioReviewedViewError_base: import("better-result").TaggedErrorClass<"UnsupportedFolioReviewedViewError">;
-export declare class UnsupportedFolioReviewedViewError extends UnsupportedFolioReviewedViewError_base<{
+declare const UnsupportedFolioReviewedViewErrorBase: TaggedErrorClass<"UnsupportedFolioReviewedViewError">;
+export declare class UnsupportedFolioReviewedViewError extends UnsupportedFolioReviewedViewErrorBase<{
   message: string;
   receivedView: unknown;
 }> {}
-declare const FolioDocumentStoryNotFoundError_base: import("better-result").TaggedErrorClass<"FolioDocumentStoryNotFoundError">;
-export declare class FolioDocumentStoryNotFoundError extends FolioDocumentStoryNotFoundError_base<{
+declare const FolioDocumentStoryNotFoundErrorBase: TaggedErrorClass<"FolioDocumentStoryNotFoundError">;
+export declare class FolioDocumentStoryNotFoundError extends FolioDocumentStoryNotFoundErrorBase<{
   message: string;
   story: FolioEditableDocumentStoryHandle;
 }> {}

package/dist/ai-edits/headless.js

@@ -12,7 +12,6 @@ import { isSeparatorEndnote, isSeparatorFootnote } from "../docx/footnoteParser.
 import { normalizeListModelRendering } from "../docx/listModelNormalization.js";
 import { createNumberingIdAllocator } from "../docx/numberingIds.js";
 import { getCachedNumberingMap } from "../docx/numberingParser.js";
-import { recreateProseNodeWithParagraphPropertySource, transferProseParagraphPropertySource } from "../docx/paragraphPropertySource.js";
 import { visitDocxParagraphs } from "../docx/paragraphTraversal.js";
 import { parseDocx } from "../docx/parser.js";
 import { createReply } from "../docx/replyToComment.js";
@@ -30,6 +29,7 @@ import { allocateCommentId, createCommentIdAllocator, seedCommentAllocator } fro
 import { fromProseDoc, proseDocToBlocks } from "../prosemirror/conversion/fromProseDoc.js";
 import { footnoteToProseDoc, headerFooterToProseDoc, toProseDoc } from "../prosemirror/conversion/toProseDoc.js";
 import { ensureBaseDirectionInState } from "../prosemirror/extensions/features/AutoBidiDetectionExtension.js";
+import { ensureParaIdsInDoc } from "../prosemirror/extensions/features/ParaIdAllocatorExtension.js";
 import { getChangedParagraphIds, getTrackedSectionEndpointRemoval, hasStructuralChanges, hasUntrackedChanges } from "../prosemirror/extensions/features/ParagraphChangeTrackerExtension.js";
 import { completeNumberingForDoc } from "../prosemirror/listInstanceReferences.js";
 import "../prosemirror/listMarker.js";
@@ -42,7 +42,6 @@ import { sectionPropertiesOf } from "../prosemirror/sectionCarrier.js";
 import { storyListNumbering } from "../prosemirror/storyListNumbering.js";
 import { collapseEmptyTextBoxHosts } from "../prosemirror/textBoxHostCollapse.js";
 import { canonicalJson } from "../utils/canonicalJson.js";
-import { deterministicHexId } from "../utils/hexId.js";
 import { buildAnnotatedBlockTextWithNoteReferences } from "./clean-text.js";
 import { anchoredCommentIdsInBlocks, anchoredCommentIdsInProseDoc, coveredCommentIdsInProseDoc, withoutLostCommentThreads } from "./comment-lifecycle.js";
 import { noteReferenceEditsAllowed } from "./note-references.js";
@@ -55,7 +54,6 @@ import { matchTableGeometry } from "./table-geometry.js";
 import { tableTemplateCanCrossPackageLosslessly } from "./table-template.js";
 import { TaggedError, panic } from "better-result";
 import { REVIEW_CARRIERS, finalizeParagraphFormatting, numberingLevelEntries, setDocumentBodyComments } from "@stll/docx-core/model";
-import { Fragment } from "prosemirror-model";
 import { reconcileDocumentPartRelationships } from "@stll/docx-core/ops";
 import { EditorState } from "prosemirror-state";
 import JSZip from "jszip";
@@ -87,79 +85,24 @@ const createReviewerComment = ({ id, text, author, date }) => ({
 	date: date ?? (/* @__PURE__ */ new Date()).toISOString(),
 	content: [commentTextParagraph(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.
-*
-* Rebuilding only the changed branches, like {@link ensureParaIdsInDoc}, keeps
-* the pass linear in paragraph count. Seeding through a transaction instead
-* costs one `setNodeMarkup` step per paragraph, and both halves of that are
-* quadratic: every step rebuilds the containing fragment, and the plugin
-* `appendTransaction` chain rescans the accumulated step maps. Because the pass
-* runs before the state exists, no history, mapping, or change-tracking
-* semantics depend on it.
-*/
-const ensureDeterministicParaIdsInDoc = (doc) => {
-	const seen = /* @__PURE__ */ new Set();
-	let ordinal = 0;
-	const rewrite = (parent) => {
-		let changed = false;
-		const children = [];
-		parent.forEach((child) => {
-			let next = child;
-			if (child.type.name === "paragraph") {
-				ordinal += 1;
-				const existing = child.attrs["paraId"];
-				if (typeof existing === "string" && existing.length > 0 && !seen.has(existing)) seen.add(existing);
-				else {
-					let paraId = deterministicHexId(`${child.textContent}:${ordinal}`);
-					for (let salt = 1; seen.has(paraId); salt++) paraId = deterministicHexId(`${child.textContent}:${ordinal}:${salt}`);
-					seen.add(paraId);
-					next = recreateProseNodeWithParagraphPropertySource(child, { attrs: {
-						...child.attrs,
-						paraId,
-						idStability: "positional"
-					} });
-				}
-				const paraId = next.attrs["paraId"];
-				if (typeof paraId === "string") transferProseParagraphPropertySource(next, child, paraId);
-			} else if (child.childCount > 0) {
-				const content = rewrite(child);
-				if (content !== child.content) next = recreateProseNodeWithParagraphPropertySource(child, { content });
-			}
-			if (next !== child) changed = true;
-			children.push(next);
-		});
-		return changed ? Fragment.fromArray(children) : parent.content;
-	};
-	const content = rewrite(doc);
-	return content === doc.content ? doc : recreateProseNodeWithParagraphPropertySource(doc, { content });
-};
 const FOLIO_REVIEWED_VIEWS = Object.freeze([
 	"original",
 	"current-markup",
 	"final"
 ]);
 const FOLIO_RESOLVED_REVIEWED_VIEWS = Object.freeze(["original", "final"]);
-var UnsupportedFolioReviewedViewError = class extends TaggedError("UnsupportedFolioReviewedViewError") {};
-var FolioDocumentStoryNotFoundError = class extends TaggedError("FolioDocumentStoryNotFoundError") {};
+const UnsupportedFolioReviewedViewErrorBase = TaggedError("UnsupportedFolioReviewedViewError");
+var UnsupportedFolioReviewedViewError = class extends UnsupportedFolioReviewedViewErrorBase {};
+const FolioDocumentStoryNotFoundErrorBase = TaggedError("FolioDocumentStoryNotFoundError");
+var FolioDocumentStoryNotFoundError = class extends FolioDocumentStoryNotFoundErrorBase {};
 const FOLIO_RESOLVED_STORY_SERIALIZATION_MISMATCHES = Object.freeze({
 	storyMissing: "story-missing",
 	revisionMarkupRemains: "revision-markup-remains",
 	textProjection: "text-projection",
 	blockProjection: "block-projection"
 });
-var FolioResolvedStorySerializationError = class extends TaggedError("FolioResolvedStorySerializationError") {};
+const FolioResolvedStorySerializationErrorBase = TaggedError("FolioResolvedStorySerializationError");
+var FolioResolvedStorySerializationError = class extends FolioResolvedStorySerializationErrorBase {};
 /** Blocks whose id folio minted, because the package names no id for them. */
 const mintedBlockOrdinals = (snapshot) => {
 	const ordinals = /* @__PURE__ */ new Set();
@@ -660,7 +603,7 @@ var FolioDocxReviewer = class FolioDocxReviewer {
 		const plugins = createHeadlessPlugins(baseDocument.package.styles, baseDocument.package.numbering);
 		const state = ensureBaseDirectionInState(EditorState.create({
 			schema,
-			doc: ensureDeterministicParaIdsInDoc(toProseDoc(baseDocument)),
+			doc: ensureParaIdsInDoc(toProseDoc(baseDocument)),
 			plugins
 		}));
 		return new FolioDocxReviewer({
@@ -1999,7 +1942,7 @@ var FolioDocxReviewer = class FolioDocxReviewer {
 			...this.baseDocument.package.theme !== void 0 && { theme: this.baseDocument.package.theme }
 		};
 		const storyDoc = story.type === "header" || story.type === "footer" ? headerFooterToProseDoc(source.content, conversionOptions) : footnoteToProseDoc(source.content, conversionOptions);
-		return ensureDeterministicParaIdsInDoc(storyDoc);
+		return ensureParaIdsInDoc(storyDoc);
 	}
 	requireEditableStoryState(story) {
 		const state = this.getEditableStoryState(story);
@@ -2093,7 +2036,7 @@ var FolioDocxReviewer = class FolioDocxReviewer {
 		(story.type === "header" ? this.importedHeaders : this.importedFooters).set(relationshipId, empty);
 		const state = ensureBaseDirectionInState(EditorState.create({
 			schema,
-			doc: ensureDeterministicParaIdsInDoc(headerFooterToProseDoc(empty.content)),
+			doc: ensureParaIdsInDoc(headerFooterToProseDoc(empty.content)),
 			plugins: createHeadlessPlugins(this.baseDocument.package.styles, this.baseDocument.package.numbering)
 		}));
 		this.secondaryStoryStates.set(headerFooterStoryKey(handle), {

package/dist/compare/content.d.ts

@@ -1,7 +1,7 @@
 import { FolioContentBlock, FolioContentBlockIdentity, FolioContentFormatRange, FolioContentIdStability, FolioContentParagraphIndentation, FolioContentParagraphSpacing, FolioContentSnapshot, FolioContentStatedNumbering } from "./content-types.js";
 import { WordDiffGranularity, createWordDiffSession } from "../ai-edits/word-diff.js";
 import { FolioContentAlignmentStep, FolioContentAlignmentWorkSession } from "./content-alignment.js";
-import { Result } from "better-result";
+import { Result, TaggedErrorClass } from "better-result";
 //#region src/compare/content.d.ts
 /** Hard resource ceilings for one representation-neutral comparison. */
 export declare const FOLIO_CONTENT_COMPARISON_LIMITS: Readonly<{
@@ -17,15 +17,15 @@ export declare const FOLIO_CONTENT_COMPARISON_LIMITS: Readonly<{
   readonly attributeCodeUnitsPerSnapshot: 8000000;
 }>;
 export type FolioContentComparisonLimit = keyof typeof FOLIO_CONTENT_COMPARISON_LIMITS;
-declare const InvalidFolioContentComparisonError_base: import("better-result").TaggedErrorClass<"InvalidFolioContentComparisonError">;
-export declare class InvalidFolioContentComparisonError extends InvalidFolioContentComparisonError_base<{
+declare const InvalidFolioContentComparisonErrorBase: TaggedErrorClass<"InvalidFolioContentComparisonError">;
+export declare class InvalidFolioContentComparisonError extends InvalidFolioContentComparisonErrorBase<{
   message: string;
   input: "options" | "base" | "revised";
   blockIndex?: number;
   field: string;
 }> {}
-declare const FolioContentComparisonLimitError_base: import("better-result").TaggedErrorClass<"FolioContentComparisonLimitError">;
-export declare class FolioContentComparisonLimitError extends FolioContentComparisonLimitError_base<{
+declare const FolioContentComparisonLimitErrorBase: TaggedErrorClass<"FolioContentComparisonLimitError">;
+export declare class FolioContentComparisonLimitError extends FolioContentComparisonLimitErrorBase<{
   message: string;
   input: "base" | "revised" | "result";
   limit: FolioContentComparisonLimit;
@@ -34,8 +34,8 @@ export declare class FolioContentComparisonLimitError extends FolioContentCompar
   blockIndex?: number;
   field?: string;
 }> {}
-declare const FolioContentInlinePresentationProjectionError_base: import("better-result").TaggedErrorClass<"FolioContentInlinePresentationProjectionError">;
-export declare class FolioContentInlinePresentationProjectionError extends FolioContentInlinePresentationProjectionError_base<{
+declare const FolioContentInlinePresentationProjectionErrorBase: TaggedErrorClass<"FolioContentInlinePresentationProjectionError">;
+export declare class FolioContentInlinePresentationProjectionError extends FolioContentInlinePresentationProjectionErrorBase<{
   message: string;
   side: "base" | "revised" | "both";
   baseBlockId: string;

package/dist/compare/content.js

@@ -43,9 +43,12 @@ const MOVE_SIMILARITY_THRESHOLD = .8;
 const MAX_MOVE_PROFILE_TOKENS = 16384;
 /** Bound source code units copied into one edited-move token profile. */
 const MAX_MOVE_PROFILE_CODE_UNITS = 1048576;
-var InvalidFolioContentComparisonError = class extends TaggedError("InvalidFolioContentComparisonError") {};
-var FolioContentComparisonLimitError = class extends TaggedError("FolioContentComparisonLimitError") {};
-var FolioContentInlinePresentationProjectionError = class extends TaggedError("FolioContentInlinePresentationProjectionError") {};
+const InvalidFolioContentComparisonErrorBase = TaggedError("InvalidFolioContentComparisonError");
+var InvalidFolioContentComparisonError = class extends InvalidFolioContentComparisonErrorBase {};
+const FolioContentComparisonLimitErrorBase = TaggedError("FolioContentComparisonLimitError");
+var FolioContentComparisonLimitError = class extends FolioContentComparisonLimitErrorBase {};
+const FolioContentInlinePresentationProjectionErrorBase = TaggedError("FolioContentInlinePresentationProjectionError");
+var FolioContentInlinePresentationProjectionError = class extends FolioContentInlinePresentationProjectionErrorBase {};
 /** Authored outline identity, including the distinction between heading and body text. */
 const sameFolioContentOutlineLevel = (left, right) => left?.kind === right?.kind && (left?.kind !== "heading" || right?.kind === "heading" && left.level === right.level);
 const createContentComparisonWorkSession = (granularity) => ({

package/dist/compare/types.d.ts

@@ -3,7 +3,12 @@ import { FolioAIBlockParagraphProperties, FolioAIBlockTableLocation, FolioAIEdit
 import { WordDiffGranularity } from "../ai-edits/word-diff.js";
 import { FolioDocumentStoryHandle, FolioNumberingLevel } from "../ai-edits/headless.js";
 import { CompareVerification, CompareVerificationCause, CompareVerificationFailure, CompareVerificationInvariant, FinalParagraphMarkRevision } from "./verification.js";
+import { TaggedErrorClass } from "better-result";
 //#region src/compare/types.d.ts
+declare const CompareDocxFinalParagraphMarkErrorBase: TaggedErrorClass<"CompareDocxFinalParagraphMarkError">;
+declare const CompareDocxOperationLimitErrorBase: TaggedErrorClass<"CompareDocxOperationLimitError">;
+declare const CompareDocxRoundTripErrorBase: TaggedErrorClass<"CompareDocxRoundTripError">;
+declare const CompareDocxApplyErrorBase: TaggedErrorClass<"CompareDocxApplyError">;
 /** Revision encoding requested for the generated package. */
 export declare const COMPARE_REVISION_FORMATS: readonly ["word", "folio-exact"];
 export type CompareRevisionFormat = (typeof COMPARE_REVISION_FORMATS)[number];
@@ -264,36 +269,34 @@ export type CompareResult = {
   compatibility: CompareCompatibility;
   unsupported: readonly CompareUnsupportedPart[];
 };
-declare const InvalidCompareDocxOptionsError_base: import("better-result").TaggedErrorClass<"InvalidCompareDocxOptionsError">;
-export declare class InvalidCompareDocxOptionsError extends InvalidCompareDocxOptionsError_base<{
+declare const InvalidCompareDocxOptionsErrorBase: TaggedErrorClass<"InvalidCompareDocxOptionsError">;
+export declare class InvalidCompareDocxOptionsError extends InvalidCompareDocxOptionsErrorBase<{
   message: string;
   option: "timestamp" | "revisionFormat";
   receivedValue: unknown;
 }> {}
-declare const CompareDocxParseError_base: import("better-result").TaggedErrorClass<"CompareDocxParseError">;
-export declare class CompareDocxParseError extends CompareDocxParseError_base<{
+declare const CompareDocxParseErrorBase: TaggedErrorClass<"CompareDocxParseError">;
+export declare class CompareDocxParseError extends CompareDocxParseErrorBase<{
   message: string;
   side: "base" | "target";
   cause: unknown;
 }> {}
-declare const CompareDocxApplyError_base: import("better-result").TaggedErrorClass<"CompareDocxApplyError">;
 /**
  * The applier refused at least one derived operation, so accepting the result
  * would not reproduce the target. Reported instead of returning a package that
  * silently under-represents the difference.
  */
-export declare class CompareDocxApplyError extends CompareDocxApplyError_base<{
+export declare class CompareDocxApplyError extends CompareDocxApplyErrorBase<{
   message: string;
   skipped: readonly FolioAIEditSkippedOperation[];
 }> {}
-declare const CompareDocxRoundTripError_base: import("better-result").TaggedErrorClass<"CompareDocxRoundTripError">;
 /**
  * The generated tracked changes do not accept back to the target. Raised by
  * the self-check {@link compareDocx} runs before returning: a redline that
  * quietly loses part of the difference is worse than no redline, so the
  * mismatch is surfaced instead of the document.
  */
-export declare class CompareDocxRoundTripError extends CompareDocxRoundTripError_base<{
+export declare class CompareDocxRoundTripError extends CompareDocxRoundTripErrorBase<{
   message: string;
   story: FolioDocumentStoryHandle;
   /** The invariant that did not hold, and what diverged under it. */
@@ -307,14 +310,13 @@ export declare class CompareDocxRoundTripError extends CompareDocxRoundTripError
    */
   failures: readonly CompareVerificationFailure[];
 }> {}
-declare const CompareDocxOperationLimitError_base: import("better-result").TaggedErrorClass<"CompareDocxOperationLimitError">;
 /** The difference needs more operations than the engine will generate. */
-export declare class CompareDocxOperationLimitError extends CompareDocxOperationLimitError_base<{
+export declare class CompareDocxOperationLimitError extends CompareDocxOperationLimitErrorBase<{
   message: string;
   limit: number;
 }> {}
-declare const CompareDocxSerializeError_base: import("better-result").TaggedErrorClass<"CompareDocxSerializeError">;
-export declare class CompareDocxSerializeError extends CompareDocxSerializeError_base<{
+declare const CompareDocxSerializeErrorBase: TaggedErrorClass<"CompareDocxSerializeError">;
+export declare class CompareDocxSerializeError extends CompareDocxSerializeErrorBase<{
   message: string;
   cause: unknown;
 }> {}
@@ -326,7 +328,6 @@ export declare class CompareDocxSerializeError extends CompareDocxSerializeError
  * every distinct save failure into a single undiagnosable row.
  */
 export declare const compareDocxSerializeError: (context: string, cause: unknown) => CompareDocxSerializeError;
-declare const CompareDocxFinalParagraphMarkError_base: import("better-result").TaggedErrorClass<"CompareDocxFinalParagraphMarkError">;
 /**
  * A container's final paragraph mark carries a revision, so the package would
  * not open, or would open carrying one no reader can resolve.
@@ -338,7 +339,7 @@ declare const CompareDocxFinalParagraphMarkError_base: import("better-result").T
  * under either `onUnverified` setting: there is no redline to emit when a
  * consumer refuses the file.
  */
-export declare class CompareDocxFinalParagraphMarkError extends CompareDocxFinalParagraphMarkError_base<{
+export declare class CompareDocxFinalParagraphMarkError extends CompareDocxFinalParagraphMarkErrorBase<{
   message: string;
   /** Every container that carries one, each named structurally. */
   revisions: readonly FinalParagraphMarkRevision[];

package/dist/compare/types.js

@@ -4,6 +4,10 @@ import { TaggedError } from "better-result";
 * Public vocabulary of {@link ./compare.compareDocx}: the change list, the
 * options that pin its output, and the failures it reports.
 */
+const CompareDocxFinalParagraphMarkErrorBase = TaggedError("CompareDocxFinalParagraphMarkError");
+const CompareDocxOperationLimitErrorBase = TaggedError("CompareDocxOperationLimitError");
+const CompareDocxRoundTripErrorBase = TaggedError("CompareDocxRoundTripError");
+const CompareDocxApplyErrorBase = TaggedError("CompareDocxApplyError");
 /** Revision encoding requested for the generated package. */
 const COMPARE_REVISION_FORMATS = ["word", "folio-exact"];
 /** Why a part of the package is absent from `changes`. */
@@ -13,24 +17,27 @@ const COMPARE_UNSUPPORTED_REASONS = Object.freeze([
 	"story-not-editable",
 	"unsupported-content"
 ]);
-var InvalidCompareDocxOptionsError = class extends TaggedError("InvalidCompareDocxOptionsError") {};
-var CompareDocxParseError = class extends TaggedError("CompareDocxParseError") {};
+const InvalidCompareDocxOptionsErrorBase = TaggedError("InvalidCompareDocxOptionsError");
+var InvalidCompareDocxOptionsError = class extends InvalidCompareDocxOptionsErrorBase {};
+const CompareDocxParseErrorBase = TaggedError("CompareDocxParseError");
+var CompareDocxParseError = class extends CompareDocxParseErrorBase {};
 /**
 * The applier refused at least one derived operation, so accepting the result
 * would not reproduce the target. Reported instead of returning a package that
 * silently under-represents the difference.
 */
-var CompareDocxApplyError = class extends TaggedError("CompareDocxApplyError") {};
+var CompareDocxApplyError = class extends CompareDocxApplyErrorBase {};
 /**
 * The generated tracked changes do not accept back to the target. Raised by
 * the self-check {@link compareDocx} runs before returning: a redline that
 * quietly loses part of the difference is worse than no redline, so the
 * mismatch is surfaced instead of the document.
 */
-var CompareDocxRoundTripError = class extends TaggedError("CompareDocxRoundTripError") {};
+var CompareDocxRoundTripError = class extends CompareDocxRoundTripErrorBase {};
 /** The difference needs more operations than the engine will generate. */
-var CompareDocxOperationLimitError = class extends TaggedError("CompareDocxOperationLimitError") {};
-var CompareDocxSerializeError = class extends TaggedError("CompareDocxSerializeError") {};
+var CompareDocxOperationLimitError = class extends CompareDocxOperationLimitErrorBase {};
+const CompareDocxSerializeErrorBase = TaggedError("CompareDocxSerializeError");
+var CompareDocxSerializeError = class extends CompareDocxSerializeErrorBase {};
 /**
 * A serialize failure whose message names the reason.
 *
@@ -53,6 +60,6 @@ const compareDocxSerializeError = (context, cause) => new CompareDocxSerializeEr
 * under either `onUnverified` setting: there is no redline to emit when a
 * consumer refuses the file.
 */
-var CompareDocxFinalParagraphMarkError = class extends TaggedError("CompareDocxFinalParagraphMarkError") {};
+var CompareDocxFinalParagraphMarkError = class extends CompareDocxFinalParagraphMarkErrorBase {};
 //#endregion
 export { COMPARE_REVISION_FORMATS, COMPARE_UNSUPPORTED_REASONS, CompareDocxApplyError, CompareDocxFinalParagraphMarkError, CompareDocxOperationLimitError, CompareDocxParseError, CompareDocxRoundTripError, CompareDocxSerializeError, InvalidCompareDocxOptionsError, compareDocxSerializeError };

package/dist/content-controls/errors.d.ts

@@ -1,18 +1,20 @@
 import { document_d_exports } from "../types/document.js";
+import { TaggedErrorClass } from "better-result";
 //#region src/content-controls/errors.d.ts
-declare const ContentControlLockedError_base: import("better-result").TaggedErrorClass<"ContentControlLockedError">;
+declare const ContentControlTypeErrorBase: TaggedErrorClass<"ContentControlTypeError">;
+declare const ContentControlBoundErrorBase: TaggedErrorClass<"ContentControlBoundError">;
+declare const ContentControlLockedErrorBase: TaggedErrorClass<"ContentControlLockedError">;
 /**
  * Refused because the target control's `w:lock` forbids the requested
  * mutation. Caller can override with `{ force: true }` if they understand
  * the consequences (overrides apply per call, not per document).
  */
-export declare class ContentControlLockedError extends ContentControlLockedError_base<{
+export declare class ContentControlLockedError extends ContentControlLockedErrorBase<{
   message: string;
   lock: NonNullable<document_d_exports.SdtProperties["lock"]>;
   tag?: string;
   alias?: string;
 }> {}
-declare const ContentControlBoundError_base: import("better-result").TaggedErrorClass<"ContentControlBoundError">;
 /**
  * Refused because the target control is bound to a `<w:dataBinding>`.
  *
@@ -27,20 +29,19 @@ declare const ContentControlBoundError_base: import("better-result").TaggedError
  * Reference: python-docx #965, Aspose forum thread on removing custom
  * XML mapping before content updates.
  */
-export declare class ContentControlBoundError extends ContentControlBoundError_base<{
+export declare class ContentControlBoundError extends ContentControlBoundErrorBase<{
   message: string;
   xpath: string;
   storeItemID?: string;
   tag?: string;
   alias?: string;
 }> {}
-declare const ContentControlTypeError_base: import("better-result").TaggedErrorClass<"ContentControlTypeError">;
 /**
  * Refused because the requested operation does not make sense for the
  * control's type — e.g. setting free text on a checkbox, or unwrapping a
  * `w15:repeatingSection` (which would orphan its row items).
  */
-export declare class ContentControlTypeError extends ContentControlTypeError_base<{
+export declare class ContentControlTypeError extends ContentControlTypeErrorBase<{
   message: string;
   sdtType: document_d_exports.SdtProperties["sdtType"];
   reason: string;

package/dist/content-controls/errors.js

@@ -5,12 +5,15 @@ import { TaggedError } from "better-result";
 * refuses a mutation throws one of these; consumers can either bubble the
 * error or retry with `{ force: true }`.
 */
+const ContentControlTypeErrorBase = TaggedError("ContentControlTypeError");
+const ContentControlBoundErrorBase = TaggedError("ContentControlBoundError");
+const ContentControlLockedErrorBase = TaggedError("ContentControlLockedError");
 /**
 * Refused because the target control's `w:lock` forbids the requested
 * mutation. Caller can override with `{ force: true }` if they understand
 * the consequences (overrides apply per call, not per document).
 */
-var ContentControlLockedError = class extends TaggedError("ContentControlLockedError") {};
+var ContentControlLockedError = class extends ContentControlLockedErrorBase {};
 /**
 * Refused because the target control is bound to a `<w:dataBinding>`.
 *
@@ -25,12 +28,12 @@ var ContentControlLockedError = class extends TaggedError("ContentControlLockedE
 * Reference: python-docx #965, Aspose forum thread on removing custom
 * XML mapping before content updates.
 */
-var ContentControlBoundError = class extends TaggedError("ContentControlBoundError") {};
+var ContentControlBoundError = class extends ContentControlBoundErrorBase {};
 /**
 * Refused because the requested operation does not make sense for the
 * control's type — e.g. setting free text on a checkbox, or unwrapping a
 * `w15:repeatingSection` (which would orphan its row items).
 */
-var ContentControlTypeError = class extends TaggedError("ContentControlTypeError") {};
+var ContentControlTypeError = class extends ContentControlTypeErrorBase {};
 //#endregion
 export { ContentControlBoundError, ContentControlLockedError, ContentControlTypeError };

package/dist/controller/canonicalComments.d.ts

@@ -1,10 +1,11 @@
 import { document_d_exports } from "../types/document.js";
 import { CANONICAL_GAP } from "../types/canonicalCapabilities.js";
 import { Comment } from "../types/content.js";
+import { Err, Ok, TaggedErrorClass } from "better-result";
 import { CreateCommentOp, DocumentOp } from "@stll/docx-core/ops";
 //#region src/controller/canonicalComments.d.ts
-declare const CanonicalCommentError_base: import("better-result").TaggedErrorClass<"CanonicalCommentError">;
-export declare class CanonicalCommentError extends CanonicalCommentError_base<{
+declare const CanonicalCommentErrorBase: TaggedErrorClass<"CanonicalCommentError">;
+export declare class CanonicalCommentError extends CanonicalCommentErrorBase<{
   message: string;
   gap: typeof CANONICAL_GAP.comments;
 }> {}
@@ -31,7 +32,7 @@ type CompileCanonicalCommentsOptions = {
   document: document_d_exports.Document;
   command: CanonicalCommentCommand;
 };
-export declare const compileCanonicalComments: ({ document, command }: CompileCanonicalCommentsOptions) => import("better-result").Err<never, CanonicalCommentError> | import("better-result").Ok<{
+export declare const compileCanonicalComments: ({ document, command }: CompileCanonicalCommentsOptions) => Err<never, CanonicalCommentError> | Ok<{
   ops: DocumentOp[];
   document: document_d_exports.Document;
   commentId: number | undefined;

package/dist/controller/canonicalComments.js

@@ -4,7 +4,8 @@ import { Result, TaggedError } from "better-result";
 import { DOCUMENT_OP_TYPES, allocateCommentAnchorIds, applyDocumentOps, packageParagraphIds } from "@stll/docx-core/ops";
 //#region src/controller/canonicalComments.ts
 /** The one semantic compiler for canonical sidebar, controlled and public comments. */
-var CanonicalCommentError = class extends TaggedError("CanonicalCommentError") {};
+const CanonicalCommentErrorBase = TaggedError("CanonicalCommentError");
+var CanonicalCommentError = class extends CanonicalCommentErrorBase {};
 const refuse = (message) => Result.err(new CanonicalCommentError({
 	message,
 	gap: CANONICAL_GAP.comments

package/dist/controller/canonicalInlineProjection.d.ts

@@ -1,6 +1,6 @@
 import { document_d_exports } from "../types/document.js";
 import { Node } from "prosemirror-model";
-import { Result } from "better-result";
+import { Result, TaggedErrorClass } from "better-result";
 //#region src/controller/canonicalInlineProjection.d.ts
 export declare const CANONICAL_SOURCE_INLINE_POLICIES: {
   readonly run: "container";
@@ -62,8 +62,8 @@ export declare const CANONICAL_NATIVE_INLINE_POLICIES: {
   readonly renderedPageBreak: "refused";
   readonly sdt: "refused";
 };
-declare const InlineProjectionError_base: import("better-result").TaggedErrorClass<"InlineProjectionError">;
-declare class InlineProjectionError extends InlineProjectionError_base<{
+declare const InlineProjectionErrorBase: TaggedErrorClass<"InlineProjectionError">;
+declare class InlineProjectionError extends InlineProjectionErrorBase<{
   message: string;
 }> {}
 /** Every source variant makes a decision before conversion can discard its positions. */

package/dist/controller/canonicalInlineProjection.js

@@ -72,7 +72,8 @@ const CANONICAL_NATIVE_INLINE_POLICIES = {
 	sdt: "refused"
 };
 const nativePolicies = new Map(Object.entries(CANONICAL_NATIVE_INLINE_POLICIES));
-var InlineProjectionError = class extends TaggedError("InlineProjectionError") {};
+const InlineProjectionErrorBase = TaggedError("InlineProjectionError");
+var InlineProjectionError = class extends InlineProjectionErrorBase {};
 const refuse = (message) => Result.err(new InlineProjectionError({ message }));
 /** Every source variant makes a decision before conversion can discard its positions. */
 const canonicalInlineSourceIssue = (items, context = "paragraph") => {

package/dist/controller/canonicalListRendering.d.ts

@@ -1,7 +1,9 @@
+import { DocumentOp } from "./canonicalOperations.js";
+import { Document } from "@stll/docx-core";
 //#region src/controller/canonicalListRendering.d.ts
 /** Canonical edits share list model normalization with the headless projection. */
-export declare const normalizeCanonicalListRendering: (document: import("@stll/docx-core").Document) => {
-  document: import("@stll/docx-core").Document;
-  inverse: import("@stll/docx-core/ops").DocumentOp[];
+export declare const normalizeCanonicalListRendering: (document: Document) => {
+  document: Document;
+  inverse: DocumentOp[];
 };
 //#endregion

package/dist/controller/canonicalPublicOperations.js

@@ -96,7 +96,8 @@ const compilePublicIntents = ({ document, intents, mode, author, date, nextRevis
 		nextRevisionId
 	});
 };
-var CanonicalPublicOperationResolutionError = class extends TaggedError("CanonicalPublicOperationResolutionError") {};
+const CanonicalPublicOperationResolutionErrorBase = TaggedError("CanonicalPublicOperationResolutionError");
+var CanonicalPublicOperationResolutionError = class extends CanonicalPublicOperationResolutionErrorBase {};
 const canonicalPublicStory = (story) => {
 	if (story === "main") return story;
 	switch (story.type) {

package/dist/controller/canonicalSession.d.ts

@@ -4,11 +4,11 @@ import { CanonicalSaveSnapshot } from "../types/canonicalSave.js";
 import { CanonicalInlineGap } from "./canonicalInlineProjection.js";
 import { Node } from "prosemirror-model";
 import { EditorState, Transaction } from "prosemirror-state";
-import { Result } from "better-result";
+import { Err, Ok, Result, TaggedErrorClass } from "better-result";
 import { DocumentOp, EditorIntent, OpStory, TextPosition, TouchedBlocks } from "@stll/docx-core/ops";
 //#region src/controller/canonicalSession.d.ts
-declare const CanonicalSessionError_base: import("better-result").TaggedErrorClass<"CanonicalSessionError">;
-export declare class CanonicalSessionError extends CanonicalSessionError_base<{
+declare const CanonicalSessionErrorBase: TaggedErrorClass<"CanonicalSessionError">;
+export declare class CanonicalSessionError extends CanonicalSessionErrorBase<{
   message: string;
   gap: CanonicalGap;
   reason: "refused" | "noChange";
@@ -76,7 +76,7 @@ type PublishCanonicalProjectionOptions = {
   session: CanonicalSession;
 };
 /** The model publishes only after PM and every plugin accept its exact projection. */
-export declare const publishCanonicalProjection: ({ state, commit, session }: PublishCanonicalProjectionOptions) => import("better-result").Err<never, CanonicalSessionError> | import("better-result").Ok<{
+export declare const publishCanonicalProjection: ({ state, commit, session }: PublishCanonicalProjectionOptions) => Err<never, CanonicalSessionError> | Ok<{
   state: EditorState;
   transactions: readonly Transaction[];
 }, never>;
@@ -120,7 +120,7 @@ declare class CanonicalSession {
   private readonly styles;
   constructor({ document, projection, styles }: CanonicalSessionSeedOptions);
   /** Render only the committed comment projection while provisional IME blocks document snapshots. */
-  getCommittedComments(): import("@stll/docx-core/model").Comment[];
+  getCommittedComments(): document_d_exports.Comment[];
   setMode(mode: CanonicalSessionMode): void;
   hasStyle(styleId: string): boolean;
   private advanceBlockId;

package/dist/controller/canonicalSession.js

@@ -19,7 +19,8 @@ import { CellSelection } from "prosemirror-tables";
 import { DOCUMENT_OP_REFUSAL_REASONS, DOCUMENT_OP_TYPES, OP_STORIES, applyDocumentOp, applyDocumentOps, combineEdits, commentDocumentIssue, compileEditorIntent, createEditorIntentIdAllocator, documentStories, editorParagraphGroups, findStoryBody, normalizeForOps, packageParagraphIds, paragraphIdsIn, sameStory, survivingComments, validateOpsDocument } from "@stll/docx-core/ops";
 import { AllSelection, NodeSelection, Selection, TextSelection } from "prosemirror-state";
 //#region src/controller/canonicalSession.ts
-var CanonicalSessionError = class extends TaggedError("CanonicalSessionError") {};
+const CanonicalSessionErrorBase = TaggedError("CanonicalSessionError");
+var CanonicalSessionError = class extends CanonicalSessionErrorBase {};
 const refuse = (message) => Result.err(new CanonicalSessionError({
 	gap: CANONICAL_GAP.dispatch,
 	message,

package/dist/controller/hiddenEditorManager.d.ts

@@ -6,13 +6,14 @@ import { HiddenEditorStateReason } from "../layout-engine/layoutInstrumentation.
 import { ExtensionManager } from "../prosemirror/extensions/ExtensionManager.js";
 import { RemoteSelection } from "../types/remote-selection.js";
 import { EditorState, Plugin, Transaction } from "prosemirror-state";
+import { TaggedErrorClass } from "better-result";
 import { EditorView } from "prosemirror-view";
 import * as Yjs from "yjs";
 import { XmlFragment } from "yjs";
 import * as YProseMirror from "y-prosemirror";
 //#region src/controller/hiddenEditorManager.d.ts
-declare const CanonicalSessionRefusalError_base: import("better-result").TaggedErrorClass<"CanonicalSessionRefusalError">;
-export declare class CanonicalSessionRefusalError extends CanonicalSessionRefusalError_base<{
+declare const CanonicalSessionRefusalErrorBase: TaggedErrorClass<"CanonicalSessionRefusalError">;
+export declare class CanonicalSessionRefusalError extends CanonicalSessionRefusalErrorBase<{
   gap: CanonicalGap;
   message: string;
 }> {}

package/dist/controller/hiddenEditorManager.js

@@ -33,7 +33,8 @@ import { OP_STORIES, freshCommentId } from "@stll/docx-core/ops";
 import { EditorState, Plugin } from "prosemirror-state";
 import { EditorView } from "prosemirror-view";
 //#region src/controller/hiddenEditorManager.ts
-var CanonicalSessionRefusalError = class extends TaggedError("CanonicalSessionRefusalError") {};
+const CanonicalSessionRefusalErrorBase = TaggedError("CanonicalSessionRefusalError");
+var CanonicalSessionRefusalError = class extends CanonicalSessionRefusalErrorBase {};
 const normalizeSeedState = (state) => ensureBaseDirectionInState(ensureParaIdsInState(state));
 const normalizeLocalSeedState = (state) => ensureBaseDirectionInState(state);
 const isObjectRecord = (value) => typeof value === "object" && value !== null;