lexical 0.45.0 → 0.45.1-dev.0

package/dist/LexicalNode.d.ts

@@ -179,6 +179,14 @@ export interface LexicalPrivateDOM {
     __lexicalLastChildKind?: 'line-break' | 'decorator' | 'empty' | null | undefined;
     __lexicalDir?: 'ltr' | 'rtl' | null | undefined;
     __lexicalUnmanaged?: boolean | undefined;
+    /**
+     * When true, the DOM subtree owns its own window selection — analogous to
+     * a DecoratorNode subtree. Resolution logic that would otherwise force the
+     * Lexical selection back onto a managed position treats the caret as
+     * intentional and leaves it alone. Set via the `captureSelection` option
+     * on {@link setDOMUnmanaged}.
+     */
+    __lexicalCapturedSelection?: boolean | undefined;
 }
 export declare function $removeNode(nodeToRemove: LexicalNode, restoreSelection: boolean, preserveEmptyParent?: boolean): void;
 export type DOMConversionProp<T extends HTMLElement> = (node: T) => DOMConversion<T> | null;

package/dist/LexicalUpdates.d.ts

@@ -13,6 +13,8 @@ export declare function isCurrentlyReadOnlyMode(): boolean;
 export declare function errorOnReadOnly(): void;
 export declare function errorOnInfiniteTransforms(): void;
 export declare function getActiveEditorState(): EditorState;
+/** @internal */
+export declare function $assumeActiveEditor(editor: LexicalEditor): void;
 export declare function getActiveEditor(): LexicalEditor;
 /**
  * Schedule a full reconcile of the active editor, so that every node is

package/dist/LexicalUtils.d.ts

@@ -30,7 +30,6 @@ export declare function getRegisteredNode(editor: LexicalEditor, nodeType: strin
 export declare const isArray: (arg: any) => arg is any[];
 /** @internal */
 export declare const scheduleMicroTask: (fn: () => void) => void;
-export declare function $isSelectionCapturedInDecorator(node: Node): boolean;
 export declare function isSelectionCapturedInDecoratorInput(anchorDOM: Node): boolean;
 export declare function isSelectionWithinEditor(editor: LexicalEditor, anchorDOM: null | Node, focusDOM: null | Node): boolean;
 /**
@@ -84,6 +83,7 @@ export declare function $getCompositionKey(): null | NodeKey;
 export declare function $getNodeByKey<T extends LexicalNode>(key: NodeKey, _editorState?: EditorState): T | null;
 export declare function $getNodeFromDOMNode(dom: Node, editorState?: EditorState): LexicalNode | null;
 export declare function setNodeKeyOnDOMNode(dom: Node, editor: LexicalEditor, key: NodeKey): void;
+export declare function clearNodeKeyOnDOMNode(dom: Node, editor: LexicalEditor): void;
 export declare function getNodeKeyFromDOMNode(dom: Node, editor: LexicalEditor): NodeKey | undefined;
 export declare function $getNearestNodeFromDOMNode(startingDOM: Node, editorState?: EditorState): LexicalNode | null;
 export declare function cloneDecorators(editor: LexicalEditor): Record<NodeKey, unknown>;
@@ -408,15 +408,37 @@ export declare function $setDirectionFromDOM<T extends ElementNode>(node: T, dom
  * @returns The node, with its align format set when the source `style.textAlign` was valid.
  */
 export declare function $setFormatFromDOM<T extends ElementNode>(node: T, domNode: HTMLElement): T;
+/**
+ * Options accepted by {@link setDOMUnmanaged}.
+ *
+ * @experimental
+ */
+export interface SetDOMUnmanagedOptions {
+    /**
+     * When true, the marked subtree owns its own window selection — analogous
+     * to a DecoratorNode subtree. Selection resolution that would otherwise
+     * mark the selection dirty for a caret position inside unmanaged DOM
+     * leaves it alone, so the embedded interaction (custom input, focusable
+     * widget, etc.) can keep its native caret.
+     *
+     * Pass `false` to clear a previously-set marker; omit the field to leave
+     * `__lexicalCapturedSelection` untouched.
+     */
+    captureSelection?: boolean;
+}
 /**
  * Mark this DOM element as unmanaged by lexical's mutation observer (like
  * decorator nodes are). Extensions that inject non-lexical decoration
  * elements into a node's DOM should mark them so the mutation observer
  * doesn't evict them as "unknown DOM children" during cleanup.
  *
+ * Pass `{captureSelection: true}` to additionally treat the subtree's
+ * window selection as decorator-like, so resolution does not force-sync
+ * the caret out of unmanaged DOM (see {@link isDOMCapturingSelection}).
+ *
  * @experimental
  */
