@stll/folio-core 0.59.0 → 0.61.0

package/dist/prosemirror/plugins/templatePreviewValues.js

@@ -1,8 +1,32 @@
+import { createPluginKeyOwner } from "../pluginKeyOwner.js";
 import { scanDirectives } from "./templateDirectives.js";
-import { Plugin, PluginKey } from "prosemirror-state";
+import { Plugin } from "prosemirror-state";
 import { Decoration, DecorationSet } from "prosemirror-view";
 import { isFieldPath } from "@stll/template-conditions";
 //#region src/prosemirror/plugins/templatePreviewValues.ts
+/**
+* Template Preview Values Plugin
+*
+* Live fill preview for template documents: given a map of field path →
+* typed value, every matching `{{path}}` marker is visually replaced by
+* the value — the marker text is hidden by an inline decoration and the
+* value is injected as a widget in its place. The document itself is
+* never modified; clearing the preview restores the markers.
+*
+* The same preview hides conditional blocks the host reports as not
+* applying: `conditions` maps an `{% if expr %}` expression to whether
+* its block applies, and a `false` block is hidden from its opener
+* through its `{% endif %}`. folio evaluates no expression.
+*
+* Two render modes: `highlighted` paints the substituted values with the
+* preview accent so it is unmistakably a preview, and keeps every
+* directive tag visible; `plain` renders the values as ordinary text and
+* drops the tag paragraphs of a block the host has ruled on, so it
+* approximates the generated document rather than the template.
+*
+* Updates are pushed via {@link setTemplatePreviewValues}; the host wires
+* this to its fill inputs.
+*/
 /** Concatenated plain text of a preview value. */
 const templatePreviewValueText = (value) => typeof value === "string" ? value : value.runs.map((run) => run.text).join("");
 /** Stable identity of a preview value (text + formatting), for decoration
@@ -26,9 +50,7 @@ const templatePreviewHidesWholeBlock = (range, block) => range.from <= block.pmS
 const ORIGINAL_CLASS = "folio-template-preview-original";
 /** Hides a conditional block the host reported as not applying. */
 const HIDDEN_CLASS = "folio-template-preview-hidden";
