@portabletext/editor 8.1.1 → 8.1.3

package/lib/index.js

@@ -1,9 +1,9 @@
-import { a as getChildren, d as isKeyedSegment, i as resolveNode, n as parentPath, o as getNodeChildren, r as getNode, t as getParent, u as serializePath } from "./get-parent-DgaKcy8-.js";
-import { C as getAncestors, S as hasNode, _ as comparePoints, a as isInline, b as isEditableContainer, c as isSpanNode, d as resolveChildEntryIndex, f as isAncestorPath, g as isAfterPoint, h as isBackwardRange, i as getEnclosingBlock, l as getSibling, m as rangeEdges, n as getEnclosingContainer, o as getBlock, p as isTextBlockNode, s as isBlock, t as getPathSubSchema, u as getNodes, v as comparePaths, x as resolveContainerAt, y as isObject } from "./get-path-sub-schema-Dd0QYZ0m.js";
-import { _ as getAncestor, a as getTextBlock, c as pathContains, d as isRange, f as isPoint, g as isLeafObject, h as getLeaf, i as getFirstChild, l as getSpan, m as isPath, n as getUnionSchema, o as rangeIntersects, p as isObject$1, r as getLastChild, s as isBeforePoint, t as getContainer, u as getText } from "./get-container-D2pN5Npr.js";
-import { a as parseBlocks, b as childAtTextOffset, c as parseSpan, d as getSelectionEndPoint, f as isSelectionCollapsed, g as isEqualSelectionPoints, h as getBlockKeyFromSelectionPoint, i as parseBlock, l as defaultKeyGenerator, m as getBlockEndPoint, n as isListBlock, o as parseInlineObject, p as getBlockStartPoint, r as parseAnnotation, s as parseMarkDefs, u as getSelectionStartPoint, v as blockOffsetToSpanSelectionPoint, x as textOffsetOfChild } from "./util.slice-blocks-_ElaB53f.js";
-import { A as getSelectionEndPoint$1, B as getFocusBlock, C as getSelectedTextBlocks, D as getPreviousSpan, F as getSelectionEndBlock, G as rangesOverlap, H as getFocusInlineObject, I as getFragment, L as getSelectedValue, M as isSelectionCollapsed$1, N as isOverlappingSelection, O as getSelectionStartPoint$1, P as getSelectionStartBlock, R as getRootAcceptedTypes, S as getActiveDecorators, T as getMarkState, U as getFocusChild, V as getFocusSpan, a as isActiveListItem, b as getActiveAnnotations, c as getSelectionEndChild, d as getLastBlock, f as getFocusListBlock, i as isActiveStyle, j as isSelectionExpanded, k as getNextSpan, l as getPreviousBlock, m as getCaretWordSelection, n as isAtTheStartOfBlock, o as isActiveDecorator, p as getFocusBlockObject, r as isAtTheEndOfBlock, s as getSelectionStartChild, t as isSelectingEntireBlocks, u as getNextBlock, w as getActiveAnnotationsMarks, x as isActiveAnnotation, z as getFocusTextBlock } from "./selector.is-selecting-entire-blocks-BFhnnkHf.js";
-import { n as isEmptyTextBlock, r as getTextBlockText, t as isEqualSelections } from "./util.is-equal-selections-BdK98okY.js";
+import { a as getChildren, d as nodeSegment, f as serializePath, i as resolveNode, n as parentPath, o as getNodeChildren, p as isKeyedSegment, r as getNode, t as getParent, u as hasUsableKey } from "./get-parent-BLzi7eLr.js";
+import { C as getAncestors, S as hasNode, _ as comparePoints, a as isInline, b as isEditableContainer, c as isSpanNode, d as resolveChildEntryIndex, f as isAncestorPath, g as isAfterPoint, h as isBackwardRange, i as getEnclosingBlock, l as getSibling, m as rangeEdges, n as getEnclosingContainer, o as getBlock, p as isTextBlockNode, s as isBlock, t as getPathSubSchema, u as getNodes, v as comparePaths, x as resolveContainerAt, y as isObject } from "./get-path-sub-schema-DsN1qF_l.js";
+import { _ as getAncestor, a as getTextBlock, c as pathContains, d as isRange, f as isPoint, g as isLeafObject, h as getLeaf, i as getFirstChild, l as getSpan, m as isPath, n as getUnionSchema, o as rangeIntersects, p as isObject$1, r as getLastChild, s as isBeforePoint, t as getContainer, u as getText } from "./get-container-CXdmRdiX.js";
+import { a as parseMarkDefs, c as getSelectionStartPoint, d as getBlockStartPoint, f as getBlockEndPoint, g as blockOffsetToSpanSelectionPoint, i as parseInlineObject, l as getSelectionEndPoint, m as isEqualSelectionPoints, n as parseAnnotation, o as parseSpan, p as getBlockKeyFromSelectionPoint, r as parseBlock, s as defaultKeyGenerator, u as isSelectionCollapsed, v as childAtTextOffset, y as textOffsetOfChild } from "./util.slice-blocks-B-iKFEG7.js";
+import { A as getSelectionEndPoint$1, B as getFocusTextBlock, C as getSelectedTextBlocks, D as getPreviousSpan, F as getSelectionStartBlock, H as getFocusSpan, I as getSelectionEndBlock, K as rangesOverlap, L as getFragment, M as isSelectionExpanded, N as isSelectionCollapsed$1, O as getSelectionStartPoint$1, P as isOverlappingSelection, R as getSelectedValue, S as getActiveDecorators, T as getMarkState, U as getFocusInlineObject, V as getFocusBlock, W as getFocusChild, a as isActiveListItem, b as getActiveAnnotations, c as getSelectionEndChild, d as getLastBlock, f as getFocusListBlock, i as isActiveStyle, j as isListBlock, k as getNextSpan, l as getPreviousBlock, m as getCaretWordSelection, n as isAtTheStartOfBlock, o as isActiveDecorator, p as getFocusBlockObject, r as isAtTheEndOfBlock, s as getSelectionStartChild, t as isSelectingEntireBlocks, u as getNextBlock, w as getActiveAnnotationsMarks, x as isActiveAnnotation, z as getRootAcceptedTypes } from "./selector.is-selecting-entire-blocks-BHVYIXbI.js";
+import { n as isEmptyTextBlock, r as getTextBlockText, t as isEqualSelections } from "./util.is-equal-selections-sCQib0IC.js";
 import { a as raise$1, i as forward, n as effect, t as defineBehavior } from "./behavior.types.behavior-BxSLb73I.js";
 import { n as EditorContext$1, t as useEditor } from "./use-editor-CwNeVwVC.js";
 import { c } from "react/compiler-runtime";