-export declare function setDOMUnmanaged(elementDom: HTMLElement & LexicalPrivateDOM): void;
+export declare function setDOMUnmanaged(elementDom: HTMLElement & LexicalPrivateDOM, options?: SetDOMUnmanagedOptions): void;
 /**
  * True if this DOM node was marked with {@link setDOMUnmanaged}.
  *
@@ -424,13 +446,27 @@ export declare function setDOMUnmanaged(elementDom: HTMLElement & LexicalPrivate
  */
 export declare function isDOMUnmanaged(elementDom: Node & LexicalPrivateDOM): boolean;
 /**
- * @internal
+ * True if the DOM node sits inside a subtree marked with
+ * `{captureSelection: true}` via {@link setDOMUnmanaged}. Walks ancestors
+ * so any descendant of a marked subtree (e.g. an `<input>` inside a marked
+ * `<div>`) reports as captured too.
+ *
+ * The walk aborts at the first DOM node that corresponds to a Lexical
+ * node in `editor` — that boundary is the implicit owner of the subtree's
+ * selection, so a captureSelection marker above it (in non-Lexical
+ * scaffolding around the editor) does not leak in.
+ *
+ * DecoratorNode DOM is marked with `setDOMUnmanaged({captureSelection:
+ * true})` by the reconciler, so decorator subtrees also report as
+ * captured here.
+ *
+ * @experimental
  */
-export declare function hasOwnStaticMethod(klass: Klass<LexicalNode>, k: keyof Klass<LexicalNode>): boolean;
+export declare function isDOMCapturingSelection(elementDom: Node & LexicalPrivateDOM, editor: LexicalEditor): boolean;
 /**
  * @internal
  */
