@portabletext/markdown 2.0.0 → 2.2.0

package/dist/index.js

@@ -1,10 +1,36 @@
+import { cleanupEfficiency, makeDiff } from "@sanity/diff-match-patch";
 import { compileSchema, defineSchema, isSpan, isTextBlock, isTypedObject } from "@portabletext/schema";
-import { buildMarksTree, isPortableTextBlock, isPortableTextListItemBlock, isPortableTextToolkitSpan, isPortableTextToolkitTextNode, spanToPlainText } from "@portabletext/toolkit";
-import { alert } from "@mdit/plugin-alert";
+import { buildMarksTree, isPortableTextBlock, isPortableTextListItemBlock, isPortableTextSpan, isPortableTextToolkitSpan, isPortableTextToolkitTextNode, spanToPlainText } from "@portabletext/toolkit";
+import LinkifyIt from "linkify-it";
 import markdownit from "markdown-it";
+import { alert } from "@mdit/plugin-alert";
 function defaultKeyGenerator() {
 	return randomKey(12);
 }
+/**
+* Wraps a caller-supplied key generator so one conversion can never
+* mint the same key twice. Keys attach content to its identity at
+* creation time (a span's `marks` entry points at the mark definition
+* minted with the same key), so a generator that repeats a key does
+* not just violate sibling uniqueness, it makes ownership ambiguous in
+* a way no later pass can repair: two definitions sharing a key leave
+* every referencing span attributable to either. Bounded retries, then
+* deterministic suffixing, mirroring how sibling-uniqueness repair
+* treats a generator that keeps returning claimed keys.
+*/
+function uniqueKeyGenerator(generator) {
+	let mintedKeys = /* @__PURE__ */ new Set();
+	return () => {
+		let candidate = generator();
+		for (let attempt = 0; attempt < 3 && mintedKeys.has(candidate); attempt++) candidate = generator();
+		if (mintedKeys.has(candidate)) {
+			let base = candidate, suffix = 2;
+			for (; mintedKeys.has(`${base}-${suffix}`);) suffix++;
+			candidate = `${base}-${suffix}`;
+		}
+		return mintedKeys.add(candidate), candidate;
+	};
+}
 const getByteHexTable = (() => {
 	let table;
 	return () => {
@@ -91,27 +117,431 @@ function buildListIndexMap(blocks) {
 		listDepthMap
 	};
 }
-const createRenderNode = (renderers, listIndexMap, listDepthMap) => {
-	function renderNode(options) {
-		let { node, index, isInline } = options;
-		return isPortableTextListItemBlock(node) ? renderListItem(node, index) : isPortableTextToolkitSpan(node) ? renderSpan(node) : isPortableTextBlock(node) ? renderBlock(node, index, isInline) : isPortableTextToolkitTextNode(node) ? renderText(node) : renderCustomBlock(node, index, isInline);
+/**
+* The CommonMark ASCII punctuation set. Only these characters can be
+* backslash-escaped into a literal without changing the parsed text.
+*/
+const ASCII_PUNCTUATION = /[!-/:-@[-`{-~]/, ENTITY_REFERENCE = /&(?:[a-zA-Z][a-zA-Z0-9]*|#[0-9]+|#[xX][0-9a-fA-F]+);/g, BACKSLASH_BEFORE_PUNCTUATION = RegExp(`\\\\(?=${ASCII_PUNCTUATION.source})`, "g"), TILDE_RUN = /~{2,}/g, HTML_LIKE_ANGLE_BRACKET = /<(?=[a-zA-Z/!?])/g, BRACKET_BEFORE_LINK_OPEN = /\](?=[([])/g, UNICODE_PUNCTUATION_OR_SYMBOL = /^(?:\p{P}|\p{S})$/u, linkify = new LinkifyIt();
+/**
+* Plans the escaped replacement for every plain-text leaf a block's children
+* will produce, in the exact left-to-right order `renderText` visits them
+* (mirroring `buildMarksTree`'s own `text.split('\n')` leaf splitting).
+*
+* Escaping runs ahead of rendering, over the flat span sequence: some
+* hazards only exist across a leaf boundary (an ordered-list marker, a
+* ref-def label, an emphasis run) because an annotation or decorator mark
+* that introduces no markup of its own splices its children in seamlessly.
+* The plan works line by line (a block's children joined into text, split
+* at hard breaks) rather than leaf by leaf: each line's leaves are joined
+* into one string first, opaque children (inline objects, or leaves a
+* custom renderer will replace) masked with a sentinel that can't match any
+* hazard, and every hazard - inline and line-start alike - is detected once
+* against that real, complete line, with true left/right context on both
+* sides. Detected hazards become position-tracked edits against the line's
+* raw text, which are then split back into each contributing leaf's own
+* escaped text; only that composition step is leaf-scoped.
+*
+* A joined line's text that markdown-it's own linkify pass (bundled as
+* `linkify-it`) would claim as a bare URL or email is masked from most
+* edits: the linkify carve-out promises that substring round-trips
+* byte-identical, gaining only a link mark, so escaping inside it would
+* corrupt text linkify is about to claim as a link's visible text. An
+* entity-reference or backtick escape is never masked (see `computeLinkifyMask`
+* for why), and a claim spliced across a decorator boundary is never masked
+* in the first place.
+*
+* `isHeading` is set for ATX headings: only the first joined line sits
+* inside the `# ` prefix an ATX heading can never be reparsed as a block
+* construct within, so line-leading hazards are skipped there; a hard
+* break's later lines are ordinary markdown lines and get the full
+* line-start battery. That first line carries a line-*end* hazard of its
+* own instead: a trailing `#`-run reads back as the heading's own optional
+* closing sequence.
+*
+* `isListItem` is set when the block renders as list-item content: a
+* `[ ] `/`[x] `/`[X] ` at the very start of the first joined line reads
+* back as a GFM task-list checkbox, regardless of the list's own item type.
+*
+* `hardBreakOutputHasNewline` says whether the renderer's actual hard-break
+* output contains a newline. A custom `hardBreak` can render to something
+* with no newline of its own (eg `() => '<br />'`), in which case the
+* leaves on either side of it land on the same rendered line, not two: a
+* hard break like that can't be planned as a line boundary, so it's walled
+* off as an opaque segment instead, the same protection an inline object's
+* unknown rendered text already gets.
+*/
+function planLeafEscaping(children, markDefs, options) {
+	let linkMarkKeys = new Set(markDefs.filter((def) => def._type === "link").map((def) => def._key)), markDefKeys = new Set(markDefs.map((def) => def._key)), pieces = [];
+	for (let child of children) if (isPortableTextSpan(child)) {
+		let isLinkLabel = (child.marks ?? []).some((mark) => linkMarkKeys.has(mark)), markSignature = (child.marks ?? []).filter((mark) => !markDefKeys.has(mark)).sort().join(",");
+		child.text.split("\n").forEach((line, index) => {
+			index > 0 && pieces.push(options.hardBreakOutputHasNewline ? { kind: "hardBreak" } : { kind: "opaque" }), pieces.push({
+				kind: "text",
+				raw: line,
+				isLinkLabel,
+				markSignature
+			});
+		});
+	} else pieces.push({ kind: "opaque" });
+	let pieceOutputs = pieces.map(() => ""), lineIndex = 0, lineText = "", lineChars = [], lineIsLinkLabelChar = [], lineMarkSignature = [], flushLine = () => {
+		processLine({
+			text: lineText,
+			chars: lineChars,
+			isLinkLabelChar: lineIsLinkLabelChar,
+			markSignature: lineMarkSignature,
+			lineIndex,
+			isHeading: options.isHeading,
+			isListItem: options.isListItem,
+			pieceOutputs
+		}), lineIndex++, lineText = "", lineChars = [], lineIsLinkLabelChar = [], lineMarkSignature = [];
+	};
+	for (let pieceIndex = 0; pieceIndex < pieces.length; pieceIndex++) {
+		let piece = pieces[pieceIndex];
+		if (!piece || piece.kind === "hardBreak") {
+			flushLine();
+			continue;
+		}
+		if (piece.kind === "opaque") {
+			lineText += "\0", lineChars.push(null), lineIsLinkLabelChar.push(!1), lineMarkSignature.push("");
+			continue;
+		}
+		let prepared = piece.isLinkLabel ? escapeLinkLabelBrackets(piece.raw) : piece.raw;
+		for (let offset = 0; offset < prepared.length; offset++) lineText += prepared[offset], lineChars.push({
+			pieceIndex,
+			offset
+		}), lineIsLinkLabelChar.push(piece.isLinkLabel), lineMarkSignature.push(piece.markSignature);
 	}
-	function renderListItem(node, index) {
-		let renderer = renderers.listItem, itemHandler = (typeof renderer == "function" ? renderer : renderer[node.listItem]) || renderers.unknownListItem, children = buildMarksTree(node).map((child, i) => renderNode({
+	flushLine();
+	let escaped = [];
+	return pieces.forEach((piece, index) => {
+		piece.kind === "text" && escaped.push(pieceOutputs[index] ?? "");
+	}), escaped;
+}
+function processLine(args) {
+	let { text, chars, isLinkLabelChar, markSignature, pieceOutputs } = args, linkifyMask = computeLinkifyMask(text, chars, isLinkLabelChar, markSignature);
+	applyEdits(text, chars, [...collectInlineEdits(text, isLinkLabelChar), ...collectLineStartEdits(text, args)].filter((edit) => edit.bypassLinkifyMask || !isMasked(edit, linkifyMask)), pieceOutputs);
+}
+/**
+* Marks every character of this line that markdown-it's linkify pass would
+* claim as part of a bare URL or email. Link-label and opaque characters
+* are blanked out first: a link label's visible text sits inside `[...]`
+* markup real linkify never reconsiders, and an opaque child's rendered
+* text is unknown at plan time, so neither should join or seed a match.
+*
+* The probe only sees this line's raw, undecoded text, one hazard pass
+* ahead of markdown-it's own pipeline: it runs linkify against inline
+* tokenization and entity decoding, not before them. A claim survives only
+* if it lies entirely inside one run of identical decorator marks: a
+* decorator boundary crossing it splices that decorator's delimiters
+* (`**`, `` ` ``, ...) into the middle of the range real linkify would see,
+* which breaks the very claim being trusted. An annotation-only boundary
+* (a link's own label text is already excluded above; any other
+* annotation type falls back to rendering with no delimiters at all,
+* same as an unregistered decorator) never splices, so it can't invalidate
+* a claim either.
+*/
+function computeLinkifyMask(text, chars, isLinkLabelChar, markSignature) {
+	let mask = Array(text.length).fill(!1);
+	if (!/[.:@]/.test(text)) return mask;
+	let probe = "";
+	for (let index = 0; index < text.length; index++) probe += chars[index] === null || isLinkLabelChar[index] ? " " : text[index];
+	let matches = linkify.match(probe) ?? [];
+	for (let match of matches) {
+		if (match.schema === "") continue;
+		let signature = markSignature[match.index], staysWithinOneMarkRun = !0;
+		for (let index = match.index; index < match.lastIndex; index++) if (markSignature[index] !== signature) {
+			staysWithinOneMarkRun = !1;
+			break;
+		}
+		if (staysWithinOneMarkRun) for (let index = match.index; index < match.lastIndex; index++) mask[index] = !0;
+	}
+	return mask;
+}
+function isMasked(edit, mask) {
+	let end = edit.at + Math.max(edit.deleteCount, 1);
+	for (let index = edit.at; index < end; index++) if (mask[index]) return !0;
+	return !1;
+}
+/** Rewrites a line's raw text into each contributing leaf's escaped text by
+* walking it once, left to right, applying at most one edit per position.
+* Every hazard is keyed off its own trigger character - a backslash, a
+* tilde, a backtick, an `&`, a `<`, a `*`/`_`, a `]`, or (line-start only,
+* one hazard per line) a `#`, `>`, `[`, `-`/`+`/`*`, the `.`/`)` after an
+* ordered-list marker's digits, `=`, 4 spaces, or a tab - and no two of
+* those characters coincide at one position, so two edits can never target
+* the same position. */
+function applyEdits(text, chars, edits, pieceOutputs) {
+	let editsByPosition = /* @__PURE__ */ new Map();
+	for (let edit of edits) {
+		if (editsByPosition.has(edit.at)) throw Error(`Two hazard edits targeted the same position (${edit.at}); hazard trigger characters are assumed disjoint by construction.`);
+		editsByPosition.set(edit.at, edit);
+	}
+	let index = 0;
+	for (; index < text.length;) {
+		let edit = editsByPosition.get(index), owner = chars[index];
+		if (edit && (owner && (pieceOutputs[owner.pieceIndex] = (pieceOutputs[owner.pieceIndex] ?? "") + edit.insert), edit.deleteCount > 0)) {
+			index += edit.deleteCount;
+			continue;
+		}
+		owner && (pieceOutputs[owner.pieceIndex] = (pieceOutputs[owner.pieceIndex] ?? "") + (text[index] ?? "")), index++;
+	}
+}
+/**
+* Hazards that can appear anywhere on a line: emphasis/strikethrough runs,
+* a backtick, an entity reference, an HTML/autolink-shaped `<`, a literal
+* backslash before punctuation, and a `]` immediately before `(`/`[`
+* (which would otherwise read back as a link/image open).
+*/
+function collectInlineEdits(text, isLinkLabelChar) {
+	let edits = [];
+	for (let match of text.matchAll(BACKSLASH_BEFORE_PUNCTUATION)) {
+		let at = match.index ?? 0;
+		isLinkLabelChar[at] || edits.push({
+			at,
+			deleteCount: 0,
+			insert: "\\"
+		});
+	}
+	for (let match of text.matchAll(TILDE_RUN)) {
+		let start = match.index ?? 0;
+		for (let index = start; index < start + match[0].length; index++) edits.push({
+			at: index,
+			deleteCount: 0,
+			insert: "\\"
+		});
+	}
+	for (let index = 0; index < text.length; index++) text[index] === "`" && edits.push({
+		at: index,
+		deleteCount: 0,
+		insert: "\\",
+		bypassLinkifyMask: !0
+	});
+	for (let match of text.matchAll(ENTITY_REFERENCE)) edits.push({
+		at: match.index ?? 0,
+		deleteCount: 0,
+		insert: "\\",
+		bypassLinkifyMask: !0
+	});
+	for (let match of text.matchAll(HTML_LIKE_ANGLE_BRACKET)) edits.push({
+		at: match.index ?? 0,
+		deleteCount: 0,
+		insert: "\\"
+	});
+	edits.push(...collectEmphasisEdits(text));
+	for (let match of text.matchAll(BRACKET_BEFORE_LINK_OPEN)) {
+		let at = match.index ?? 0;
+		isLinkLabelChar[at] || edits.push({
+			at,
+			deleteCount: 0,
+			insert: "\\"
+		});
+	}
+	return edits;
+}
+function isWhitespace(char) {
+	return char === void 0 || /\s/.test(char);
+}
+function isPunctuation(char) {
+	return char !== void 0 && UNICODE_PUNCTUATION_OR_SYMBOL.test(char);
+}
+/**
+* The full code point sitting immediately before `index`: two UTF-16 code
+* units for an astral character (eg an emoji) whose low surrogate lands at
+* `index - 1`, one otherwise.
+*/
+function codePointBefore(text, index) {
+	if (!(index <= 0)) return index >= 2 && isLowSurrogate(text[index - 1]) && isHighSurrogate(text[index - 2]) ? text.slice(index - 2, index) : text[index - 1];
+}
+/**
+* The full code point sitting immediately at `index`: two UTF-16 code units
+* for an astral character whose high surrogate lands at `index`, one
+* otherwise.
+*/
+function codePointAt(text, index) {
+	if (!(index >= text.length)) return isHighSurrogate(text[index]) && isLowSurrogate(text[index + 1]) ? text.slice(index, index + 2) : text[index];
+}
+function isHighSurrogate(char) {
+	if (char === void 0) return !1;
+	let code = char.charCodeAt(0);
+	return code >= 55296 && code <= 56319;
+}
+function isLowSurrogate(char) {
+	if (char === void 0) return !1;
+	let code = char.charCodeAt(0);
+	return code >= 56320 && code <= 57343;
+}
+function isLeftFlanking(before, after) {
+	return isWhitespace(after) ? !1 : !isPunctuation(after) || isWhitespace(before) || isPunctuation(before);
+}
+function isRightFlanking(before, after) {
+	return isWhitespace(before) ? !1 : !isPunctuation(before) || isWhitespace(after) || isPunctuation(after);
+}
+/**
+* Finds `*`/`_` runs CommonMark would treat as flanking delimiters, using
+* each run's true neighbors on the joined line (the start/end of the line
+* itself counts as whitespace, matching the spec's treatment of line
+* boundaries).
+*/
+function collectEmphasisEdits(text) {
+	let edits = [], index = 0;
+	for (; index < text.length;) {
+		let char = text[index];
+		if (char !== "*" && char !== "_") {
+			index++;
+			continue;
+		}
+		let end = index;
+		for (; end < text.length && text[end] === char;) end++;
+		let before = codePointBefore(text, index), after = codePointAt(text, end), leftFlanking = isLeftFlanking(before, after), rightFlanking = isRightFlanking(before, after), canOpen = char === "_" ? leftFlanking && (!rightFlanking || isPunctuation(before)) : leftFlanking, canClose = char === "_" ? rightFlanking && (!leftFlanking || isPunctuation(after)) : rightFlanking;
+		if (canOpen || canClose) for (let position = index; position < end; position++) edits.push({
+			at: position,
+			deleteCount: 0,
+			insert: "\\"
+		});
+		index = end;
+	}
+	return edits;
+}
+/**
+* Hazards that only matter at the start (or, for a handful of whole-line
+* constructs, the start *and* end) of a line: headings, blockquotes, list
+* markers, ref-defs, setext underlines, thematic breaks, indented code, and
+* a list item's own GFM task-checkbox prefix. A fence needs no branch of
+* its own here: the inline backtick/tilde escaping every line already
+* neutralizes the run a fence needs, so it can never open one on reparse.
+* The remaining branches are mutually exclusive by construction
+* (each targets a disjoint leading character) and return as soon as one
+* matches, mirroring how CommonMark itself commits to one block-start
+* interpretation per line; the checkbox branch above is the one exception,
+* since a list item's checkbox prefix and, say, its heading marker are two
+* independent hazards that can both apply to the same first line.
+*/
+function collectLineStartEdits(text, context) {
+	let edits = [], isFirstLine = context.lineIndex === 0, leadingSpaces = /^ {0,3}/.exec(text)?.[0].length ?? 0, rest = text.slice(leadingSpaces);
+	if (context.isListItem && isFirstLine && /^\[[ xX]\] /.test(rest) && edits.push({
+		at: leadingSpaces,
+		deleteCount: 0,
+		insert: "\\"
+	}), context.isHeading && isFirstLine) {
+		let closingSequence = /^(?:(.*[ \t]))?(#+[ \t]*)$/.exec(text);
+		return closingSequence && edits.push({
+			at: closingSequence[1]?.length ?? 0,
+			deleteCount: 0,
+			insert: "\\"
+		}), edits;
+	}
+	let orderedListMarker = /^ {0,3}(\d{1,9})([.)])(?=[ \t]|$)/.exec(text);
+	if (orderedListMarker) return edits.push({
+		at: orderedListMarker[0].length - 1,
+		deleteCount: 0,
+		insert: "\\"
+	}), edits;
+	if (/^#{1,6}(?:[ \t]|$)/.test(rest) || rest.startsWith(">") || /^\[[^\]\n]*\]:/.test(rest) || /^[-+*](?:[ \t]|$)/.test(rest) || /^ {0,3}([-*_])(?:[ \t]*\1){2,}[ \t]*$/.test(text) || /^ {0,3}=+[ \t]*$/.test(text) || /^ {0,3}-+[ \t]*$/.test(text)) return edits.push({
+		at: leadingSpaces,
+		deleteCount: 0,
+		insert: "\\"
+	}), edits;
+	if (/^ {4}/.test(text)) return edits.push({
+		at: 0,
+		deleteCount: 1,
+		insert: "&#32;"
+	}), edits;
+	let tabIndent = /^ {0,3}\t/.exec(text);
+	return tabIndent && edits.push({
+		at: tabIndent[0].length - 1,
+		deleteCount: 1,
+		insert: "&#9;"
+	}), edits;
+}
+/**
+* Text rendered inside a link label needs every `[`, `]` and `\` escaped
+* unconditionally, on top of the general-purpose hazard escaping every
+* line gets: a link label must stay bracket-balanced, and any literal
+* backslash in it needs protecting regardless of what follows (unlike
+* plain text, where only a backslash immediately before punctuation is a
+* hazard).
+*/
+function escapeLinkLabelBrackets(text) {
+	return text.replace(/[[\]\\]/g, (char) => `\\${char}`);
+}
+/**
+* Blocks currently known to be a list item's first content block: it shares
+* its first line with the list marker (and, for a task item, its GFM
+* checkbox), which changes how `renderBlock` plans line-start hazard
+* escaping. Internal to this package so the signal never reaches the
+* public `Serializable`/`RenderNode` types a custom renderer's `.d.ts`
+* would otherwise expose it through.
+*
+* A block is marked right before rendering it; the `renderNode` call that
+* dispatches to `renderBlock` consumes the membership on the way past so a
+* later, unrelated render of the same object (still possible - `renderNode`
+* accepts any `TypedObject`) doesn't inherit a stale claim.
+*/
+const listItemFirstBlocks = /* @__PURE__ */ new WeakSet();
+function markListItemFirstBlock(block) {
+	listItemFirstBlocks.add(block);
+}
+function consumeListItemFirstBlock(block) {
+	let isListItemFirstBlock = listItemFirstBlocks.has(block);
+	return listItemFirstBlocks.delete(block), isListItemFirstBlock;
+}
+/**
+* ATX headings are single-line, inline-only leaf blocks: an ATX heading's
+* first line sits inside its `# ` prefix and can never be reparsed as a
+* block construct, so line-leading hazards never apply there. A hard
+* break's later lines are ordinary markdown lines outside that prefix and
+* get the full line-start battery, same as any other block's continuation.
+*/
+const HEADING_STYLES = /* @__PURE__ */ new Set([
+	"h1",
+	"h2",
+	"h3",
+	"h4",
+	"h5",
+	"h6"
+]), createRenderNode = (renderers, listIndexMap, listDepthMap) => {
+	let escapedTextByNode = /* @__PURE__ */ new WeakMap(), hardBreakOutputHasNewline = renderers.hardBreak().includes("\n");
+	function renderBlockChildren(node, isHeading, isListItem = !1) {
+		let chunks = planLeafEscaping(node.children ?? [], node.markDefs ?? [], {
+			isHeading,
+			isListItem,
+			hardBreakOutputHasNewline
+		}), tree = buildMarksTree(node);
+		return assignEscapedText(tree, chunks), tree.map((child, i) => renderNode({
 			node: child,
 			isInline: !0,
 			index: i,
 			renderNode
 		})).join("");
+	}
+	function assignEscapedText(nodes, chunks) {
+		let pointer = 0, visit = (node) => {
+			if (isPortableTextToolkitTextNode(node)) {
+				if (node.text !== "\n") {
+					let escaped = chunks[pointer];
+					escaped !== void 0 && escapedTextByNode.set(node, escaped), pointer++;
+				}
+				return;
+			}
+			isPortableTextToolkitSpan(node) && node.children.forEach(visit);
+		};
+		nodes.forEach(visit);
+	}
+	function renderNode(options) {
+		let { node, index, isInline } = options;
+		return isPortableTextListItemBlock(node) ? renderListItem(node, index) : isPortableTextToolkitSpan(node) ? renderSpan(node) : isPortableTextBlock(node) ? renderBlock(node, index, isInline, consumeListItemFirstBlock(node)) : isPortableTextToolkitTextNode(node) ? renderText(node) : renderCustomBlock(node, index, isInline);
+	}
+	function renderListItem(node, index) {
+		let renderer = renderers.listItem, itemHandler = (typeof renderer == "function" ? renderer : renderer[node.listItem]) || renderers.unknownListItem, children;
 		if (node.style && node.style !== "normal") {
 			let { listItem: _listItem, ...blockNode } = node;
-			children = renderNode({
+			markListItemFirstBlock(blockNode), children = renderNode({
 				node: blockNode,
 				index,
 				isInline: !1,
 				renderNode
 			}), children = children.replace(/\n+$/, "");
-		}
+		} else children = renderBlockChildren(node, !1, !0);
 		return itemHandler({
 			value: node,
 			index,
@@ -138,21 +568,18 @@ const createRenderNode = (renderers, listIndexMap, listDepthMap) => {
 			children: children.join("")
 		});
 	}
-	function renderBlock(node, index, isInline) {
-		let { _key, ...props } = serializeBlock({
-			node,
+	function renderBlock(node, index, isInline, isListItem) {
+		let style = node.style || "normal", children = renderBlockChildren(node, HEADING_STYLES.has(style), isListItem);
+		return ((typeof renderers.block == "function" ? renderers.block : renderers.block[style]) || renderers.unknownBlockStyle)({
 			index,
 			isInline,
-			renderNode
-		}), style = props.node.style || "normal";
-		return ((typeof renderers.block == "function" ? renderers.block : renderers.block[style]) || renderers.unknownBlockStyle)({
-			...props,
-			value: props.node,
+			children,
+			value: node,
 			renderNode
 		});
 	}
 	function renderText(node) {
-		return node.text === "\n" ? renderers.hardBreak() : node.text;
+		return node.text === "\n" ? renderers.hardBreak() : escapedTextByNode.get(node) ?? node.text;
 	}
 	function renderCustomBlock(value, index, isInline) {
 		return (renderers.types[value._type] ?? renderers.unknownType)({
@@ -163,26 +590,7 @@ const createRenderNode = (renderers, listIndexMap, listDepthMap) => {
 		});
 	}
 	return renderNode;
-};
-function serializeBlock(options) {
-	let { node, index, isInline, renderNode } = options, renderedChildren = buildMarksTree(node).map((child, i) => renderNode({
-		node: child,
-		isInline: !0,
-		index: i,
-		renderNode
-	}));
-	return {
-		_key: node._key || defaultKeyGenerator(),
-		children: renderedChildren.join(""),
-		index,
-		isInline,
-		node
-	};
-}
-/**
-* @public
-*/
-const DefaultBlockSpacingRenderer = ({ current, next }) => isPortableTextListItemBlock(current) && isPortableTextListItemBlock(next) ? "\n" : isPortableTextBlock(current) && isPortableTextBlock(next) && current.style === "blockquote" && next.style === "blockquote" ? "\n>\n" : "\n\n", DefaultHardBreakRenderer = () => "  \n", DefaultListItemRenderer = ({ children, value, listIndex, listDepth }) => {
+}, DefaultBlockSpacingRenderer = ({ current, next }) => isPortableTextListItemBlock(current) && isPortableTextListItemBlock(next) ? "\n" : isPortableTextBlock(current) && isPortableTextBlock(next) && current.style === "blockquote" && next.style === "blockquote" ? "\n>\n" : "\n\n", DefaultHardBreakRenderer = () => "  \n", DefaultListItemRenderer = ({ children, value, listIndex, listDepth }) => {
 	let listStyle = value.listItem || "bullet", depth = listDepth ?? (value.level || 1) - 1, indent = "   ".repeat(depth);
 	return listStyle === "number" ? `${indent}${listIndex ?? 1}. ${children}` : listStyle === "task" ? `${indent}- ${"checked" in value && typeof value.checked == "boolean" && value.checked ? "[x]" : "[ ]"} ${children}` : `${indent}- ${children}`;
 }, DefaultUnknownListItemRenderer = ({ children }) => `- ${children}\n`;
@@ -208,32 +616,39 @@ function escapeImageAndLinkTitle(text) {
 * Escapes characters that have special meaning at the row level of a GFM
 * table cell.
 *
-* A literal `|` ends the cell, so unescaped pipes are replaced with `\|`.
-* Newlines end the row, so they are replaced with `<br>` to keep the
-* visible line break inside the cell. Already-escaped pipes (`\|`) are
-* left intact so that escapes introduced by mark renderers survive the
-* pass.
+* A literal `|` ends the cell, so a pipe preceded by an even number of
+* backslashes (including zero) gets one more: paired backslashes cancel
+* out to a literal backslash and leave the pipe live, so parity, not mere
+* presence, decides whether it is already escaped. Newlines end the row,
+* so they are replaced with `<br>` to keep the visible line break inside
+* the cell.
 *
-* Backslashes are intentionally not escaped here so that other escapes
-* already in the rendered cell (such as `\[` and `\]` in link text) are
-* not double-escaped.
+* Backslashes themselves are left alone here; only the parity check reads
+* them, so escapes already in the rendered cell (such as `\[` and `\]` in
+* link text) survive the pass untouched.
 */
 function escapeTableCell(text) {
-	return text.replace(RegExp("(?<!\\\\)\\|", "g"), "\\|").replace(/\n/g, "<br>");
+	return text.replace(/(\\*)\|/g, (match, backslashes) => backslashes.length % 2 == 0 ? `${backslashes}\\|` : match).replace(/\n/g, "<br>");
+}
+/**
+* @public
+*/
+const DefaultEmRenderer = ({ children }) => `_${children}_`, DefaultStrongRenderer = ({ children }) => `**${children}**`, DefaultCodeRenderer = ({ text }) => wrapInCodeSpan(text);
+function wrapInCodeSpan(text) {
+	let fence = "`".repeat(longestBacktickRun(text) + 1), touchesBacktick = text.startsWith("`") || text.endsWith("`"), wouldBeStripped = text.startsWith(" ") && text.endsWith(" ") && text.trim() !== "", padding = touchesBacktick || wouldBeStripped ? " " : "";
+	return `${fence}${padding}${text}${padding}${fence}`;
+}
+function longestBacktickRun(text) {
+	let longest = 0;
+	for (let run of text.match(/`+/g) ?? []) longest = Math.max(longest, run.length);
+	return longest;
 }
 /**
 * @public
 */
-const DefaultEmRenderer = ({ children }) => `_${children}_`, DefaultStrongRenderer = ({ children }) => `**${children}**`, DefaultCodeRenderer = ({ children }) => `\`${children}\``, DefaultUnderlineRenderer = ({ children }) => `<u>${children}</u>`, DefaultStrikeThroughRenderer = ({ children }) => `~~${children}~~`, DefaultLinkRenderer = ({ children, value }) => {
+const DefaultUnderlineRenderer = ({ children }) => `<u>${children}</u>`, DefaultStrikeThroughRenderer = ({ children }) => `~~${children}~~`, DefaultLinkRenderer = ({ children, value }) => {
 	let href = value?.href || "", title = value?.title || "";
-	if (uriLooksSafe(href)) {
-		if (/["'][^"']*[<>]|[<>][^<>]*["']/.test(href)) {
-			let encodedHref = href.replace(/["<>() ]/g, (char) => `%${char.charCodeAt(0).toString(16).toUpperCase()}`);
-			return `[${escapeImageAndLinkText(children)}](${encodedHref})`;
-		}
-		return `[${escapeImageAndLinkText(children)}](${href}${title ? ` "${escapeImageAndLinkTitle(title)}"` : ""})`;
-	}
-	return children;
+	return uriLooksSafe(href) ? /["'][^"']*[<>]|[<>][^<>]*["']/.test(href) ? `[${children}](${href.replace(/["<>() ]/g, (char) => `%${char.charCodeAt(0).toString(16).toUpperCase()}`)})` : `[${children}](${href}${title ? ` "${escapeImageAndLinkTitle(title)}"` : ""})` : children;
 };
 function uriLooksSafe(uri) {
 	let url = (uri || "").trim(), first = url.charAt(0);
@@ -267,7 +682,7 @@ function isCodeShaped(value) {
 * as absent instead of guarded.
 */
 function normalizeLanguage(language) {
-	return typeof language != "string" || language.includes("\n") ? "" : language;
+	return typeof language != "string" || language.includes("\n") || language === "json:object" ? "" : language;
 }
 /**
 * @public
@@ -280,10 +695,10 @@ function isHtmlShaped(value) {
 * @public
 */
 const DefaultImageRenderer = (options) => {
-	if (!isImageShaped(options.value)) return DefaultUnknownTypeRenderer(options);
+	if (!isImageShaped(options.value) || !linkValidator(options.value.src)) return DefaultUnknownTypeRenderer(options);
 	let alt = escapeImageAndLinkText(options.value.alt ?? ""), title = options.value.title ? ` "${escapeImageAndLinkTitle(options.value.title)}"` : "";
 	return `![${alt}](${options.value.src}${title})`;
-};
+}, linkValidator = new markdownit().validateLink;
 function isImageShaped(value) {
 	let image = value;
 	return typeof image?.src == "string" && (image.alt == null || typeof image.alt == "string") && (image.title == null || typeof image.title == "string");
@@ -325,12 +740,23 @@ const DefaultTableRenderer = (options) => {
 function renderTable(value, renderNode) {
 	let rows = value.rows, alignment = Array.isArray(value.alignment) ? value.alignment : void 0, headerRow = rows.at(0);
 	if (!headerRow) return "";
-	let getCellText = (cellBlocks) => cellBlocks.map((block, index) => renderNode({
-		node: block,
-		index,
-		isInline: !1,
-		renderNode
-	})).join(" ").trim(), lines = [], columnCount = rows.reduce((max, row) => Math.max(max, row.cells.length), 0), renderCells = (texts) => {
+	let getCellText = (cellBlocks) => cellBlocks.map((block, index) => {
+		let rendered = renderNode({
+			node: block,
+			index,
+			isInline: !1,
+			renderNode
+		}), rendererOptions = {
+			value: block,
+			isInline: !1,
+			index,
+			renderNode
+		};
+		return rendered === DefaultUnknownTypeRenderer(rendererOptions) ? DefaultUnknownTypeRenderer({
+			...rendererOptions,
+			isInline: !0
+		}) : rendered;
+	}).join(" ").trim(), lines = [], columnCount = rows.reduce((max, row) => Math.max(max, row.cells.length), 0), renderCells = (texts) => {
 		let padded = [...texts];
 		for (; padded.length < columnCount;) padded.push("");
 		return `| ${padded.join(" | ")} |`;
@@ -363,7 +789,7 @@ const DefaultCalloutRenderer = (options) => {
 		index,
 		isInline: !1,
 		renderNode
-	})).join("\n\n").split("\n").map((line) => line === "" ? ">" : `> ${line}`).join("\n");
+	})).filter((rendered) => rendered !== "").join("\n\n").split("\n").map((line) => line === "" ? ">" : `> ${line}`).join("\n");
 	return `> [!${options.value.tone.toUpperCase()}]\n${prefixed}`;
 };
 function isCalloutShaped(value) {
@@ -390,20 +816,29 @@ const DefaultBlockquoteObjectRenderer = ({ value, renderNode }) => value.content
 	index,
 	isInline: !1,
 	renderNode
-})).join("\n\n").split("\n").map((line) => line === "" ? ">" : `> ${line}`).join("\n"), DefaultListRenderer = ({ value, renderNode }) => {
-	let itemSeparator = value.items.some((item) => item.content.filter((block) => block._type !== "list").length > 1) ? "\n\n" : "\n";
-	return value.items.map((item, itemIndex) => {
-		let marker = getListMarker(value.kind, itemIndex, item.checked), indentWidth = value.kind === "task" ? 2 : marker.length, indent = " ".repeat(indentWidth), [first, ...rest] = item.content.map((block, blockIndex) => ({
-			isNestedList: block._type === "list",
-			text: renderNode({
+})).filter((rendered) => rendered !== "").join("\n\n").split("\n").map((line) => line === "" ? ">" : `> ${line}`).join("\n"), DefaultListRenderer = ({ value, renderNode }) => {
+	let renderedItems = value.items.map((item) => {
+		let markerLineSettled = !1;
+		return item.content.map((block, blockIndex) => {
+			let isNestedList = block._type === "list", isTextBlock = !isNestedList && isPortableTextBlock(block);
+			!markerLineSettled && isTextBlock && markListItemFirstBlock(block);
+			let text = renderNode({
 				node: block,
 				index: blockIndex,
 				isInline: !1,
 				renderNode
-			})
-		})), head = `${marker}${first?.text ?? ""}`.trimEnd();
+			});
+			return text !== "" && (markerLineSettled = !0), {
+				isNestedList,
+				isTextBlock,
+				text
+			};
+		});
+	}), itemSeparator = renderedItems.some((renderedBlocks) => renderedBlocks.filter((rendered) => !rendered.isNestedList && rendered.text !== "").length > 1) ? "\n\n" : "\n";
+	return value.items.map((item, itemIndex) => {
+		let marker = getListMarker(value.kind, itemIndex, item.checked), indentWidth = value.kind === "task" ? 2 : marker.length, indent = " ".repeat(indentWidth), indentLines = (text) => text.split("\n").map((line) => line === "" ? "" : `${indent}${line}`).join("\n"), nonEmptyBlocks = (renderedItems[itemIndex] ?? []).filter((rendered) => rendered.text !== ""), markerLineCandidate = nonEmptyBlocks[0], promoted = markerLineCandidate && !markerLineCandidate.isNestedList && (value.kind !== "task" || markerLineCandidate.isTextBlock) ? markerLineCandidate : void 0, rest = promoted ? nonEmptyBlocks.slice(1) : nonEmptyBlocks, [promotedFirstLine = "", ...promotedRestLines] = (promoted?.text ?? "").split("\n"), head = [`${marker}${promotedFirstLine}`, ...promotedRestLines.length > 0 ? [indentLines(promotedRestLines.join("\n"))] : []].join("\n").trimEnd();
 		return rest.length === 0 ? head : `${head}${rest.map((rendered) => {
-			let indented = rendered.text.split("\n").map((line) => line === "" ? "" : `${indent}${line}`).join("\n");
+			let indented = indentLines(rendered.text);
 			return rendered.isNestedList ? `\n${indented}` : `\n\n${indented}`;
 		}).join("")}`;
 	}).join(itemSeparator);
@@ -414,10 +849,7 @@ function getListMarker(kind, itemIndex, checked) {
 /**
 * @public
 */
-const DefaultUnknownTypeRenderer = ({ value, isInline }) => {
-	let json = `\`\`\`json\n${JSON.stringify(value, null, 2)}\n\`\`\``;
-	return isInline ? `\n${json}\n` : json;
-}, defaultRenderers = {
+const DefaultUnknownTypeRenderer = ({ value, isInline }) => isInline ? `json:object${wrapInCodeSpan(JSON.stringify(value))}` : `\`\`\`json:object\n${JSON.stringify(value, null, 2)}\n\`\`\``, defaultRenderers = {
 	types: {
 		callout: DefaultCalloutRenderer,
 		code: DefaultCodeBlockRenderer,
@@ -466,7 +898,7 @@ function portableTextToMarkdown(blocks, options = {}) {
 			...options.marks
 		},
 		types: {
-			...defaultRenderers.types,
+			...gateDefaultTypeRenderers(defaultRenderers.types, options.schema, options.unknownType ?? defaultRenderers.unknownType),
 			...options.types
 		},
 		hardBreak: options.hardBreak ?? defaultRenderers.hardBreak,
@@ -474,22 +906,26 @@ function portableTextToMarkdown(blocks, options = {}) {
 		unknownBlockStyle: options.unknownBlockStyle ?? defaultRenderers.unknownBlockStyle,
 		unknownListItem: options.unknownListItem ?? defaultRenderers.unknownListItem,
 		unknownMark: options.unknownMark ?? defaultRenderers.unknownMark
-	}, renderBlockSpacing = options.blockSpacing ?? DefaultBlockSpacingRenderer, { listIndexMap, listDepthMap } = buildListIndexMap(blocks), renderNode = createRenderNode(renderers, listIndexMap, listDepthMap);
-	return blocks.map((node, index) => {
-		let renderedNode = renderNode({
+	}, renderBlockSpacing = options.blockSpacing ?? DefaultBlockSpacingRenderer, { listIndexMap, listDepthMap } = buildListIndexMap(blocks), renderNode = createRenderNode(renderers, listIndexMap, listDepthMap), renderedBlocks = blocks.map((node, index) => ({
+		node,
+		rendered: renderNode({
 			node,
 			index,
 			isInline: !1,
 			renderNode
-		});
-		if (index === blocks.length - 1) return renderedNode;
-		let nextNode = blocks.at(index + 1);
-		return nextNode ? `${renderedNode}${renderBlockSpacing({
+		})
+	})).filter(({ rendered }) => rendered !== "");
+	return renderedBlocks.map(({ node, rendered }, index) => {
+		let nextBlock = renderedBlocks.at(index + 1);
+		return nextBlock ? `${rendered}${renderBlockSpacing({
 			current: node,
-			next: nextNode
-		}) ?? "\n\n"}` : renderedNode;
+			next: nextBlock.node
+		}) ?? "\n\n"}` : rendered;
 	}).join("");
 }
+function gateDefaultTypeRenderers(defaultTypeRenderers, schema, resolvedUnknownType) {
+	return schema ? Object.fromEntries(Object.entries(defaultTypeRenderers).map(([typeName, renderer]) => [typeName, (rendererOptions) => (rendererOptions.isInline ? schema.inlineObjects : schema.blockObjects).some((item) => item.name === typeName) && renderer ? renderer(rendererOptions) : resolvedUnknownType(rendererOptions)])) : defaultTypeRenderers;
+}
 /********************
 * Default style definitions
 ********************/
@@ -611,7 +1047,66 @@ const normalStyleDefinition = { name: "normal" }, h1StyleDefinition = { name: "h
 		defaultTableObjectDefinition
 	],
 	inlineObjects: [defaultImageObjectDefinition]
-}));
+})), degradationMessage = {
+	"decorator-dropped": (decorator) => {
+		switch (decorator) {
+			case "code": return "Removed inline-code formatting, kept the text: the schema has no `code` decorator";
+			case "strong": return "Removed bold formatting, kept the text: the schema has no `strong` decorator";
+			case "em": return "Removed italic formatting, kept the text: the schema has no `em` decorator";
+			case "strikeThrough": return "Removed strikethrough formatting, kept the text: the schema has no `strike-through` decorator";
+		}
+	},
+	"annotation-dropped": (cause) => cause === "missing-url" ? "Removed a link that has no URL, kept its text" : "Removed the link, kept its text: the schema has no `link` annotation",
+	"style-fallback": (name) => /^h[1-6]$/.test(name) ? `\`${"#".repeat(Number(name.slice(1)))}\` heading became a normal paragraph: the schema has no \`${name}\` style` : name === "blockquote" ? "Blockquote became normal paragraphs: the schema has no `blockquote` style" : `Fell back to \`normal\` style: \`${name}\` not in schema`,
+	"list-flattened": (kind) => `${kind === "number" ? "Numbered" : "Bullet"} list became plain paragraphs: the schema has no \`${kind}\` list`,
+	"task-checkbox-stripped": (checked) => `Removed the \`${checked ? "[x]" : "[ ]"}\` checkbox, kept a plain list item: the schema has no \`task\` list`,
+	"table-flattened": "Table became plain text blocks, rows and columns lost: the schema has no `table` block object",
+	"code-block-to-text": (language) => language ? `\`${language}\` code block became plain text: the schema has no \`code\` block object` : "Code block became plain text: the schema has no `code` block object",
+	"horizontal-rule-to-text": "Horizontal rule became the text `---`: the schema has no `horizontal-rule` block object",
+	"html-block-to-text": "HTML block became plain text: the schema has no `html` block object",
+	"inline-html-dropped": "Removed inline HTML tags, kept nothing: `html.inline` is `skip` (the default)",
+	"image-block-to-inline": (cause) => cause === "table-cell" ? "The image became inline: a table cell can't hold a block-level `image`" : "The image became inline: the schema has no block-level `image`",
+	"image-inline-to-block": "The image became its own block, splitting the paragraph: the schema has no inline `image`",
+	"image-to-text": "Image became its markdown source as plain text: the schema has no `image` object",
+	"callout-fallback": (calloutType, style) => `\`[!${calloutType.toUpperCase()}]\` callout became ${style}-styled text: the schema has no \`callout\` block object`,
+	"fields-dropped": (names, construct) => `Dropped ${names} from \`${construct}\`: not in the schema's \`${construct}\` fields`,
+	"object-carrier-invalid": (kind, payload) => kind === "fence" ? `\`json:object\` fence fell back to a code block: ${describeObjectCarrierFailure(payload)}` : `\`json:object\`-tagged code span fell back to a plain code span: ${describeObjectCarrierFailure(payload)}`
+};
+/**
+* Names why a `json:object` payload failed to parse as an object carrier:
+* a payload that isn't a JSON object at all reads differently from one
+* that is but has no usable `_type`.
+*/
+function describeObjectCarrierFailure(payload) {
+	let parsed;
+	try {
+		parsed = JSON.parse(payload);
+	} catch {
+		return "the payload is not valid JSON";
+	}
+	return typeof parsed != "object" || !parsed || Array.isArray(parsed) ? "the payload is not a JSON object" : "the payload has no string `_type`";
+}
+const droppedFieldsTag = Symbol("droppedFields");
+function readDroppedFields(object) {
+	if (object) return object[droppedFieldsTag];
+}
+function buildFilteredObject(schemaDefinition, value, keyGenerator) {
+	let filteredValue = schemaDefinition.fields.reduce((filteredValue, field) => {
+		let fieldValue = value[field.name];
+		return fieldValue !== void 0 && (filteredValue[field.name] = fieldValue), filteredValue;
+	}, {}), object = {
+		_key: keyGenerator(),
+		_type: schemaDefinition.name,
+		...filteredValue
+	}, droppedKeys = Object.entries(value).filter(([, fieldValue]) => fieldValue !== void 0).map(([key]) => key).filter((key) => !(key in filteredValue));
+	return droppedKeys.length > 0 && Object.defineProperty(object, droppedFieldsTag, {
+		value: {
+			construct: schemaDefinition.name,
+			keys: droppedKeys
+		},
+		enumerable: !1
+	}), object;
+}
 function buildStyleMatcher(definition) {
 	return ({ context }) => {
 		let schemaDefinition = context.schema.styles.find((item) => item.name === definition.name);
@@ -633,31 +1128,13 @@ function buildDecoratorMatcher(definition) {
 function buildAnnotationMatcher(definition) {
 	return ({ context, value }) => {
 		let schemaDefinition = context.schema.annotations.find((item) => item.name === definition.name);
-		if (!schemaDefinition) return;
-		let filteredValue = schemaDefinition.fields.reduce((filteredValue, field) => {
-			let fieldValue = value[field.name];
-			return fieldValue !== void 0 && (filteredValue[field.name] = fieldValue), filteredValue;
-		}, {});
-		return {
-			_key: context.keyGenerator(),
-			_type: schemaDefinition.name,
-			...filteredValue
-		};
+		if (schemaDefinition) return buildFilteredObject(schemaDefinition, value, context.keyGenerator);
 	};
 }
 function buildObjectMatcher(definition) {
 	return ({ context, value, isInline }) => {
 		let schemaDefinition = (isInline ? context.schema.inlineObjects : context.schema.blockObjects).find((item) => item.name === definition.name);
-		if (!schemaDefinition) return;
-		let filteredValue = schemaDefinition.fields.reduce((filteredValue, field) => {
-			let fieldValue = value[field.name];
-			return fieldValue !== void 0 && (filteredValue[field.name] = fieldValue), filteredValue;
-		}, {});
-		return {
-			_key: context.keyGenerator(),
-			_type: schemaDefinition.name,
-			...filteredValue
-		};
+		if (schemaDefinition) return buildFilteredObject(schemaDefinition, value, context.keyGenerator);
 	};
 }
 const codeBlockMatcher = ({ context, value, isInline }) => {
@@ -742,6 +1219,83 @@ function flattenTable(table, portableText) {
 	for (let row of table.rows) for (let cell of row.cells) for (let block of cell.value) portableText.push(block);
 }
 /**
+* Truncates a degradation message's snippet to keep the thrown/reported
+* message readable. Truncates on character count, not word boundaries: the
+* snippet is a diagnostic pointer back to the source, not prose. Undefined
+* for empty input, so a construct with nothing to quote (an empty link's
+* text, say) omits `snippet` entirely instead of reporting `""`. Backs the
+* cut off by one unit when it would land on a lead surrogate, so a snippet
+* ending mid-emoji doesn't produce an unpaired surrogate. A literal newline
+* surviving into the snippet is escaped to `\n`, since the reported message
+* is one line per finding.
+*/
+function truncateSnippet(text, maxLength = 40) {
+	if (text.length === 0) return;
+	if (text.length <= maxLength) return text.replace(/\n/g, "\\n");
+	let cut = maxLength, codeUnit = text.charCodeAt(cut - 1);
+	return codeUnit >= 55296 && codeUnit <= 56319 && --cut, `${text.slice(0, cut).replace(/\n/g, "\\n")}...`;
+}
+/**
+* Concatenates the plain text between an inline open token (`strong_open`,
+* `em_open`, `s_open`, `link_open`) and its matching close, for use as a
+* degradation message snippet. Tracks nesting depth so a same-type token
+* nested inside itself doesn't stop the scan at the wrong close.
+*/
+function collectInlineText(children, openIndex, openType, closeType) {
+	let depth = 1, text = "";
+	for (let i = openIndex + 1; i < children.length; i++) {
+		let child = children[i];
+		if (child) {
+			if (child.type === openType) depth++;
+			else if (child.type === closeType) {
+				if (depth--, depth === 0) break;
+			} else child.type === "text" ? text += child.content : child.type === "softbreak" ? text += " " : child.type === "hardbreak" && (text += "\n");
+		}
+	}
+	return text;
+}
+function capList(values) {
+	if (values.length <= 5) return values.join(", ");
+	let shown = values.slice(0, 5), more = values.length - 5;
+	return `${shown.join(", ")}, and ${more} more`;
+}
+/**
+* Builds the canonical grouped message reported alongside a non-empty
+* `degradations` array: identical (`type`, `message`) pairs collapse into one
+* line, so a document with the same missing decorator on three spans
+* doesn't repeat the same sentence three times. Groups sort by their
+* earliest-lined entry so the message reads top-to-bottom regardless of walk
+* order: nested constructs (a blockquote inside a blockquote, say) report
+* the innermost closing first even though it opened last, and that line may
+* arrive after another entry already in the group. Groups without any lined
+* entry sort last, in their relative encounter order.
+*/
+function buildDegradationMessage(degradations) {
+	let groups = [], groupIndexByKey = /* @__PURE__ */ new Map();
+	for (let degradation of degradations) {
+		let key = `${degradation.type}\u0000${degradation.message}`, groupIndex = groupIndexByKey.get(key);
+		groupIndex === void 0 && (groupIndex = groups.length, groupIndexByKey.set(key, groupIndex), groups.push({
+			base: degradation.message,
+			entries: []
+		})), groups[groupIndex].entries.push(degradation);
+	}
+	let minLine = (entries) => {
+		let definedLines = entries.map((entry) => entry.line).filter((line) => line !== void 0);
+		return definedLines.length > 0 ? Math.min(...definedLines) : void 0;
+	};
+	return ["Markdown could not be converted without loss:", ...[...groups].sort((a, b) => {
+		let lineA = minLine(a.entries), lineB = minLine(b.entries);
+		return lineA === void 0 ? lineB === void 0 ? 0 : 1 : lineB === void 0 ? -1 : lineA - lineB;
+	}).map((group) => {
+		if (group.entries.length === 1) {
+			let event = group.entries[0], snippetPart = event.snippet === void 0 ? "" : ` ("${event.snippet}")`;
+			return event.line === void 0 ? `- ${event.message}${snippetPart}` : `- line ${event.line}: ${event.message}${snippetPart}`;
+		}
+		let snippets = group.entries.map((entry) => entry.snippet).filter((snippet) => snippet !== void 0), linesAscending = [...new Set(group.entries.map((entry) => entry.line).filter((line) => line !== void 0).sort((a, b) => a - b))], count = group.entries.length, suffix = snippets.length === count ? `(${count}\u00d7: ${capList(snippets.map((snippet) => `"${snippet}"`))})` : linesAscending.length > 0 ? `(${count}\u00d7: lines ${capList(linesAscending.map(String))})` : `(${count}\u00d7)`;
+		return `- ${group.base} ${suffix}`;
+	})].join("\n");
+}
+/**
 * Converts a markdown string to an array of Portable Text blocks.
 *
 * @public
@@ -749,7 +1303,7 @@ function flattenTable(table, portableText) {
 function markdownToPortableText(markdown, options) {
 	let consolidatedOptions = {
 		schema: options?.schema ?? defaultSchema,
-		keyGenerator: options?.keyGenerator ?? defaultKeyGenerator,
+		keyGenerator: uniqueKeyGenerator(options?.keyGenerator ?? defaultKeyGenerator),
 		html: { inline: options?.html?.inline ?? "skip" },
 		marks: {
 			...defaultOptions.marks,
@@ -767,11 +1321,46 @@ function markdownToPortableText(markdown, options) {
 			...defaultOptions.types,
 			...options?.types
 		}
+	}, degradationEvents = [], report = (event) => {
+		degradationEvents.push(event);
+	}, lineOf = (candidateToken) => candidateToken?.map ? candidateToken.map[0] + 1 : void 0, reportStyleFallback = (name, line, snippet) => {
+		if (/^h[1-6]$/.test(name)) {
+			let truncated = snippet === void 0 ? void 0 : truncateSnippet(snippet);
+			report({
+				type: "style-fallback",
+				message: degradationMessage["style-fallback"](name),
+				line,
+				snippet: truncated
+			});
+			return;
+		}
+		if (name === "blockquote") {
+			report({
+				type: "style-fallback",
+				message: degradationMessage["style-fallback"](name),
+				line
+			});
+			return;
+		}
+		report({
+			type: "style-fallback",
+			message: degradationMessage["style-fallback"](name),
+			line
+		});
+	}, reportFieldsDropped = (object, line) => {
+		let dropped = readDroppedFields(object);
+		if (!dropped) return;
+		let names = dropped.keys.map((key) => `\`${key}\``).join(", ");
+		report({
+			type: "fields-dropped",
+			message: degradationMessage["fields-dropped"](names, dropped.construct),
+			line
+		});
 	}, tokens = markdownit({
 		html: !0,
 		linkify: !0,
 		typographer: !1
-	}).enable(["strikethrough", "table"]).use(alert).parse(markdown, {}), taskCheckedByListItemIndex = /* @__PURE__ */ new Map();
+	}).enable(["strikethrough", "table"]).use(alert).parse(markdown, {}), taskCheckedByListItemIndex = /* @__PURE__ */ new Map(), taskItemTextByListItemIndex = /* @__PURE__ */ new Map();
 	for (let i = 0; i < tokens.length; i++) {
 		if (tokens[i]?.type !== "list_item_open") continue;
 		let inlineIndex = -1;
@@ -791,11 +1380,11 @@ function markdownToPortableText(markdown, options) {
 		let match = inlineToken.content.match(/^\[([ xX])\] /);
 		if (!match) continue;
 		let checked = match[1] !== " ";
-		taskCheckedByListItemIndex.set(i, checked), inlineToken.content = inlineToken.content.slice(match[0].length);
+		taskCheckedByListItemIndex.set(i, checked), inlineToken.content = inlineToken.content.slice(match[0].length), taskItemTextByListItemIndex.set(i, inlineToken.content);
 		let firstChild = inlineToken.children?.[0];
 		firstChild && typeof firstChild.content == "string" && (firstChild.content = firstChild.content.slice(match[0].length));
 	}
-	let portableText = [], currentBlock = null, currentListStack = [], markDefRefs = [], currentMarkDefs = [], currentBlockquoteStyle = null, inListItem = !1, calloutStartIndex = null, calloutStartTarget = null, calloutType = null, blockquoteStack = [], currentTable = null, currentTableRow = null, inTableHead = !1, listContainerStack = [], blockTarget = () => {
+	let portableText = [], currentBlock = null, currentListStack = [], markDefRefs = [], currentMarkDefs = [], currentBlockquoteStyle = null, inListItem = !1, currentBlockTookBlockquoteStyle = !1, currentBlockIsPlainParagraph = !1, plainParagraphBlocks = /* @__PURE__ */ new WeakSet(), calloutStartIndex = null, calloutStartTarget = null, calloutType = null, calloutStartLine, calloutPendingStyleFallbacks = [], blockquoteStack = [], currentTable = null, currentTableRow = null, inTableHead = !1, demotedTableImages = /* @__PURE__ */ new WeakMap(), listContainerStack = [], pendingListFlattenedStack = [], taskInfoByListItem = /* @__PURE__ */ new WeakMap(), blockTarget = () => {
 		for (let i = listContainerStack.length - 1; i >= 0; i--) {
 			let frame = listContainerStack[i];
 			if (frame && frame.currentItem) return frame.currentItem.content;
@@ -803,26 +1392,35 @@ function markdownToPortableText(markdown, options) {
 		return portableText;
 	}, pushBlock = (block) => {
 		blockTarget().push(block);
-	}, startBlock = (style) => {
+	}, startBlock = (style, provenance) => {
 		flushBlock(), currentBlock = {
 			_type: "block",
 			style,
 			children: [],
 			_key: consolidatedOptions.keyGenerator(),
 			markDefs: []
-		}, currentMarkDefs = [];
+		}, currentMarkDefs = [], currentBlockTookBlockquoteStyle = provenance?.tookBlockquoteStyle ?? !1, currentBlockIsPlainParagraph = provenance?.isPlainParagraph ?? !1;
 	}, flushBlock = () => {
-		currentBlock && (currentBlock.children.length === 0 && currentBlock.children.push({
-			_type: consolidatedOptions.schema.span.name,
-			_key: consolidatedOptions.keyGenerator(),
-			text: "",
-			marks: []
-		}), currentBlock.markDefs = currentMarkDefs, pushBlock(currentBlock), currentBlock = null, currentMarkDefs = []);
+		if (currentBlock) {
+			if (calloutPendingStyleFallbacks.length > 0 && currentBlockTookBlockquoteStyle) {
+				for (let name of calloutPendingStyleFallbacks) reportStyleFallback(name, calloutStartLine);
+				calloutPendingStyleFallbacks = [];
+			}
+			currentBlock.children.length === 0 && currentBlock.children.push({
+				_type: consolidatedOptions.schema.span.name,
+				_key: consolidatedOptions.keyGenerator(),
+				text: "",
+				marks: []
+			}), currentBlock.markDefs = currentMarkDefs, currentBlockIsPlainParagraph && plainParagraphBlocks.add(currentBlock), pushBlock(currentBlock), currentBlock = null, currentMarkDefs = [];
+		}
 	}, addSpan = (text) => {
 		if (text.length === 0) return;
 		if (!currentBlock) {
 			let style = currentBlockquoteStyle ?? consolidatedOptions.block.normal({ context: { schema: consolidatedOptions.schema } });
-			style ? startBlock(style) : (console.warn("No default style found, using \"normal\""), startBlock("normal"));
+			style ? startBlock(style, {
+				tookBlockquoteStyle: currentBlockquoteStyle !== null,
+				isPlainParagraph: !0
+			}) : (reportStyleFallback("normal"), startBlock("normal", { isPlainParagraph: !0 }));
 		}
 		if (!currentBlock) throw Error("Expected current block");
 		let lastChild = currentBlock.children.at(-1);
@@ -835,7 +1433,7 @@ function markdownToPortableText(markdown, options) {
 	}, listLevel = () => currentListStack.length, ensureListBlock = (listItem, checked) => {
 		if (!currentBlock) {
 			let style = currentBlockquoteStyle ?? consolidatedOptions.block.normal({ context: { schema: consolidatedOptions.schema } });
-			style ? startBlock(style) : (console.warn("No default style found, using \"normal\""), startBlock("normal"));
+			style ? startBlock(style, { tookBlockquoteStyle: currentBlockquoteStyle !== null }) : (reportStyleFallback("normal"), startBlock("normal"));
 		}
 		if (!currentBlock) throw Error("Expected current block");
 		(currentBlock.listItem !== listItem || currentBlock.level !== listLevel()) && (currentBlock.listItem = listItem, currentBlock.level = listLevel()), checked !== void 0 && (currentBlock.checked = checked);
@@ -846,7 +1444,13 @@ function markdownToPortableText(markdown, options) {
 			case "paragraph_open": {
 				if (inListItem) {
 					if (listContainerStack.at(-1)) {
-						currentBlock || startBlock(currentBlockquoteStyle ?? consolidatedOptions.block.normal({ context: { schema: consolidatedOptions.schema } }) ?? "normal");
+						if (!currentBlock) {
+							let style = currentBlockquoteStyle ?? consolidatedOptions.block.normal({ context: { schema: consolidatedOptions.schema } });
+							style || reportStyleFallback("normal", lineOf(token)), startBlock(style ?? "normal", {
+								tookBlockquoteStyle: currentBlockquoteStyle !== null,
+								isPlainParagraph: !0
+							});
+						}
 						break;
 					}
 					if (!currentBlock) {
@@ -857,10 +1461,13 @@ function markdownToPortableText(markdown, options) {
 				}
 				let style = currentBlockquoteStyle ?? consolidatedOptions.block.normal({ context: { schema: consolidatedOptions.schema } });
 				if (!style) {
-					console.warn("No default style found, using \"normal\""), startBlock("normal");
+					reportStyleFallback("normal", lineOf(token)), startBlock("normal", { isPlainParagraph: !0 });
 					break;
 				}
-				startBlock(style);
+				startBlock(style, {
+					tookBlockquoteStyle: currentBlockquoteStyle !== null,
+					isPlainParagraph: !0
+				});
 				break;
 			}
 			case "paragraph_close":
@@ -878,9 +1485,11 @@ function markdownToPortableText(markdown, options) {
 					4: consolidatedOptions.block.h4,
 					5: consolidatedOptions.block.h5,
 					6: consolidatedOptions.block.h6
-				}[level], style = headingMatcher?.({ context: { schema: consolidatedOptions.schema } }) ?? consolidatedOptions.block.normal({ context: { schema: consolidatedOptions.schema } });
+				}[level], headingStyle = headingMatcher?.({ context: { schema: consolidatedOptions.schema } });
+				headingStyle || reportStyleFallback(`h${level}`, lineOf(token), tokens[tokenIndex + 1]?.content);
+				let style = headingStyle ?? consolidatedOptions.block.normal({ context: { schema: consolidatedOptions.schema } });
 				if (!style) {
-					console.warn("No heading style found, using \"normal\""), startBlock("normal");
+					reportStyleFallback("normal", lineOf(token)), startBlock("normal");
 					break;
 				}
 				startBlock(style);
@@ -889,17 +1498,22 @@ function markdownToPortableText(markdown, options) {
 			case "heading_close":
 				flushBlock();
 				break;
-			case "blockquote_open":
+			case "blockquote_open": {
 				if (flushBlock(), consolidatedOptions.types.blockquote) {
 					let startTarget = blockTarget();
 					blockquoteStack.push({
 						startTarget,
-						startIndex: startTarget.length
+						startIndex: startTarget.length,
+						line: lineOf(token)
 					});
 					break;
 				}
-				currentBlockquoteStyle = consolidatedOptions.block.blockquote({ context: { schema: consolidatedOptions.schema } }) ?? consolidatedOptions.block.normal({ context: { schema: consolidatedOptions.schema } }) ?? "normal";
+				let blockquoteStyle = consolidatedOptions.block.blockquote({ context: { schema: consolidatedOptions.schema } });
+				blockquoteStyle || reportStyleFallback("blockquote", lineOf(token));
+				let style = blockquoteStyle ?? consolidatedOptions.block.normal({ context: { schema: consolidatedOptions.schema } });
+				style || reportStyleFallback("normal", lineOf(token)), currentBlockquoteStyle = style ?? "normal";
 				break;
+			}
 			case "blockquote_close":
 				if (flushBlock(), consolidatedOptions.types.blockquote && blockquoteStack.length > 0) {
 					let frame = blockquoteStack.pop();
@@ -914,11 +1528,18 @@ function markdownToPortableText(markdown, options) {
 						});
 						if (blockquoteObject) pushBlock(blockquoteObject);
 						else {
-							let blockquoteStyle = consolidatedOptions.block.blockquote({ context: { schema: consolidatedOptions.schema } }) ?? consolidatedOptions.block.normal({ context: { schema: consolidatedOptions.schema } }) ?? "blockquote";
-							for (let block of contentBlocks) block._type === "block" ? pushBlock({
-								...block,
-								style: blockquoteStyle
-							}) : pushBlock(block);
+							let blockquoteStyle = consolidatedOptions.block.blockquote({ context: { schema: consolidatedOptions.schema } });
+							blockquoteStyle || reportStyleFallback("blockquote", frame.line);
+							let resolvedStyle = blockquoteStyle ?? consolidatedOptions.block.normal({ context: { schema: consolidatedOptions.schema } });
+							resolvedStyle || reportStyleFallback("normal", frame.line);
+							let fallbackStyle = resolvedStyle ?? "blockquote";
+							for (let block of contentBlocks) if (block._type === "block" && plainParagraphBlocks.has(block)) {
+								let restyledBlock = {
+									...block,
+									style: fallbackStyle
+								};
+								plainParagraphBlocks.add(restyledBlock), pushBlock(restyledBlock);
+							} else pushBlock(block);
 						}
 					}
 					break;
@@ -930,16 +1551,21 @@ function markdownToPortableText(markdown, options) {
 					listContainerStack.push({
 						kind: "bullet",
 						items: [],
-						currentItem: null
-					}), currentListStack.push(null);
+						currentItem: null,
+						line: lineOf(token)
+					}), currentListStack.push(null), pendingListFlattenedStack.push(null);
 					break;
 				}
 				let listItem = consolidatedOptions.listItem.bullet({ context: { schema: consolidatedOptions.schema } });
 				if (listContainerStack.push(null), !listItem) {
-					currentListStack.push(null);
+					pendingListFlattenedStack.push({
+						line: lineOf(token),
+						kindName: "bullet",
+						reported: !1
+					}), currentListStack.push(null);
 					break;
 				}
-				currentListStack.push(listItem);
+				pendingListFlattenedStack.push(null), currentListStack.push(listItem);
 				break;
 			}
 			case "ordered_list_open": {
@@ -947,22 +1573,27 @@ function markdownToPortableText(markdown, options) {
 					listContainerStack.push({
 						kind: "number",
 						items: [],
-						currentItem: null
-					}), currentListStack.push(null);
+						currentItem: null,
+						line: lineOf(token)
+					}), currentListStack.push(null), pendingListFlattenedStack.push(null);
 					break;
 				}
 				let listItem = consolidatedOptions.listItem.number({ context: { schema: consolidatedOptions.schema } });
 				if (listContainerStack.push(null), !listItem) {
-					currentListStack.push(null);
+					pendingListFlattenedStack.push({
+						line: lineOf(token),
+						kindName: "number",
+						reported: !1
+					}), currentListStack.push(null);
 					break;
 				}
-				currentListStack.push(listItem);
+				pendingListFlattenedStack.push(null), currentListStack.push(listItem);
 				break;
 			}
 			case "bullet_list_close":
 			case "ordered_list_close": {
 				let frame = listContainerStack.pop();
-				if (currentListStack.pop(), frame && consolidatedOptions.types.list) {
+				if (currentListStack.pop(), pendingListFlattenedStack.pop(), frame && consolidatedOptions.types.list) {
 					let kind = frame.items.some((item) => "checked" in item) ? "task" : frame.kind, listObject = consolidatedOptions.types.list({
 						context: {
 							schema: consolidatedOptions.schema,
@@ -976,13 +1607,45 @@ function markdownToPortableText(markdown, options) {
 					});
 					if (listObject) pushBlock(listObject);
 					else {
-						let flatListItem = (kind === "task" ? consolidatedOptions.listItem.task?.({ context: { schema: consolidatedOptions.schema } }) : kind === "number" ? consolidatedOptions.listItem.number({ context: { schema: consolidatedOptions.schema } }) : consolidatedOptions.listItem.bullet({ context: { schema: consolidatedOptions.schema } })) ?? null, level = listContainerStack.length + 1;
-						for (let item of frame.items) for (let block of item.content) block._type === "block" && flatListItem !== null && !("listItem" in block) ? pushBlock({
-							...block,
-							listItem: flatListItem,
-							level,
-							...item.checked === void 0 ? {} : { checked: item.checked }
-						}) : pushBlock(block);
+						let kindListItem = (frame.kind === "number" ? consolidatedOptions.listItem.number : consolidatedOptions.listItem.bullet)({ context: { schema: consolidatedOptions.schema } }) ?? null, taskListItemType = consolidatedOptions.listItem.task?.({ context: { schema: consolidatedOptions.schema } }) ?? null, kindName = frame.kind === "number" ? "number" : "bullet", level = listContainerStack.length + 1, flattenedReported = !1;
+						for (let item of frame.items) {
+							let itemListType = kindListItem, itemChecked;
+							if (item.checked !== void 0) {
+								if (taskListItemType) itemListType = taskListItemType, itemChecked = item.checked;
+								else if (kindListItem !== null) {
+									let info = taskInfoByListItem.get(item);
+									report({
+										type: "task-checkbox-stripped",
+										message: degradationMessage["task-checkbox-stripped"](item.checked),
+										line: info?.line,
+										snippet: info?.snippet
+									});
+								}
+							}
+							itemListType === null && !flattenedReported && (report({
+								type: "list-flattened",
+								message: degradationMessage["list-flattened"](kindName),
+								line: frame.line
+							}), flattenedReported = !0);
+							let mergeTarget = null;
+							for (let block of item.content) {
+								if (!(itemListType !== null && block._type === "block" && !("listItem" in block) && !/^h[1-6]$/.test(block.style ?? "") && plainParagraphBlocks.has(block))) {
+									mergeTarget = null, pushBlock(block);
+									continue;
+								}
+								let textBlock = block;
+								if (mergeTarget && mergeTarget.style === textBlock.style) {
+									mergeTarget.children.push(...textBlock.children), mergeTarget.markDefs = [...mergeTarget.markDefs ?? [], ...textBlock.markDefs ?? []];
+									continue;
+								}
+								mergeTarget = {
+									...textBlock,
+									listItem: itemListType,
+									level,
+									...itemChecked === void 0 ? {} : { checked: itemChecked }
+								}, pushBlock(mergeTarget);
+							}
+						}
 					}
 				}
 				break;
@@ -996,7 +1659,10 @@ function markdownToPortableText(markdown, options) {
 						_key: consolidatedOptions.keyGenerator(),
 						...taskChecked === void 0 ? {} : { checked: taskChecked },
 						content: []
-					}, inListItem = !0;
+					}, taskChecked !== void 0 && taskInfoByListItem.set(frame.currentItem, {
+						line: lineOf(token),
+						snippet: truncateSnippet(taskItemTextByListItemIndex.get(tokenIndex) ?? "")
+					}), inListItem = !0;
 					break;
 				}
 				let baseListType = currentListStack.at(-1);
@@ -1007,10 +1673,25 @@ function markdownToPortableText(markdown, options) {
 					taskListType && (listType = taskListType, checked = taskChecked);
 				}
 				if (listType === null) {
+					let pendingFlattened = pendingListFlattenedStack.at(-1);
+					pendingFlattened && !pendingFlattened.reported && (report({
+						type: "list-flattened",
+						message: degradationMessage["list-flattened"](pendingFlattened.kindName),
+						line: pendingFlattened.line
+					}), pendingFlattened.reported = !0);
 					let style = currentBlockquoteStyle ?? consolidatedOptions.block.normal({ context: { schema: consolidatedOptions.schema } });
-					style ? startBlock(style) : (console.warn("No default style found, using \"normal\""), startBlock("normal")), inListItem = !0;
+					style ? startBlock(style, { tookBlockquoteStyle: currentBlockquoteStyle !== null }) : (reportStyleFallback("normal", lineOf(token)), startBlock("normal")), inListItem = !0;
 					break;
 				}
+				if (taskChecked !== void 0 && checked === void 0) {
+					let snippet = truncateSnippet(taskItemTextByListItemIndex.get(tokenIndex) ?? "");
+					report({
+						type: "task-checkbox-stripped",
+						message: degradationMessage["task-checkbox-stripped"](taskChecked),
+						line: lineOf(token),
+						snippet
+					});
+				}
 				ensureListBlock(listType, checked), inListItem = !0;
 				break;
 			}
@@ -1025,7 +1706,21 @@ function markdownToPortableText(markdown, options) {
 			}
 			case "fence": {
 				flushBlock();
-				let language = token.info.trim() || void 0, code = token.content.replace(/\n$/, ""), codeObject = consolidatedOptions.types.code({
+				let language = token.info.trim() || void 0, code = token.content.replace(/\n$/, "");
+				if (language === "json:object") {
+					let objectValue = parseJsonObjectFence(code);
+					if (objectValue) {
+						pushBlock(objectValue);
+						break;
+					}
+					report({
+						type: "object-carrier-invalid",
+						message: degradationMessage["object-carrier-invalid"]("fence", code),
+						line: lineOf(token),
+						snippet: truncateSnippet(code)
+					});
+				}
+				let codeObject = consolidatedOptions.types.code({
 					context: {
 						schema: consolidatedOptions.schema,
 						keyGenerator: consolidatedOptions.keyGenerator
@@ -1037,11 +1732,18 @@ function markdownToPortableText(markdown, options) {
 					isInline: !1
 				});
 				if (!codeObject) {
+					let snippet = truncateSnippet(code.split("\n")[0] ?? "");
+					report({
+						type: "code-block-to-text",
+						message: degradationMessage["code-block-to-text"](language),
+						line: lineOf(token),
+						snippet
+					});
 					let style = consolidatedOptions.block.normal({ context: { schema: consolidatedOptions.schema } });
-					style ? startBlock(style) : (console.warn("No default style found, using \"normal\""), startBlock("normal")), addSpan(code), flushBlock();
+					style ? startBlock(style) : (reportStyleFallback("normal", lineOf(token)), startBlock("normal")), addSpan(code), flushBlock();
 					break;
 				}
-				pushBlock(codeObject);
+				reportFieldsDropped(codeObject, lineOf(token)), pushBlock(codeObject);
 				break;
 			}
 			case "hr": {
@@ -1055,8 +1757,13 @@ function markdownToPortableText(markdown, options) {
 					isInline: !1
 				});
 				if (!hrObject) {
+					report({
+						type: "horizontal-rule-to-text",
+						message: degradationMessage["horizontal-rule-to-text"],
+						line: lineOf(token)
+					});
 					let style = consolidatedOptions.block.normal({ context: { schema: consolidatedOptions.schema } });
-					style ? startBlock(style) : (console.warn("No default style found, using \"normal\""), startBlock("normal")), addSpan("---"), flushBlock();
+					style ? startBlock(style) : (reportStyleFallback("normal", lineOf(token)), startBlock("normal")), addSpan("---"), flushBlock();
 					break;
 				}
 				pushBlock(hrObject);
@@ -1075,11 +1782,18 @@ function markdownToPortableText(markdown, options) {
 					isInline: !1
 				});
 				if (!htmlObject) {
+					let snippet = truncateSnippet(htmlContent);
+					report({
+						type: "html-block-to-text",
+						message: degradationMessage["html-block-to-text"],
+						line: lineOf(token),
+						snippet
+					});
 					let style = consolidatedOptions.block.normal({ context: { schema: consolidatedOptions.schema } });
-					style ? startBlock(style) : (console.warn("No default style found, using \"normal\""), startBlock("normal")), addSpan(htmlContent), flushBlock();
+					style ? startBlock(style) : (reportStyleFallback("normal", lineOf(token)), startBlock("normal")), addSpan(htmlContent), flushBlock();
 					break;
 				}
-				pushBlock(htmlObject);
+				reportFieldsDropped(htmlObject, lineOf(token)), pushBlock(htmlObject);
 				break;
 			}
 			case "code_block": {
@@ -1095,10 +1809,17 @@ function markdownToPortableText(markdown, options) {
 					},
 					isInline: !1
 				});
-				if (codeObject) pushBlock(codeObject);
+				if (codeObject) reportFieldsDropped(codeObject, lineOf(token)), pushBlock(codeObject);
 				else {
+					let snippet = truncateSnippet(code.split("\n")[0] ?? "");
+					report({
+						type: "code-block-to-text",
+						message: degradationMessage["code-block-to-text"](void 0),
+						line: lineOf(token),
+						snippet
+					});
 					let style = consolidatedOptions.block.normal({ context: { schema: consolidatedOptions.schema } });
-					style ? startBlock(style) : (console.warn("No default style found, using \"normal\""), startBlock("normal")), addSpan(code), flushBlock();
+					style ? startBlock(style) : (reportStyleFallback("normal", lineOf(token)), startBlock("normal")), addSpan(code), flushBlock();
 				}
 				break;
 			}
@@ -1107,7 +1828,8 @@ function markdownToPortableText(markdown, options) {
 					rows: [],
 					headerRows: 0,
 					emptyHeaderDropped: !1,
-					alignment: []
+					alignment: [],
+					line: lineOf(token)
 				};
 				break;
 			case "table_close":
@@ -1125,8 +1847,16 @@ function markdownToPortableText(markdown, options) {
 						},
 						isInline: !1
 					});
-					tableObject ? pushBlock(tableObject) : flattenTable(currentTable, blockTarget());
-				} else flattenTable(currentTable, blockTarget());
+					tableObject ? (reportFieldsDropped(tableObject, currentTable.line), pushBlock(tableObject)) : (report({
+						type: "table-flattened",
+						message: degradationMessage["table-flattened"],
+						line: currentTable.line
+					}), flattenTable(currentTable, blockTarget()));
+				} else report({
+					type: "table-flattened",
+					message: degradationMessage["table-flattened"],
+					line: currentTable.line
+				}), flattenTable(currentTable, blockTarget());
 				currentTable = null;
 				break;
 			case "thead_open":
@@ -1151,7 +1881,7 @@ function markdownToPortableText(markdown, options) {
 			case "td_open": {
 				currentTable && inTableHead && token.type === "th_open" && currentTable.alignment.push(extractAlignmentFromStyleAttr(token.attrGet("style")));
 				let style = consolidatedOptions.block.normal({ context: { schema: consolidatedOptions.schema } });
-				style ? startBlock(style) : (console.warn("No default style found, using \"normal\""), startBlock("normal"));
+				style ? startBlock(style) : (reportStyleFallback("normal", currentTable?.line), startBlock("normal"));
 				break;
 			}
 			case "th_close":
@@ -1174,10 +1904,24 @@ function markdownToPortableText(markdown, options) {
 					_key: consolidatedOptions.keyGenerator(),
 					markDefs: []
 				});
-				let firstBlock = cellBlocks[0];
+				let demotedInlineImages = [];
+				for (let block of cellBlocks) if (block._type === "block" && "children" in block && Array.isArray(block.children)) for (let child of block.children) typeof child == "object" && child && demotedTableImages.has(child) && demotedInlineImages.push(child);
+				let firstBlock = cellBlocks[0], liftedObject;
 				if (cellBlocks.length === 1 && firstBlock && firstBlock._type === "block" && "children" in firstBlock && Array.isArray(firstBlock.children) && firstBlock.children.length === 1) {
 					let onlyChild = firstBlock.children[0];
-					typeof onlyChild == "object" && onlyChild && "_type" in onlyChild && onlyChild._type !== consolidatedOptions.schema.span.name && onlyChild._type === "image" && (cellBlocks[0] = onlyChild);
+					if (typeof onlyChild == "object" && onlyChild && "_type" in onlyChild && onlyChild._type !== consolidatedOptions.schema.span.name) {
+						let declaredInline = consolidatedOptions.schema.inlineObjects.some((inlineObject) => inlineObject.name === onlyChild._type), declaredBlock = consolidatedOptions.schema.blockObjects.some((blockObject) => blockObject.name === onlyChild._type);
+						declaredInline && !declaredBlock || (cellBlocks[0] = onlyChild, liftedObject = onlyChild);
+					}
+				}
+				for (let demotedImage of demotedInlineImages) if (demotedImage !== liftedObject) {
+					let { alt, src } = demotedImage;
+					report({
+						type: "image-block-to-inline",
+						message: degradationMessage["image-block-to-inline"](demotedTableImages.get(demotedImage) ?? "table-cell"),
+						line: currentTable?.line,
+						snippet: truncateSnippet(alt || src || "")
+					});
 				}
 				currentTableRow !== null && currentTableRow.push({
 					_type: "cell",
@@ -1187,7 +1931,7 @@ function markdownToPortableText(markdown, options) {
 				break;
 			}
 			case "inline": {
-				let inTableCell = currentTableRow !== null;
+				let inTableCell = currentTableRow !== null, inlineLine = () => lineOf(token) ?? currentTable?.line;
 				if (token.children?.length === 1 && token.children[0]?.type === "image") {
 					let imageToken = token.children[0];
 					if (!imageToken) break;
@@ -1204,7 +1948,7 @@ function markdownToPortableText(markdown, options) {
 						isInline: !1
 					});
 					if (blockImageObject) {
-						inTableCell ? currentBlock && "children" in currentBlock && currentBlock.children.push(blockImageObject) : (currentBlock && "children" in currentBlock && currentBlock.children.length > 0 ? flushBlock() : (currentBlock = null, currentMarkDefs = []), pushBlock(blockImageObject));
+						reportFieldsDropped(blockImageObject, inlineLine()), inTableCell ? (demotedTableImages.set(blockImageObject, "table-cell"), currentBlock && "children" in currentBlock && currentBlock.children.push(blockImageObject)) : (currentBlock && "children" in currentBlock && currentBlock.children.length > 0 ? flushBlock() : (currentBlock = null, currentMarkDefs = []), pushBlock(blockImageObject));
 						break;
 					}
 					let inlineImageObject = consolidatedOptions.types.image({
@@ -1220,165 +1964,281 @@ function markdownToPortableText(markdown, options) {
 						isInline: !0
 					});
 					if (inlineImageObject) {
-						if (!currentBlock) if (inListItem) if (listContainerStack.at(-1)) startBlock(consolidatedOptions.block.normal({ context: { schema: consolidatedOptions.schema } }) ?? "normal");
-						else {
-							let listType = currentListStack.at(-1);
-							listType && ensureListBlock(listType);
-						}
-						else {
-							let style = consolidatedOptions.block.normal({ context: { schema: consolidatedOptions.schema } });
-							style && startBlock(style);
+						if (reportFieldsDropped(inlineImageObject, inlineLine()), inTableCell ? demotedTableImages.set(inlineImageObject, "no-block-image") : report({
+							type: "image-block-to-inline",
+							message: degradationMessage["image-block-to-inline"]("no-block-image"),
+							line: inlineLine(),
+							snippet: truncateSnippet(alt || src)
+						}), !currentBlock) {
+							if (inListItem) {
+								if (listContainerStack.at(-1)) {
+									let style = consolidatedOptions.block.normal({ context: { schema: consolidatedOptions.schema } });
+									style || reportStyleFallback("normal", inlineLine()), startBlock(style ?? "normal");
+								} else {
+									let listType = currentListStack.at(-1);
+									listType && ensureListBlock(listType);
+								}
+							} else {
+								let style = consolidatedOptions.block.normal({ context: { schema: consolidatedOptions.schema } });
+								style && startBlock(style);
+							}
 						}
 						currentBlock && "children" in currentBlock && currentBlock.children.push(inlineImageObject);
 						break;
 					}
-					addSpan(`![${alt}](${src})`);
+					let standaloneImageSnippet = truncateSnippet(alt || src);
+					report({
+						type: "image-to-text",
+						message: degradationMessage["image-to-text"],
+						line: inlineLine(),
+						snippet: standaloneImageSnippet
+					}), addSpan(`![${alt}](${src})`);
 					break;
 				}
-				for (let childToken of token.children ?? []) switch (childToken.type) {
-					case "text":
-						addSpan(childToken.content);
-						break;
-					case "softbreak":
-					case "hardbreak":
-						addSpan("\n");
-						break;
-					case "code_inline": {
-						let decorator = consolidatedOptions.marks.code({ context: { schema: consolidatedOptions.schema } });
-						if (!decorator) {
+				let inlineChildren = token.children ?? [];
+				for (let childIndex = 0; childIndex < inlineChildren.length; childIndex++) {
+					let childToken = inlineChildren[childIndex];
+					if (childToken) switch (childToken.type) {
+						case "text": {
+							let nextToken = inlineChildren[childIndex + 1];
+							if (childToken.content.endsWith("json:object") && nextToken?.type === "code_inline" && currentBlock && "children" in currentBlock) {
+								let objectValue = parseJsonObjectFence(nextToken.content);
+								if (objectValue) {
+									let prefix = childToken.content.slice(0, -11);
+									prefix.length > 0 && addSpan(prefix), currentBlock.children.push(objectValue), childIndex++;
+									break;
+								}
+								report({
+									type: "object-carrier-invalid",
+									message: degradationMessage["object-carrier-invalid"]("code-span", nextToken.content),
+									line: inlineLine(),
+									snippet: truncateSnippet(nextToken.content)
+								});
+							}
 							addSpan(childToken.content);
 							break;
 						}
-						markDefRefs.push(decorator), addSpan(childToken.content);
-						let index = markDefRefs.lastIndexOf(decorator);
-						index !== -1 && markDefRefs.splice(index, 1);
-						break;
-					}
-					case "strong_open": {
-						let decorator = consolidatedOptions.marks.strong({ context: { schema: consolidatedOptions.schema } });
-						if (!decorator) break;
-						markDefRefs.push(decorator);
-						break;
-					}
-					case "strong_close": {
-						let decorator = consolidatedOptions.marks.strong({ context: { schema: consolidatedOptions.schema } });
-						if (!decorator) break;
-						let index = markDefRefs.lastIndexOf(decorator);
-						index !== -1 && markDefRefs.splice(index, 1);
-						break;
-					}
-					case "em_open": {
-						let decorator = consolidatedOptions.marks.em({ context: { schema: consolidatedOptions.schema } });
-						if (!decorator) break;
-						markDefRefs.push(decorator);
-						break;
-					}
-					case "em_close": {
-						let decorator = consolidatedOptions.marks.em({ context: { schema: consolidatedOptions.schema } });
-						if (!decorator) break;
-						let index = markDefRefs.lastIndexOf(decorator);
-						index !== -1 && markDefRefs.splice(index, 1);
-						break;
-					}
-					case "s_open": {
-						let decorator = consolidatedOptions.marks.strikeThrough({ context: { schema: consolidatedOptions.schema } });
-						if (!decorator) break;
-						markDefRefs.push(decorator);
-						break;
-					}
-					case "s_close": {
-						let decorator = consolidatedOptions.marks.strikeThrough({ context: { schema: consolidatedOptions.schema } });
-						if (!decorator) break;
-						let index = markDefRefs.lastIndexOf(decorator);
-						index !== -1 && markDefRefs.splice(index, 1);
-						break;
-					}
-					case "link_open": {
-						let href = childToken.attrs?.find(([name]) => name === "href")?.at(1);
-						if (!href) break;
-						let title = childToken.attrs?.find(([name]) => name === "title")?.at(1), linkObject = consolidatedOptions.marks.link({
-							context: {
-								schema: consolidatedOptions.schema,
-								keyGenerator: consolidatedOptions.keyGenerator
-							},
-							value: {
-								href,
-								title
+						case "softbreak":
+							addSpan(" ");
+							break;
+						case "hardbreak":
+							addSpan("\n");
+							break;
+						case "code_inline": {
+							let decorator = consolidatedOptions.marks.code({ context: { schema: consolidatedOptions.schema } });
+							if (!decorator) {
+								let codeSnippet = truncateSnippet(childToken.content);
+								report({
+									type: "decorator-dropped",
+									message: degradationMessage["decorator-dropped"]("code"),
+									line: inlineLine(),
+									snippet: codeSnippet
+								}), addSpan(childToken.content);
+								break;
 							}
-						});
-						if (!linkObject) break;
-						currentMarkDefs.push(linkObject), markDefRefs.push(linkObject._key);
-						break;
-					}
-					case "link_close": {
-						let markDefKeys = new Set(currentMarkDefs.map((d) => d._key)), lastLinkIndex;
-						for (let markDefRef of markDefRefs.reverse()) if (markDefKeys.has(markDefRef)) {
-							lastLinkIndex = markDefRefs.indexOf(markDefRef);
+							markDefRefs.push(decorator), addSpan(childToken.content);
+							let index = markDefRefs.lastIndexOf(decorator);
+							index !== -1 && markDefRefs.splice(index, 1);
+							break;
+						}
+						case "strong_open": {
+							let decorator = consolidatedOptions.marks.strong({ context: { schema: consolidatedOptions.schema } });
+							if (!decorator) {
+								let strongSnippet = truncateSnippet(collectInlineText(inlineChildren, childIndex, "strong_open", "strong_close"));
+								report({
+									type: "decorator-dropped",
+									message: degradationMessage["decorator-dropped"]("strong"),
+									line: inlineLine(),
+									snippet: strongSnippet
+								});
+								break;
+							}
+							markDefRefs.push(decorator);
 							break;
 						}
-						if (lastLinkIndex !== void 0) {
-							let realIndex = markDefRefs.length - 1 - lastLinkIndex;
-							markDefRefs.splice(realIndex, 1);
+						case "strong_close": {
+							let decorator = consolidatedOptions.marks.strong({ context: { schema: consolidatedOptions.schema } });
+							if (!decorator) break;
+							let index = markDefRefs.lastIndexOf(decorator);
+							index !== -1 && markDefRefs.splice(index, 1);
+							break;
 						}
-						break;
-					}
-					case "image": {
-						let src = childToken.attrs?.find(([name]) => name === "src")?.at(1) || "", alt = unescapeImageAndLinkText(childToken.content || ""), inlineImageObject = consolidatedOptions.types.image({
-							context: {
-								schema: consolidatedOptions.schema,
-								keyGenerator: consolidatedOptions.keyGenerator
-							},
-							value: {
-								src,
-								alt,
-								title: void 0
-							},
-							isInline: !0
-						});
-						if (inlineImageObject) {
-							if (!currentBlock) {
-								let style = consolidatedOptions.block.normal({ context: { schema: consolidatedOptions.schema } });
-								style ? startBlock(style) : (console.warn("No default style found, using \"normal\""), startBlock("normal"));
+						case "em_open": {
+							let decorator = consolidatedOptions.marks.em({ context: { schema: consolidatedOptions.schema } });
+							if (!decorator) {
+								let emSnippet = truncateSnippet(collectInlineText(inlineChildren, childIndex, "em_open", "em_close"));
+								report({
+									type: "decorator-dropped",
+									message: degradationMessage["decorator-dropped"]("em"),
+									line: inlineLine(),
+									snippet: emSnippet
+								});
+								break;
 							}
-							if (!currentBlock) throw Error("Expected current block after startBlock");
-							currentBlock.children.push(inlineImageObject);
+							markDefRefs.push(decorator);
 							break;
 						}
-						let blockImageObject = consolidatedOptions.types.image({
-							context: {
-								schema: consolidatedOptions.schema,
-								keyGenerator: consolidatedOptions.keyGenerator
-							},
-							value: {
-								src,
-								alt,
-								title: void 0
-							},
-							isInline: !1
-						});
-						if (!blockImageObject) {
-							addSpan(`![${alt}](${src})`);
+						case "em_close": {
+							let decorator = consolidatedOptions.marks.em({ context: { schema: consolidatedOptions.schema } });
+							if (!decorator) break;
+							let index = markDefRefs.lastIndexOf(decorator);
+							index !== -1 && markDefRefs.splice(index, 1);
 							break;
 						}
-						if (inTableCell) {
-							currentBlock && "children" in currentBlock && currentBlock.children.push(blockImageObject);
+						case "s_open": {
+							let decorator = consolidatedOptions.marks.strikeThrough({ context: { schema: consolidatedOptions.schema } });
+							if (!decorator) {
+								let strikeSnippet = truncateSnippet(collectInlineText(inlineChildren, childIndex, "s_open", "s_close"));
+								report({
+									type: "decorator-dropped",
+									message: degradationMessage["decorator-dropped"]("strikeThrough"),
+									line: inlineLine(),
+									snippet: strikeSnippet
+								});
+								break;
+							}
+							markDefRefs.push(decorator);
 							break;
 						}
-						flushBlock(), pushBlock(blockImageObject);
-						let style = consolidatedOptions.block.normal({ context: { schema: consolidatedOptions.schema } });
-						style && startBlock(style);
-						break;
+						case "s_close": {
+							let decorator = consolidatedOptions.marks.strikeThrough({ context: { schema: consolidatedOptions.schema } });
+							if (!decorator) break;
+							let index = markDefRefs.lastIndexOf(decorator);
+							index !== -1 && markDefRefs.splice(index, 1);
+							break;
+						}
+						case "link_open": {
+							let href = childToken.attrs?.find(([name]) => name === "href")?.at(1);
+							if (!href) {
+								let missingHrefSnippet = truncateSnippet(collectInlineText(inlineChildren, childIndex, "link_open", "link_close"));
+								report({
+									type: "annotation-dropped",
+									message: degradationMessage["annotation-dropped"]("missing-url"),
+									line: inlineLine(),
+									snippet: missingHrefSnippet
+								});
+								break;
+							}
+							let title = childToken.attrs?.find(([name]) => name === "title")?.at(1), linkObject = consolidatedOptions.marks.link({
+								context: {
+									schema: consolidatedOptions.schema,
+									keyGenerator: consolidatedOptions.keyGenerator
+								},
+								value: {
+									href,
+									title
+								}
+							});
+							if (!linkObject) {
+								let linkSnippet = truncateSnippet(collectInlineText(inlineChildren, childIndex, "link_open", "link_close"));
+								report({
+									type: "annotation-dropped",
+									message: degradationMessage["annotation-dropped"]("no-annotation"),
+									line: inlineLine(),
+									snippet: linkSnippet
+								});
+								break;
+							}
+							reportFieldsDropped(linkObject, inlineLine()), currentMarkDefs.push(linkObject), markDefRefs.push(linkObject._key);
+							break;
+						}
+						case "link_close": {
+							let markDefKeys = new Set(currentMarkDefs.map((d) => d._key)), lastLinkIndex;
+							for (let markDefRef of markDefRefs.reverse()) if (markDefKeys.has(markDefRef)) {
+								lastLinkIndex = markDefRefs.indexOf(markDefRef);
+								break;
+							}
+							if (lastLinkIndex !== void 0) {
+								let realIndex = markDefRefs.length - 1 - lastLinkIndex;
+								markDefRefs.splice(realIndex, 1);
+							}
+							break;
+						}
+						case "image": {
+							let src = childToken.attrs?.find(([name]) => name === "src")?.at(1) || "", alt = unescapeImageAndLinkText(childToken.content || ""), inlineImageObject = consolidatedOptions.types.image({
+								context: {
+									schema: consolidatedOptions.schema,
+									keyGenerator: consolidatedOptions.keyGenerator
+								},
+								value: {
+									src,
+									alt,
+									title: void 0
+								},
+								isInline: !0
+							});
+							if (inlineImageObject) {
+								if (reportFieldsDropped(inlineImageObject, inlineLine()), !currentBlock) {
+									let style = consolidatedOptions.block.normal({ context: { schema: consolidatedOptions.schema } });
+									style ? startBlock(style) : (reportStyleFallback("normal", inlineLine()), startBlock("normal"));
+								}
+								if (!currentBlock) throw Error("Expected current block after startBlock");
+								currentBlock.children.push(inlineImageObject);
+								break;
+							}
+							let blockImageObject = consolidatedOptions.types.image({
+								context: {
+									schema: consolidatedOptions.schema,
+									keyGenerator: consolidatedOptions.keyGenerator
+								},
+								value: {
+									src,
+									alt,
+									title: void 0
+								},
+								isInline: !1
+							});
+							if (!blockImageObject) {
+								let inlineImageSnippet = truncateSnippet(alt || src);
+								report({
+									type: "image-to-text",
+									message: degradationMessage["image-to-text"],
+									line: inlineLine(),
+									snippet: inlineImageSnippet
+								}), addSpan(`![${alt}](${src})`);
+								break;
+							}
+							if (inTableCell) {
+								reportFieldsDropped(blockImageObject, inlineLine()), demotedTableImages.set(blockImageObject, "table-cell"), currentBlock && "children" in currentBlock && currentBlock.children.push(blockImageObject);
+								break;
+							}
+							reportFieldsDropped(blockImageObject, inlineLine()), report({
+								type: "image-inline-to-block",
+								message: degradationMessage["image-inline-to-block"],
+								line: inlineLine(),
+								snippet: truncateSnippet(alt || src)
+							}), flushBlock(), pushBlock(blockImageObject);
+							let style = consolidatedOptions.block.normal({ context: { schema: consolidatedOptions.schema } });
+							style && startBlock(style);
+							break;
+						}
+						case "html_inline": if (consolidatedOptions.html.inline === "text") addSpan(childToken.content);
+						else if (childToken.content) {
+							let htmlInlineSnippet = truncateSnippet(childToken.content);
+							report({
+								type: "inline-html-dropped",
+								message: degradationMessage["inline-html-dropped"],
+								line: inlineLine(),
+								snippet: htmlInlineSnippet
+							});
+						}
 					}
-					case "html_inline": consolidatedOptions.html.inline === "text" && addSpan(childToken.content);
 				}
 				break;
 			}
-			case "alert_open":
-				flushBlock(), calloutStartTarget = blockTarget(), calloutStartIndex = calloutStartTarget.length, calloutType = token.markup, currentBlockquoteStyle = consolidatedOptions.block.blockquote({ context: { schema: consolidatedOptions.schema } }) ?? consolidatedOptions.block.normal({ context: { schema: consolidatedOptions.schema } }) ?? "normal";
+			case "alert_open": {
+				flushBlock(), calloutStartTarget = blockTarget(), calloutStartIndex = calloutStartTarget.length, calloutType = token.markup, calloutStartLine = lineOf(token);
+				let blockquoteStyle = consolidatedOptions.block.blockquote({ context: { schema: consolidatedOptions.schema } });
+				calloutPendingStyleFallbacks = [], blockquoteStyle || calloutPendingStyleFallbacks.push("blockquote");
+				let style = blockquoteStyle ?? consolidatedOptions.block.normal({ context: { schema: consolidatedOptions.schema } });
+				style || calloutPendingStyleFallbacks.push("normal"), currentBlockquoteStyle = style ?? "normal";
+				break;
+			}
+			case "alert_title":
+				calloutStartLine = lineOf(token);
 				break;
-			case "alert_title": break;
 			case "alert_close":
-				if (flushBlock(), calloutStartIndex !== null && calloutType !== null && calloutStartTarget !== null) {
+				if (flushBlock(), calloutPendingStyleFallbacks = [], calloutStartIndex !== null && calloutType !== null && calloutStartTarget !== null) {
 					let contentBlocks = calloutStartTarget.splice(calloutStartIndex), calloutObject = consolidatedOptions.types.callout?.({
 						context: {
 							schema: consolidatedOptions.schema,
@@ -1390,14 +2250,864 @@ function markdownToPortableText(markdown, options) {
 						},
 						isInline: !1
 					});
-					if (calloutObject) pushBlock(calloutObject);
-					else for (let block of contentBlocks) pushBlock(block);
+					if (calloutObject) reportFieldsDropped(calloutObject, calloutStartLine), pushBlock(calloutObject);
+					else {
+						report({
+							type: "callout-fallback",
+							message: degradationMessage["callout-fallback"](calloutType, currentBlockquoteStyle ?? "normal"),
+							line: calloutStartLine
+						});
+						for (let block of contentBlocks) pushBlock(block);
+					}
 				}
-				calloutStartIndex = null, calloutStartTarget = null, calloutType = null, currentBlockquoteStyle = null;
+				calloutStartIndex = null, calloutStartTarget = null, calloutType = null, calloutStartLine = void 0, currentBlockquoteStyle = null;
+		}
+	}
+	return flushBlock(), degradationEvents.length > 0 && options?.onDegradation?.({
+		degradations: degradationEvents,
+		message: buildDegradationMessage(degradationEvents)
+	}), portableText;
+}
+/**
+* A `json:object` fence always reconstructs its object, schema or no
+* schema: the fence carries its own `_type`, and degrading it to a code
+* block would reintroduce the loss the syntax exists to remove. Returns
+* `undefined` instead of throwing, so an unusable fence falls through to
+* the regular code path.
+*/
+function parseJsonObjectFence(code) {
+	let parsed;
+	try {
+		parsed = JSON.parse(code);
+	} catch {
+		return;
+	}
+	if (typeof parsed != "object" || !parsed || Array.isArray(parsed)) return;
+	let objectValue = parsed;
+	if (typeof objectValue._type == "string" && objectValue._type.length !== 0) return objectValue;
+}
+/**
+* Deliberately high pending calibration against real agent edit
+* traces: a wrong match moves anchors onto unrelated text, a fresh
+* key resets one block.
+*/
+const MIN_BLOCK_SIMILARITY = .8, MAX_SIMILARITY_PAIRS = 2500;
+/**
+* Converts edited markdown to Portable Text, restores stored keys, and
+* restores fields the markdown dialect cannot express (dropped by
+* serialization, so the edit could not have touched them); a field
+* markdown does express follows the edit. The same rule covers a
+* custom style or decorator markdown has no syntax for, coerced to a
+* built-in on the round trip. An empty or whitespace-only text block
+* is the same case taken to the whole block: markdown has no form for
+* either, so it is restored next to its surviving neighbor and
+* dropped along with that neighbor if the neighbor does not survive.
+* Keys aim for what the
+* same edit would have produced in an editor:
+* unchanged, moved, and rewritten-in-place content keeps its keys
+* (rewriting a paragraph in place keeps its identity, like typing over
+* it), a split keeps the key on its first non-empty fragment, a merge
+* keeps the first source block's key, and a `json:object` payload keeps
+* the key it carries, unless reconciliation matches it to stored
+* content, which takes the stored key even over a differing key in the
+* payload. When an insertion or deletion makes positions ambiguous,
+* only clear similarity evidence adopts a key and everything else gets
+* a new one; gathering that evidence is time-capped, so on very large
+* ambiguous edits the set of adopted keys can differ across machine
+* speeds, degrading toward fresh keys.
+* Output keys are unique among siblings. The function does not mutate
+* `storedPortableText` and returns a value, not patches. The `schema`
+* is taken once and governs both directions; pass the same `serialize`
+* options that produced the markdown that was edited. A throwing or
+* stateful custom matcher or renderer propagates or degrades matching
+* respectively.
+* Reconciliation never merges concurrent edits: compare the stored
+* field against the live document before writing the result back.
+* The trades in one line: same-position replacement inherits identity,
+* a count-preserving rewrite pairs positionally (block-level and
+* sibling-level alike), and evidence gathering is capped, degrading to
+* fresh keys.
+*
+* @public
+*/
+function applyMarkdownEdit(storedPortableText, editedMarkdown, options) {
+	let onReconciliation = options?.onReconciliation, recorder = onReconciliation ? {
+		preservationBasis: /* @__PURE__ */ new WeakMap(),
+		renamePreviousKey: /* @__PURE__ */ new WeakMap(),
+		annotationKeyConflicts: [],
+		ambiguousRegionGroups: [],
+		skipReason: void 0
+	} : void 0, result = structuredClone(markdownToPortableText(editedMarkdown, {
+		...options?.deserialize,
+		schema: options?.schema
+	})), canonical = canonicalizeStored(storedPortableText, options), originOf = traceOrigins(nonEmptyBlocks(storedPortableText, options), canonical, recorder), adoptedNodes = /* @__PURE__ */ new WeakSet();
+	if (originOf) {
+		let alignment = alignBlocks(canonical, result, recorder);
+		if (alignment) {
+			adoptAnchors(alignment.anchors, originOf, result, adoptedNodes, recorder);
+			let gaps = adoptMoves(alignment.gaps, canonical, result, originOf, adoptedNodes, recorder);
+			for (let gap of gaps) resolveGap(gap.storedIndexes, gap.editedIndexes, canonical, result, originOf, adoptedNodes, recorder);
+			reinsertEmptyRuns(storedPortableText, result, adoptedNodes, options, recorder);
+		}
+	}
+	return enforceSiblingKeyUniqueness(result, options?.deserialize?.keyGenerator ?? defaultKeyGenerator, adoptedNodes, recorder), recorder && onReconciliation && onReconciliation(buildReconciliationReport(result, recorder)), result;
+}
+/**
+* Re-expresses the stored value in the parser's dialect by serializing
+* it and parsing it right back: the parser merges same-mark sibling
+* spans, reorders marks, collapses list levels, and fills defaults, so
+* content the edit never touched only deep-equals its parsed
+* counterpart after both sides have been through the same round trip.
+* The replacement keys are positional (`__canonical_<n>`), so a match
+* against canonical node `n` can be traded back for stored node `n`'s
+* real `_key`.
+*/
+function canonicalizeStored(stored, options) {
+	let storedMarkdown = portableTextToMarkdown(structuredClone(stored), {
+		...options?.serialize,
+		schema: options?.schema
+	}), { onDegradation, ...canonicalDeserializeOptions } = options?.deserialize ?? {}, canonicalKeyCounter = 0;
+	return markdownToPortableText(storedMarkdown, {
+		...canonicalDeserializeOptions,
+		schema: options?.schema,
+		keyGenerator: () => `__canonical_${canonicalKeyCounter++}`
+	});
+}
+/**
+* Positional pairing between `stored` and `canonical` is only
+* trustworthy when serialization preserved the node count and the
+* type sequence; when it did not (heading hard-break splits, lossy
+* table normalization), no key can be traced back to its owner, so
+* nothing adopts. `stored` is already the non-empty subsequence: empty
+* text blocks have no markdown form, so `canonical` never carries them
+* either, and `reinsertEmptyRuns` restores them afterward.
+*/
+function traceOrigins(stored, canonical, recorder) {
+	if (canonical.length !== stored.length) {
+		recorder && (recorder.skipReason = "round-trip-mismatch");
+		return;
+	}
+	for (let index = 0; index < stored.length; index++) if (stored[index]._type !== canonical[index]?._type) {
+		recorder && (recorder.skipReason = "round-trip-mismatch");
+		return;
+	}
+	for (let index = 0; index < stored.length; index++) {
+		let storedNode = stored[index], canonicalNode = canonical[index];
+		if (isTextBlock$1(storedNode) && isTextBlock$1(canonicalNode) && blockText(storedNode).trim() !== blockText(canonicalNode).trim()) {
+			recorder && (recorder.skipReason = "round-trip-mismatch");
+			return;
+		}
+	}
+	return (canonicalIndex) => stored[canonicalIndex];
+}
+/**
+* Equal runs become anchor pairs (so repeated content pairs
+* first-to-first when adopted), and the delete/insert runs between
+* them form the gaps.
+*/
+function alignBlocks(canonical, result, recorder) {
+	let tokenByNeutral = /* @__PURE__ */ new Map(), tokenOf = (node) => {
+		let neutral = neutralForm(node), token = tokenByNeutral.get(neutral);
+		return token === void 0 && (token = String.fromCharCode(tokenByNeutral.size + 1), tokenByNeutral.set(neutral, token)), token;
+	}, canonicalTokens = canonical.map(tokenOf).join(""), resultTokens = result.map(tokenOf).join("");
+	if (tokenByNeutral.size > 55e3) {
+		recorder && (recorder.skipReason = "document-too-large");
+		return;
+	}
+	let diffs = makeDiff(canonicalTokens, resultTokens, { checkLines: !1 }), anchors = [], gaps = [], gap = {
+		storedIndexes: [],
+		editedIndexes: []
+	}, flushGap = () => {
+		(gap.storedIndexes.length > 0 || gap.editedIndexes.length > 0) && (gaps.push(gap), gap = {
+			storedIndexes: [],
+			editedIndexes: []
+		});
+	}, canonicalIndex = 0, resultIndex = 0;
+	for (let [operation, text] of diffs) if (operation === 0) {
+		flushGap();
+		for (let offset = 0; offset < text.length; offset++) anchors.push({
+			canonicalIndex,
+			resultIndex
+		}), canonicalIndex++, resultIndex++;
+	} else if (operation === -1) for (let offset = 0; offset < text.length; offset++) gap.storedIndexes.push(canonicalIndex++);
+	else for (let offset = 0; offset < text.length; offset++) gap.editedIndexes.push(resultIndex++);
+	return flushGap(), {
+		anchors,
+		gaps
+	};
+}
+function adoptAnchors(anchors, originOf, result, adoptedNodes, recorder) {
+	for (let anchor of anchors) result[anchor.resultIndex] = adoptVerbatim(originOf(anchor.canonicalIndex), result[anchor.resultIndex], adoptedNodes, "content-unchanged", recorder);
+}
+/**
+* An anchor or a unique exact leftover pairs a canonical block against
+* a parsed one that share the same neutral form (that is what put them
+* in the same equal-diff run or the same neutral-form bucket), so
+* everything the dialect can express is untouched and everything it
+* cannot express was invisible to the edit. The stored subtree is the
+* truth at every depth, spans, marks, markDefs, and any field the
+* dialect drops, so adoption replaces the whole node rather than
+* reconciling into the parsed shape (which would otherwise, for
+* instance, keep a parser-side span merge that collapsed an
+* unmappable mark boundary the edit never touched). `restoreFields`
+* and per-child reconciliation are skipped entirely: a verbatim clone
+* of the stored node is already complete.
+*/
+function adoptVerbatim(original, target, adoptedNodes, basis, recorder) {
+	let clone = structuredClone(original);
+	return fillMissingKeysFromTarget(clone, target), markSubtreeAdopted(clone, adoptedNodes), recorder && (tagSubtreePreserved(clone, recorder), basis !== "content-unchanged" && typeof clone._key == "string" && recorder.preservationBasis.set(clone, basis)), clone;
+}
+/**
+* A stored node practically always carries its own `_key`; when it
+* genuinely does not, there is nothing to adopt, so the clone keeps
+* whatever key the plain parse already minted at the corresponding
+* position, the same key adoption would have left in place. The walk
+* follows both trees positionally (not by content matching, which is
+* exactly what an exact-signature match already guarantees agrees at
+* every position the two sides both still have).
+*/
+function fillMissingKeysFromTarget(clone, target) {
+	typeof clone._key != "string" && typeof target._key == "string" && (clone._key = target._key);
+	for (let field of Object.keys(clone)) {
+		let cloneValue = clone[field], targetValue = target[field];
+		if (isTypedObjectArray(cloneValue) && isTypedObjectArray(targetValue)) {
+			let length = Math.min(cloneValue.length, targetValue.length);
+			for (let index = 0; index < length; index++) fillMissingKeysFromTarget(cloneValue[index], targetValue[index]);
+		} else typeof cloneValue == "object" && cloneValue && !Array.isArray(cloneValue) && typeof targetValue == "object" && targetValue && !Array.isArray(targetValue) && fillMissingKeysFromTarget(cloneValue, targetValue);
+	}
+}
+/**
+* Every keyed node in a verbatim clone is adopted, not only its root:
+* the sibling-key-uniqueness pass recurses into every nested keyed
+* array, and an adopted-first ordering there only favors a clone's
+* descendants if they are themselves marked adopted.
+*/
+function markSubtreeAdopted(node, adoptedNodes) {
+	adoptedNodes.add(node);
+	for (let value of Object.values(node)) if (Array.isArray(value) && value.every((item) => typeof item == "object" && !!item) && value.length > 0) for (let child of value) markSubtreeAdopted(child, adoptedNodes);
+	else typeof value == "object" && value && markSubtreeAdopted(value, adoptedNodes);
+}
+/**
+* Moves: content that left one gap and reappeared in another. Unique
+* exact pairs across all gaps adopt before any gap-local pairing can
+* consume the keys they need.
+*/
+function adoptMoves(gaps, canonical, result, originOf, adoptedNodes, recorder) {
+	let consumedStored = /* @__PURE__ */ new Set(), consumedEdited = /* @__PURE__ */ new Set(), storedLeftovers = gaps.flatMap((g) => g.storedIndexes), editedLeftovers = gaps.flatMap((g) => g.editedIndexes), storedByNeutral = /* @__PURE__ */ new Map();
+	for (let index of storedLeftovers) {
+		let neutral = neutralForm(canonical[index]);
+		storedByNeutral.set(neutral, [...storedByNeutral.get(neutral) ?? [], index]);
+	}
+	let editedByNeutral = /* @__PURE__ */ new Map();
+	for (let index of editedLeftovers) {
+		let neutral = neutralForm(result[index]);
+		editedByNeutral.set(neutral, [...editedByNeutral.get(neutral) ?? [], index]);
+	}
+	for (let [neutral, storedIndexes] of storedByNeutral) {
+		let editedIndexes = editedByNeutral.get(neutral);
+		if (storedIndexes.length !== 1 || !editedIndexes || editedIndexes.length !== 1) continue;
+		consumedStored.add(storedIndexes[0]), consumedEdited.add(editedIndexes[0]);
+		let clone = adoptVerbatim(originOf(storedIndexes[0]), result[editedIndexes[0]], adoptedNodes, "content-moved", recorder);
+		result[editedIndexes[0]] = clone;
+	}
+	return gaps.map((currentGap) => ({
+		storedIndexes: currentGap.storedIndexes.filter((index) => !consumedStored.has(index)),
+		editedIndexes: currentGap.editedIndexes.filter((index) => !consumedEdited.has(index))
+	}));
+}
+/**
+* Gap policy, in order: split/merge survivor (the first fragment or
+* first source block keeps the key, matching what pressing enter or
+* backspace does in the editor), positional zip for equal counts
+* (typing over a paragraph keeps its identity), similarity for
+* unequal counts (an insertion or deletion shifted positions, so
+* position lies and only mutual unique best evidence adopts).
+*/
+function resolveGap(storedIndexes, editedIndexes, canonical, result, originOf, adoptedNodes, recorder) {
+	let remainingStored = new Set(storedIndexes), remainingEdited = new Set(editedIndexes), withinConcatenationCap = storedIndexes.length * editedIndexes.length <= MAX_SIMILARITY_PAIRS;
+	if (withinConcatenationCap) for (let storedIndex of storedIndexes) {
+		if (!remainingStored.has(storedIndex)) continue;
+		let storedBlock = canonical[storedIndex];
+		if (!isTextBlock$1(storedBlock)) continue;
+		let fragments = findConcatenation(blockText(storedBlock), editedIndexes.filter((index) => remainingEdited.has(index)), result);
+		if (fragments) {
+			remainingStored.delete(storedIndex);
+			for (let fragment of fragments) remainingEdited.delete(fragment);
+			let survivor = fragments.find((fragment) => blockText(result[fragment]).length > 0) ?? fragments[0];
+			adoptNode(originOf(storedIndex), canonical[storedIndex], result[survivor], adoptedNodes, "content-split", recorder);
+		}
+	}
+	if (withinConcatenationCap) for (let editedIndex of editedIndexes) {
+		if (!remainingEdited.has(editedIndex)) continue;
+		let editedBlock = result[editedIndex];
+		if (!isTextBlock$1(editedBlock)) continue;
+		let sources = findConcatenation(blockText(editedBlock), storedIndexes.filter((index) => remainingStored.has(index)), canonical);
+		if (sources) {
+			remainingEdited.delete(editedIndex);
+			for (let source of sources) remainingStored.delete(source);
+			adoptNode(originOf(sources[0]), canonical[sources[0]], result[editedIndex], adoptedNodes, "content-merged", recorder);
 		}
 	}
-	return flushBlock(), portableText;
+	let storedRest = [...remainingStored], editedRest = [...remainingEdited];
+	if (storedRest.length === editedRest.length) {
+		for (let offset = 0; offset < storedRest.length; offset++) {
+			let storedBlock = canonical[storedRest[offset]], editedBlock = result[editedRest[offset]];
+			storedBlock._type === editedBlock._type && adoptNode(originOf(storedRest[offset]), canonical[storedRest[offset]], editedBlock, adoptedNodes, "same-position", recorder);
+		}
+		return;
+	}
+	if (storedRest.length * editedRest.length > MAX_SIMILARITY_PAIRS) {
+		recorder && recorder.ambiguousRegionGroups.push(editedRest.map((editedIndex) => result[editedIndex]));
+		return;
+	}
+	let scores = /* @__PURE__ */ new Map();
+	for (let storedIndex of storedRest) for (let editedIndex of editedRest) {
+		let score = blockSimilarity(canonical[storedIndex], result[editedIndex]);
+		score >= MIN_BLOCK_SIMILARITY && scores.set(`${storedIndex}:${editedIndex}`, score);
+	}
+	for (let storedIndex of storedRest) {
+		let best = uniqueBest(editedRest, (editedIndex) => scores.get(`${storedIndex}:${editedIndex}`));
+		best !== void 0 && uniqueBest(storedRest, (otherStoredIndex) => scores.get(`${otherStoredIndex}:${best}`)) === storedIndex && adoptNode(originOf(storedIndex), canonical[storedIndex], result[best], adoptedNodes, "similar-content", recorder);
+	}
+}
+/**
+* Fragments join with nothing or a single space, since a markdown
+* merge is often a soft-wrap join that inserts one ("alpha\nbeta"
+* parses to "alpha beta").
+*/
+function findConcatenation(wholeText, candidateIndexes, nodes) {
+	if (wholeText.length !== 0) for (let joiner of ["", " "]) for (let start = 0; start < candidateIndexes.length; start++) {
+		let concatenated = "", used = [];
+		for (let position = start; position < candidateIndexes.length; position++) {
+			let index = candidateIndexes[position];
+			if (position > start && candidateIndexes[position - 1] !== index - 1 || !isTextBlock$1(nodes[index]) || (concatenated = used.length === 0 ? blockText(nodes[index]) : concatenated + joiner + blockText(nodes[index]), used.push(index), concatenated.length > wholeText.length)) break;
+			if (concatenated === wholeText && used.length > 1) return used;
+		}
+	}
+}
+/**
+* Adopts the original node's `_key`, its markdown-inexpressible
+* fields, then its `markDefs` before its other keyed children, since
+* `span.marks` references need the adopted `markDefs` keys already in
+* place.
+*/
+function adoptNode(original, canonicalCounterpart, target, adoptedNodes, basis, recorder) {
+	adoptedNodes.add(target), typeof original._key == "string" && (target._key = original._key, recorder?.preservationBasis.set(target, basis)), restoreFields(original, canonicalCounterpart, target), rewriteMarkReferences(target, adoptMarkDefs(original, canonicalCounterpart, target, recorder));
+	for (let field of Object.keys(target)) {
+		if (field === "markDefs") continue;
+		let originalChildren = original[field], targetChildren = target[field];
+		if (!isTypedObjectArray(originalChildren) || !isTypedObjectArray(targetChildren)) continue;
+		let canonicalChildren = canonicalChildArray(canonicalCounterpart, field, originalChildren), matchedOriginal = /* @__PURE__ */ new Set(), matchedTarget = /* @__PURE__ */ new Set(), originalGroups = groupByNeutralForm(originalChildren, matchedOriginal, buildAliasMap(original)), targetGroups = groupByNeutralForm(targetChildren, matchedTarget, buildAliasMap(target));
+		for (let [neutral, originalIndexes] of originalGroups) {
+			let targetIndexes = targetGroups.get(neutral);
+			originalIndexes.length !== 1 || !targetIndexes || targetIndexes.length !== 1 || (matchedOriginal.add(originalIndexes[0]), matchedTarget.add(targetIndexes[0]), adoptNode(originalChildren[originalIndexes[0]], canonicalChildren?.[originalIndexes[0]], targetChildren[targetIndexes[0]], adoptedNodes, "content-unchanged", recorder));
+		}
+		field === "children" && originalChildren.length * targetChildren.length <= MAX_SIMILARITY_PAIRS && adoptMergedSpans(originalChildren, canonicalChildren, matchedOriginal, targetChildren, matchedTarget, adoptedNodes, recorder), adoptResidualZip(originalChildren, canonicalChildren, matchedOriginal, targetChildren, matchedTarget, adoptedNodes, recorder);
+	}
+}
+/**
+* The container-level counterpart of `traceOrigins`'s guard: a
+* child's canonical form is only trustworthy when the canonical
+* container holds the same field as the same typed object array,
+* equal in length and `_type` sequence to the original's, so pairing
+* by index (original child `i` to canonical child `i`) means the same
+* content on both sides.
+*/
+function canonicalChildArray(canonicalCounterpart, field, originalChildren) {
+	if (!canonicalCounterpart) return;
+	let candidate = canonicalCounterpart[field];
+	if (!(!isTypedObjectArray(candidate) || candidate.length !== originalChildren.length)) {
+		for (let index = 0; index < originalChildren.length; index++) if (originalChildren[index]._type !== candidate[index]._type) return;
+		return candidate;
+	}
+}
+/**
+* Restores fields the markdown dialect dropped or altered: present on
+* the original, unchanged by the edit (the target still agrees with
+* the original's own canonical round trip), and different on that
+* round trip from the original (so the parse, left to itself, could
+* never have produced the original's value). Absence counts as a
+* value under both comparisons, which is what folds a wholly dropped
+* field (no markdown form at all) and a coerced one (a custom style
+* or decorator markdown silently maps to its closest built-in) into
+* one rule. Structural child arrays (`children`, `markDefs`, and
+* typed object arrays generally) are excluded: their elements adopt
+* individually through the recursive per-child walk instead, except
+* when the target has no such element to walk at all: a typed-object
+* array field the dialect drops entirely leaves nothing on the target
+* side for that walk to reconcile, so it falls through to the same
+* absent-on-target, absent-on-canonical oracle as every scalar field,
+* restored verbatim rather than left missing. Restored values are
+* cloned, since the sibling-key-uniqueness pass may rewrite `_key`s
+* inside a restored array of objects, and the original must stay
+* untouched.
+*/
+function restoreFields(original, canonicalCounterpart, target) {
+	if (canonicalCounterpart) for (let field of Object.keys(original)) {
+		if (field === "_key" || field === "_type" || field === "markDefs" || field === "children") continue;
+		if (isTypedObjectArray(original[field])) {
+			target[field] === void 0 && canonicalCounterpart[field] === void 0 && (target[field] = structuredClone(original[field]));
+			continue;
+		}
+		let canonicalValue = canonicalCounterpart[field];
+		valuesEqual(target[field], canonicalValue) && (valuesEqual(canonicalValue, original[field]) || (target[field] = structuredClone(original[field])));
+	}
+}
+/**
+* Deep equality for restoration's before/after comparison: the
+* `encodeNeutral` encoding without alias rewriting, so it compares
+* `marks` arrays (and any other array or nested object) by value
+* rather than by identity. Absent (`undefined`) encodes to the same
+* string on both sides, so two absent fields count as equal.
+*/
+function valuesEqual(a, b) {
+	return encodeNeutral(a, void 0) === encodeNeutral(b, void 0);
+}
+/**
+* A span in the edited output can be the merge of several stored
+* spans: the parser merges adjacent same-mark spans, and an edit that
+* removes formatting merges across the old mark boundary too. Matching
+* is by text alone, and the first contributor's key survives, matching
+* the editor's own span-merge normalization.
+*/
+function adoptMergedSpans(originalChildren, canonicalChildren, matchedOriginal, targetChildren, matchedTarget, adoptedNodes, recorder) {
+	for (let targetIndex = 0; targetIndex < targetChildren.length; targetIndex++) {
+		if (matchedTarget.has(targetIndex)) continue;
+		let targetSpan = targetChildren[targetIndex], targetText = targetSpan.text;
+		if (typeof targetText == "string") for (let start = 0; start < originalChildren.length; start++) {
+			if (matchedOriginal.has(start)) continue;
+			let concatenated = "", used = [];
+			for (let index = start; index < originalChildren.length && !matchedOriginal.has(index); index++) {
+				let originalSpan = originalChildren[index];
+				if (typeof originalSpan.text != "string" || (concatenated += originalSpan.text, used.push(index), concatenated.length > targetText.length)) break;
+				if (concatenated === targetText && used.length > 1) {
+					matchedTarget.add(targetIndex);
+					for (let usedIndex of used) matchedOriginal.add(usedIndex);
+					adoptNode(originalChildren[used[0]], canonicalChildren?.[used[0]], targetSpan, adoptedNodes, "content-merged", recorder);
+					break;
+				}
+			}
+			if (matchedTarget.has(targetIndex)) break;
+		}
+	}
+}
+/**
+* The equal-count residual rule, mirroring `resolveGap`'s positional
+* zip: elements left unmatched after neutral-form (and, for
+* `children`, span-merge) matching are treated as in-place edits when
+* both sides leave the same count, position being the same evidence
+* the block-level zip already trusts, and the trade is the same too:
+* a reorder-plus-edit with balanced counts mispairs. Unequal counts
+* adopt nothing, since position no longer lines up.
+*/
+function adoptResidualZip(originalChildren, canonicalChildren, matchedOriginal, targetChildren, matchedTarget, adoptedNodes, recorder) {
+	let originalRest = originalChildren.map((node, index) => ({
+		node,
+		index
+	})).filter(({ index }) => !matchedOriginal.has(index)), targetRest = targetChildren.filter((_, index) => !matchedTarget.has(index));
+	if (originalRest.length === targetRest.length) for (let offset = 0; offset < originalRest.length; offset++) {
+		let originalNode = originalRest[offset].node, targetNode = targetRest[offset];
+		originalNode._type === targetNode._type && adoptNode(originalNode, canonicalChildren?.[originalRest[offset].index], targetNode, adoptedNodes, "same-position", recorder);
+	}
+}
+/**
+* Matches `markDefs` by definition content, `_key` excluded. Returns
+* the mapping from the target's fresh keys to the adopted stored
+* keys, for rewriting `span.marks` references.
+*/
+function adoptMarkDefs(original, canonicalCounterpart, target, recorder) {
+	let keyMap = /* @__PURE__ */ new Map(), originalDefs = original.markDefs, targetDefs = target.markDefs;
+	if (!isTypedObjectArray(originalDefs) || !isTypedObjectArray(targetDefs)) return keyMap;
+	let canonicalDefs = canonicalChildArray(canonicalCounterpart, "markDefs", originalDefs), matchedOriginal = /* @__PURE__ */ new Set(), matchedTarget = /* @__PURE__ */ new Set(), originalGroups = groupByNeutralForm(originalDefs.map((def, index) => canonicalDefs?.[index] ?? def), matchedOriginal), targetGroups = groupByNeutralForm(targetDefs, matchedTarget), adoptDef = (originalDef, canonicalDef, targetDef, basis) => {
+		if (restoreFields(originalDef, canonicalDef, targetDef), typeof originalDef._key == "string" && typeof targetDef._key == "string") {
+			let adoptedKey = originalDef._key;
+			if (targetDefs.some((def) => def !== targetDef && def._key === adoptedKey)) {
+				recorder?.annotationKeyConflicts.push(targetDef);
+				return;
+			}
+			keyMap.set(targetDef._key, adoptedKey), targetDef._key = adoptedKey, recorder?.preservationBasis.set(targetDef, basis);
+		}
+	};
+	for (let [neutral, originalIndexes] of originalGroups) {
+		let targetIndexes = targetGroups.get(neutral);
+		if (!(!targetIndexes || targetIndexes.length !== originalIndexes.length)) for (let offset = 0; offset < originalIndexes.length; offset++) matchedOriginal.add(originalIndexes[offset]), matchedTarget.add(targetIndexes[offset]), adoptDef(originalDefs[originalIndexes[offset]], canonicalDefs?.[originalIndexes[offset]], targetDefs[targetIndexes[offset]], originalIndexes.length === 1 ? "content-unchanged" : "same-position");
+	}
+	let originalRest = originalDefs.map((node, index) => ({
+		node,
+		index
+	})).filter(({ index }) => !matchedOriginal.has(index)), targetRest = targetDefs.filter((_, index) => !matchedTarget.has(index));
+	return originalRest.length === 1 && targetRest.length === 1 && originalRest[0].node._type === targetRest[0]._type && adoptDef(originalRest[0].node, canonicalDefs?.[originalRest[0].index], targetRest[0], "same-position"), keyMap;
+}
+function rewriteMarkReferences(block, keyMap) {
+	if (keyMap.size === 0) return;
+	let children = block.children;
+	if (isTypedObjectArray(children)) for (let child of children) {
+		let marks = child.marks;
+		Array.isArray(marks) && (child.marks = marks.map((mark) => typeof mark == "string" && keyMap.has(mark) ? keyMap.get(mark) : mark));
+	}
+}
+function groupByNeutralForm(nodes, exclude, aliasByKey) {
+	let groups = /* @__PURE__ */ new Map();
+	for (let index = 0; index < nodes.length; index++) {
+		if (exclude.has(index)) continue;
+		let neutral = aliasByKey ? encodeNeutral(nodes[index], aliasByKey) : neutralForm(nodes[index]), group = groups.get(neutral);
+		group ? group.push(index) : groups.set(neutral, [index]);
+	}
+	return groups;
+}
+/**
+* A canonical JSON encoding that erases identity: `_key` properties
+* are dropped, object properties are sorted, and annotation `_key`
+* references inside `span.marks` are rewritten to the definition's
+* position in `markDefs` (dropping `_key` alone would compare the
+* stored annotation key against the fresh one and reject an unchanged
+* link).
+*/
+function neutralForm(node) {
+	return encodeNeutral(node, buildAliasMap(node));
+}
+/**
+* Aliases each `markDefs` key to a key-independent spelling of the
+* definition itself, so `span.marks` references compare by what the
+* annotation is rather than which key it carries. The spelling is the
+* definition's own neutral form, not its array position: aliasing by
+* position made every annotated sibling span's neutral form shift when
+* a definition was inserted or removed before its own, so adding one
+* link re-keyed unrelated annotated spans. Identical definitions (the
+* same link twice) are disambiguated by occurrence order among
+* identical forms only, which no unrelated insertion can shift.
+*/
+function buildAliasMap(node) {
+	let markDefs = node.markDefs;
+	if (!isTypedObjectArray(markDefs)) return;
+	let aliasByKey = /* @__PURE__ */ new Map(), occurrenceByForm = /* @__PURE__ */ new Map();
+	for (let definition of markDefs) {
+		let key = definition._key;
+		if (typeof key != "string") continue;
+		let form = encodeNeutral(definition, void 0), occurrence = occurrenceByForm.get(form) ?? 0;
+		occurrenceByForm.set(form, occurrence + 1), aliasByKey.set(key, `@annotation:${occurrence}:${form}`);
+	}
+	return aliasByKey;
+}
+function encodeNeutral(value, aliasByKey) {
+	return Array.isArray(value) ? `[${value.map((item) => encodeNeutral(item, aliasByKey)).join(",")}]` : typeof value == "object" && value ? `{${Object.entries(value).filter(([field]) => field !== "_key").sort(([a], [b]) => a < b ? -1 : +(a > b)).map(([field, fieldValue]) => {
+		if (field === "marks" && aliasByKey && Array.isArray(fieldValue)) {
+			let aliased = fieldValue.map((mark) => typeof mark == "string" && aliasByKey.has(mark) ? aliasByKey.get(mark) : mark);
+			return `${JSON.stringify(field)}:${JSON.stringify(aliased)}`;
+		}
+		return `${JSON.stringify(field)}:${encodeNeutral(fieldValue, aliasByKey)}`;
+	}).join(",")}}` : JSON.stringify(value) ?? "undefined";
+}
+/**
+* The block's comparison text: concatenated span text with inline
+* objects as sentinels. Marks are ignored, since a formatting-only
+* edit does not change textual identity.
+*/
+function blockText(block) {
+	let children = block.children;
+	return isTypedObjectArray(children) ? children.map((child) => typeof child.text == "string" ? child.text : "").join("") : "";
+}
+/**
+* Text similarity in `[0, 1]`, gated to `0` unless the block shells
+* agree and the inline objects are compatible: however alike the
+* prose, blocks that disagree on structure are not the same block.
+* The length prescreen skips the diff when the size difference alone
+* puts the score under `MIN_BLOCK_SIMILARITY`.
+*/
+function blockSimilarity(canonicalBlock, resultBlock) {
+	if (!shellEquals(canonicalBlock, resultBlock) || !inlineObjectsCompatible(canonicalBlock, resultBlock)) return 0;
+	let canonicalText = blockText(canonicalBlock), resultText = blockText(resultBlock);
+	if (canonicalText.length === 0 || resultText.length === 0) return 0;
+	let longer = Math.max(canonicalText.length, resultText.length);
+	return 1 - Math.abs(canonicalText.length - resultText.length) / longer < MIN_BLOCK_SIMILARITY ? 0 : 1 - levenshteinFromDiffs(cleanupEfficiency(makeDiff(canonicalText, resultText, { timeout: .05 }))) / longer;
+}
+/**
+* The distance derivation from diff runs: insertions and deletions
+* between equality runs accumulate as the larger of the two, so a
+* delete-plus-insert counts as one substitution.
+*/
+function levenshteinFromDiffs(diffs) {
+	let distance = 0, insertions = 0, deletions = 0;
+	for (let [operation, text] of diffs) operation === 1 ? insertions += text.length : operation === -1 ? deletions += text.length : (distance += Math.max(insertions, deletions), insertions = 0, deletions = 0);
+	return distance + Math.max(insertions, deletions);
+}
+/**
+* The block minus its content: `_type`, `style`, `listItem`, `level`,
+* and any custom fields must agree before text similarity means
+* anything.
+*/
+function shellEquals(a, b) {
+	let shellOf = (node) => encodeNeutral(Object.fromEntries(Object.entries(node).filter(([field]) => field !== "children" && field !== "markDefs")), void 0);
+	return shellOf(a) === shellOf(b);
+}
+/**
+* Inline objects are opaque content: two blocks whose objects differ
+* are different blocks no matter how similar their prose is.
+*/
+function inlineObjectsCompatible(a, b) {
+	let objectsOf = (node) => {
+		let children = node.children;
+		return isTypedObjectArray(children) ? children.filter((child) => typeof child.text != "string") : [];
+	}, aObjects = objectsOf(a), bObjects = objectsOf(b);
+	return aObjects.length === bObjects.length && aObjects.every((aObject, index) => {
+		let bObject = bObjects[index];
+		return aObject._type === bObject._type ? typeof aObject._key == "string" && aObject._key === bObject._key || neutralForm(aObject) === neutralForm(bObject) : !1;
+	});
+}
+/**
+* The highest-scoring candidate, or `undefined` on a tie: a tie is
+* ambiguity, and ambiguity refuses adoption rather than guessing.
+*/
+function uniqueBest(candidates, scoreOf) {
+	let best, bestScore = 0, tied = !1;
+	for (let candidate of candidates) {
+		let score = scoreOf(candidate);
+		score !== void 0 && (score > bestScore ? (best = candidate, bestScore = score, tied = !1) : score === bestScore && best !== void 0 && (tied = !0));
+	}
+	return tied ? void 0 : best;
+}
+/**
+* Deliberately loose: any node with a `children` array reconciles like
+* a text block, custom block types included.
+*/
+function isTextBlock$1(node) {
+	return Array.isArray(node.children);
+}
+/**
+* A text block the round trip drops. Whether a whitespace-only block
+* survives serialize→parse depends on the converters, not on
+* structure: a heading renders `## ` and survives, a custom style
+* falls back to a plain paragraph and vanishes, and a non-breaking
+* space renders "blank-looking" output the parser still keeps (JS
+* `trim` folds NBSP, CommonMark does not), so any string check here is
+* a hand-written mirror of one converter or the other that drifts. The
+* block's own render-then-reparse is the authority, the same round
+* trip `canonicalizeStored` performs, so this predicate cannot
+* disagree with the canonical node count. The JS-trim pre-check only
+* keeps the per-block round trip off paths that cannot qualify: it
+* over-admits candidates (NBSP text passes it), and the reparse then
+* decides.
+*/
+function isEmptyTextBlock(node, options) {
+	if (!(isTextBlock$1(node) && blockText(node).trim() === "")) return !1;
+	let rendered = portableTextToMarkdown([structuredClone(node)], {
+		...options?.serialize,
+		schema: options?.schema
+	});
+	if (rendered === "") return !0;
+	let { onDegradation: _onDegradation, ...deserializeOptions } = options?.deserialize ?? {}, probeKeyCounter = 0;
+	return markdownToPortableText(rendered, {
+		...deserializeOptions,
+		schema: options?.schema,
+		keyGenerator: () => `empty-probe-${probeKeyCounter++}`
+	}).length === 0;
+}
+/**
+* Blank lines are markdown's block separator, so an empty text block
+* has no serialized form: `canonicalizeStored`'s round trip drops it,
+* the same way `markdownToPortableText` would if it were parsed back
+* from `editedMarkdown`. Tracing origins and aligning blocks over this
+* subsequence keeps both sides the same length; `reinsertEmptyRuns`
+* restores the dropped blocks afterward.
+*/
+function nonEmptyBlocks(stored, options) {
+	return stored.filter((node) => !isEmptyTextBlock(node, options));
+}
+function isTypedObjectArray(value) {
+	return Array.isArray(value) && value.length > 0 && value.every((item) => typeof item == "object" && !!item && typeof item._type == "string");
+}
+/**
+* Maximal runs of empty text blocks, each paired with the surviving
+* neighbor its restoration hangs off: a run with a preceding block
+* anchors to it (insert after); a run at the document's start, with
+* none, anchors to the block that follows it (insert before). A run
+* with neither (the whole document is empty blocks) has nothing to
+* anchor to and is dropped.
+*/
+function findEmptyRuns(stored, options) {
+	let runs = [], index = 0;
+	for (; index < stored.length;) {
+		if (!isEmptyTextBlock(stored[index], options)) {
+			index++;
+			continue;
+		}
+		let runStart = index;
+		for (; index < stored.length && isEmptyTextBlock(stored[index], options);) index++;
+		let precedingBlock = runStart > 0 ? stored[runStart - 1] : void 0, followingBlock = index < stored.length ? stored[index] : void 0, anchor = precedingBlock ?? followingBlock;
+		anchor && typeof anchor._key == "string" && runs.push({
+			anchorKey: anchor._key,
+			insertAfter: precedingBlock !== void 0,
+			blocks: stored.slice(runStart, index)
+		});
+	}
+	return runs;
+}
+/**
+* Restores each empty run next to the result node that adopted its
+* anchor's key, found by `_key` since positions have already shifted
+* under insertion, deletion, and move. An anchor whose key did not
+* survive into `result` (its region was rewritten or deleted) drops
+* the run with it, consistent with rewrite semantics elsewhere in this
+* module. Runs are cloned and marked adopted, the same authoritative
+* status as every other restored key, so a collision resolves in
+* their favor like `enforceSiblingKeyUniqueness` already does for
+* `json:object` duplicates.
+*/
+function reinsertEmptyRuns(stored, result, adoptedNodes, options, recorder) {
+	for (let run of findEmptyRuns(stored, options)) {
+		let adoptedAnchorIndex = result.findIndex((node) => node._key === run.anchorKey && adoptedNodes.has(node)), anchorIndex = adoptedAnchorIndex === -1 ? result.findIndex((node) => node._key === run.anchorKey) : adoptedAnchorIndex;
+		if (anchorIndex === -1) continue;
+		let clones = run.blocks.map((block) => structuredClone(block));
+		for (let clone of clones) adoptedNodes.add(clone), recorder && tagSubtreePreserved(clone, recorder);
+		result.splice(run.insertAfter ? anchorIndex + 1 : anchorIndex, 0, ...clones);
+	}
+}
+/**
+* Every keyed node in a reinserted empty run is the stored value
+* verbatim, at every depth, so key resolution reporting tags the
+* whole subtree `content-unchanged` rather than only the run's top
+* block.
+*/
+function tagSubtreePreserved(node, recorder) {
+	typeof node._key == "string" && recorder.preservationBasis.set(node, "content-unchanged");
+	for (let value of Object.values(node)) if (Array.isArray(value) && value.every((item) => typeof item == "object" && !!item) && value.length > 0) for (let child of value) tagSubtreePreserved(child, recorder);
+	else typeof value == "object" && value && tagSubtreePreserved(value, recorder);
+}
+/**
+* `json:object` payloads transport their `_key` verbatim, so a
+* copy-pasted fence puts the same key on two siblings, and everything
+* downstream (patches, anchors, editor normalization) assumes sibling
+* keys are unique. Adopted keys are authoritative, so a duplicate that
+* was adopted from the stored value wins and the other occurrences are
+* regenerated.
+*/
+function enforceSiblingKeyUniqueness(nodes, keyGenerator, adoptedNodes, recorder, onKeyRewritten) {
+	let usedKeys = /* @__PURE__ */ new Set(), claim = (node) => {
+		let key = node._key;
+		if (typeof key == "string") {
+			if (usedKeys.has(key)) {
+				let freshKey;
+				for (let attempt = 0; attempt < 3; attempt++) {
+					let candidate = keyGenerator();
+					if (!usedKeys.has(candidate)) {
+						freshKey = candidate;
+						break;
+					}
+				}
+				if (freshKey === void 0) {
+					let suffix = 1, candidate = `${key}_${suffix}`;
+					for (; usedKeys.has(candidate);) suffix++, candidate = `${key}_${suffix}`;
+					freshKey = candidate;
+				}
+				node._key = freshKey, usedKeys.add(freshKey), onKeyRewritten?.(key, freshKey), recorder?.renamePreviousKey.set(node, key);
+				return;
+			}
+			usedKeys.add(key);
+		}
+	}, adopted = nodes.filter((node) => adoptedNodes.has(node)), rest = nodes.filter((node) => !adoptedNodes.has(node));
+	for (let node of [...adopted, ...rest]) claim(node);
+	for (let node of nodes) enforceNestedSiblingKeyUniqueness(node, keyGenerator, adoptedNodes, recorder);
+}
+function enforceNestedSiblingKeyUniqueness(node, keyGenerator, adoptedNodes, recorder) {
+	for (let [field, value] of Object.entries(node)) Array.isArray(value) && value.every((item) => typeof item == "object" && !!item) && value.length > 0 ? enforceSiblingKeyUniqueness(value, keyGenerator, adoptedNodes, recorder, field === "markDefs" ? buildMarkDefKeyRewriter(node) : void 0) : typeof value == "object" && value && enforceNestedSiblingKeyUniqueness(value, keyGenerator, adoptedNodes, recorder);
+}
+/**
+* A colliding `keyGenerator` can mint the identical string for two
+* `markDefs` entries, which means the block's spans already reference
+* that shared string ambiguously before any rewrite happens: a
+* blanket find-and-replace of the old key would move every span's
+* reference, including the one that was never renamed. The
+* `markDefs` array and each span's `marks` are walked in the same
+* fixed document order, so the Nth occurrence of a given key in one
+* lines up with the Nth occurrence in the other; the first occurrence
+* is always the survivor (`enforceSiblingKeyUniqueness` only renames
+* on collision, never the first sighting of a key), so each rename
+* event retargets the next occurrence in that shared order instead of
+* every occurrence.
+*/
+function buildMarkDefKeyRewriter(block) {
+	let children = block.children;
+	if (!isTypedObjectArray(children)) return () => {};
+	let occurrencesByKey = /* @__PURE__ */ new Map();
+	for (let child of children) {
+		let marks = child.marks;
+		if (Array.isArray(marks)) for (let markIndex = 0; markIndex < marks.length; markIndex++) {
+			let mark = marks[markIndex];
+			if (typeof mark != "string") continue;
+			let occurrences = occurrencesByKey.get(mark) ?? [];
+			occurrences.push({
+				child,
+				markIndex
+			}), occurrencesByKey.set(mark, occurrences);
+		}
+	}
+	let consumedByKey = /* @__PURE__ */ new Map();
+	return (oldKey, newKey) => {
+		let occurrences = occurrencesByKey.get(oldKey), index = consumedByKey.get(oldKey) ?? 1;
+		consumedByKey.set(oldKey, index + 1);
+		let target = occurrences?.[index];
+		if (!target) return;
+		let marks = target.child.marks;
+		Array.isArray(marks) && (marks[target.markIndex] = newKey);
+	};
+}
+/**
+* Materializes the public report from the recorder's node-identity
+* decisions, walking the settled result tree once so every `key` and
+* `path` matches the returned value exactly: key resolution records
+* decisions before the sibling-uniqueness pass can still rewrite a
+* key, so keys and paths are only trustworthy read back from the
+* final tree, not from the moment a decision was made.
+*/
+function buildReconciliationReport(result, recorder) {
+	let preservedKeys = [], renamedKeys = [], pathByNode = /* @__PURE__ */ new WeakMap(), walk = (node, path) => {
+		pathByNode.set(node, path);
+		let key = node._key;
+		if (typeof key == "string") {
+			let basis = recorder.preservationBasis.get(node), previousKey = recorder.renamePreviousKey.get(node);
+			basis && previousKey === void 0 && preservedKeys.push({
+				basis,
+				key,
+				path
+			}), previousKey !== void 0 && renamedKeys.push({
+				previousKey,
+				key,
+				path
+			});
+		}
+		for (let [field, value] of Object.entries(node)) Array.isArray(value) && value.every((item) => typeof item == "object" && !!item) && value.length > 0 ? value.forEach((child, index) => {
+			let childKey = child._key;
+			walk(child, [
+				...path,
+				field,
+				typeof childKey == "string" ? { _key: childKey } : index
+			]);
+		}) : typeof value == "object" && value && walk(value, [...path, field]);
+	};
+	if (result.forEach((block, index) => {
+		let key = block._key;
+		walk(block, [typeof key == "string" ? { _key: key } : index]);
+	}), recorder.skipReason) return {
+		keyMatching: "skipped",
+		reason: recorder.skipReason,
+		renamedKeys
+	};
+	let keyFallbacks = [];
+	for (let group of recorder.ambiguousRegionGroups) keyFallbacks.push({
+		type: "ambiguous-region-too-large",
+		keys: group.map((node) => node._key).filter((key) => typeof key == "string")
+	});
+	for (let node of recorder.annotationKeyConflicts) keyFallbacks.push({
+		type: "annotation-key-conflict",
+		path: pathByNode.get(node)
+	});
+	return {
+		keyMatching: "performed",
+		preservedKeys,
+		keyFallbacks,
+		renamedKeys
+	};
 }
-export { DefaultBlockSpacingRenderer, DefaultBlockquoteObjectRenderer, DefaultBlockquoteRenderer, DefaultCalloutRenderer, DefaultCodeBlockRenderer, DefaultCodeRenderer, DefaultEmRenderer, DefaultH1Renderer, DefaultH2Renderer, DefaultH3Renderer, DefaultH4Renderer, DefaultH5Renderer, DefaultH6Renderer, DefaultHardBreakRenderer, DefaultHorizontalRuleRenderer, DefaultHtmlRenderer, DefaultImageRenderer, DefaultLinkRenderer, DefaultListItemRenderer, DefaultListRenderer, DefaultNormalRenderer, DefaultStrikeThroughRenderer, DefaultStrongRenderer, DefaultTableRenderer, DefaultUnderlineRenderer, markdownToPortableText, portableTextToMarkdown };
+export { DefaultBlockSpacingRenderer, DefaultBlockquoteObjectRenderer, DefaultBlockquoteRenderer, DefaultCalloutRenderer, DefaultCodeBlockRenderer, DefaultCodeRenderer, DefaultEmRenderer, DefaultH1Renderer, DefaultH2Renderer, DefaultH3Renderer, DefaultH4Renderer, DefaultH5Renderer, DefaultH6Renderer, DefaultHardBreakRenderer, DefaultHorizontalRuleRenderer, DefaultHtmlRenderer, DefaultImageRenderer, DefaultLinkRenderer, DefaultListItemRenderer, DefaultListRenderer, DefaultNormalRenderer, DefaultStrikeThroughRenderer, DefaultStrongRenderer, DefaultTableRenderer, DefaultUnderlineRenderer, applyMarkdownEdit, markdownToPortableText, portableTextToMarkdown };
 
 //# sourceMappingURL=index.js.map