@@ -0,0 +1,91 @@
+import { describe, expect, it } from "vite-plus/test";
+
+import { BlockNoteEditor } from "../../editor/BlockNoteEditor.js";
+import { nodeToBlock } from "./nodeToBlock.js";
+import { blockToNode } from "./blockToNode.js";
+
+/**
+ * @vitest-environment jsdom
+ */
+
+// Backwards compatibility for the "plain" content migration on the NON-Yjs
+// (BlockNote JSON) path. A block whose content type changed from "inline"
+// (formatting marks allowed) to "plain" (only the "annotation" group allowed)
+// may appear in stored BlockNote JSON with formatting styles on its text. The
+// write path must drop those disallowed marks instead of throwing when the node
+// is assembled (`createChecked`), and the change must be scoped to plain blocks
+// so inline blocks still keep their formatting.
+
+// Old BlockNote JSON: a (now-plain) code block carrying a bold style.
+const legacyBoldCodeBlock = {
+  type: "codeBlock" as const,
+  props: { language: "javascript" },
+  content: [
+    { type: "text" as const, text: "const x = 1;", styles: { bold: true } },
+  ],
+};
+
+describe("blockToNode: plain-block backwards compatibility (write path)", () => {
+  it("does not throw and drops formatting when converting a plain block with styles", () => {
+    const editor = BlockNoteEditor.create();
+
+    expect(() =>
+      blockToNode(legacyBoldCodeBlock as any, editor.pmSchema),
+    ).not.toThrow();
+
+    const node = blockToNode(legacyBoldCodeBlock as any, editor.pmSchema);
+    // The node is valid (would otherwise fail this check).
+    expect(() => node.check()).not.toThrow();
+
+    // Round-trips back to a plain string with no materialized formatting.
+    const block = nodeToBlock(node, editor.pmSchema);
+    expect(block.type).toBe("codeBlock");
+    expect(block.content).toBe("const x = 1;");
+
+    editor._tiptapEditor.destroy();
+  });
+
+  it("keeps formatting on an inline block (scoped to plain blocks only)", () => {
+    const editor = BlockNoteEditor.create();
+
+    const node = blockToNode(
+      {
+        type: "paragraph",
+        content: [{ type: "text", text: "hello", styles: { bold: true } }],
+      } as any,
+      editor.pmSchema,
+    );
+
+    const block = nodeToBlock(node, editor.pmSchema);
+    expect(block.type).toBe("paragraph");
+    // Paragraph is "inline" content, so bold survives.
+    expect(Array.isArray(block.content)).toBe(true);
+    expect((block.content as any[])[0].styles.bold).toBe(true);
+
+    editor._tiptapEditor.destroy();
+  });
+
+  it("mounts an editor with legacy initialContent without throwing", () => {
+    const editor = BlockNoteEditor.create({
+      initialContent: [legacyBoldCodeBlock as any],
+    });
+    editor.mount(document.createElement("div"));
+
+    expect(editor.document.map((b) => b.type)).toEqual(["codeBlock"]);
+    expect(editor.document[0].content).toBe("const x = 1;");
+
+    editor._tiptapEditor.destroy();
+  });
+
+  it("read path already strips marks: nodeToBlock yields a bare string", () => {
+    const editor = BlockNoteEditor.create();
+
+    // Build the node leniently and confirm the read path emits no styles even if
+    // the block content is plain text.
+    const node = blockToNode(legacyBoldCodeBlock as any, editor.pmSchema);
+    const block = nodeToBlock(node, editor.pmSchema);
+    expect(typeof block.content).toBe("string");
+
+    editor._tiptapEditor.destroy();
+  });
+});
@@ -19,7 +19,7 @@ import {
 import { getColspan, isPartialTableCell } from "../../util/table.js";
 import { UnreachableCaseError } from "../../util/typescript.js";
 import { getAbsoluteTableCells } from "../blockManipulation/tables/tables.js";
-import { getStyleSchema } from "../pmUtil.js";
+import { getStyleSchema, isPlainContentNodeType } from "../pmUtil.js";
 
 /**
  * Convert a StyledText inline element to a
@@ -52,11 +52,23 @@ function styledTextToNodes<T extends StyleSchema>(
     }
   }
 
+  // Backwards compat: old BlockNote JSON may carry formatting marks (e.g. bold)
+  // on a block whose content type is now "plain". Those marks aren't allowed on
+  // the node, and would make `createChecked` throw when the block is assembled.
+  // Drop them here (for plain blocks only) — comment/suggestion (annotation)
+  // marks are allowed and kept by `allowedMarks`.
+  const allowedMarks =
+    blockType &&
+    schema.nodes[blockType] &&
+    isPlainContentNodeType(schema, schema.nodes[blockType])
+      ? [...schema.nodes[blockType].allowedMarks(marks)]
+      : marks;
+
   const parseHardBreaks = !blockType || !schema.nodes[blockType].spec.code;
 
   if (!parseHardBreaks) {
     return styledText.text.length > 0
-      ? [schema.text(styledText.text, marks)]
+      ? [schema.text(styledText.text, allowedMarks)]
       : [];
   }
 
@@ -72,7 +84,7 @@ function styledTextToNodes<T extends StyleSchema>(
         if (text === "\n") {
           return schema.nodes["hardBreak"].createChecked();
         } else {
-          return schema.text(text, marks);
+          return schema.text(text, allowedMarks);
         }
       })
   );
 
@@ -1,4 +1,4 @@
-import type { Node, Schema } from "prosemirror-model";
+import type { Node, NodeType, Schema } from "prosemirror-model";
 import { Transform } from "prosemirror-transform";
 import type { BlockNoteEditor } from "../editor/BlockNoteEditor.js";
 import { BlockNoteSchema } from "../blocks/BlockNoteSchema.js";
@@ -52,3 +52,20 @@ export function getStyleSchema<S extends StyleSchema>(schema: Schema): S {
 export function getBlockCache(schema: Schema) {
   return getBlockNoteEditor(schema).blockCache;
 }
+
+/**
+ * Whether `nodeType` is a BlockNote block whose content type is `"plain"` — i.e.
+ * it holds unstyled text and only allows the non-formatting (`"annotation"`)
+ * marks. Resolved semantically from the block schema (the source of truth),
+ * reachable from `schema.cached.blockNoteEditor`.
+ *
+ * Returns `false` for every non-block / structural node type (`doc`,
+ * `blockGroup`, `text`, inline content, table sub-nodes), since those aren't
+ * keys in the block schema.
+ */
+export function isPlainContentNodeType(
+  schema: Schema,
+  nodeType: NodeType,
+): boolean {
+  return getBlockSchema(schema)[nodeType.name]?.content === "plain";
+}
@@ -532,6 +532,10 @@ export class BlockNoteEditor<
         );
       }
       const schema = getSchema(tiptapOptions.extensions!);
+      // `blockToNode` (via `isPlainContentNodeType`) resolves the block schema
+      // through `schema.cached.blockNoteEditor`, so stamp it on this throwaway
+      // schema now — the real `pmSchema` is stamped separately below.
+      schema.cached.blockNoteEditor = this;
       const pmNodes = initialContent.map((b) =>
         blockToNode(b, schema, this.schema.styleSchema).toJSON(),
       );