-export declare function hasOwnExportDOM(klass: Klass<LexicalNode>): boolean;
+export declare function hasOwnStaticMethod(klass: Klass<LexicalNode>, k: keyof Klass<LexicalNode>): boolean;
 /** @internal */
 export declare function getStaticNodeConfig(klass: Klass<LexicalNode>): {
     ownNodeType: undefined | string;

package/dist/index.d.ts

@@ -24,14 +24,14 @@ export { $getState, $getStateChange, $getWritableNodeState, $setState, type AnyS
 export { $normalizeSelection as $normalizeSelection__EXPERIMENTAL } from './LexicalNormalization';
 export type { BaseSelection, ElementPointType as ElementPoint, NodeSelection, Point, PointType, RangeSelection, TextPointType as TextPoint, } from './LexicalSelection';
 export { $createNodeSelection, $createPoint, $createRangeSelection, $createRangeSelectionFromDom, $generateNodesFromRawText, $getCharacterOffsets, $getPreviousSelection, $getSelection, $getTextContent, $insertNodes, $isBlockElementNode, $isNodeSelection, $isRangeSelection, $updateDOMSelection, type RawTextVisitor, tokenizeRawText, } from './LexicalSelection';
-export { $fullReconcile, $parseSerializedNode, isCurrentlyReadOnlyMode, } from './LexicalUpdates';
-export { $addUpdateTag, $applyNodeReplacement, $cloneWithProperties, $cloneWithPropertiesEphemeral, $copyNode, $create, $createChildrenArray, $findMatchingParent, $getAdjacentNode, $getDOMSlot, $getDOMTextNode, $getEditor, $getEditorDOMRenderConfig, $getNearestNodeFromDOMNode, $getNearestRootOrShadowRoot, $getNodeByKey, $getNodeByKeyOrThrow, $getNodeFromDOMNode, $getRoot, $hasAncestor, $hasUpdateTag, $isElementDOMSlot, $isInlineElementOrDecoratorNode, $isLeafNode, $isRootOrShadowRoot, $isTokenOrSegmented, $isTokenOrTab, $nodesOfType, $onUpdate, $selectAll, $setCompositionKey, $setDirectionFromDOM, $setFormatFromDOM, $setSelection, $splitNode, getDOMOwnerDocument, getDOMSelection, getDOMSelectionFromTarget, getDOMTextNode, getEditorPropertyFromDOMNode, getNearestEditorFromDOMNode, getRegisteredNode, getRegisteredNodeOrThrow, getStaticNodeConfig, getTextDirection, INTERNAL_$isBlock, isBlockDomNode, isDocumentFragment, isDOMDocumentNode, isDOMNode, isDOMTextNode, isDOMUnmanaged, isExactShortcutMatch, isHTMLAnchorElement, isHTMLElement, isHTMLTableCellElement, isHTMLTableRowElement, isInlineDomNode, isLexicalEditor, isModifierMatch, isSelectionCapturedInDecoratorInput, isSelectionWithinEditor, removeFromParent, resetRandomKey, setDOMUnmanaged, setNodeIndentFromDOM, toggleTextFormatType, } from './LexicalUtils';
+export { $assumeActiveEditor, $fullReconcile, $parseSerializedNode, isCurrentlyReadOnlyMode, } from './LexicalUpdates';
+export { $addUpdateTag, $applyNodeReplacement, $cloneWithProperties, $cloneWithPropertiesEphemeral, $copyNode, $create, $createChildrenArray, $findMatchingParent, $getAdjacentNode, $getDOMSlot, $getDOMTextNode, $getEditor, $getEditorDOMRenderConfig, $getNearestNodeFromDOMNode, $getNearestRootOrShadowRoot, $getNodeByKey, $getNodeByKeyOrThrow, $getNodeFromDOMNode, $getRoot, $hasAncestor, $hasUpdateTag, $isElementDOMSlot, $isInlineElementOrDecoratorNode, $isLeafNode, $isRootOrShadowRoot, $isTokenOrSegmented, $isTokenOrTab, $nodesOfType, $onUpdate, $selectAll, $setCompositionKey, $setDirectionFromDOM, $setFormatFromDOM, $setSelection, $splitNode, getDOMOwnerDocument, getDOMSelection, getDOMSelectionFromTarget, getDOMTextNode, getEditorPropertyFromDOMNode, getNearestEditorFromDOMNode, getRegisteredNode, getRegisteredNodeOrThrow, getStaticNodeConfig, getTextDirection, INTERNAL_$isBlock, isBlockDomNode, isDocumentFragment, isDOMCapturingSelection, isDOMDocumentNode, isDOMNode, isDOMTextNode, isDOMUnmanaged, isExactShortcutMatch, isHTMLAnchorElement, isHTMLElement, isHTMLTableCellElement, isHTMLTableRowElement, isInlineDomNode, isLexicalEditor, isModifierMatch, isSelectionCapturedInDecoratorInput, isSelectionWithinEditor, removeFromParent, resetRandomKey, setDOMUnmanaged, type SetDOMUnmanagedOptions, setNodeIndentFromDOM, toggleTextFormatType, } from './LexicalUtils';
 export { ArtificialNode__DO_NOT_USE } from './nodes/ArtificialNode';
 export { $isDecoratorNode, DecoratorNode } from './nodes/LexicalDecoratorNode';
 export type { ElementFormatType, SerializedElementNode, } from './nodes/LexicalElementNode';
 export { $isElementNode, ElementNode } from './nodes/LexicalElementNode';
 export type { SerializedLineBreakNode } from './nodes/LexicalLineBreakNode';
-export { $createLineBreakNode, $isLineBreakNode, LineBreakNode, } from './nodes/LexicalLineBreakNode';
+export { $createLineBreakNode, $isLineBreakNode, isLastChildInBlockNode, isOnlyChildInBlockNode, LineBreakNode, } from './nodes/LexicalLineBreakNode';
 export type { SerializedParagraphNode } from './nodes/LexicalParagraphNode';
 export { $createParagraphNode, $isParagraphNode, ParagraphNode, } from './nodes/LexicalParagraphNode';
 export type { SerializedRootNode } from './nodes/LexicalRootNode';

package/dist/nodes/LexicalLineBreakNode.d.ts

@@ -25,3 +25,21 @@ export declare class LineBreakNode extends LexicalNode {
 }
 export declare function $createLineBreakNode(): LineBreakNode;
 export declare function $isLineBreakNode(node: LexicalNode | null | undefined): node is LineBreakNode;
+/**
+ * True when `node` is the sole non-whitespace child of a block DOM
+ * element. Used by the LineBreak importer to drop stray `<br>` elements
+ * that the legacy `$generateNodesFromDOM` also skipped (matches the
+ * behavior of `LineBreakNode.importDOM`).
+ *
+ * @experimental
+ */
+export declare function isOnlyChildInBlockNode(node: Node): boolean;
+/**
+ * True when `node` is the trailing non-whitespace child of a block DOM
+ * element (excluding the only-child case). Used by the LineBreak
+ * importer to drop trailing `<br>` elements like the Apple-interchange
+ * clipboard artifact (matches `LineBreakNode.importDOM`).
+ *
+ * @experimental
+ */
+export declare function isLastChildInBlockNode(node: Node): boolean;

package/package.json

@@ -9,7 +9,7 @@
     "rich-text"
   ],
   "license": "MIT",
-  "version": "0.45.0",
+  "version": "0.45.1-dev.0",
   "main": "./dist/Lexical.js",
   "types": "./dist/index.d.ts",
   "repository": {
@@ -51,6 +51,6 @@
     "LICENSE"
   ],
   "dependencies": {
-    "@lexical/internal": "0.45.0"
+    "@lexical/internal": "0.45.1-dev.0"
   }
 }

