@portabletext/editor 1.48.12 → 1.48.14

package/lib/_chunks-cjs/editor-provider.cjs

@@ -149,18 +149,18 @@ const IS_PROCESSING_REMOTE_CHANGES = /* @__PURE__ */ new WeakMap(), KEY_TO_SLATE
       }) => {
         if (xstate.assertEvent(event, "patch"), context.pendingMutations.length === 0)
           return [{
-            actionId: event.actionId,
+            operationId: event.operationId,
             value: event.value,
             patches: [event.patch]
           }];
         const lastBulk = context.pendingMutations.at(-1);
-        return lastBulk && lastBulk.actionId === event.actionId ? context.pendingMutations.slice(0, -1).concat({
+        return lastBulk && lastBulk.operationId === event.operationId ? context.pendingMutations.slice(0, -1).concat({
           value: event.value,
-          actionId: lastBulk.actionId,
+          operationId: lastBulk.operationId,
           patches: [...lastBulk.patches, event.patch]
         }) : context.pendingMutations.concat({
           value: event.value,
-          actionId: event.actionId,
+          operationId: event.operationId,
           patches: [event.patch]
         });
       }
@@ -1301,16 +1301,6 @@ function randomKey(length) {
   const table = getByteHexTable();
   return whatwgRNG(length).reduce((str, n) => str + table[n], "").slice(0, length);
 }
-const CURRENT_ACTION_ID = /* @__PURE__ */ new WeakMap();
-function withApplyingBehaviorActions(editor, fn) {
-  CURRENT_ACTION_ID.set(editor, defaultKeyGenerator()), slate.Editor.withoutNormalizing(editor, fn), CURRENT_ACTION_ID.set(editor, void 0);
-}
-function getCurrentActionId(editor) {
-  return CURRENT_ACTION_ID.get(editor);
-}
-function isApplyingBehaviorActions(editor) {
-  return getCurrentActionId(editor) !== void 0;
-}
 const CURRENT_UNDO_STEP = /* @__PURE__ */ new WeakMap();
 function withUndoStep(editor, fn) {
   const current = CURRENT_UNDO_STEP.get(editor);
@@ -1412,10 +1402,10 @@ function createWithUndoRedo(options) {
     }, editor;
   };
 }
-const historyUndoActionImplementation = ({
-  action
+const historyUndoOperationImplementation = ({
+  operation
 }) => {
-  const editor = action.editor, {
+  const editor = operation.editor, {
     undos
   } = editor.history, remotePatches = getRemotePatches(editor);
   if (undos.length > 0) {
@@ -1447,10 +1437,10 @@ const historyUndoActionImplementation = ({
       editor.history.redos.push(step), editor.history.undos.pop();
     }
   }
-}, historyRedoActionImplementation = ({
-  action
+}, historyRedoOperationImplementation = ({
+  operation
 }) => {
-  const editor = action.editor, {
+  const editor = operation.editor, {
     redos
   } = editor.history, remotePatches = getRemotePatches(editor);
   if (redos.length > 0) {
@@ -2626,13 +2616,214 @@ function createOperationToPatches(editorActor) {
     splitNodePatch
   };
 }
-const insertTextActionImplementation = ({
-  action
+function getFocusBlock({
+  editor
+}) {
+  if (!editor.selection)
+    return [void 0, void 0];
+  try {
+    return slate.Editor.node(editor, editor.selection.focus.path.slice(0, 1)) ?? [void 0, void 0];
+  } catch {
+    return [void 0, void 0];
+  }
+}
+function getSelectionStartBlock({
+  editor
+}) {
+  if (!editor.selection)
+    return [void 0, void 0];
+  const selectionStartPoint = slate.Range.start(editor.selection);
+  return getPointBlock({
+    editor,
+    point: selectionStartPoint
+  });
+}
+function getSelectionEndBlock({
+  editor
+}) {
+  if (!editor.selection)
+    return [void 0, void 0];
+  const selectionEndPoint = slate.Range.end(editor.selection);
+  return getPointBlock({
+    editor,
+    point: selectionEndPoint
+  });
+}
+function getPointBlock({
+  editor,
+  point
+}) {
+  try {
+    const [block] = slate.Editor.node(editor, point.path.slice(0, 1)) ?? [void 0, void 0];
+    return block ? [block, point.path.slice(0, 1)] : [void 0, void 0];
+  } catch {
+    return [void 0, void 0];
+  }
+}
+function getFocusChild({
+  editor
+}) {
+  const [focusBlock, focusBlockPath] = getFocusBlock({
+    editor
+  }), childIndex = editor.selection?.focus.path.at(1);
+  if (!focusBlock || !focusBlockPath || childIndex === void 0)
+    return [void 0, void 0];
+  try {
+    const focusChild = slate.Node.child(focusBlock, childIndex);
+    return focusChild ? [focusChild, [...focusBlockPath, childIndex]] : [void 0, void 0];
+  } catch {
+    return [void 0, void 0];
+  }
+}
+function getPointChild({
+  editor,
+  point
+}) {
+  const [block, blockPath] = getPointBlock({
+    editor,
+    point
+  }), childIndex = point.path.at(1);
+  if (!block || !blockPath || childIndex === void 0)
+    return [void 0, void 0];
+  try {
+    const pointChild = slate.Node.child(block, childIndex);
+    return pointChild ? [pointChild, [...blockPath, childIndex]] : [void 0, void 0];
+  } catch {
+    return [void 0, void 0];
+  }
+}
+function getFirstBlock({
+  editor
+}) {
+  const firstBlockPath = slate.Editor.start(editor, []).path.at(0);
+  try {
+    return firstBlockPath !== void 0 ? slate.Editor.node(editor, [firstBlockPath]) ?? [void 0, void 0] : [void 0, void 0];
+  } catch {
+    return [void 0, void 0];
+  }
+}
+function getLastBlock({
+  editor
+}) {
+  const lastBlockPath = slate.Editor.end(editor, []).path.at(0);
+  try {
+    return lastBlockPath !== void 0 ? slate.Editor.node(editor, [lastBlockPath]) ?? [void 0, void 0] : [void 0, void 0];
+  } catch {
+    return [void 0, void 0];
+  }
+}
+function getNodeBlock({
+  editor,
+  schema: schema2,
+  node
+}) {
+  if (slate.Editor.isEditor(node))
+    return;
+  if (isBlockElement({
+    editor,
+    schema: schema2
+  }, node))
+    return elementToBlock({
+      schema: schema2,
+      element: node
+    });
+  const parent = Array.from(slate.Editor.nodes(editor, {
+    mode: "highest",
+    at: [],
+    match: (n) => isBlockElement({
+      editor,
+      schema: schema2
+    }, n) && n.children.some((child) => child._key === node._key)
+  })).at(0)?.at(0);
+  return slate.Element.isElement(parent) ? elementToBlock({
+    schema: schema2,
+    element: parent
+  }) : void 0;
+}
+function elementToBlock({
+  schema: schema2,
+  element
+}) {
+  return fromSlateValue([element], schema2.block.name)?.at(0);
+}
+function isBlockElement({
+  editor,
+  schema: schema2
+}, node) {
+  return slate.Element.isElement(node) && !editor.isInline(node) && (schema2.block.name === node._type || schema2.blockObjects.some((blockObject) => blockObject.name === node._type));
+}
+function isListItemActive({
+  editor,
+  listItem
+}) {
+  if (!editor.selection)
+    return !1;
+  const selectedBlocks = [...slate.Editor.nodes(editor, {
+    at: editor.selection,
+    match: (node) => editor.isTextBlock(node)
+  })];
+  return selectedBlocks.length > 0 ? selectedBlocks.every(([node]) => editor.isListBlock(node) && node.listItem === listItem) : !1;
+}
+function isStyleActive({
+  editor,
+  style
+}) {
+  if (!editor.selection)
+    return !1;
+  const selectedBlocks = [...slate.Editor.nodes(editor, {
+    at: editor.selection,
+    match: (node) => editor.isTextBlock(node)
+  })];
+  return selectedBlocks.length > 0 ? selectedBlocks.every(([node]) => node.style === style) : !1;
+}
+function slateRangeToSelection({
+  schema: schema2,
+  editor,
+  range
+}) {
+  const [anchorBlock] = getPointBlock({
+    editor,
+    point: range.anchor
+  }), [focusBlock] = getPointBlock({
+    editor,
+    point: range.focus
+  });
+  if (!anchorBlock || !focusBlock)
+    return null;
+  const [anchorChild] = anchorBlock._type === schema2.block.name ? getPointChild({
+    editor,
+    point: range.anchor
+  }) : [void 0, void 0], [focusChild] = focusBlock._type === schema2.block.name ? getPointChild({
+    editor,
+    point: range.focus
+  }) : [void 0, void 0], selection = {
+    anchor: {
+      path: [{
+        _key: anchorBlock._key
+      }],
+      offset: range.anchor.offset
+    },
+    focus: {
+      path: [{
+        _key: focusBlock._key
+      }],
+      offset: range.focus.offset
+    },
+    backward: slate.Range.isBackward(range)
+  };
+  return anchorChild && (selection.anchor.path.push("children"), selection.anchor.path.push({
+    _key: anchorChild._key
+  })), focusChild && (selection.focus.path.push("children"), selection.focus.path.push({
+    _key: focusChild._key
+  })), selection;
+}
+const insertTextOperationImplementation = ({
+  operation
 }) => {
-  action.editor.marks ? slate.Transforms.insertNodes(action.editor, {
-    text: action.text,
-    ...action.editor.marks
-  }) : slate.Transforms.insertText(action.editor, action.text), action.editor.marks = null;
+  operation.editor.marks ? slate.Transforms.insertNodes(operation.editor, {
+    text: operation.text,
+    ...operation.editor.marks
+  }) : slate.Transforms.insertText(operation.editor, operation.text), operation.editor.marks = null;
 };
 function isPortableTextSpan(node) {
   return node._type === "span" && "text" in node && typeof node.text == "string" && (typeof node.marks > "u" || Array.isArray(node.marks) && node.marks.every((mark) => typeof mark == "string"));
@@ -3032,10 +3223,10 @@ function createWithPortableTextMarkModel(editorActor) {
     }, editor;
   };
 }
-const removeDecoratorActionImplementation = ({
-  action
+const removeDecoratorOperationImplementation = ({
+  operation
 }) => {
-  const editor = action.editor, mark = action.decorator, {
+  const editor = operation.editor, mark = operation.decorator, {
     selection
   } = editor;
   if (selection) {
@@ -3106,14 +3297,14 @@ function isDecoratorActive({
     ...slate.Editor.marks(editor) || {}
   }.marks || []).includes(decorator);
 }
-const addAnnotationActionImplementation = ({
+const addAnnotationOperationImplementation = ({
   context,
-  action
+  operation
 }) => {
   const parsedAnnotation = util_sliceBlocks.parseAnnotation({
     annotation: {
-      _type: action.annotation.name,
-      ...action.annotation.value
+      _type: operation.annotation.name,
+      ...operation.annotation.value
     },
     context,
     options: {
@@ -3121,8 +3312,8 @@ const addAnnotationActionImplementation = ({
     }
   });
   if (!parsedAnnotation)
-    throw new Error(`Failed to parse annotation ${JSON.stringify(action.annotation)}`);
-  const editor = action.editor;
+    throw new Error(`Failed to parse annotation ${JSON.stringify(operation.annotation)}`);
+  const editor = operation.editor;
   if (!editor.selection || slate.Range.isCollapsed(editor.selection))
     return;
   let paths, spanPath, markDefPath;
@@ -3173,10 +3364,10 @@ const addAnnotationActionImplementation = ({
     markDefPaths,
     spanPath
   }), paths;
-}, removeAnnotationActionImplementation = ({
-  action
+}, removeAnnotationOperationImplementation = ({
+  operation
 }) => {
-  const editor = action.editor;
+  const editor = operation.editor;
   if (editor.selection)
     if (slate.Range.isCollapsed(editor.selection)) {
       const [block, blockPath] = slate.Editor.node(editor, editor.selection, {
@@ -3184,7 +3375,7 @@ const addAnnotationActionImplementation = ({
       });
       if (!editor.isTextBlock(block))
         return;
-      const potentialAnnotations = (block.markDefs ?? []).filter((markDef) => markDef._type === action.annotation.name), [selectedChild, selectedChildPath] = slate.Editor.node(editor, editor.selection, {
+      const potentialAnnotations = (block.markDefs ?? []).filter((markDef) => markDef._type === operation.annotation.name), [selectedChild, selectedChildPath] = slate.Editor.node(editor, editor.selection, {
         depth: 2
       });
       if (!editor.isTextSpan(selectedChild))
@@ -3229,7 +3420,7 @@ const addAnnotationActionImplementation = ({
         for (const [child, childPath] of children) {
           if (!editor.isTextSpan(child) || !slate.Range.includes(editor.selection, childPath))
             continue;
-          const markDefs = block.markDefs ?? [], marks = child.marks ?? [], marksWithoutAnnotation = marks.filter((mark) => markDefs.find((markDef2) => markDef2._key === mark)?._type !== action.annotation.name);
+          const markDefs = block.markDefs ?? [], marks = child.marks ?? [], marksWithoutAnnotation = marks.filter((mark) => markDefs.find((markDef2) => markDef2._key === mark)?._type !== operation.annotation.name);
           marksWithoutAnnotation.length !== marks.length && slate.Transforms.setNodes(editor, {
             marks: marksWithoutAnnotation
           }, {
@@ -3281,34 +3472,34 @@ function moveRangeByOperation(range, operation) {
     focus
   };
 }
-const blockSetBehaviorActionImplementation = ({
+const blockSetOperationImplementation = ({
   context,
-  action
+  operation
 }) => {
   const location = toSlateRange({
     anchor: {
-      path: action.at,
+      path: operation.at,
       offset: 0
     },
     focus: {
-      path: action.at,
+      path: operation.at,
       offset: 0
     }
-  }, action.editor);
+  }, operation.editor);
   if (!location)
-    throw new Error(`Unable to convert ${JSON.stringify(action.at)} into a Slate Range`);
-  const block = slate.Editor.node(action.editor, location, {
+    throw new Error(`Unable to convert ${JSON.stringify(operation.at)} into a Slate Range`);
+  const block = slate.Editor.node(operation.editor, location, {
     depth: 1
   })?.[0];
   if (!block)
-    throw new Error(`Unable to find block at ${JSON.stringify(action.at)}`);
-  const parsedBlock = fromSlateValue([block], context.schema.block.name, KEY_TO_VALUE_ELEMENT.get(action.editor)).at(0);
+    throw new Error(`Unable to find block at ${JSON.stringify(operation.at)}`);
+  const parsedBlock = fromSlateValue([block], context.schema.block.name, KEY_TO_VALUE_ELEMENT.get(operation.editor)).at(0);
   if (!parsedBlock)
-    throw new Error(`Unable to parse block at ${JSON.stringify(action.at)}`);
+    throw new Error(`Unable to parse block at ${JSON.stringify(operation.at)}`);
   const {
     _type,
     ...filteredProps
-  } = action.props, updatedBlock = util_sliceBlocks.parseBlock({
+  } = operation.props, updatedBlock = util_sliceBlocks.parseBlock({
     context,
     block: {
       ...parsedBlock,
@@ -3319,41 +3510,41 @@ const blockSetBehaviorActionImplementation = ({
     }
   });
   if (!updatedBlock)
-    throw new Error(`Unable to update block at ${JSON.stringify(action.at)}`);
+    throw new Error(`Unable to update block at ${JSON.stringify(operation.at)}`);
   const slateBlock = toSlateValue([updatedBlock], {
     schemaTypes: context.schema
   })?.at(0);
   if (!slateBlock)
     throw new Error("Unable to convert block to Slate value");
-  slate.Transforms.setNodes(action.editor, slateBlock, {
+  slate.Transforms.setNodes(operation.editor, slateBlock, {
     at: location
   });
-}, blockUnsetBehaviorActionImplementation = ({
+}, blockUnsetOperationImplementation = ({
   context,
-  action
+  operation
 }) => {
   const location = toSlateRange({
     anchor: {
-      path: action.at,
+      path: operation.at,
       offset: 0
     },
     focus: {
-      path: action.at,
+      path: operation.at,
       offset: 0
     }
-  }, action.editor);
+  }, operation.editor);
   if (!location)
-    throw new Error(`Unable to convert ${JSON.stringify(action.at)} into a Slate Range`);
-  const block = slate.Editor.node(action.editor, location, {
+    throw new Error(`Unable to convert ${JSON.stringify(operation.at)} into a Slate Range`);
+  const block = slate.Editor.node(operation.editor, location, {
     depth: 1
   })?.[0];
   if (!block)
-    throw new Error(`Unable to find block at ${JSON.stringify(action.at)}`);
-  const parsedBlock = fromSlateValue([block], context.schema.block.name, KEY_TO_VALUE_ELEMENT.get(action.editor)).at(0);
+    throw new Error(`Unable to find block at ${JSON.stringify(operation.at)}`);
+  const parsedBlock = fromSlateValue([block], context.schema.block.name, KEY_TO_VALUE_ELEMENT.get(operation.editor)).at(0);
   if (!parsedBlock)
-    throw new Error(`Unable to parse block at ${JSON.stringify(action.at)}`);
+    throw new Error(`Unable to parse block at ${JSON.stringify(operation.at)}`);
   if (util_sliceBlocks.isTextBlock(context, parsedBlock)) {
-    const propsToRemove = action.props.filter((prop) => prop !== "_type"), updatedTextBlock = util_sliceBlocks.parseBlock({
+    const propsToRemove = operation.props.filter((prop) => prop !== "_type"), updatedTextBlock = util_sliceBlocks.parseBlock({
       context,
       block: omit__default.default(parsedBlock, propsToRemove),
       options: {
@@ -3361,260 +3552,58 @@ const blockSetBehaviorActionImplementation = ({
       }
     });
     if (!updatedTextBlock)
-      throw new Error(`Unable to update block at ${JSON.stringify(action.at)}`);
+      throw new Error(`Unable to update block at ${JSON.stringify(operation.at)}`);
     const propsToSet = {};
     for (const prop of propsToRemove)
       prop in updatedTextBlock ? propsToSet[prop] = updatedTextBlock[prop] : propsToSet[prop] = void 0;
-    slate.Transforms.setNodes(action.editor, propsToSet, {
+    slate.Transforms.setNodes(operation.editor, propsToSet, {
       at: location
     });
     return;
   }
   const updatedBlockObject = util_sliceBlocks.parseBlock({
     context,
-    block: omit__default.default(parsedBlock, action.props.filter((prop) => prop !== "_type")),
+    block: omit__default.default(parsedBlock, operation.props.filter((prop) => prop !== "_type")),
     options: {
       refreshKeys: !1
     }
   });
   if (!updatedBlockObject)
-    throw new Error(`Unable to update block at ${JSON.stringify(action.at)}`);
+    throw new Error(`Unable to update block at ${JSON.stringify(operation.at)}`);
   const {
     _type,
     _key,
     ...props
   } = updatedBlockObject;
-  slate.Transforms.setNodes(action.editor, {
+  slate.Transforms.setNodes(operation.editor, {
     _type,
     _key,
     value: props
   }, {
     at: location
   });
-};
-function getFocusBlock({
-  editor
-}) {
-  if (!editor.selection)
-    return [void 0, void 0];
-  try {
-    return slate.Editor.node(editor, editor.selection.focus.path.slice(0, 1)) ?? [void 0, void 0];
-  } catch {
-    return [void 0, void 0];
-  }
-}
-function getSelectionStartBlock({
-  editor
-}) {
-  if (!editor.selection)
-    return [void 0, void 0];
-  const selectionStartPoint = slate.Range.start(editor.selection);
-  return getPointBlock({
-    editor,
-    point: selectionStartPoint
-  });
-}
-function getSelectionEndBlock({
-  editor
-}) {
-  if (!editor.selection)
-    return [void 0, void 0];
-  const selectionEndPoint = slate.Range.end(editor.selection);
-  return getPointBlock({
-    editor,
-    point: selectionEndPoint
-  });
-}
-function getPointBlock({
-  editor,
-  point
-}) {
-  try {
-    const [block] = slate.Editor.node(editor, point.path.slice(0, 1)) ?? [void 0, void 0];
-    return block ? [block, point.path.slice(0, 1)] : [void 0, void 0];
-  } catch {
-    return [void 0, void 0];
-  }
-}
-function getFocusChild({
-  editor
-}) {
-  const [focusBlock, focusBlockPath] = getFocusBlock({
-    editor
-  }), childIndex = editor.selection?.focus.path.at(1);
-  if (!focusBlock || !focusBlockPath || childIndex === void 0)
-    return [void 0, void 0];
-  try {
-    const focusChild = slate.Node.child(focusBlock, childIndex);
-    return focusChild ? [focusChild, [...focusBlockPath, childIndex]] : [void 0, void 0];
-  } catch {
-    return [void 0, void 0];
-  }
-}
-function getPointChild({
-  editor,
-  point
-}) {
-  const [block, blockPath] = getPointBlock({
-    editor,
-    point
-  }), childIndex = point.path.at(1);
-  if (!block || !blockPath || childIndex === void 0)
-    return [void 0, void 0];
-  try {
-    const pointChild = slate.Node.child(block, childIndex);
-    return pointChild ? [pointChild, [...blockPath, childIndex]] : [void 0, void 0];
-  } catch {
-    return [void 0, void 0];
-  }
-}
-function getFirstBlock({
-  editor
-}) {
-  const firstBlockPath = slate.Editor.start(editor, []).path.at(0);
-  try {
-    return firstBlockPath !== void 0 ? slate.Editor.node(editor, [firstBlockPath]) ?? [void 0, void 0] : [void 0, void 0];
-  } catch {
-    return [void 0, void 0];
-  }
-}
-function getLastBlock({
-  editor
-}) {
-  const lastBlockPath = slate.Editor.end(editor, []).path.at(0);
-  try {
-    return lastBlockPath !== void 0 ? slate.Editor.node(editor, [lastBlockPath]) ?? [void 0, void 0] : [void 0, void 0];
-  } catch {
-    return [void 0, void 0];
-  }
-}
-function getNodeBlock({
-  editor,
-  schema: schema2,
-  node
-}) {
-  if (slate.Editor.isEditor(node))
-    return;
-  if (isBlockElement({
-    editor,
-    schema: schema2
-  }, node))
-    return elementToBlock({
-      schema: schema2,
-      element: node
-    });
-  const parent = Array.from(slate.Editor.nodes(editor, {
-    mode: "highest",
-    at: [],
-    match: (n) => isBlockElement({
-      editor,
-      schema: schema2
-    }, n) && n.children.some((child) => child._key === node._key)
-  })).at(0)?.at(0);
-  return slate.Element.isElement(parent) ? elementToBlock({
-    schema: schema2,
-    element: parent
-  }) : void 0;
-}
-function elementToBlock({
-  schema: schema2,
-  element
-}) {
-  return fromSlateValue([element], schema2.block.name)?.at(0);
-}
-function isBlockElement({
-  editor,
-  schema: schema2
-}, node) {
-  return slate.Element.isElement(node) && !editor.isInline(node) && (schema2.block.name === node._type || schema2.blockObjects.some((blockObject) => blockObject.name === node._type));
-}
-function isListItemActive({
-  editor,
-  listItem
-}) {
-  if (!editor.selection)
-    return !1;
-  const selectedBlocks = [...slate.Editor.nodes(editor, {
-    at: editor.selection,
-    match: (node) => editor.isTextBlock(node)
-  })];
-  return selectedBlocks.length > 0 ? selectedBlocks.every(([node]) => editor.isListBlock(node) && node.listItem === listItem) : !1;
-}
-function isStyleActive({
-  editor,
-  style
-}) {
-  if (!editor.selection)
-    return !1;
-  const selectedBlocks = [...slate.Editor.nodes(editor, {
-    at: editor.selection,
-    match: (node) => editor.isTextBlock(node)
-  })];
-  return selectedBlocks.length > 0 ? selectedBlocks.every(([node]) => node.style === style) : !1;
-}
-function slateRangeToSelection({
-  schema: schema2,
-  editor,
-  range
-}) {
-  const [anchorBlock] = getPointBlock({
-    editor,
-    point: range.anchor
-  }), [focusBlock] = getPointBlock({
-    editor,
-    point: range.focus
-  });
-  if (!anchorBlock || !focusBlock)
-    return null;
-  const [anchorChild] = anchorBlock._type === schema2.block.name ? getPointChild({
-    editor,
-    point: range.anchor
-  }) : [void 0, void 0], [focusChild] = focusBlock._type === schema2.block.name ? getPointChild({
-    editor,
-    point: range.focus
-  }) : [void 0, void 0], selection = {
-    anchor: {
-      path: [{
-        _key: anchorBlock._key
-      }],
-      offset: range.anchor.offset
-    },
-    focus: {
-      path: [{
-        _key: focusBlock._key
-      }],
-      offset: range.focus.offset
-    },
-    backward: slate.Range.isBackward(range)
-  };
-  return anchorChild && (selection.anchor.path.push("children"), selection.anchor.path.push({
-    _key: anchorChild._key
-  })), focusChild && (selection.focus.path.push("children"), selection.focus.path.push({
-    _key: focusChild._key
-  })), selection;
-}
-const decoratorAddActionImplementation = ({
+}, decoratorAddOperationImplementation = ({
   context,
-  action
+  operation
 }) => {
-  const editor = action.editor, mark = action.decorator, value = fromSlateValue(editor.children, context.schema.block.name, KEY_TO_VALUE_ELEMENT.get(editor)), manualAnchor = action.at?.anchor ? util_sliceBlocks.blockOffsetToSpanSelectionPoint({
+  const editor = operation.editor, mark = operation.decorator, value = fromSlateValue(editor.children, context.schema.block.name, KEY_TO_VALUE_ELEMENT.get(editor)), manualAnchor = operation.at?.anchor ? util_sliceBlocks.blockOffsetToSpanSelectionPoint({
     context: {
       ...context,
       value
     },
-    blockOffset: action.at.anchor,
+    blockOffset: operation.at.anchor,
     direction: "backward"
-  }) : void 0, manualFocus = action.at?.focus ? util_sliceBlocks.blockOffsetToSpanSelectionPoint({
+  }) : void 0, manualFocus = operation.at?.focus ? util_sliceBlocks.blockOffsetToSpanSelectionPoint({
     context: {
       ...context,
       value
     },
-    blockOffset: action.at.focus,
+    blockOffset: operation.at.focus,
     direction: "forward"
   }) : void 0, manualSelection = manualAnchor && manualFocus ? {
     anchor: manualAnchor,
     focus: manualFocus
-  } : void 0, selection = manualSelection ? toSlateRange(manualSelection, action.editor) ?? editor.selection : editor.selection;
+  } : void 0, selection = manualSelection ? toSlateRange(manualSelection, operation.editor) ?? editor.selection : editor.selection;
   if (!selection)
     return;
   const editorSelection = slateRangeToSelection({
@@ -3717,86 +3706,82 @@ const decoratorAddActionImplementation = ({
       ...selection2
     };
   }
-}, deleteActionImplementation = ({
+}, deleteOperationImplementation = ({
   context,
-  action
+  operation
 }) => {
-  const range = toSlateRange(action.at, action.editor);
+  const range = toSlateRange(operation.at, operation.editor);
   if (!range)
-    throw new Error(`Failed to get Slate Range for selection ${JSON.stringify(action.at)}`);
+    throw new Error(`Failed to get Slate Range for selection ${JSON.stringify(operation.at)}`);
   if (slate.Range.isCollapsed(range)) {
     const [focusBlock] = getFocusBlock({
       editor: {
-        ...action.editor,
+        ...operation.editor,
         selection: range
       }
     }), [focusChild] = getFocusChild({
       editor: {
-        ...action.editor,
+        ...operation.editor,
         selection: range
       }
     });
     if (focusBlock && focusBlock._type === context.schema.block.name && focusChild && focusChild._type === context.schema.span.name)
       return;
   }
-  action.editor.delete({
+  operation.editor.delete({
     at: range
   });
-}, deleteBackwardActionImplementation = ({
-  action
+}, deleteBackwardOperationImplementation = ({
+  operation
 }) => {
-  action.editor.deleteBackward(action.unit);
-}, deleteBlockActionImplementation = ({
-  action
+  slate.deleteBackward(operation.editor, operation.unit);
+}, deleteBlockOperationImplementation = ({
+  operation
 }) => {
   const range = toSlateRange({
     anchor: {
-      path: action.at,
+      path: operation.at,
       offset: 0
     },
     focus: {
-      path: action.at,
+      path: operation.at,
       offset: 0
     }
-  }, action.editor);
+  }, operation.editor);
   if (!range) {
     console.error("Unable to find Slate range from selection points");
     return;
   }
-  slate.Transforms.removeNodes(action.editor, {
+  slate.Transforms.removeNodes(operation.editor, {
     at: range
   });
-}, deleteForwardActionImplementation = ({
-  action
-}) => {
-  action.editor.deleteForward(action.unit);
-}, effectActionImplementation = ({
-  action
+}, deleteForwardOperationImplementation = ({
+  operation
 }) => {
-  action.effect();
-}, insertInlineObjectActionImplementation = ({
+  slate.deleteForward(operation.editor, operation.unit);
+}, insertInlineObjectOperationImplementation = ({
   context,
-  action
+  operation
 }) => {
   const parsedInlineObject = util_sliceBlocks.parseInlineObject({
     context,
     inlineObject: {
-      _type: action.inlineObject.name,
-      ...action.inlineObject.value ?? {}
+      _type: operation.inlineObject.name,
+      ...operation.inlineObject.value ?? {}
     },
     options: {
       refreshKeys: !1
     }
   });
   if (!parsedInlineObject)
-    throw new Error(`Failed to parse inline object ${JSON.stringify(action.inlineObject)}`);
-  if (!action.editor.selection) {
+    throw new Error(`Failed to parse inline object ${JSON.stringify(operation.inlineObject)}`);
+  if (!operation.editor.selection) {
     console.error("Unable to insert inline object without selection");
     return;
   }
-  const [focusTextBlock] = Array.from(slate.Editor.nodes(action.editor, {
-    at: action.editor.selection.focus.path,
-    match: (node) => action.editor.isTextBlock(node)
+  const [focusTextBlock] = Array.from(slate.Editor.nodes(operation.editor, {
+    at: operation.editor.selection.focus.path,
+    match: (node) => operation.editor.isTextBlock(node)
   })).at(0) ?? [void 0, void 0];
   if (!focusTextBlock) {
     console.error("Unable to perform action without focus text block");
@@ -3813,49 +3798,49 @@ const decoratorAddActionImplementation = ({
     console.error("Unable to insert inline object");
     return;
   }
-  slate.Transforms.insertNodes(action.editor, child);
-}, insertSpanActionImplementation = ({
+  slate.Transforms.insertNodes(operation.editor, child);
+}, insertSpanOperationImplementation = ({
   context,
-  action
+  operation
 }) => {
-  if (!action.editor.selection) {
-    console.error("Unable to perform action without selection", action);
+  if (!operation.editor.selection) {
+    console.error("Unable to perform action without selection", operation);
     return;
   }
-  const [focusBlock, focusBlockPath] = Array.from(slate.Editor.nodes(action.editor, {
-    at: action.editor.selection.focus.path,
-    match: (node) => action.editor.isTextBlock(node)
+  const [focusBlock, focusBlockPath] = Array.from(slate.Editor.nodes(operation.editor, {
+    at: operation.editor.selection.focus.path,
+    match: (node) => operation.editor.isTextBlock(node)
   }))[0] ?? [void 0, void 0];
   if (!focusBlock || !focusBlockPath) {
-    console.error("Unable to perform action without focus block", action);
+    console.error("Unable to perform action without focus block", operation);
     return;
   }
-  const markDefs = focusBlock.markDefs ?? [], annotations = action.annotations ? action.annotations.map((annotation) => ({
+  const markDefs = focusBlock.markDefs ?? [], annotations = operation.annotations ? operation.annotations.map((annotation) => ({
     _type: annotation.name,
     _key: context.keyGenerator(),
     ...annotation.value
   })) : void 0;
-  annotations && annotations.length > 0 && slate.Transforms.setNodes(action.editor, {
+  annotations && annotations.length > 0 && slate.Transforms.setNodes(operation.editor, {
     markDefs: [...markDefs, ...annotations]
-  }), slate.Transforms.insertNodes(action.editor, {
+  }), slate.Transforms.insertNodes(operation.editor, {
     _type: "span",
     _key: context.keyGenerator(),
-    text: action.text,
-    marks: [...annotations?.map((annotation) => annotation._key) ?? [], ...action.decorators ?? []]
+    text: operation.text,
+    marks: [...annotations?.map((annotation) => annotation._key) ?? [], ...operation.decorators ?? []]
   });
-}, insertBlockActionImplementation = ({
+}, insertBlockOperationImplementation = ({
   context,
-  action
+  operation
 }) => {
   const parsedBlock = util_sliceBlocks.parseBlock({
-    block: action.block,
+    block: operation.block,
     context,
     options: {
       refreshKeys: !1
     }
   });
   if (!parsedBlock)
-    throw new Error(`Failed to parse block ${JSON.stringify(action.block)}`);
+    throw new Error(`Failed to parse block ${JSON.stringify(operation.block)}`);
   const fragment = toSlateValue([parsedBlock], {
     schemaTypes: context.schema
   })[0];
@@ -3863,9 +3848,9 @@ const decoratorAddActionImplementation = ({
     throw new Error(`Failed to convert block to Slate fragment ${JSON.stringify(parsedBlock)}`);
   insertBlock({
     block: fragment,
-    placement: action.placement,
-    select: action.select ?? "start",
-    editor: action.editor,
+    placement: operation.placement,
+    select: operation.select ?? "start",
+    editor: operation.editor,
     schema: context.schema
   });
 };
@@ -4017,226 +4002,229 @@ function insertBlock({
     }
   }
 }
-const moveBackwardActionImplementation = ({
-  action
+const moveBackwardOperationImplementation = ({
+  operation
 }) => {
-  slate.Transforms.move(action.editor, {
+  slate.Transforms.move(operation.editor, {
     unit: "character",
-    distance: action.distance,
+    distance: operation.distance,
     reverse: !0
   });
-}, moveBlockActionImplementation = ({
-  action
+}, moveBlockOperationImplementation = ({
+  operation
 }) => {
-  const at = [toSlatePath(action.at, action.editor)[0]], to = [toSlatePath(action.to, action.editor)[0]];
-  slate.Transforms.moveNodes(action.editor, {
+  const at = [toSlatePath(operation.at, operation.editor)[0]], to = [toSlatePath(operation.to, operation.editor)[0]];
+  slate.Transforms.moveNodes(operation.editor, {
     at,
     to,
     mode: "highest"
   });
-}, moveForwardActionImplementation = ({
-  action
+}, moveForwardOperationImplementation = ({
+  operation
 }) => {
-  slate.Transforms.move(action.editor, {
+  slate.Transforms.move(operation.editor, {
     unit: "character",
-    distance: action.distance
+    distance: operation.distance
   });
-}, selectActionImplementation = ({
-  action
+}, selectOperationImplementation = ({
+  operation
 }) => {
-  const newSelection = toSlateRange(action.at, action.editor);
-  newSelection ? slate.Transforms.select(action.editor, newSelection) : slate.Transforms.deselect(action.editor);
-}, behaviorActionImplementations = {
-  "annotation.add": addAnnotationActionImplementation,
-  "annotation.remove": removeAnnotationActionImplementation,
-  "block.set": blockSetBehaviorActionImplementation,
-  "block.unset": blockUnsetBehaviorActionImplementation,
-  "decorator.add": decoratorAddActionImplementation,
-  "decorator.remove": removeDecoratorActionImplementation,
-  delete: deleteActionImplementation,
-  "delete.backward": deleteBackwardActionImplementation,
-  "delete.forward": deleteForwardActionImplementation,
-  "delete.block": deleteBlockActionImplementation,
-  "history.redo": historyRedoActionImplementation,
-  "history.undo": historyUndoActionImplementation,
-  "insert.block": insertBlockActionImplementation,
-  "insert.inline object": insertInlineObjectActionImplementation,
-  "insert.span": insertSpanActionImplementation,
-  "insert.text": insertTextActionImplementation,
-  effect: effectActionImplementation,
-  "move.backward": moveBackwardActionImplementation,
-  "move.block": moveBlockActionImplementation,
-  "move.forward": moveForwardActionImplementation,
-  select: selectActionImplementation
+  const newSelection = toSlateRange(operation.at, operation.editor);
+  newSelection ? slate.Transforms.select(operation.editor, newSelection) : slate.Transforms.deselect(operation.editor);
+}, behaviorOperationImplementations = {
+  "annotation.add": addAnnotationOperationImplementation,
+  "annotation.remove": removeAnnotationOperationImplementation,
+  "block.set": blockSetOperationImplementation,
+  "block.unset": blockUnsetOperationImplementation,
+  "decorator.add": decoratorAddOperationImplementation,
+  "decorator.remove": removeDecoratorOperationImplementation,
+  delete: deleteOperationImplementation,
+  "delete.backward": deleteBackwardOperationImplementation,
+  "delete.forward": deleteForwardOperationImplementation,
+  "delete.block": deleteBlockOperationImplementation,
+  "history.redo": historyRedoOperationImplementation,
+  "history.undo": historyUndoOperationImplementation,
+  "insert.block": insertBlockOperationImplementation,
+  "insert.inline object": insertInlineObjectOperationImplementation,
+  "insert.span": insertSpanOperationImplementation,
+  "insert.text": insertTextOperationImplementation,
+  "move.backward": moveBackwardOperationImplementation,
+  "move.block": moveBlockOperationImplementation,
+  "move.forward": moveForwardOperationImplementation,
+  select: selectOperationImplementation
 };
-function performAction({
+function performOperation({
   context,
-  action
+  operation
 }) {
-  switch (action.type) {
-    case "annotation.add": {
-      behaviorActionImplementations["annotation.add"]({
-        context,
-        action
-      });
-      break;
-    }
-    case "annotation.remove": {
-      behaviorActionImplementations["annotation.remove"]({
-        context,
-        action
-      });
-      break;
-    }
-    case "block.set": {
-      behaviorActionImplementations["block.set"]({
-        context,
-        action
-      });
-      break;
-    }
-    case "block.unset": {
-      behaviorActionImplementations["block.unset"]({
-        context,
-        action
-      });
-      break;
-    }
-    case "decorator.add": {
-      behaviorActionImplementations["decorator.add"]({
-        context,
-        action
-      });
-      break;
-    }
-    case "decorator.remove": {
-      behaviorActionImplementations["decorator.remove"]({
-        context,
-        action
-      });
-      break;
-    }
-    case "delete": {
-      behaviorActionImplementations.delete({
-        context,
-        action
-      });
-      break;
-    }
-    case "delete.backward": {
-      behaviorActionImplementations["delete.backward"]({
-        context,
-        action
-      });
-      break;
-    }
-    case "delete.block": {
-      behaviorActionImplementations["delete.block"]({
-        context,
-        action
-      });
-      break;
-    }
-    case "delete.forward": {
-      behaviorActionImplementations["delete.forward"]({
-        context,
-        action
-      });
-      break;
-    }
-    case "effect": {
-      behaviorActionImplementations.effect({
-        context,
-        action
-      });
-      break;
-    }
-    case "history.redo": {
-      behaviorActionImplementations["history.redo"]({
-        context,
-        action
-      });
-      break;
-    }
-    case "history.undo": {
-      behaviorActionImplementations["history.undo"]({
-        context,
-        action
-      });
-      break;
-    }
-    case "insert.block": {
-      behaviorActionImplementations["insert.block"]({
-        context,
-        action
-      });
-      break;
-    }
-    case "insert.inline object": {
-      behaviorActionImplementations["insert.inline object"]({
-        context,
-        action
-      });
-      break;
-    }
-    case "insert.span": {
-      behaviorActionImplementations["insert.span"]({
-        context,
-        action
-      });
-      break;
-    }
-    case "insert.text": {
-      behaviorActionImplementations["insert.text"]({
-        context,
-        action
-      });
-      break;
-    }
-    case "move.backward": {
-      behaviorActionImplementations["move.backward"]({
-        context,
-        action
-      });
-      break;
-    }
-    case "move.block": {
-      behaviorActionImplementations["move.block"]({
-        context,
-        action
-      });
-      break;
-    }
-    case "move.forward": {
-      behaviorActionImplementations["move.forward"]({
-        context,
-        action
-      });
-      break;
-    }
-    default: {
-      behaviorActionImplementations.select({
-        context,
-        action
-      });
-      break;
+  try {
+    switch (operation.type) {
+      case "annotation.add": {
+        behaviorOperationImplementations["annotation.add"]({
+          context,
+          operation
+        });
+        break;
+      }
+      case "annotation.remove": {
+        behaviorOperationImplementations["annotation.remove"]({
+          context,
+          operation
+        });
+        break;
+      }
+      case "block.set": {
+        behaviorOperationImplementations["block.set"]({
+          context,
+          operation
+        });
+        break;
+      }
+      case "block.unset": {
+        behaviorOperationImplementations["block.unset"]({
+          context,
+          operation
+        });
+        break;
+      }
+      case "decorator.add": {
+        behaviorOperationImplementations["decorator.add"]({
+          context,
+          operation
+        });
+        break;
+      }
+      case "decorator.remove": {
+        behaviorOperationImplementations["decorator.remove"]({
+          context,
+          operation
+        });
+        break;
+      }
+      case "delete": {
+        behaviorOperationImplementations.delete({
+          context,
+          operation
+        });
+        break;
+      }
+      case "delete.backward": {
+        behaviorOperationImplementations["delete.backward"]({
+          context,
+          operation
+        });
+        break;
+      }
+      case "delete.block": {
+        behaviorOperationImplementations["delete.block"]({
+          context,
+          operation
+        });
+        break;
+      }
+      case "delete.forward": {
+        behaviorOperationImplementations["delete.forward"]({
+          context,
+          operation
+        });
+        break;
+      }
+      case "history.redo": {
+        behaviorOperationImplementations["history.redo"]({
+          context,
+          operation
+        });
+        break;
+      }
+      case "history.undo": {
+        behaviorOperationImplementations["history.undo"]({
+          context,
+          operation
+        });
+        break;
+      }
+      case "insert.block": {
+        behaviorOperationImplementations["insert.block"]({
+          context,
+          operation
+        });
+        break;
+      }
+      case "insert.inline object": {
+        behaviorOperationImplementations["insert.inline object"]({
+          context,
+          operation
+        });
+        break;
+      }
+      case "insert.span": {
+        behaviorOperationImplementations["insert.span"]({
+          context,
+          operation
+        });
+        break;
+      }
+      case "insert.text": {
+        behaviorOperationImplementations["insert.text"]({
+          context,
+          operation
+        });
+        break;
+      }
+      case "move.backward": {
+        behaviorOperationImplementations["move.backward"]({
+          context,
+          operation
+        });
+        break;
+      }
+      case "move.block": {
+        behaviorOperationImplementations["move.block"]({
+          context,
+          operation
+        });
+        break;
+      }
+      case "move.forward": {
+        behaviorOperationImplementations["move.forward"]({
+          context,
+          operation
+        });
+        break;
+      }
+      default: {
+        behaviorOperationImplementations.select({
+          context,
+          operation
+        });
+        break;
+      }
     }
+  } catch (error) {
+    console.error(new Error(`Executing "${operation.type}" failed due to: ${error.message}`));
   }
 }
+const CURRENT_OPERATION_ID = /* @__PURE__ */ new WeakMap();
+function withApplyingBehaviorOperations(editor, fn) {
+  CURRENT_OPERATION_ID.set(editor, defaultKeyGenerator()), slate.Editor.withoutNormalizing(editor, fn), CURRENT_OPERATION_ID.set(editor, void 0);
+}
+function getCurrentOperationId(editor) {
+  return CURRENT_OPERATION_ID.get(editor);
+}
+function isApplyingBehaviorOperations(editor) {
+  return getCurrentOperationId(editor) !== void 0;
+}
 function createWithEventListeners(editorActor) {
   return function(editor) {
     if (editorActor.getSnapshot().context.maxBlocks !== void 0)
       return editor;
     const {
-      deleteBackward,
-      deleteForward,
-      insertBreak,
       insertText,
       select
     } = editor;
     return editor.deleteBackward = (unit) => {
-      if (isApplyingBehaviorActions(editor)) {
-        deleteBackward(unit);
+      if (isApplyingBehaviorOperations(editor)) {
+        console.error("Unexpected call to .deleteBackward(...)");
         return;
       }
       editorActor.send({
@@ -4248,8 +4236,8 @@ function createWithEventListeners(editorActor) {
         editor
       });
     }, editor.deleteForward = (unit) => {
-      if (isApplyingBehaviorActions(editor)) {
-        deleteForward(unit);
+      if (isApplyingBehaviorOperations(editor)) {
+        console.error("Unexpected call to .deleteForward(...)");
         return;
       }
       editorActor.send({
@@ -4261,8 +4249,8 @@ function createWithEventListeners(editorActor) {
         editor
       });
     }, editor.insertBreak = () => {
-      if (isApplyingBehaviorActions(editor)) {
-        insertBreak();
+      if (isApplyingBehaviorOperations(editor)) {
+        console.error("Unexpected call to .insertBreak(...)");
         return;
       }
       editorActor.send({
@@ -4273,8 +4261,10 @@ function createWithEventListeners(editorActor) {
         editor
       });
     }, editor.insertData = (dataTransfer) => {
-      if (isApplyingBehaviorActions(editor))
-        throw new Error("Unexpected call to .insertData(...)");
+      if (isApplyingBehaviorOperations(editor)) {
+        console.error("Unexpected call to .insertData(...)");
+        return;
+      }
       editorActor.send({
         type: "behavior event",
         behaviorEvent: {
@@ -4286,13 +4276,13 @@ function createWithEventListeners(editorActor) {
         editor
       });
     }, editor.insertSoftBreak = () => {
-      if (isApplyingBehaviorActions(editor)) {
-        insertTextActionImplementation({
+      if (isApplyingBehaviorOperations(editor)) {
+        insertTextOperationImplementation({
           context: {
             keyGenerator: editorActor.getSnapshot().context.keyGenerator,
             schema: editorActor.getSnapshot().context.schema
           },
-          action: {
+          operation: {
             text: `
 `,
             editor
@@ -4308,7 +4298,7 @@ function createWithEventListeners(editorActor) {
         editor
       });
     }, editor.insertText = (text, options) => {
-      if (isApplyingBehaviorActions(editor)) {
+      if (isApplyingBehaviorOperations(editor)) {
         insertText(text, options);
         return;
       }
@@ -4321,13 +4311,13 @@ function createWithEventListeners(editorActor) {
         editor
       });
     }, editor.redo = () => {
-      if (isApplyingBehaviorActions(editor)) {
-        performAction({
+      if (isApplyingBehaviorOperations(editor)) {
+        performOperation({
           context: {
             keyGenerator: editorActor.getSnapshot().context.keyGenerator,
             schema: editorActor.getSnapshot().context.schema
           },
-          action: {
+          operation: {
             type: "history.redo",
             editor
           }
@@ -4342,7 +4332,7 @@ function createWithEventListeners(editorActor) {
         editor
       });
     }, editor.select = (location) => {
-      if (isApplyingBehaviorActions(editor)) {
+      if (isApplyingBehaviorOperations(editor)) {
         select(location);
         return;
       }
@@ -4360,15 +4350,15 @@ function createWithEventListeners(editorActor) {
         editor
       });
     }, editor.setFragmentData = () => {
-      console.warn("Unexpected call to .setFragmentData(...)");
+      console.error("Unexpected call to .setFragmentData(...)");
     }, editor.undo = () => {
-      if (isApplyingBehaviorActions(editor)) {
-        performAction({
+      if (isApplyingBehaviorOperations(editor)) {
+        performOperation({
           context: {
             keyGenerator: editorActor.getSnapshot().context.keyGenerator,
             schema: editorActor.getSnapshot().context.schema
           },
-          action: {
+          operation: {
             type: "history.undo",
             editor
           }
@@ -4772,9 +4762,14 @@ function createWithPatches({
         slate.Editor.withoutNormalizing(editor, () => {
           withoutPatching(editor, () => {
             withoutSaving(editor, () => {
-              patches2.forEach((patch) => {
-                debug$8.enabled && debug$8(`Handling remote patch ${JSON.stringify(patch)}`), changed = applyPatch(editor, patch);
-              });
+              for (const patch of patches2) {
+                debug$8.enabled && debug$8(`Handling remote patch ${JSON.stringify(patch)}`);
+                try {
+                  changed = applyPatch(editor, patch);
+                } catch (error) {
+                  console.error(`Applying patch ${JSON.stringify(patch)} failed due to: ${error.message}`);
+                }
+              }
             });
           });
         }), changed && (editor.normalize(), editor.onChange());
@@ -4836,7 +4831,7 @@ function createWithPatches({
               ...patch,
               origin: "local"
             },
-            actionId: getCurrentActionId(editor),
+            operationId: getCurrentOperationId(editor),
             value: fromSlateValue(editor.children, editorActor.getSnapshot().context.schema.block.name, KEY_TO_VALUE_ELEMENT.get(editor))
           });
       return editor;
@@ -5578,12 +5573,12 @@ function createEditableAPI(editor, editorActor) {
     addAnnotation: (type, value) => {
       let paths;
       return slate.Editor.withoutNormalizing(editor, () => {
-        paths = addAnnotationActionImplementation({
+        paths = addAnnotationOperationImplementation({
           context: {
             keyGenerator: editorActor.getSnapshot().context.keyGenerator,
             schema: types2
           },
-          action: {
+          operation: {
             annotation: {
               name: type.name,
               value: value ?? {}
@@ -6667,7 +6662,24 @@ const arrowDownOnLonelyBlockObject = behaviors_index.defineBehavior({
     text: `
 `
   })]]
-})], abstractListItemBehaviors = [behaviors_index.defineBehavior({
+})], keyIs = {
+  lineBreak: (event) => event.key === "Enter" && event.shiftKey
+}, abstractKeyboardBehaviors = [
+  /**
+   * On WebKit, Shift+Enter results in an `insertParagraph` input event rather
+   * than an `insertLineBreak` input event. This Behavior makes sure we catch
+   * that `keyboard.keydown` event beforehand and raise an `insert.soft break` manually.
+   */
+  behaviors_index.defineBehavior({
+    on: "keyboard.keydown",
+    guard: ({
+      event
+    }) => keyIs.lineBreak(event.originEvent),
+    actions: [() => [behaviors_index.raise({
+      type: "insert.soft break"
+    })]]
+  })
+], abstractListItemBehaviors = [behaviors_index.defineBehavior({
   on: "list item.add",
   guard: ({
     snapshot
@@ -6993,17 +7005,7 @@ const arrowDownOnLonelyBlockObject = behaviors_index.defineBehavior({
     type: "style.add",
     style: event.style
   })]]
-})], keyIs = {
-  lineBreak: (event) => event.key === "Enter" && event.shiftKey
-}, raiseInsertSoftBreak = behaviors_index.defineBehavior({
-  on: "keyboard.keydown",
-  guard: ({
-    event
-  }) => keyIs.lineBreak(event.originEvent),
-  actions: [() => [behaviors_index.raise({
-    type: "insert.soft break"
-  })]]
-}), raiseDeserializationSuccessOrFailure = behaviors_index.defineBehavior({
+})], raiseDeserializationSuccessOrFailure = behaviors_index.defineBehavior({
   on: "deserialize",
   guard: ({
     snapshot,
@@ -7063,7 +7065,7 @@ const arrowDownOnLonelyBlockObject = behaviors_index.defineBehavior({
     ...serializeEvent,
     originEvent: event.originEvent
   }))]
-}), defaultBehaviors = [
+}), abstractBehaviors = [
   behaviors_index.defineBehavior({
     on: "clipboard.copy",
     guard: ({
@@ -7338,14 +7340,14 @@ const arrowDownOnLonelyBlockObject = behaviors_index.defineBehavior({
   ...abstractDecoratorBehaviors,
   ...abstractDeleteBehaviors,
   ...abstractInsertBehaviors,
+  ...abstractKeyboardBehaviors,
   ...abstractListItemBehaviors,
   ...abstractMoveBehaviors,
   ...abstractStyleBehaviors,
   ...abstractSelectBehaviors,
   ...abstractSplitBehaviors,
   raiseDeserializationSuccessOrFailure,
-  raiseSerializationSuccessOrFailure,
-  raiseInsertSoftBreak
+  raiseSerializationSuccessOrFailure
 ];
 function isSyntheticBehaviorEvent(event) {
   return !isCustomBehaviorEvent(event) && !isNativeBehaviorEvent(event) && !isAbstractBehaviorEvent(event);
@@ -7377,28 +7379,24 @@ function performEvent({
   nativeEvent
 }) {
   debug$2(`(${mode}:${eventCategory(event)})`, JSON.stringify(event, null, 2));
-  const eventBehaviors = [...remainingEventBehaviors, ...defaultBehaviors].filter((behavior) => {
+  const eventBehaviors = [...remainingEventBehaviors, ...abstractBehaviors].filter((behavior) => {
     if (behavior.on === "*")
       return !0;
     const [listenedNamespace] = behavior.on.includes("*") && behavior.on.includes(".") ? behavior.on.split(".") : [void 0], [eventNamespace] = event.type.includes(".") ? event.type.split(".") : [void 0];
     return listenedNamespace !== void 0 && eventNamespace !== void 0 && listenedNamespace === eventNamespace || listenedNamespace !== void 0 && eventNamespace === void 0 && listenedNamespace === event.type ? !0 : behavior.on === event.type;
   });
   if (eventBehaviors.length === 0 && isSyntheticBehaviorEvent(event)) {
-    nativeEvent?.preventDefault(), withApplyingBehaviorActions(editor, () => {
-      try {
-        debug$2(`(execute:${eventCategory(event)})`, JSON.stringify(event, null, 2)), performAction({
-          context: {
-            keyGenerator,
-            schema: schema2
-          },
-          action: {
-            ...event,
-            editor
-          }
-        });
-      } catch (error) {
-        console.error(new Error(`Executing "${event.type}" failed due to: ${error.message}`));
-      }
+    nativeEvent?.preventDefault(), withApplyingBehaviorOperations(editor, () => {
+      debug$2(`(execute:${eventCategory(event)})`, JSON.stringify(event, null, 2)), performOperation({
+        context: {
+          keyGenerator,
+          schema: schema2
+        },
+        operation: {
+          ...event,
+          editor
+        }
+      });
     }), editor.onChange();
     return;
   }
@@ -7418,25 +7416,27 @@ function performEvent({
     if (shouldRun) {
       defaultBehaviorOverwritten = !0;
       for (const actionSet of eventBehavior.actions) {
-        const actionsSnapshot = getSnapshot(), actions = actionSet({
-          snapshot: actionsSnapshot,
-          event
-        }, shouldRun);
+        const actionsSnapshot = getSnapshot();
+        let actions = [];
+        try {
+          actions = actionSet({
+            snapshot: actionsSnapshot,
+            event
+          }, shouldRun);
+        } catch (error) {
+          console.error(new Error(`Evaluating actions for "${event.type}" failed due to: ${error.message}`));
+        }
         if (actions.length !== 0) {
           if (actions.some((action) => action.type === "execute")) {
             withUndoStep(editor, () => {
               for (const action of actions) {
                 if (action.type === "effect") {
-                  nativeEventPrevented = !0, performAction({
-                    context: {
-                      keyGenerator,
-                      schema: schema2
-                    },
-                    action: {
-                      ...action,
-                      editor
-                    }
-                  });
+                  nativeEventPrevented = !0;
+                  try {
+                    action.effect();
+                  } catch (error) {
+                    console.error(new Error(`Executing effect as a result of "${event.type}" failed due to: ${error.message}`));
+                  }
                   continue;
                 }
                 if (action.type === "forward") {
@@ -7485,16 +7485,12 @@ function performEvent({
           }
           for (const action of actions) {
             if (action.type === "effect") {
-              nativeEventPrevented = !0, performAction({
-                context: {
-                  keyGenerator,
-                  schema: schema2
-                },
-                action: {
-                  ...action,
-                  editor
-                }
-              });
+              nativeEventPrevented = !0;
+              try {
+                action.effect();
+              } catch (error) {
+                console.error(new Error(`Executing effect as a result of "${event.type}" failed due to: ${error.message}`));
+              }
               continue;
             }
             if (action.type === "forward") {
@@ -7533,21 +7529,17 @@ function performEvent({
       break;
     }
   }
-  !defaultBehaviorOverwritten && isSyntheticBehaviorEvent(event) ? (nativeEvent?.preventDefault(), withApplyingBehaviorActions(editor, () => {
-    try {
-      debug$2(`(execute:${eventCategory(event)})`, JSON.stringify(event, null, 2)), performAction({
-        context: {
-          keyGenerator,
-          schema: schema2
-        },
-        action: {
-          ...event,
-          editor
-        }
-      });
-    } catch (error) {
-      console.error(new Error(`Executing "${event.type}" failed due to: ${error.message}`));
-    }
+  !defaultBehaviorOverwritten && isSyntheticBehaviorEvent(event) ? (nativeEvent?.preventDefault(), withApplyingBehaviorOperations(editor, () => {
+    debug$2(`(execute:${eventCategory(event)})`, JSON.stringify(event, null, 2)), performOperation({
+      context: {
+        keyGenerator,
+        schema: schema2
+      },
+      operation: {
+        ...event,
+        editor
+      }
+    });
   }), editor.onChange()) : nativeEventPrevented && nativeEvent?.preventDefault();
 }
 function createEditorSnapshot({
@@ -7694,27 +7686,32 @@ const editorMachine = xstate.setup({
       event,
       self: self2
     }) => {
-      xstate.assertEvent(event, ["behavior event"]), performEvent({
-        mode: "raise",
-        behaviors: [...context.behaviors.values()],
-        remainingEventBehaviors: [...context.behaviors.values()],
-        event: event.behaviorEvent,
-        editor: event.editor,
-        keyGenerator: context.keyGenerator,
-        schema: context.schema,
-        getSnapshot: () => createEditorSnapshot({
-          converters: [...context.converters],
+      xstate.assertEvent(event, ["behavior event"]);
+      try {
+        performEvent({
+          mode: "raise",
+          behaviors: [...context.behaviors.values(), ...coreBehaviors],
+          remainingEventBehaviors: [...context.behaviors.values(), ...coreBehaviors],
+          event: event.behaviorEvent,
           editor: event.editor,
           keyGenerator: context.keyGenerator,
-          readOnly: self2.getSnapshot().matches({
-            "edit mode": "read only"
-          }),
           schema: context.schema,
-          hasTag: (tag) => self2.getSnapshot().hasTag(tag),
-          internalDrag: context.internalDrag
-        }),
-        nativeEvent: event.nativeEvent
-      });
+          getSnapshot: () => createEditorSnapshot({
+            converters: [...context.converters],
+            editor: event.editor,
+            keyGenerator: context.keyGenerator,
+            readOnly: self2.getSnapshot().matches({
+              "edit mode": "read only"
+            }),
+            schema: context.schema,
+            hasTag: (tag) => self2.getSnapshot().hasTag(tag),
+            internalDrag: context.internalDrag
+          }),
+          nativeEvent: event.nativeEvent
+        });
+      } catch (error) {
+        console.error(new Error(`Raising "${event.behaviorEvent.type}" failed due to: ${error.message}`));
+      }
     }
   },
   guards: {
@@ -7727,7 +7724,7 @@ const editorMachine = xstate.setup({
   context: ({
     input
   }) => ({
-    behaviors: /* @__PURE__ */ new Set([...coreBehaviors]),
+    behaviors: /* @__PURE__ */ new Set([]),
     converters: new Set(input.converters ?? []),
     getLegacySchema: input.getLegacySchema,
     keyGenerator: input.keyGenerator,
@@ -8645,7 +8642,6 @@ exports.EditorActorContext = EditorActorContext;
 exports.EditorProvider = EditorProvider;
 exports.KEY_TO_VALUE_ELEMENT = KEY_TO_VALUE_ELEMENT;
 exports.PortableTextEditor = PortableTextEditor;
-exports.coreBehaviors = coreBehaviors;
 exports.debugWithName = debugWithName;
 exports.defaultKeyGenerator = defaultKeyGenerator;
 exports.defineSchema = defineSchema;