@@ -15,7 +15,7 @@ import {
 import { nonFormattingMarks } from "../markGroups.js";
 import { PropSchema } from "../propTypes.js";
 import {
-  getBlockFromPos,
+  getBlockFromNodeView,
   propsToAttributes,
   wrapInBlockStructure,
 } from "./internal.js";
@@ -247,8 +247,15 @@ export function addNodeAndExtensionsToSpec<
         return (props) => {
           // Gets the BlockNote editor instance
           const editor = this.options.editor;
-          // Gets the block
-          const block = getBlockFromPos(props.getPos, props.view.state.doc);
+          // Gets the block. Resolving this can't rely on `getPos()` alone —
+          // node views are constructed part-way through ProseMirror's
+          // reconciliation, where positions don't always line up with
+          // `view.state.doc` yet (see `getBlockFromNodeView`).
+          const block = getBlockFromNodeView(
+            props.getPos,
+            props.node,
+            props.view.state.doc,
+          );
           // Gets the custom HTML attributes for `blockContent` nodes
           const blockContentDOMAttributes =
             this.options.domAttributes?.blockContent || {};
 
@@ -0,0 +1,77 @@
+import { beforeEach, describe, expect, it } from "vite-plus/test";
+
+import { getNodeById } from "../../api/nodeUtil.js";
+import { BlockNoteEditor } from "../../editor/BlockNoteEditor.js";
+import { getBlockFromNodeView } from "./internal.js";
+
+describe("getBlockFromNodeView", () => {
+  let editor: BlockNoteEditor;
+
+  beforeEach(() => {
+    editor = BlockNoteEditor.create({
+      trailingBlock: false,
+      initialContent: [
+        { type: "paragraph", content: "first" },
+        { type: "paragraph", content: "second" },
+      ],
+    });
+  });
+
+  it("resolves from the position when it is valid", () => {
+    const doc = editor.prosemirrorState.doc;
+    const target = editor.document[1];
+    // `getBlockFromPos` resolves the *parent* of the position, so the position
+    // sits just inside the block container — which is what ProseMirror hands a
+    // node view.
+    const pos = getNodeById(target.id, doc)!.posBeforeNode + 1;
+    const block = getBlockFromNodeView(() => pos, doc.nodeAt(pos)!, doc) as any;
+
+    expect(block.id).toBe(target.id);
+  });
+
+  it("builds a standalone block when the node is no longer in the document", () => {
+    // The only way `getPos()` fails at node view construction is a re-entrant
+    // dispatch superseding `view.state.doc`, which takes the node with it — so
+    // the node genuinely isn't in the document any more. See #2937.
+    const doc = editor.prosemirrorState.doc;
+    const orphan = editor.pmSchema.nodes.paragraph.create(
+      { textAlignment: "right" },
+      editor.pmSchema.text("orphaned content"),
+    );
+    const block = getBlockFromNodeView(
+      () => doc.content.size + 1000,
+      orphan,
+      doc,
+    ) as any;
+
+    // Everything readable off the node is correct...
+    expect(block.type).toBe("paragraph");
+    expect(block.props.textAlignment).toBe("right");
+    expect(block.content[0].text).toBe("orphaned content");
+    // ...but the id belongs to no block in the document, so it must not
+    // collide with a real one.
+    expect(editor.document.map((b) => b.id)).not.toContain(block.id);
+  });
+
+  it("recovers from an in-range position that resolves to the wrong node", () => {
+    // Position 0 resolves to the doc rather than a block container — the shape
+    // a bounds check alone would not catch.
+    const doc = editor.prosemirrorState.doc;
+    const orphan = editor.pmSchema.nodes.paragraph.create(
+      null,
+      editor.pmSchema.text("orphaned content"),
+    );
+    expect(() => getBlockFromNodeView(() => 0, orphan, doc)).not.toThrow();
+  });
+
+  it("recovers when the position is undefined", () => {
+    const doc = editor.prosemirrorState.doc;
+    const orphan = editor.pmSchema.nodes.paragraph.create(
+      null,
+      editor.pmSchema.text("orphaned content"),
+    );
+    expect(() =>
+      getBlockFromNodeView(() => undefined, orphan, doc),
+    ).not.toThrow();
+  });
+});
@@ -93,6 +93,74 @@ export function getBlockFromPos(getPos: () => number | undefined, doc: PMNode) {
   return block;
 }
 
+/**
+ * Resolves the block a node view should render, tolerating a `getPos()` that
+ * can't be trusted.
+ *
+ * ProseMirror derives `getPos()` from its view-desc tree, but
+ * `EditorView.updateStateInner` assigns the new state *before* it reconciles
+ * that tree. Anything that runs partway through reconciliation - a re-entrant
+ * dispatch from a node view's effect, TipTap's `flushSync` while mounting a
+ * node view - therefore sees positions that no longer line up with
+ * `view.state.doc`. The position then either lands out of range or, just as
+ * bad, in range but pointing at the wrong node.
+ *
+ * Node views are constructed inside that same window, so this applies at
+ * construction just as much as on re-render. The state is always transient:
+ * ProseMirror finishes reconciling and rebuilds the node view against the
+ * current document immediately after. So we degrade instead of throwing,
+ * because a stale frame is invisible where a throw is not.
+ *
+ * See issues #2937, #2682 and #2621.
+ */
+export function getBlockFromNodeView(
+  getPos: () => number | undefined,
+  node: PMNode,
+  doc: PMNode,
+) {
+  let positionError: unknown;
+
+  try {
+    return getBlockFromPos(getPos, doc);
+  } catch (e) {
+    // Kept only to rethrow below if there turns out to be nothing to render.
+    // Otherwise deliberately silent: this is expected and self-correcting, and
+    // there is nothing a consumer could do about it in the meantime.
+    positionError = e;
+  }
+
+  // Whenever this is reached, the node is not in `doc` — a re-entrant dispatch
+  // superseded the document ProseMirror is building node views for, and the
+  // node went with it. So there is no container to read an id from, and the
+  // block has to be built from the node alone.
+  //
+  // `type`, `props` and `content` are read off the node and are correct.
+  // `children` is empty and `id` is freshly generated, i.e. it belongs to no
+  // block in the document — callers must not treat it as addressable. (It can't
+  // collide with a real block: ids are uuids, and the deterministic test-mode
+  // generator shares one monotonic counter with real ids.) This is short-lived;
+  // ProseMirror rebuilds the node view against the real document right after.
+  //
+  // The alternatives are worse. Throwing is the crash this exists to prevent.
+  // Returning an empty placeholder node view can leave the block *permanently*
+  // blank, since vanilla node views don't implement `update()` and so are only
+  // rebuilt when something else changes the document.
+  //
+  // `createAndFill` rather than `create` so an unexpected node shape yields
+  // `null` instead of throwing over the top of the original failure.
+  const standalone = doc.type.schema.nodes["blockContainer"]?.createAndFill(
+    null,
+    node,
+  );
+  if (standalone) {
+    return nodeToBlock(standalone, doc);
+  }
+
+  // Nothing left to render from. Surface the original failure rather than
+  // inventing a block that isn't grounded in anything.
+  throw positionError;
+}
+
 // Function that wraps the `dom` element returned from 'blockConfig.render' in a
 // `blockContent` div, which contains the block type and props as HTML
 // attributes. If `blockConfig.render` also returns a `contentDOM`, it also adds
 
@@ -139,6 +139,7 @@ export * from "./hooks/useEditorState.js";
 export * from "./schema/ReactBlockSpec.js";
 export * from "./schema/ReactInlineContentSpec.js";
 export * from "./schema/ReactStyleSpec.js";
+export * from "./schema/useNodeViewBlock.js";
 
 export * from "./icons.js";
 
 
@@ -10,7 +10,6 @@ import {
   Extension,
   ExtensionFactoryInstance,
   ExtractBlockConfigFromConfigOrCreator,
-  getBlockFromPos,
   mergeCSSClasses,
   Props,
   PropSchema,
@@ -23,6 +22,7 @@ import {
 } from "@tiptap/react";
 import { FC, ReactNode } from "react";
 import { renderToDOMSpec } from "./@util/ReactRenderUtil.js";
+import { useNodeViewBlock } from "./useNodeViewBlock.js";
 
 // this file is mostly analogoues to `customBlocks.ts`, but for React blocks
 
@@ -267,17 +267,20 @@ export function createReactBlockSpec<
         },
         render(block, editor) {
           if (this.renderType === "nodeView") {
+            // The block core's `addNodeView` resolved when this node view was
+            // constructed (itself guarded, via `getBlockFromNodeView`). Seeds
+            // the fallback below so there is always something to render.
+            const initialBlock = block;
+
             return ReactNodeViewRenderer(
               (props: NodeViewProps) => {
                 // Vanilla JS node views are recreated on each update. However,
                 // using `ReactNodeViewRenderer` makes it so the node view is
                 // only created once, so the block we get in the node view will
                 // be outdated. Therefore, we have to get the block in the
-                // `ReactNodeViewRenderer` instead.
-                const block = getBlockFromPos(
-                  props.getPos,
-                  props.view.state.doc,
-                );
+                // `ReactNodeViewRenderer` instead. That position can be stale,
+                // so resolving it is guarded (see `useNodeViewBlock`).
+                const block = useNodeViewBlock(props, initialBlock);
 
                 const ref = useReactNodeView().nodeViewContentRef;
 
 
@@ -0,0 +1,57 @@
+import { Block, getBlockFromPos } from "@blocknote/core";
+import type { NodeViewProps } from "@tiptap/react";
+import { useRef } from "react";
+
+/**
+ * Resolves the `Block` that a React node view should render.
+ *
+ * A node view's `getPos()` is not always usable. ProseMirror computes it by
+ * walking the view-desc tree, but `EditorView.updateStateInner` assigns the new
+ * state *before* it reconciles that tree, so any render that happens partway
+ * through reconciliation sees positions computed against a half-updated tree
+ * while `view.state.doc` is already the new document. React node views get
+ * rendered in exactly that window: TipTap's `ReactRenderer` calls `flushSync`
+ * while mounting a node view, and anything that runs from the resulting commit
+ * (a layout effect, a re-entrant dispatch, another node view's pending update)
+ * renders with a position that no longer matches the document. `getPos()` can
+ * also return `undefined` outright once a desc has been detached.
+ *
+ * The resulting position is either out of range (`RangeError: Position N out of
+ * range`) or in range but pointing at the wrong node (`Node should be a
+ * bnBlock, but is instead: doc`) — both thrown out of the render path, which
+ * under React 19 tears down the consumer's tree rather than being rethrown.
+ *
+ * Upstream considers this TipTap's problem (ProseMirror/prosemirror#1532) and
+ * TipTap considers `flushSync` unavoidable, so we recover here instead, by
+ * reusing the last block we rendered. The bad position is always transient —
+ * ProseMirror finishes reconciling and re-renders the node view with a valid
+ * one immediately after — so a stale frame is invisible, whereas a throw is
+ * not.
+ *
+ * See BlockNote issues #2937, #2682 and #2621.
+ */
+export function useNodeViewBlock(
+  props: NodeViewProps,
+  /**
+   * The block core's `addNodeView` resolved when the node view was constructed
+   * — via `getBlockFromNodeView`, so it is already guarded against the same
+   * problem. Seeds the fallback so there is always a block to render.
+   */
+  initialBlock: Block<any, any, any>,
+): Block<any, any, any> {
+  const lastBlockRef = useRef(initialBlock);
+  const doc = props.view.state.doc;
+
+  try {
+    // Deliberate render-phase write: a monotonic "last good value" cache, so a
+    // repeated render (e.g. StrictMode's double invoke) recomputes the same
+    // thing.
+    lastBlockRef.current = getBlockFromPos(props.getPos, doc);
+  } catch {
+    // Expected and self-correcting, so deliberately silent: ProseMirror
+    // re-renders the node view with a usable position immediately after, and
+    // there is nothing a consumer could do about it in the meantime.
+  }
+
+  return lastBlockRef.current;
+}