package/src/LexicalEditor.ts

@@ -54,6 +54,7 @@ import {
   $addUpdateTag,
   $onUpdate,
   $setSelection,
+  clearNodeKeyOnDOMNode,
   createUID,
   dispatchCommand,
   getCachedClassNameArray,
@@ -62,9 +63,9 @@ import {
   getDOMSelection,
   getRegisteredNode,
   getStaticNodeConfig,
-  hasOwnExportDOM,
   hasOwnStaticMethod,
   markNodesWithTypesAsDirty,
+  setNodeKeyOnDOMNode,
 } from './LexicalUtils';
 import {ArtificialNode__DO_NOT_USE} from './nodes/ArtificialNode';
 import {LineBreakNode} from './nodes/LexicalLineBreakNode';
@@ -664,11 +665,19 @@ export function resetEditor(
   // Remove all the DOM nodes from the root element
   if (prevRootElement !== null) {
     prevRootElement.textContent = '';
+    clearNodeKeyOnDOMNode(prevRootElement, editor);
   }
 
   if (nextRootElement !== null) {
     nextRootElement.textContent = '';
     keyNodeMap.set('root', nextRootElement);
+    // Stash __lexicalKey_${editor._key} = 'root' on the root element so it
+    // participates in the unified key lookup (selection resolution in
+    // $internalResolveSelectionPoint, mutation handling in
+    // $getNearestManagedNodePairFromDOMNode, $getNodeFromDOM, and
+    // $getNearestNodeFromDOMNode) instead of requiring a dedicated
+    // editor.getRootElement() carveout at each call site.
+    setNodeKeyOnDOMNode(nextRootElement, editor, 'root');
   }
 }
 
@@ -854,14 +863,6 @@ export function createEditor(editorConfig?: CreateEditorArgs): LexicalEditor {
               console.warn(`${name} must implement static "${method}" method`);
             }
           });
