@jackuait/blok 0.10.6 → 0.10.8

package/dist/chunks/{constants-lOEJu8bC.mjs → constants-BoE5frJm.mjs}

@@ -130,7 +130,7 @@ var a = {
 	RIGHT: 2,
 	BACKWARD: 3,
 	FORWARD: 4
-}, l = () => "0.10.6", u = /* @__PURE__ */ function(e) {
+}, l = () => "0.10.8", u = /* @__PURE__ */ function(e) {
 	return e.VERBOSE = "VERBOSE", e.INFO = "INFO", e.WARN = "WARN", e.ERROR = "ERROR", e;
 }({}), d = (e, t, n = "log", r, i = "color: inherit") => {
 	let a = typeof console > "u" ? void 0 : console;

package/dist/chunks/{core-C942GvJO.mjs → core-B7mxBIHA.mjs}

@@ -1,6 +1,6 @@
 import { r as e } from "./chunk-D6kmoKXy.mjs";
 import { n as t, t as n } from "./objectSpread2-CWwMYL_U.mjs";
-import { t as r } from "./objectWithoutProperties-D0XxKB4n.mjs";
+import { t as r } from "./objectWithoutProperties-Dci1-l7D.mjs";
 import { t as i } from "./ccount-C9Y7nqDe.mjs";
 //#region node_modules/zwitch/index.js
 var a = {}.hasOwnProperty;

package/dist/chunks/{engine-javascript-Dd6ViPCH.mjs → engine-javascript-Bmmg8uL9.mjs}

@@ -1,5 +1,5 @@
 import { n as e, t } from "./objectSpread2-CWwMYL_U.mjs";
-import { t as n } from "./objectWithoutProperties-D0XxKB4n.mjs";
+import { t as n } from "./objectWithoutProperties-Dci1-l7D.mjs";
 //#region node_modules/@shikijs/engine-javascript/dist/scanner-BFcBmQR1.mjs
 var r = 4294967295, i = class {
 	constructor(t, n = {}) {

package/dist/chunks/{i18next-loader-CIXsptng.mjs → i18next-loader-453gJdot.mjs}

@@ -1,4 +1,4 @@
-import { n as e } from "./lightweight-i18n-DTYoSr_o.mjs";
+import { n as e } from "./lightweight-i18n-DSjG0iTr.mjs";
 //#region src/components/i18n/i18next-loader.ts
 var t = async (t, n) => {
 	let r = (await import("./i18next-CLUkHqmV.mjs")).default.createInstance(), i = {

package/dist/chunks/{tools-FmtWXVgt.mjs → tools-HQPJLj5m.mjs}

@@ -1,4 +1,4 @@
-import { $ as e, $t as t, A as n, At as r, B as i, Bt as a, Ct as o, D as s, Et as c, F as l, Ft as u, G as d, Gt as f, H as p, Ht as m, I as h, It as g, J as _, Jt as v, K as y, Kt as b, L as ee, Lt as x, M as te, Mt as S, Nn as ne, Nt as re, O as ie, Ot as C, P as ae, Pt as oe, Q as se, Qt as ce, R as le, Rn as w, Rt as ue, St as de, Tt as fe, U as pe, Ut as me, V as he, W as ge, Wt as _e, X as ve, Xt as ye, Y as be, Yt as xe, Z as Se, Zt as Ce, _n as we, _t as Te, a as Ee, at as De, bt as Oe, c as ke, cn as T, ct as Ae, d as je, dr as E, dt as Me, en as Ne, et as Pe, f as Fe, ft as Ie, g as Le, gt as Re, h as ze, ht as Be, i as Ve, ir as He, it as Ue, j as We, jt as Ge, k as Ke, kt as qe, l as Je, ln as Ye, lt as Xe, mn as Ze, mt as Qe, n as $e, nt as et, o as tt, ot as nt, p as rt, pn as D, pt as it, q as at, qt as ot, r as st, rn as ct, rt as lt, s as ut, sn as dt, st as ft, t as pt, tt as mt, u as O, un as ht, ur as k, ut as gt, v as _t, vn as vt, vt as yt, wt as bt, xt, z as St, zt as Ct } from "./constants-lOEJu8bC.mjs";
+import { $ as e, $t as t, A as n, At as r, B as i, Bt as a, Ct as o, D as s, Et as c, F as l, Ft as u, G as d, Gt as f, H as p, Ht as m, I as h, It as g, J as _, Jt as v, K as y, Kt as b, L as ee, Lt as x, M as te, Mt as S, Nn as ne, Nt as re, O as ie, Ot as C, P as ae, Pt as oe, Q as se, Qt as ce, R as le, Rn as w, Rt as ue, St as de, Tt as fe, U as pe, Ut as me, V as he, W as ge, Wt as _e, X as ve, Xt as ye, Y as be, Yt as xe, Z as Se, Zt as Ce, _n as we, _t as Te, a as Ee, at as De, bt as Oe, c as ke, cn as T, ct as Ae, d as je, dr as E, dt as Me, en as Ne, et as Pe, f as Fe, ft as Ie, g as Le, gt as Re, h as ze, ht as Be, i as Ve, ir as He, it as Ue, j as We, jt as Ge, k as Ke, kt as qe, l as Je, ln as Ye, lt as Xe, mn as Ze, mt as Qe, n as $e, nt as et, o as tt, ot as nt, p as rt, pn as D, pt as it, q as at, qt as ot, r as st, rn as ct, rt as lt, s as ut, sn as dt, st as ft, t as pt, tt as mt, u as O, un as ht, ur as k, ut as gt, v as _t, vn as vt, vt as yt, wt as bt, xt, z as St, zt as Ct } from "./constants-BoE5frJm.mjs";
 import { t as A } from "./objectSpread2-CWwMYL_U.mjs";
 import { n as j } from "./tw-CqxBf-1Y.mjs";
 //#region src/components/utils/html.ts
@@ -3075,7 +3075,7 @@ var Ir = (e) => {
 					let e = n.blocks.getBlockIndex(t);
 					if (e === void 0) continue;
 					let i = n.blocks.getBlockByIndex(e);
-					if (i && i.parentId === r) {
+					if (i && !(i.parentId !== null && i.parentId !== void 0 && i.parentId !== r)) {
 						if (i.holder.closest(`[${k.nestedBlocks}]`)) {
 							s.appendChild(i.holder.cloneNode(!0));
 							continue;
@@ -9051,7 +9051,7 @@ function ec(e) {
 }
 async function tc() {
 	return $s.highlighterPromise || ($s.highlighterPromise = (async () => {
-		let { createHighlighterCore: e } = await import("./core-C942GvJO.mjs"), { createJavaScriptRegexEngine: t } = await import("./engine-javascript-Dd6ViPCH.mjs"), n = await e({
+		let { createHighlighterCore: e } = await import("./core-B7mxBIHA.mjs"), { createJavaScriptRegexEngine: t } = await import("./engine-javascript-Bmmg8uL9.mjs"), n = await e({
 			themes: [import("./one-light-Di_o5Kb7.mjs"), import("./vitesse-dark-B5oAIYZ5.mjs")],
 			langs: [],
 			engine: t()

package/dist/full.mjs

@@ -1,7 +1,7 @@
-import { n as e, t } from "./chunks/blok-B0k4z2h1.mjs";
-import { ur as n } from "./chunks/constants-lOEJu8bC.mjs";
+import { n as e, t } from "./chunks/blok-ClCrnWuI.mjs";
+import { ur as n } from "./chunks/constants-BoE5frJm.mjs";
 import { t as r } from "./chunks/objectSpread2-CWwMYL_U.mjs";
-import { a as i, b as a, c as o, g as s, i as c, l, n as u, o as d, s as f, t as p, v as m, y as h } from "./chunks/tools-FmtWXVgt.mjs";
+import { a as i, b as a, c as o, g as s, i as c, l, n as u, o as d, s as f, t as p, v as m, y as h } from "./chunks/tools-HQPJLj5m.mjs";
 //#region src/full.ts
 var g = {
 	paragraph: {

package/dist/react.mjs

@@ -1,7 +1,7 @@
-import { t as e } from "./chunks/blok-B0k4z2h1.mjs";
-import "./chunks/constants-lOEJu8bC.mjs";
+import { t as e } from "./chunks/blok-ClCrnWuI.mjs";
+import "./chunks/constants-BoE5frJm.mjs";
 import { t } from "./chunks/objectSpread2-CWwMYL_U.mjs";
-import { t as n } from "./chunks/objectWithoutProperties-D0XxKB4n.mjs";
+import { t as n } from "./chunks/objectWithoutProperties-Dci1-l7D.mjs";
 import { forwardRef as r, useEffect as i, useMemo as a, useRef as o, useState as s } from "react";
 import { jsx as c } from "react/jsx-runtime";
 //#region src/react/holder-map.ts

package/dist/tools.mjs

@@ -1,3 +1,3 @@
-import { m as e } from "./chunks/constants-lOEJu8bC.mjs";
-import { _ as t, a as n, b as r, c as i, d as a, f as o, g as s, h as c, i as l, l as u, m as d, n as f, o as p, p as m, r as h, s as g, t as _, u as v, v as y, y as b } from "./chunks/tools-FmtWXVgt.mjs";
+import { m as e } from "./chunks/constants-BoE5frJm.mjs";
+import { _ as t, a as n, b as r, c as i, d as a, f as o, g as s, h as c, i as l, l as u, m as d, n as f, o as p, p as m, r as h, s as g, t as _, u as v, v as y, y as b } from "./chunks/tools-HQPJLj5m.mjs";
 export { u as Bold, c as Callout, v as Code, e as Convert, d as Database, m as DatabaseRow, o as Divider, b as Header, h as InlineCode, i as Italic, g as Link, y as List, p as Marker, r as Paragraph, a as Quote, l as Strikethrough, t as Table, s as Toggle, n as Underline, _ as defaultBlockTools, f as defaultInlineTools };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jackuait/blok",
-  "version": "0.10.6",
+  "version": "0.10.8",
   "description": "Blok — headless, highly extensible rich text editor built for developers who need to implement a block-based editing experience (similar to Notion) without building it from scratch",
   "module": "dist/blok.mjs",
   "types": "./types/index.d.ts",

package/src/components/modules/api/blocks.ts

@@ -7,6 +7,7 @@ import { Module } from '../../__module';
 import { Block } from '../../block';
 import { BlockAPI } from '../../block/api';
 import { capitalize } from '../../utils';
+import { normalizeTableChildParents } from '../../utils/data-model-transform';
 
 import { logLabeled } from './../../utils';
 
@@ -401,11 +402,23 @@ export class BlocksAPI extends Module {
   ): BlockAPIInterface[] => {
     this.validateIndex(index);
 
-    const blocksToInsert = blocks.map(({ id, type, data }) => {
+    // Backfill `parent` on children referenced by table cells so that
+    // alternative load paths (any consumer of the public API) get the
+    // same hierarchical correctness as Renderer.render(). Without this,
+    // flat-array article shapes lose their cell→child relationship and
+    // children render as detached top-level blocks.
+    const normalizedBlocks = normalizeTableChildParents(blocks);
+
+    const blocksToInsert = normalizedBlocks.map(({ id, type, data, tunes, parent, content, lastEditedAt, lastEditedBy }) => {
       return this.Blok.BlockManager.composeBlock({
         id,
         tool: type || (this.config.defaultBlock as string),
         data: data as BlockToolData,
+        tunes,
+        parentId: parent,
+        contentIds: content,
+        lastEditedAt,
+        lastEditedBy,
       });
     });
     

package/src/components/modules/paste/handlers/blok-data-handler.ts

@@ -142,10 +142,17 @@ export class BlokDataHandler extends BasePasteHandler implements PasteHandler {
    * accumulated old→new ID mapping.
    */
   private insertBlokBlocks(
-    blocks: BlokClipboardBlock[],
+    rawBlocks: BlokClipboardBlock[],
     canReplace: boolean
   ): void {
     const { BlockManager, Caret, Tools } = this.Blok;
+
+    // Some article shapes (e.g. flat-array exports) reference table children
+    // ONLY via `data.content[r][c].blocks = [<id>]` and never set parentId
+    // on the children themselves. Backfill parentId before classification so
+    // those children get adopted by the table during the two-pass insert
+    // instead of becoming detached top-level paragraphs.
+    const blocks = backfillTableChildParents(rawBlocks);
     const sanitizedBlocks = sanitizeBlocks(
       blocks,
       (name) => Tools.blockTools.get(name)?.sanitizeConfig ?? {},
@@ -243,6 +250,91 @@ export class BlokDataHandler extends BasePasteHandler implements PasteHandler {
   }
 }
 
+/**
+ * Records each cell-referenced child id under its owning table.
+ */
+function collectCellChildIds(
+  cell: unknown,
+  tableId: string,
+  childToTable: Map<string, string>
+): void {
+  if (
+    typeof cell !== 'object' ||
+    cell === null ||
+    !Array.isArray((cell as { blocks?: unknown }).blocks)
+  ) {
+    return;
+  }
+  const ids = (cell as { blocks: unknown[] }).blocks;
+
+  ids.forEach(childId => {
+    if (typeof childId === 'string' && !childToTable.has(childId)) {
+      childToTable.set(childId, tableId);
+    }
+  });
+}
+
+/**
+ * Walks a clipboard table block's `data.content[r][c]` cells and records
+ * every child id referenced by `cell.blocks` under its owning table.
+ */
+function collectTableCellRefs(
+  block: BlokClipboardBlock,
+  childToTable: Map<string, string>
+): void {
+  if (block.tool !== 'table' || block.id === undefined) {
+    return;
+  }
+  const data = block.data as { content?: unknown } | undefined;
+  const content = data?.content;
+
+  if (!Array.isArray(content)) {
+    return;
+  }
+
+  const tableId = block.id;
+
+  content.forEach(row => {
+    if (!Array.isArray(row)) {
+      return;
+    }
+    row.forEach(cell => collectCellChildIds(cell, tableId, childToTable));
+  });
+}
+
+/**
+ * Backfills `parentId` on clipboard blocks that are referenced by a sibling
+ * table's `data.content[r][c].blocks` array but never declare a parent of
+ * their own. Idempotent — never overwrites an explicit parentId.
+ */
+function backfillTableChildParents(
+  blocks: BlokClipboardBlock[]
+): BlokClipboardBlock[] {
+  const childToTable = new Map<string, string>();
+
+  blocks.forEach(block => collectTableCellRefs(block, childToTable));
+
+  if (childToTable.size === 0) {
+    return blocks;
+  }
+
+  return blocks.map(block => {
+    if (block.id === undefined) {
+      return block;
+    }
+    const tableId = childToTable.get(block.id);
+
+    if (tableId === undefined) {
+      return block;
+    }
+    if (block.parentId !== undefined && block.parentId !== null) {
+      return block;
+    }
+
+    return { ...block, parentId: tableId };
+  });
+}
+
 /**
  * Recursively walks `value` and replaces any string found as a key in `idMap`
  * with its mapped value.  Used to remap old block IDs to new IDs within a

package/src/components/modules/renderer.ts

@@ -7,6 +7,7 @@ import { generateBlockId, log, logLabeled } from '../utils';
 import {
   analyzeDataFormat,
   expandToHierarchical,
+  normalizeTableChildParents,
   shouldExpandToHierarchical,
   type DataFormatAnalysis,
 } from '../utils/data-model-transform';
@@ -88,10 +89,17 @@ export class Renderer extends Module {
         this.detectedInputFormat = analysis.format;
 
         // Transform to hierarchical if config requires it
-        const processedBlocks = shouldExpandToHierarchical(dataModelConfig, analysis.format)
+        const expandedBlocks = shouldExpandToHierarchical(dataModelConfig, analysis.format)
           ? expandToHierarchical(blocksData)
           : blocksData;
 
+        // Tables persist child references via `data.content[r][c].blocks = [<id>]`
+        // rather than an explicit `parent` field on each child. Pre-normalize
+        // those parent references so downstream code that gates on parentId
+        // (read-only cell mounter, saver filter, hierarchy queries) correctly
+        // recognizes the children as belonging to their table.
+        const processedBlocks = normalizeTableChildParents(expandedBlocks);
+
         // Note: Yjs data layer is loaded via BlockManager.insertMany() with the correct block IDs
 
         /**

package/src/components/modules/themeManager.ts

@@ -42,7 +42,7 @@ export class ThemeManager extends Module {
   public prepare(): void {
     state.activeInstances++;
     this.mode = this.config.theme ?? 'auto';
-    this.applyAttribute();
+    this.applyAttribute(false);
     this.resolved = this.deriveResolved();
 
     if (this.mode === 'auto') {
@@ -75,7 +75,7 @@ export class ThemeManager extends Module {
     }
 
     this.mode = mode;
-    this.applyAttribute();
+    this.applyAttribute(true);
     this.resolved = this.deriveResolved();
 
     if (this.mode === 'auto') {
@@ -102,7 +102,14 @@ export class ThemeManager extends Module {
 
   // ─── Private ───────────────────────────────────────────────────────────────
 
-  private applyAttribute(): void {
+  /**
+   * @param explicit - true when called from setMode() (consumer API);
+   *                   false when called from prepare() (initial construction).
+   *                   During prepare(), skip setting the attribute if another
+   *                   instance already controls it — prevents nested editors
+   *                   (e.g. inside Columns) from overriding the parent theme.
+   */
+  private applyAttribute(explicit: boolean): void {
     if (typeof document === 'undefined') {
       return;
     }
@@ -112,6 +119,9 @@ export class ThemeManager extends Module {
         this.removeAttribute();
       }
     } else {
+      if (!explicit && state.activeInstances > 1 && document.documentElement.hasAttribute(ATTR)) {
+        return;
+      }
       document.documentElement.setAttribute(ATTR, this.mode);
     }
   }

package/src/components/utils/data-model-transform.ts

@@ -368,6 +368,45 @@ const expandListToHierarchical = (
   return blocks;
 };
 
+/**
+ * Recursively expand a list of legacy body blocks into hierarchical flat blocks.
+ * Each body block is routed through expandToHierarchical so that nested legacy
+ * toggleList/callout/list structures are fully flattened instead of passing
+ * through with their legacy type (which would hit Renderer's "unknown tool"
+ * fallback and render as a stub).
+ *
+ * Returns both the direct-child IDs (for the parent's `content` array) and
+ * the flattened descendant blocks in document order.
+ * @param bodyBlocks - legacy body blocks to expand
+ * @param parentId - id of the parent block (toggle/callout) that owns them
+ */
+const expandLegacyBodyBlocks = (
+  bodyBlocks: OutputBlockData[],
+  parentId: BlockId
+): { childIds: BlockId[]; childBlocks: OutputBlockData[] } => {
+  const childIds: BlockId[] = [];
+  const childBlocks: OutputBlockData[] = [];
+
+  for (const childBlock of bodyBlocks) {
+    const expanded = expandToHierarchical([childBlock]);
+
+    if (expanded.length === 0) {
+      continue;
+    }
+
+    // The first emitted block corresponds to the original input block.
+    // Re-parent it to the legacy container; descendants already carry the
+    // correct parent refs assigned during their own recursive expansion.
+    const [first, ...rest] = expanded;
+    const childId = first.id ?? generateBlockId();
+
+    childIds.push(childId);
+    childBlocks.push({ ...first, id: childId, parent: parentId }, ...rest);
+  }
+
+  return { childIds, childBlocks };
+};
+
 /**
  * Expand a legacy toggleList block into flat toggle block + child blocks
  */
@@ -378,20 +417,7 @@ const expandToggleListToHierarchical = (
   const toggleId = block.id ?? generateBlockId();
   const bodyBlocks = block.data.body?.blocks ?? [];
 
-  // Collect child IDs, ensuring each child has an ID
-  const childIds: BlockId[] = [];
-  const childBlocks: OutputBlockData[] = [];
-
-  for (const childBlock of bodyBlocks) {
-    const childId = childBlock.id ?? generateBlockId();
-
-    childIds.push(childId);
-    childBlocks.push({
-      ...childBlock,
-      id: childId,
-      parent: toggleId,
-    });
-  }
+  const { childIds, childBlocks } = expandLegacyBodyBlocks(bodyBlocks, toggleId);
 
   const sharedFields = {
     id: toggleId,
@@ -439,20 +465,7 @@ const expandCalloutToHierarchical = (
   const calloutId = block.id ?? generateBlockId();
   const bodyBlocks = block.data.body?.blocks ?? [];
 
-  // Collect child IDs, ensuring each child has an ID
-  const childIds: BlockId[] = [];
-  const childBlocks: OutputBlockData[] = [];
-
-  for (const childBlock of bodyBlocks) {
-    const childId = childBlock.id ?? generateBlockId();
-
-    childIds.push(childId);
-    childBlocks.push({
-      ...childBlock,
-      id: childId,
-      parent: calloutId,
-    });
-  }
+  const { childIds, childBlocks } = expandLegacyBodyBlocks(bodyBlocks, calloutId);
 
   // Map variant → backgroundColor preset
   const variant = block.data.variant ?? 'general';
@@ -905,6 +918,131 @@ export const collapseToLegacy = (blocks: OutputBlockData[]): OutputBlockData[] =
   return result;
 };
 
+/**
+ * A table cell that references its content blocks by id.
+ * Tables persist their child blocks via `data.content[row][col].blocks = [<id>, ...]`
+ * rather than nesting block payloads inline, so the parent/content relationship
+ * is implicit in the table data instead of explicit on each child block.
+ */
+interface CellWithBlockRefs {
+  blocks: string[];
+}
+
+const isCellWithBlockRefs = (cell: unknown): cell is CellWithBlockRefs => {
+  return (
+    typeof cell === 'object' &&
+    cell !== null &&
+    Array.isArray((cell as { blocks?: unknown }).blocks)
+  );
+};
+
+interface TableDataShape {
+  content?: unknown;
+}
+
+const getTableContentRows = (data: unknown): unknown[][] | null => {
+  if (typeof data !== 'object' || data === null) {
+    return null;
+  }
+  const content = (data as TableDataShape).content;
+
+  if (!Array.isArray(content)) {
+    return null;
+  }
+  return content as unknown[][];
+};
+
+/**
+ * When a flat block array contains `table` blocks that reference child blocks
+ * via `data.content[row][col].blocks = [<id>, ...]`, ensure each referenced
+ * child carries `parent: <tableId>`. This makes the parent/content invariant
+ * explicit even for externally-authored data shapes that omit the `parent`
+ * field on children.
+ *
+ * Without this normalization, downstream readers that key on parentId
+ * (`mountCellBlocksReadOnly`'s cross-table guard, the table saver's
+ * own-child filter, hierarchy queries, drag-and-drop) skip those children
+ * and leak them out of the table, rendering them at the bottom of the page
+ * instead of inside the cells.
+ *
+ * The function is idempotent, never mutates the input array, and leaves
+ * pre-existing `parent` fields unchanged. Children referenced by multiple
+ * tables get assigned to the first table that lists them (first-writer-wins);
+ * corrupted cross-table references are preserved as-is so defensive guards
+ * downstream can still reject them.
+ * @param blocks - flat block array potentially containing tables with cell refs
+ */
+const collectCellChildRefs = (
+  cell: unknown,
+  tableId: BlockId,
+  childToTable: Map<BlockId, BlockId>
+): void => {
+  if (!isCellWithBlockRefs(cell)) {
+    return;
+  }
+  for (const childId of cell.blocks) {
+    if (typeof childId !== 'string' || childToTable.has(childId)) {
+      continue;
+    }
+    childToTable.set(childId, tableId);
+  }
+};
+
+const collectRowChildRefs = (
+  row: unknown,
+  tableId: BlockId,
+  childToTable: Map<BlockId, BlockId>
+): void => {
+  if (!Array.isArray(row)) {
+    return;
+  }
+  row.forEach(cell => collectCellChildRefs(cell, tableId, childToTable));
+};
+
+const collectTableChildRefs = (
+  tableBlock: OutputBlockData,
+  childToTable: Map<BlockId, BlockId>
+): void => {
+  if (tableBlock.id === undefined || tableBlock.id === null) {
+    return;
+  }
+  const rows = getTableContentRows(tableBlock.data);
+
+  if (rows === null) {
+    return;
+  }
+  const tableId = tableBlock.id;
+
+  rows.forEach(row => collectRowChildRefs(row, tableId, childToTable));
+};
+
+export const normalizeTableChildParents = (blocks: OutputBlockData[]): OutputBlockData[] => {
+  const childToTable = new Map<BlockId, BlockId>();
+
+  blocks
+    .filter(block => block.type === 'table')
+    .forEach(tableBlock => collectTableChildRefs(tableBlock, childToTable));
+
+  if (childToTable.size === 0) {
+    return blocks;
+  }
+
+  return blocks.map(block => {
+    if (block.id === undefined || block.id === null) {
+      return block;
+    }
+    const tableId = childToTable.get(block.id);
+
+    if (tableId === undefined) {
+      return block;
+    }
+    if (block.parent !== undefined && block.parent !== null) {
+      return block;
+    }
+    return { ...block, parent: tableId };
+  });
+};
+
 /**
  * Check if transformation is needed based on config and detected format
  */

package/src/markdown/markdown-handler.ts

@@ -6,6 +6,7 @@ import type { HandlerContext } from '../components/modules/paste/types';
 import type { PasteHandler } from '../components/modules/paste/handlers/base';
 import { BasePasteHandler } from '../components/modules/paste/handlers/base';
 import { Block } from '../components/block';
+import { normalizeTableChildParents } from '../components/utils/data-model-transform';
 
 /**
  * Patterns that indicate text is likely Markdown rather than plain text.
@@ -66,12 +67,18 @@ export class MarkdownHandler extends BasePasteHandler implements PasteHandler {
     }
 
     const { markdownToBlocks } = await import('./index');
-    const outputBlocks = await markdownToBlocks(data);
+    const rawOutputBlocks = await markdownToBlocks(data);
 
-    if (!outputBlocks.length) {
+    if (!rawOutputBlocks.length) {
       return false;
     }
 
+    // Defense-in-depth: backfill `parent` on table cell children so that any
+    // future regression in mdast-to-blocks (or external converter) cannot
+    // produce the dodopizza shape (children referenced by table cells but
+    // lacking explicit parent), which would render them at page bottom.
+    const outputBlocks = normalizeTableChildParents(rawOutputBlocks);
+
     const { BlockManager, Caret } = this.Blok;
 
     // Replace empty default block if present

package/src/tools/table/table-operations.ts

@@ -326,10 +326,15 @@ export const mountCellBlocksReadOnly = (
           continue;
         }
 
-        // Skip blocks that don't belong to this table.
-        // Corrupted data may contain cross-table references; mounting them
-        // would steal (or clone) DOM nodes from the other table.
-        if (block.parentId !== _tableBlockId) {
+        // Skip blocks whose parentId explicitly points to a DIFFERENT table
+        // (corrupted cross-table references). Blocks with null/undefined
+        // parentId are accepted: legitimate flat-array data shapes (e.g. the
+        // dodopizza article format) reference children by id from
+        // `cell.blocks` without setting `parent` on each child, and the
+        // Renderer's normalizeTableChildParents pre-step is the primary
+        // place that backfills parentId. This guard is defense-in-depth for
+        // load paths that bypass the Renderer (Yjs sync, direct insertion).
+        if (block.parentId !== null && block.parentId !== undefined && block.parentId !== _tableBlockId) {
           continue;
         }