-const KEY_HOLDER_SYMBOL = Symbol.for("stll.folio.templatePreviewValuesKey");
-const keyHolder = globalThis;
-const templatePreviewValuesKey = keyHolder[KEY_HOLDER_SYMBOL] ?? (keyHolder[KEY_HOLDER_SYMBOL] = new PluginKey("templatePreviewValues"));
+const templatePreviewValuesKey = createPluginKeyOwner("templatePreviewValues");
 /** A rich span as DOM: text wrapped in `<em>` / `<strong>` per its flags. */
 function buildSpanNode(span) {
 	let node = document.createTextNode(span.text);
@@ -267,7 +289,7 @@ function buildDecorationSet(doc, { entries, hidden }, mode) {
 }
 function createTemplatePreviewValuesPlugin() {
 	return new Plugin({
-		key: templatePreviewValuesKey,
+		key: templatePreviewValuesKey.createKey(),
 		state: {
 			init() {
 				return {

package/dist/prosemirror/plugins/templateSlashMenu.d.ts

@@ -1,4 +1,4 @@
-import { EditorState, Plugin, PluginKey, Transaction } from "prosemirror-state";
+import { EditorState, Plugin, Transaction } from "prosemirror-state";
 //#region src/prosemirror/plugins/templateSlashMenu.d.ts
 type TemplateSlashMenuState = {
   active: false;
@@ -34,7 +34,13 @@ type TemplateSlashMenuPluginOptions = {
    */
   onKeyAction?: (action: TemplateSlashMenuKeyAction) => boolean;
 };
-declare const templateSlashMenuKey: PluginKey<TemplateSlashMenuState>;
+declare const templateSlashMenuKey: Readonly<{
+  key: string;
+  createKey: () => import("prosemirror-state").PluginKey<TemplateSlashMenuState>;
+  owns: (plugin: Plugin<TemplateSlashMenuState>) => boolean;
+  get: (state: EditorState) => Plugin<TemplateSlashMenuState> | undefined;
+  getState: (state: EditorState) => TemplateSlashMenuState | undefined;
+}>;
 declare const templateSlashMenuPlugin: (options?: TemplateSlashMenuPluginOptions) => Plugin<TemplateSlashMenuState>;
 declare const getTemplateSlashMenu: (state: EditorState) => TemplateSlashMenuState;
 /** Clear the trigger. Set on the host's marker-insert transaction so the

package/dist/prosemirror/plugins/templateSlashMenu.js

@@ -1,6 +1,26 @@
+import { createPluginKeyOwner } from "../pluginKeyOwner.js";
 import { getTemplateDirectives } from "./templateDirectives.js";
-import { Plugin, PluginKey } from "prosemirror-state";
+import { Plugin } from "prosemirror-state";
 //#region src/prosemirror/plugins/templateSlashMenu.ts
+/**
+* Template slash-menu trigger plugin.
+*
+* Watches the template editor for a `/` typed at a marker boundary (start of a
+* text block or right after whitespace) and tracks the query the author types
+* after it. The plugin owns only the *trigger* state — `{active, from, query}` —
+* and the keyboard contract while active; the floating menu UI and the actual
+* marker insertion live in the host (template-studio), which subscribes via
+* {@link TemplateSlashMenuPluginOptions.onChange} and resolves keys via
+* {@link TemplateSlashMenuPluginOptions.onKeyAction}.
+*
+* The trigger guard is deliberately strict so the menu never misfires inside
+* ordinary legal prose: dates (`30/06`), `and/or`, and URLs all have a non-space
+* char before the `/`, so only a leading or post-whitespace `/` opens the menu.
+*
+* Insertion is host-driven: a doc-changing transaction the host dispatches to
+* insert the marker carries a `clear` meta so the plugin tears down without the
+* generic doc-change reset racing the host's selection move.
+*/
 const IDLE = {
 	active: false,
 	from: null,
@@ -8,9 +28,7 @@ const IDLE = {
 	query: ""
 };
 const QUERY_CHAR = /[\p{L}\p{N}_.-]/u;
-const KEY_HOLDER_SYMBOL = Symbol.for("stll.folio.templateSlashMenuKey");
-const keyHolder = globalThis;
-const templateSlashMenuKey = keyHolder[KEY_HOLDER_SYMBOL] ?? (keyHolder[KEY_HOLDER_SYMBOL] = new PluginKey("templateSlashMenu"));
+const templateSlashMenuKey = createPluginKeyOwner("templateSlashMenu");
 /** Whether the char immediately before `pos` is a marker boundary (start of the
 *  text block or whitespace). This is the misfire guard: a `/` mid-token (dates,
 *  URLs, and/or) has a word char before it and never opens the menu. */
@@ -78,7 +96,7 @@ const tryOpenTrigger = (view) => {
 };
 const templateSlashMenuPlugin = (options = {}) => {
 	return new Plugin({
-		key: templateSlashMenuKey,
+		key: templateSlashMenuKey.createKey(),
 		state: {
 			init: () => IDLE,
 			apply: (tr, value, _oldState, newState) => {

package/dist/prosemirror/plugins/transactionInvariants.js

@@ -1,16 +1,41 @@
+import { sliceText } from "../../utils/sliceText.js";
 import { expectParagraphAttrs } from "../attrs/index.js";
 import { effectiveParagraphNumberingReference, paragraphNumberingSourcesFromBoundary } from "../numberingAttr.js";
+import { createPluginKeyOwner } from "../pluginKeyOwner.js";
 import { validateProseMirrorDocument } from "../validation.js";
 import { getDocumentNumbering, hasDocumentNumbering } from "./documentNumbering.js";
-import { Plugin, PluginKey } from "prosemirror-state";
+import { Plugin } from "prosemirror-state";
 //#region src/prosemirror/plugins/transactionInvariants.ts
+/**
+* Transaction invariants: a development and test aid that checks the editor
+* document after every transaction, so a command that leaves a document the
+* save path will refuse fails where it happens rather than at save.
+*
+* Off by default. {@link ExtensionManager} installs it when
+* `globalThis.__folioTransactionInvariants` is `{ enabled: true }` at the time
+* the runtime is initialized; the core test preload sets that flag, which turns
+* every editor test built on the extension manager into a validity check. A
+* host may set it in a development build. Production code never reads it
+* otherwise.
+*
+* The checks are the ones the document-model validator makes that the editor
+* state can answer on its own:
+* - the ProseMirror document is structurally valid (node and mark attributes,
+*   bookmark pairing), incrementally cached per node;
+* - every paragraph numbering reference names an instance the document's
+*   numbering defines.
+*/
 /** Whether new extension-manager runtimes install the invariant plugin. */
 const areTransactionInvariantsEnabled = () => globalThis.__folioTransactionInvariants?.enabled === true;
 const MAX_REPORTED_STEPS_LENGTH = 4e3;
 const describeSteps = (transactions) => {
 	const steps = transactions.flatMap((transaction) => transaction.steps.map((step) => step.toJSON()));
 	const json = JSON.stringify(steps);
-	return json.length > MAX_REPORTED_STEPS_LENGTH ? `${json.slice(0, MAX_REPORTED_STEPS_LENGTH)}… (${json.length} characters)` : json;
+	return json.length > MAX_REPORTED_STEPS_LENGTH ? `${sliceText({
+		text: json,
+		units: "codeUnits",
+		end: MAX_REPORTED_STEPS_LENGTH
+	})}… (${json.length} characters)` : json;
 };
 var TransactionInvariantError = class extends Error {
 	issues;
@@ -69,14 +94,14 @@ const introducedIssues = (before, after, transactions) => {
 		return false;
 	});
 };
-const transactionInvariantsKey = new PluginKey("transactionInvariants");
+const transactionInvariantsKey = createPluginKeyOwner("transactionInvariants");
 /**
 * Throw a {@link TransactionInvariantError} naming the offending steps when a
 * document-changing transaction leaves the state with an issue it did not
 * have before.
 */
 const createTransactionInvariantPlugin = () => new Plugin({
-	key: transactionInvariantsKey,
+	key: transactionInvariantsKey.createKey(),
 	appendTransaction(transactions, oldState, newState) {
 		if (!transactions.some((transaction) => transaction.docChanged)) return null;
 		const issues = checkEditorStateInvariants(newState);

package/dist/prosemirror/replacedAnnotations.d.ts

@@ -19,6 +19,20 @@ declare const NON_INCLUSIVE_MARK_DISPOSITION: {
 };
 /** The mark names in the schema that a replacement must not silently drop. */
 declare const nonInclusiveMarkNames: (schema: Schema) => string[];
+/** One typed point for a comment whose aligned coverage has no content left. */
+declare const commentPoint: (schema: Schema, id: number) => Node;
+type ResolvedCommentPointsOptions = {
+  doc: Node;
+  removes: (node: Node, position: number) => boolean;
+  retiresStructure: (node: Node, position: number) => boolean;
+};
+/** The same collector serves standalone commands and the existing bulk walk. */
+declare const createResolvedCommentPointCollector: ({ removes, retiresStructure }: Omit<ResolvedCommentPointsOptions, "doc">) => {
+  visit: (node: Node, position: number, previous?: Node) => boolean;
+  finish: () => Map<number, number>;
+};
+/** Point fallback excludes comments belonging to retired blocks and table cells. */
+declare const resolvedCommentPoints: ({ doc, removes, retiresStructure }: ResolvedCommentPointsOptions) => Map<number, number>;
 type ReplacedAnnotations = {
   /** Marks the replacement must carry, in document order. */
   carried: readonly Mark[];
@@ -88,4 +102,4 @@ declare const annotatedReplacement: ({ annotations: { carried, leading, trailing
  */
 declare const inheritedReplacementMarks: (doc: Node, from: number, to: number) => readonly Mark[];
 //#endregion
-export { NON_INCLUSIVE_MARK_DISPOSITION, ReplacedAnnotations, addCarriedMarks, annotatedReplacement, commentsAcrossBlockBoundary, commentsForTrackedInsertion, hasReplacedAnnotations, inheritedReplacementMarks, nonInclusiveMarkNames, placeTrackedInsertion, surveyReplacedAnnotations };
+export { NON_INCLUSIVE_MARK_DISPOSITION, ReplacedAnnotations, addCarriedMarks, annotatedReplacement, commentPoint, commentsAcrossBlockBoundary, commentsForTrackedInsertion, createResolvedCommentPointCollector, hasReplacedAnnotations, inheritedReplacementMarks, nonInclusiveMarkNames, placeTrackedInsertion, resolvedCommentPoints, surveyReplacedAnnotations };

package/dist/prosemirror/replacedAnnotations.js

@@ -1,9 +1,11 @@
+import { expectParagraphAttrs, expectTableCellAttrs, expectTableRowAttrs } from "./attrs/index.js";
 import { BOOKMARK_BOUNDARY_NODE_NAME } from "./extensions/nodes/BookmarkBoundaryExtension.js";
 import { COMMENT_REFERENCE_NODE_NAME } from "./extensions/nodes/CommentReferenceExtension.js";
 import { MOVE_RANGE_BOUNDARY_NODE_NAME } from "./extensions/nodes/MoveRangeBoundaryExtension.js";
 import { RANGE_ANCHOR_NODE_NAME } from "./extensions/nodes/RangeAnchorExtension.js";
 import { TEXT_BOX_ANCHOR_NODE_NAME } from "./extensions/nodes/TextBoxAnchorExtension.js";
 import { readMoveRangeBoundaryAttrs } from "./moveRangeBoundaryAttrs.js";
+import { readRangeAnchorAttrs } from "./rangeAnchorAttrs.js";
 import { isZeroWidthAnchor } from "./zeroWidthAnchors.js";
 import { Fragment, Mark } from "prosemirror-model";
 //#region src/prosemirror/replacedAnnotations.ts
@@ -21,15 +23,12 @@ import { Fragment, Mark } from "prosemirror-model";
 * hyperlink simply stops being a link. Zero-width anchors fare worse still: a
 * plain replace deletes them outright.
 *
-* Word moves a range start that sits inside a replaced span to the beginning
-* of the replacement and lets the range keep covering the new text; it keeps
-* a link across a replacement of its display text. A range wholly inside the
-* span collapses onto the replacement, and disappears only when every
-* character it covered is gone. One rule per marker kind, and that is the
-* whole contract:
+* Text replacement preserves a comment's aligned coverage. Unchanged text
+* keeps its ranges; inserted text takes the comments of the replaced aligned
+* span. A range with no remaining content becomes a point at the replacement
+* start. The applier decides alignment once for direct and tracked edits.
 *
-* - `comment` mark: the replacement carries every comment the span covered, so
-*   a range that started inside it starts at the replacement instead.
+* - `comment` mark: carried over its aligned replacement span.
 * - `hyperlink` mark: the replacement carries the first link the span held, so
 *   replacing a link's display text leaves the link on the new text. A span
 *   crossing two links keeps the one it opens in, because the mark excludes
@@ -66,9 +65,8 @@ import { Fragment, Mark } from "prosemirror-model";
 * - every other mark: formatting, and left to boundary inheritance, which
 *   already gives the replacement the formatting of the text it replaces.
 *
-* Deleting the whole of a comment's span leaves it no mark anywhere, so
-* `CommentReferenceExtension` drops the orphan reference and the save drops
-* the comment: the one case where a range is meant to disappear.
+* Removing the owning block removes its comment. Replacing its last covered
+* text within a surviving block retains a point rather than dropping it.
 */
 /**
 * What a replacement does with each mark the schema declares
@@ -90,6 +88,67 @@ const NON_INCLUSIVE_MARK_DISPOSITION = {
 /** The mark names in the schema that a replacement must not silently drop. */
 const nonInclusiveMarkNames = (schema) => Object.entries(schema.marks).filter(([, type]) => type.spec.inclusive === false).map(([name]) => name);
 const isCarried = (mark) => NON_INCLUSIVE_MARK_DISPOSITION[mark.type.name] === "carry";
+/** One typed point for a comment whose aligned coverage has no content left. */
+const commentPoint = (schema, id) => schema.node(RANGE_ANCHOR_NODE_NAME, {
+	start: {
+		type: "commentRangeStart",
+		id
+	},
+	end: {
+		type: "commentRangeEnd",
+		id
+	}
+});
+/** The same collector serves standalone commands and the existing bulk walk. */
+const createResolvedCommentPointCollector = ({ removes, retiresStructure }) => {
+	const points = /* @__PURE__ */ new Map();
+	const retained = /* @__PURE__ */ new Set();
+	const visit = (node, position, previous) => {
+		if (node.type.name === "paragraph") {
+			const mark = expectParagraphAttrs(node).pPrMark;
+			const precedingMark = previous?.type.name === "paragraph" ? expectParagraphAttrs(previous).pPrMark : null;
+			if ((mark?.kind === "del" || mark?.kind === "moveFrom") && retiresStructure(node, position) || (precedingMark?.kind === "del" || precedingMark?.kind === "moveFrom") && previous !== void 0 && retiresStructure(previous, position - previous.nodeSize)) {
+				let survivingContent = false;
+				node.descendants((inline, offset) => {
+					if (inline.isInline && !isZeroWidthAnchor(inline) && !removes(inline, position + 1 + offset)) survivingContent = true;
+					return !survivingContent;
+				});
+				if (!survivingContent) return false;
+			}
+		}
+		if (node.type.name === "tableRow" && expectTableRowAttrs(node).trDel && retiresStructure(node, position)) return false;
+		if ((node.type.name === "tableCell" || node.type.name === "tableHeader") && expectTableCellAttrs(node).cellMarker?.kind === "del" && retiresStructure(node, position)) return false;
+		if (node.type.name === "rangeAnchor") {
+			const attrs = readRangeAnchorAttrs(node);
+			if (attrs.ok && attrs.value.start.type === "commentRangeStart") retained.add(attrs.value.start.id);
+		}
+		if (!node.isInline || isZeroWidthAnchor(node)) return true;
+		for (const mark of node.marks) {
+			if (mark.type.name !== "comment") continue;
+			const id = mark.attrs["commentId"];
+			if (!removes(node, position)) retained.add(id);
+			else if (!points.has(id)) points.set(id, position);
+		}
+		return true;
+	};
+	const finish = () => {
+		for (const id of retained) points.delete(id);
+		return points;
+	};
+	return {
+		visit,
+		finish
+	};
+};
+/** Point fallback excludes comments belonging to retired blocks and table cells. */
+const resolvedCommentPoints = ({ doc, removes, retiresStructure }) => {
+	const collector = createResolvedCommentPointCollector({
+		removes,
+		retiresStructure
+	});
+	doc.descendants((node, position, parent, index) => collector.visit(node, position, index > 0 ? parent?.maybeChild(index - 1) ?? void 0 : void 0));
+	return collector.finish();
+};
 /** Anchors an edit must put back, and where relative to the replacement. */
 const ANCHOR_PLACEMENT = {
 	[COMMENT_REFERENCE_NODE_NAME]: "after",
@@ -349,4 +408,4 @@ const inheritedReplacementMarks = (doc, from, to) => {
 	return (to === from ? $from.marks() : $from.marksAcross(doc.resolve(to))) ?? Mark.none;
 };
 //#endregion
-export { NON_INCLUSIVE_MARK_DISPOSITION, addCarriedMarks, annotatedReplacement, commentsAcrossBlockBoundary, commentsForTrackedInsertion, hasReplacedAnnotations, inheritedReplacementMarks, nonInclusiveMarkNames, placeTrackedInsertion, surveyReplacedAnnotations };
+export { NON_INCLUSIVE_MARK_DISPOSITION, addCarriedMarks, annotatedReplacement, commentPoint, commentsAcrossBlockBoundary, commentsForTrackedInsertion, createResolvedCommentPointCollector, hasReplacedAnnotations, inheritedReplacementMarks, nonInclusiveMarkNames, placeTrackedInsertion, resolvedCommentPoints, surveyReplacedAnnotations };

package/dist/prosemirror/runFormattingReconciliation.d.ts

@@ -9,6 +9,8 @@ type ReadAuthoredRunFormattingOptions = {
 };
 /** Read authored run properties without confusing inherited visuals for direct formatting. */
 declare const readAuthoredRunFormatting: ({ context, marks, styleResolver }: ReadAuthoredRunFormattingOptions) => document_d_exports.TextFormatting;
+/** Preserve the authored distinction between an absent and empty property set in revisions. */
+declare const readAuthoredRunPropertySnapshot: (options: ReadAuthoredRunFormattingOptions) => document_d_exports.TextFormatting | undefined;
 type ReconcileRunFormattingMarksOptions = {
   authoredFormatting: document_d_exports.TextFormatting;
   context: ParagraphRunStyleContext;
@@ -22,4 +24,4 @@ type ReconcileRunFormattingMarksOptions = {
  */
 declare const reconcileRunFormattingMarks: ({ authoredFormatting, context, node, styleResolver }: ReconcileRunFormattingMarksOptions) => readonly Mark[];
 //#endregion
-export { readAuthoredRunFormatting, reconcileRunFormattingMarks };
+export { readAuthoredRunFormatting, readAuthoredRunPropertySnapshot, reconcileRunFormattingMarks };

package/dist/prosemirror/runFormattingReconciliation.js

@@ -1,8 +1,9 @@
 import { mergeTextFormatting } from "../utils/textFormattingMerge.js";
-import { expectCharacterStyleMarkAttrs } from "./attrs/index.js";
+import { expectCharacterStyleMarkAttrs, expectRunIdentityMarkAttrs } from "./attrs/index.js";
 import { textFormattingToMarks } from "./extensions/marks/markUtils.js";
 import { marksToTextFormatting } from "./runFormattingFromMarks.js";
 import { RUN_FORMATTING_MARK_NAMES } from "./runFormattingMarkNames.js";
+import { RUN_IDENTITY_MARK_NAME } from "./runIdentity.js";
 import { getParagraphMarkSuppressionOverrides, hasDirectRunFormatting, isParagraphMarkSuppressionEligible, paragraphFormattingForRun, resolveEffectiveRunStyleFormatting } from "./runStyleFormatting.js";
 import { Mark } from "prosemirror-model";
 //#region src/prosemirror/runFormattingReconciliation.ts
@@ -14,6 +15,13 @@ const readAuthoredRunFormatting = ({ context, marks, styleResolver }) => marksTo
 	paragraphMarkPrecedesStyle: context.paragraphMarkPrecedesStyle,
 	...styleResolver !== void 0 ? { styleResolver } : {}
 });
+/** Preserve the authored distinction between an absent and empty property set in revisions. */
+const readAuthoredRunPropertySnapshot = (options) => {
+	const formatting = readAuthoredRunFormatting(options);
+	if (Object.keys(formatting).length > 0) return formatting;
+	const identity = options.marks.find(({ type }) => type.name === RUN_IDENTITY_MARK_NAME);
+	return identity && expectRunIdentityMarkAttrs(identity).emptyFormatting ? formatting : void 0;
+};
 /**
 * Rebuild a run's physical formatting marks from its authored properties and
 * current style context. This is the inverse of {@link readAuthoredRunFormatting}:
@@ -54,4 +62,4 @@ const reconcileRunFormattingMarks = ({ authoredFormatting, context, node, styleR
 	]);
 };
 //#endregion
-export { readAuthoredRunFormatting, reconcileRunFormattingMarks };
+export { readAuthoredRunFormatting, readAuthoredRunPropertySnapshot, reconcileRunFormattingMarks };

package/dist/prosemirror/runIdentityAcrossRevisions.d.ts

@@ -1,10 +1,8 @@
 import { Node } from "prosemirror-model";
 //#region src/prosemirror/runIdentityAcrossRevisions.d.ts
-/**
- * `nodes`, one inline container's content, with each run a revision cut given
- * the identity of the run it was cut from. A control is a container of its
- * own. `nodes` itself comes back when nothing changes.
- */
-declare const continueRunIdentitiesAcrossRevisions: (nodes: readonly Node[]) => readonly Node[];
+/** The continuation policy covers every declared source-carrier mark. */
+declare const SOURCE_CARRIER_MARK_NAMES: ("hyperlink" | "runIdentity")[];
+/** Every source-carrier family uses the same revision-boundary continuation policy. */
+declare const continueSourceCarrierIdentitiesAcrossRevisions: (nodes: readonly Node[]) => readonly Node[];
 //#endregion
-export { continueRunIdentitiesAcrossRevisions };
+export { SOURCE_CARRIER_MARK_NAMES, continueSourceCarrierIdentitiesAcrossRevisions };

package/dist/prosemirror/runIdentityAcrossRevisions.js

@@ -1,52 +1,73 @@
-import { expectRunIdentityMarkAttrs } from "./attrs/index.js";
+import { expectHyperlinkMarkAttrs, expectRunIdentityMarkAttrs } from "./attrs/index.js";
 import "./extensions/nodes/SdtExtension.js";
 import { RUN_IDENTITY_MARK_NAME } from "./runIdentity.js";
 import { Fragment, Mark } from "prosemirror-model";
 //#region src/prosemirror/runIdentityAcrossRevisions.ts
 /**
-* One run identity for the pieces of a `w:r` a tracked change cut.
-*
-* A revision inside a run splits it: `<w:r a>Sel</w:r><w:del><w:r a>ler</w:r></w:del>`,
-* `<w:r a>Sel</w:r><w:ins>…</w:ins><w:r a>ler</w:r>`, or a `w:rPrChange` on
-* one piece of the run only. Read back, each
-* `w:r` is its own authored run, so resolving the revision would leave two
-* runs where the source had one. The package cannot say whether the two were
-* one run, but runs that carry the same attributes and that only revised
-* content holds apart are what such a cut writes, so the later piece takes the
-* earlier one's identity. The pieces stay separate runs while the revision
-* holds them apart, and become one run once it is resolved and they state the
-* same properties again (a run joins its owner only then, see `fromProseDoc`).
-*
-* Runs the package writes side by side under the same revision state keep
-* their own identities.
+* One source identity for matching runs and hyperlinks a revision cut apart.
+* Serialized fragments mint separate identities on reopen. Matching fragments
+* across a revision boundary or revised-only bridge take the earlier identity,
+* so resolution can rejoin them. Every non-identity attribute must match.
+* Adjacent carriers under the same revision state keep their source identities.
 */
 const REVISION_MARK_NAMES = /* @__PURE__ */ new Set([
 	"insertion",
 	"deletion",
 	"runPropertyChange"
 ]);
-const identityOf = (node) => node.marks.find((mark) => mark.type.name === RUN_IDENTITY_MARK_NAME);
+const CARRIER_OWNERS = [{
+	markName: RUN_IDENTITY_MARK_NAME,
+	read: (mark) => {
+		const attrs = expectRunIdentityMarkAttrs(mark);
+		return {
+			id: attrs.id,
+			payloadKey: JSON.stringify({
+				...attrs,
+				id: 0
+			})
+		};
+	}
+}, {
+	markName: "hyperlink",
+	read: (mark) => {
+		const attrs = expectHyperlinkMarkAttrs(mark);
+		if (typeof attrs._docxHyperlinkIndex !== "number") return void 0;
+		return {
+			id: attrs._docxHyperlinkIndex,
+			payloadKey: JSON.stringify({
+				...attrs,
+				_docxHyperlinkIndex: 0
+			})
+		};
+	}
+}];
+/** The continuation policy covers every declared source-carrier mark. */
+const SOURCE_CARRIER_MARK_NAMES = CARRIER_OWNERS.map(({ markName }) => markName);
+const identityOf = (node, owner) => {
+	const mark = node.marks.find((candidate) => candidate.type.name === owner.markName);
+	if (!mark) return void 0;
+	const identity = owner.read(mark);
+	return identity === void 0 ? void 0 : {
+		mark,
+		...identity
+	};
+};
 const revisionMarksOf = (node) => node.marks.filter((mark) => REVISION_MARK_NAMES.has(mark.type.name));
-/** The identity's attrs without the id: what the run carries. */
-const payloadKey = (identity) => JSON.stringify({
-	...expectRunIdentityMarkAttrs(identity),
-	id: 0
-});
 /** Whether `right` continues `left`'s run across a revision boundary. */
-const continuesRun = ({ left, right, bridged }) => {
-	const leftIdentity = identityOf(left);
-	const rightIdentity = identityOf(right);
-	if (!leftIdentity || !rightIdentity || leftIdentity.eq(rightIdentity)) return false;
-	return (bridged || !Mark.sameSet(revisionMarksOf(left), revisionMarksOf(right))) && payloadKey(leftIdentity) === payloadKey(rightIdentity);
+const continuesCarrier = ({ left, right, bridged, owner }) => {
+	const leftIdentity = identityOf(left, owner);
+	const rightIdentity = identityOf(right, owner);
+	if (!leftIdentity || !rightIdentity || leftIdentity.mark.eq(rightIdentity.mark)) return false;
+	return (bridged || !Mark.sameSet(revisionMarksOf(left), revisionMarksOf(right))) && leftIdentity.payloadKey === rightIdentity.payloadKey;
 };
 /**
-* `nodes`, one inline container's content, with each run a revision cut given
-* the identity of the run it was cut from. A control is a container of its
+* `nodes`, one inline container's content, with each revision fragment given
+* the identity of its matching source carrier. A control is a container of its
 * own. `nodes` itself comes back when nothing changes.
 */
-const continueRunIdentitiesAcrossRevisions = (nodes) => {
+const continueIdentities = (nodes, owner) => {
 	const renamed = /* @__PURE__ */ new Map();
-	/** The last run with an identity, while only revised content follows it. */
+	/** The last carrier with an identity, while only revised content follows it. */
 	let anchor;
 	let bridged = false;
 	let changed = false;
@@ -57,25 +78,26 @@ const continueRunIdentitiesAcrossRevisions = (nodes) => {
 			node.forEach((child) => {
 				children.push(child);
 			});
-			const continued = continueRunIdentitiesAcrossRevisions(children);
+			const continued = continueIdentities(children, owner);
 			if (continued === children) return node;
 			changed = true;
 			return node.copy(Fragment.fromArray([...continued]));
 		}
-		const identity = identityOf(node);
+		const identity = identityOf(node, owner);
 		if (!identity) {
 			if (anchor && revisionMarksOf(node).length > 0) bridged = true;
 			else anchor = void 0;
 			return node;
 		}
-		const id = expectRunIdentityMarkAttrs(identity).id;
+		const id = identity.id;
 		let replacement = renamed.get(id);
-		if (!replacement && anchor && continuesRun({
+		if (!replacement && anchor && continuesCarrier({
 			left: anchor,
 			right: node,
-			bridged
+			bridged,
+			owner
 		})) {
-			replacement = identityOf(anchor);
+			replacement = identityOf(anchor, owner)?.mark;
 			if (replacement) renamed.set(id, replacement);
 		}
 		const next = replacement ? node.mark(replacement.addToSet(node.marks)) : node;
@@ -86,5 +108,11 @@ const continueRunIdentitiesAcrossRevisions = (nodes) => {
 	});
 	return changed ? result : nodes;
 };
+/** Every source-carrier family uses the same revision-boundary continuation policy. */
+const continueSourceCarrierIdentitiesAcrossRevisions = (nodes) => {
+	let continued = nodes;
+	for (const owner of CARRIER_OWNERS) continued = continueIdentities(continued, owner);
+	return continued;
+};
 //#endregion
-export { continueRunIdentitiesAcrossRevisions };
+export { SOURCE_CARRIER_MARK_NAMES, continueSourceCarrierIdentitiesAcrossRevisions };

package/dist/prosemirror/runPropertyChangeResolution.js

@@ -1,6 +1,8 @@
+import { expectRunIdentityMarkAttrs } from "./attrs/index.js";
 import { runFormattingInlineAtomDisposition } from "./runFormattingInlineCarriers.js";
 import { RUN_FORMATTING_MARK_NAMES } from "./runFormattingMarkNames.js";
 import { readAuthoredRunFormatting, reconcileRunFormattingMarks } from "./runFormattingReconciliation.js";
+import { RUN_IDENTITY_MARK_NAME, runIdentityAttrs } from "./runIdentity.js";
 //#region src/prosemirror/runPropertyChangeResolution.ts
 /**
 * Rebuild the pre-change run marks against the paragraph's live style cascade.
@@ -8,12 +10,22 @@ import { readAuthoredRunFormatting, reconcileRunFormattingMarks } from "./runFor
 * owner so their reject semantics cannot diverge at the bulk threshold.
 */
 const reconstructRejectedRunFormattingMarks = ({ node, paragraphContext, previousFormatting, styleResolver }) => {
-	return reconcileRunFormattingMarks({
+	const formatting = reconcileRunFormattingMarks({
 		authoredFormatting: previousFormatting ?? {},
 		context: paragraphContext,
 		node,
 		...styleResolver !== void 0 ? { styleResolver } : {}
 	}).filter(({ type }) => RUN_FORMATTING_MARK_NAMES.has(type.name));
+	if (previousFormatting === void 0 || Object.keys(previousFormatting).length > 0) return formatting;
+	const identityType = node.type.schema.marks[RUN_IDENTITY_MARK_NAME];
+	if (!identityType) return formatting;
+	const identity = node.marks.find(({ type }) => type === identityType);
+	const attrs = identity ? expectRunIdentityMarkAttrs(identity) : void 0;
+	return [...formatting, identityType.create(runIdentityAttrs(attrs?.id ?? 0, {
+		preservedAttributes: attrs?.preservedAttributes ?? void 0,
+		preserved: attrs?.preserved ?? void 0,
+		emptyFormatting: true
+	}))];
 };
 /** Restored deletions inherit the live paragraph cascade without authoring their historical visuals. */
 const restoreHistoricalRunFormatting = ({ node, paragraphContext, styleResolver }) => {

package/dist/utils/base64.d.ts

@@ -1,35 +1,5 @@
+import { bytesToBase64, encodeBase64Portable } from "@stll/utf8-boundaries";
 //#region src/utils/base64.d.ts
-/**
- * The package's one bytes-to-base64 encoder.
- *
- * Every call site that spelled this itself got a different answer to the same
- * two questions, and one of them got the first question wrong:
- *
- * - `btoa(new TextDecoder("latin1").decode(bytes))` is not a binary string.
- *   The Encoding standard maps the `latin1` label to windows-1252, so bytes
- *   0x80-0x9F decode to characters outside Latin-1 and `btoa` throws
- *   `InvalidCharacterError` on them. Ordinary image bytes contain those values,
- *   so the browser path of that spelling fails on real input.
- * - `String.fromCharCode(...chunk)` is correct but spreads a chunk's worth of
- *   arguments per call, and the intermediate binary string is as large as the
- *   input.
- *
- * Neither question has to be asked per call site, so it is asked here once.
- * The runtime's own encoder answers it when the runtime has one, and the
- * portable encoder below answers it when not; both produce canonical base64,
- * so the choice is invisible in the output.
- */
-/**
- * Encode into exactly one intermediate buffer: ASCII codes are written into a
- * single array and decoded once, so a megabyte-scale input leaves the output
- * string and nothing else.
- *
- * Exported because the runtimes the tests run on all carry a native encoder,
- * and the fallback is the branch the browsers that lack one take.
- */
-declare const encodeBase64Portable: (bytes: Uint8Array) => string;
-/** Encode bytes as canonical, padded, standard-alphabet base64. */
-declare const bytesToBase64: (bytes: Uint8Array) => string;
 /** Encode bytes as a `data:` URL with the given media type. */
 declare const bytesToDataUrl: (bytes: Uint8Array, mimeType: string) => string;
 //#endregion