The Seed editor is a fork of BlockNote living in frontend/packages/editor/src/blocknote/. The upstream BlockNote ships a Table block built on prosemirror-tables, but our fork was before it was implemented.

Tables are now one of the biggest gaps in our editor. They show up in PDFs, in pasted Markdown, in copied web content, and in any document that needs to present a small dataset. We currently drop them on import.

Add Table, TableRow, and TableColumn to BlockNode schema. A Table block contains both TableRow children and TableColumn children. Blocks live inside a TableRow and carry a columnId attribute referencing its TableColumn by ID.

• Row order is determined by the order of TableRow blocks under the Table.

• Column order is determined by the order of TableColumn blocks under the Table.

• A cell's position is its row (parent) and its columnId (reference). The physical order of cells inside a row is ignored, but we do apply move operations to them (see )

New schema code:

export const HMBlockTableSchema = z.object({
  type: z.literal('Table'),
  ...blockBaseProperties,
  attributes: z.object({
    ...parentBlockAttributes,
  }).optional().default({}),
}).strict()

export const HMBlockTableRowSchema = z.object({
  type: z.literal('TableRow'),
  ...blockBaseProperties,
  attributes: z.object({
    ...parentBlockAttributes,
    isHeader: z.boolean().optional().default(false), // header row
  }).optional().default({}),
}).strict()

export const HMBlockTableColumnSchema = z.object({
  type: z.literal('TableColumn'),
  ...blockBaseProperties,
  attributes: z.object({
    ...parentBlockAttributes,
    width: z.number().optional(), // px or %
    isHeader: z.boolean().optional().default(false), // header column
  }).optional().default({}),
}).strict()

Pros:

• Concurrent edits don't corrupt the table. Reordering columns is a single MoveBlock op on a TableColumn. Adding a row is a single MoveBlock insert of a TableRow with cells. If both happen at the same time, both succeed and the cells still land under the correct columns (cells reference columns by ID, not by position).

• Each cell is an existing block type with its own ID, text, and annotations.

• Column metadata (width, isHeader) lives on TableColumn blocks, which means concurrent column resize is a single attribute edit on a single block. Header columns are supported by the same mechanism as header rows.

• Stable cell IDs survive insert/delete/reorder, which keeps comments, version diffs, and per-cell permalinks sensible.

Cons:

• Three new entries in HMBlockKnownSchema and four new converter cases.

• Larger block count for table-heavy documents (a 10×10 table = 1 + 10 + 100 = 111 blocks). Need to confirm this doesn't blow up indexing or render performance.

• Heterogeneous Table.children (mix of TableRow and TableColumn blocks) is a small break from the "every parent has one kind of child" intuition.

• prosemirror-tables operates on physical row/column indexes, not column IDs. We need to extend the vendored TipTap extension so cells carry columnId in PM attrs, and so column-insert/move/delete commands mint and move TableColumn blocks accordingly.

• Light corruption is possible if a column is deleted concurrently with a cell being added that references it. The cell is "orphaned" and won't render. We normalize on read (drop orphans) and accept this as a rare edge case.

• Slash menu: "Table" inserts a 3×3 empty table.

• Floating toolbar/menu (when inside a cell): add row above/below, add column left/right, delete row, delete column, toggle header row, delete table. These map to prosemirror-tables commands. (Needs designs!)

• Column resize: drag handle on cell borders writes to the TableColumn block's width attribute. CSS from prosemirror-tables/style/tables.css and Tailwind overrides to match our theme.

• Mobile / narrow viewport: wrap the table in a horizontally-scrollable container (overflow-x-auto) so it never breaks the document layout.

Because readonly-viewer.tsx initializes the same BlockNote editor in editable: false mode, our React block spec renders identically in published view.

The only packages/ui/ change is to make sure blocks-content-utils.tsx tree traversal recognizes Table descendants and walks through both TableRow and TableColumn children.

Because Approach A makes each cell its own block with its own text and annotations, quote ranges land cell-scoped for free. For example, quoting "the third cell of the second row" is a quote range inside TableCell's text. No new range model needed.

Cross-cell quoting ("from cell A2 to cell B3") is explicitly out of scope. This matches how we handle quotes that cross block boundaries today (we don't).

I'd cut this in three PRs, each landable independently, ramping risk:

• Add HMBlockTableSchema, HMBlockTableRowSchema, HMBlockTableColumnSchema, HMBlockTableCellSchema to hm-types.ts.

• Add converters in both directions (including normalization of orphans/missing cells on read).

• Add @tiptap/extension-table dependency (similar to link and code-block) and add the columnId attribute extension on the cell node.

• Add TableBlock React spec, register in schema.ts and full-schema.ts.

• Read-only rendering works in readonly-viewer.tsx because of the shared block spec.

• Slash-menu insert (a default 3×3 table is enough to test the rest).

• Tests: roundtrip, Zod validation, snapshot of read-only render, normalization (orphaned cells dropped, missing cells filled).

• Floating cell menu (add/remove row/col, toggle header, delete table). (Again needs designs)

• Column resize writes to TableColumn.width.

• Backspace to delete empty table.

• Tab/Shift-Tab navigation.

• The columnID aware commands (insert/delete/move) maintain TableColumn blocks and propagate columnId.

• Tests: editor commands (insert, addRow, addColumn, delete), Playwright E2E for cell selection and resize.

• Markdown GFM paste/parse and export.

• HTML paste.

• PDF import LLM schema extension.

• Tests: paste fixtures (Google Docs, Notion), Markdown roundtrip.

Explicit no-goes (defer to later):

• Nested blocks inside cells (images, embeds, code, sub-tables). Initially, cells are inline only, which matches BlockNote upstream's tableParagraph constraint.

• Cell-level styling (per-cell background, alignment overrides). Header-row and header-column styling are the only differentiation.

• colspan / rowspan merging. Adding optional Zod fields later is backward-compatible, so we add them when we add merging UI.

• Sorting, filtering, formulas.

• Cross-cell comment/quote ranges. Quotes will be cell-scoped.

• Multiple children and nested groups in a table cell.