-          if (
-            !hasOwnStaticMethod(klass, 'importDOM') &&
-            hasOwnExportDOM(klass)
-          ) {
-            console.warn(
-              `${name} should implement "importDOM" if using a custom "exportDOM" method to ensure HTML serialization (important for copy & paste) works as expected`,
-            );
-          }
           if (!hasOwnStaticMethod(klass, 'importJSON')) {
             console.warn(
               `${name} should implement "importJSON" method to ensure JSON and default HTML serialization works as expected`,

package/src/LexicalEvents.ts

@@ -100,7 +100,6 @@ import {
   $getAdjacentNode,
   $getDOMTextNode,
   $getNodeByKey,
-  $isSelectionCapturedInDecorator,
   $isTokenOrSegmented,
   $isTokenOrTab,
   $setSelection,
@@ -127,6 +126,7 @@ import {
   isDeleteLineForward,
   isDeleteWordBackward,
   isDeleteWordForward,
+  isDOMCapturingSelection,
   isDOMNode,
   isDOMTextNode,
   isEscape,
@@ -560,7 +560,7 @@ function onPointerDown(event: PointerEvent, editor: LexicalEditor) {
     updateEditorSync(editor, () => {
       // Drag & drop should not recompute selection until mouse up; otherwise the initially
       // selected content is lost.
-      if (!$isSelectionCapturedInDecorator(target)) {
+      if (!isDOMCapturingSelection(target, editor)) {
         isSelectionChangeFromMouseDown = true;
       }
     });
@@ -1082,14 +1082,13 @@ function onInput(event: InputEvent, editor: LexicalEditor): void {
 }
 
 function $handleInput(event: InputEvent): boolean {
+  const editor = getActiveEditor();
   if (
     isHTMLElement(event.target) &&
-    $isSelectionCapturedInDecorator(event.target)
+    isDOMCapturingSelection(event.target, editor)
   ) {
     return true;
   }
-
-  const editor = getActiveEditor();
   const selection = $getSelection();
   const data = event.data;
   const targetRange = getTargetRange(event);

package/src/LexicalMutations.ts

@@ -29,7 +29,6 @@ import {
   getNodeKeyFromDOMNode,
   getParentElement,
   getWindow,
-  internalGetRoot,
   isDOMTextNode,
   isDOMUnmanaged,
   isFirefoxClipboardEvents,
@@ -118,7 +117,6 @@ function $getNearestManagedNodePairFromDOMNode(
   startingDOM: Node,
   editor: LexicalEditor,
   editorState: EditorState,
-  rootElement: HTMLElement | null,
 ): [HTMLElement, LexicalNode] | undefined {
   for (
     let dom: Node | null = startingDOM;
@@ -134,8 +132,6 @@ function $getNearestManagedNodePairFromDOMNode(
           ? undefined
           : [dom, node];
       }
-    } else if (dom === rootElement) {
-      return [rootElement, internalGetRoot(editorState)];
     }
   }
 }
@@ -152,7 +148,6 @@ function flushMutations(
     updateEditorSync(editor, () => {
       const selection = $getSelection() || getLastSelection(editor);
       const badDOMTargets = new Map<HTMLElement, LexicalNode>();
-      const rootElement = editor.getRootElement();
       // We use the current editor state, as that reflects what is
       // actually "on screen".
       const currentEditorState = editor._editorState;
@@ -168,7 +163,6 @@ function flushMutations(
           targetDOM,
           editor,
           currentEditorState,
-          rootElement,
         );
         if (!pair) {
           continue;

package/src/LexicalNode.ts

@@ -272,6 +272,14 @@ export interface LexicalPrivateDOM {
     | undefined;
   __lexicalDir?: 'ltr' | 'rtl' | null | undefined;
   __lexicalUnmanaged?: boolean | undefined;
+  /**
+   * When true, the DOM subtree owns its own window selection — analogous to
+   * a DecoratorNode subtree. Resolution logic that would otherwise force the
+   * Lexical selection back onto a managed position treats the caret as
+   * intentional and leaves it alone. Set via the `captureSelection` option
+   * on {@link setDOMUnmanaged}.
+   */
+  __lexicalCapturedSelection?: boolean | undefined;
 }
 
 export function $removeNode(

package/src/LexicalReconciler.ts

@@ -51,6 +51,7 @@ import {
   $isRootOrShadowRoot,
   cloneDecorators,
   getElementByKeyOrThrow,
+  setDOMUnmanaged,
   setMutatedNode,
   setNodeKeyOnDOMNode,
 } from './LexicalUtils';
@@ -458,6 +459,13 @@ function $createNode(key: NodeKey, slot: ElementDOMSlot | null): HTMLElement {
     dom.setAttribute('data-lexical-text', 'true');
   } else if ($isDecoratorNode(node)) {
     dom.setAttribute('data-lexical-decorator', 'true');
+    // DecoratorNode DOM is selection-captured: window selection inside
+    // a decorator subtree (e.g. an embedded input) is owned by the
+    // decorator, not by Lexical's caret management. Marking it via
+    // setDOMUnmanaged unifies the decorator case with extension-owned
+    // unmanaged subtrees so callers only need isDOMCapturingSelection /
+    // isDOMUnmanaged.
+    setDOMUnmanaged(dom, {captureSelection: true});
   }
 
   if ($isElementNode(node)) {

package/src/LexicalSelection.ts

@@ -80,7 +80,6 @@ import {
   $getRoot,
   $hasAncestor,
   $isRootOrShadowRoot,
-  $isSelectionCapturedInDecorator,
   $isTokenOrSegmented,
   $isTokenOrTab,
   $setCompositionKey,
@@ -90,6 +89,7 @@ import {
   getNodeKeyFromDOMNode,
   getWindow,
   INTERNAL_$isBlock,
+  isDOMCapturingSelection,
   isHTMLElement,
   isSelectionCapturedInDecoratorInput,
   isSelectionWithinEditor,
@@ -2322,8 +2322,7 @@ function $internalResolveSelectionPoint(
     }
     if (
       getNodeKeyFromDOMNode(dom, editor) === undefined &&
-      dom !== editor.getRootElement() &&
-      !$isSelectionCapturedInDecorator(dom)
+      !isDOMCapturingSelection(dom, editor)
     ) {
       // The DOM caret is sitting on a node that has no Lexical key
       // (e.g. <col> inside an unmanaged <colgroup>, or any unmanaged
@@ -2334,14 +2333,14 @@ function $internalResolveSelectionPoint(
       // selection dirty so the reconciler writes a valid DOM caret back
       // at the resolved Lexical position.
       //
-      // Exceptions where the DOM caret is intentionally somewhere
-      // Lexical doesn't own and we should NOT force-sync it:
-      //  - the editor root element (tracked separately in
-      //    _keyToDOMMap as 'root'; has no __lexicalKey_* attribute);
-      //  - anything inside a DecoratorNode subtree (the decorator owns
-      //    its own DOM and may manage its own selection — for inputs
-      //    isSelectionCapturedInDecoratorInput rejects earlier, but
-      //    non-input decorator content also shouldn't be force-synced).
+      // Exclusions split across the two guard clauses:
+      //  - The first clause (`key !== undefined`) covers any DOM node
+      //    with a `__lexicalKey_*` attribute — Lexical-managed elements
+      //    and the editor root (stashed in `resetEditor`).
+      //  - `isDOMCapturingSelection` covers DecoratorNode subtrees (which
+      //    own their own DOM) and subtrees marked via
+      //    `setDOMUnmanaged(dom, {captureSelection: true})` —
+      //    extension-owned widgets that keep a native caret.
       //
       // Void elements that ARE Lexical nodes (LineBreakNode <br>,
       // empty decorator containers, etc.) have keys, so this check

package/src/LexicalUpdates.ts

@@ -115,6 +115,18 @@ export function getActiveEditorState(): EditorState {
   return activeEditorState;
 }
 
+/** @internal */
+export function $assumeActiveEditor(editor: LexicalEditor): void {
+  // Throw if called outside of an update
+  if (getActiveEditorState() !== null && activeEditor === null) {
+    activeEditor = editor;
+  }
+  invariant(
+    activeEditor === editor,
+    'The given editor argument does not match $getEditor() in this context. Use editor.getEditorState().read(..., {editor}) if this cross-editor call is intentional.',
+  );
+}
+
 export function getActiveEditor(): LexicalEditor {
   if (activeEditor === null) {
     invariant(

package/src/LexicalUtils.ts

@@ -159,10 +159,6 @@ export const scheduleMicroTask: (fn: () => void) => void =
         Promise.resolve().then(fn);
       };
 
-export function $isSelectionCapturedInDecorator(node: Node): boolean {
-  return $isDecoratorNode($getNearestNodeFromDOMNode(node));
-}
-
 export function isSelectionCapturedInDecoratorInput(anchorDOM: Node): boolean {
   const activeElement = document.activeElement;
 
@@ -571,6 +567,11 @@ export function setNodeKeyOnDOMNode(
   (dom as Node & Record<typeof prop, NodeKey | undefined>)[prop] = key;
 }
 
+export function clearNodeKeyOnDOMNode(dom: Node, editor: LexicalEditor) {
+  const prop = `__lexicalKey_${editor._key}`;
+  delete (dom as Node & Record<typeof prop, NodeKey | undefined>)[prop];
+}
+
 export function getNodeKeyFromDOMNode(
   dom: Node,
   editor: LexicalEditor,
@@ -683,10 +684,6 @@ export function $getNodeFromDOM(dom: Node): null | LexicalNode {
   const editor = getActiveEditor();
   const nodeKey = getNodeKeyFromDOMTree(dom, editor);
   if (nodeKey === null) {
-    const rootElement = editor.getRootElement();
-    if (dom === rootElement) {
-      return $getNodeByKey('root');
-    }
     return null;
   }
   return $getNodeByKey(nodeKey);
@@ -2265,18 +2262,45 @@ export function $setFormatFromDOM<T extends ElementNode>(
     : node;
 }
 
+/**
+ * Options accepted by {@link setDOMUnmanaged}.
+ *
+ * @experimental
+ */
+export interface SetDOMUnmanagedOptions {
+  /**
+   * When true, the marked subtree owns its own window selection — analogous
+   * to a DecoratorNode subtree. Selection resolution that would otherwise
+   * mark the selection dirty for a caret position inside unmanaged DOM
+   * leaves it alone, so the embedded interaction (custom input, focusable
+   * widget, etc.) can keep its native caret.
+   *
+   * Pass `false` to clear a previously-set marker; omit the field to leave
+   * `__lexicalCapturedSelection` untouched.
+   */
+  captureSelection?: boolean;
+}
+
 /**
  * Mark this DOM element as unmanaged by lexical's mutation observer (like
  * decorator nodes are). Extensions that inject non-lexical decoration
  * elements into a node's DOM should mark them so the mutation observer
  * doesn't evict them as "unknown DOM children" during cleanup.
  *
+ * Pass `{captureSelection: true}` to additionally treat the subtree's
+ * window selection as decorator-like, so resolution does not force-sync
+ * the caret out of unmanaged DOM (see {@link isDOMCapturingSelection}).
+ *
  * @experimental
  */
 export function setDOMUnmanaged(
   elementDom: HTMLElement & LexicalPrivateDOM,
+  options?: SetDOMUnmanagedOptions,
 ): void {
   elementDom.__lexicalUnmanaged = true;
+  if (options && options.captureSelection !== undefined) {
+    elementDom.__lexicalCapturedSelection = options.captureSelection;
+  }
 }
 
 /**
@@ -2288,6 +2312,40 @@ export function isDOMUnmanaged(elementDom: Node & LexicalPrivateDOM): boolean {
   return elementDom.__lexicalUnmanaged === true;
 }
 
+/**
+ * True if the DOM node sits inside a subtree marked with
+ * `{captureSelection: true}` via {@link setDOMUnmanaged}. Walks ancestors
+ * so any descendant of a marked subtree (e.g. an `<input>` inside a marked
+ * `<div>`) reports as captured too.
+ *
+ * The walk aborts at the first DOM node that corresponds to a Lexical
+ * node in `editor` — that boundary is the implicit owner of the subtree's
+ * selection, so a captureSelection marker above it (in non-Lexical
+ * scaffolding around the editor) does not leak in.
+ *
+ * DecoratorNode DOM is marked with `setDOMUnmanaged({captureSelection:
+ * true})` by the reconciler, so decorator subtrees also report as
+ * captured here.
+ *
+ * @experimental
+ */
+export function isDOMCapturingSelection(
+  elementDom: Node & LexicalPrivateDOM,
+  editor: LexicalEditor,
+): boolean {
+  let dom: (Node & LexicalPrivateDOM) | null = elementDom;
+  while (dom != null) {
+    if (dom.__lexicalCapturedSelection === true) {
+      return true;
+    }
+    if (getNodeKeyFromDOMNode(dom, editor) !== undefined) {
+      return false;
+    }
+    dom = getParentElement(dom);
+  }
+  return false;
+}
+
 /**
  * @internal
  *
@@ -2307,13 +2365,6 @@ export function hasOwnStaticMethod(
   return hasOwn(klass, k) && klass[k] !== LexicalNode[k];
 }
 
-/**
- * @internal
- */
-export function hasOwnExportDOM(klass: Klass<LexicalNode>) {
-  return hasOwn(klass.prototype, 'exportDOM');
-}
-
 /** @internal */
 function isAbstractNodeClass(klass: Klass<LexicalNode>): boolean {
   if (!(klass === LexicalNode || klass.prototype instanceof LexicalNode)) {

package/src/index.ts

@@ -255,6 +255,7 @@ export {
   tokenizeRawText,
 } from './LexicalSelection';
 export {
+  $assumeActiveEditor,
   $fullReconcile,
   $parseSerializedNode,
   isCurrentlyReadOnlyMode,
@@ -308,6 +309,7 @@ export {
   INTERNAL_$isBlock,
   isBlockDomNode,
   isDocumentFragment,
+  isDOMCapturingSelection,
   isDOMDocumentNode,
   isDOMNode,
   isDOMTextNode,
@@ -325,6 +327,7 @@ export {
   removeFromParent,
   resetRandomKey,
   setDOMUnmanaged,
+  type SetDOMUnmanagedOptions,
   setNodeIndentFromDOM,
   toggleTextFormatType,
 } from './LexicalUtils';
@@ -339,6 +342,8 @@ export type {SerializedLineBreakNode} from './nodes/LexicalLineBreakNode';
 export {
   $createLineBreakNode,
   $isLineBreakNode,
+  isLastChildInBlockNode,
+  isOnlyChildInBlockNode,
   LineBreakNode,
 } from './nodes/LexicalLineBreakNode';
 export type {SerializedParagraphNode} from './nodes/LexicalParagraphNode';

package/src/nodes/LexicalLineBreakNode.ts

@@ -90,7 +90,15 @@ export function $isLineBreakNode(
   return node instanceof LineBreakNode;
 }
 
-function isOnlyChildInBlockNode(node: Node): boolean {
+/**
+ * True when `node` is the sole non-whitespace child of a block DOM
+ * element. Used by the LineBreak importer to drop stray `<br>` elements
+ * that the legacy `$generateNodesFromDOM` also skipped (matches the
+ * behavior of `LineBreakNode.importDOM`).
+ *
+ * @experimental
+ */
+export function isOnlyChildInBlockNode(node: Node): boolean {
   const parentElement = node.parentElement;
   if (parentElement !== null && isBlockDomNode(parentElement)) {
     const firstChild = parentElement.firstChild!;
@@ -111,7 +119,15 @@ function isOnlyChildInBlockNode(node: Node): boolean {
   return false;
 }
 
-function isLastChildInBlockNode(node: Node): boolean {
+/**
+ * True when `node` is the trailing non-whitespace child of a block DOM
+ * element (excluding the only-child case). Used by the LineBreak
+ * importer to drop trailing `<br>` elements like the Apple-interchange
+ * clipboard artifact (matches `LineBreakNode.importDOM`).
+ *
+ * @experimental
+ */
+export function isLastChildInBlockNode(node: Node): boolean {
   const parentElement = node.parentElement;
   if (parentElement !== null && isBlockDomNode(parentElement)) {
     // check if node is first child, because only child dont count

package/src/nodes/LexicalTextNode.ts

@@ -53,6 +53,7 @@ import {
 import {LexicalNode} from '../LexicalNode';
 import {$cloneNodeState} from '../LexicalNodeState';
 import {
+  $generateNodesFromRawText,
   $getSelection,
   $internalMakeRangeSelection,
   $isRangeSelection,
@@ -74,8 +75,6 @@ import {
   toggleTextFormatType,
 } from '../LexicalUtils';
 import {setDOMStyleFromCSS} from '../utils/setDOMStyle';
-import {$createLineBreakNode} from './LexicalLineBreakNode';
-import {$createTabNode} from './LexicalTabNode';
 
 export type SerializedTextNode = Spread<
   {
@@ -1262,20 +1261,7 @@ function $convertTextDOMNode(domNode: Node): DOMConversionOutput {
   let textContent = domNode_.textContent || '';
   // No collapse and preserve segment break for pre, pre-wrap and pre-line
   if (findParentPreDOMNode(domNode_) !== null) {
-    const parts = textContent.split(/(\r?\n|\t)/);
-    const nodes: Array<LexicalNode> = [];
-    const length = parts.length;
-    for (let i = 0; i < length; i++) {
-      const part = parts[i];
-      if (part === '\n' || part === '\r\n') {
-        nodes.push($createLineBreakNode());
-      } else if (part === '\t') {
-        nodes.push($createTabNode());
-      } else if (part !== '') {
-        nodes.push($createTextNode(part));
-      }
-    }
-    return {node: nodes};
+    return {node: $generateNodesFromRawText(textContent)};
   }
   textContent = textContent.replace(/\r/g, '').replace(/[ \t\n]+/g, ' ');
   if (textContent === '') {