@jackuait/blok 0.10.7 → 0.10.9

package/src/components/modules/blockManager/hierarchy.ts

@@ -5,6 +5,7 @@
  */
 import type { Block } from '../../block';
 import { DATA_ATTR } from '../../constants/data-attributes';
+import { logLabeled } from '../../utils';
 
 import type { BlockRepository } from './repository';
 
@@ -14,28 +15,56 @@ import type { BlockRepository } from './repository';
 export class BlockHierarchy {
   private readonly repository: BlockRepository;
   private readonly onParentChanged?: (parentId: string) => void;
+  private readonly getIsSyncingFromYjs?: () => boolean;
 
   /**
    * @param repository - BlockRepository for looking up blocks by id
    * @param onParentChanged - optional callback invoked after a block is assigned a non-null parent
+   * @param getIsSyncingFromYjs - optional getter that reports whether the editor is
+   *   currently applying a remote Yjs update. When true, the Layer 7 dangling
+   *   parent id guard skips the throw and always coerces + logs — remote
+   *   peers can legitimately deliver a transiently-dangling parent id during
+   *   conflict resolution, batched undo replay, or initial sync ordering.
    */
-  constructor(repository: BlockRepository, onParentChanged?: (parentId: string) => void) {
+  constructor(
+    repository: BlockRepository,
+    onParentChanged?: (parentId: string) => void,
+    getIsSyncingFromYjs?: () => boolean
+  ) {
     this.repository = repository;
     this.onParentChanged = onParentChanged;
+    this.getIsSyncingFromYjs = getIsSyncingFromYjs;
   }
 
   /**
    * Returns the depth (nesting level) of a block in the hierarchy.
    * Root-level blocks have depth 0.
+   *
+   * Fix 4: a `visited` set guards against malformed parent chains that form a
+   * cycle (e.g. remote peers that concurrently reparent A→B and B→A converge
+   * into A↔B). Without the guard, the recursion blows the stack and takes
+   * down the tab.
    * @param block - the block to get depth for
    * @returns {number} - depth level (0 for root, 1 for first level children, etc.)
    */
   public getBlockDepth(block: Block): number {
+    const visited = new Set<string>();
+
+    if (block.id !== undefined) {
+      visited.add(block.id);
+    }
+
     const calculateDepth = (parentId: string | null, currentDepth: number): number => {
       if (parentId === null) {
         return currentDepth;
       }
 
+      if (visited.has(parentId)) {
+        // Cycle detected — bail to the current depth so we don't blow the stack.
+        return currentDepth;
+      }
+      visited.add(parentId);
+
       const parentBlock = this.repository.getBlockById(parentId);
 
       if (parentBlock === undefined) {
@@ -48,12 +77,129 @@ export class BlockHierarchy {
     return calculateDepth(block.parentId, 0);
   }
 
+  /**
+   * Walks the target parent chain and returns true if `childId` already
+   * appears in it — meaning assigning `child` as a descendant of the target
+   * parent would form a cycle.
+   *
+   * Fix 4 companion guard for {@link setBlockParent}.
+   * @param childId - block id being reparented
+   * @param targetParentId - prospective new parent id
+   * @returns true if the assignment would form a cycle
+   */
+  private wouldFormCycle(childId: string, targetParentId: string): boolean {
+    const walk = (cursor: string | null, visited: Set<string>): boolean => {
+      if (cursor === null) {
+        return false;
+      }
+      if (cursor === childId) {
+        return true;
+      }
+      if (visited.has(cursor)) {
+        // Pre-existing cycle — still disqualifies the reparent.
+        return true;
+      }
+      visited.add(cursor);
+
+      const parent = this.repository.getBlockById(cursor);
+
+      if (parent === undefined) {
+        return false;
+      }
+
+      return walk(parent.parentId, visited);
+    };
+
+    return walk(targetParentId, new Set<string>());
+  }
+
   /**
    * Sets the parent of a block, updating both the block's parentId and the parent's contentIds.
    * @param block - the block to reparent
    * @param newParentId - the new parent block id, or null for root level
    */
   public setBlockParent(block: Block, newParentId: string | null): void {
+    /**
+     * Layer 19: stale-block guard (regression: wrong-block-dropped family).
+     *
+     * If `block` has been destroyed and is no longer in the repository,
+     * `repository.blocks.indexOf(block)` below returns -1. The toggle-DOM
+     * anchor logic then runs `allBlocks.slice(0, -1)` — the whole array
+     * minus its last element — and silently anchors the stale block's
+     * holder at a completely unrelated DOM position. The new-parent
+     * branch repeats the same failure with `slice(0)` returning every
+     * block. That's the DOM-manipulation analogue of the `splice(-1, …)`
+     * root cause behind the original "wrong block dropped" bug.
+     *
+     * Additionally, without this guard `block.parentId` would be mutated
+     * on a destroyed reference and `onParentChanged` would fire with a
+     * ghost id, polluting Yjs with writes against a dead block.
+     *
+     * Bail out cleanly at entry so callers — DragController.handleDrop in
+     * particular — get a no-op instead of silent DOM/data corruption.
+     */
+    if (this.repository.getBlockIndex(block) === -1) {
+      return;
+    }
+
+    /**
+     * Fix 4: cycle guard.
+     *
+     * Reject reparents that would form a cycle (e.g. make A a descendant of
+     * one of its own descendants). Without this guard, a corrupted remote
+     * update can land the editor in a state where getBlockDepth recurses
+     * forever, plus any hierarchical save would produce a tree that can
+     * never round-trip.
+     */
+    if (newParentId !== null && this.wouldFormCycle(block.id, newParentId)) {
+      throw new Error(
+        `BlockHierarchy.setBlockParent: refusing to form cycle — assigning ${block.id} to parent ${newParentId} would create a parent/child cycle.`
+      );
+    }
+
+    /**
+     * Layer 7: universal chokepoint guard against dangling parentId.
+     *
+     * Every reparent in the editor — paste, drag, split, duplicate, slash
+     * menu, Cmd+D, markdown shortcut, public api — flows through this
+     * method. Previously, if the caller passed a parent id that was no
+     * longer in the repository, the write silently mutated block.parentId
+     * to garbage: getBlockById returned undefined, the new-parent DOM and
+     * contentIds branches no-opped, but `block.parentId = newParentId`
+     * still ran. The ghost id then survived until Saver's dangling-parent
+     * repair (layer 5), by which point the block has already been
+     * ejected from any container it was supposed to belong to.
+     *
+     * Guarding at this chokepoint catches the regression at the point of
+     * introduction instead of one save cycle later:
+     *   - test/dev: throw loudly so the offending caller is fixed before
+     *     the build ships.
+     *   - prod: coerce to null + log `error`, matching the saver's graceful
+     *     repair semantics so end users never see a wedged editor.
+     *
+     * This is the upstream-most defense in the callout paste ejection
+     * bug family (operations.paste title-vs-child, insert transfer, blok
+     * data handler contextParent, saver repair, validateHierarchy gate).
+     */
+    const parentExists =
+      newParentId === null || this.repository.getBlockById(newParentId) !== undefined;
+
+    if (!parentExists) {
+      const env = typeof process !== 'undefined' ? process.env?.NODE_ENV : undefined;
+      const isSyncingFromYjs = this.getIsSyncingFromYjs?.() === true;
+      const message =
+        `BlockHierarchy.setBlockParent: dangling parent id "${newParentId}" ` +
+        `for block "${block.id}" — parent block is not in the repository.`;
+
+      if (!isSyncingFromYjs && (env === 'test' || env === 'development')) {
+        throw new Error(message);
+      }
+
+      logLabeled(message, 'error');
+    }
+
+    const sanitizedParentId = parentExists ? newParentId : null;
+
     const oldParentId = block.parentId;
 
     // Remove from old parent's contentIds
@@ -85,7 +231,7 @@ export class BlockHierarchy {
     }
 
     // Add to new parent's contentIds
-    const newParent = newParentId !== null ? this.repository.getBlockById(newParentId) : undefined;
+    const newParent = sanitizedParentId !== null ? this.repository.getBlockById(sanitizedParentId) : undefined;
     const shouldAddToNewParent = newParent !== undefined && !newParent.contentIds.includes(block.id);
 
     if (shouldAddToNewParent) {
@@ -94,19 +240,29 @@ export class BlockHierarchy {
 
     // Update block's parentId - parentId is a public mutable property on Block
     // eslint-disable-next-line no-param-reassign
-    block.parentId = newParentId;
+    block.parentId = sanitizedParentId;
 
     // If the new parent's existing children are hidden (toggle is collapsed),
     // hide this newly added child too so Tab navigation skips it.
-    if (newParentId !== null && newParent !== undefined) {
+    //
+    // Fix 5: a previously-empty collapsed container has no existing hidden
+    // children to infer state from. Fall back to reading the toggle/header
+    // tool's persistent open-state attribute (`data-blok-toggle-open="false"`)
+    // on any descendant of the parent holder.
+    if (sanitizedParentId !== null && newParent !== undefined) {
       const existingChildren = newParent.contentIds
         .filter(id => id !== block.id)
         .map(id => this.repository.getBlockById(id))
         .filter((b): b is NonNullable<typeof b> => b !== undefined);
 
-      const parentIsCollapsed = existingChildren.length > 0 &&
+      const parentIsCollapsedFromChildren = existingChildren.length > 0 &&
         existingChildren.every(b => b.holder.classList.contains('hidden'));
 
+      const parentIsCollapsedFromAttr =
+        newParent.holder.querySelector('[data-blok-toggle-open="false"]') !== null;
+
+      const parentIsCollapsed = parentIsCollapsedFromChildren || parentIsCollapsedFromAttr;
+
       if (parentIsCollapsed) {
         block.holder.classList.add('hidden');
       }
@@ -116,7 +272,7 @@ export class BlockHierarchy {
     // honouring the flat-array order so the DOM order matches the logical order.
     // Skip if the holder is already claimed by another nested-blocks container
     // (e.g. a table cell) — moving it would steal it from that container.
-    if (newParentId !== null && newParent !== undefined && !block.holder.closest(`[${DATA_ATTR.nestedBlocks}]`)) {
+    if (sanitizedParentId !== null && newParent !== undefined && !block.holder.closest(`[${DATA_ATTR.nestedBlocks}]`)) {
       const newContainer = newParent.holder.querySelector('[data-blok-toggle-children]');
       if (newContainer) {
         const allBlocks = this.repository.blocks;
@@ -134,8 +290,8 @@ export class BlockHierarchy {
     this.updateBlockIndentation(block);
 
     // Notify listener so parent data can be synced (e.g. to Yjs)
-    if (newParentId !== null && this.onParentChanged !== undefined) {
-      this.onParentChanged(newParentId);
+    if (sanitizedParentId !== null && this.onParentChanged !== undefined) {
+      this.onParentChanged(sanitizedParentId);
     }
   }
 

package/src/components/modules/blockManager/operations.ts

@@ -221,6 +221,7 @@ export class BlockOperations {
       tunes,
       skipYjsSync = false,
       appendToWorkingArea = false,
+      forceTopLevel = false,
     } = options;
 
     const targetIndex = index ?? this.currentBlockIndex + (replace ? 0 : 1);
@@ -277,13 +278,36 @@ export class BlockOperations {
       throw new Error(`Could not replace Block at index ${targetIndex}. Block not found.`);
     }
 
+    /**
+     * Capture the replaced block's parent link BEFORE it leaves the
+     * repository so the new block inherits the same container membership.
+     * Without this, a replace-insert inside a callout/toggle/table-cell
+     * child drops parentId and the Saver's derive-from-live-parentId
+     * fallback then emits the new block as a root sibling — the "callout
+     * paste ejection" regression family. Defense-in-depth counterpart to
+     * the paste() method's inheritance handling.
+     */
+    const replacedParentId = blockToReplace?.parentId ?? null;
+    const replacedBlockId = blockToReplace?.id;
+
     if (replace && blockToReplace !== undefined) {
       this.blockDidMutated(BlockRemovedMutationType, blockToReplace, {
         index: targetIndex,
       });
     }
 
-    blocksStore.insert(targetIndex, block, replace, appendToWorkingArea);
+    blocksStore.insert(targetIndex, block, replace, appendToWorkingArea, forceTopLevel);
+
+    /**
+     * Transfer the parent link to the new block BEFORE Yjs sync so
+     * `addBlock` writes the final parentId in a single shot. Routing
+     * through `transferParentLinkToNewBlock` swaps the old id for the new
+     * one in the parent's contentIds while preserving its original
+     * position, matching the semantics used by `replace()`.
+     */
+    if (replace && replacedParentId !== null && replacedBlockId !== undefined) {
+      this.transferParentLinkToNewBlock(replacedBlockId, block, replacedParentId);
+    }
 
     /**
      * Update the raw currentBlockIndex BEFORE firing the mutation event so
@@ -342,9 +366,18 @@ export class BlockOperations {
    * @param needToFocus - If true, updates current Block index
    * @param skipYjsSync - If true, skip syncing to Yjs
    * @param blocksStore - The blocks store to modify
+   * @param forceTopLevel - If true, place new block at workingArea root level regardless of
+   *   whether the predecessor in the flat array is nested. Used by Enter-at-start and
+   *   Enter-at-end handlers when the current block is top-level.
    * @returns Inserted Block
    */
-  public insertDefaultBlockAtIndex(index: number, needToFocus = false, skipYjsSync = false, blocksStore: BlocksStore): Block {
+  public insertDefaultBlockAtIndex(
+    index: number,
+    needToFocus = false,
+    skipYjsSync = false,
+    blocksStore: BlocksStore,
+    forceTopLevel = false
+  ): Block {
     const defaultTool = this.dependencies.config.defaultBlock;
 
     if (defaultTool === undefined) {
@@ -356,6 +389,7 @@ export class BlockOperations {
       index,
       needToFocus,
       skipYjsSync,
+      forceTopLevel,
     }, blocksStore);
   }
 
@@ -475,6 +509,26 @@ export class BlockOperations {
 
     const existingData = await block.data;
 
+    /**
+     * Layer 16: stale-source guard (regression: wrong-block-dropped family).
+     *
+     * `await block.data` is async — during that await, `block` can be removed
+     * by a Yjs remote delete, undo/redo, or tool conversion. When that happens
+     * `getBlockIndex(block)` returns -1 and `blocksStore.replace(-1, newBlock)`
+     * throws `Incorrect index`, aborting the surrounding batch mid-flight and
+     * leaving the flat blocks array inconsistent with the DOM — exactly the
+     * stale-state condition that lets drag drop an unrelated block.
+     *
+     * Abort cleanly: return the original block with no mutation or Yjs side
+     * effects. Revalidate AFTER the await, not before, so the guard covers
+     * the full async gap.
+     */
+    const blockIndex = this.repository.getBlockIndex(block);
+
+    if (blockIndex === -1) {
+      return block;
+    }
+
     const newBlock = this.factory.composeBlock({
       id: block.id,
       tool: block.name,
@@ -485,8 +539,6 @@ export class BlockOperations {
       bindEventsImmediately: true,
     });
 
-    const blockIndex = this.repository.getBlockIndex(block);
-
     blocksStore.replace(blockIndex, newBlock);
 
     this.blockDidMutated(BlockChangedMutationType, newBlock, {
@@ -511,7 +563,50 @@ export class BlockOperations {
   }
 
   /**
-   * Update the parentId of each child block to the given parent id.
+   * Attach `newBlock` to the old parent in place of the old block id,
+   * routing through `setBlockParent` so the DOM reparent/hide side effects
+   * run, then restoring the original position in the parent's contentIds[].
+   *
+   * Extracted from `replace()` to keep nesting depth under the lint cap.
+   * @param oldBlockId - The id of the block being replaced
+   * @param newBlock - The newly composed replacement block
+   * @param oldParentId - The parent id to transfer onto `newBlock`
+   */
+  private transferParentLinkToNewBlock(oldBlockId: string, newBlock: Block, oldParentId: string): void {
+    const parentBlock = this.repository.getBlockById(oldParentId);
+
+    if (parentBlock === undefined) {
+      // Parent already gone from the repository (e.g. race) — fall back to
+      // the bare parentId assignment so the new block at least carries the
+      // parent link for save/serialization.
+      // eslint-disable-next-line no-param-reassign
+      newBlock.parentId = oldParentId;
+
+      return;
+    }
+
+    const oldPositionInParent = parentBlock.contentIds.indexOf(oldBlockId);
+
+    this.hierarchy.setBlockParent(newBlock, oldParentId);
+
+    if (oldPositionInParent < 0) {
+      return;
+    }
+
+    const withoutStale = parentBlock.contentIds.filter(id => id !== oldBlockId && id !== newBlock.id);
+
+    withoutStale.splice(oldPositionInParent, 0, newBlock.id);
+    parentBlock.contentIds = withoutStale;
+  }
+
+  /**
+   * Route each child through `BlockHierarchy.setBlockParent` so that DOM
+   * reparenting (into the new parent's toggle-children container) and
+   * collapsed-state propagation run as a single atomic side effect per child.
+   *
+   * Direct `childBlock.parentId = ...` mutation is the same architectural bug
+   * as the callout paste-ejection family: the parent/content invariant is
+   * maintained but the DOM drifts from the logical tree until the next render.
    * @param childIds - Array of child block IDs to reparent
    * @param newParentId - New parent block ID
    */
@@ -520,7 +615,7 @@ export class BlockOperations {
       const childBlock = this.repository.getBlockById(childId);
 
       if (childBlock !== undefined) {
-        childBlock.parentId = newParentId;
+        this.hierarchy.setBlockParent(childBlock, newParentId);
       }
     }
   }
@@ -534,6 +629,24 @@ export class BlockOperations {
    */
   public replace(block: Block, newTool: string, data: BlockToolData, blocksStore: BlocksStore): Block {
     const blockIndex = this.repository.getBlockIndex(block);
+
+    /**
+     * Layer 16: stale-source guard (regression: wrong-block-dropped family).
+     *
+     * `convert()` calls this after `await block.save()` — during that await
+     * the block can be removed by a Yjs remote delete or undo. A stale source
+     * here would drive `YjsManager.addBlock({...}, -1)` and
+     * `insert({ index: -1, replace: true })` — both feed negative indices
+     * into downstream splice paths that silently corrupt the flat array.
+     *
+     * Abort cleanly: return the original block with no Yjs or DOM side
+     * effects. The caller (conversion dropdown, paste) already tolerates a
+     * no-op outcome for a destroyed source.
+     */
+    if (blockIndex === -1) {
+      return block;
+    }
+
     const newBlockId = generateBlockId();
 
     // Capture hierarchy before replacement
@@ -560,15 +673,23 @@ export class BlockOperations {
       skipYjsSync: true,
     }, blocksStore);
 
-    // Transfer hierarchy to new block
+    // Transfer hierarchy to new block.
+    //
+    // Route through `BlockHierarchy.setBlockParent` rather than mutating
+    // `newBlock.parentId` / `parentBlock.contentIds` directly, so that DOM
+    // reparenting (into the parent's toggle-children container) and
+    // collapsed-state propagation happen atomically. Direct mutation was the
+    // last remaining path that could leave a replaced child inside a
+    // callout/toggle rendered at the wrong DOM position until the next full
+    // render pass — same architectural shape as the callout paste-ejection
+    // bug family.
+    //
+    // Ordering concern: `setBlockParent` appends the new id to the parent's
+    // contentIds[], but `replace()` must preserve the OLD block's position.
+    // Capture the old index first, then run setBlockParent, then move the new
+    // id back into the captured slot and drop the (now-stale) old id.
     if (oldParentId !== null) {
-      newBlock.parentId = oldParentId;
-
-      const parentBlock = this.repository.getBlockById(oldParentId);
-
-      if (parentBlock !== undefined) {
-        parentBlock.contentIds = parentBlock.contentIds.map(id => id === block.id ? newBlock.id : id);
-      }
+      this.transferParentLinkToNewBlock(block.id, newBlock, oldParentId);
     }
 
     /**
@@ -584,7 +705,11 @@ export class BlockOperations {
       (newTool === 'header' && (data as { isToggleable?: boolean }).isToggleable === true);
 
     if (oldContentIds.length > 0 && !newToolCanHostChildren) {
-      // Promote each child to root level, inserting after the new block
+      // Promote each child to root level, inserting after the new block.
+      // Route through setBlockParent so the child holder is also moved out
+      // of the old (now-removed) parent's toggle-children container and any
+      // hidden/indentation state is recomputed — same reasoning as
+      // `reparentChildren` above.
       const insertAfterIndex = this.repository.getBlockIndex(newBlock);
 
       oldContentIds.forEach((childId, offset) => {
@@ -594,14 +719,17 @@ export class BlockOperations {
           return;
         }
 
-        childBlock.parentId = null;
+        this.hierarchy.setBlockParent(childBlock, null);
         blocksStore.insert(insertAfterIndex + 1 + offset, childBlock, false, false);
       });
 
       newBlock.contentIds = [];
     } else {
+      // `reparentChildren` uses setBlockParent, which pushes each child id
+      // onto `newBlock.contentIds`. Reset it first so we don't end up with a
+      // pre-existing array plus appended ids.
+      newBlock.contentIds = [];
       this.reparentChildren(oldContentIds, newBlock.id);
-      newBlock.contentIds = oldContentIds;
     }
 
     return newBlock;
@@ -684,15 +812,61 @@ export class BlockOperations {
    * @param blocksStore - The blocks store to modify
    */
   public async mergeBlocks(targetBlock: Block, blockToMerge: Block, blocksStore: BlocksStore): Promise<void> {
+    /**
+     * Layer 17: stale-source guard (regression: wrong-block-dropped family).
+     *
+     * `mergeBlocks` awaits `blockToMerge.data` (and `blockToMerge.exportDataAsString`
+     * in the conversion path), then re-awaits `targetBlock.data` inside
+     * `completeMerge`. During those awaits, either block can be removed by a
+     * Yjs remote delete, undo/redo, or a tool-conversion callback. The original
+     * code held closure references and used them unguarded after the awaits,
+     * which drove:
+     *   - `YjsManager.transact` + `updateBlockData(targetBlock.id, …)` against a
+     *     dead target id (silent no-op but still a mutation attempt)
+     *   - `targetBlock.mergeWith(mergeData).then(…)` on a destroyed Block where
+     *     `mergeWith` returns undefined → `.then` crash
+     *   - `removeBlock(blockToMerge, …)` → `Can't find a Block to remove` thrown
+     *     inside a `void ... .then(...)` chain → unhandled rejection
+     *   - `currentBlockIndexValue = getBlockIndex(targetBlock)` → -1, corrupting
+     *     caret state downstream
+     *
+     * Verify both blocks are still in the store before starting and also before
+     * each mutation step so a remote delete during any of the awaits aborts
+     * cleanly rather than propagating the stale reference into Yjs and the DOM.
+     */
+    if (
+      this.repository.getBlockIndex(targetBlock) === -1 ||
+      this.repository.getBlockIndex(blockToMerge) === -1
+    ) {
+      return;
+    }
+
     /**
      * Complete the merge operation with the prepared data
      * Syncs to Yjs atomically, then updates DOM without re-syncing
      */
     const completeMerge = async (mergeData: BlockToolData): Promise<void> => {
+      // Layer 17 re-check: post-await staleness window. Both blocks must still
+      // be in the store, otherwise abort before any Yjs/DOM mutation.
+      if (
+        this.repository.getBlockIndex(targetBlock) === -1 ||
+        this.repository.getBlockIndex(blockToMerge) === -1
+      ) {
+        return;
+      }
+
       // Get current target data to compute merged result for Yjs
       const targetData = await targetBlock.data;
       const mergedData = { ...targetData, ...mergeData };
 
+      // Layer 17 re-check after the second await.
+      if (
+        this.repository.getBlockIndex(targetBlock) === -1 ||
+        this.repository.getBlockIndex(blockToMerge) === -1
+      ) {
+        return;
+      }
+
       // Sync to Yjs atomically: update target + remove source as single undo entry
       this.dependencies.YjsManager.transact(() => {
         for (const [key, value] of Object.entries(mergedData)) {
@@ -957,7 +1131,7 @@ export class BlockOperations {
       this.hierarchy.setBlockParent(newBlock, parentId);
 
       return newBlock;
-    });
+    }, { extendThroughRAF: true });
   }
 
   /**
@@ -1033,11 +1207,27 @@ export class BlockOperations {
     replace = false,
     blocksStore: BlocksStore
   ): Promise<Block> {
-    // Capture predecessor's parentId BEFORE insert (for non-replace, the
-    // predecessor is the current block; its parentId should be inherited).
-    const predecessorParentId = !replace
-      ? this.currentBlock?.parentId ?? null
-      : null;
+    // Capture predecessor's parentId and id BEFORE insert. The predecessor is
+    // the current block — whether we're replacing it in place or inserting
+    // after it, the new block belongs to the same parent. Without this, pasting
+    // into a nested empty block (e.g. a paragraph inside a callout) via the
+    // replace=true path strands the new block as a root sibling once Saver
+    // re-derives content[] from live parentIds.
+    //
+    // Title-vs-child defense: when the caret is in the CONTAINER's own title
+    // input (the header of a toggle/callout) rather than inside one of its
+    // children, the new block should become a CHILD of the container — its
+    // parent must be the container's id, NOT the container's parentId.
+    // Mirrors the `contextParentId` logic in BasePasteHandler.insertPasteData
+    // and BlokDataHandler so all paste entry points agree.
+    const currentBlock = this.currentBlock;
+    const childContainer = currentBlock?.holder?.querySelector('[data-blok-toggle-children]') ?? null;
+    const isInContainerTitle = childContainer !== null &&
+      !childContainer.contains(currentBlock?.currentInput ?? null);
+    const predecessorParentId = isInContainerTitle
+      ? (currentBlock?.id ?? null)
+      : (currentBlock?.parentId ?? null);
+    const oldBlockId = replace ? currentBlock?.id : undefined;
 
     // Insert block without syncing to Yjs yet.
     // Wrap in atomic operation so that child blocks created during rendered()
@@ -1066,9 +1256,16 @@ export class BlockOperations {
       block.refreshToolRootElement();
     });
 
-    // Inherit parentId from predecessor for non-replace inserts.
-    if (!replace && predecessorParentId !== null) {
-      this.hierarchy.setBlockParent(block, predecessorParentId);
+    // Wire the new block into the predecessor's parent BEFORE the Yjs addBlock
+    // call below so Yjs sees the final parentId in one shot. For replace we
+    // route through `transferParentLinkToNewBlock` which swaps the old id for
+    // the new id inside the parent's contentIds while preserving position.
+    if (predecessorParentId !== null) {
+      if (replace && oldBlockId !== undefined) {
+        this.transferParentLinkToNewBlock(oldBlockId, block, predecessorParentId);
+      } else {
+        this.hierarchy.setBlockParent(block, predecessorParentId);
+      }
     }
 
     // Sync final state to Yjs as single operation

package/src/components/modules/blockManager/types.ts

@@ -54,6 +54,12 @@ export interface InsertBlockOptions {
   skipYjsSync?: boolean;
   /** When true, append block to workingArea instead of positioning relative to adjacent blocks */
   appendToWorkingArea?: boolean;
+  /**
+   * When true, force DOM placement at workingArea root level even if the previous block
+   * in the flat array is nested. Prevents the Enter-after-callout regression family where
+   * a top-level insertion would otherwise land inside a nested container.
+   */
+  forceTopLevel?: boolean;
 }
 
 /**
@@ -111,7 +117,13 @@ export interface ConvertBlockOptions {
  */
 export type BlocksStore = Blocks & {
   [index: number]: Block | undefined;
-  insert(index: number, block: Block, replace?: boolean, appendToWorkingArea?: boolean): void;
+  insert(
+    index: number,
+    block: Block,
+    replace?: boolean,
+    appendToWorkingArea?: boolean,
+    forceTopLevel?: boolean
+  ): void;
   remove(index: number): void;
   move(toIndex: number, fromIndex: number, skipDOM?: boolean, skipMovedHook?: boolean): void;
 };