@@ -101,6 +101,26 @@ describe("Test splitBlocks", () => {
     expect(newBlock.children).toEqual([]);
   });
 
+  it("Block has children, split at start of content", () => {
+    getEditor().transact((tr) => {
+      setSelectionWithOffset(tr.doc, "paragraph-with-children", 0);
+    });
+
+    splitBlock(getEditor().transact((tr) => tr.selection.anchor));
+
+    // The first half keeps no content, so the children go with the second one,
+    // which does — rather than being stranded on an empty block.
+    const original = getEditor().document.find(
+      (block) => block.id === "paragraph-with-children",
+    )!;
+    expect(original.children).toEqual([]);
+
+    const newBlock = getEditor().document.find((block) => block.id === "0")!;
+    expect(newBlock.children.map((child) => child.id)).toEqual([
+      "nested-paragraph-0",
+    ]);
+  });
+
   it("Keep type", () => {
     getEditor().transact((tr) => {
       setSelectionWithOffset(tr.doc, "heading-0", 4);
 
@@ -58,7 +58,13 @@ export const splitBlockTr = (
   // To avoid that, the group is detached before the split and put back on the
   // original block afterwards. Both happen in the same transaction, so this is
   // still a single undo step.
-  const childContainer = info.childContainer;
+  //
+  // Splitting at the very start is the exception: there the first half keeps no
+  // content at all and the whole of it moves to the second, so the children
+  // follow it rather than being left behind on an empty block. That's what a
+  // plain `tr.split` already does.
+  const splitAtStart = posInBlock === info.blockContent.beforePos + 1;
+  const childContainer = splitAtStart ? undefined : info.childContainer;
 
   if (childContainer) {
     // The group sits after `posInBlock`, so deleting it doesn't shift the split
 
@@ -204,7 +204,7 @@ function serializeBlock<
   // `CollapsibleExtension` doesn't run when exporting, so the chevron is added
   // here to keep the layout identical to the editor's. It can't fold anything,
   // so it's rendered inert.
-  if (isBlockCollapsible(editor as any, block.type as string, props)) {
+  if (isBlockCollapsible(editor, block.type as string, props)) {
     const collapseButton = createCollapseButton(true);
     collapseButton.setAttribute("aria-hidden", "true");
     collapseButton.setAttribute("tabindex", "-1");
 
@@ -339,9 +339,16 @@ NESTED BLOCKS
   padding: 3px;
 }
 
-/* Headings pad 18px at the top rather than 3px (see HEADINGS above), which
-   lifts the centred chevron off the text; this pushes it back down by half the
-   difference. */
+/* Headings pad 18px at the top (see HEADINGS above), so centring the chevron
+   against the whole content box leaves it sitting above the text. This pushes it
+   back down.
+
+   The value is empirical, and only right for a single-line heading around the
+   default level — the correct offset depends on the heading's line box, which
+   scales with `--level`, and that custom property is set on the content element,
+   a sibling the button can't read it from. Not visible in the screenshot tests
+   either, which mask `.bn-collapse-button`. Wants a proper pass: align to
+   `flex-start` and offset by the first line's height. */
 .bn-block-outer[data-collapsible="true"]:has(
     > .bn-block > .bn-block-content[data-content-type="heading"]
   )
 
@@ -1,7 +1,13 @@
+import { TextSelection } from "prosemirror-state";
 import { afterEach, beforeEach, describe, expect, it } from "vite-plus/test";
 
-import type { PartialBlock } from "../../blocks/defaultBlocks.js";
+import { BlockNoteSchema } from "../../blocks/BlockNoteSchema.js";
+import {
+  defaultBlockSpecs,
+  type PartialBlock,
+} from "../../blocks/defaultBlocks.js";
 import { BlockNoteEditor } from "../../editor/BlockNoteEditor.js";
+import { createBlockSpec } from "../../schema/index.js";
 import { CollapsibleExtension } from "./Collapsible.js";
 
 /**
@@ -26,8 +32,16 @@ afterEach(() => {
   window.localStorage.clear();
 });
 
-function createEditor(initialContent: PartialBlock<any, any, any>[]) {
-  const editor = BlockNoteEditor.create({ initialContent });
+function createEditor(
+  initialContent: PartialBlock<any, any, any>[],
+  schema?: BlockNoteSchema<any, any, any>,
+): BlockNoteEditor<any, any, any> {
+  // Spread rather than passed as `undefined`, which isn't the same as absent
+  // here — it overrides the default schema with nothing.
+  const editor = BlockNoteEditor.create({
+    initialContent,
+    ...(schema ? { schema } : {}),
+  } as any);
   editor.mount(document.createElement("div"));
   activeEditors.push(editor);
 
@@ -67,18 +81,44 @@ function addChildButton(editor: BlockNoteEditor<any, any, any>, id: string) {
  * equivalent: it replays only the *steps* a handler dispatched, so a selection
  * the handler set is dropped.
  */
-function pressEnter(editor: BlockNoteEditor<any, any, any>) {
+function pressEnter(
+  editor: BlockNoteEditor<any, any, any>,
+  { shift = false }: { shift?: boolean } = {},
+) {
   const view = editor.prosemirrorView;
   const event = new KeyboardEvent("keydown", {
     key: "Enter",
     code: "Enter",
+    shiftKey: shift,
     bubbles: true,
     cancelable: true,
   });
 
   view.someProp("handleKeyDown", (handler) => handler(view, event));
 }
 
+/** A collapsible block that takes no hard breaks, so Shift-Enter falls through. */
+const NO_HARD_BREAK_SCHEMA = BlockNoteSchema.create({
+  blockSpecs: {
+    ...defaultBlockSpecs,
+    collapsibleNoHardBreak: createBlockSpec(
+      {
+        type: "collapsibleNoHardBreak",
+        propSchema: {},
+        content: "inline",
+      },
+      {
+        meta: { collapsible: true, hardBreakShortcut: "none" },
+        render: () => {
+          const dom = document.createElement("p");
+
+          return { dom, contentDOM: dom };
+        },
+      },
+    )(),
+  },
+});
+
 const TOGGLE_HEADING: PartialBlock<any, any, any> = {
   id: "toggle-heading",
   type: "heading",
@@ -171,6 +211,26 @@ describe("CollapsibleExtension", () => {
     expect(chevron(editor, "toggle-heading")).not.toBe(null);
   });
 
+  it("points the chevron at the group it discloses, for screen readers", () => {
+    const editor = createEditor(TOGGLE_HEADING_WITH_CHILD);
+    const button = chevron(editor, "toggle-heading")!;
+
+    const controls = button.getAttribute("aria-controls");
+    expect(controls).toBe("bn-collapse-children-toggle-heading");
+    // The link has to actually resolve, or it's worse than saying nothing.
+    expect(
+      editor.prosemirrorView.dom.querySelector(`#${controls}`)?.className,
+    ).toContain("bn-block-group");
+
+    // Nothing to point at while the block has no children.
+    const childless = createEditor([
+      { id: "toggle", type: "toggleListItem", content: "Toggle" },
+    ]);
+    expect(chevron(childless, "toggle")!.hasAttribute("aria-controls")).toBe(
+      false,
+    );
+  });
+
   // #2124
   it("drops the chevron when a toggle heading is converted to a plain heading", () => {
     const editor = createEditor(TOGGLE_HEADING_WITH_CHILD);
@@ -397,11 +457,66 @@ describe("CollapsibleExtension", () => {
       expect(editor.document[0].type).toBe("paragraph");
       expect(editor.document[0].children).toHaveLength(0);
 
-      // A cursor part-way through the title splits it, keeping the children.
+      // A cursor part-way through the title splits it, keeping the children on
+      // the half that keeps the title.
       editor.setTextCursorPosition("toggle", "start");
+      editor.transact((tr) =>
+        tr.setSelection(TextSelection.create(tr.doc, tr.selection.from + 3)),
+      );
       pressEnter(editor);
       const toggle = editor.document.find((block) => block.id === "toggle")!;
       expect(toggle.children.map((child) => child.id)).toEqual(["child"]);
     });
+
+    // At the very start there's no title left on the original half to keep the
+    // children company, so they go with the text instead of being stranded on an
+    // empty block. Notion likewise leaves the toggle intact and puts the new
+    // block above it.
+    it("moves the children with the title when splitting at the start", () => {
+      const editor = createEditor([
+        {
+          id: "toggle",
+          type: "toggleListItem",
+          content: "Toggle",
+          children: [{ id: "child", type: "paragraph", content: "Child" }],
+        },
+      ]);
+      collapsible(editor).setCollapsed({ id: "toggle" }, false);
+
+      editor.setTextCursorPosition("toggle", "start");
+      pressEnter(editor);
+
+      const [empty, withTitle] = editor.document;
+      expect(empty.content).toEqual([]);
+      expect(empty.children).toHaveLength(0);
+      expect(withTitle.content).toEqual([
+        { type: "text", text: "Toggle", styles: {} },
+      ]);
+      expect(withTitle.children.map((child) => child.id)).toEqual(["child"]);
+    });
+
+    // A block that opts out of hard breaks lets Shift-Enter fall through to the
+    // default Enter chain. It should still split there rather than start a
+    // child, the way it did before this handler existed. Needs a block with
+    // `hardBreakShortcut: "none"`: with the default, the hard-break handler runs
+    // first and this never gets the chance to go wrong.
+    it("ignores Shift-Enter", () => {
+      const editor = createEditor(
+        [{ id: "toggle", type: "collapsibleNoHardBreak", content: "Toggle" }],
+        NO_HARD_BREAK_SCHEMA,
+      );
+      collapsible(editor).setCollapsed({ id: "toggle" }, false);
+      editor.setTextCursorPosition("toggle", "end");
+
+      pressEnter(editor, { shift: true });
+
+      expect(editor.document).toHaveLength(2);
+      expect(editor.document[0].children).toHaveLength(0);
+
+      // ...whereas plain Enter still starts a child.
+      editor.setTextCursorPosition("toggle", "end");
+      pressEnter(editor);
+      expect(editor.document[0].children).toHaveLength(1);
+    });
   });
 });
@@ -96,10 +96,12 @@ export type CollapsibleOptions = {
  * Whether a block of `type` with `props` declares itself collapsible.
  *
  * Shared with the HTML exporter, which has to reproduce what the extension
- * renders without an editor view to read decorations from.
+ * renders without an editor view to read decorations from. It takes only the
+ * schema rather than a whole editor, so an editor with a concrete block schema
+ * can be passed without a cast.
  */
 export function isBlockCollapsible(
-  editor: BlockNoteEditor<any, any, any>,
+  editor: Pick<BlockNoteEditor<any, any, any>, "schema">,
   type: string,
   props: Record<string, any>,
 ): boolean {
@@ -111,15 +113,28 @@ export function isBlockCollapsible(
     : !!collapsible;
 }
 
+/** The DOM id given to a collapsible block's child group, for `aria-controls`. */
+export function collapsibleChildrenId(blockId: string): string {
+  return `bn-collapse-children-${blockId}`;
+}
+
 /**
  * The chevron shown to the left of a collapsible block's content. It's the
- * disclosure control for the block's children, so it carries `aria-expanded`.
+ * disclosure control for the block's children, so it carries `aria-expanded`,
+ * and `aria-controls` naming what it discloses where there is anything to name —
+ * a childless block has no group to point at.
  */
-export function createCollapseButton(expanded: boolean): HTMLButtonElement {
+export function createCollapseButton(
+  expanded: boolean,
+  controls?: string,
+): HTMLButtonElement {
   const button = document.createElement("button");
   button.className = "bn-collapse-button";
   button.type = "button";
   button.setAttribute("aria-expanded", expanded ? "true" : "false");
+  if (controls) {
+    button.setAttribute("aria-controls", controls);
+  }
   button.innerHTML =
     // https://fonts.google.com/icons?selected=Material+Symbols+Rounded:chevron_right:FILL@0;wght@700;GRAD@0;opsz@24&icon.query=chevron&icon.style=Rounded&icon.size=24&icon.color=%23e8eaed
     '<svg xmlns="http://www.w3.org/2000/svg" height="24px" viewBox="0 -960 960 960" width="24px" fill="CURRENTCOLOR"><path d="M320-200v-560l440 280-440 280Z"/></svg>';
@@ -147,10 +162,6 @@ export const CollapsibleExtension = createExtension(
 
     const isExpanded = (id: string) => toggledState.get({ id });
 
-    // Child counts as of each block's last decoration, so that a block which
-    // gains one can expand rather than appear to swallow it.
-    const childCounts = new Map<string, number>();
-
     /** Redraws the decorations, for state that isn't in the document. */
     function invalidate() {
       // A headless editor has no view to redraw.
@@ -176,8 +187,16 @@ export const CollapsibleExtension = createExtension(
       }
     });
 
-    function createChevron(id: string, expanded: boolean, disabled: boolean) {
-      const button = createCollapseButton(expanded);
+    function createChevron(
+      id: string,
+      expanded: boolean,
+      disabled: boolean,
+      hasChildren: boolean,
+    ) {
+      const button = createCollapseButton(
+        expanded,
+        hasChildren ? collapsibleChildrenId(id) : undefined,
+      );
       button.disabled = disabled;
       // Keeps the editor's selection (and focus) where it was.
       button.addEventListener("mousedown", (event) => event.preventDefault());
@@ -227,17 +246,26 @@ export const CollapsibleExtension = createExtension(
 
     const collapsiblePlugin = createBlockDecorationPlugin(
       collapsiblePluginKey,
-      (info, pos, id) => {
+      (info, pos, id, previous) => {
         const props = info.blockContent.node.attrs;
         if (!isBlockCollapsible(editor, info.blockNoteType, props)) {
           return [];
         }
 
         const childCount = info.childContainer?.node.childCount ?? 0;
-        if (childCount > (childCounts.get(id) ?? childCount)) {
+        // The count as of the last time this block was decorated, carried on the
+        // decoration so it lives and dies with the block. A block that has just
+        // gained a child expands, rather than appearing to swallow it — note
+        // that this writes collapse state from inside `apply`, which a remote
+        // insert can therefore trigger. It's idempotent, and the write is to
+        // per-user storage rather than the document.
+        const lastChildCount = previous.find(
+          (decoration) => decoration.spec.childCount !== undefined,
+        )?.spec.childCount;
+
+        if (childCount > (lastChildCount ?? childCount)) {
           toggledState.set({ id }, true);
         }
-        childCounts.set(id, childCount);
 
         const expanded = isExpanded(id);
         // Nothing to reveal, and no "add a block" button either.
@@ -252,21 +280,35 @@ export const CollapsibleExtension = createExtension(
               "data-collapsible": "true",
               ...(expanded ? {} : { "data-collapsed": "true" }),
             },
-            { blockId: id },
+            { blockId: id, childCount },
           ),
           Decoration.widget(
             pos + 1,
-            () => createChevron(id, expanded, disabled),
+            () => createChevron(id, expanded, disabled, childCount > 0),
             {
               blockId: id,
               side: -1,
               // Everything the button's DOM depends on, so ProseMirror reuses
               // it until one of them changes.
-              key: `bn-collapse-button:${id}:${expanded}:${disabled}`,
+              key: `bn-collapse-button:${id}:${expanded}:${disabled}:${
+                childCount > 0
+              }`,
             },
           ),
         ];
 
+        // Names the group the chevron discloses, for `aria-controls`.
+        if (info.childContainer) {
+          decorations.push(
+            Decoration.node(
+              info.childContainer.beforePos,
+              info.childContainer.afterPos,
+              { id: collapsibleChildrenId(id) },
+              { blockId: id },
+            ),
+          );
+        }
+
         // An expanded block with no children gets an "add a block" button, so
         // its chevron has something to reveal.
         if (expanded && editor.isEditable && childCount === 0) {