@@ -465,17 +465,19 @@ const IS_IOS = typeof navigator < "u" && typeof window < "u" && /iPad|iPhone|iPo
 	},
 	toEditorSelection: (editor, domRange, options) => {
 		let { exactMatch, suppressThrow } = options, el = isDOMSelection(domRange) ? domRange.anchorNode : domRange.startContainer, anchorNode = null, anchorOffset = 0, focusNode = null, focusOffset = 0, isCollapsed = !1;
-		if (el) if (isDOMSelection(domRange)) {
-			if (IS_FIREFOX && domRange.rangeCount > 1) {
-				focusNode = domRange.focusNode;
-				let firstRange = domRange.getRangeAt(0), lastRange = domRange.getRangeAt(domRange.rangeCount - 1);
-				if (focusNode instanceof HTMLTableRowElement && firstRange.startContainer instanceof HTMLTableRowElement && lastRange.startContainer instanceof HTMLTableRowElement) {
-					let getLastChildren = (element) => element.childElementCount > 0 ? getLastChildren(element.children[0]) : element, firstNodeRow = firstRange.startContainer, lastNodeRow = lastRange.startContainer, firstNode = getLastChildren(firstNodeRow.children[firstRange.startOffset]), lastNode = getLastChildren(lastNodeRow.children[lastRange.startOffset]);
-					focusOffset = 0, anchorNode = lastNode.childNodes.length > 0 ? lastNode.childNodes[0] ?? null : lastNode, focusNode = firstNode.childNodes.length > 0 ? firstNode.childNodes[0] ?? null : firstNode, anchorOffset = lastNode instanceof HTMLElement ? lastNode.innerHTML.length : 0;
-				} else firstRange.startContainer === focusNode ? (anchorNode = lastRange.endContainer, anchorOffset = lastRange.endOffset, focusOffset = firstRange.startOffset) : (anchorNode = firstRange.startContainer, anchorOffset = firstRange.endOffset, focusOffset = lastRange.startOffset);
-			} else anchorNode = domRange.anchorNode, anchorOffset = domRange.anchorOffset, focusNode = domRange.focusNode, focusOffset = domRange.focusOffset;
-			isCollapsed = IS_CHROME && hasShadowRoot(anchorNode) || IS_FIREFOX ? domRange.anchorNode === domRange.focusNode && domRange.anchorOffset === domRange.focusOffset : domRange.isCollapsed;
-		} else anchorNode = domRange.startContainer, anchorOffset = domRange.startOffset, focusNode = domRange.endContainer, focusOffset = domRange.endOffset, isCollapsed = domRange.collapsed;
+		if (el) {
+			if (isDOMSelection(domRange)) {
+				if (IS_FIREFOX && domRange.rangeCount > 1) {
+					focusNode = domRange.focusNode;
+					let firstRange = domRange.getRangeAt(0), lastRange = domRange.getRangeAt(domRange.rangeCount - 1);
+					if (focusNode instanceof HTMLTableRowElement && firstRange.startContainer instanceof HTMLTableRowElement && lastRange.startContainer instanceof HTMLTableRowElement) {
+						let getLastChildren = (element) => element.childElementCount > 0 ? getLastChildren(element.children[0]) : element, firstNodeRow = firstRange.startContainer, lastNodeRow = lastRange.startContainer, firstNode = getLastChildren(firstNodeRow.children[firstRange.startOffset]), lastNode = getLastChildren(lastNodeRow.children[lastRange.startOffset]);
+						focusOffset = 0, anchorNode = lastNode.childNodes.length > 0 ? lastNode.childNodes[0] ?? null : lastNode, focusNode = firstNode.childNodes.length > 0 ? firstNode.childNodes[0] ?? null : firstNode, anchorOffset = lastNode instanceof HTMLElement ? lastNode.innerHTML.length : 0;
+					} else firstRange.startContainer === focusNode ? (anchorNode = lastRange.endContainer, anchorOffset = lastRange.endOffset, focusOffset = firstRange.startOffset) : (anchorNode = firstRange.startContainer, anchorOffset = firstRange.endOffset, focusOffset = lastRange.startOffset);
+				} else anchorNode = domRange.anchorNode, anchorOffset = domRange.anchorOffset, focusNode = domRange.focusNode, focusOffset = domRange.focusOffset;
+				isCollapsed = IS_CHROME && hasShadowRoot(anchorNode) || IS_FIREFOX ? domRange.anchorNode === domRange.focusNode && domRange.anchorOffset === domRange.focusOffset : domRange.isCollapsed;
+			} else anchorNode = domRange.startContainer, anchorOffset = domRange.startOffset, focusNode = domRange.endContainer, focusOffset = domRange.endOffset, isCollapsed = domRange.collapsed;
+		}
 		if (anchorNode == null || focusNode == null || anchorOffset == null || focusOffset == null) {
 			if (suppressThrow) return null;
 			throw Error(`Cannot map DOM range to an editor selection: ${domRange}`);
@@ -746,6 +748,36 @@ function move(editor, options = {}) {
 	}
 	editor.setSelection(props);
 }
+/**
+* Reduces the frame stack to an `OperationOrigin` by fixed precedence
+* (undo > redo > normalization > remote > local), regardless of nesting
+* order. Normalization outranks remote so a fix that runs while replaying
+* a remote patch is attributed to the fix, not laundered into looking like
+* an ordinary remote write; `hasRemoteFrame` is the precedence-blind read
+* for callers that need the externally-triggered fact regardless of
+* whether a fix ran on top of it.
+*/
+function getOrigin(frames) {
+	return frames.some((frame) => frame.kind === "undo") ? "undo" : frames.some((frame) => frame.kind === "redo") ? "redo" : frames.some((frame) => frame.kind === "normalization") ? "normalization" : frames.some((frame) => frame.kind === "remote") ? "remote" : "local";
+}
+/**
+* True while the frame stack carries a `remote` frame at any depth: the
+* editor is applying content that arrived from outside (remote `patches`
+* or value sync), possibly nested inside a normalization fix.
+* `normalize-node`'s readers gate optional fix-ups on it to leave adopted
+* content alone; `apply-operation` skips inverse population; the sync
+* machine treats it as busy.
+*/
+function hasRemoteFrame(frames) {
+	return frames.some((frame) => frame.kind === "remote");
+}
+/**
+* Precedence-blind: true whenever a `normalization` frame is on the stack,
+* even when an `undo` or `redo` frame outranks it in `getOrigin`.
+*/
+function isInNormalization(frames) {
+	return frames.some((frame) => frame.kind === "normalization");
+}
 function subscribeToOperations(editor, listener, options) {
 	let phase = options?.phase ?? "after";
 	return editor.operationListeners[phase] = [...editor.operationListeners[phase], listener], () => {
@@ -761,20 +793,16 @@ function subscribeToOperations(editor, listener, options) {
 * the apply.
 */
 function createOperationEvent(editor, operation) {
-	let isNormalizingNode = !!editor.isNormalizingNode, isProcessingRemoteChanges = !!editor.isProcessingRemoteChanges, isUndoing = !!editor.isUndoing, isRedoing = !!editor.isRedoing;
 	return {
 		operation,
 		beforeValue: editor.snapshot.context.value,
 		beforeSelection: editor.snapshot.context.selection,
 		operationsInProgress: editor.operations.length > 0,
-		isNormalizingNode,
 		isPatching: !!editor.isPatching,
-		isProcessingRemoteChanges,
-		isUndoing,
-		isRedoing,
 		withHistory: !!editor.withHistory,
 		undoStepId: editor.undoStepId,
-		origin: isProcessingRemoteChanges ? "remote" : isUndoing ? "undo" : isRedoing ? "redo" : isNormalizingNode ? "normalization" : "local"
+		origin: getOrigin(editor.applyContext),
+		context: Object.freeze([...editor.applyContext])
 	};
 }
 function emitOperationEvent(listeners, event) {
@@ -2863,12 +2891,14 @@ const RestoreDOM = IS_ANDROID ? RestoreDOMComponent : ({ children }) => /* @__PU
 					exactMatch: !1,
 					suppressThrow: !0
 				});
-				if (range) if (!editor.composing && !androidInputManager?.hasPendingChanges() && !androidInputManager?.isFlushing()) {
-					if (editor.select(range), domSelection.isCollapsed && anchorNode && anchorNode.nodeType === Node.ELEMENT_NODE) try {
-						let canonicalRange = DOMEditor.toDOMRange(editor, range);
-						domSelection.setBaseAndExtent(canonicalRange.startContainer, canonicalRange.startOffset, canonicalRange.startContainer, canonicalRange.startOffset);
-					} catch {}
-				} else androidInputManager?.handleUserSelect(range);
+				if (range) {
+					if (!editor.composing && !androidInputManager?.hasPendingChanges() && !androidInputManager?.isFlushing()) {
+						if (editor.select(range), domSelection.isCollapsed && anchorNode && anchorNode.nodeType === Node.ELEMENT_NODE) try {
+							let canonicalRange = DOMEditor.toDOMRange(editor, range);
+							domSelection.setBaseAndExtent(canonicalRange.startContainer, canonicalRange.startOffset, canonicalRange.startContainer, canonicalRange.startOffset);
+						} catch {}
+					} else androidInputManager?.handleUserSelect(range);
+				}
 			}
 			readOnly && (!anchorNodeSelectable || !focusNodeInEditor) && deselect(editor);
 		}
@@ -4201,7 +4231,7 @@ const engineOperationCallback = ({ input, sendBack }) => subscribeToOperations(i
 	event.operation.type !== "set.selection" && sendBack({
 		type: "engine operation",
 		operation: event.operation,
-		origin: event.origin
+		origin: hasRemoteFrame(event.context) ? "remote" : "local"
 	});
 }, { phase: "before" });
 function mergeRangeDecoration(leaf, decoration) {
@@ -4264,7 +4294,7 @@ const rangeDecorationsMachine = setup({
 					decoratedRange.rangeDecoration.onMoved?.({
 						newSelection: null,
 						rangeDecoration: decoratedRange.rangeDecoration,
-						origin: event.origin === "remote" ? "remote" : "local"
+						origin: event.origin
 					});
 					continue;
 				}
@@ -4272,7 +4302,7 @@ const rangeDecorationsMachine = setup({
 				(newRange && newRange !== currentSelection || newRange === null && currentSelection) && decoratedRange.rangeDecoration.onMoved?.({
 					newSelection: newRange,
 					rangeDecoration: decoratedRange.rangeDecoration,
-					origin: event.origin === "remote" ? "remote" : "local"
+					origin: event.origin
 				}), newRange !== null && rangeDecorationState.push({
 					...newRange || currentSelection,
 					rangeDecoration: {
@@ -5465,16 +5495,7 @@ const PortableTextEditable = forwardRef(function PortableTextEditable(props, for
 				type: "behavior event",
 				behaviorEvent: {
 					type: "insert.blocks",
-					blocks: parseBlocks({
-						keyGenerator: editorEngine.snapshot.context.keyGenerator,
-						schema: editorEngine.snapshot.context.schema,
-						blocks: result_1.insert,
-						options: {
-							normalize: !1,
-							removeUnusedMarkDefs: !0,
-							validateFields: !1
-						}
-					}),
+					blocks: result_1.insert,
 					placement: "auto"
 				},
 				editor: editorEngine
@@ -5644,11 +5665,7 @@ const PortableTextEditable = forwardRef(function PortableTextEditable(props, for
 	}, $[105] = editorActor, $[106] = editorEngine, $[107] = onDragStart, $[108] = readOnly, $[109] = t28) : t28 = $[109];
 	let handleDragStart = t28, t29;
 	$[110] !== editorActor || $[111] !== editorEngine || $[112] !== onDrag ? (t29 = (event_9) => {
-		if (onDrag?.(event_9), !(event_9.isDefaultPrevented() || event_9.isPropagationStopped()) && getEventPosition({
-			editorActor,
-			editorEngine,
-			event: event_9.nativeEvent
-		})) return editorActor.send({
+		if (onDrag?.(event_9), !(event_9.isDefaultPrevented() || event_9.isPropagationStopped()) && !(editorActor.getSnapshot().matches({ setup: "setting up" }) || !DOMEditor.hasTarget(editorEngine, event_9.target))) return editorActor.send({
 			type: "behavior event",
 			behaviorEvent: {
 				type: "drag.drag",
@@ -5671,17 +5688,17 @@ const PortableTextEditable = forwardRef(function PortableTextEditable(props, for
 	let handleDragEnd = t30, t31;
 	$[118] !== editorActor || $[119] !== editorEngine || $[120] !== onDragEnter ? (t31 = (event_11) => {
 		if (onDragEnter?.(event_11), event_11.isDefaultPrevented() || event_11.isPropagationStopped()) return;
-		let position_6 = getEventPosition({
+		let position_5 = getEventPosition({
 			editorActor,
 			editorEngine,
 			event: event_11.nativeEvent
 		});
-		if (position_6) return editorActor.send({
+		if (position_5) return editorActor.send({
 			type: "behavior event",
 			behaviorEvent: {
 				type: "drag.dragenter",
 				originEvent: { dataTransfer: event_11.dataTransfer },
-				position: position_6
+				position: position_5
 			},
 			editor: editorEngine
 		}), !0;
@@ -5689,18 +5706,18 @@ const PortableTextEditable = forwardRef(function PortableTextEditable(props, for
 	let handleDragEnter = t31, t32;
 	$[122] !== editorActor || $[123] !== editorEngine || $[124] !== onDragOver ? (t32 = (event_12) => {
 		if (onDragOver?.(event_12), event_12.isDefaultPrevented() || event_12.isPropagationStopped()) return;
-		let position_7 = getEventPosition({
+		let position_6 = getEventPosition({
 			editorActor,
 			editorEngine,
 			event: event_12.nativeEvent
 		});
-		if (position_7) return editorActor.send({
+		if (position_6) return editorActor.send({
 			type: "behavior event",
 			behaviorEvent: {
 				type: "drag.dragover",
 				originEvent: { dataTransfer: event_12.dataTransfer },
 				dragOrigin: editorActor.getSnapshot().context.internalDrag?.origin,
-				position: position_7
+				position: position_6
 			},
 			editor: editorEngine,
 			nativeEvent: event_12
@@ -5709,12 +5726,12 @@ const PortableTextEditable = forwardRef(function PortableTextEditable(props, for
 	let handleDragOver = t32, t33;
 	$[126] !== editorActor || $[127] !== editorEngine || $[128] !== onDrop ? (t33 = (event_13) => {
 		if (onDrop?.(event_13), event_13.isDefaultPrevented() || event_13.isPropagationStopped()) return;
-		let position_8 = getEventPosition({
+		let position_7 = getEventPosition({
 			editorActor,
 			editorEngine,
 			event: event_13.nativeEvent
 		});
-		if (!position_8) {
+		if (!position_7) {
 			console.warn("Could not find position for drop event");
 			return;
 		}
@@ -5724,7 +5741,7 @@ const PortableTextEditable = forwardRef(function PortableTextEditable(props, for
 				type: "drag.drop",
 				originEvent: { dataTransfer: event_13.dataTransfer },
 				dragOrigin: editorActor.getSnapshot().context.internalDrag?.origin,
-				position: position_8
+				position: position_7
 			},
 			editor: editorEngine,
 			nativeEvent: event_13
@@ -5732,11 +5749,7 @@ const PortableTextEditable = forwardRef(function PortableTextEditable(props, for
 	}, $[126] = editorActor, $[127] = editorEngine, $[128] = onDrop, $[129] = t33) : t33 = $[129];
 	let handleDrop = t33, t34;
 	$[130] !== editorActor || $[131] !== editorEngine || $[132] !== onDragLeave ? (t34 = (event_14) => {
-		if (onDragLeave?.(event_14), !(event_14.isDefaultPrevented() || event_14.isPropagationStopped()) && getEventPosition({
-			editorActor,
-			editorEngine,
-			event: event_14.nativeEvent
-		})) return editorActor.send({
+		if (onDragLeave?.(event_14), !(event_14.isDefaultPrevented() || event_14.isPropagationStopped()) && !(editorActor.getSnapshot().matches({ setup: "setting up" }) || !DOMEditor.hasTarget(editorEngine, event_14.target))) return editorActor.send({
 			type: "behavior event",
 			behaviorEvent: {
 				type: "drag.dragleave",
@@ -5919,11 +5932,7 @@ const converterJson = defineConverter({
 			let parsedBlock = parseBlock({
 				keyGenerator: snapshot.context.keyGenerator,
 				block,
-				options: {
-					normalize: !1,
-					removeUnusedMarkDefs: !0,
-					validateFields: !1
-				},
+				profile: "lenient",
 				schema: snapshot.context.schema
 			});
 			return parsedBlock ? [parsedBlock] : [];
@@ -5971,11 +5980,7 @@ const converterJson = defineConverter({
 			let parsedBlock = parseBlock({
 				keyGenerator: snapshot.context.keyGenerator,
 				block,
-				options: {
-					normalize: !1,
-					removeUnusedMarkDefs: !0,
-					validateFields: !1
-				},
+				profile: "lenient",
 				schema: snapshot.context.schema
 			});
 			return parsedBlock ? [parsedBlock] : [];
@@ -6011,11 +6016,7 @@ const converterJson = defineConverter({
 			let parsedBlock = parseBlock({
 				keyGenerator: snapshot.context.keyGenerator,
 				block,
-				options: {
-					normalize: !1,
-					removeUnusedMarkDefs: !0,
-					validateFields: !1
-				},
+				profile: "lenient",
 				schema: snapshot.context.schema
 			});
 			return parsedBlock ? [parsedBlock] : [];
@@ -6316,7 +6317,7 @@ function createBehaviorApiPlugin(editorActor) {
 	return function behaviorApiPlugin(editor) {
 		let { select, setSelection } = editor;
 		return editor.select = (location) => {
-			if (editor.isNormalizingNode || editor.isPerformingBehaviorOperation) {
+			if (isInNormalization(editor.applyContext) || editor.isPerformingBehaviorOperation) {
 				select(location);
 				return;
 			}
@@ -6337,7 +6338,7 @@ function createBehaviorApiPlugin(editorActor) {
 				editor
 			});
 		}, editor.setSelection = (partialRange) => {
-			if (editor.isNormalizingNode || editor.isPerformingBehaviorOperation) {
+			if (isInNormalization(editor.applyContext) || editor.isPerformingBehaviorOperation) {
 				setSelection(partialRange);
 				return;
 			}
@@ -6482,8 +6483,8 @@ function getDirtyPaths(context, op) {
 				let levels = [[]];
 				if (Array.isArray(op.value)) for (let i = 0; i < op.value.length; i++) {
 					let child = op.value[i];
-					if (typeof child != "object" || !child || !("_key" in child) || typeof child._key != "string") continue;
-					let childNode = child, childPath = [{ _key: childNode._key }];
+					if (typeof child != "object" || !child) continue;
+					let childNode = child, childPath = [nodeSegment(childNode, i)];
 					levels.push(childPath), collectDescendantPaths(context, childNode, childPath, levels, context.containers.get(childNode._type));
 				}
 				return levels;
@@ -6507,11 +6508,11 @@ function getDirtyPaths(context, op) {
 				let parentRegistration = resolveContainerAt(context.containers, context.value, nodePath), seed = parentRegistration && "field" in parentRegistration ? parentRegistration : void 0;
 				for (let i = 0; i < op.value.length; i++) {
 					let child = op.value[i];
-					if (typeof child != "object" || !child || !("_key" in child) || typeof child._key != "string") continue;
+					if (typeof child != "object" || !child) continue;
 					let childNode = child, childPath = [
 						...nodePath,
 						propertyName,
-						{ _key: childNode._key }
+						nodeSegment(childNode, i)
 					];
 					levels.push(childPath), collectDescendantPaths(context, childNode, childPath, levels, seed);
 				}
@@ -6587,7 +6588,14 @@ function normalize(editor, options = {}) {
 				let entry = getNode(editor.snapshot, dirtyPath);
 				if (!entry) continue;
 				let entryNode = entry.node;
-				isTextBlock({ schema: editor.snapshot.context.schema }, entryNode) && entryNode.children.length === 0 && (editor.isNormalizingNode = !0, editor.normalizeNode([entry.node, entry.path], { operation }), editor.isNormalizingNode = !1);
+				if (isTextBlock({ schema: editor.snapshot.context.schema }, entryNode) && entryNode.children.length === 0) {
+					editor.applyContext.push(Object.freeze({ kind: "normalization" }));
+					try {
+						editor.normalizeNode([entry.node, entry.path], { operation });
+					} finally {
+						editor.applyContext.pop();
+					}
+				}
 			}
 			let dirtyPaths = getDirtyPaths(editor), initialDirtyPathsLength = dirtyPaths.length, iteration = 0;
 			for (; dirtyPaths.length !== 0;) {
@@ -6598,10 +6606,23 @@ function normalize(editor, options = {}) {
 					operation
 				})) return;
 				let dirtyPath = popDirtyPath(editor);
-				if (dirtyPath.length === 0) editor.isNormalizingNode = !0, editor.normalizeNode([editor, dirtyPath], { operation }), editor.isNormalizingNode = !1;
-				else if (hasNode(editor.snapshot, dirtyPath)) {
+				if (dirtyPath.length === 0) {
+					editor.applyContext.push(Object.freeze({ kind: "normalization" }));
+					try {
+						editor.normalizeNode([editor, dirtyPath], { operation });
+					} finally {
+						editor.applyContext.pop();
+					}
+				} else if (hasNode(editor.snapshot, dirtyPath)) {
 					let entry = getNode(editor.snapshot, dirtyPath);
-					entry && (editor.isNormalizingNode = !0, editor.normalizeNode([entry.node, entry.path], { operation }), editor.isNormalizingNode = !1);
+					if (entry) {
+						editor.applyContext.push(Object.freeze({ kind: "normalization" }));
+						try {
+							editor.normalizeNode([entry.node, entry.path], { operation });
+						} finally {
+							editor.applyContext.pop();
+						}
+					}
 				}
 				iteration++, dirtyPaths = getDirtyPaths(editor);
 			}
@@ -6770,74 +6791,42 @@ function replaceChildren(xs, index, removeCount, ...newValues) {
 	let result = xs.slice();
 	return result.splice(index, removeCount, ...newValues), result;
 }
-const removeChildren = replaceChildren;
-/**
-* Find the index of a node in an array by its _key.
-*/
-function findIndexByKey(children, key) {
-	return children.findIndex((child) => child._key === key);
-}
-/**
-* Extract the keyed segments from a path (skipping field name strings).
-*/
-function getKeyedSegments(path) {
-	return path.filter(isKeyedSegment);
-}
-/**
-* Replace a descendant with a new node, replacing all ancestors
-*/
-const modifyDescendant = (editor, path, f) => {
+const removeChildren = replaceChildren, modifyDescendant = (editor, path, f) => {
 	if (path.length === 0) return;
 	let context = {
 		schema: editor.snapshot.context.schema,
 		containers: editor.snapshot.context.containers
 	}, nodeEntry = getNode(editor.snapshot, path);
 	if (!nodeEntry) return;
-	let node = nodeEntry.node, modifiedNode = f(node), keyedSegments = getKeyedSegments(nodeEntry.path), numericIndices = /* @__PURE__ */ new Map();
-	{
-		let keyedIdx = 0;
-		for (let segment of path) typeof segment == "number" ? (numericIndices.set(keyedIdx, segment), keyedIdx++) : isKeyedSegment(segment) && keyedIdx++;
-	}
-	let fieldNames = [];
-	{
-		let currentNode = { value: editor.snapshot.context.value }, currentParent;
-		for (let i = 0; i < keyedSegments.length; i++) {
-			let result = getNodeChildren(context, currentNode, currentParent);
-			if (!result) return;
-			fieldNames.push(result.fieldName);
-			let numericIndex = numericIndices.get(i), child = numericIndex === void 0 ? result.children.find((c) => c._key === keyedSegments[i]._key) : result.children[numericIndex];
-			if (!child) return;
-			currentNode = child, currentParent = result.parent;
-		}
-	}
-	for (let level = keyedSegments.length - 2; level >= 0; level--) {
-		let childKey = keyedSegments[level + 1]._key, fieldName = fieldNames[level + 1], ancestorPathEnd = -1, keyedCount = 0;
-		for (let pi = 0; pi < path.length; pi++) if (typeof path[pi] != "string") {
-			if (keyedCount === level) {
-				ancestorPathEnd = pi + 1;
-				break;
-			}
-			keyedCount++;
-		}
-		let ancestorPath = ancestorPathEnd > 0 ? path.slice(0, ancestorPathEnd) : [], ancestorEntry = getNode(editor.snapshot, ancestorPath);
-		if (!ancestorEntry) return;
-		let ancestorNode = ancestorEntry.node, ancestorRecord = ancestorNode, currentChildren = Array.isArray(ancestorRecord[fieldName]) ? ancestorRecord[fieldName] : [], originalNumericIndex = numericIndices.get(level + 1), childIndex = originalNumericIndex === void 0 ? findIndexByKey(currentChildren, childKey) : originalNumericIndex;
-		if (childIndex === -1) return;
+	let resolvedNodeSegments = nodeEntry.path.filter((segment) => typeof segment != "string"), inputNodeSegments = path.filter((segment) => typeof segment != "string"), levels = [], currentNode = { value: editor.snapshot.context.value }, currentParent;
+	for (let i = 0; i < resolvedNodeSegments.length; i++) {
+		let result = getNodeChildren(context, currentNode, currentParent);
+		if (!result) return;
+		let inputSegment = inputNodeSegments[i], resolvedSegment = resolvedNodeSegments[i], index;
+		if (typeof inputSegment == "number") index = inputSegment;
+		else if (typeof resolvedSegment == "number") index = resolvedSegment;
+		else if (isKeyedSegment(resolvedSegment)) index = result.children.findIndex((child) => child._key === resolvedSegment._key);
+		else return;
+		let child = result.children[index];
+		if (!child) return;
+		levels.push({
+			parentNode: currentNode,
+			fieldName: result.fieldName,
+			children: result.children,
+			index
+		}), currentNode = child, currentParent = result.parent;
+	}
+	let deepestLevel = levels.length - 1;
+	if (deepestLevel < 0) return;
+	let modifiedNode = f(currentNode);
+	for (let level = deepestLevel; level >= 1; level--) {
+		let { parentNode, fieldName, children, index } = levels[level];
 		modifiedNode = {
-			...ancestorNode,
-			[fieldName]: replaceChildren(currentChildren, childIndex, 1, modifiedNode)
+			...parentNode,
+			[fieldName]: replaceChildren(children, index, 1, modifiedNode)
 		};
 	}
-	let rootIndex, rootNumericIndex = numericIndices.get(0);
-	if (rootNumericIndex !== void 0) rootIndex = rootNumericIndex;
-	else if (keyedSegments.length > 0) {
-		let rootSegment = keyedSegments[0], mapIndex = editor.blockIndexMap.get(serializePath([rootSegment]));
-		rootIndex = mapIndex === void 0 ? findIndexByKey(editor.snapshot.context.value, rootSegment._key) : mapIndex;
-	} else {
-		let firstSegment = path[0];
-		rootIndex = typeof firstSegment == "number" ? firstSegment : -1;
-	}
-	rootIndex === -1 || rootIndex >= editor.snapshot.context.value.length || (editor.snapshot.context.value = replaceChildren(editor.snapshot.context.value, rootIndex, 1, modifiedNode));
+	editor.snapshot.context.value = replaceChildren(editor.snapshot.context.value, levels[0].index, 1, modifiedNode);
 }, modifyChildren = (editor, path, f) => {
 	if (path.length === 0) editor.snapshot.context.value = f(editor.snapshot.context.value);
 	else {
@@ -6871,7 +6860,7 @@ function applyOperation(editor, op) {
 				break;
 			}
 			modifyChildren(editor, parentPath(path), (children) => {
-				!editor.isProcessingRemoteChanges && !editor.isUndoing && !editor.isRedoing && node._key !== void 0 && children.some((sibling) => sibling._key === node._key) && (node = {
+				!editor.applyContext.some((frame) => frame.kind === "remote" || frame.kind === "undo" || frame.kind === "redo") && node._key !== void 0 && children.some((sibling) => sibling._key === node._key) && (node = {
 					...node,
 					_key: editor.snapshot.context.keyGenerator()
 				}, op.node = node);
@@ -6883,7 +6872,7 @@ function applyOperation(editor, op) {
 				} else if (typeof lastSegment == "number") index = op.position === "after" ? lastSegment + 1 : lastSegment;
 				else throw Error(`Cannot apply an "insert" operation at path [${path}] because the last segment is a field name.`);
 				if (index > children.length) throw Error(`Cannot apply an "insert" operation at path [${path}] because the destination is past the end of the node.`);
-				return !op.inverse && !editor.isProcessingRemoteChanges && (op.inverse = {
+				return !op.inverse && !hasRemoteFrame(editor.applyContext) && (op.inverse = {
 					type: "unset",
 					path: node._key === void 0 ? path : replaceLastSegment(path, { _key: node._key })
 				}), insertChildren(children, index, node);
@@ -6916,7 +6905,7 @@ function applyOperation(editor, op) {
 		}
 		case "set": {
 			let { path, value } = op;
-			if (!op.inverse && !editor.isProcessingRemoteChanges) {
+			if (!op.inverse && !hasRemoteFrame(editor.applyContext)) {
 				let previousValue = getValue(editor.snapshot.context.value, path), inversePath = path[path.length - 1] === "_key" && typeof value == "string" && isKeyedSegment(path[path.length - 2]) ? [
 					...path.slice(0, -2),
 					{ _key: value },
@@ -6945,14 +6934,15 @@ function applyOperation(editor, op) {
 				typeof value == "object" && value && !Array.isArray(value) && modifyDescendant(editor, setNodePath, () => value), transformSelection = !0;
 				break;
 			}
-			if (getNode(editor.snapshot, setNodePath)) if (setPropertyPath.length === 1) {
-				let propertyName = setPropertyPath[0];
-				modifyDescendant(editor, setNodePath, (node) => ({
-					...node,
-					[propertyName]: value
-				}));
-			} else modifyDescendant(editor, setNodePath, (node) => deepSet(node, setPropertyPath, value));
-			else {
+			if (getNode(editor.snapshot, setNodePath)) {
+				if (setPropertyPath.length === 1) {
+					let propertyName = setPropertyPath[0];
+					modifyDescendant(editor, setNodePath, (node) => ({
+						...node,
+						[propertyName]: value
+					}));
+				} else modifyDescendant(editor, setNodePath, (node) => deepSet(node, setPropertyPath, value));
+			} else {
 				let blockSegment = findBlockSegment(path);
 				if (!blockSegment) break;
 				let blockIndex = resolveBlockIndex(editor, blockSegment);
@@ -6968,7 +6958,7 @@ function applyOperation(editor, op) {
 		case "unset": {
 			let { path } = op;
 			if (path.length === 0) {
-				!op.inverse && !editor.isProcessingRemoteChanges && (op.inverse = {
+				!op.inverse && !hasRemoteFrame(editor.applyContext) && (op.inverse = {
 					type: "set",
 					path,
 					value: editor.snapshot.context.value
@@ -6977,7 +6967,7 @@ function applyOperation(editor, op) {
 			}
 			let lastSegment = path[path.length - 1];
 			if ((isKeyedSegment(lastSegment) || typeof lastSegment == "number") && !targetsStructuralChildren(editor, path)) {
-				if (!op.inverse && !editor.isProcessingRemoteChanges) {
+				if (!op.inverse && !hasRemoteFrame(editor.applyContext)) {
 					let arrayValue = getValue(editor.snapshot.context.value, path.slice(0, -1));
 					Array.isArray(arrayValue) && (op.inverse = {
 						type: "set",
@@ -7013,7 +7003,7 @@ function applyOperation(editor, op) {
 				modifyChildren(editor, parentPath(path), (children) => {
 					let index;
 					if (index = isKeyedSegment(lastSegment) ? resolveChildIndex$1(editor.blockIndexMap, path.slice(0, -1), lastSegment, children) : lastSegment, index === -1 || index >= children.length) throw Error(`Cannot apply an "unset" (node removal) operation at path [${path}] because the node was not found.`);
-					if (!op.inverse && !editor.isProcessingRemoteChanges) {
+					if (!op.inverse && !hasRemoteFrame(editor.applyContext)) {
 						let previousSibling = index > 0 ? children[index - 1] : void 0;
 						op.inverse = previousSibling?._key ? {
 							type: "insert",
@@ -7033,7 +7023,7 @@ function applyOperation(editor, op) {
 			}
 			let { nodePath: unsetNodePath, propertyPath: unsetPropertyPath } = splitNodePath(path);
 			if (unsetPropertyPath.length === 0 || unsetNodePath.length === 0) break;
-			if (!op.inverse && !editor.isProcessingRemoteChanges) {
+			if (!op.inverse && !hasRemoteFrame(editor.applyContext)) {
 				let previousValue = getValue(editor.snapshot.context.value, path);
 				if (previousValue === void 0) break;
 				op.inverse = {
@@ -7042,14 +7032,15 @@ function applyOperation(editor, op) {
 					value: previousValue
 				};
 			}
-			if (getNode(editor.snapshot, unsetNodePath)) if (unsetPropertyPath.length === 1) {
-				let propertyName = unsetPropertyPath[0];
-				modifyDescendant(editor, unsetNodePath, (node) => {
-					let newNode = { ...node };
-					return delete newNode[propertyName], newNode;
-				});
-			} else modifyDescendant(editor, unsetNodePath, (node) => deepUnset(node, unsetPropertyPath));
-			else {
+			if (getNode(editor.snapshot, unsetNodePath)) {
+				if (unsetPropertyPath.length === 1) {
+					let propertyName = unsetPropertyPath[0];
+					modifyDescendant(editor, unsetNodePath, (node) => {
+						let newNode = { ...node };
+						return delete newNode[propertyName], newNode;
+					});
+				} else modifyDescendant(editor, unsetNodePath, (node) => deepUnset(node, unsetPropertyPath));
+			} else {
 				let blockSegment = findBlockSegment(path);
 				if (!blockSegment) break;
 				let blockIndex = resolveBlockIndex(editor, blockSegment);
@@ -7163,18 +7154,21 @@ function resolveChildIndex$1(blockIndexMap, parentSegments, segment, children) {
 	return index !== void 0 && children[index]?._key === segment._key ? index : children.findIndex((child) => child._key === segment._key);
 }
 /**
-* Extract the block key from the first segment of a path.
+* Extract the root block reference from the first segment of a path:
+* keyed, or a numeric index for a node normalization has not keyed yet.
 */
 function findBlockSegment(path) {
 	let firstSegment = path[0];
-	if (isKeyedSegment(firstSegment)) return firstSegment;
+	if (isKeyedSegment(firstSegment) || typeof firstSegment == "number") return firstSegment;
 }
 /**
 * Resolve a root block's index via `blockIndexMap`, falling back to a
 * linear scan when the map misses or disagrees with the tree.
 */
 function resolveBlockIndex(editor, segment) {
-	let value = editor.snapshot.context.value, index = editor.blockIndexMap.get(serializePath([segment]));
+	let value = editor.snapshot.context.value;
+	if (typeof segment == "number") return segment < value.length ? segment : -1;
+	let index = editor.blockIndexMap.get(serializePath([segment]));
 	return index !== void 0 && value[index]?._key === segment._key ? index : value.findIndex((block) => block._key === segment._key);
 }
 /**
@@ -7253,30 +7247,37 @@ const apply$1 = (editor, op) => {
 	for (let ref of editor.pathRefs) PathRef.transform(ref, op);
 	for (let ref of editor.pointRefs) PointRef.transform(ref, op);
 	for (let ref of editor.rangeRefs) transformRangeRef(ref, op, editor.snapshot.context);
-	if (applyOperation(editor, op), updateDirtyPaths(editor, getDirtyPaths(editor.snapshot.context, op)), editor.operations.push(op), normalize(editor, { operation: op }), op.type === "set.selection") if (op.properties && op.newProperties && op.properties.anchor && op.properties.focus && op.newProperties.anchor && op.newProperties.focus) {
-		let previousSelectionIsCollapsed = isCollapsedRange({
-			anchor: op.properties.anchor,
-			focus: op.properties.focus
-		}), newSelectionIsCollapsed = isCollapsedRange({
-			anchor: op.newProperties.anchor,
-			focus: op.newProperties.focus
-		});
-		if (previousSelectionIsCollapsed && newSelectionIsCollapsed) {
-			let focusSpan = getSpan(editor.snapshot, op.properties.focus.path)?.node, newFocusSpan = getSpan(editor.snapshot, op.newProperties.focus.path)?.node, sameParent = pathEquals(parentPath(op.properties.focus.path), parentPath(op.newProperties.focus.path)), movedToNextSpan = !1, movedToPreviousSpan = !1;
-			if (sameParent && focusSpan && newFocusSpan) {
-				let nextSibling = getSibling(editor.snapshot, op.properties.focus.path, { direction: "next" }), previousSibling = getSibling(editor.snapshot, op.properties.focus.path, { direction: "previous" });
-				movedToNextSpan = nextSibling !== void 0 && pathEquals(nextSibling.path, op.newProperties.focus.path) && focusSpan.text.length === op.properties.focus.offset && op.newProperties.focus.offset === 0, movedToPreviousSpan = previousSibling !== void 0 && pathEquals(previousSibling.path, op.newProperties.focus.path) && op.properties.focus.offset === 0 && newFocusSpan.text.length === op.newProperties.focus.offset;
+	if (applyOperation(editor, op), updateDirtyPaths(editor, getDirtyPaths(editor.snapshot.context, op)), editor.operations.push(op), normalize(editor, { operation: op }), op.type === "set.selection") {
+		if (op.properties && op.newProperties && op.properties.anchor && op.properties.focus && op.newProperties.anchor && op.newProperties.focus) {
+			let previousSelectionIsCollapsed = isCollapsedRange({
+				anchor: op.properties.anchor,
+				focus: op.properties.focus
+			}), newSelectionIsCollapsed = isCollapsedRange({
+				anchor: op.newProperties.anchor,
+				focus: op.newProperties.focus
+			});
+			if (previousSelectionIsCollapsed && newSelectionIsCollapsed) {
+				let focusSpan = getSpan(editor.snapshot, op.properties.focus.path)?.node, newFocusSpan = getSpan(editor.snapshot, op.newProperties.focus.path)?.node, sameParent = pathEquals(parentPath(op.properties.focus.path), parentPath(op.newProperties.focus.path)), movedToNextSpan = !1, movedToPreviousSpan = !1;
+				if (sameParent && focusSpan && newFocusSpan) {
+					let nextSibling = getSibling(editor.snapshot, op.properties.focus.path, { direction: "next" }), previousSibling = getSibling(editor.snapshot, op.properties.focus.path, { direction: "previous" });
+					movedToNextSpan = nextSibling !== void 0 && pathEquals(nextSibling.path, op.newProperties.focus.path) && focusSpan.text.length === op.properties.focus.offset && op.newProperties.focus.offset === 0, movedToPreviousSpan = previousSibling !== void 0 && pathEquals(previousSibling.path, op.newProperties.focus.path) && op.properties.focus.offset === 0 && newFocusSpan.text.length === op.newProperties.focus.offset;
+				}
+				!movedToNextSpan && !movedToPreviousSpan && (editor.snapshot.decoratorState = {});
 			}
-			!movedToNextSpan && !movedToPreviousSpan && (editor.snapshot.decoratorState = {});
-		}
-	} else editor.snapshot.decoratorState = {};
+		} else editor.snapshot.decoratorState = {};
+	}
 	editor.flushing || (editor.flushing = !0, Promise.resolve().then(() => {
 		editor.flushing = !1, editor.onChange({ operation: op }), editor.operations = [];
 	})), operationEvent && emitOperationEvent(editor.operationListeners.after, operationEvent);
 };
 function withoutPatching(editor, fn) {
 	let prev = editor.isPatching;
-	editor.isPatching = !1, fn(), editor.isPatching = prev;
+	editor.isPatching = !1;
+	try {
+		fn();
+	} finally {
+		editor.isPatching = prev;
+	}
 }
 function isEnd(editor, point, at) {
 	return pointEquals(point, end(editor, at));
@@ -7677,30 +7678,32 @@ function applyNodeProperties(editor, props, path) {
 	let nodeRecord = result.entry.node, propsRecord = props, keys = Object.keys(propsRecord), keyIndex = keys.indexOf("_key");
 	keyIndex !== -1 && (keys.splice(keyIndex, 1), keys.unshift("_key"));
 	let currentPath = path;
-	for (let key of keys) if (propsRecord[key] !== nodeRecord[key]) if (propsRecord[key] != null) {
-		let hadProperty = nodeRecord.hasOwnProperty(key), lastSegment = currentPath[currentPath.length - 1], renamedPath = key === "_key" && typeof propsRecord[key] == "string" && isKeyedSegment(lastSegment) ? [...currentPath.slice(0, -1), { _key: propsRecord[key] }] : void 0, inversePath = renamedPath ? [...renamedPath, key] : [...currentPath, key];
-		editor.apply({
-			type: "set",
+	for (let key of keys) if (propsRecord[key] !== nodeRecord[key]) {
+		if (propsRecord[key] != null) {
+			let hadProperty = nodeRecord.hasOwnProperty(key), lastSegment = currentPath[currentPath.length - 1], renamedPath = key === "_key" && typeof propsRecord[key] == "string" && isKeyedSegment(lastSegment) ? [...currentPath.slice(0, -1), { _key: propsRecord[key] }] : void 0, inversePath = renamedPath ? [...renamedPath, key] : [...currentPath, key];
+			editor.apply({
+				type: "set",
+				path: [...currentPath, key],
+				value: propsRecord[key],
+				inverse: hadProperty ? {
+					type: "set",
+					path: inversePath,
+					value: nodeRecord[key]
+				} : {
+					type: "unset",
+					path: inversePath
+				}
+			}), renamedPath && (currentPath = renamedPath);
+		} else nodeRecord.hasOwnProperty(key) && editor.apply({
+			type: "unset",
 			path: [...currentPath, key],
-			value: propsRecord[key],
-			inverse: hadProperty ? {
+			inverse: {
 				type: "set",
-				path: inversePath,
+				path: [...currentPath, key],
 				value: nodeRecord[key]
-			} : {
-				type: "unset",
-				path: inversePath
 			}
-		}), renamedPath && (currentPath = renamedPath);
-	} else nodeRecord.hasOwnProperty(key) && editor.apply({
-		type: "unset",
-		path: [...currentPath, key],
-		inverse: {
-			type: "set",
-			path: [...currentPath, key],
-			value: nodeRecord[key]
-		}
-	});
+		});
+	}
 }
 /**
 * Create a placeholder text block -- the empty initial block used when the
@@ -7819,7 +7822,7 @@ function richDescentToParent(input, path) {
 * 3. **Global fallback with position-validity.** Falls back to the
 *    top-level rich `containers` map keyed by `_type`. Activates only
 *    when schema-at-position permits the registered `arrayField`
-*    (for containers) or simply declares `_type` (for leaves).
+*    (for containers) or declares `_type` (for leaves).
 *    Registration is type-keyed; activation is position-gated.
 */
 function resolveContainerByPath(input, path, node) {
@@ -7854,7 +7857,7 @@ const normalizeNode = (editor, entry) => {
 	/**
 	* Merge spans with same set of .marks
 	*/
-	if (!editor.isProcessingRemoteChanges && isTextBlock({ schema: editor.snapshot.context.schema }, node)) {
+	if (!hasRemoteFrame(editor.applyContext) && isTextBlock({ schema: editor.snapshot.context.schema }, node)) {
 		let children = getChildren(editor.snapshot, path);
 		for (let i = 0; i < children.length - 1; i++) {
 			let { node: child } = children[i], { node: nextNode, path: nextChildPath } = children[i + 1];
@@ -7889,35 +7892,15 @@ const normalizeNode = (editor, entry) => {
 		});
 		return;
 	}
-	if (nodeRecord._key === void 0 && path.length > 0) {
+	if (!hasUsableKey(nodeRecord._key) && path.length > 0) {
 		let newKey = editor.snapshot.context.keyGenerator();
-		debug.normalization("Setting missing key on node");
-		let numericPath = [], currentNode;
-		for (let segment of path) {
-			if (typeof segment == "string") {
-				currentNode && numericPath.push(segment);
-				continue;
-			}
-			let siblings = currentNode ? currentNode[numericPath[numericPath.length - 1]] ?? [] : editor.snapshot.context.value;
-			if (isKeyedSegment(segment) && segment._key !== void 0) numericPath.push(segment), currentNode = Array.prototype.find.call(siblings, (child) => child._key === segment._key);
-			else {
-				let index = typeof segment == "number" ? segment : -1;
-				if (index === -1) {
-					for (let i = 0; i < siblings.length; i++) if (siblings[i]._key === void 0) {
-						index = i;
-						break;
-					}
-				}
-				index !== -1 && (numericPath.push(index), currentNode = siblings[index]);
-			}
-		}
-		editor.apply({
+		debug.normalization("Setting missing key on node"), editor.apply({
 			type: "set",
-			path: [...numericPath, "_key"],
+			path: [...path, "_key"],
 			value: newKey,
 			inverse: {
 				type: "unset",
-				path: [...numericPath, "_key"]
+				path: [...path, "_key"]
 			}
 		});
 		return;
@@ -7959,14 +7942,14 @@ const normalizeNode = (editor, entry) => {
 	/**
 	* Add missing .markDefs to text block nodes
 	*/
-	if (!editor.isProcessingRemoteChanges && isTextBlockNode({ schema: editor.snapshot.context.schema }, node) && !Array.isArray(node.markDefs)) {
+	if (!hasRemoteFrame(editor.applyContext) && isTextBlockNode({ schema: editor.snapshot.context.schema }, node) && !Array.isArray(node.markDefs)) {
 		debug.normalization("adding .markDefs to block node"), applyNodeProperties(editor, { markDefs: [] }, path);
 		return;
 	}
 	/**
 	* Add missing .style to text block nodes
 	*/
-	if (!editor.isProcessingRemoteChanges && isTextBlockNode({ schema: editor.snapshot.context.schema }, node) && node.style === void 0) {
+	if (!hasRemoteFrame(editor.applyContext) && isTextBlockNode({ schema: editor.snapshot.context.schema }, node) && node.style === void 0) {
 		let defaultStyle = getPathSubSchema(editor.snapshot, path).styles.at(0)?.name;
 		if (defaultStyle) {
 			debug.normalization("adding .style to block node"), applyNodeProperties(editor, { style: defaultStyle }, path);
@@ -7991,14 +7974,14 @@ const normalizeNode = (editor, entry) => {
 	/**
 	* Add missing .marks to span nodes
 	*/
-	if (!editor.isProcessingRemoteChanges && isSpan({ schema: editor.snapshot.context.schema }, node) && !Array.isArray(node.marks)) {
+	if (!hasRemoteFrame(editor.applyContext) && isSpan({ schema: editor.snapshot.context.schema }, node) && !Array.isArray(node.marks)) {
 		debug.normalization("Adding .marks to span node"), applyNodeProperties(editor, { marks: [] }, path);
 		return;
 	}
 	/**
 	* Remove annotations from empty spans
 	*/
-	if (!editor.isProcessingRemoteChanges && isSpan({ schema: editor.snapshot.context.schema }, node)) {
+	if (!hasRemoteFrame(editor.applyContext) && isSpan({ schema: editor.snapshot.context.schema }, node)) {
 		let blockPath = parentPath(path), blockEntry = getTextBlock(editor.snapshot, blockPath);
 		if (!blockEntry) return;
 		let annotations = node.marks?.filter((mark) => blockEntry.node.markDefs?.some((markDef) => markDef._key === mark));
@@ -8010,7 +7993,7 @@ const normalizeNode = (editor, entry) => {
 	/**
 	* Remove duplicate markDefs
 	*/
-	if (!editor.isProcessingRemoteChanges && isTextBlock({ schema: editor.snapshot.context.schema }, node)) {
+	if (!hasRemoteFrame(editor.applyContext) && isTextBlock({ schema: editor.snapshot.context.schema }, node)) {
 		let markDefs = node.markDefs ?? [], markDefKeys = /* @__PURE__ */ new Set(), newMarkDefs = [];
 		for (let markDef of markDefs) markDefKeys.has(markDef._key) || (markDefKeys.add(markDef._key), newMarkDefs.push(markDef));
 		if (markDefs.length !== newMarkDefs.length) {
@@ -8021,7 +8004,7 @@ const normalizeNode = (editor, entry) => {
 	/**
 	* Remove markDefs not in use
 	*/
-	if (!editor.isProcessingRemoteChanges && isTextBlock({ schema: editor.snapshot.context.schema }, node)) {
+	if (!hasRemoteFrame(editor.applyContext) && isTextBlock({ schema: editor.snapshot.context.schema }, node)) {
 		let newMarkDefs = (node.markDefs || []).filter((def) => node.children.find((child) => isSpan({ schema: editor.snapshot.context.schema }, child) && Array.isArray(child.marks) && child.marks.includes(def._key)));
 		if (node.markDefs && !isEqualMarkDefs(newMarkDefs, node.markDefs)) {
 			debug.normalization("removing markDef not in use"), applyNodeProperties(editor, { markDefs: newMarkDefs }, path);
@@ -8163,7 +8146,7 @@ const normalizeNode = (editor, entry) => {
 				{ _key: child._key }
 			];
 			if (isSpan({ schema: editor.snapshot.context.schema }, child)) {
-				if (prev != null && isSpan({ schema: editor.snapshot.context.schema }, prev) && !editor.isProcessingRemoteChanges) {
+				if (prev != null && isSpan({ schema: editor.snapshot.context.schema }, prev) && !hasRemoteFrame(editor.applyContext)) {
 					if (child.text === "") {
 						editor.apply({
 							type: "unset",
@@ -8257,6 +8240,7 @@ const shouldNormalize = (_editor, { iteration, initialDirtyPathsLength }) => {
 }, createEditor = () => {
 	let e = {
 		[EDITOR_BRAND]: !0,
+		applyContext: [],
 		operations: [],
 		operationListeners: {
 			before: [],
@@ -8350,13 +8334,25 @@ function collectDescendantIndexes(context, node, nodePath, parent, blockIndexMap
 		blockIndexMap.has(childKey) || blockIndexMap.set(childKey, i), collectDescendantIndexes(context, child, childPath, result.parent, blockIndexMap);
 	}
 }
-function withRemoteChanges(editor, fn) {
-	let prev = editor.isProcessingRemoteChanges;
-	editor.isProcessingRemoteChanges = !0, fn(), editor.isProcessingRemoteChanges = prev;
+function withRemoteChanges(editor, source, fn) {
+	editor.applyContext.push(Object.freeze({
+		kind: "remote",
+		source
+	}));
+	try {
+		fn();
+	} finally {
+		editor.applyContext.pop();
+	}
 }
 function pluginWithoutHistory(editor, fn) {
 	let prev = editor.withHistory;
-	editor.withHistory = !1, fn(), editor.withHistory = prev;
+	editor.withHistory = !1;
+	try {
+		fn();
+	} finally {
+		editor.withHistory = prev;
+	}
 }
 function cloneDiff(diff2) {
 	let [type, patch] = diff2;
@@ -8759,8 +8755,10 @@ function bitap(text, pattern, loc, opts = {}) {
 			let charMatch = s[text.charAt(j - 1)];
 			if (d === 0 ? rd[j] = (rd[j + 1] << 1 | 1) & charMatch : rd[j] = (rd[j + 1] << 1 | 1) & charMatch | (lastRd[j + 1] | lastRd[j]) << 1 | 1 | lastRd[j + 1], rd[j] & matchmask) {
 				let score = getBitapScore(d, j - 1);
-				if (score <= scoreThreshold) if (scoreThreshold = score, bestLoc = j - 1, bestLoc > loc) start = Math.max(1, 2 * loc - bestLoc);
-				else break;
+				if (score <= scoreThreshold) {
+					if (scoreThreshold = score, bestLoc = j - 1, bestLoc > loc) start = Math.max(1, 2 * loc - bestLoc);
+					else break;
+				}
 			}
 		}
 		if (getBitapScore(d + 1, loc) > scoreThreshold) break;
@@ -9125,7 +9123,7 @@ function setupRemotePatches({ editorActor, subscriptions, editor }) {
 		let patches = bufferedPatches;
 		bufferedPatches = [];
 		let changed = !1;
-		withRemoteChanges(editor, () => {
+		withRemoteChanges(editor, "patches", () => {
 			withoutNormalizing(editor, () => {
 				withoutPatching(editor, () => {
 					pluginWithoutHistory(editor, () => {
@@ -9150,10 +9148,10 @@ function setupRemotePatches({ editorActor, subscriptions, editor }) {
 		};
 	});
 }
-function createUndoSteps({ steps, op, currentUndoStepId, previousUndoStepId, operationsInProgress, isNormalizingNode, selectionBeforeApply }) {
+function createUndoSteps({ steps, op, currentUndoStepId, previousUndoStepId, operationsInProgress, isInNormalization, selectionBeforeApply }) {
 	let lastStep = steps.at(-1);
 	if (!lastStep) return createNewStep(steps, op, selectionBeforeApply);
-	if (operationsInProgress) return currentUndoStepId === previousUndoStepId || isNormalizingNode ? mergeIntoLastStep(steps, lastStep, op) : createNewStep(steps, op, selectionBeforeApply);
+	if (operationsInProgress) return currentUndoStepId === previousUndoStepId || isInNormalization ? mergeIntoLastStep(steps, lastStep, op) : createNewStep(steps, op, selectionBeforeApply);
 	if (op.type === "set.selection" && currentUndoStepId === void 0 && previousUndoStepId !== void 0 || op.type === "set.selection" && currentUndoStepId !== void 0 && previousUndoStepId !== void 0 && previousUndoStepId !== currentUndoStepId) return mergeIntoLastStep(steps, lastStep, op);
 	if (currentUndoStepId === void 0 && previousUndoStepId === void 0) {
 		if (op.type === "set.selection") return mergeIntoLastStep(steps, lastStep, op);
@@ -9213,7 +9211,7 @@ function subscribeHistory({ editorActor, subscriptions, editor }) {
 			subscription.unsubscribe();
 		};
 	}), subscribeToOperations(editor, (event) => {
-		if (editorActor.getSnapshot().matches({ "edit mode": "read only" }) || event.isProcessingRemoteChanges || event.isUndoing || event.isRedoing) return;
+		if (editorActor.getSnapshot().matches({ "edit mode": "read only" }) || hasRemoteFrame(event.context) || event.origin === "undo" || event.origin === "redo") return;
 		let currentUndoStepId = event.undoStepId;
 		if (!event.withHistory) {
 			previousUndoStepId = currentUndoStepId;
@@ -9230,7 +9228,7 @@ function subscribeHistory({ editorActor, subscriptions, editor }) {
 			currentUndoStepId,
 			previousUndoStepId,
 			operationsInProgress: event.operationsInProgress,
-			isNormalizingNode: event.isNormalizingNode,
+			isInNormalization: isInNormalization(event.context),
 			selectionBeforeApply: event.beforeSelection
 		}); editor.history.undos.length > 1e3;) editor.history.undos.shift();
 		previousUndoStepId = currentUndoStepId;
@@ -9260,7 +9258,7 @@ function insertNodePatch(operation) {
 function subscribePatchGeneration({ editorActor, editor }) {
 	return subscribeToOperations(editor, (event) => {
 		if (!event.isPatching) return;
-		let operation = event.operation, previousValue = event.beforeValue, patches = [], { initialValue, schema } = editorActor.getSnapshot().context, editorWasEmpty = previousValue.length === 1 && isEqualToEmptyEditor(initialValue, previousValue, schema) && !isEqualValues({ schema }, editor.lastSyncedValue, previousValue), editorIsEmpty = editor.snapshot.context.value.length === 1 && isEqualToEmptyEditor(initialValue, editor.snapshot.context.value, schema) && !isEqualValues({ schema }, editor.lastSyncedValue, editor.snapshot.context.value);
+		let operation = event.operation, previousValue = event.beforeValue, patches = [], { initialValue, schema } = editorActor.getSnapshot().context, editorWasEmpty = previousValue.length === 1 && isEqualToEmptyEditor(initialValue, previousValue, schema) && (editor.valueUnsetEmitted || !isEqualValues({ schema }, editor.lastSyncedValue, previousValue)), editorIsEmpty = editor.snapshot.context.value.length === 1 && isEqualToEmptyEditor(initialValue, editor.snapshot.context.value, schema) && !isEqualValues({ schema }, editor.lastSyncedValue, editor.snapshot.context.value);
 		switch (editorWasEmpty && !editorIsEmpty && operation.type !== "set.selection" && patches.push(insert(previousValue, "before", [0])), operation.type) {
 			case "insert.text":
 				patches = [...patches, ...textPatch(editor.snapshot, operation, previousValue)];
@@ -9280,7 +9278,7 @@ function subscribePatchGeneration({ editorActor, editor }) {
 			"set",
 			"unset",
 			"remove.text"
-		].includes(operation.type) && (patches = [...patches, unset([])]), editorWasEmpty && patches.length > 0 && (patches = [setIfMissing([], []), ...patches]), patches.length > 0) for (let patch of patches) editorActor.send({
+		].includes(operation.type) && (patches = [...patches, unset([])], editor.valueUnsetEmitted = !0), editorWasEmpty && patches.length > 0 && (patches = [setIfMissing([], []), ...patches], editor.valueUnsetEmitted = !1, isEqualValues({ schema }, editor.lastSyncedValue, previousValue) && (editor.lastSyncedValue = void 0)), patches.length > 0) for (let patch of patches) editorActor.send({
 			type: "internal.patch",
 			patch: {
 				...patch,
@@ -9670,7 +9668,7 @@ function invalidateVerifiedGroups(groups, operation) {
 */
 function subscribeUpdateValue(context, editor) {
 	let unsubscribeNormalizationLog = debug.normalization.enabled ? subscribeToOperations(editor, (event) => {
-		event.isNormalizingNode && debug.normalization(`((engine operation))\n${safeStringify(event.operation, 2)}`);
+		isInNormalization(event.context) && debug.normalization(`((engine operation))\n${safeStringify(event.operation, 2)}`);
 	}, { phase: "before" }) : void 0, unsubscribeIndexMaps = subscribeToOperations(editor, (event) => {
 		let operation = event.operation;
 		operation.type !== "set.selection" && operation.type !== "insert.text" && operation.type !== "remove.text" && (transformBlockIndexMap(editor.blockIndexMap, operation, event.beforeValue, editor.snapshot.context.value, {
@@ -9708,7 +9706,7 @@ function createEditorEngine(config) {
 	}, editor.containers = /* @__PURE__ */ new Map(), editor.annotations = /* @__PURE__ */ new Map(), editor.blockObjects = /* @__PURE__ */ new Map(), editor.decorators = /* @__PURE__ */ new Map(), editor.inlineObjects = /* @__PURE__ */ new Map(), editor.spans = /* @__PURE__ */ new Map(), editor.textBlocks = /* @__PURE__ */ new Map(), editor.decoratedRanges = [], editor.blockIndexMap = blockIndexMap, editor.history = {
 		undos: [],
 		redos: []
-	}, editor.selectorChannelsPending = { registrations: !1 }, editor.verifiedUniqueChildGroups = /* @__PURE__ */ new Set(), editor.remotePatches = [], editor.undoStepId = void 0, editor.isDeferringMutations = !1, editor.lastSyncedValue = void 0, editor.isNormalizingNode = !1, editor.isPatching = !0, editor.isPerformingBehaviorOperation = !1, editor.isProcessingRemoteChanges = !1, editor.isRedoing = !1, editor.isUndoing = !1, editor.withHistory = !0;
+	}, editor.selectorChannelsPending = { registrations: !1 }, editor.verifiedUniqueChildGroups = /* @__PURE__ */ new Set(), editor.remotePatches = [], editor.undoStepId = void 0, editor.isDeferringMutations = !1, editor.lastSyncedValue = void 0, editor.valueUnsetEmitted = !1, editor.isPatching = !0, editor.isPerformingBehaviorOperation = !1, editor.withHistory = !0;
 	let editorEngine = plugins(withDOM(editor), { editorActor: config.editorActor });
 	return subscribeUpdateValue(context, editorEngine), subscribePatchGeneration({
 		editorActor: config.editorActor,
@@ -10387,9 +10385,9 @@ function isBlockLike(value) {
 * drag origin in a way that would make the drop a no-op.
 *
 * Two expanded selections that only touch at a single endpoint are not treated
-* as a self-drop — the drop position covers an adjacent block (typical when
+* as a self-drop: the drop position covers an adjacent block (typical when
 * dragging a block-object onto the next block via the expanded fallback in
-* `getEventPosition`), and the user genuinely wants the drop to happen.
+* `getEventPosition`), so the drop should go through.
 *
 * Chrome drags emit a collapsed selection pointing AT the dragged container.
 * A drop position whose path descends into that container is dropping the
@@ -11034,7 +11032,7 @@ const coreListBehaviors = {
 			let adjustLevel = !0, listStartBlockFound = !1;
 			return [raise$1({
 				...event,
-				blocks: event.blocks.map((block) => (block._key === insertedListBlock._key && (listStartBlockFound = !0), adjustLevel ? listStartBlockFound && adjustLevel && isListBlock(snapshot.context, block) ? {
+				blocks: event.blocks.map((block) => (block === insertedListBlock && (listStartBlockFound = !0), adjustLevel ? listStartBlockFound && adjustLevel && isListBlock(snapshot.context, block) ? {
 					...block,
 					level: Math.min(10, Math.max(1, block.level + levelDifference))
 				} : (listStartBlockFound && (adjustLevel = !1), block) : block))
@@ -11062,7 +11060,7 @@ const coreListBehaviors = {
 			let adjustListItem = !0, listStartBlockFound = !1;
 			return [raise$1({
 				...event,
-				blocks: event.blocks.map((block) => (block._key === insertedListBlock._key && (listStartBlockFound = !0), adjustListItem ? listStartBlockFound && adjustListItem && isListBlock(snapshot.context, block) ? {
+				blocks: event.blocks.map((block) => (block === insertedListBlock && (listStartBlockFound = !0), adjustListItem ? listStartBlockFound && adjustListItem && isListBlock(snapshot.context, block) ? {
 					...block,
 					listItem: block.level === insertedListBlock.level ? listItem : block.listItem
 				} : (listStartBlockFound && (adjustListItem = !1), block) : block))
@@ -11162,7 +11160,12 @@ function createEditorSnapshot({ converters, editor, keyGenerator, readOnly, sche
 }
 function withPerformingBehaviorOperation(editor, fn) {
 	let prev = editor.isPerformingBehaviorOperation;
-	editor.isPerformingBehaviorOperation = !0, fn(), editor.isPerformingBehaviorOperation = prev;
+	editor.isPerformingBehaviorOperation = !0;
+	try {
+		fn();
+	} finally {
+		editor.isPerformingBehaviorOperation = prev;
+	}
 }
 function withoutNormalizingConditional(editor, predicate, fn) {
 	predicate() ? withoutNormalizing(editor, fn) : fn();
@@ -11176,7 +11179,7 @@ const addAnnotationOperationImplementation = ({ snapshot, operation }) => {
 		},
 		schema: annotationSchema,
 		keyGenerator: context.keyGenerator,
-		options: { validateFields: !0 }
+		profile: "strict"
 	});
 	if (!parsedAnnotation) throw Error(`Failed to parse annotation ${safeStringify(operation.annotation)}`);
 	if (!effectiveSelection || isCollapsedRange(effectiveSelection)) return;
@@ -11222,59 +11225,65 @@ function isBeforePath(path, another, root) {
 }
 const removeAnnotationOperationImplementation = ({ snapshot, operation }) => {
 	let editor = operation.editor, at = operation.at ? resolveSelection(operation.editor, operation.at) : null, effectiveSelection = at ?? editor.snapshot.context.selection;
-	if (effectiveSelection) if (isCollapsedRange(effectiveSelection)) {
-		let blockEntry = getParent(snapshot, effectiveSelection.focus.path, { match: (node) => isTextBlock({ schema: editor.snapshot.context.schema }, node) });
-		if (!blockEntry) return;
-		let { node: block, path: blockPath } = blockEntry, potentialAnnotations = (block.markDefs ?? []).filter((markDef) => markDef._type === operation.annotation.name), selectedChildEntry = getNode(editor.snapshot, effectiveSelection.focus.path);
-		if (!selectedChildEntry) return;
-		let { node: selectedChild, path: selectedChildPath } = selectedChildEntry;
-		if (!isSpan({ schema: editor.snapshot.context.schema }, selectedChild)) return;
-		let annotationToRemove = selectedChild.marks?.find((mark) => potentialAnnotations.some((markDef) => markDef._key === mark));
-		if (!annotationToRemove) return;
-		let previousSpansWithSameAnnotation = [], reversedChildren = getChildren(editor.snapshot, blockPath);
-		for (let index = reversedChildren.length - 1; index >= 0; index--) {
-			let entry = reversedChildren[index];
-			if (!entry) continue;
-			let { node: child, path: childPath } = entry;
-			if (isSpan({ schema: editor.snapshot.context.schema }, child) && isBeforePath(childPath, selectedChildPath, editor.snapshot.context)) if (child.marks?.includes(annotationToRemove)) previousSpansWithSameAnnotation.push([child, childPath]);
-			else break;
-		}
-		let nextSpansWithSameAnnotation = [];
-		for (let { node: child, path: childPath } of getChildren(editor.snapshot, blockPath)) if (isSpan({ schema: editor.snapshot.context.schema }, child) && isAfterPath(childPath, selectedChildPath, editor.snapshot.context)) if (child.marks?.includes(annotationToRemove)) nextSpansWithSameAnnotation.push([child, childPath]);
-		else break;
-		for (let [child, childPath] of [
-			...previousSpansWithSameAnnotation,
-			[selectedChild, selectedChildPath],
-			...nextSpansWithSameAnnotation
-		]) applyNodeProperties(editor, { marks: child.marks?.filter((mark) => mark !== annotationToRemove) }, childPath);
-	} else {
-		let ref = at ? rangeRef(editor, at, { affinity: "inward" }) : null;
-		withoutNormalizing(editor, () => {
-			let splitRange = at ?? editor.snapshot.context.selection;
-			if (splitRange && isRange(splitRange)) {
-				let splitLeaf = getNode(editor.snapshot, splitRange.anchor.path)?.node;
-				if (!(splitLeaf && isCollapsedRange(splitRange) && isSpan({ schema: editor.snapshot.context.schema }, splitLeaf) && splitLeaf.text.length > 0)) {
-					let splitRangeRef = rangeRef(editor, splitRange, { affinity: "inward" }), [splitStart, splitEnd] = rangeEdges(splitRange, editor.snapshot.context);
-					(!isEnd(editor, splitEnd, splitEnd.path) || !isEdge(editor, splitEnd, splitEnd.path)) && applySplitNode(editor, splitEnd.path, splitEnd.offset), (!isStart(editor, splitStart, splitStart.path) || !isEdge(editor, splitStart, splitStart.path)) && applySplitNode(editor, splitStart.path, splitStart.offset);
-					let updatedSplitRange = splitRangeRef.unref();
-					!at && updatedSplitRange && applySelect(editor, updatedSplitRange);
+	if (effectiveSelection) {
+		if (isCollapsedRange(effectiveSelection)) {
+			let blockEntry = getParent(snapshot, effectiveSelection.focus.path, { match: (node) => isTextBlock({ schema: editor.snapshot.context.schema }, node) });
+			if (!blockEntry) return;
+			let { node: block, path: blockPath } = blockEntry, potentialAnnotations = (block.markDefs ?? []).filter((markDef) => markDef._type === operation.annotation.name), selectedChildEntry = getNode(editor.snapshot, effectiveSelection.focus.path);
+			if (!selectedChildEntry) return;
+			let { node: selectedChild, path: selectedChildPath } = selectedChildEntry;
+			if (!isSpan({ schema: editor.snapshot.context.schema }, selectedChild)) return;
+			let annotationToRemove = selectedChild.marks?.find((mark) => potentialAnnotations.some((markDef) => markDef._key === mark));
+			if (!annotationToRemove) return;
+			let previousSpansWithSameAnnotation = [], reversedChildren = getChildren(editor.snapshot, blockPath);
+			for (let index = reversedChildren.length - 1; index >= 0; index--) {
+				let entry = reversedChildren[index];
+				if (!entry) continue;
+				let { node: child, path: childPath } = entry;
+				if (isSpan({ schema: editor.snapshot.context.schema }, child) && isBeforePath(childPath, selectedChildPath, editor.snapshot.context)) {
+					if (child.marks?.includes(annotationToRemove)) previousSpansWithSameAnnotation.push([child, childPath]);
+					else break;
 				}
 			}
-			let blocks = Array.from(getNodes(editor.snapshot, {
-				from: rangeStart(effectiveSelection, editor.snapshot.context).path,
-				to: rangeEnd(effectiveSelection, editor.snapshot.context).path,
-				match: (node) => isTextBlock({ schema: editor.snapshot.context.schema }, node)
-			})), selectionRange = ref?.current ?? editor.snapshot.context.selection;
-			for (let { node: block, path: blockPath } of blocks) {
-				if (!isTextBlock({ schema: editor.snapshot.context.schema }, block)) continue;
-				let children = getChildren(editor.snapshot, blockPath);
-				for (let { node: child, path: childPath } of children) {
-					if (!isSpan({ schema: editor.snapshot.context.schema }, child) || !selectionRange || !rangeIntersects(editor.snapshot, selectionRange, childPath)) continue;
-					let markDefs = block.markDefs ?? [], marks = child.marks ?? [], marksWithoutAnnotation = marks.filter((mark) => markDefs.find((markDef) => markDef._key === mark)?._type !== operation.annotation.name);
-					marksWithoutAnnotation.length !== marks.length && applyNodeProperties(editor, { marks: marksWithoutAnnotation }, childPath);
-				}
+			let nextSpansWithSameAnnotation = [];
+			for (let { node: child, path: childPath } of getChildren(editor.snapshot, blockPath)) if (isSpan({ schema: editor.snapshot.context.schema }, child) && isAfterPath(childPath, selectedChildPath, editor.snapshot.context)) {
+				if (child.marks?.includes(annotationToRemove)) nextSpansWithSameAnnotation.push([child, childPath]);
+				else break;
 			}
-		}), ref?.unref();
+			for (let [child, childPath] of [
+				...previousSpansWithSameAnnotation,
+				[selectedChild, selectedChildPath],
+				...nextSpansWithSameAnnotation
+			]) applyNodeProperties(editor, { marks: child.marks?.filter((mark) => mark !== annotationToRemove) }, childPath);
+		} else {
+			let ref = at ? rangeRef(editor, at, { affinity: "inward" }) : null;
+			withoutNormalizing(editor, () => {
+				let splitRange = at ?? editor.snapshot.context.selection;
+				if (splitRange && isRange(splitRange)) {
+					let splitLeaf = getNode(editor.snapshot, splitRange.anchor.path)?.node;
+					if (!(splitLeaf && isCollapsedRange(splitRange) && isSpan({ schema: editor.snapshot.context.schema }, splitLeaf) && splitLeaf.text.length > 0)) {
+						let splitRangeRef = rangeRef(editor, splitRange, { affinity: "inward" }), [splitStart, splitEnd] = rangeEdges(splitRange, editor.snapshot.context);
+						(!isEnd(editor, splitEnd, splitEnd.path) || !isEdge(editor, splitEnd, splitEnd.path)) && applySplitNode(editor, splitEnd.path, splitEnd.offset), (!isStart(editor, splitStart, splitStart.path) || !isEdge(editor, splitStart, splitStart.path)) && applySplitNode(editor, splitStart.path, splitStart.offset);
+						let updatedSplitRange = splitRangeRef.unref();
+						!at && updatedSplitRange && applySelect(editor, updatedSplitRange);
+					}
+				}
+				let blocks = Array.from(getNodes(editor.snapshot, {
+					from: rangeStart(effectiveSelection, editor.snapshot.context).path,
+					to: rangeEnd(effectiveSelection, editor.snapshot.context).path,
+					match: (node) => isTextBlock({ schema: editor.snapshot.context.schema }, node)
+				})), selectionRange = ref?.current ?? editor.snapshot.context.selection;
+				for (let { node: block, path: blockPath } of blocks) {
+					if (!isTextBlock({ schema: editor.snapshot.context.schema }, block)) continue;
+					let children = getChildren(editor.snapshot, blockPath);
+					for (let { node: child, path: childPath } of children) {
+						if (!isSpan({ schema: editor.snapshot.context.schema }, child) || !selectionRange || !rangeIntersects(editor.snapshot, selectionRange, childPath)) continue;
+						let markDefs = block.markDefs ?? [], marks = child.marks ?? [], marksWithoutAnnotation = marks.filter((mark) => markDefs.find((markDef) => markDef._key === mark)?._type !== operation.annotation.name);
+						marksWithoutAnnotation.length !== marks.length && applyNodeProperties(editor, { marks: marksWithoutAnnotation }, childPath);
+					}
+				}
+			}), ref?.unref();
+		}
 	}
 };
 /**
@@ -11326,7 +11335,7 @@ const blockSetOperationImplementation = ({ snapshot, operation }) => {
 				let { markDefs } = parseMarkDefs({
 					keyGenerator: context.keyGenerator,
 					markDefs: operation.props[key],
-					options: { validateFields: !0 },
+					profile: "strict",
 					schema: getPathSubSchema(snapshot, blockEntry.path)
 				});
 				filteredProps[key] = markDefs;
@@ -12350,8 +12359,12 @@ const deleteOperationImplementation = ({ operation }) => {
 	});
 };
 function pluginRedoing(editor, fn) {
-	let prev = editor.isRedoing;
-	editor.isRedoing = !0, fn(), editor.isRedoing = prev;
+	editor.applyContext.push(Object.freeze({ kind: "redo" }));
+	try {
+		fn();
+	} finally {
+		editor.applyContext.pop();
+	}
 }
 /**
 * This will adjust the operation paths and offsets according to the
@@ -12421,7 +12434,7 @@ const historyRedoOperationImplementation = ({ operation }) => {
 				console.error(`Could not perform 'history.redo' operation: ${err instanceof Error ? err.message : err}`), editor.remotePatches.splice(0, editor.remotePatches.length), applyDeselect(editor), editor.history = {
 					undos: [],
 					redos: []
-				}, editor.withHistory = !0, editor.isRedoing = !1, editor.onChange();
+				}, editor.onChange();
 				return;
 			}
 			editor.history.undos.push(step), editor.history.redos.pop();
@@ -12429,8 +12442,12 @@ const historyRedoOperationImplementation = ({ operation }) => {
 	}
 };
 function pluginUndoing(editor, fn) {
-	let prev = editor.isUndoing;
-	editor.isUndoing = !0, fn(), editor.isUndoing = prev;
+	editor.applyContext.push(Object.freeze({ kind: "undo" }));
+	try {
+		fn();
+	} finally {
+		editor.applyContext.pop();
+	}
 }
 function inverseOperation(op) {
 	switch (op.type) {
@@ -12526,7 +12543,7 @@ const historyUndoOperationImplementation = ({ operation }) => {
 				console.error(`Could not perform 'history.undo' operation: ${err instanceof Error ? err.message : err}`), editor.remotePatches.splice(0, editor.remotePatches.length), applyDeselect(editor), editor.history = {
 					undos: [],
 					redos: []
-				}, editor.withHistory = !0, editor.isUndoing = !1, editor.onChange();
+				}, editor.onChange();
 				return;
 			}
 			editor.history.redos.push(step), editor.history.undos.pop();
@@ -12543,11 +12560,7 @@ const historyUndoOperationImplementation = ({ operation }) => {
 	let { context } = snapshot, editor = operation.editor, resolved = operation.at ? resolveSelection(editor, operation.at) : resolveSelection(editor, editor.snapshot.context.selection), at = resolved && operation.at && operation.placement !== "auto" ? operation.at : resolved, destinationPath = at ? operation.placement === "before" ? rangeStart(at, editor.snapshot.context).path : rangeEnd(at, editor.snapshot.context).path : editor.snapshot.context.value.length > 0 ? end(editor, []).path : void 0, schema = destinationPath ? getPathSubSchema(snapshot, destinationPath) : context.schema, parsedBlock = parseBlock({
 		block: operation.block,
 		keyGenerator: context.keyGenerator,
-		options: {
-			normalize: !0,
-			removeUnusedMarkDefs: !0,
-			validateFields: !0
-		},
+		profile: "strict",
 		schema
 	});
 	if (!parsedBlock) return;
@@ -12947,13 +12960,11 @@ const insertChildOperationImplementation = ({ snapshot, operation }) => {
 		...focusBlockEntry.path,
 		"children",
 		focusChildSegment
-	], markDefs = focusBlock.markDefs ?? [], markDefKeyMap = /* @__PURE__ */ new Map();
-	for (let markDef of markDefs) markDefKeyMap.set(markDef._key, markDef._key);
-	let schema = getPathSubSchema(snapshot, focusBlockEntry.path), span = parseSpan({
+	], markDefs = focusBlock.markDefs ?? [], markDefKeys = new Set(markDefs.map((markDef) => markDef._key)), schema = getPathSubSchema(snapshot, focusBlockEntry.path), span = parseSpan({
 		span: operation.child,
 		keyGenerator: context.keyGenerator,
-		markDefKeyMap,
-		options: { validateFields: !0 },
+		markDefKeys,
+		profile: "strict",
 		schema
 	});
 	if (span) {
@@ -12974,7 +12985,7 @@ const insertChildOperationImplementation = ({ snapshot, operation }) => {
 	let inlineObject = parseInlineObject({
 		inlineObject: operation.child,
 		keyGenerator: context.keyGenerator,
-		options: { validateFields: !0 },
+		profile: "strict",
 		schema
 	});
 	if (inlineObject) {
@@ -13014,12 +13025,13 @@ const insertChildOperationImplementation = ({ snapshot, operation }) => {
 	let node = nodeEntry.node;
 	if (isLeafObject(editor.snapshot, node, nodeEntry.path)) {
 		let nextSibling = getSibling(editor.snapshot, nodeEntry.path, { direction: "next" });
-		if (nextSibling) if (getSpan(editor.snapshot, nextSibling.path)) path = nextSibling.path, offset = 0, applySelect(editor, {
-			path,
-			offset
-		});
-		else return;
-		else return;
+		if (nextSibling) {
+			if (getSpan(editor.snapshot, nextSibling.path)) path = nextSibling.path, offset = 0, applySelect(editor, {
+				path,
+				offset
+			});
+			else return;
+		} else return;
 	}
 	operation.text.length > 0 && editor.apply({
 		type: "insert.text",
@@ -13066,7 +13078,14 @@ const moveBackwardOperationImplementation = ({ operation }) => {
 	if (newSelection) {
 		let anchorContainer = getContainer(operation.editor.snapshot, newSelection.anchor.path), focusContainer = getContainer(operation.editor.snapshot, newSelection.focus.path), containers = anchorContainer ? [anchorContainer] : [];
 		focusContainer && focusContainer.node !== anchorContainer?.node && containers.push(focusContainer), containers.length > 0 && (withoutNormalizing(operation.editor, () => {
-			for (let entry of containers) operation.editor.isNormalizingNode = !0, operation.editor.normalizeNode([entry.node, entry.path]), operation.editor.isNormalizingNode = !1;
+			for (let entry of containers) {
+				operation.editor.applyContext.push(Object.freeze({ kind: "normalization" }));
+				try {
+					operation.editor.normalizeNode([entry.node, entry.path]);
+				} finally {
+					operation.editor.applyContext.pop();
+				}
+			}
 		}), newSelection = resolveSelection(operation.editor, operation.at));
 	}
 	newSelection ? applySelect(operation.editor, newSelection) : applyDeselect(operation.editor), operation.editor.focused && operation.editor.snapshot.context.readOnly && (operation.editor.focused = !1);
@@ -14444,11 +14463,7 @@ const abstractInsertBehaviors = [
 					endPoint: blockEndPoint
 				}),
 				keyGenerator: snapshot.context.keyGenerator,
-				options: {
-					normalize: !1,
-					removeUnusedMarkDefs: !0,
-					validateFields: !1
-				},
+				profile: "lenient",
 				schema: getPathSubSchema(snapshot, focusTextBlock.path)
 			});
 			return newTextBlock ? {
@@ -15264,7 +15279,7 @@ const editorMachine = setup({
 	},
 	guards: {
 		"engine is busy": ({ context }) => context.editorEngine ? context.editorEngine.operations.length > 0 : !1,
-		"engine is normalizing node": ({ context }) => context.editorEngine ? context.editorEngine.isNormalizingNode : !1
+		"engine is normalizing node": ({ context }) => context.editorEngine ? isInNormalization(context.editorEngine.applyContext) : !1
 	}
 }).createMachine({
 	id: "editor",
@@ -15976,7 +15991,7 @@ const syncValueCallback = ({ sendBack, input }) => {
 		"clear pending value": assign({ pendingValue: void 0 }),
 		"assign previous value": assign({ previousValue: ({ event }) => (assertEvent(event, "done syncing"), event.value) }),
 		"record synced value on engine": ({ context, event }) => {
-			assertEvent(event, "done syncing"), context.editorEngine.lastSyncedValue = event.value;
+			assertEvent(event, "done syncing"), event.changed && (context.editorEngine.lastSyncedValue = event.value);
 		},
 		"emit done syncing value": emit({ type: "done syncing value" }),
 		"emit syncing value": emit({ type: "syncing value" })
@@ -15984,11 +15999,11 @@ const syncValueCallback = ({ sendBack, input }) => {
 	guards: {
 		"initial value synced": ({ context }) => context.initialValueSynced,
 		"is busy": ({ context }) => {
-			let isBusy = context.editorEngine.isDeferringMutations || context.editorEngine.isProcessingRemoteChanges;
+			let isBusy = context.editorEngine.isDeferringMutations || hasRemoteFrame(context.editorEngine.applyContext);
 			return debug.syncValue(safeStringify({
 				isBusy,
 				isDeferringMutations: context.editorEngine.isDeferringMutations,
-				isProcessingRemoteChanges: context.editorEngine.isProcessingRemoteChanges
+				hasRemoteFrame: hasRemoteFrame(context.editorEngine.applyContext)
 			})), isBusy;
 		},
 		"is empty value": ({ event }) => event.type === "update value" && event.value === void 0,
@@ -16138,59 +16153,67 @@ const syncValueCallback = ({ sendBack, input }) => {
 	}
 });
 async function updateValue({ context, sendBack, editorEngine, streamBlocks, value }) {
-	let doneSyncing = !1, isChanged = !1, isValid = !0, hadSelection = !!editorEngine.snapshot.context.selection;
+	let doneSyncing = !1, isChanged = !1, isValid = !0, hadSelection = !!editorEngine.snapshot.context.selection, remoteSource = streamBlocks ? "initial-sync" : "update-value";
 	if ((!value || value.length === 0) && (clearEditor({
 		editorEngine,
-		doneSyncing
-	}), isChanged = !0), value && value.length > 0) if (streamBlocks) await new Promise((resolve) => {
-		if (doneSyncing) {
-			resolve();
-			return;
-		}
-		isChanged = removeExtraBlocks({
-			editorEngine,
-			value
+		doneSyncing,
+		remoteSource
+	}), isChanged = !0), value && value.length > 0) {
+		if (streamBlocks) await new Promise((resolve) => {
+			if (doneSyncing) {
+				resolve();
+				return;
+			}
+			isChanged = removeExtraBlocks({
+				editorEngine,
+				value,
+				remoteSource
+			});
+			let processBlocks = async () => {
+				for await (let [currentBlock, currentBlockIndex] of getStreamedBlocks({ value })) {
+					let { blockChanged, blockValid } = syncBlock({
+						context,
+						sendBack,
+						block: currentBlock,
+						index: currentBlockIndex,
+						editorEngine,
+						value,
+						remoteSource
+					});
+					if (isChanged = blockChanged || isChanged, isValid &&= blockValid, !isValid) break;
+				}
+				resolve();
+			};
+			processBlocks();
 		});
-		let processBlocks = async () => {
-			for await (let [currentBlock, currentBlockIndex] of getStreamedBlocks({ value })) {
+		else {
+			if (doneSyncing) return;
+			isChanged = removeExtraBlocks({
+				editorEngine,
+				value,
+				remoteSource
+			});
+			let index = 0;
+			for (let block of value) {
 				let { blockChanged, blockValid } = syncBlock({
 					context,
 					sendBack,
-					block: currentBlock,
-					index: currentBlockIndex,
+					block,
+					index,
 					editorEngine,
-					value
+					value,
+					remoteSource
 				});
-				if (isChanged = blockChanged || isChanged, isValid &&= blockValid, !isValid) break;
+				if (isChanged = blockChanged || isChanged, isValid &&= blockValid, !blockValid) break;
+				index++;
 			}
-			resolve();
-		};
-		processBlocks();
-	});
-	else {
-		if (doneSyncing) return;
-		isChanged = removeExtraBlocks({
-			editorEngine,
-			value
-		});
-		let index = 0;
-		for (let block of value) {
-			let { blockChanged, blockValid } = syncBlock({
-				context,
-				sendBack,
-				block,
-				index,
-				editorEngine,
-				value
-			});
-			if (isChanged = blockChanged || isChanged, isValid &&= blockValid, !blockValid) break;
-			index++;
 		}
 	}
 	if (!isValid) {
 		debug.syncValue("Invalid value, returning"), doneSyncing = !0, sendBack({
 			type: "done syncing",
-			value
+			value,
+			changed: isChanged
 		});
 		return;
 	}
@@ -16205,7 +16228,8 @@ async function updateValue({ context, sendBack, editorEngine, streamBlocks, valu
 				value
 			}), doneSyncing = !0, sendBack({
 				type: "done syncing",
-				value
+				value,
+				changed: isChanged
 			});
 			return;
 		}
@@ -16216,7 +16240,8 @@ async function updateValue({ context, sendBack, editorEngine, streamBlocks, valu
 	} else debug.syncValue("remote value and local value are equal, no need to sync");
 	doneSyncing = !0, sendBack({
 		type: "done syncing",
-		value
+		value,
+		changed: isChanged
 	});
 }
 async function* getStreamedBlocks({ value }) {
@@ -16226,8 +16251,8 @@ async function* getStreamedBlocks({ value }) {
 /**
 * Unsets every block; normalization then inserts the empty placeholder block.
 */
-function clearEditor({ editorEngine, doneSyncing }) {
-	withRemoteChanges(editorEngine, () => {
+function clearEditor({ editorEngine, doneSyncing, remoteSource }) {
+	withRemoteChanges(editorEngine, remoteSource, () => {
 		withoutNormalizing(editorEngine, () => {
 			pluginWithoutHistory(editorEngine, () => {
 				withoutPatching(editorEngine, () => {
@@ -16249,9 +16274,9 @@ function clearEditor({ editorEngine, doneSyncing }) {
 * Compare the length of the value and the length of the editor's children, and
 * remove blocks that have become superfluous
 */
-function removeExtraBlocks({ editorEngine, value }) {
+function removeExtraBlocks({ editorEngine, value, remoteSource }) {
 	let isChanged = !1;
-	return withRemoteChanges(editorEngine, () => {
+	return withRemoteChanges(editorEngine, remoteSource, () => {
 		withoutNormalizing(editorEngine, () => {
 			withoutPatching(editorEngine, () => {
 				let childrenLength = editorEngine.snapshot.context.value.length;
@@ -16269,13 +16294,13 @@ function removeExtraBlocks({ editorEngine, value }) {
 		});
 	}), isChanged;
 }
-function syncBlock({ context, sendBack, block, index, editorEngine, value }) {
+function syncBlock({ context, sendBack, block, index, editorEngine, value, remoteSource }) {
 	let oldEngineBlock = editorEngine.snapshot.context.value.at(index), oldBlock = editorEngine.snapshot.context.value.at(index);
 	if (!oldEngineBlock || !oldBlock) {
 		let validation = validateValue([block], context.schema, context.keyGenerator);
 		if (debug.syncValue("Validating and inserting new block in the end of the value", block), validation.valid || validation.resolution?.autoResolve) {
 			let engineBlock = toEngineBlock(applyAutoResolution(validation, [block], block), { schemaTypes: context.schema });
-			return withRemoteChanges(editorEngine, () => {
+			return withRemoteChanges(editorEngine, remoteSource, () => {
 				withoutNormalizing(editorEngine, () => {
 					withoutPatching(editorEngine, () => {
 						editorEngine.apply({
@@ -16317,7 +16342,7 @@ function syncBlock({ context, sendBack, block, index, editorEngine, value }) {
 		});
 	})), validation.valid || validation.resolution?.autoResolve) {
 		let repairedBlock = applyAutoResolution(validation, validationValue, block);
-		return oldBlock._key === block._key && oldBlock._type === block._type ? (debug.syncValue("Updating block", oldBlock, repairedBlock), withRemoteChanges(editorEngine, () => {
+		return oldBlock._key === block._key && oldBlock._type === block._type ? (debug.syncValue("Updating block", oldBlock, repairedBlock), withRemoteChanges(editorEngine, remoteSource, () => {
 			withoutNormalizing(editorEngine, () => {
 				withoutPatching(editorEngine, () => {
 					updateBlock({
@@ -16329,7 +16354,7 @@ function syncBlock({ context, sendBack, block, index, editorEngine, value }) {
 					});
 				});
 			});
-		})) : (debug.syncValue("Replacing block", oldBlock, repairedBlock), withRemoteChanges(editorEngine, () => {
+		})) : (debug.syncValue("Replacing block", oldBlock, repairedBlock), withRemoteChanges(editorEngine, remoteSource, () => {
 			withoutNormalizing(editorEngine, () => {
 				withoutPatching(editorEngine, () => {
 					replaceBlock({
@@ -16627,7 +16652,7 @@ function createActors(config) {
 		isPublicOperation(event.operation) && config.relay.send({
 			type: "operation",
 			operation: event.operation,
-			origin: event.origin === "remote" ? "remote" : "local"
+			origin: hasRemoteFrame(event.context) ? "remote" : "local"
 		});
 	})), config.subscriptions.push(() => {
 		let subscription = syncActor.on("*", (event) => {