diff --git a/AGENTS.md b/AGENTS.md
index 94ae91fca06..ec0c5726548 100644
--- a/AGENTS.md
+++ b/AGENTS.md
@@ -38,6 +38,7 @@ For E2E testing workflow:
 - `pnpm run prettier:fix` - Auto-fix formatting issues
 - `pnpm run flow` - Run a full foreground Flow check (does not reuse a server)
 - `pnpm run tsc` - Run TypeScript compiler
+- `pnpm run tsc-dev-examples` - Type-check each `dev-examples/*` app with its own tsconfig (the root `tsc` doesn't cover them)
 - `pnpm run ci-check` - Run all checks (TypeScript, Flow, Prettier, ESLint)
 
 **Never commit changes to `scripts/error-codes/codes.json`.**
diff --git a/dev-examples/dom-import/package.json b/dev-examples/dom-import/package.json
index 1def708f84b..40ed0ad05f4 100644
--- a/dev-examples/dom-import/package.json
+++ b/dev-examples/dom-import/package.json
@@ -6,6 +6,7 @@
   "scripts": {
     "dev": "vite",
     "build": "tsc && vite build",
+    "tsc": "tsc",
     "preview": "vite preview"
   },
   "dependencies": {
diff --git a/dev-examples/hmr/package.json b/dev-examples/hmr/package.json
index 38b949793fb..e7a519cef1a 100644
--- a/dev-examples/hmr/package.json
+++ b/dev-examples/hmr/package.json
@@ -6,6 +6,7 @@
   "scripts": {
     "dev": "vite",
     "build": "tsc && vite build",
+    "tsc": "tsc",
     "preview": "vite preview"
   },
   "dependencies": {
diff --git a/dev-examples/mdast-editor/package.json b/dev-examples/mdast-editor/package.json
index 967b7243fd9..b5ba116325f 100644
--- a/dev-examples/mdast-editor/package.json
+++ b/dev-examples/mdast-editor/package.json
@@ -6,6 +6,7 @@
   "scripts": {
     "dev": "vite",
     "build": "tsc && vite build",
+    "tsc": "tsc",
     "preview": "vite preview",
     "size": "node ./size/measure.mjs"
   },
@@ -24,6 +25,7 @@
     "@lexical/react": "workspace:*",
     "@lexical/rich-text": "workspace:*",
     "@lexical/selection": "workspace:*",
+    "@lexical/table": "workspace:*",
     "@lexical/utils": "workspace:*",
     "lexical": "workspace:*",
     "mdast-util-gfm-footnote": "^2.1.0",
diff --git a/dev-examples/mdast-editor/src/Editor.tsx b/dev-examples/mdast-editor/src/Editor.tsx
index f59224725bf..6e32787a657 100644
--- a/dev-examples/mdast-editor/src/Editor.tsx
+++ b/dev-examples/mdast-editor/src/Editor.tsx
@@ -70,6 +70,19 @@ Type \`[^another]\` to mint one.
 - [x] Syntax preserved via NodeState
 - [ ] Ship it
 
+## Tables
+
+GFM tables edit as \`@lexical/table\` nodes: Tab moves between cells, and
+the **Table** menu in the toolbar adds or removes rows and columns while
+the cursor is in one. A cell holds a single line in Markdown, so Enter in a
+cell becomes \`<br>\`:
+
+| Construct | Syntax | Notes |
+| :-- | :-: | --: |
+| Strikethrough | \`~~text~~\` | GFM |
+| Task list | \`- [ ] \` | GFM |
+| Line break | \`<br>\` | One line<br>per paragraph |
+
 ## Alerts
 
 GitHub-style alerts are plain blockquotes with a \`[!TYPE]\` marker: the
@@ -109,6 +122,10 @@ const editor = buildEditorFromExtensions({
 `;
 
 const theme = {
+  // The cursor Lexical draws where a text caret can't go, such as between
+  // two tables or decorators: a blinking horizontal bar.
+  blockCursor:
+    'pointer-events-none absolute block after:absolute after:-top-0.5 after:block after:w-5 after:border-0 after:border-t after:border-solid after:border-current after:content-[""] after:animate-[block-cursor-blink_1.1s_steps(2,start)_infinite]',
   code: 'my-2 block rounded-md bg-zinc-100 p-3 font-mono text-sm whitespace-pre dark:bg-zinc-900',
   heading: {
     h1: 'mb-2 text-3xl font-bold',
@@ -132,6 +149,15 @@ const theme = {
   paragraph: 'my-1',
   quote:
     'my-2 border-l-4 border-solid border-zinc-300 pl-3 text-zinc-600 dark:border-zinc-600 dark:text-zinc-300',
+  // @lexical/table: the scroll wrapper holds the margin, cells get a grid,
+  // and a multi-cell selection is drawn on the cells instead of the text.
+  table: 'border-collapse border-spacing-0',
+  tableCell:
+    'relative min-w-[75px] border border-solid border-zinc-300 px-2 py-0.5 text-start align-top dark:border-zinc-600',
+  tableCellHeader: 'bg-zinc-100 font-semibold dark:bg-zinc-700',
+  tableCellSelected: 'bg-blue-100 caret-transparent dark:bg-blue-900/60',
+  tableScrollableWrapper: 'my-2 overflow-x-auto',
+  tableSelection: 'selection:bg-transparent',
   text: {
     bold: 'font-bold',
     code: 'rounded bg-zinc-200/70 px-1 py-0.5 font-mono text-[0.9em] dark:bg-zinc-700/60',
diff --git a/dev-examples/mdast-editor/src/__tests__/browser/MdastEditorChrome.test.ts b/dev-examples/mdast-editor/src/__tests__/browser/MdastEditorChrome.test.ts
index 83b406acadf..b93b268e59a 100644
--- a/dev-examples/mdast-editor/src/__tests__/browser/MdastEditorChrome.test.ts
+++ b/dev-examples/mdast-editor/src/__tests__/browser/MdastEditorChrome.test.ts
@@ -16,17 +16,21 @@ import {
 } from '@lexical/mdast';
 import {RichTextExtension} from '@lexical/rich-text';
 import {
+  $createParagraphNode,
   $createRangeSelection,
   $getRoot,
   $getSelection,
+  $getSlot,
   $isElementNode,
   $isRangeSelection,
   $isTextNode,
   $setSelection,
   defineExtension,
+  HISTORY_MERGE_TAG,
+  INSERT_PARAGRAPH_COMMAND,
   type LexicalEditor,
 } from 'lexical';
-import {describe, expect, onTestFinished, test, vi} from 'vitest';
+import {assert, describe, expect, onTestFinished, test, vi} from 'vitest';
 
 import {
   INSERT_ALERT_COMMAND,
@@ -38,6 +42,7 @@ import {
 } from '../../extensions/MdastCollapsibleExtension';
 import {
   $isFootnoteDefinitionNode,
+  FOOTNOTES_SLOT,
   INSERT_FOOTNOTE_COMMAND,
   MdastFootnoteExtension,
 } from '../../extensions/MdastFootnoteExtension';
@@ -254,6 +259,53 @@ describe('footnotes', () => {
     );
   });
 
+  test('deleting everything else clears the footnotes', () => {
+    const {editor, root} = mountEditor('body[^a] text\n\n[^a]: the note');
+    editor.update(
+      () => {
+        $getRoot().clear().append($createParagraphNode()).selectEnd();
+      },
+      {discrete: true},
+    );
+    expect(root.querySelector('.footnote-def')).toBeNull();
+    expect(markdownOf(editor)).toBe('');
+  });
+
+  test('the footnotes stay while a definition is being edited', () => {
+    const {editor} = mountEditor('body[^a] text\n\n[^a]: the note');
+    editor.update(
+      () => {
+        const footnotes = $getSlot($getRoot(), FOOTNOTES_SLOT);
+        assert($isElementNode(footnotes));
+        footnotes.selectEnd();
+        $getRoot().clear().append($createParagraphNode());
+      },
+      {discrete: true},
+    );
+    // The empty body paragraph serializes as leading blank lines.
+    expect(markdownOf(editor).trim()).toBe('[^a]: the note');
+  });
+
+  test('a Markdown pane sync keeps definitions with no body', () => {
+    const {editor} = mountEditor('');
+    editor.update(() => $convertFromMarkdownString('[^a]: the note'), {
+      discrete: true,
+      tag: HISTORY_MERGE_TAG,
+    });
+    expect(markdownOf(editor)).toBe('[^a]: the note');
+  });
+
+  test('typing in an already-empty body keeps definitions', () => {
+    const {editor} = mountEditor('');
+    editor.update(() => $convertFromMarkdownString('[^a]: saved note'), {
+      discrete: true,
+      tag: HISTORY_MERGE_TAG,
+    });
+    editor.update(() => $getRoot().selectEnd(), {discrete: true});
+    editor.dispatchCommand(INSERT_PARAGRAPH_COMMAND, undefined);
+    expect(markdownOf(editor).trim()).toBe('[^a]: saved note');
+  });
+
   test('removing the last definition drops the section and its refs', async () => {
     const {editor, root} = mountEditor(
       'body[^a] and[^a] again\n\n[^a]: the note',
diff --git a/dev-examples/mdast-editor/src/__tests__/browser/TableEdit.test.ts b/dev-examples/mdast-editor/src/__tests__/browser/TableEdit.test.ts
new file mode 100644
index 00000000000..60547d9b1d0
--- /dev/null
+++ b/dev-examples/mdast-editor/src/__tests__/browser/TableEdit.test.ts
@@ -0,0 +1,160 @@
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ */
+
+import {
+  buildEditorFromExtensions,
+  effect,
+  getExtensionDependencyFromEditor,
+} from '@lexical/extension';
+import {
+  $convertFromMarkdownString,
+  $convertToMarkdownString,
+} from '@lexical/mdast';
+import {$isTableCellNode, INSERT_TABLE_COMMAND} from '@lexical/table';
+import {
+  $getRoot,
+  $isElementNode,
+  type LexicalEditor,
+  type LexicalNode,
+} from 'lexical';
+import {expect, onTestFinished, test} from 'vitest';
+import {userEvent} from 'vitest/browser';
+
+import {
+  TABLE_EDIT_COMMAND,
+  type TableEdit,
+} from '../../extensions/TableEditExtension';
+import {ToolbarStateExtension} from '../../extensions/ToolbarStateExtension';
+
+const TABLE = '| a | b |\n| - | - |\n| 1 | 2 |';
+
+function mountEditor(markdown: string) {
+  const root = document.createElement('div');
+  root.contentEditable = 'true';
+  document.body.appendChild(root);
+  const editor = buildEditorFromExtensions(ToolbarStateExtension);
+  editor.setRootElement(root);
+  onTestFinished(() => {
+    editor.dispose();
+    root.remove();
+  });
+  const toolbar = getExtensionDependencyFromEditor(
+    editor,
+    ToolbarStateExtension,
+  ).output;
+  // Subscribe like ToolbarPlugin so the watched editor-state signal updates.
+  onTestFinished(
+    effect(() => {
+      void toolbar.isInTable.value;
+    }),
+  );
+  editor.update(() => $convertFromMarkdownString(markdown), {discrete: true});
+  return {editor, root, toolbar};
+}
+
+function exportMarkdown(editor: LexicalEditor): string {
+  return editor.read(() => $convertToMarkdownString());
+}
+
+/** Puts the caret at the end of the last cell of the last table. */
+function selectLastCell(editor: LexicalEditor) {
+  editor.update(
+    () => {
+      let node: LexicalNode | null = $getRoot().getLastChild();
+      while ($isElementNode(node) && !$isTableCellNode(node)) {
+        node = node.getLastChild();
+      }
+      if ($isTableCellNode(node)) {
+        node.selectEnd();
+      }
+    },
+    {discrete: true},
+  );
+}
+
+test('the toolbar sees when the selection is in a table', () => {
+  const {editor, toolbar} = mountEditor(`intro\n\n${TABLE}`);
+  editor.update(() => $getRoot().selectStart(), {discrete: true});
+  expect(toolbar.isInTable.value).toBe(false);
+  selectLastCell(editor);
+  expect(toolbar.isInTable.value).toBe(true);
+});
+
+test.each<[TableEdit, string]>([
+  ['row-above', '| a | b |\n| - | - |\n|   |   |\n| 1 | 2 |'],
+  ['row-below', '| a | b |\n| - | - |\n| 1 | 2 |\n|   |   |'],
+  ['column-left', '| a |   | b |\n| - | - | - |\n| 1 |   | 2 |'],
+  ['column-right', '| a | b |   |\n| - | - | - |\n| 1 | 2 |   |'],
+  ['delete-row', '| a | b |\n| - | - |'],
+  ['delete-column', '| a |\n| - |\n| 1 |'],
+  ['delete-table', ''],
+  ['align-center', '| a |  b  |\n| - | :-: |\n| 1 |  2  |'],
+  ['align-right', '| a |  b |\n| - | -: |\n| 1 |  2 |'],
+])('TABLE_EDIT_COMMAND %s', (edit, expected) => {
+  const {editor} = mountEditor(TABLE);
+  selectLastCell(editor);
+  editor.dispatchCommand(TABLE_EDIT_COMMAND, edit);
+  expect(exportMarkdown(editor)).toBe(expected);
+});
+
+test('an inserted table exports as GFM with a header row', () => {
+  const {editor} = mountEditor('');
+  editor.update(() => $getRoot().selectEnd(), {discrete: true});
+  editor.dispatchCommand(INSERT_TABLE_COMMAND, {
+    columns: '2',
+    includeHeaders: {columns: false, rows: true},
+    rows: '2',
+  });
+  expect(exportMarkdown(editor)).toContain('|   |   |\n| - | - |\n|   |   |');
+});
+
+test('an aligned column renders and clears its alignment', () => {
+  const {editor, root} = mountEditor('| a | b |\n| - | -: |\n| 1 | 2 |');
+  const cells = () =>
+    [...root.querySelectorAll('td, th')].map(
+      cell => (cell as HTMLElement).style.textAlign,
+    );
+  expect(cells()).toEqual(['', 'right', '', 'right']);
+  selectLastCell(editor);
+  editor.dispatchCommand(TABLE_EDIT_COMMAND, 'align-none');
+  // Reading commits the pending update to the DOM.
+  editor.read(() => {});
+  expect(cells()).toEqual(['', '', '', '']);
+  expect(exportMarkdown(editor)).toBe('| a | b |\n| - | - |\n| 1 | 2 |');
+});
+
+// https://github.com/facebook/lexical/issues/9323
+test('Enter in a cell exports as <br>, not a newline', async () => {
+  const {editor, root} = mountEditor(TABLE);
+  root.focus();
+  selectLastCell(editor);
+  await userEvent.keyboard('{Enter}3');
+  expect(exportMarkdown(editor)).toBe(
+    '| a | b      |\n| - | ------ |\n| 1 | 2<br>3 |',
+  );
+});
+
+test('a list and a code block in a cell round-trip as HTML', () => {
+  const markdown =
+    '| a |\n| - |\n| x<ul><li>**i**</li><li>j</li></ul><pre data-language="js">let y<br>  z</pre> |';
+  const {editor} = mountEditor(markdown);
+  expect(
+    editor.read(() => {
+      let node: LexicalNode | null = $getRoot().getFirstChild();
+      while ($isElementNode(node) && !$isTableCellNode(node)) {
+        node = node.getLastChild();
+      }
+      return $isElementNode(node)
+        ? node.getChildren().map(child => child.getType())
+        : [];
+    }),
+  ).toEqual(['paragraph', 'list', 'code']);
+  expect(exportMarkdown(editor).split('\n')[2]).toMatch(
+    /^\| x<ul><li>\*\*i\*\*<\/li><li>j<\/li><\/ul><pre data-language="js">let y<br> {2}z<\/pre> +\|$/,
+  );
+});
diff --git a/dev-examples/mdast-editor/src/__tests__/browser/ToolbarState.test.ts b/dev-examples/mdast-editor/src/__tests__/browser/ToolbarState.test.ts
index 7a13f72ad2f..44642d8d0bd 100644
--- a/dev-examples/mdast-editor/src/__tests__/browser/ToolbarState.test.ts
+++ b/dev-examples/mdast-editor/src/__tests__/browser/ToolbarState.test.ts
@@ -103,9 +103,9 @@ test.each(['', '\n\n[^a]: Footnote'])(
       MdastEditorExtension,
     ).output;
     await vi.waitFor(() => {
-      // Select-all covers the root's children; footnote definitions occupy a
-      // separate slot and remain outside that selection.
-      expect(markdown.value).toBe(footnotes);
+      // Select-all covers the root's children; the footnote definitions
+      // occupy a separate slot, which goes once nothing else is left.
+      expect(markdown.value).toBe('');
       expect(toolbar.blockType.value).toBe('paragraph');
       expect(toolbar.isBold.value).toBe(false);
       expect(toolbar.isItalic.value).toBe(false);
@@ -113,8 +113,6 @@ test.each(['', '\n\n[^a]: Footnote'])(
     });
 
     await userEvent.keyboard('replacement');
-    await vi.waitFor(() =>
-      expect(markdown.value).toBe('replacement' + footnotes),
-    );
+    await vi.waitFor(() => expect(markdown.value).toBe('replacement'));
   },
 );
diff --git a/dev-examples/mdast-editor/src/extensions/MdastEditorExtension.ts b/dev-examples/mdast-editor/src/extensions/MdastEditorExtension.ts
index 905de2bcdd8..03fb2c67596 100644
--- a/dev-examples/mdast-editor/src/extensions/MdastEditorExtension.ts
+++ b/dev-examples/mdast-editor/src/extensions/MdastEditorExtension.ts
@@ -63,6 +63,7 @@ import {
 } from './MdastCollapsibleExtension';
 import {MdastFootnoteExtension} from './MdastFootnoteExtension';
 import {MdastKbdExtension} from './MdastKbdExtension';
+import {TableEditExtension} from './TableEditExtension';
 
 /**
  * Reformats the current selection's blocks as a paragraph. Toolbars
@@ -146,6 +147,9 @@ export const MdastEditorExtension = defineExtension({
     RichTextExtension,
     ListExtension,
     CheckListExtension,
+    // GFM tables (imported and exported by MdastGfmExtension) get the
+    // @lexical/table editing behavior and the toolbar's structure commands.
+    TableEditExtension,
     HistoryExtension,
     TabIndentationExtension,
     EditorStateExtension,
diff --git a/dev-examples/mdast-editor/src/extensions/MdastFootnoteExtension.ts b/dev-examples/mdast-editor/src/extensions/MdastFootnoteExtension.ts
index 1eb22c2524d..51f1e0d4821 100644
--- a/dev-examples/mdast-editor/src/extensions/MdastFootnoteExtension.ts
+++ b/dev-examples/mdast-editor/src/extensions/MdastFootnoteExtension.ts
@@ -39,6 +39,7 @@ import {
   $create,
   $createParagraphNode,
   $getDocument,
+  $getEditor,
   $getNodeByKey,
   $getRoot,
   $getSelection,
@@ -46,6 +47,7 @@ import {
   $getSlotHost,
   $getState,
   $getStateChange,
+  $hasUpdateTag,
   $isDecoratorNode,
   $isElementNode,
   $isParagraphNode,
@@ -72,6 +74,7 @@ import {
   type ElementDOMSlot,
   ElementNode,
   HISTORIC_TAG,
+  HISTORY_MERGE_TAG,
   isExactShortcutMatch,
   isHTMLElement,
   KEY_DOWN_COMMAND,
@@ -723,6 +726,44 @@ export function $clearFootnotes(): void {
   }
 }
 
+/** Whether everything outside the footnotes section is empty paragraphs. */
+function $isBodyEmpty(root: RootNode): boolean {
+  return root
+    .getChildren()
+    .every(child => $isParagraphNode(child) && child.isEmpty());
+}
+
+/**
+ * A RootNode transform: once everything outside the footnotes section has
+ * been deleted (select-all and Backspace, cut, ...), the section goes too,
+ * since a definition with no reference to it doesn't render in GFM and the
+ * empty editor would otherwise still show stale notes.
+ *
+ * Left alone: a body that was already empty before this update (only a
+ * deletion clears, not Enter in an empty body), the Markdown pane's sync
+ * (tagged history-merge), so a note typed there before any body text isn't
+ * dropped mid-edit, and an editor whose caret is in a definition, which is
+ * being edited.
+ */
+function $clearFootnotesOfEmptyDocument(root: RootNode): void {
+  if (
+    $hasUpdateTag(HISTORY_MERGE_TAG) ||
+    !$isFootnotesNode($getSlot(root, FOOTNOTES_SLOT)) ||
+    !$isBodyEmpty(root) ||
+    $getEditor().read('latest', () => $isBodyEmpty($getRoot()))
+  ) {
+    return;
+  }
+  const selection = $getSelection();
+  if (
+    $isRangeSelection(selection) &&
+    selection.anchor.getNode().getParents().some($isFootnotesNode)
+  ) {
+    return;
+  }
+  $clearFootnotes();
+}
+
 /* -------------------------------------------------------------------------- *
  * Markdown import: refs inline, definitions relocated to the footnotes slot  *
  * -------------------------------------------------------------------------- */
@@ -1155,6 +1196,7 @@ export const MdastFootnoteExtension = defineExtension({
     mergeRegister(
       registerFootnoteShortcut(editor),
       registerFootnoteAnchors(editor),
+      editor.registerNodeTransform(RootNode, $clearFootnotesOfEmptyDocument),
       editor.registerCommand(
         KEY_DOWN_COMMAND,
         event => {
diff --git a/dev-examples/mdast-editor/src/extensions/TableEditExtension.ts b/dev-examples/mdast-editor/src/extensions/TableEditExtension.ts
new file mode 100644
index 00000000000..900c0593c1f
--- /dev/null
+++ b/dev-examples/mdast-editor/src/extensions/TableEditExtension.ts
@@ -0,0 +1,176 @@
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ */
+
+import {
+  $deleteTableColumnAtSelection,
+  $deleteTableRowAtSelection,
+  $findCellNode,
+  $findTableNode,
+  $getTableColumnIndexFromTableCellNode,
+  $insertTableColumnAtSelection,
+  $insertTableRowAtSelection,
+  $isTableCellNode,
+  $isTableRowNode,
+  $isTableSelection,
+  TableExtension,
+  type TableNode,
+} from '@lexical/table';
+import {
+  $createParagraphNode,
+  $getSelection,
+  $isElementNode,
+  $isRangeSelection,
+  COMMAND_PRIORITY_EDITOR,
+  configExtension,
+  createCommand,
+  defineExtension,
+  type ElementFormatType,
+  type LexicalCommand,
+} from 'lexical';
+
+export type TableEdit =
+  | 'row-above'
+  | 'row-below'
+  | 'column-left'
+  | 'column-right'
+  | 'delete-row'
+  | 'delete-column'
+  | 'delete-table'
+  | 'align-left'
+  | 'align-center'
+  | 'align-right'
+  | 'align-none';
+
+const COLUMN_ALIGN = {
+  'align-center': 'center',
+  'align-left': 'left',
+  'align-none': '',
+  'align-right': 'right',
+} as const;
+
+/**
+ * Aligns every column the selection touches. GFM alignment belongs to a
+ * column (the delimiter row's `:-:`), so it is set as the element format of
+ * each cell in the column, which `@lexical/mdast` renders as `text-align`
+ * and exports. The cells' paragraphs are reset so they follow the cell.
+ */
+function $alignSelectedColumns(table: TableNode, format: ElementFormatType) {
+  const selection = $getSelection();
+  const cells = $isTableSelection(selection)
+    ? selection.getNodes().filter($isTableCellNode)
+    : [
+        $isRangeSelection(selection)
+          ? $findCellNode(selection.anchor.getNode())
+          : null,
+      ];
+  const columns = new Set<number>();
+  for (const cell of cells) {
+    if (cell) {
+      columns.add($getTableColumnIndexFromTableCellNode(cell));
+    }
+  }
+  for (const row of table.getChildren()) {
+    if (!$isTableRowNode(row)) {
+      continue;
+    }
+    const rowCells = row.getChildren();
+    for (const column of columns) {
+      const cell = rowCells[column];
+      if ($isTableCellNode(cell)) {
+        cell.setFormat(format);
+        for (const child of cell.getChildren()) {
+          if ($isElementNode(child) && !child.isInline()) {
+            child.setFormat('');
+          }
+        }
+      }
+    }
+  }
+}
+
+/**
+ * Edits the structure of the table the selection is in. The toolbar
+ * dispatches this rather than calling the `@lexical/table` helpers itself,
+ * so this extension owns table editing behavior.
+ */
+export const TABLE_EDIT_COMMAND: LexicalCommand<TableEdit> =
+  createCommand('TABLE_EDIT_COMMAND');
+
+/**
+ * The table the current selection is in, or null when it is outside one.
+ */
+export function $getSelectedTable(): TableNode | null {
+  const selection = $getSelection();
+  if (!$isRangeSelection(selection) && !$isTableSelection(selection)) {
+    return null;
+  }
+  const anchorTable = $findTableNode(selection.anchor.getNode());
+  return anchorTable !== null &&
+    anchorTable.is($findTableNode(selection.focus.getNode()))
+    ? anchorTable
+    : null;
+}
+
+/**
+ * GFM tables, as `@lexical/table` nodes with the table editing behavior
+ * (cell selection, Tab navigation, horizontal scroll) and structure
+ * commands. Markdown tables have a header row and plain cells, so the
+ * features GFM can't express (merged cells, cell background colors, nested
+ * tables) are turned off rather than silently dropped on export.
+ */
+export const TableEditExtension = defineExtension({
+  dependencies: [
+    configExtension(TableExtension, {
+      hasCellBackgroundColor: false,
+      hasCellMerge: false,
+      hasNestedTables: false,
+    }),
+  ],
+  name: '@lexical/dev-mdast-editor-example/TableEdit',
+  register(editor) {
+    return editor.registerCommand(
+      TABLE_EDIT_COMMAND,
+      edit => {
+        const table = $getSelectedTable();
+        if (!editor.isEditable() || table === null) {
+          return false;
+        }
+        switch (edit) {
+          case 'row-above':
+          case 'row-below':
+            $insertTableRowAtSelection(edit === 'row-below');
+            break;
+          case 'column-left':
+          case 'column-right':
+            $insertTableColumnAtSelection(edit === 'column-right');
+            break;
+          case 'delete-row':
+            $deleteTableRowAtSelection();
+            break;
+          case 'delete-column':
+            $deleteTableColumnAtSelection();
+            break;
+          case 'align-left':
+          case 'align-center':
+          case 'align-right':
+          case 'align-none':
+            $alignSelectedColumns(table, COLUMN_ALIGN[edit]);
+            break;
+          case 'delete-table': {
+            const paragraph = $createParagraphNode();
+            table.replace(paragraph);
+            paragraph.select();
+            break;
+          }
+        }
+        return true;
+      },
+      COMMAND_PRIORITY_EDITOR,
+    );
+  },
+});
diff --git a/dev-examples/mdast-editor/src/extensions/ToolbarStateExtension.ts b/dev-examples/mdast-editor/src/extensions/ToolbarStateExtension.ts
index d6427ec4f19..31050df5def 100644
--- a/dev-examples/mdast-editor/src/extensions/ToolbarStateExtension.ts
+++ b/dev-examples/mdast-editor/src/extensions/ToolbarStateExtension.ts
@@ -13,6 +13,7 @@ import {$isHeadingNode} from '@lexical/rich-text';
 import {$getSelection, $isRangeSelection, defineExtension} from 'lexical';
 
 import {MdastEditorExtension} from './MdastEditorExtension';
+import {$getSelectedTable} from './TableEditExtension';
 
 export type BlockType =
   | 'paragraph'
@@ -28,19 +29,25 @@ interface ToolbarSelectionState {
   isBold: boolean;
   isItalic: boolean;
   isCode: boolean;
+  isInTable: boolean;
 }
 
 const DEFAULT_SELECTION_STATE: ToolbarSelectionState = {
   blockType: 'paragraph',
   isBold: false,
   isCode: false,
+  isInTable: false,
   isItalic: false,
 };
 
 function $readSelectionState(): ToolbarSelectionState {
   const selection = $getSelection();
   if (!$isRangeSelection(selection)) {
-    return DEFAULT_SELECTION_STATE;
+    // A multi-cell TableSelection still edits its table.
+    const isInTable = $getSelectedTable() !== null;
+    return isInTable
+      ? {...DEFAULT_SELECTION_STATE, isInTable}
+      : DEFAULT_SELECTION_STATE;
   }
   const anchorNode = selection.anchor.getNode();
   // Deleting all content can leave the selection on the root, which has no
@@ -59,6 +66,7 @@ function $readSelectionState(): ToolbarSelectionState {
     blockType,
     isBold: selection.hasFormat('bold'),
     isCode: selection.hasFormat('code'),
+    isInTable: $getSelectedTable() !== null,
     isItalic: selection.hasFormat('italic'),
   };
 }
@@ -68,7 +76,7 @@ function $readSelectionState(): ToolbarSelectionState {
  * derived as `computed()` signals off the existing extension outputs:
  *
  * - The selection-derived signals (`blockType`, `isBold`, `isItalic`,
- *   `isCode`) are computed off the {@link EditorStateExtension} signal,
+ *   `isCode`, `isInTable`) are computed off the {@link EditorStateExtension} signal,
  *   so they recompute lazily whenever the editor state changes.
  * - `canUndo` / `canRedo` are computed off the {@link HistoryExtension}
  *   `historyState` signal. The history state object is mutated in
@@ -112,6 +120,7 @@ export const ToolbarStateExtension = defineExtension({
       }),
       isBold: computed(() => selection.value.isBold),
       isCode: computed(() => selection.value.isCode),
+      isInTable: computed(() => selection.value.isInTable),
       isItalic: computed(() => selection.value.isItalic),
     };
   },
diff --git a/dev-examples/mdast-editor/src/plugins/ToolbarPlugin.tsx b/dev-examples/mdast-editor/src/plugins/ToolbarPlugin.tsx
index 35151290b57..f1d3690aec0 100644
--- a/dev-examples/mdast-editor/src/plugins/ToolbarPlugin.tsx
+++ b/dev-examples/mdast-editor/src/plugins/ToolbarPlugin.tsx
@@ -14,6 +14,7 @@ import {
 } from '@lexical/list';
 import {useLexicalComposerContext} from '@lexical/react/LexicalComposerContext';
 import {useExtensionSignalValue} from '@lexical/react/useExtensionSignalValue';
+import {INSERT_TABLE_COMMAND} from '@lexical/table';
 import {
   FORMAT_TEXT_COMMAND,
   type LexicalEditor,
@@ -30,6 +31,10 @@ import {
 } from '../extensions/MdastEditorExtension';
 import {INSERT_FOOTNOTE_COMMAND} from '../extensions/MdastFootnoteExtension';
 import {FORMAT_KBD_COMMAND} from '../extensions/MdastKbdExtension';
+import {
+  TABLE_EDIT_COMMAND,
+  type TableEdit,
+} from '../extensions/TableEditExtension';
 import {
   type BlockType,
   ToolbarStateExtension,
@@ -50,8 +55,23 @@ const INSERT_TYPES = [
   {label: 'Collapsible section', value: 'details'},
   {label: 'Alert', value: 'alert'},
   {label: 'Footnote', value: 'footnote'},
+  {label: 'Table', value: 'table'},
 ] as const;
 
+const TABLE_EDITS: readonly {label: string; value: TableEdit}[] = [
+  {label: 'Insert row above', value: 'row-above'},
+  {label: 'Insert row below', value: 'row-below'},
+  {label: 'Insert column left', value: 'column-left'},
+  {label: 'Insert column right', value: 'column-right'},
+  {label: 'Delete row', value: 'delete-row'},
+  {label: 'Delete column', value: 'delete-column'},
+  {label: 'Align column left', value: 'align-left'},
+  {label: 'Align column center', value: 'align-center'},
+  {label: 'Align column right', value: 'align-right'},
+  {label: 'Clear column alignment', value: 'align-none'},
+  {label: 'Delete table', value: 'delete-table'},
+];
+
 type InsertType = (typeof INSERT_TYPES)[number]['value'];
 
 function applyInsert(editor: LexicalEditor, type: InsertType): void {
@@ -68,6 +88,14 @@ function applyInsert(editor: LexicalEditor, type: InsertType): void {
     case 'footnote':
       editor.dispatchCommand(INSERT_FOOTNOTE_COMMAND);
       return;
+    case 'table':
+      // A GFM table always has a header row.
+      editor.dispatchCommand(INSERT_TABLE_COMMAND, {
+        columns: '3',
+        includeHeaders: {columns: false, rows: true},
+        rows: '3',
+      });
+      return;
   }
 }
 
@@ -118,6 +146,7 @@ export function ToolbarPlugin() {
   const isBold = useExtensionSignalValue(ToolbarStateExtension, 'isBold');
   const isItalic = useExtensionSignalValue(ToolbarStateExtension, 'isItalic');
   const isCode = useExtensionSignalValue(ToolbarStateExtension, 'isCode');
+  const isInTable = useExtensionSignalValue(ToolbarStateExtension, 'isInTable');
   const isEditable = useExtensionSignalValue(
     MdastEditorExtension,
     'isEditable',
@@ -203,6 +232,28 @@ export function ToolbarPlugin() {
           </option>
         ))}
       </select>
+      {isInTable && (
+        <select
+          className={selectClass}
+          value=""
+          disabled={!isEditable}
+          onChange={e =>
+            editor.dispatchCommand(
+              TABLE_EDIT_COMMAND,
+              e.target.value as TableEdit,
+            )
+          }
+          aria-label="Table">
+          <option value="" hidden={true}>
+            Table
+          </option>
+          {TABLE_EDITS.map(({label, value}) => (
+            <option key={value} value={value}>
+              {label}
+            </option>
+          ))}
+        </select>
+      )}
       <div className="ml-auto flex items-center">
         <Divider />
         <button
diff --git a/dev-examples/mdast-editor/src/styles.css b/dev-examples/mdast-editor/src/styles.css
index b2e25342a76..a1ee76589bb 100644
--- a/dev-examples/mdast-editor/src/styles.css
+++ b/dev-examples/mdast-editor/src/styles.css
@@ -414,3 +414,10 @@ br[data-lexical-managed-linebreak] + .footnote-def-backlinks {
 [data-lexical-editor][contenteditable='false'] .markdown-alert-title::after {
   content: none;
 }
+
+/* The blink for theme.blockCursor (the after: bar) in Editor.tsx. */
+@keyframes block-cursor-blink {
+  to {
+    visibility: hidden;
+  }
+}
diff --git a/package.json b/package.json
index d4d288ad743..f30397943ce 100644
--- a/package.json
+++ b/package.json
@@ -41,6 +41,7 @@
     "tsc-scripts": "tsc -p ./tsconfig.scripts.json",
     "tsc-extension": "pnpm --filter @lexical/devtools run compile",
     "tsc-website": "pnpm --filter @lexical/website run tsc",
+    "tsc-dev-examples": "pnpm --filter \"./dev-examples/*\" run tsc",
     "tsc-watch": "tsc -w",
     "collab": "cross-env HOST=localhost PORT=1234 pnpm exec y-websocket",
     "vitest": "vitest",
@@ -92,7 +93,7 @@
     "lint": "eslint ./",
     "lint:fix": "eslint ./ --fix",
     "prettier": "prettier --list-different .",
-    "ci-check": "npm-run-all --parallel tsc tsc-test tsc-scripts tsc-extension tsc-website flow prettier lint",
+    "ci-check": "npm-run-all --parallel tsc tsc-test tsc-scripts tsc-extension tsc-website tsc-dev-examples flow prettier lint",
     "prettier:fix": "prettier --write .",
     "prepare-ci": "pnpm run build-playground-dev",
     "prepare-ci-prod": "pnpm run build-playground-prod",
diff --git a/packages/lexical-markdown/src/MarkdownExport.ts b/packages/lexical-markdown/src/MarkdownExport.ts
index eaecb8075e8..616286e781a 100644
--- a/packages/lexical-markdown/src/MarkdownExport.ts
+++ b/packages/lexical-markdown/src/MarkdownExport.ts
@@ -503,6 +503,8 @@ function exportTextFormat(
     output = shouldPreserveNewLines
       ? output.replace(/([*_`~])/g, '\\$1')
       : output.replace(/([*_`~\\])/g, '\\$1');
+    // Text that reads as a character reference keeps its `&` (`\&#65;`).
+    output = output.replace(/&(?=#\d{1,7};)/g, '\\&');
   }
 
   let leadingSpace: string;
diff --git a/packages/lexical-markdown/src/MarkdownImport.ts b/packages/lexical-markdown/src/MarkdownImport.ts
index e5ced6d006b..bc068d0c983 100644
--- a/packages/lexical-markdown/src/MarkdownImport.ts
+++ b/packages/lexical-markdown/src/MarkdownImport.ts
@@ -238,10 +238,21 @@ function $importBlocks(
     const match = lineText.match(regExp);
 
     if (match) {
-      textNode.setTextContent(lineText.slice(match[0].length));
+      const rest = lineText.slice(match[0].length);
+      textNode.setTextContent(rest);
       if (replace(elementNode, [textNode], match, true) !== false) {
         break;
       }
+      // A transform that cancels without touching the line gives it back
+      // whole. One that changed the text or moved it is left as it was
+      // before this restore, so the next transform that matches still
+      // starts from its own cut of the line.
+      if (
+        textNode.getParent() === elementNode &&
+        textNode.getTextContent() === rest
+      ) {
+        textNode.setTextContent(lineText);
+      }
     }
   }
 
diff --git a/packages/lexical-markdown/src/MarkdownTransformers.ts b/packages/lexical-markdown/src/MarkdownTransformers.ts
index 621cc6aba1b..8140f11706c 100644
--- a/packages/lexical-markdown/src/MarkdownTransformers.ts
+++ b/packages/lexical-markdown/src/MarkdownTransformers.ts
@@ -1098,7 +1098,9 @@ export function getCodeSpanDelimiter(content: string): {
   const needsPadding =
     content.length === 0 ||
     content.includes('`') ||
-    (/^\s/.test(content) && /\s$/.test(content));
+    // A reader strips one space (U+0020 only) from each end of a span that
+    // has something other than spaces, so only such a span needs padding.
+    (content.startsWith(' ') && content.endsWith(' ') && /[^ ]/.test(content));
   const padded = needsPadding ? ` ${content} ` : content;
   return {fence, padded};
 }
diff --git a/packages/lexical-markdown/src/__tests__/unit/CodeSpanEscapes.test.ts b/packages/lexical-markdown/src/__tests__/unit/CodeSpanEscapes.test.ts
new file mode 100644
index 00000000000..27b1cba2232
--- /dev/null
+++ b/packages/lexical-markdown/src/__tests__/unit/CodeSpanEscapes.test.ts
@@ -0,0 +1,195 @@
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ */
+
+// @vitest-environment node
+
+import {buildEditorFromExtensions} from '@lexical/extension';
+import {
+  $convertFromMarkdownString,
+  $convertToMarkdownString,
+  $generateNodesFromMarkdownString,
+  type TextMatchTransformer,
+  TRANSFORMERS,
+} from '@lexical/markdown';
+import {
+  $createParagraphNode,
+  $createTextNode,
+  $getRoot,
+  $isParagraphNode,
+  $isTextNode,
+  type LexicalNode,
+} from 'lexical';
+import {$assertNodeType} from 'lexical/src/__tests__/utils';
+import {describe, expect, it} from 'vitest';
+
+import {MarkdownTestExtension} from '../utils';
+
+describe('a code span', () => {
+  // CommonMark: backslash escapes don't work in code spans.
+  it.each([
+    ['`\\*`', '\\*'],
+    ['**`\\*`**', '\\*'],
+  ])('keeps its backslashes in %j', (markdown, text) => {
+    using editor = buildEditorFromExtensions([MarkdownTestExtension]);
+    editor.update(() => $convertFromMarkdownString(markdown, TRANSFORMERS), {
+      discrete: true,
+    });
+    editor.read(() => {
+      expect($getRoot().getTextContent()).toBe(text);
+      const code = $getRoot()
+        .getAllTextNodes()
+        .find(node => node.hasFormat('code'));
+      expect($isTextNode(code)).toBe(true);
+      expect($convertToMarkdownString(TRANSFORMERS)).toBe(markdown);
+    });
+  });
+
+  // A reader strips only U+0020 padding, so other whitespace needs none.
+  it.each([' ', '  ', '\tx\t', '\u00a0'])('round-trips %j bare', text => {
+    using editor = buildEditorFromExtensions([MarkdownTestExtension]);
+    editor.update(
+      () =>
+        $getRoot()
+          .clear()
+          .append(
+            $createParagraphNode().append(
+              $createTextNode(text).toggleFormat('code'),
+            ),
+          ),
+      {discrete: true},
+    );
+    const markdown = editor.read(() => $convertToMarkdownString(TRANSFORMERS));
+    expect(markdown).toBe('`' + text + '`');
+    editor.update(() => $convertFromMarkdownString(markdown, TRANSFORMERS), {
+      discrete: true,
+    });
+    expect(editor.read(() => $getRoot().getTextContent())).toBe(text);
+  });
+
+  it('leaves the text after it to read its escapes', () => {
+    using editor = buildEditorFromExtensions([MarkdownTestExtension]);
+    editor.update(
+      () => $convertFromMarkdownString('`\\*` \\* &#160;', TRANSFORMERS),
+      {discrete: true},
+    );
+    expect(
+      editor.read(() =>
+        $getRoot()
+          .getAllTextNodes()
+          .map(node => [node.getTextContent(), node.hasFormat('code')]),
+      ),
+    ).toEqual([
+      ['\\*', true],
+      [' * \u00a0', false],
+    ]);
+  });
+});
+
+describe('formatted text', () => {
+  // Each backslash escape is read once, in formatted text and beside a
+  // text match such as a link.
+  it.each([
+    ['**a\\\\\\*b**', 'a\\*b'],
+    ['a\\\\\\*b [x](https://y)', 'a\\*b x'],
+  ])('reads %j as %j', (markdown, text) => {
+    using editor = buildEditorFromExtensions([MarkdownTestExtension]);
+    editor.update(() => $convertFromMarkdownString(markdown, TRANSFORMERS), {
+      discrete: true,
+    });
+    expect(editor.read(() => $getRoot().getTextContent())).toBe(text);
+  });
+});
+
+describe('text a text match leaves in place', () => {
+  const MENTION: TextMatchTransformer = {
+    dependencies: [],
+    importRegExp: /@\S+/,
+    regExp: /@\S+$/,
+    replace: node => {
+      node.setFormat('bold');
+    },
+    type: 'text-match',
+  };
+  const textOf = (nodes: LexicalNode[]) =>
+    nodes
+      .flatMap(node => ($isTextNode(node) ? [node] : []))
+      .map(node => [node.getTextContent(), node.hasFormat('bold')]);
+
+  it.each(['@a\\*b', 'x @a\\*b'])(
+    'reads its escapes when the transformer edits it in place: %j',
+    markdown => {
+      using editor = buildEditorFromExtensions([MarkdownTestExtension]);
+      editor.update(() => $convertFromMarkdownString(markdown, [MENTION]), {
+        discrete: true,
+      });
+      expect(editor.read(() => textOf($getRoot().getAllTextNodes()))).toEqual([
+        ...(markdown.startsWith('x') ? [['x ', false]] : []),
+        ['@a*b', true],
+      ]);
+    },
+  );
+
+  it('reads its escapes in nodes generated outside the root', () => {
+    using editor = buildEditorFromExtensions([MarkdownTestExtension]);
+    let text;
+    editor.update(
+      () => {
+        const [paragraph] = $generateNodesFromMarkdownString('@a\\*b', [
+          MENTION,
+        ]);
+        text = textOf(
+          $assertNodeType(paragraph, $isParagraphNode).getChildren(),
+        );
+      },
+      {discrete: true},
+    );
+    expect(text).toEqual([['@a*b', true]]);
+  });
+});
+
+describe('a character reference', () => {
+  it.each(['&#0;', '&#55296;', '&#9999999;'])(
+    'reads %j, which names no valid character, as U+FFFD',
+    markdown => {
+      using editor = buildEditorFromExtensions([MarkdownTestExtension]);
+      editor.update(() => $convertFromMarkdownString(markdown, TRANSFORMERS), {
+        discrete: true,
+      });
+      expect(editor.read(() => $getRoot().getTextContent())).toBe('\ufffd');
+    },
+  );
+
+  it.each([
+    // More than 7 digits is no reference.
+    ['&#99999999;', '&#99999999;'],
+    // An escaped `&` begins no reference.
+    ['\\&#65;', '&#65;'],
+  ])('reads %j as the text %j', (markdown, text) => {
+    using editor = buildEditorFromExtensions([MarkdownTestExtension]);
+    editor.update(() => $convertFromMarkdownString(markdown, TRANSFORMERS), {
+      discrete: true,
+    });
+    expect(editor.read(() => $getRoot().getTextContent())).toBe(text);
+  });
+
+  it('round-trips text that reads as one', () => {
+    using editor = buildEditorFromExtensions([MarkdownTestExtension]);
+    editor.update(
+      () =>
+        $getRoot()
+          .clear()
+          .append($createParagraphNode().append($createTextNode('a &#32; b'))),
+      {discrete: true},
+    );
+    const markdown = editor.read(() => $convertToMarkdownString(TRANSFORMERS));
+    editor.update(() => $convertFromMarkdownString(markdown, TRANSFORMERS), {
+      discrete: true,
+    });
+    expect(editor.read(() => $getRoot().getTextContent())).toBe('a &#32; b');
+  });
+});
diff --git a/packages/lexical-markdown/src/__tests__/unit/LexicalMarkdown.test.ts b/packages/lexical-markdown/src/__tests__/unit/LexicalMarkdown.test.ts
index 4f2c2e44d28..defb00df06f 100644
--- a/packages/lexical-markdown/src/__tests__/unit/LexicalMarkdown.test.ts
+++ b/packages/lexical-markdown/src/__tests__/unit/LexicalMarkdown.test.ts
@@ -1235,6 +1235,46 @@ describe('Markdown', () => {
     );
   });
 
+  it('keeps the whole line when an element transformer cancels its import', () => {
+    const CANCELED_HEADING: ElementTransformer = {
+      dependencies: [HeadingNode],
+      export: () => null,
+      regExp: /^#\s/,
+      replace: () => false,
+      type: 'element',
+    };
+    const editor = createTestEditor({nodes: [HeadingNode]});
+    editor.update(
+      () => $convertFromMarkdownString('# kept', [CANCELED_HEADING]),
+      {discrete: true},
+    );
+    expect(editor.read(() => $getRoot().getTextContent())).toBe('# kept');
+  });
+
+  it('keeps the text an element transformer changed before cancelling', () => {
+    const REWRITING_CANCEL: ElementTransformer = {
+      dependencies: [HeadingNode],
+      export: () => null,
+      regExp: /^#\s/,
+      replace: (_parentNode, children) => {
+        const [text] = children;
+        if ($isTextNode(text)) {
+          text.setTextContent('rewritten ' + text.getTextContent());
+        }
+        return false;
+      },
+      type: 'element',
+    };
+    const editor = createTestEditor({nodes: [HeadingNode]});
+    editor.update(
+      () => $convertFromMarkdownString('# kept', [REWRITING_CANCEL]),
+      {discrete: true},
+    );
+    expect(editor.read(() => $getRoot().getTextContent())).toBe(
+      'rewritten kept',
+    );
+  });
+
   it('should remove leading node and execute transform if replace does not return false', () => {
     const editor = createTestEditor({
       nodes: [
diff --git a/packages/lexical-markdown/src/importTextMatchTransformer.ts b/packages/lexical-markdown/src/importTextMatchTransformer.ts
index 8bc58526aa1..4bcc26224a9 100644
--- a/packages/lexical-markdown/src/importTextMatchTransformer.ts
+++ b/packages/lexical-markdown/src/importTextMatchTransformer.ts
@@ -84,6 +84,8 @@ export function importFoundTextMatchTransformer(
   transformedNode?: TextNode;
   nodeBefore: TextNode | undefined; // If split
   nodeAfter: TextNode | undefined; // If split
+  // The text the transformer was given, which it may have left in place.
+  matchedNode?: TextNode;
 } | null {
   let transformedNode, nodeAfter, nodeBefore;
 
@@ -102,6 +104,7 @@ export function importFoundTextMatchTransformer(
   const potentialTransformedNode = transformer.replace(transformedNode, match);
 
   return {
+    matchedNode: transformedNode,
     nodeAfter,
     nodeBefore,
     transformedNode: potentialTransformedNode || undefined,
diff --git a/packages/lexical-markdown/src/importTextTransformers.ts b/packages/lexical-markdown/src/importTextTransformers.ts
index 1525c24a0f4..63cd0f5c7e0 100644
--- a/packages/lexical-markdown/src/importTextTransformers.ts
+++ b/packages/lexical-markdown/src/importTextTransformers.ts
@@ -115,6 +115,8 @@ export function importTextTransformers(
         textMatchTransformers,
       );
     }
+    // Each piece, `textNode` among them, has had its escapes read.
+    return;
   } else if (foundTextMatch) {
     const result = importFoundTextMatchTransformer(
       textNode,
@@ -147,11 +149,26 @@ export function importTextTransformers(
         textFormatTransformersIndex,
         textMatchTransformers,
       );
+    } else if (
+      result.transformedNode === undefined &&
+      canContainTransformableMarkdown(result.matchedNode) &&
+      result.matchedNode.getParent() !== null
+    ) {
+      // A transformer that returns nothing may have edited the matched text
+      // in place, which still reads its escapes. The parent test, unlike
+      // isAttached(), also holds in a tree not attached to the root.
+      result.matchedNode.setTextContent(
+        unescapeText(result.matchedNode.getTextContent()),
+      );
     }
+    return;
   }
 
-  // Handle escape characters
-  const textContent = textNode.getTextContent();
-  const unescapedText = unescapeText(textContent);
-  textNode.setTextContent(unescapedText);
+  // Handle escape characters, which a code span doesn't take. The node is
+  // the code span itself when the span was all of its text.
+  if (canContainTransformableMarkdown(textNode)) {
+    const textContent = textNode.getTextContent();
+    const unescapedText = unescapeText(textContent);
+    textNode.setTextContent(unescapedText);
+  }
 }
diff --git a/packages/lexical-markdown/src/utils.ts b/packages/lexical-markdown/src/utils.ts
index 0c05c87dbe8..d3b5e1d3437 100644
--- a/packages/lexical-markdown/src/utils.ts
+++ b/packages/lexical-markdown/src/utils.ts
@@ -77,9 +77,21 @@ export function isEmptyParagraph(node: LexicalNode): boolean {
 }
 
 export function unescapeText(value: string): string {
-  return value
-    .replace(/\\([!-/:-@[-`{-~])/g, '$1')
-    .replace(/&#(\d+);/g, (_, codePoint) =>
-      String.fromCodePoint(Number(codePoint)),
-    );
+  // One pass, so an escaped `\&#65;` stays the text `&#65;`. As in
+  // CommonMark, a decimal reference has at most 7 digits, and one to no
+  // valid character reads as U+FFFD.
+  return value.replace(
+    /\\([!-/:-@[-`{-~])|&#(\d{1,7});/g,
+    (_, escaped: string | undefined, digits: string | undefined) => {
+      if (escaped !== undefined) {
+        return escaped;
+      }
+      const codePoint = Number(digits);
+      return codePoint === 0 ||
+        codePoint > 0x10ffff ||
+        (codePoint >= 0xd800 && codePoint <= 0xdfff)
+        ? '\ufffd'
+        : String.fromCodePoint(codePoint);
+    },
+  );
 }
diff --git a/packages/lexical-mdast/src/MdastHtmlExtension.ts b/packages/lexical-mdast/src/MdastHtmlExtension.ts
index 3f4d42a452a..36845fcdaee 100644
--- a/packages/lexical-mdast/src/MdastHtmlExtension.ts
+++ b/packages/lexical-mdast/src/MdastHtmlExtension.ts
@@ -55,6 +55,7 @@ import {
 } from 'lexical';
 import {fromMarkdown} from 'mdast-util-from-markdown';
 
+import {htmlBlockPlaceholder, splitHtmlBlock} from './htmlBlockParts';
 import {MdastExtension} from './MdastExtension';
 
 // The mdast nodes raw HTML is normalized into — one for a block-level tag
@@ -191,7 +192,7 @@ function tryBuildHtmlBlock(parent: Parent, index: number): HtmlBlock | null {
         // Splice the Markdown blocks since the previous fragment in as
         // placeholders, then continue the raw stream.
         for (const child of pending) {
-          value += `<template data-mdast-child="${children.length}"></template>`;
+          value += htmlBlockPlaceholder(children.length);
           children.push(child);
         }
         pending = [];
@@ -679,8 +680,7 @@ export type RawHtmlBlockPart =
 export function rawHtmlBlock(...parts: RawHtmlBlockPart[]): HtmlBlock {
   let value = '';
   const children: BlockContent[] = [];
-  const placeholder = () =>
-    `<template data-mdast-child="${children.length}"></template>`;
+  const placeholder = () => htmlBlockPlaceholder(children.length);
   for (const part of parts) {
     if (typeof part === 'string') {
       value += part;
@@ -941,10 +941,6 @@ export const $exportViaDOM: MdastExportHandler = (node, ctx) => {
   return rawHtmlBlock(...parts);
 };
 
-// Split on the placeholder elements, capturing the child index: even
-// segments are raw HTML, odd segments are indices.
-const PLACEHOLDER_SPLIT_RE = /<template data-mdast-child="(\d+)"><\/template>/;
-
 // Serializes an `htmlBlock`: raw segments verbatim, each placeholder through
 // the regular handler for its child so the embedded Markdown gets correct
 // escaping and syntax.
@@ -952,7 +948,7 @@ const htmlBlockToMarkdown: ToMarkdownExtension = {
   handlers: {
     htmlBlock: ((node: HtmlBlock, _parent, state, info) => {
       const tracker = state.createTracker(info);
-      const segments = node.value.split(PLACEHOLDER_SPLIT_RE);
+      const segments = splitHtmlBlock(node.value);
       let value = '';
       for (let i = 0; i < segments.length; i++) {
         if (i % 2 === 0) {
diff --git a/packages/lexical-mdast/src/MdastImport.ts b/packages/lexical-mdast/src/MdastImport.ts
index dec898e2d54..6302886d4b9 100644
--- a/packages/lexical-mdast/src/MdastImport.ts
+++ b/packages/lexical-mdast/src/MdastImport.ts
@@ -29,9 +29,9 @@ import {
   $getSelection,
   tokenizeRawText,
 } from 'lexical';
-import {fromMarkdown} from 'mdast-util-from-markdown';
 
 import {$append, $isBlockLevelNode, $prepend} from './handlers';
+import {parseMarkdown} from './sourceOffsets';
 
 /**
  * Import context state that is true for the whole of a Markdown/mdast
@@ -241,14 +241,9 @@ export function createMdastImport(compiled: CompiledMdast): {
     return blocks;
   };
 
-  const $generateNodesFromMarkdown = (markdown: string): LexicalNode[] =>
-    $generateNodes(
-      fromMarkdown(markdown, {
-        extensions: compiled.micromarkExtensions,
-        mdastExtensions: compiled.mdastExtensions,
-      }),
-      markdown,
-    );
+  const $generateNodesFromMarkdown = (markdown: string): LexicalNode[] => {
+    return $generateNodes(parseMarkdown(compiled, markdown), markdown);
+  };
 
   const $generateNodesFromMdast = (tree: Root): LexicalNode[] =>
     $generateNodes(tree, '');
diff --git a/packages/lexical-mdast/src/MdastStream.ts b/packages/lexical-mdast/src/MdastStream.ts
index 5fcfd2f6d5f..2cfced9f79e 100644
--- a/packages/lexical-mdast/src/MdastStream.ts
+++ b/packages/lexical-mdast/src/MdastStream.ts
@@ -10,9 +10,8 @@ import type {CompiledMdast, MdastNode} from './types';
 import type {LexicalNode} from 'lexical';
 import type {Blockquote, Code, Heading, List, PhrasingContent} from 'mdast';
 
-import {fromMarkdown} from 'mdast-util-from-markdown';
-
 import {createNodeImporter} from './MdastImport';
+import {parseMarkdown} from './sourceOffsets';
 
 export type MdastBlockMatch =
   | {kind: 'heading'; node: Heading; markerLength: number}
@@ -88,10 +87,7 @@ export class MarkdownStreamScanner {
   }
 
   private parse(value: string) {
-    return fromMarkdown(value, {
-      extensions: this.compiled.micromarkExtensions,
-      mdastExtensions: this.compiled.mdastExtensions,
-    });
+    return parseMarkdown(this.compiled, value);
   }
 
   /**
diff --git a/packages/lexical-mdast/src/MdastTableExtension.ts b/packages/lexical-mdast/src/MdastTableExtension.ts
index 88647d9100c..57101e4e987 100644
--- a/packages/lexical-mdast/src/MdastTableExtension.ts
+++ b/packages/lexical-mdast/src/MdastTableExtension.ts
@@ -6,10 +6,26 @@
  *
  */
 
-import type {MdastExportHandler, MdastImportHandler} from './types';
-import type {AlignType, Table, TableCell, TableRow} from 'mdast';
+import type {MdastHtmlExtension} from './MdastHtmlExtension';
+import type {
+  MdastExportHandler,
+  MdastImportContext,
+  MdastImportHandler,
+  MdastNode,
+} from './types';
+import type {
+  AlignType,
+  Html,
+  HtmlBlock,
+  HtmlInline,
+  PhrasingContent,
+  Table,
+  TableCell,
+  TableRow,
+  Text,
+} from 'mdast';
 
-import {configExtension} from '@lexical/extension';
+import {$getPeerDependency, configExtension} from '@lexical/extension';
 import {
   $createTableCellNode,
   $createTableNode,
@@ -25,54 +41,832 @@ import {
 import {
   $createParagraphNode,
   $getState,
+  $isDecoratorNode,
   $isElementNode,
   $setState,
+  arrayValue,
   createState,
+  declarePeerDependency,
   defineExtension,
+  enumValue,
+  type LexicalNode,
+  type ParagraphNode,
 } from 'lexical';
 import {gfmTableFromMarkdown, gfmTableToMarkdown} from 'mdast-util-gfm-table';
 import {gfmTable} from 'micromark-extension-gfm-table';
 
 import {$append} from './handlers';
+import {splitHtmlBlock} from './htmlBlockParts';
 import {MdastExtension} from './MdastExtension';
 
-/** The per-column alignment (`| :-: |`) a table's delimiter row declared. */
+/** A GFM column alignment as mdast spells it; anything else reads as `null`. */
+const alignValue = enumValue<AlignType>([null, 'left', 'center', 'right']);
+
+/**
+ * The per-column alignment (`| :-: |`) a table's delimiter row declared, as
+ * imported before alignment moved to the cells' element format. An editor
+ * moves it onto the cells and clears it as soon as such a table is loaded
+ * (see {@link $migrateTableAlign}); export reads it as the fallback only
+ * where that hasn't happened, such as a read of an `EditorState` that was
+ * never set on an editor.
+ */
 const tableAlignState = createState('mdastTableAlign', {
-  parse: (v): AlignType[] =>
-    Array.isArray(v)
-      ? v.map(a => (a === 'center' || a === 'left' || a === 'right' ? a : null))
-      : [],
+  parse: arrayValue(alignValue),
   resetOnCopyNode: true,
 });
 
+/**
+ * The GFM alignment a cell renders with: its own element format (what
+ * import sets, and what `FORMAT_ELEMENT_COMMAND` sets on a cell selection),
+ * else the format its block children share (what that command sets with
+ * the caret in a single cell).
+ */
+function $getCellAlign(cell: TableCellNode): AlignType {
+  const own = alignValue(cell.getFormatType());
+  if (own !== null) {
+    return own;
+  }
+  let shared: AlignType | undefined;
+  for (const child of cell.getChildren()) {
+    if ($isElementNode(child) && !child.isInline()) {
+      const align = alignValue(child.getFormatType());
+      if (shared !== undefined && shared !== align) {
+        return null;
+      }
+      shared = align;
+    }
+  }
+  return shared || null;
+}
+
+/**
+ * The number of line breaks an inline `<br>` run stands for (`<br>`,
+ * `<br/>`, `<br />`, any case), or 0 when `node` is anything else. With
+ * {@link MdastHtmlExtension} the tag arrives reassembled as `htmlInline`;
+ * without it, as a plain `html` token.
+ */
+function brCount(node: MdastNode): number {
+  if (
+    (node.type !== 'html' && node.type !== 'htmlInline') ||
+    ('children' in node && node.children.length > 0)
+  ) {
+    return 0;
+  }
+  const value = node.value.trim();
+  return /^(?:<br\s*\/?>\s*)+$/i.test(value)
+    ? value.split(/<br/i).length - 1
+    : 0;
+}
+
+/**
+ * A deep copy of `nodes` with each node that `replace` returns an array for
+ * swapped for that array; the children of the others are mapped in turn.
+ */
+function mapPhrasing(
+  nodes: readonly PhrasingContent[],
+  replace: (node: PhrasingContent) => PhrasingContent[] | undefined,
+): PhrasingContent[] {
+  return nodes.flatMap(
+    node =>
+      replace(node) ||
+      ('children' in node
+        ? ({
+            ...node,
+            children: mapPhrasing(node.children, replace),
+          } as PhrasingContent)
+        : node),
+  );
+}
+
+/**
+ * A copy of `nodes` with every `<br>` nested inside other phrasing content
+ * (`**a<br>b**`) replaced by hard `break`s, which import as line breaks.
+ */
+function nestedBrToBreaks(nodes: PhrasingContent[]): PhrasingContent[] {
+  return mapPhrasing(nodes, node => {
+    const count = brCount(node);
+    if (count > 0) {
+      return Array.from({length: count}, () => ({type: 'break'}));
+    }
+    return node.type === 'htmlInline' ? [node] : undefined;
+  });
+}
+
+/**
+ * How many of the spaces and tabs at the start (or the end) of `node`'s
+ * value were written as they are, rather than as character references
+ * (`&#32;`), which {@link refEdgeSpaces} writes for spaces to keep. Without
+ * the source, or the node's position in it, all of them: a tree carries no
+ * record of which characters were references.
+ */
+function literalSpaces(node: Text, source: string, atEnd: boolean): number {
+  const re = atEnd ? /[ \t]*$/ : /^[ \t]*/;
+  const inValue = re.exec(node.value)![0].length;
+  // parseMarkdown gives points without offsets the ones their lines and
+  // columns stand for.
+  const {position} = node;
+  const start = position && position.start.offset;
+  const end = position && position.end.offset;
+  if (source === '' || start == null || end == null) {
+    return inValue;
+  }
+  const written = source.slice(start, end);
+  return Math.min(inValue, re.exec(written)![0].length);
+}
+
+/** Trims the whitespace a `<br>` was written with (`a <br> b`). */
+function trimSegment(
+  segment: PhrasingContent[],
+  source: string,
+): PhrasingContent[] {
+  const result = segment.slice();
+  const first = result[0];
+  if (first && first.type === 'text') {
+    result[0] = {
+      ...first,
+      value: first.value.slice(literalSpaces(first, source, false)),
+    };
+  }
+  const lastIndex = result.length - 1;
+  const last = result[lastIndex];
+  if (last && last.type === 'text') {
+    result[lastIndex] = {
+      ...last,
+      value: last.value.slice(
+        0,
+        last.value.length - literalSpaces(last, source, true),
+      ),
+    };
+  }
+  return result.filter(node => node.type !== 'text' || node.value !== '');
+}
+
+/** The names of the block elements a cell's HTML can open with. */
+const BLOCK_HTML_RE =
+  /^\s*<(?:address|article|aside|blockquote|details|div|dl|figure|footer|h[1-6]|header|hr|ol|p|pre|section|ul)\b/i;
+
+/**
+ * Whether `node` is a block element written as one line of HTML in a cell
+ * (`<ul><li>a</li></ul>`). Only {@link MdastHtmlExtension} reassembles such
+ * a run into one `htmlInline` node.
+ */
+function isBlockHtml(node: MdastNode): node is HtmlInline {
+  return node.type === 'htmlInline' && BLOCK_HTML_RE.test(node.value);
+}
+
+/**
+ * Splits a cell's phrasing content into lines, one paragraph each, and the
+ * blocks written as HTML between them. GFM cells can't contain a newline,
+ * so `<br>` is the conventional line separator; it imports as a paragraph
+ * boundary, which is what Enter inserts in a table cell, so typed lines
+ * round-trip. A block ends the line before it without a `<br>`, so a `<br>`
+ * next to a block stands for an empty line on that side
+ * (see {@link joinCellItems}). Spaces and tabs written as they are between
+ * a block and a `<br>` are padding and make no line; any other whitespace,
+ * such as spaces written as references (`&#32;`) by {@link refEdgeSpaces}
+ * or a no-break space, is a line's content.
+ */
+function cellItems(
+  cell: TableCell,
+  source: string,
+): (PhrasingContent[] | HtmlInline)[] {
+  const items: (PhrasingContent[] | HtmlInline)[] = [];
+  // The open line, or null right after a block.
+  let line: PhrasingContent[] | null = [];
+  // Ends the open line; one left empty by trimming is no line before a block.
+  const endLine = (beforeBlock = false) => {
+    if (line !== null) {
+      const segment = trimSegment(nestedBrToBreaks(line), source);
+      if (!beforeBlock || segment.length > 0) {
+        items.push(segment);
+      }
+    }
+  };
+  for (const child of cell.children) {
+    const count = brCount(child);
+    if (count > 0) {
+      for (let i = 0; i < count; i++) {
+        endLine();
+        line = [];
+      }
+    } else if (isBlockHtml(child)) {
+      endLine(true);
+      items.push(child);
+      line = null;
+    } else if (
+      line !== null ||
+      child.type !== 'text' ||
+      literalSpaces(child, source, false) < child.value.length
+    ) {
+      line = line || [];
+      line.push(child);
+    }
+  }
+  endLine();
+  return items;
+}
+
+/**
+ * Imports a block written as HTML in a cell through
+ * {@link MdastHtmlExtension}'s block import, which keeps its block
+ * structure where an inline run would be flattened into the line.
+ */
+function $importBlockHtml(
+  node: HtmlInline,
+  ctx: MdastImportContext,
+): LexicalNode[] {
+  const block: HtmlBlock = {
+    // The phrasing children are pre-imported into their placeholders the
+    // same way block children are.
+    children: node.children as unknown as HtmlBlock['children'],
+    type: 'htmlBlock',
+    value: node.value,
+  };
+  // Inline output (from a block tag no DOM rule handles) gets a paragraph.
+  const blocks: LexicalNode[] = [];
+  let paragraph: ParagraphNode | null = null;
+  for (const child of ctx.importNode(block)) {
+    if (
+      ($isElementNode(child) || $isDecoratorNode(child)) &&
+      !child.isInline()
+    ) {
+      blocks.push(child);
+      paragraph = null;
+    } else {
+      if (paragraph === null) {
+        paragraph = $createParagraphNode();
+        blocks.push(paragraph);
+      }
+      $append(paragraph, [child]);
+    }
+  }
+  return blocks;
+}
+
 const $importTable: MdastImportHandler<Table> = (node, ctx) => {
-  const table = $createTableNode();
-  if (node.align && node.align.some(a => a != null)) {
-    $setState(table, tableAlignState, node.align);
-  }
-  node.children.forEach((row, rowIndex) => {
-    const rowNode = $createTableRowNode();
-    for (const cell of row.children) {
-      const cellNode = $createTableCellNode(
-        rowIndex === 0
-          ? TableCellHeaderStates.ROW
-          : TableCellHeaderStates.NO_STATUS,
+  const align = node.align || [];
+  return $append(
+    $createTableNode(),
+    node.children.map((row, rowIndex) =>
+      $append(
+        $createTableRowNode(),
+        row.children.map((cell, columnIndex) => {
+          const cellNode = $createTableCellNode(
+            rowIndex === 0
+              ? TableCellHeaderStates.ROW
+              : TableCellHeaderStates.NO_STATUS,
+          );
+          // Every cell of the column carries the alignment, so it renders as
+          // the cell's text-align and moves with the cells when columns are
+          // edited.
+          return $append(
+            cellNode.setFormat(align[columnIndex] || ''),
+            cellItems(cell, ctx.source).flatMap(item =>
+              Array.isArray(item)
+                ? [
+                    $append(
+                      $createParagraphNode(),
+                      ctx.importChildren({children: item, type: 'tableCell'}),
+                    ),
+                  ]
+                : $importBlockHtml(item, ctx),
+            ),
+          );
+        }),
+      ),
+    ),
+  );
+};
+
+function html(value: string): Html {
+  return {type: 'html', value};
+}
+
+// Elements whose text is read to their end tag without tags in it, and
+// with (RCDATA) or without (raw text) character references.
+const RCDATA_HTML_RE = /^(?:textarea|title)$/i;
+const RAW_TEXT_HTML_RE =
+  /^(?:iframe|noembed|noframes|noscript|plaintext|script|style|xmp)$/i;
+// The characters HTML takes as whitespace.
+const HTML_SPACE_RE = /[\t\n\f\r ]/;
+
+/**
+ * Raw HTML as it can go in a GFM cell, which holds one line and splits on
+ * `|` even inside HTML. A newline in text or in a quoted attribute value is
+ * a character reference (`&#10;`), which reads back as the same newline, so
+ * whitespace that `<pre>` or CSS keeps survives. A newline between a tag's
+ * attributes, or in a comment or a declaration, is a space, which reads
+ * the same there. Every pipe is a character reference (`&#124;`). The text
+ * of `<script>`, `<style>` and the like takes no references, so a newline
+ * there is a space and a pipe stays a reference: GFM can't write either in
+ * them, nor a pipe in a comment.
+ */
+function cellHtml(value: string): string {
+  let result = '';
+  // What the scan is in: text, a tag, a quoted attribute value, an
+  // unquoted one, a comment or other markup declaration ending in
+  // `markupEnd`, or the text of an element named `rawTag`.
+  let state: 'text' | 'tag' | 'quoted' | 'unquoted' | 'markup' | 'raw' = 'text';
+  let quote = '';
+  let markupEnd = '';
+  let afterEquals = false;
+  // The element whose start tag is being read, and the one whose text is.
+  let openTag = '';
+  let rawTag = '';
+  for (let i = 0; i < value.length; i++) {
+    const char = value[i];
+    if (char === '\r' || char === '\n') {
+      if (char === '\r' && value[i + 1] === '\n') {
+        i++;
+      }
+      if (state === 'unquoted') {
+        state = 'tag';
+      }
+      result +=
+        state === 'text' ||
+        state === 'quoted' ||
+        (state === 'raw' && RCDATA_HTML_RE.test(rawTag))
+          ? '&#10;'
+          : ' ';
+      continue;
+    }
+    switch (state) {
+      case 'text':
+        if (char === '<') {
+          if (value.startsWith('<!--', i)) {
+            state = 'markup';
+            markupEnd = '-->';
+          } else if (/^<[!?]/.test(value.slice(i, i + 2))) {
+            state = 'markup';
+            markupEnd = '>';
+          } else {
+            const tag = /^<(\/?)([a-z][\w-]*)/i.exec(value.slice(i, i + 64));
+            if (tag !== null) {
+              state = 'tag';
+              afterEquals = false;
+              openTag = tag[1] ? '' : tag[2];
+            }
+          }
+        }
+        break;
+      case 'markup':
+        if (value.startsWith(markupEnd, i)) {
+          result += markupEnd;
+          i += markupEnd.length - 1;
+          state = 'text';
+          continue;
+        }
+        break;
+      case 'raw':
+        if (
+          value.slice(i, i + rawTag.length + 2).toLowerCase() ===
+          '</' + rawTag
+        ) {
+          state = 'tag';
+          afterEquals = false;
+          openTag = '';
+        }
+        break;
+      case 'tag':
+      case 'unquoted':
+        if (char === '>') {
+          rawTag =
+            RCDATA_HTML_RE.test(openTag) || RAW_TEXT_HTML_RE.test(openTag)
+              ? openTag.toLowerCase()
+              : '';
+          state = rawTag === '' ? 'text' : 'raw';
+        } else if (state === 'unquoted') {
+          if (HTML_SPACE_RE.test(char)) {
+            state = 'tag';
+          }
+        } else if (char === '=') {
+          afterEquals = true;
+        } else if (afterEquals && (char === '"' || char === "'")) {
+          state = 'quoted';
+          quote = char;
+          afterEquals = false;
+        } else if (afterEquals && !HTML_SPACE_RE.test(char)) {
+          state = 'unquoted';
+          afterEquals = false;
+        }
+        break;
+      case 'quoted':
+        if (char === quote) {
+          state = 'tag';
+        }
+        break;
+    }
+    result += char === '|' ? '&#124;' : char;
+  }
+  return result;
+}
+
+/** A space or tab as a character reference, which a cell doesn't trim. */
+function spaceReference(space: string): Html {
+  return html(`&#${space.charCodeAt(0)};`);
+}
+
+/**
+ * A line of a cell (which may hold `<br>`s of its own) with the space or
+ * tab at each edge of its lines written as a character reference, since a
+ * cell's padding and the whitespace around a `<br>` are trimmed on import.
+ */
+function refEdgeSpaces(nodes: PhrasingContent[]): PhrasingContent[] {
+  const isEdge = (node: PhrasingContent | undefined) =>
+    node === undefined || brCount(node) > 0;
+  return nodes.flatMap((node, i): PhrasingContent[] => {
+    if (node.type !== 'text') {
+      return [node];
+    }
+    let {value} = node;
+    const before: PhrasingContent[] = [];
+    const after: PhrasingContent[] = [];
+    if (isEdge(nodes[i - 1]) && /^[ \t]/.test(value)) {
+      before.push(spaceReference(value[0]));
+      value = value.slice(1);
+    }
+    if (isEdge(nodes[i + 1]) && /[ \t]$/.test(value)) {
+      after.push(spaceReference(value[value.length - 1]));
+      value = value.slice(0, -1);
+    }
+    return [...before, ...(value === '' ? [] : [{...node, value}]), ...after];
+  });
+}
+
+/** Whether `nodes` or their descendants hold raw HTML. */
+function hasHtml(nodes: readonly PhrasingContent[]): boolean {
+  return nodes.some(
+    node =>
+      node.type === 'html' || ('children' in node && hasHtml(node.children)),
+  );
+}
+
+/**
+ * A cell's content with its raw HTML as {@link cellHtml} writes it, or the
+ * content itself when it has none.
+ */
+function encodeCellHtml(nodes: PhrasingContent[]): PhrasingContent[] {
+  return hasHtml(nodes)
+    ? mapPhrasing(nodes, node =>
+        node.type === 'html' ? [html(cellHtml(node.value))] : undefined,
+      )
+    : nodes;
+}
+
+/** The line separator inside a GFM table cell, which can't hold a newline. */
+function lineBreakHtml(): Html {
+  return html('<br>');
+}
+
+/**
+ * Rewrites the line breaks in exported phrasing content (`break` nodes and
+ * newlines inside text) as `<br>`. Left alone, gfm-table would serialize
+ * them as spaces, losing the line structure.
+ */
+function breaksToHtml(nodes: readonly PhrasingContent[]): PhrasingContent[] {
+  return mapPhrasing(nodes, node => {
+    if (node.type === 'break') {
+      return [lineBreakHtml()];
+    }
+    if (node.type === 'text' && /[\r\n]/.test(node.value)) {
+      return joinLines(
+        node.value
+          .split(/\r?\n|\r/)
+          .map((value): PhrasingContent[] =>
+            value ? [{type: 'text', value}] : [],
+          ),
       );
-      const paragraph = $createParagraphNode();
-      $append(paragraph, ctx.importChildren(cell));
-      $append(cellNode, [paragraph]);
-      $append(rowNode, [cellNode]);
     }
-    $append(table, [rowNode]);
+    return undefined;
   });
-  return table;
-};
+}
+
+/** Joins lines of phrasing content with `<br>`, keeping empty lines. */
+function joinLines(lines: readonly PhrasingContent[][]): PhrasingContent[] {
+  return lines.flatMap((line, i) =>
+    i > 0 ? [lineBreakHtml(), ...line] : line,
+  );
+}
+
+/**
+ * Flattens the mdast a cell's children exported to into lines of phrasing
+ * content: a GFM cell holds a single line of inline content, so every block
+ * (paragraph, heading, list item, code line) becomes its own line.
+ */
+function cellContentLines(nodes: readonly MdastNode[]): PhrasingContent[][] {
+  const lines: PhrasingContent[][] = [];
+  const visit = (node: MdastNode) => {
+    switch (node.type) {
+      case 'paragraph':
+      case 'heading':
+      case 'tableCell':
+        lines.push(breaksToHtml(node.children));
+        return;
+      case 'code':
+        for (const value of node.value.split(/\r?\n|\r/)) {
+          lines.push(value ? [{type: 'inlineCode', value}] : []);
+        }
+        return;
+      case 'html':
+        lines.push([html(node.value)]);
+        return;
+      case 'thematicBreak':
+      case 'definition':
+        return;
+    }
+    if ('children' in node) {
+      node.children.forEach(visit);
+    } else if ('value' in node) {
+      // Phrasing content exported at the cell's top level (an inline
+      // decorator's fallback, for one) stays on the current line.
+      const phrasing = breaksToHtml([node as PhrasingContent]);
+      if (lines.length === 0) {
+        lines.push([]);
+      }
+      lines[lines.length - 1].push(...phrasing);
+    }
+  };
+  nodes.forEach(visit);
+  return lines;
+}
+
+/**
+ * Whether `value`'s characters can go in an HTML attribute value as is.
+ */
+function isPlainAttribute(value: string): boolean {
+  return /^[\w.+#-]+$/.test(value);
+}
+
+/**
+ * Exported blocks as one line of HTML tags around their Markdown phrasing
+ * (paragraphs as bare lines separated by `<br>`), or null when one of them
+ * has no such form.
+ */
+function flowHtml(nodes: readonly MdastNode[]): PhrasingContent[] | null {
+  const result: PhrasingContent[] = [];
+  let afterLine = false;
+  for (const node of nodes) {
+    if (node.type === 'paragraph') {
+      if (afterLine) {
+        result.push(lineBreakHtml());
+      }
+      result.push(...breaksToHtml(node.children));
+      afterLine = true;
+    } else {
+      const block = blockHtml(node);
+      if (block === null) {
+        return null;
+      }
+      result.push(...block);
+      afterLine = false;
+    }
+  }
+  return result;
+}
+
+/**
+ * An exported block as one line of HTML around its Markdown phrasing, which
+ * GFM allows in a cell, or null for a block with no such form here.
+ */
+function blockHtml(node: MdastNode): PhrasingContent[] | null {
+  const wrap = (
+    open: string,
+    content: PhrasingContent[] | null,
+    close: string,
+  ): PhrasingContent[] | null =>
+    content && [html(open), ...content, html(close)];
+  switch (node.type) {
+    case 'heading':
+      return wrap(
+        `<h${node.depth}>`,
+        breaksToHtml(node.children),
+        `</h${node.depth}>`,
+      );
+    case 'blockquote':
+      return wrap('<blockquote>', flowHtml(node.children), '</blockquote>');
+    case 'list': {
+      const tag = node.ordered ? 'ol' : 'ul';
+      let attributes =
+        node.ordered && typeof node.start === 'number' && node.start !== 1
+          ? ` start="${node.start}"`
+          : '';
+      // The classes GitHub renders task lists with, which the list DOM
+      // import rules read back as a check list.
+      if (node.children.some(item => typeof item.checked === 'boolean')) {
+        attributes += ' class="contains-task-list"';
+      }
+      return wrap(
+        `<${tag}${attributes}>`,
+        flowHtml(node.children),
+        `</${tag}>`,
+      );
+    }
+    case 'listItem':
+      return wrap(
+        typeof node.checked === 'boolean'
+          ? `<li class="task-list-item"><input type="checkbox" disabled${
+              node.checked ? ' checked' : ''
+            }>`
+          : '<li>',
+        flowHtml(node.children),
+        '</li>',
+      );
+    case 'code': {
+      const lines = node.value.split(/\r?\n|\r/);
+      // HTML drops a block's last `<br>`, so a code block that ends with
+      // an empty line needs one more.
+      if (lines.length > 1 && lines[lines.length - 1] === '') {
+        lines.push('');
+      }
+      return wrap(
+        node.lang && isPlainAttribute(node.lang)
+          ? `<pre data-language="${node.lang}">`
+          : '<pre>',
+        joinLines(
+          lines.map((value): PhrasingContent[] =>
+            value ? [{type: 'text', value}] : [],
+          ),
+        ),
+        '</pre>',
+      );
+    }
+    case 'thematicBreak':
+      return [html('<hr>')];
+    case 'html':
+      return [html(node.value)];
+    case 'htmlBlock': {
+      // Raw HTML around placeholders for its Markdown children. Children
+      // with only whitespace between them are one run of blocks, which
+      // `flowHtml` separates as it does elsewhere (paragraphs by `<br>`).
+      const result: PhrasingContent[] = [];
+      let run: MdastNode[] = [];
+      const flushRun = (): boolean => {
+        const content = flowHtml(run);
+        run = [];
+        if (content === null) {
+          return false;
+        }
+        result.push(...content);
+        return true;
+      };
+      const segments = splitHtmlBlock(node.value);
+      for (let i = 0; i < segments.length; i++) {
+        const segment = segments[i];
+        if (i % 2 === 1) {
+          const child = node.children[Number(segment)];
+          if (child !== undefined) {
+            run.push(child);
+          }
+        } else if (
+          run.length === 0 ||
+          i === segments.length - 1 ||
+          segment.trim() !== ''
+        ) {
+          if (!flushRun()) {
+            return null;
+          }
+          if (segment !== '') {
+            result.push(html(segment));
+          }
+        }
+      }
+      return result;
+    }
+  }
+  return null;
+}
+
+/**
+ * A cell's exported blocks as lines of phrasing content and, with
+ * {@link MdastHtmlExtension}, blocks written as one line of HTML.
+ * Without it, every block is flattened into lines (see
+ * {@link cellContentLines}).
+ */
+function cellExportItems(
+  nodes: readonly MdastNode[],
+  withHtml: boolean,
+): {block: boolean; content: PhrasingContent[]}[] {
+  const items: {block: boolean; content: PhrasingContent[]}[] = [];
+  let pending: MdastNode[] = [];
+  const flush = () => {
+    for (const content of cellContentLines(pending)) {
+      items.push({block: false, content});
+    }
+    pending = [];
+  };
+  for (const node of nodes) {
+    // Raw HTML that isn't a block element reads back as part of a line.
+    const block =
+      withHtml &&
+      node.type !== 'paragraph' &&
+      (node.type !== 'html' || BLOCK_HTML_RE.test(node.value))
+        ? blockHtml(node)
+        : null;
+    if (block === null) {
+      pending.push(node);
+    } else {
+      flush();
+      items.push({block: true, content: block});
+    }
+  }
+  flush();
+  return items;
+}
+
+/**
+ * Joins a cell's items into its content, the inverse of
+ * {@link cellItems}: lines are separated by `<br>`, and a block needs none
+ * unless the line beside it is empty. Empty lines are kept as consecutive
+ * (or leading/trailing) `<br>`s, which import back as the same empty
+ * paragraphs.
+ */
+function joinCellItems(
+  items: readonly {block: boolean; content: PhrasingContent[]}[],
+): PhrasingContent[] {
+  return items.flatMap((item, i) => {
+    const prev = items[i - 1];
+    const needsBreak =
+      prev !== undefined &&
+      (prev.block
+        ? !item.block && item.content.length === 0
+        : !item.block || prev.content.length === 0);
+    const content = item.block ? item.content : refEdgeSpaces(item.content);
+    return needsBreak ? [lineBreakHtml(), ...content] : content;
+  });
+}
+
+/** Whether the editor writes cell blocks as HTML: its HTML peer is there. */
+function $hasHtmlPeer(): boolean {
+  return (
+    $getPeerDependency<typeof MdastHtmlExtension>('@lexical/mdast/Html') !==
+    undefined
+  );
+}
+
+/**
+ * Whether a cell or one of its blocks has a format of its own, which may
+ * be one that GFM can't write (`justify`, `start`, `end`).
+ */
+function $hasFormat(cell: TableCellNode): boolean {
+  return (
+    cell.getFormatType() !== '' ||
+    cell
+      .getChildren()
+      .some(
+        child =>
+          $isElementNode(child) &&
+          !child.isInline() &&
+          child.getFormatType() !== '',
+      )
+  );
+}
+
+/**
+ * Moves a table's legacy alignment state onto the element format of its
+ * cells that have none, and clears it, so it can no longer override a
+ * column's alignment after the column is cleared or moved.
+ */
+function $migrateTableAlign(table: TableNode): void {
+  const legacyAlign = $getState(table, tableAlignState);
+  if (legacyAlign.length === 0) {
+    return;
+  }
+  for (const row of table.getChildren()) {
+    if ($isTableRowNode(row)) {
+      row
+        .getChildren()
+        .filter($isTableCellNode)
+        .forEach((cell, column) => {
+          const align = legacyAlign[column];
+          if (align && !$hasFormat(cell)) {
+            cell.setFormat(align);
+          }
+        });
+    }
+  }
+  $setState(table, tableAlignState, []);
+}
 
 const $exportTable: MdastExportHandler = (node, ctx) => {
   if (!$isTableNode(node)) {
     return null;
   }
   const rows: TableRow[] = [];
+  const legacyAlign = $getState(node, tableAlignState);
+  // The cells in each column, and how many of them have each alignment.
+  const columns: {aligned: Map<AlignType, number>; cells: number}[] = [];
+  const withHtml = $hasHtmlPeer();
+  // The header is the table's first row of cells, which a selection's
+  // export may leave out.
+  const headerRow = node
+    .getChildren()
+    .find(
+      row => $isTableRowNode(row) && row.getChildren().some($isTableCellNode),
+    );
+  // Read even when a selection's export leaves the header row out.
+  const headerAlign = $isTableRowNode(headerRow)
+    ? headerRow.getChildren().filter($isTableCellNode).map($getCellAlign)
+    : [];
   for (const row of node.getChildren()) {
     // Structural iteration bypasses the walk's selection filter, so rows a
     // selection export does not reach are skipped here. Cells stay: dropping
@@ -85,24 +879,35 @@ const $exportTable: MdastExportHandler = (node, ctx) => {
       if (!$isTableCellNode(cell)) {
         continue;
       }
-      const children: TableCell['children'] = [];
-      for (const child of cell.getChildren()) {
-        if ($isElementNode(child)) {
-          // GFM cells hold a single line of phrasing content; multiple block
-          // children (paragraphs from Enter inside the cell) are joined with
-          // hard breaks, which gfm-table serializes as spaces inside the cell.
-          if (children.length > 0) {
-            children.push({type: 'break'});
-          }
-          children.push(...ctx.exportInline(child));
-        }
+      const cellAlign = $getCellAlign(cell);
+      const column = (columns[cells.length] ??= {aligned: new Map(), cells: 0});
+      column.cells++;
+      if (cellAlign !== null) {
+        column.aligned.set(cellAlign, (column.aligned.get(cellAlign) ?? 0) + 1);
       }
-      cells.push({children, type: 'tableCell'});
+      cells.push({
+        children: encodeCellHtml(
+          joinCellItems(cellExportItems(ctx.exportChildren(cell), withHtml)),
+        ),
+        type: 'tableCell',
+      });
     }
     rows.push({children: cells, type: 'tableRow'});
   }
+  // GFM aligns columns, not cells: a column takes the alignment that most
+  // of its cells have, so aligning one body cell doesn't align its column,
+  // or else that of its header cell, the cell the delimiter row is under,
+  // so rows inserted into an aligned column don't clear it.
+  const align = columns.map((column, i): AlignType => {
+    for (const [cellAlign, count] of column.aligned) {
+      if (count * 2 > column.cells) {
+        return cellAlign;
+      }
+    }
+    return headerAlign[i] || legacyAlign[i] || null;
+  });
   return {
-    align: $getState(node, tableAlignState),
+    align,
     children: rows,
     type: 'table',
   };
@@ -112,7 +917,14 @@ const $exportTable: MdastExportHandler = (node, ctx) => {
  * GFM tables, mapped to `@lexical/table` nodes. Opt-in (not part of
  * {@link MdastCommonMarkExtension}) because it pulls in the `@lexical/table`
  * nodes it ships. The first table row is treated as the header row in both
- * directions.
+ * directions. A GFM cell holds a single line, so the paragraphs and line
+ * breaks in a cell are written as `<br>`, and `<br>` reads back as a
+ * paragraph boundary. With {@link MdastHtmlExtension} in the editor, the
+ * other blocks in a cell (lists, headings, quotes, code) are written as one
+ * line of HTML and read back as blocks; without it they are flattened into
+ * lines. Column alignment is the element format of the column's cells
+ * (`TableCellNode.setFormat`), exported as the alignment most of the
+ * column's cells have, or else its header cell's.
  *
  * @example
  * ```ts
@@ -141,4 +953,14 @@ export const MdastTableExtension = defineExtension({
   ],
   name: '@lexical/mdast/Table',
   nodes: [TableNode, TableRowNode, TableCellNode],
+  // With it, blocks a cell's single line can't express in Markdown are
+  // written as HTML.
+  peerDependencies: [
+    declarePeerDependency<typeof MdastHtmlExtension>('@lexical/mdast/Html'),
+  ],
+  // A node transform runs before anything edits a table: in the update that
+  // creates or pastes it, when the editor loads a parsed editor state (which
+  // marks every node dirty), and when the transform is registered.
+  register: editor =>
+    editor.registerNodeTransform(TableNode, $migrateTableAlign),
 });
diff --git a/packages/lexical-mdast/src/__tests__/unit/MdastImportExport.test.ts b/packages/lexical-mdast/src/__tests__/unit/MdastImportExport.test.ts
index e9b0da783f2..b8d2ab89707 100644
--- a/packages/lexical-mdast/src/__tests__/unit/MdastImportExport.test.ts
+++ b/packages/lexical-mdast/src/__tests__/unit/MdastImportExport.test.ts
@@ -8,6 +8,7 @@
 
 // @vitest-environment node
 
+import {$createCodeNode} from '@lexical/code-core';
 import {
   buildEditorFromExtensions,
   configExtension,
@@ -21,10 +22,17 @@ import {
   createImportState,
 } from '@lexical/html';
 import {$isLinkNode} from '@lexical/link';
-import {$isListNode} from '@lexical/list';
+import {$createListItemNode, $createListNode, $isListNode} from '@lexical/list';
 import {$isHeadingNode, $isQuoteNode} from '@lexical/rich-text';
-import {$isTableNode} from '@lexical/table';
 import {
+  $createTableCellNode,
+  $createTableRowNode,
+  $createTableSelectionFrom,
+  $isTableCellNode,
+  $isTableNode,
+} from '@lexical/table';
+import {
+  $createLineBreakNode,
   $createParagraphNode,
   $createTextNode,
   $getCaretRange,
@@ -34,8 +42,11 @@ import {
   $isElementNode,
   $isRangeSelection,
   $isTextNode,
+  $setSelection,
   $setSelectionFromCaretRange,
   defineExtension,
+  type ElementNode,
+  type LexicalNode,
   TEXT_TYPE_TO_FORMAT,
   type TextNode,
 } from 'lexical';
@@ -910,6 +921,363 @@ describe('@lexical/mdast import/export', () => {
       expect(importExport(out, true)).toBe(out);
     });
 
+    function editColumns(
+      markdown: string,
+      edit: (row: ElementNode) => void,
+    ): string {
+      using editor = createEditor(true);
+      editor.update(
+        () => {
+          $convertFromMarkdownString(markdown);
+          const table = $assertNodeType(
+            $getRoot().getFirstChild(),
+            $isTableNode,
+          );
+          for (const row of table.getChildren()) {
+            edit($assertNodeType(row, $isElementNode));
+          }
+        },
+        {discrete: true},
+      );
+      return editor.read(() => $convertToMarkdownString());
+    }
+
+    describe('a table aligned by the legacy table-level state', () => {
+      function legacyEditor(): LexicalEditorWithDispose {
+        const editor = createEditor(true);
+        editor.update(
+          () => $convertFromMarkdownString('| a | b |\n| - | - |\n| 1 | 2 |'),
+          {discrete: true},
+        );
+        // What a document imported before alignment moved to the cells
+        // holds: the alignment as an array on the table.
+        const json = editor.getEditorState().toJSON();
+        Object.assign(json.root.children[0], {
+          $: {mdastTableAlign: [null, 'center']},
+        });
+        editor.setEditorState(editor.parseEditorState(json));
+        return editor;
+      }
+
+      it('keeps its alignment', () => {
+        using editor = legacyEditor();
+        expect(editor.read(() => $convertToMarkdownString())).toBe(
+          '| a |  b  |\n| - | :-: |\n| 1 |  2  |',
+        );
+      });
+
+      it('loses the alignment a column edit clears', () => {
+        using editor = legacyEditor();
+        editor.update(
+          () => {
+            for (const node of $getRoot().getAllTextNodes()) {
+              $assertNodeType(
+                node.getParent()?.getParent(),
+                $isElementNode,
+              ).setFormat('');
+            }
+          },
+          {discrete: true},
+        );
+        expect(editor.read(() => $convertToMarkdownString())).toBe(
+          '| a | b |\n| - | - |\n| 1 | 2 |',
+        );
+      });
+
+      it('keeps the alignment with its column when one is inserted', () => {
+        using editor = legacyEditor();
+        editor.update(
+          () => {
+            const table = $assertNodeType(
+              $getRoot().getFirstChild(),
+              $isTableNode,
+            );
+            for (const row of table.getChildren()) {
+              $assertNodeType(row, $isElementNode).splice(0, 0, [
+                $createTableCellNode().append(
+                  $createParagraphNode().append($createTextNode('x')),
+                ),
+              ]);
+            }
+          },
+          {discrete: true},
+        );
+        expect(editor.read(() => $convertToMarkdownString())).toBe(
+          '| x | a |  b  |\n| - | - | :-: |\n| x | 1 |  2  |',
+        );
+      });
+
+      it.each(['justify', 'start', 'end'] as const)(
+        'leaves a cell its own %s format',
+        format => {
+          using editor = legacyEditor();
+          editor.update(
+            () => {
+              for (const node of $getRoot().getAllTextNodes()) {
+                const cell = $assertNodeType(
+                  node.getParent()?.getParent(),
+                  $isElementNode,
+                );
+                if (cell.getIndexWithinParent() === 1) {
+                  cell.setFormat(format);
+                }
+              }
+            },
+            {discrete: true},
+          );
+          const json = editor.getEditorState().toJSON();
+          Object.assign(json.root.children[0], {
+            $: {mdastTableAlign: [null, 'center']},
+          });
+          editor.setEditorState(editor.parseEditorState(json));
+          editor.read(() => {
+            for (const node of $getRoot().getAllTextNodes()) {
+              const cell = $assertNodeType(
+                node.getParent()?.getParent(),
+                $isElementNode,
+              );
+              expect(cell.getFormatType()).toBe(
+                cell.getIndexWithinParent() === 1 ? format : '',
+              );
+            }
+          });
+        },
+      );
+    });
+
+    it('keeps each column its alignment when a column is removed', () => {
+      expect(
+        editColumns('| a | b |\n| :- | -: |\n| 1 | 2 |', row =>
+          row.getFirstChildOrThrow().remove(),
+        ),
+      ).toBe('|  b |\n| -: |\n|  2 |');
+    });
+
+    it("renders column alignment as the cells' element format", () => {
+      using editor = createEditor(true);
+      editor.update(
+        () =>
+          $convertFromMarkdownString(
+            '| a | b | c |\n| :- | :-: | - |\n| 1 | 2 | 3 |',
+          ),
+        {discrete: true},
+      );
+      editor.read(() => {
+        const table = $assertNodeType($getRoot().getFirstChild(), $isTableNode);
+        expect(
+          table.getChildren().map(row =>
+            $assertNodeType(row, $isElementNode)
+              .getChildren()
+              .map(cell =>
+                $assertNodeType(cell, $isElementNode).getFormatType(),
+              ),
+          ),
+        ).toEqual([
+          ['left', 'center', ''],
+          ['left', 'center', ''],
+        ]);
+      });
+    });
+
+    it('exports alignment set on a cell or on all of its blocks', () => {
+      // A cell's own format (what FORMAT_ELEMENT_COMMAND sets on a table
+      // selection) or the format its paragraphs share (what it sets with
+      // the caret in one cell) aligns the cell.
+      expect(
+        editColumns('| a | b |\n| - | - |\n| 1 | 2 |', row => {
+          const [first, second] = row.getChildren();
+          $assertNodeType(first, $isElementNode).setFormat('right');
+          for (const child of $assertNodeType(
+            second,
+            $isElementNode,
+          ).getChildren()) {
+            $assertNodeType(child, $isElementNode).setFormat('center');
+          }
+        }),
+      ).toBe('|  a |  b  |\n| -: | :-: |\n|  1 |  2  |');
+    });
+
+    it.each([
+      ['| a |\n| - |\n| 1 |\n| 2 |', [1], '| a |\n| - |\n| 1 |\n| 2 |'],
+      ['| a |\n| - |\n| 1 |', [1], '| a |\n| - |\n| 1 |'],
+      [
+        '| a |\n| - |\n| 1 |\n| 2 |',
+        [1, 2],
+        '|  a  |\n| :-: |\n|  1  |\n|  2  |',
+      ],
+    ])(
+      'aligns a column that most of its cells are aligned in: %j, rows %j',
+      (markdown, rows, expected) => {
+        // GFM aligns columns, not cells, so aligning one cell doesn't align
+        // the others in its column.
+        expect(
+          editColumns(markdown, row => {
+            if (rows.includes(row.getIndexWithinParent())) {
+              for (const child of $assertNodeType(
+                row.getFirstChild(),
+                $isElementNode,
+              ).getChildren()) {
+                $assertNodeType(child, $isElementNode).setFormat('center');
+              }
+            }
+          }),
+        ).toBe(expected);
+      },
+    );
+
+    it('keeps a column aligned when a row is inserted above the header', () => {
+      expect(
+        editColumns('| a |\n| :-: |\n| 1 |\n| 2 |', row => {
+          if (row.getIndexWithinParent() === 0) {
+            row.insertBefore(
+              $createTableRowNode().append(
+                $createTableCellNode().append(
+                  $createParagraphNode().append($createTextNode('x')),
+                ),
+              ),
+            );
+          }
+        }),
+      ).toBe('|  x  |\n| :-: |\n|  a  |\n|  1  |\n|  2  |');
+    });
+
+    it('keeps a column aligned when rows are inserted below the header', () => {
+      expect(
+        editColumns('| a |\n| :-: |\n| 1 |', row => {
+          if (row.getIndexWithinParent() === 1) {
+            for (const text of ['x', 'y', 'z']) {
+              row.insertBefore(
+                $createTableRowNode().append(
+                  $createTableCellNode().append(
+                    $createParagraphNode().append($createTextNode(text)),
+                  ),
+                ),
+              );
+            }
+          }
+        }),
+      ).toBe('|  a  |\n| :-: |\n|  x  |\n|  y  |\n|  z  |\n|  1  |');
+    });
+
+    it('aligns a column by its header cell alone', () => {
+      expect(
+        editColumns('| a |\n| - |\n| 1 |\n| 2 |', row => {
+          if (row.getIndexWithinParent() === 0) {
+            $assertNodeType(row.getFirstChild(), $isElementNode).setFormat(
+              'right',
+            );
+          }
+        }),
+      ).toBe('|  a |\n| -: |\n|  1 |\n|  2 |');
+    });
+
+    it('aligns a column by most of its cells over its header cell', () => {
+      expect(
+        editColumns('| a |\n| -: |\n| 1 |\n| 2 |', row => {
+          if (row.getIndexWithinParent() > 0) {
+            $assertNodeType(row.getFirstChild(), $isElementNode).setFormat(
+              'center',
+            );
+          }
+        }),
+      ).toBe('|  a  |\n| :-: |\n|  1  |\n|  2  |');
+    });
+
+    it("takes the header from the table's first row with cells", () => {
+      expect(
+        editColumns('| a |\n| - |\n| 1 |\n| 2 |', row => {
+          if (row.getIndexWithinParent() === 0) {
+            $assertNodeType(row.getFirstChild(), $isElementNode).setFormat(
+              'right',
+            );
+            row.insertBefore($createTableRowNode());
+          }
+        }),
+      ).toBe('|    |\n| -: |\n|  a |\n|  1 |\n|  2 |');
+    });
+
+    it('takes no header alignment from a selection without the header row', () => {
+      using editor = createEditor(true);
+      editor.update(
+        () => {
+          $convertFromMarkdownString('| a |\n| - |\n| 1 |\n| 2 |\n| 3 |');
+          const table = $assertNodeType(
+            $getRoot().getFirstChild(),
+            $isTableNode,
+          );
+          const [, first, , last] = table.getChildren();
+          const cell = (row: LexicalNode) =>
+            $assertNodeType(
+              $assertNodeType(row, $isElementNode).getFirstChild(),
+              $isTableCellNode,
+            );
+          cell(first).setFormat('right');
+          $setSelection(
+            $createTableSelectionFrom(table, cell(first), cell(last)),
+          );
+        },
+        {discrete: true},
+      );
+      expect(editor.read(() => $convertSelectionToMarkdownString())).toBe(
+        '| 1 |\n| - |\n| 2 |\n| 3 |',
+      );
+    });
+
+    it("takes the header cell's alignment into a selection without it", () => {
+      using editor = createEditor(true);
+      editor.update(
+        () => {
+          $convertFromMarkdownString('| a |\n| :-: |\n| 1 |');
+          const table = $assertNodeType(
+            $getRoot().getFirstChild(),
+            $isTableNode,
+          );
+          const [header, row] = table.getChildren();
+          const cell = (node: LexicalNode) =>
+            $assertNodeType(
+              $assertNodeType(node, $isElementNode).getFirstChild(),
+              $isTableCellNode,
+            );
+          for (const text of ['2', '3']) {
+            row.insertAfter(
+              $createTableRowNode().append(
+                $createTableCellNode().append(
+                  $createParagraphNode().append($createTextNode(text)),
+                ),
+              ),
+            );
+          }
+          cell(row).setFormat('');
+          $setSelection(
+            $createTableSelectionFrom(
+              table,
+              cell(row),
+              cell(table.getLastChildOrThrow()),
+            ),
+          );
+          expect(cell(header).getFormatType()).toBe('center');
+        },
+        {discrete: true},
+      );
+      expect(editor.read(() => $convertSelectionToMarkdownString())).toBe(
+        '|  1  |\n| :-: |\n|  3  |\n|  2  |',
+      );
+    });
+
+    it('gives an inserted column no alignment', () => {
+      expect(
+        editColumns('| a | b |\n| :- | -: |\n| 1 | 2 |', row =>
+          row
+            .getFirstChildOrThrow()
+            .insertBefore(
+              $createTableCellNode().append(
+                $createParagraphNode().append($createTextNode('x')),
+              ),
+            ),
+        ),
+      ).toBe('| x | a  |  b |\n| - | :- | -: |\n| x | 1  |  2 |');
+    });
+
     it('joins multi-paragraph cells instead of fusing their text', () => {
       using editor = createEditor(true);
       editor.update(
@@ -928,7 +1296,104 @@ describe('@lexical/mdast import/export', () => {
         {discrete: true},
       );
       const out = editor.read(() => $convertToMarkdownString());
-      expect(out).toContain('| foo bar |');
+      expect(out).toContain('| foo<br>bar |');
+    });
+
+    function cellOf(markdown: string): string {
+      // The second row's first cell, as exported.
+      return markdown.split('\n')[2].replace(/^\| (.*?) *\|$/, '$1');
+    }
+
+    function exportCell(...children: (() => LexicalNode)[]): string {
+      using editor = createEditor(true);
+      editor.update(
+        () => {
+          $convertFromMarkdownString('| a |\n| - |\n| x |');
+          const table = $assertNodeType(
+            $getRoot().getFirstChild(),
+            $isTableNode,
+          );
+          const lastRow = $assertNodeType(table.getLastChild(), $isElementNode);
+          const cell = $assertNodeType(lastRow.getFirstChild(), $isElementNode);
+          cell.clear().append(...children.map(f => f()));
+        },
+        {discrete: true},
+      );
+      return editor.read(() => $convertToMarkdownString());
+    }
+
+    const text = (value: string) => () =>
+      $createParagraphNode().append($createTextNode(value));
+
+    // https://github.com/facebook/lexical/issues/9323
+    it('writes line breaks in a cell as <br>, never a newline', () => {
+      const cases: [string, string][] = [
+        [
+          exportCell(() =>
+            $createParagraphNode().append(
+              $createTextNode('a'),
+              $createLineBreakNode(),
+              $createTextNode('b'),
+            ),
+          ),
+          'a<br>b',
+        ],
+        [exportCell(text('a'), text('b')), 'a<br>b'],
+        [exportCell(text('a'), text(''), text('b')), 'a<br><br>b'],
+        [exportCell(text('a\nb')), 'a<br>b'],
+        [
+          exportCell(() =>
+            $createListNode('bullet').append(
+              $createListItemNode().append($createTextNode('x')),
+              $createListItemNode().append($createTextNode('y')),
+            ),
+          ),
+          'x<br>y',
+        ],
+        [
+          exportCell(() =>
+            $createCodeNode().append(
+              $createTextNode('l1'),
+              $createLineBreakNode(),
+              $createTextNode('l2'),
+            ),
+          ),
+          '`l1`<br>`l2`',
+        ],
+      ];
+      for (const [out, expected] of cases) {
+        expect(out.split('\n')).toHaveLength(3);
+        expect(cellOf(out)).toBe(expected);
+        expect(importExport(out, true)).toBe(out);
+      }
+    });
+
+    it('reads <br> in a cell as a paragraph boundary', () => {
+      using editor = createEditor(true);
+      editor.update(
+        () => {
+          $convertFromMarkdownString(
+            '| a |\n| - |\n| x <br/> y<BR /><br>**z<br>w** |',
+          );
+        },
+        {discrete: true},
+      );
+      editor.read(() => {
+        const table = $assertNodeType($getRoot().getFirstChild(), $isTableNode);
+        const lastRow = $assertNodeType(table.getLastChild(), $isElementNode);
+        const cell = $assertNodeType(lastRow.getFirstChild(), $isElementNode);
+        expect(cell.getChildren().map(p => p.getTextContent())).toEqual([
+          'x',
+          'y',
+          '',
+          'z\nw',
+        ]);
+      });
+      expect(
+        cellOf(
+          importExport('| a |\n| - |\n| x <br/> y<BR /><br>**z<br>w** |', true),
+        ),
+      ).toBe('x<br>y<br><br>**z**<br>**w**');
     });
   });
 
diff --git a/packages/lexical-mdast/src/__tests__/unit/MdastSourceOffsets.test.ts b/packages/lexical-mdast/src/__tests__/unit/MdastSourceOffsets.test.ts
new file mode 100644
index 00000000000..56c1ca3705b
--- /dev/null
+++ b/packages/lexical-mdast/src/__tests__/unit/MdastSourceOffsets.test.ts
@@ -0,0 +1,146 @@
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ */
+
+// @vitest-environment node
+
+import type {Nodes as MdastNode, Root} from 'mdast';
+
+import {
+  buildEditorFromExtensions,
+  configExtension,
+  type LexicalEditorWithDispose,
+} from '@lexical/extension';
+import {$isHeadingNode} from '@lexical/rich-text';
+import {
+  $createParagraphNode,
+  $getRoot,
+  $getSelection,
+  $isRangeSelection,
+  defineExtension,
+} from 'lexical';
+import {describe, expect, it} from 'vitest';
+
+import {
+  $convertFromMarkdownString,
+  $convertToMarkdownString,
+  MdastCommonMarkExtension,
+  MdastExtension,
+  MdastGfmExtension,
+  MdastShortcutsExtension,
+} from '../../index';
+
+// A tree transform may leave points with only lines and columns, the way
+// some remark plugins rebuild positions.
+const dropOffsets = (node: MdastNode) => {
+  if (node.position) {
+    delete node.position.start.offset;
+    delete node.position.end.offset;
+  }
+  if ('children' in node) {
+    node.children.forEach(dropOffsets);
+  }
+};
+
+// One frozen position shared by every node, which a transform may also do.
+const FROZEN = Object.freeze({
+  end: Object.freeze({column: 1, line: 1}),
+  start: Object.freeze({column: 1, line: 1}),
+});
+const freezePositions = (node: MdastNode) => {
+  node.position = FROZEN;
+  if ('children' in node) {
+    node.children.forEach(freezePositions);
+  }
+};
+
+function createEditor(
+  transform: (tree: Root) => void,
+  withShortcuts = false,
+): LexicalEditorWithDispose {
+  return buildEditorFromExtensions(
+    defineExtension({
+      dependencies: [
+        MdastCommonMarkExtension,
+        MdastGfmExtension,
+        ...(withShortcuts ? [MdastShortcutsExtension] : []),
+        configExtension(MdastExtension, {
+          mdastExtensions: [{transforms: [transform]}],
+        }),
+      ],
+      name: '[root]',
+    }),
+  );
+}
+
+describe('a tree whose points have no offsets', () => {
+  // Each reads how it was written from the source, by offset.
+  it.each([
+    ['a setext heading', 'h\n='],
+    ['a list marker', '* a\n* b'],
+    ['a code fence', '~~~js\nx\n~~~'],
+    ['a line break of spaces', 'a  \nb'],
+    ['an autolink', '<https://example.com>'],
+  ])('keeps %s as written', (_, markdown) => {
+    using editor = createEditor(dropOffsets);
+    editor.update(() => $convertFromMarkdownString(markdown), {
+      discrete: true,
+    });
+    expect(editor.read(() => $convertToMarkdownString())).toBe(markdown);
+  });
+
+  it('keeps the text of a reference with no definition', () => {
+    using editor = createEditor(dropOffsets);
+    editor.update(() => $convertFromMarkdownString('[a][nope]'), {
+      discrete: true,
+    });
+    expect(editor.read(() => $getRoot().getTextContent())).toBe('[a][nope]');
+  });
+
+  it('imports with a frozen position shared by its nodes', () => {
+    // With no offset to read, the list marker is the default one.
+    using editor = createEditor(freezePositions);
+    editor.update(() => $convertFromMarkdownString('# h\n\n* a'), {
+      discrete: true,
+    });
+    expect(editor.read(() => $convertToMarkdownString())).toBe('# h\n\n- a');
+  });
+
+  it.each([
+    ['a block shortcut', ['#', ' '], '', true],
+    ['an inline shortcut', ['a **b*', '*'], 'a b', false],
+  ])('fires %s while typing', (_, chunks, text, isHeading) => {
+    using editor = createEditor(dropOffsets, true);
+    editor.update(
+      () => {
+        const paragraph = $createParagraphNode();
+        $getRoot().clear().append(paragraph);
+        paragraph.selectEnd();
+      },
+      {discrete: true},
+    );
+    for (const chunk of chunks) {
+      editor.update(
+        () => {
+          const selection = $getSelection();
+          if ($isRangeSelection(selection)) {
+            selection.insertText(chunk);
+          }
+        },
+        {discrete: true},
+      );
+    }
+    editor.read(() => {
+      const block = $getRoot().getFirstChild();
+      expect(block && block.getTextContent()).toBe(text);
+      expect($isHeadingNode(block)).toBe(isHeading);
+      if (!isHeading) {
+        expect($getRoot().getAllTextNodes()[1].hasFormat('bold')).toBe(true);
+      }
+    });
+  });
+});
diff --git a/packages/lexical-mdast/src/__tests__/unit/MdastTableHtml.test.ts b/packages/lexical-mdast/src/__tests__/unit/MdastTableHtml.test.ts
new file mode 100644
index 00000000000..9fe682c35c2
--- /dev/null
+++ b/packages/lexical-mdast/src/__tests__/unit/MdastTableHtml.test.ts
@@ -0,0 +1,529 @@
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ */
+
+import type {Nodes as MdastNode, RootContent} from 'mdast';
+
+import {$createCodeNode, CodeExtension} from '@lexical/code-core';
+import {
+  buildEditorFromExtensions,
+  configExtension,
+  type LexicalEditorWithDispose,
+} from '@lexical/extension';
+import {
+  $createListItemNode,
+  $createListNode,
+  ListExtension,
+} from '@lexical/list';
+import {
+  $createHeadingNode,
+  $createQuoteNode,
+  QuoteNode,
+  RichTextExtension,
+} from '@lexical/rich-text';
+import {
+  $createTableCellNode,
+  $createTableNode,
+  $createTableRowNode,
+  $isTableCellNode,
+  TableCellHeaderStates,
+  TableExtension,
+} from '@lexical/table';
+import {
+  $createLineBreakNode,
+  $createParagraphNode,
+  $createTextNode,
+  $getRoot,
+  $isElementNode,
+  $isTextNode,
+  defineExtension,
+  type LexicalNode,
+} from 'lexical';
+import {describe, expect, it} from 'vitest';
+
+import {
+  $convertFromMarkdownString,
+  $convertToMarkdownString,
+  MdastCommonMarkExtension,
+  MdastExtension,
+  MdastHtmlExtension,
+  MdastTableExtension,
+  MdastTaskListExtension,
+  rawHtmlBlock,
+} from '../../index';
+
+function createEditor(withHtml: boolean): LexicalEditorWithDispose {
+  // The caller is responsible for disposal (with `using`).
+  return buildEditorFromExtensions(
+    defineExtension({
+      dependencies: [
+        MdastCommonMarkExtension,
+        MdastTaskListExtension,
+        MdastTableExtension,
+        ...(withHtml ? [MdastHtmlExtension] : []),
+        // Node packages whose DOM import rules the cell HTML should reach.
+        RichTextExtension,
+        ListExtension,
+        CodeExtension,
+        TableExtension,
+      ],
+      name: '[root]',
+    }),
+  );
+}
+
+/** The body row's cell content, without the column padding. */
+function bodyLine(markdown: string): string {
+  return markdown.split('\n')[2].replace(/^\| | +\|$/g, '');
+}
+
+function table(body: string): string {
+  return `| a |\n| - |\n| ${body} |`;
+}
+
+/** The second row's cell as a compact tree of node types and texts. */
+function $bodyCellShape(): unknown {
+  const shape = (node: LexicalNode): unknown => {
+    if ($isTextNode(node)) {
+      return node.getTextContent();
+    }
+    if (!$isElementNode(node)) {
+      return node.getType();
+    }
+    const json = node.exportJSON() as {
+      checked?: boolean;
+      language?: string;
+      listType?: string;
+      tag?: string;
+    };
+    const label = [
+      node.getType(),
+      json.tag,
+      json.listType,
+      json.checked,
+      json.language,
+    ]
+      .filter(part => part !== undefined)
+      .join(':');
+    return {[label]: node.getChildren().map(shape)};
+  };
+  const tableNode = $getRoot().getFirstChildOrThrow();
+  const row = $isElementNode(tableNode) ? tableNode.getChildAtIndex(1) : null;
+  const cell = $isElementNode(row) ? row.getFirstChild() : null;
+  return $isElementNode(cell) ? cell.getChildren().map(shape) : null;
+}
+
+function importCell(markdown: string): {markdown: string; shape: unknown} {
+  using editor = createEditor(true);
+  editor.update(() => $convertFromMarkdownString(markdown), {discrete: true});
+  return editor.read(() => ({
+    markdown: $convertToMarkdownString(),
+    shape: $bodyCellShape(),
+  }));
+}
+
+function $appendCell(...children: LexicalNode[]): void {
+  $getRoot()
+    .clear()
+    .append(
+      $createTableNode().append(
+        $createTableRowNode().append(
+          $createTableCellNode(TableCellHeaderStates.ROW).append(
+            $createParagraphNode().append($createTextNode('a')),
+          ),
+        ),
+        $createTableRowNode().append(
+          $createTableCellNode().append(...children),
+        ),
+      ),
+    );
+}
+
+function $buildBlocks(): void {
+  $appendCell(
+    $createParagraphNode().append($createTextNode('intro')),
+    $createListNode('number', 3).append(
+      $createListItemNode().append($createTextNode('one')),
+      $createListItemNode().append(
+        $createListNode('bullet').append(
+          $createListItemNode().append($createTextNode('nested')),
+        ),
+      ),
+    ),
+    $createHeadingNode('h3').append($createTextNode('title')),
+    $createCodeNode('js').append(
+      $createTextNode('a | *b*'),
+      $createLineBreakNode(),
+      $createTextNode('  c'),
+    ),
+    $createParagraphNode(),
+  );
+}
+
+describe('MdastTableExtension with MdastHtmlExtension', () => {
+  it('writes blocks in a cell as one line of HTML and reads them back', () => {
+    using editor = createEditor(true);
+    editor.update($buildBlocks, {discrete: true});
+    const markdown = editor.read(() => $convertToMarkdownString());
+    expect(bodyLine(markdown)).toBe(
+      'intro<ol start="3"><li>one<ul><li>nested</li></ul></li></ol><h3>title</h3><pre data-language="js">a \\| \\*b\\*<br>  c</pre><br>',
+    );
+    const shape = editor.read($bodyCellShape);
+    editor.update(() => $convertFromMarkdownString(markdown), {discrete: true});
+    expect(editor.read($bodyCellShape)).toEqual(shape);
+    expect(editor.read(() => $convertToMarkdownString())).toBe(markdown);
+  });
+
+  it.each(['\nx\n', 'x\n\n', '\n'])(
+    'keeps the empty last line of a code block in a cell: %j',
+    code => {
+      using editor = createEditor(true);
+      editor.update(
+        () =>
+          $appendCell(
+            $createCodeNode('js').append(
+              ...code
+                .split('\n')
+                .flatMap((line, i): LexicalNode[] => [
+                  ...(i > 0 ? [$createLineBreakNode()] : []),
+                  ...(line ? [$createTextNode(line)] : []),
+                ]),
+            ),
+          ),
+        {discrete: true},
+      );
+      const markdown = editor.read(() => $convertToMarkdownString());
+      editor.update(() => $convertFromMarkdownString(markdown), {
+        discrete: true,
+      });
+      expect(editor.read(() => $convertToMarkdownString())).toBe(markdown);
+      const cellCode = editor.read(() => {
+        const shape = $bodyCellShape() as {'code:js': unknown[]}[];
+        return shape[0]['code:js'];
+      });
+      expect(
+        cellCode.map(part => (part === 'linebreak' ? '\n' : part)).join(''),
+      ).toBe(code);
+    },
+  );
+
+  it('keeps a block exported as inline HTML on a line of its own', () => {
+    using editor = buildEditorFromExtensions(
+      defineExtension({
+        dependencies: [
+          configExtension(MdastExtension, {
+            exportRules: [
+              {
+                $export: () => [{type: 'html', value: '<span>x</span>'}],
+                type: QuoteNode,
+              },
+            ],
+          }),
+          MdastCommonMarkExtension,
+          MdastTableExtension,
+          MdastHtmlExtension,
+          RichTextExtension,
+          TableExtension,
+        ],
+        name: '[root]',
+      }),
+    );
+    editor.update(
+      () =>
+        $appendCell(
+          $createParagraphNode().append($createTextNode('a')),
+          $createQuoteNode().append($createTextNode('q')),
+        ),
+      {discrete: true},
+    );
+    expect(bodyLine(editor.read(() => $convertToMarkdownString()))).toBe(
+      'a<br><span>x</span>',
+    );
+  });
+
+  function exportRawHtml(
+    withHtml: boolean,
+    $export: () => RootContent[],
+  ): LexicalEditorWithDispose {
+    const editor = buildEditorFromExtensions(
+      defineExtension({
+        dependencies: [
+          configExtension(MdastExtension, {
+            exportRules: [{$export, type: QuoteNode}],
+          }),
+          MdastCommonMarkExtension,
+          MdastTableExtension,
+          ...(withHtml ? [MdastHtmlExtension] : []),
+          RichTextExtension,
+          TableExtension,
+        ],
+        name: '[root]',
+      }),
+    );
+    editor.update(
+      () => $appendCell($createQuoteNode().append($createTextNode('q'))),
+      {discrete: true},
+    );
+    return editor;
+  }
+
+  it.each([
+    [
+      '<pre>a|b\n  c</pre><span\ntitle="x|y\nz">w</span>',
+      '<pre>a&#124;b&#10;  c</pre><span title="x&#124;y&#10;z">w</span>',
+    ],
+    [
+      "<!-- don't -->\n<b\nclass='a b'>y</b>",
+      "<!-- don't -->&#10;<b class='a b'>y</b>",
+    ],
+    [
+      '<div style="white-space: pre-wrap">a\n\u00a0b</div>',
+      '<div style="white-space: pre-wrap">a&#10;\u00a0b</div>',
+    ],
+    [
+      '<textarea>a<b\nc</textarea><script>a||b\nc</script>',
+      '<textarea>a<b&#10;c</textarea><script>a&#124;&#124;b c</script>',
+    ],
+  ])('writes raw HTML %j in a cell on one line', (value, line) => {
+    using editor = exportRawHtml(false, () => [{type: 'html', value}]);
+    expect(bodyLine(editor.read(() => $convertToMarkdownString()))).toBe(line);
+  });
+
+  it('reads the newlines and pipes of raw HTML in a cell back', () => {
+    using editor = exportRawHtml(true, () => [
+      {type: 'html', value: '<pre>a|b\n  c</pre>'},
+    ]);
+    const markdown = editor.read(() => $convertToMarkdownString());
+    editor.update(() => $convertFromMarkdownString(markdown), {
+      discrete: true,
+    });
+    expect(editor.read(() => $getRoot().getTextContent())).toContain(
+      'a|b\n  c',
+    );
+  });
+
+  it('writes an htmlBlock in a cell on one line', () => {
+    using editor = exportRawHtml(true, () => [
+      rawHtmlBlock(
+        '<details><summary>\n',
+        [{type: 'text', value: 's|t'}],
+        '\n</summary>\n\n',
+        {
+          flow: [
+            {children: [{type: 'text', value: 'b'}], type: 'paragraph'},
+            {children: [{type: 'text', value: 'c'}], type: 'paragraph'},
+          ],
+        },
+        '\n</details>',
+      ),
+    ]);
+    const markdown = editor.read(() => $convertToMarkdownString());
+    expect(markdown.split('\n')).toHaveLength(3);
+    expect(bodyLine(markdown)).toBe(
+      '<details><summary>&#10;s\\|t&#10;</summary>&#10;&#10;b<br>c&#10;</details>',
+    );
+  });
+
+  it.each([false, true])(
+    'keeps the spaces at the edges of a line in a cell (HTML extension: %s)',
+    withHtml => {
+      using editor = createEditor(withHtml);
+      editor.update(
+        () =>
+          $appendCell(
+            $createParagraphNode().append(
+              $createTextNode('a  '),
+              $createLineBreakNode(),
+              $createTextNode('\tb'),
+            ),
+            $createParagraphNode().append($createTextNode(' ')),
+            $createParagraphNode().append($createTextNode('c ')),
+          ),
+        {discrete: true},
+      );
+      const markdown = editor.read(() => $convertToMarkdownString());
+      editor.update(() => $convertFromMarkdownString(markdown), {
+        discrete: true,
+      });
+      const cell = editor.read(() =>
+        $getRoot()
+          .getLastDescendant()
+          ?.getParents()
+          .find($isTableCellNode)
+          ?.getChildren()
+          .map(node => node.getTextContent()),
+      );
+      expect(cell).toEqual(['a  ', '\tb', ' ', 'c ']);
+      expect(editor.read(() => $convertToMarkdownString())).toBe(markdown);
+    },
+  );
+
+  it('still trims the spaces written around a <br>', () => {
+    using editor = createEditor(false);
+    editor.update(() => $convertFromMarkdownString(table('a <br>  b')), {
+      discrete: true,
+    });
+    expect(
+      editor.read(() =>
+        $getRoot()
+          .getLastDescendant()
+          ?.getParents()
+          .find($isTableCellNode)
+          ?.getChildren()
+          .map(node => node.getTextContent()),
+      ),
+    ).toEqual(['a', 'b']);
+  });
+
+  it('keeps a line of only whitespace after a block in a cell', () => {
+    using editor = createEditor(true);
+    editor.update(
+      () =>
+        $appendCell(
+          $createListNode('bullet').append(
+            $createListItemNode().append($createTextNode('a')),
+          ),
+          $createParagraphNode().append($createTextNode('  ')),
+          $createListNode('bullet').append(
+            $createListItemNode().append($createTextNode('b')),
+          ),
+          // Not padding in GFM, so not trimmed either.
+          $createParagraphNode().append($createTextNode('\u00a0')),
+          $createParagraphNode().append($createTextNode(' x ')),
+        ),
+      {discrete: true},
+    );
+    const markdown = editor.read(() => $convertToMarkdownString());
+    editor.update(() => $convertFromMarkdownString(markdown), {
+      discrete: true,
+    });
+    expect(
+      editor.read(() =>
+        $getRoot()
+          .getLastDescendant()
+          ?.getParents()
+          .find($isTableCellNode)
+          ?.getChildren()
+          .map(node => [node.getType(), node.getTextContent()]),
+      ),
+    ).toEqual([
+      ['list', 'a'],
+      ['paragraph', '  '],
+      ['list', 'b'],
+      ['paragraph', '\u00a0'],
+      ['paragraph', ' x '],
+    ]);
+  });
+
+  it.each([
+    ['', 'a <br>  b', ['a', 'b']],
+    ['', 'a<br>&#32;b', ['a', ' b']],
+    // Blank lines before it, which line starts must count one at a time.
+    ['x\n\n\n', 'a<br>&#32;b', ['a', ' b']],
+  ])('reads %j%j in a tree without offsets', (prefix, body, lines) => {
+    // A tree transform may leave nodes with lines and columns only.
+    const dropOffsets = (node: MdastNode) => {
+      if (node.position) {
+        delete node.position.start.offset;
+        delete node.position.end.offset;
+      }
+      if ('children' in node) {
+        node.children.forEach(dropOffsets);
+      }
+    };
+    using editor = buildEditorFromExtensions(
+      defineExtension({
+        dependencies: [
+          MdastCommonMarkExtension,
+          MdastTableExtension,
+          TableExtension,
+          configExtension(MdastExtension, {
+            mdastExtensions: [{transforms: [dropOffsets]}],
+          }),
+        ],
+        name: '[root]',
+      }),
+    );
+    editor.update(() => $convertFromMarkdownString(prefix + table(body)), {
+      discrete: true,
+    });
+    expect(
+      editor.read(() =>
+        $getRoot()
+          .getLastDescendant()
+          ?.getParents()
+          .find($isTableCellNode)
+          ?.getChildren()
+          .map(node => node.getTextContent()),
+      ),
+    ).toEqual(lines);
+  });
+
+  it('flattens the same blocks into lines without MdastHtmlExtension', () => {
+    using editor = createEditor(false);
+    editor.update($buildBlocks, {discrete: true});
+    expect(bodyLine(editor.read(() => $convertToMarkdownString()))).toBe(
+      'intro<br>one<br>nested<br>title<br>`a \\| *b*`<br>`  c`<br>',
+    );
+  });
+
+  it('reads a GitHub task list, a quote and a rule in a cell', () => {
+    const markdown = table(
+      '<ul class="contains-task-list"><li class="task-list-item"><input type="checkbox" disabled checked>done</li><li class="task-list-item"><input type="checkbox" disabled>todo</li></ul><blockquote>q<br>**r**</blockquote><hr>',
+    );
+    const result = importCell(markdown);
+    expect(result.shape).toEqual([
+      {
+        'list:ul:check': [
+          {'listitem:true': ['done']},
+          {'listitem:false': ['todo']},
+        ],
+      },
+      {quote: ['q', 'linebreak', 'r']},
+      'horizontalrule',
+    ]);
+    expect(bodyLine(result.markdown)).toBe(bodyLine(markdown));
+  });
+
+  it.each([
+    [
+      'x<ul><li>i</li></ul>y',
+      [
+        {paragraph: ['x']},
+        {'list:ul:bullet': [{listitem: ['i']}]},
+        {paragraph: ['y']},
+      ],
+    ],
+    [
+      '<br><ul><li>i</li></ul>',
+      [{paragraph: []}, {'list:ul:bullet': [{listitem: ['i']}]}],
+    ],
+    [
+      '<ul><li>i</li></ul><br>',
+      [{'list:ul:bullet': [{listitem: ['i']}]}, {paragraph: []}],
+    ],
+    [
+      '<ul><li>i</li></ul><br><br>y',
+      [
+        {'list:ul:bullet': [{listitem: ['i']}]},
+        {paragraph: []},
+        {paragraph: ['y']},
+      ],
+    ],
+    [
+      '<ul><li>i</li></ul> <h2>h</h2>',
+      [{'list:ul:bullet': [{listitem: ['i']}]}, {'heading:h2': ['h']}],
+    ],
+  ])('reads %s as the cell blocks it separates', (body, shape) => {
+    const result = importCell(table(body));
+    expect(result.shape).toEqual(shape);
+    // The lines beside a block keep their `<br>`s only where they're empty.
+    expect(bodyLine(result.markdown)).toBe(
+      body.replace('</ul> <h2>', '</ul><h2>'),
+    );
+  });
+});
diff --git a/packages/lexical-mdast/src/htmlBlockParts.ts b/packages/lexical-mdast/src/htmlBlockParts.ts
new file mode 100644
index 00000000000..dc667d4122c
--- /dev/null
+++ b/packages/lexical-mdast/src/htmlBlockParts.ts
@@ -0,0 +1,25 @@
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ */
+
+/**
+ * The placeholder an `htmlBlock`'s raw HTML holds for its `index`th
+ * Markdown child.
+ */
+export function htmlBlockPlaceholder(index: number): string {
+  return `<template data-mdast-child="${index}"></template>`;
+}
+
+const PLACEHOLDER_SPLIT_RE = /<template data-mdast-child="(\d+)"><\/template>/;
+
+/**
+ * An `htmlBlock`'s value split at its placeholders: the even entries are
+ * raw HTML, and the odd ones the indices of the children they stand for.
+ */
+export function splitHtmlBlock(value: string): string[] {
+  return value.split(PLACEHOLDER_SPLIT_RE);
+}
diff --git a/packages/lexical-mdast/src/sourceOffsets.ts b/packages/lexical-mdast/src/sourceOffsets.ts
new file mode 100644
index 00000000000..bdf3aea5e50
--- /dev/null
+++ b/packages/lexical-mdast/src/sourceOffsets.ts
@@ -0,0 +1,81 @@
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ */
+
+import type {CompiledMdast} from './types';
+import type {Nodes, Root} from 'mdast';
+
+import {fromMarkdown} from 'mdast-util-from-markdown';
+
+type Point = NonNullable<Nodes['position']>['start'];
+
+/**
+ * Parses `markdown` with the registry's extensions. The import reads the
+ * source by offset, so every parse whose tree is imported goes through here,
+ * which also fills the offsets a tree transform left out.
+ */
+export function parseMarkdown(
+  compiled: Pick<CompiledMdast, 'mdastExtensions' | 'micromarkExtensions'>,
+  markdown: string,
+): Root {
+  const tree = fromMarkdown(markdown, {
+    extensions: compiled.micromarkExtensions,
+    mdastExtensions: compiled.mdastExtensions,
+  });
+  // Only a tree transform can leave a point without an offset.
+  if (
+    compiled.mdastExtensions
+      .flat()
+      .some(extension => extension.transforms && extension.transforms.length)
+  ) {
+    fillOffsets(tree, markdown);
+  }
+  return tree;
+}
+
+/**
+ * Gives each point in `tree` that has a line and column but no offset the
+ * offset they stand for in `source`, which the tree was parsed from. A tree
+ * transform may leave points without offsets, and the import reads the
+ * source by offset.
+ */
+export function fillOffsets(tree: Nodes, source: string): void {
+  let lineStarts: number[] | null = null;
+  const fill = (point: Point) => {
+    if (
+      point.offset != null ||
+      point.line == null ||
+      point.column == null ||
+      // A transform may share one frozen position; it keeps no offset.
+      Object.isFrozen(point)
+    ) {
+      return;
+    }
+    if (lineStarts === null) {
+      lineStarts = [0];
+      for (const match of source.matchAll(/\r\n?|\n/g)) {
+        lineStarts.push(match.index + match[0].length);
+      }
+    }
+    const lineStart = lineStarts[point.line - 1];
+    if (lineStart !== undefined) {
+      point.offset = lineStart + point.column - 1;
+    }
+  };
+  const stack: Nodes[] = [tree];
+  for (let node = stack.pop(); node !== undefined; node = stack.pop()) {
+    if (node.position) {
+      fill(node.position.start);
+      fill(node.position.end);
+    }
+    if ('children' in node) {
+      for (const child of node.children as Nodes[]) {
+        stack.push(child);
+      }
+    }
+  }
+}
diff --git a/packages/lexical-playground/__tests__/unit/MarkdownTransformers.test.ts b/packages/lexical-playground/__tests__/unit/MarkdownTransformers.test.ts
index 5328e9b870b..a0555334cb6 100644
--- a/packages/lexical-playground/__tests__/unit/MarkdownTransformers.test.ts
+++ b/packages/lexical-playground/__tests__/unit/MarkdownTransformers.test.ts
@@ -8,22 +8,52 @@
 
 // @vitest-environment node
 
+import {
+  $createCodeNode,
+  $isCodeNode,
+  CodeHighlightNode,
+  CodeNode,
+} from '@lexical/code-core';
 import {buildEditorFromExtensions} from '@lexical/extension';
+import {$createLinkNode, $isLinkNode, LinkNode} from '@lexical/link';
+import {
+  $createListItemNode,
+  $createListNode,
+  ListItemNode,
+  ListNode,
+} from '@lexical/list';
 import {
   $convertFromMarkdownString,
   $convertToMarkdownString,
+  $generateNodesFromMarkdownString,
   registerMarkdownShortcuts,
+  TRANSFORMERS,
 } from '@lexical/markdown';
-import {RichTextExtension} from '@lexical/rich-text';
+import {$createHeadingNode, RichTextExtension} from '@lexical/rich-text';
 import {
+  $createTableCellNode,
+  $createTableNode,
+  $createTableNodeWithDimensions,
+  $createTableRowNode,
+  $isTableCellNode,
+  $isTableNode,
+  TableCellHeaderStates,
+  TableExtension,
+  type TableNode,
+} from '@lexical/table';
+import {
+  $createLineBreakNode,
   $createParagraphNode,
   $createTextNode,
   $getRoot,
   $getSelection,
+  $isElementNode,
   $isParagraphNode,
   $isRangeSelection,
+  $isTextNode,
   createEditor,
   defineExtension,
+  type ElementNode,
   type LexicalEditor,
 } from 'lexical';
 import {assert, describe, expect, it} from 'vitest';
@@ -38,6 +68,8 @@ import {
   BLOCK_EQUATION,
   EQUATION,
   IMAGE,
+  PLAYGROUND_TRANSFORMERS,
+  TABLE,
 } from '../../src/plugins/MarkdownTransformers';
 
 const EQUATION_TRANSFORMERS = [BLOCK_EQUATION, EQUATION];
@@ -296,3 +328,1086 @@ describe('playground IMAGE markdown transformer', () => {
     });
   });
 });
+
+// https://github.com/facebook/lexical/issues/9323
+describe('playground TABLE markdown transformer', () => {
+  const TableMarkdownTestExtension = defineExtension({
+    dependencies: [RichTextExtension, TableExtension],
+    name: 'TableMarkdownTest',
+    nodes: [CodeNode, CodeHighlightNode, LinkNode, ListNode, ListItemNode],
+  });
+
+  function exportCells(): string {
+    using editor = buildEditorFromExtensions(TableMarkdownTestExtension);
+    editor.update(
+      () => {
+        const header = $createTableRowNode().append(
+          $createTableCellNode(TableCellHeaderStates.ROW).append(
+            $createParagraphNode().append($createTextNode('a')),
+          ),
+          $createTableCellNode(TableCellHeaderStates.ROW).append(
+            $createParagraphNode().append($createTextNode('b')),
+          ),
+        );
+        const body = $createTableRowNode().append(
+          $createTableCellNode().append(
+            $createParagraphNode().append($createTextNode('one')),
+            $createParagraphNode().append(
+              $createTextNode('two'),
+              $createLineBreakNode(),
+              $createTextNode('three'),
+            ),
+          ),
+          $createTableCellNode().append(
+            $createParagraphNode().append($createTextNode('x|y')),
+          ),
+        );
+        $getRoot().clear().append($createTableNode().append(header, body));
+      },
+      {discrete: true},
+    );
+    return editor.read(() => $convertToMarkdownString([TABLE]));
+  }
+
+  it('writes line breaks in a cell as <br> and escapes pipes', () => {
+    expect(exportCells()).toBe(
+      ['| a | b |', '| --- | --- |', '| one<br>two<br>three | x\\|y |'].join(
+        '\n',
+      ),
+    );
+  });
+
+  it('reads <br>, escaped pipes and the legacy \\n back', () => {
+    using editor = buildEditorFromExtensions(TableMarkdownTestExtension);
+    editor.update(
+      () => {
+        $convertFromMarkdownString(
+          [
+            '| a | b |',
+            '| --- | --- |',
+            '| one<br>two <br/> three | x\\|y\\nz |',
+          ].join('\n'),
+          [TABLE],
+        );
+      },
+      {discrete: true},
+    );
+    editor.read(() => {
+      const table = $getRoot().getFirstChildOrThrow();
+      assert($isTableNode(table), 'Root child must be a table');
+      expect(
+        table
+          .getChildren()
+          .map(row =>
+            $isElementNode(row)
+              ? row
+                  .getChildren()
+                  .map(cell =>
+                    $isElementNode(cell)
+                      ? cell.getChildren().map(p => p.getTextContent())
+                      : [],
+                  )
+              : [],
+          ),
+      ).toEqual([
+        [['a'], ['b']],
+        [['one\ntwo\nthree'], ['x|y\nz']],
+      ]);
+      expect($convertToMarkdownString([TABLE])).toBe(
+        [
+          '| a | b |',
+          '| --- | --- |',
+          '| one<br>two<br>three | x\\|y<br>z |',
+        ].join('\n'),
+      );
+    });
+  });
+
+  function importMarkdown(
+    markdown: string,
+  ): ReturnType<typeof buildEditorFromExtensions> {
+    const editor = buildEditorFromExtensions(TableMarkdownTestExtension);
+    editor.update(() => $convertFromMarkdownString(markdown, [TABLE]), {
+      discrete: true,
+    });
+    return editor;
+  }
+
+  function cellTexts(editor: LexicalEditor): string[][][] {
+    return editor.read(() => {
+      const table = $getRoot().getFirstChildOrThrow();
+      assert($isTableNode(table), 'Root child must be a table');
+      return table
+        .getChildren()
+        .map(row =>
+          $isElementNode(row)
+            ? row
+                .getChildren()
+                .map(cell =>
+                  $isElementNode(cell)
+                    ? cell.getChildren().map(p => p.getTextContent())
+                    : [],
+                )
+            : [],
+        );
+    });
+  }
+
+  it('writes a hard line break marked with a backslash as a bare <br>', () => {
+    using editor = buildEditorFromExtensions(TableMarkdownTestExtension);
+    editor.update(
+      () => {
+        // A hard break imported (or pasted) from Markdown remembers its
+        // `\` marker, which must not end up escaping the `<br>`.
+        $convertFromMarkdownString('a\\\nb', TRANSFORMERS);
+        const paragraph = $getRoot().getFirstChildOrThrow();
+        const cell = $createTableCellNode(TableCellHeaderStates.ROW);
+        paragraph.replace(
+          $createTableNode().append($createTableRowNode().append(cell)),
+        );
+        cell.append(paragraph);
+      },
+      {discrete: true},
+    );
+    expect(editor.read(() => $convertToMarkdownString([TABLE]))).toBe(
+      ['| a<br>b |', '| --- |'].join('\n'),
+    );
+  });
+
+  it('writes the delimiter row of a single-column table', () => {
+    using editor = buildEditorFromExtensions(TableMarkdownTestExtension);
+    editor.update(
+      () => {
+        $getRoot()
+          .clear()
+          .append($createTableNodeWithDimensions(2, 1, true));
+      },
+      {discrete: true},
+    );
+    expect(editor.read(() => $convertToMarkdownString([TABLE]))).toBe(
+      ['|  |', '| --- |', '|  |'].join('\n'),
+    );
+  });
+
+  it('keeps an escaped backslash before n when reading the legacy \\n', () => {
+    using editor = importMarkdown(
+      ['| a |', '| --- |', '| C:\\\\new |'].join('\n'),
+    );
+    expect(cellTexts(editor)).toEqual([[['a']], [['C:\\new']]]);
+  });
+
+  it.each([
+    ['`<br>`', '<br>', true],
+    ['\\<br>', '<br>', false],
+    ['`a\\|b`', 'a|b', true],
+    ['`\\n`', '\\n', true],
+  ])('keeps %s in a cell literal', (body, text, isCode) => {
+    using editor = importMarkdown(
+      ['| h |', '| --- |', `| ${body} |`].join('\n'),
+    );
+    expect(cellTexts(editor)).toEqual([[['h']], [[text]]]);
+    editor.read(() => {
+      const cellText = $getRoot().getLastDescendant();
+      assert($isTextNode(cellText), 'The cell must end in text');
+      expect(cellText.hasFormat('code')).toBe(isCode);
+    });
+  });
+
+  it.each([
+    '<code>x</code>',
+    'see <code>a|b</code> y',
+    'a\\|b',
+    'a\\\\|b',
+    'a|b\\',
+  ])(
+    'round-trips text with backslashes, pipes and tags in a cell: %j',
+    text => {
+      using editor = buildEditorFromExtensions(TableMarkdownTestExtension);
+      editor.update(
+        () => {
+          $getRoot()
+            .clear()
+            .append(
+              $createTableNode().append(
+                $createTableRowNode().append(
+                  $createTableCellNode(TableCellHeaderStates.ROW).append(
+                    $createParagraphNode().append($createTextNode('h')),
+                  ),
+                ),
+                $createTableRowNode().append(
+                  $createTableCellNode().append(
+                    $createParagraphNode().append($createTextNode(text)),
+                  ),
+                ),
+              ),
+            );
+        },
+        {discrete: true},
+      );
+      const markdown = editor.read(() => $convertToMarkdownString([TABLE]));
+      using imported = importMarkdown(markdown);
+      expect(cellTexts(imported)).toEqual([[['h']], [[text]]]);
+      expect(imported.read(() => $convertToMarkdownString([TABLE]))).toBe(
+        markdown,
+      );
+    },
+  );
+
+  it.each(
+    [
+      'a|b',
+      'a\\|b',
+      'a\\\\|b',
+      '\\|',
+      'x`\\|`*y*',
+      '``\\|``',
+      '```\\|```',
+      ' `a\\|` ',
+      '&#38;\\|*',
+    ].flatMap(text =>
+      (['code', 'bold', 'italic', 'strikethrough'] as const).map(
+        format => [text, format] as const,
+      ),
+    ),
+  )(
+    'round-trips inline code with pipes and backslashes in a cell: %j, %s',
+    (text, format) => {
+      using editor = buildEditorFromExtensions(TableMarkdownTestExtension);
+      editor.update(
+        () => {
+          $getRoot()
+            .clear()
+            .append(
+              $createTableNode().append(
+                $createTableRowNode().append(
+                  $createTableCellNode(TableCellHeaderStates.ROW).append(
+                    $createParagraphNode().append($createTextNode('h')),
+                  ),
+                ),
+                $createTableRowNode().append(
+                  $createTableCellNode().append(
+                    $createParagraphNode().append(
+                      format === 'code'
+                        ? $createTextNode(text).toggleFormat('code')
+                        : $createTextNode(text)
+                            .toggleFormat('code')
+                            .toggleFormat(format),
+                    ),
+                  ),
+                ),
+              ),
+            );
+        },
+        {discrete: true},
+      );
+      const markdown = editor.read(() => $convertToMarkdownString([TABLE]));
+      using imported = importMarkdown(markdown);
+      expect(cellTexts(imported)).toEqual([[['h']], [[text]]]);
+      imported.read(() => {
+        const node = $getRoot().getLastDescendant();
+        assert($isTextNode(node), 'The cell must hold text');
+        expect(node.hasFormat('code')).toBe(true);
+        expect(node.hasFormat(format)).toBe(true);
+      });
+      expect(imported.read(() => $convertToMarkdownString([TABLE]))).toBe(
+        markdown,
+      );
+    },
+  );
+
+  it('escapes a literal <br> outside code spans and reads it back', () => {
+    using editor = importMarkdown(
+      ['| h |', '| --- |', '| `<br>` \\<br> a<br>b |'].join('\n'),
+    );
+    expect(cellTexts(editor)).toEqual([[['h']], [['<br> <br> a\nb']]]);
+    expect(editor.read(() => $convertToMarkdownString([TABLE]))).toBe(
+      ['| h |', '| --- |', '| `<br>` \\<br> a<br>b |'].join('\n'),
+    );
+  });
+
+  it.each([
+    ['the legacy \\n', '```js\\nfoo\\nbar\\n```'],
+    ['<br>', '```js<br>foo<br>bar<br>```'],
+  ])('reads a code block in a cell written with %s', (_, body) => {
+    using editor = importMarkdown(
+      ['| h |', '| --- |', `| ${body} |`].join('\n'),
+    );
+    editor.read(() => {
+      const cellCode = $getRoot().getAllTextNodes().at(-1)?.getParentOrThrow();
+      assert($isCodeNode(cellCode), 'The cell must hold a code block');
+      expect(cellCode.getLanguage()).toBe('js');
+      expect(cellCode.getTextContent()).toBe('foo\nbar');
+      expect($convertToMarkdownString([TABLE])).toBe(
+        ['| h |', '| --- |', '| ```js<br>foo<br>bar<br>``` |'].join('\n'),
+      );
+    });
+  });
+
+  it.each([
+    ['**', 'bold'],
+    ['*', 'italic'],
+    ['~~', 'strikethrough'],
+  ] as const)(
+    'keeps %s formatting across a <br> in a cell',
+    (marker, format) => {
+      const $cellShape = () => {
+        const cell = $getRoot().getLastDescendant()?.getParentOrThrow();
+        assert($isElementNode(cell), 'The cell must hold a paragraph');
+        return cell
+          .getChildren()
+          .map(node =>
+            $isTextNode(node)
+              ? [node.getTextContent(), node.hasFormat(format)]
+              : node.getType(),
+          );
+      };
+      using editor = importMarkdown(
+        ['| h |', '| --- |', `| ${marker}a<br>b${marker} |`].join('\n'),
+      );
+      expect(editor.read($cellShape)).toEqual([
+        ['a', true],
+        'linebreak',
+        ['b', true],
+      ]);
+      // Export closes the formatting around the break, which reads back
+      // the same way.
+      const markdown = editor.read(() => $convertToMarkdownString([TABLE]));
+      expect(markdown.split('\n')[2]).toBe(
+        `| ${marker}a${marker}<br>${marker}b${marker} |`,
+      );
+      using reimported = importMarkdown(markdown);
+      expect(reimported.read($cellShape)).toEqual(editor.read($cellShape));
+    },
+  );
+
+  it.each([false, true])(
+    'keeps a literal U+E000 in a cell (code: %s)',
+    isCode => {
+      using editor = buildEditorFromExtensions(TableMarkdownTestExtension);
+      editor.update(
+        () => {
+          const text = $createTextNode('a\uE000b');
+          if (isCode) {
+            text.toggleFormat('code');
+          }
+          $getRoot()
+            .clear()
+            .append(
+              $createTableNode().append(
+                $createTableRowNode().append(
+                  $createTableCellNode(TableCellHeaderStates.ROW).append(
+                    $createParagraphNode().append(text),
+                  ),
+                ),
+              ),
+            );
+        },
+        {discrete: true},
+      );
+      const body = isCode ? '`a\uE000b`' : 'a\uE000b';
+      expect(editor.read(() => $convertToMarkdownString([TABLE]))).toBe(
+        [`| ${body} |`, '| --- |'].join('\n'),
+      );
+    },
+  );
+
+  it.each([
+    'const x = a*b;\nc;',
+    '/* a */\nb;',
+    'a\n\nb',
+    'x  \n  y \t',
+    'x = "<br>";\ny = "\\<br>";',
+    '| p_q_r ~~s',
+  ])('round-trips a code block in a cell: %j', code => {
+    using editor = buildEditorFromExtensions(TableMarkdownTestExtension);
+    editor.update(
+      () => {
+        const block = $createCodeNode('js');
+        code.split('\n').forEach((line, i) => {
+          if (i > 0) {
+            block.append($createLineBreakNode());
+          }
+          if (line) {
+            block.append($createTextNode(line));
+          }
+        });
+        $getRoot()
+          .clear()
+          .append(
+            $createTableNode().append(
+              $createTableRowNode().append(
+                $createTableCellNode(TableCellHeaderStates.ROW).append(block),
+              ),
+            ),
+          );
+      },
+      {discrete: true},
+    );
+    const markdown = editor.read(() => $convertToMarkdownString([TABLE]));
+    using reimported = importMarkdown(markdown);
+    reimported.read(() => {
+      const cellCode = $getRoot().getFirstDescendant()?.getParent();
+      assert($isCodeNode(cellCode), 'The cell must hold a code block');
+      expect(cellCode.getLanguage()).toBe('js');
+      expect(cellCode.getTextContent()).toBe(code);
+      expect($convertToMarkdownString([TABLE])).toBe(markdown);
+    });
+  });
+
+  it.each([
+    ['**', '# b', 'bold'],
+    ['*', '- b', 'italic'],
+    ['~~', '> b', 'strikethrough'],
+    ['**', '1. b', 'bold'],
+  ] as const)(
+    'keeps %s formatting whole across a <br> before %j',
+    (marker, line, format) => {
+      // Formatting is closed on each side of a line break, as elsewhere.
+      const exported = `| ${marker}a${marker}<br>${marker}${line}${marker} |`;
+      for (const body of [`| ${marker}a<br>${line}${marker} |`, exported]) {
+        using editor = importMarkdown(['| h |', '| --- |', body].join('\n'));
+        editor.read(() => {
+          const paragraph = $getRoot().getLastDescendant()?.getParent();
+          assert($isParagraphNode(paragraph), 'The cell must hold a paragraph');
+          const children = paragraph.getChildren();
+          expect(
+            children.map(node => node.getTextContent() || node.getType()),
+          ).toEqual(['a', '\n', line]);
+          for (const node of children) {
+            if ($isTextNode(node)) {
+              expect(node.hasFormat(format)).toBe(true);
+            }
+          }
+          expect($convertToMarkdownString([TABLE]).split('\n')[2]).toBe(
+            exported,
+          );
+        });
+      }
+    },
+  );
+
+  it.each([
+    ['a<br>**(b)**', ['a', '\n', '(b)'], 2],
+    ['**(a)**<br>b', ['(a)', '\n', 'b'], 0],
+    ['*[a]*<br>_.b_', ['[a]', '\n', '.b'], 0],
+  ])(
+    'reads formatting beside punctuation and a <br>: %j',
+    (body, texts, formatted) => {
+      using editor = importMarkdown(
+        ['| h |', '| --- |', `| ${body} |`].join('\n'),
+      );
+      editor.read(() => {
+        const paragraph = $getRoot().getLastDescendant()?.getParent();
+        assert($isParagraphNode(paragraph), 'The cell must hold a paragraph');
+        const children = paragraph.getChildren();
+        expect(
+          children.map(node => node.getTextContent() || node.getType()),
+        ).toEqual(texts);
+        const node = children[formatted];
+        assert($isTextNode(node), 'The formatted child must be text');
+        expect(node.getFormat()).not.toBe(0);
+      });
+    },
+  );
+
+  it('keeps a link whose second line starts like a list item', () => {
+    using editor = importMarkdown(
+      ['| h |', '| --- |', '| [a<br>- b](https://example.com) |'].join('\n'),
+    );
+    editor.read(() => {
+      const link = $getRoot().getLastDescendant()?.getParent();
+      assert($isLinkNode(link), 'The cell must hold a link');
+      expect(link.getTextContent()).toBe('a\n- b');
+      expect($convertToMarkdownString([TABLE]).split('\n')[2]).toBe(
+        '| [a<br>\\- b](https://example.com) |',
+      );
+    });
+  });
+
+  it('still reads a heading after a <br> outside formatting', () => {
+    using editor = importMarkdown(
+      ['| h |', '| --- |', '| **a**<br># b |'].join('\n'),
+    );
+    expect(cellTexts(editor)).toEqual([[['h']], [['a', 'b']]]);
+  });
+
+  it.each([
+    ['a　b<br>c', 'a　b\nc'],
+    ['a&#12288;b<br>c', 'a　b\nc'],
+    ['a<br>', 'a\n'],
+    ['<br>a', '\na'],
+    ['<br>', '\n'],
+    ['<br><br>', '\n\n'],
+    ['x<br>\u3000y', 'x\n\u3000y'],
+    ['x<br>\u2003\u3000y', 'x\n\u2003\u3000y'],
+  ])('reads %j with its spaces and line breaks', (body, text) => {
+    using editor = importMarkdown(
+      ['| h |', '| --- |', `| ${body} |`].join('\n'),
+    );
+    expect(cellTexts(editor)).toEqual([[['h']], [[text]]]);
+  });
+
+  it('round-trips a cell that is only a line break', () => {
+    using editor = buildEditorFromExtensions(TableMarkdownTestExtension);
+    editor.update(
+      () => {
+        $getRoot()
+          .clear()
+          .append(
+            $createTableNode().append(
+              $createTableRowNode().append(
+                $createTableCellNode(TableCellHeaderStates.ROW).append(
+                  $createParagraphNode().append($createTextNode('h')),
+                ),
+              ),
+              $createTableRowNode().append(
+                $createTableCellNode().append(
+                  $createParagraphNode().append($createLineBreakNode()),
+                ),
+              ),
+            ),
+          );
+      },
+      {discrete: true},
+    );
+    const markdown = editor.read(() => $convertToMarkdownString([TABLE]));
+    expect(markdown.split('\n')[2]).toBe('| <br> |');
+    using imported = importMarkdown(markdown);
+    expect(cellTexts(imported)).toEqual([[['h']], [['\n']]]);
+  });
+
+  it.each([false, true])(
+    'keeps a link URL that holds the export line break mark (code block: %s)',
+    withCode => {
+      using editor = buildEditorFromExtensions(TableMarkdownTestExtension);
+      const url = 'https://example.com/\ue000';
+      editor.update(
+        () => {
+          $getRoot()
+            .clear()
+            .append(
+              $createTableNode().append(
+                $createTableRowNode().append(
+                  $createTableCellNode(TableCellHeaderStates.ROW).append(
+                    $createParagraphNode().append($createTextNode('h')),
+                  ),
+                ),
+                $createTableRowNode().append(
+                  $createTableCellNode().append(
+                    $createParagraphNode().append(
+                      $createLinkNode(url).append($createTextNode('l')),
+                      $createLineBreakNode(),
+                      $createTextNode('m'),
+                    ),
+                    ...(withCode
+                      ? [
+                          $createCodeNode().append(
+                            $createTextNode('a'),
+                            $createLineBreakNode(),
+                            $createTextNode('b'),
+                          ),
+                        ]
+                      : []),
+                  ),
+                ),
+              ),
+            );
+        },
+        {discrete: true},
+      );
+      const markdown = editor.read(() => $convertToMarkdownString([TABLE]));
+      using imported = importMarkdown(markdown);
+      imported.read(() => {
+        const link = $getRoot().getAllTextNodes()[1].getParent();
+        assert($isLinkNode(link), 'The cell must hold the link');
+        expect(link.getURL()).toBe(url);
+      });
+      expect(cellTexts(imported)).toEqual([
+        [['h']],
+        [withCode ? ['l\nm', 'a\nb'] : ['l\nm']],
+      ]);
+    },
+  );
+
+  it('keeps a code block whose info string holds a pipe in one cell', () => {
+    using editor = buildEditorFromExtensions(TableMarkdownTestExtension);
+    editor.update(
+      () => {
+        $getRoot()
+          .clear()
+          .append(
+            $createTableNode().append(
+              $createTableRowNode().append(
+                $createTableCellNode(TableCellHeaderStates.ROW).append(
+                  $createParagraphNode().append($createTextNode('h')),
+                ),
+              ),
+              $createTableRowNode().append(
+                $createTableCellNode().append(
+                  $createCodeNode('a|b').append($createTextNode('x')),
+                ),
+              ),
+            ),
+          );
+      },
+      {discrete: true},
+    );
+    const markdown = editor.read(() => $convertToMarkdownString([TABLE]));
+    using imported = importMarkdown(markdown);
+    // The row stays one cell. The core importer reads only letters,
+    // digits, `_` and `-` as a language, so the language doesn't come back.
+    expect(cellTexts(imported)).toEqual([[['h']], [['x']]]);
+  });
+
+  it.each(['    ', '\t'])(
+    'reads a code fence indented with %j in a cell as the importer does',
+    indent => {
+      const body = `a<br>${indent}\`\`\`<br>*b*  c<br>${indent}\`\`\``;
+      using editor = importMarkdown(
+        ['| h |', '| --- |', `| ${body} |`].join('\n'),
+      );
+      using direct = buildEditorFromExtensions(TableMarkdownTestExtension);
+      direct.update(
+        () =>
+          $convertFromMarkdownString(
+            `a\n${indent}\`\`\`\n*b*  c\n${indent}\`\`\``,
+            PLAYGROUND_TRANSFORMERS,
+          ),
+        {discrete: true},
+      );
+      const types = direct.read(() =>
+        $getRoot()
+          .getChildren()
+          .map(node => [node.getType(), node.getTextContent()]),
+      );
+      expect(types.map(([type]) => type)).toContain('code');
+      expect(
+        editor.read(() =>
+          $getRoot()
+            .getLastDescendant()
+            ?.getParents()
+            .find($isTableCellNode)
+            ?.getChildren()
+            .map(node => [node.getType(), node.getTextContent()]),
+        ),
+      ).toEqual(types);
+    },
+  );
+
+  it('keeps a character reference to the line break marker', () => {
+    using editor = importMarkdown(
+      ['| h |', '| --- |', '| a&#57344;b<br>c |'].join('\n'),
+    );
+    expect(cellTexts(editor)).toEqual([[['h']], [['a\ue000b\nc']]]);
+  });
+
+  it.each(['a<br />b', 'a<br    />b', 'a<BR\t/>b'])(
+    'reads %j as a line break',
+    body => {
+      using editor = importMarkdown(
+        ['| h |', '| --- |', `| ${body} |`].join('\n'),
+      );
+      expect(cellTexts(editor)).toEqual([[['h']], [['a\nb']]]);
+    },
+  );
+
+  it('reads a link with a <br> in its text', () => {
+    using editor = importMarkdown(
+      ['| h |', '| --- |', '| [a<br>b](https://example.com) |'].join('\n'),
+    );
+    editor.read(() => {
+      const link = $getRoot().getLastDescendant()?.getParent();
+      assert($isLinkNode(link), 'The cell must hold a link');
+      expect(link.getURL()).toBe('https://example.com');
+      expect(
+        link.getChildren().map(node => node.getTextContent() || node.getType()),
+      ).toEqual(['a', '\n', 'b']);
+      const markdown = $convertToMarkdownString([TABLE]);
+      expect(markdown.split('\n')[2]).toBe('| [a<br>b](https://example.com) |');
+    });
+  });
+
+  it('keeps a lone delimiter row out of the table below it', () => {
+    using editor = importMarkdown(['| --- |', '| a |'].join('\n'));
+    editor.read(() => {
+      const [text, table] = $getRoot().getChildren();
+      expect($isParagraphNode(text) && text.getTextContent()).toBe('| --- |');
+      assert($isTableNode(table), 'A table must follow the text');
+      expect(table.getTextContent()).toBe('a');
+    });
+  });
+
+  it.each([
+    ['- i\n\nafter', ['list', 'paragraph']],
+    ['- i\n- j\n\nafter', ['list', 'paragraph']],
+    ['> q\n\nafter', ['quote', 'paragraph']],
+    ['- i\nmore', ['list']],
+    ['- a\n    - nested\n\nend', ['list', 'paragraph']],
+    ['1. a\n    1. b\n        - c\n2. d', ['list']],
+    ['a\n\n> q\n\nafter', ['paragraph', 'quote', 'paragraph']],
+  ])('keeps the blocks of %j apart in a cell', (markdown, types) => {
+    using editor = buildEditorFromExtensions(TableMarkdownTestExtension);
+    editor.update(
+      () => {
+        const cell = $createTableCellNode();
+        $convertFromMarkdownString(markdown, PLAYGROUND_TRANSFORMERS, cell);
+        $getRoot()
+          .clear()
+          .append(
+            $createTableNode().append(
+              $createTableRowNode().append(
+                $createTableCellNode(TableCellHeaderStates.ROW).append(
+                  $createParagraphNode().append($createTextNode('h')),
+                ),
+              ),
+              $createTableRowNode().append(cell),
+            ),
+          );
+      },
+      {discrete: true},
+    );
+    const shape = editor.read(() =>
+      $getRoot()
+        .getLastDescendant()
+        ?.getParents()
+        .find($isTableCellNode)
+        ?.getChildren()
+        .map(node => [node.getType(), node.getTextContent()]),
+    );
+    expect(shape?.map(([type]) => type)).toEqual(types);
+    const exported = editor.read(() => $convertToMarkdownString([TABLE]));
+    using imported = importMarkdown(exported);
+    expect(
+      imported.read(() =>
+        $getRoot()
+          .getLastDescendant()
+          ?.getParents()
+          .find($isTableCellNode)
+          ?.getChildren()
+          .map(node => [node.getType(), node.getTextContent()]),
+      ),
+    ).toEqual(shape);
+    expect(imported.read(() => $convertToMarkdownString([TABLE]))).toBe(
+      exported,
+    );
+  });
+
+  it('leaves a delimiter row with no table above it as text', () => {
+    using editor = importMarkdown('| --- |');
+    expect(
+      editor.read(() =>
+        $getRoot()
+          .getChildren()
+          .map(node => node.getTextContent()),
+      ),
+    ).toEqual(['| --- |']);
+  });
+  it.each([
+    ['| a\\|b | c |', [['a|b'], ['c']]],
+    ['| a\\\\| b |', [['a\\'], ['b']]],
+    ['| a\\\\\\|b | c |', [['a\\|b'], ['c']]],
+    ['| a | \\a | b |', [['a'], ['\\a'], ['b']]],
+  ])(
+    'splits %j only on pipes after an even run of backslashes',
+    (row, cells) => {
+      using editor = importMarkdown(row);
+      expect(cellTexts(editor)).toEqual([cells]);
+    },
+  );
+
+  it('keeps an empty body row that reads like a delimiter row', () => {
+    using editor = importMarkdown(
+      ['| a | b |', '| --- | --- |', '|  |  |', '| c | d |'].join('\n'),
+    );
+    expect(cellTexts(editor)).toEqual([
+      [['a'], ['b']],
+      [[''], ['']],
+      [['c'], ['d']],
+    ]);
+    editor.read(() => {
+      const table = $getRoot().getFirstChildOrThrow();
+      assert($isTableNode(table), 'Root child must be a table');
+      expect(
+        table
+          .getChildren()
+          .map(
+            row =>
+              $isElementNode(row) &&
+              row
+                .getChildren()
+                .every(
+                  cell =>
+                    $isTableCellNode(cell) &&
+                    cell.hasHeaderState(TableCellHeaderStates.ROW),
+                ),
+          ),
+      ).toEqual([true, false, false]);
+    });
+  });
+
+  it('reads a table whose header cells are empty', () => {
+    using editor = importMarkdown(
+      ['|  |  |', '| --- | --- |', '| c | d |'].join('\n'),
+    );
+    expect(cellTexts(editor)).toEqual([
+      [[''], ['']],
+      [['c'], ['d']],
+    ]);
+  });
+
+  function $cellOf(...blocks: ElementNode[]): TableNode {
+    return $createTableNode().append(
+      $createTableRowNode().append(
+        $createTableCellNode(TableCellHeaderStates.ROW).append(
+          $createParagraphNode().append($createTextNode('h')),
+        ),
+      ),
+      $createTableRowNode().append($createTableCellNode().append(...blocks)),
+    );
+  }
+
+  function exportTable(build: () => TableNode): string {
+    using editor = buildEditorFromExtensions(TableMarkdownTestExtension);
+    editor.update(() => $getRoot().clear().append(build()), {discrete: true});
+    return editor.read(() => $convertToMarkdownString([TABLE]));
+  }
+
+  it.each([
+    [
+      'between paragraphs',
+      () => [
+        $createParagraphNode().append($createTextNode('a')),
+        $createParagraphNode(),
+        $createParagraphNode().append($createTextNode('b')),
+      ],
+      'a<br><br>b',
+      [['a\n\nb']],
+    ],
+    [
+      'after a heading',
+      () => [
+        $createHeadingNode('h2').append($createTextNode('t')),
+        $createParagraphNode(),
+        $createParagraphNode().append($createTextNode('b')),
+      ],
+      '## t<br><br>b',
+      [['t', '\nb']],
+    ],
+    [
+      'first',
+      () => [
+        $createParagraphNode(),
+        $createParagraphNode().append($createTextNode('b')),
+      ],
+      '<br>b',
+      [['\nb']],
+    ],
+    [
+      'last',
+      () => [
+        $createParagraphNode().append($createTextNode('a')),
+        $createParagraphNode(),
+      ],
+      'a<br>',
+      [['a\n']],
+    ],
+    [
+      'alone',
+      () => [$createParagraphNode(), $createParagraphNode()],
+      '<br>',
+      [['\n']],
+    ],
+    [
+      'after a list',
+      () => [
+        $createListNode('bullet').append(
+          $createListItemNode().append($createTextNode('i')),
+        ),
+        $createParagraphNode(),
+        $createParagraphNode().append($createTextNode('b')),
+      ],
+      '- i<br><br><br>b',
+      [['i', '\nb']],
+    ],
+  ])(
+    'keeps the line of an empty paragraph %s in a cell',
+    (_, blocks, cell, texts) => {
+      const markdown = exportTable(() => $cellOf(...blocks()));
+      expect(markdown.split('\n')[2]).toBe(`| ${cell} |`);
+      using imported = importMarkdown(markdown);
+      expect(cellTexts(imported)[1]).toEqual(texts);
+      expect(imported.read(() => $convertToMarkdownString([TABLE]))).toBe(
+        markdown,
+      );
+    },
+  );
+
+  it.each(['a  \nb', 'a\n  b', 'a\t\n\tb', 'a \n \nb'])(
+    'keeps the spaces beside a line break in %j',
+    text => {
+      const markdown = exportTable(() => {
+        const paragraph = $createParagraphNode();
+        text.split('\n').forEach((line, i) => {
+          if (i > 0) {
+            paragraph.append($createLineBreakNode());
+          }
+          paragraph.append($createTextNode(line));
+        });
+        return $cellOf(paragraph);
+      });
+      using imported = importMarkdown(markdown);
+      expect(cellTexts(imported)[1]).toEqual([[text]]);
+    },
+  );
+
+  it('reads a cell with more line breaks than a call can take arguments', () => {
+    const lines = Array.from({length: 70000}, (_, i) => String(i % 10));
+    using editor = importMarkdown(
+      ['| h |', '| --- |', `| ${lines.join('<br>')} |`].join('\n'),
+    );
+    expect(cellTexts(editor)[1]).toEqual([[lines.join('\n')]]);
+  });
+  it.each(['-', ':-:', '---', '-:'])(
+    'keeps a row whose cells are only %j',
+    text => {
+      for (const header of [false, true]) {
+        const markdown = exportTable(() => {
+          const table = $cellOf(
+            $createParagraphNode().append($createTextNode(text)),
+          );
+          if (header) {
+            const [first, second] = table.getChildren();
+            first.insertBefore(second);
+          }
+          return table;
+        });
+        using imported = importMarkdown(markdown);
+        const texts = header ? [[[text]], [['h']]] : [[['h']], [[text]]];
+        expect(cellTexts(imported)).toEqual(texts);
+      }
+    },
+  );
+
+  it.each(['---', '# h', '> q', '- i', '1. i'])(
+    'keeps a line %j in a cell as text',
+    line => {
+      for (const [first, blocks] of [
+        [
+          'a',
+          () => [
+            $createParagraphNode().append($createTextNode('a')),
+            $createParagraphNode().append($createTextNode(line)),
+          ],
+        ],
+        [
+          'b',
+          () => [
+            $createParagraphNode().append(
+              $createTextNode('b').toggleFormat('bold'),
+              $createLineBreakNode(),
+              $createTextNode(line),
+            ),
+          ],
+        ],
+      ] as const) {
+        const markdown = exportTable(() => $cellOf(...blocks()));
+        using imported = importMarkdown(markdown);
+        expect(cellTexts(imported)[1]).toEqual([[`${first}\n${line}`]]);
+      }
+    },
+  );
+
+  it('keeps a paragraph that is only whitespace', () => {
+    const markdown = exportTable(() =>
+      $cellOf(
+        $createParagraphNode().append($createTextNode('a')),
+        $createParagraphNode().append($createTextNode('   ')),
+        $createParagraphNode().append($createTextNode('b')),
+      ),
+    );
+    using imported = importMarkdown(markdown);
+    expect(cellTexts(imported)[1]).toEqual([['a\n   \nb']]);
+  });
+
+  it('keeps a line that starts and ends with a pipe as text', () => {
+    const markdown = exportTable(() =>
+      $cellOf($createParagraphNode().append($createTextNode('|q|'))),
+    );
+    using imported = importMarkdown(markdown);
+    expect(cellTexts(imported)[1]).toEqual([['|q|']]);
+    expect(imported.read(() => $convertToMarkdownString([TABLE]))).toBe(
+      markdown,
+    );
+  });
+
+  it('writes a paragraph whose content writes nothing as an empty line', () => {
+    using editor = buildEditorFromExtensions(TableMarkdownTestExtension);
+    let markdown = '';
+    editor.update(
+      () => {
+        // Before normalization drops it, an empty text node writes nothing.
+        $getRoot()
+          .clear()
+          .append(
+            $cellOf(
+              $createParagraphNode().append($createTextNode('a')),
+              $createParagraphNode().append($createTextNode('')),
+              $createParagraphNode().append($createTextNode('b')),
+            ),
+          );
+        markdown = $convertToMarkdownString([TABLE]);
+      },
+      {discrete: true},
+    );
+    expect(markdown.split('\n')[2]).toBe('| a<br><br>b |');
+  });
+
+  it('keeps a code span that is only whitespace', () => {
+    const markdown = exportTable(() =>
+      $cellOf(
+        $createParagraphNode().append($createTextNode('a')),
+        $createParagraphNode().append(
+          $createTextNode('  ').toggleFormat('code'),
+        ),
+      ),
+    );
+    using imported = importMarkdown(markdown);
+    expect(
+      imported.read(() =>
+        $getRoot()
+          .getAllTextNodes()
+          .map(node => [node.getTextContent(), node.hasFormat('code')]),
+      ),
+    ).toEqual([
+      ['h', false],
+      ['a', false],
+      ['  ', true],
+    ]);
+  });
+
+  it('trims only spaces and tabs from a cell', () => {
+    using imported = importMarkdown(
+      ['| h |', '| --- |', '|\u3000a\u00a0 \t|'].join('\n'),
+    );
+    expect(cellTexts(imported)[1]).toEqual([['\u3000a\u00a0']]);
+  });
+
+  it('leaves the selection alone when it generates a table', () => {
+    using editor = buildEditorFromExtensions(TableMarkdownTestExtension);
+    editor.update(
+      () => {
+        const text = $createTextNode('x');
+        $getRoot().clear().append($createParagraphNode().append(text));
+        text.select(1, 1);
+        $generateNodesFromMarkdownString(
+          '| a |\n| --- |\n| **b<br># c** |\n\n| d |\n| --- |\n| e |',
+          [TABLE, ...PLAYGROUND_TRANSFORMERS],
+        );
+        const selection = $getSelection();
+        assert($isRangeSelection(selection), 'A range selection must remain');
+        expect(selection.anchor.getNode().is(text)).toBe(true);
+      },
+      {discrete: true},
+    );
+  });
+});
diff --git a/packages/lexical-playground/src/plugins/MarkdownTransformers/index.ts b/packages/lexical-playground/src/plugins/MarkdownTransformers/index.ts
index 5989639f6a8..ea762485d0d 100644
--- a/packages/lexical-playground/src/plugins/MarkdownTransformers/index.ts
+++ b/packages/lexical-playground/src/plugins/MarkdownTransformers/index.ts
@@ -12,8 +12,8 @@ import {
   HorizontalRuleNode,
 } from '@lexical/extension';
 import {
-  $convertFromMarkdownString,
   $convertToMarkdownString,
+  $generateNodesFromMarkdownString,
   CHECK_LIST,
   ELEMENT_TRANSFORMERS,
   type ElementTransformer,
@@ -38,10 +38,16 @@ import {
   TableRowNode,
 } from '@lexical/table';
 import {
+  $copyNode,
+  $createLineBreakNode,
   $createTextNode,
+  $isElementNode,
+  $isLineBreakNode,
   $isParagraphNode,
   $isTextNode,
   type LexicalNode,
+  LineBreakNode,
+  type TextNode,
 } from 'lexical';
 
 import {
@@ -203,6 +209,185 @@ export const TWEET: ElementTransformer = {
 // Very primitive table setup
 const TABLE_ROW_REG_EXP = /^(?:\|)(.+)(?:\|)\s?$/;
 
+/**
+ * Characters that `text` doesn't contain, by themselves or as a numeric
+ * character reference (`&#57344;`), which reads as its character: the
+ * first `count` of `candidates`, then private-use characters.
+ */
+function unusedChars(
+  text: string,
+  count: number,
+  candidates: readonly number[] = [],
+): string[] {
+  const used = new Set<number>();
+  for (const char of text) {
+    used.add(char.codePointAt(0)!);
+  }
+  for (const [, decimal, hex] of text.matchAll(/&#(?:(\d+)|x([\da-f]+));/gi)) {
+    used.add(decimal ? parseInt(decimal, 10) : parseInt(hex, 16));
+  }
+  const chars: string[] = [];
+  for (const code of candidates) {
+    if (chars.length < count && !used.has(code)) {
+      chars.push(String.fromCharCode(code));
+    }
+  }
+  for (let code = 0xe000; chars.length < count; code++) {
+    if (!used.has(code)) {
+      chars.push(String.fromCharCode(code));
+    }
+  }
+  return chars;
+}
+
+// Space characters that a line break can stand in for while a cell is
+// read: Markdown takes them, like the line ending they replace, as
+// whitespace beside emphasis (`a<br>**(b)**`), and `.` matches them.
+const LINE_BREAK_MARKS = [
+  0x3000, 0x205f, 0x2000, 0x2001, 0x2002, 0x2003, 0x2004, 0x2005, 0x2006,
+  0x2007, 0x2008, 0x2009, 0x200a, 0x202f, 0x1680,
+];
+
+/** The characters that stand in for line breaks and code while a cell is read. */
+interface CellMarks {
+  codeEnd: string;
+  codeStart: string;
+  lineBreak: string;
+}
+
+/**
+ * Writes a line break inside a table cell as `mark`, and adds its key to
+ * `written` each time it does. It runs before the default line break export, which would put
+ * the break's hard line break marker (`\` or two spaces) in front of it,
+ * and `\<br>` reads back as an escaped `<`. A line break in a code block
+ * is exported by the code block, as a newline.
+ */
+function tableCellLineBreak(
+  mark: string,
+  written: string[],
+): TextMatchTransformer {
+  return {
+    dependencies: [LineBreakNode],
+    export: node => {
+      if (!$isLineBreakNode(node)) {
+        return null;
+      }
+      written.push(node.getKey());
+      return mark;
+    },
+    regExp: /$^/,
+    type: 'text-match',
+  };
+}
+
+/**
+ * Writes a paragraph at the top of a table cell, where each paragraph is a
+ * line. An empty one, or one whose content writes nothing, is an empty
+ * line, written as `mark` (with its key added to `written`), since Markdown
+ * has no empty paragraphs. One that is
+ * only whitespace keeps it as character references, which aren't trimmed.
+ * Any other has a block marker it starts with escaped (`\#`), since the
+ * line after a `<br>` reads as a block where one could start.
+ */
+function tableCellParagraph(
+  mark: string,
+  written: string[],
+): ElementTransformer {
+  return {
+    dependencies: [],
+    export: (node, exportChildren) => {
+      if (!$isParagraphNode(node) || !$isTableCellNode(node.getParent())) {
+        return null;
+      }
+      // Formatted whitespace, such as a code span, isn't only whitespace.
+      const markdown = exportChildren(node);
+      if (markdown === '') {
+        written.push(node.getKey());
+        return mark;
+      }
+      return /^\s+$/.test(markdown)
+        ? markdown.replace(/\s/g, spaceReference)
+        : escapeBlockStart(markdown);
+    },
+    regExp: /$^/,
+    replace: () => false,
+    type: 'element',
+  };
+}
+
+/**
+ * `line` with the marker that makes it start a block in a cell escaped, so
+ * it reads as text: `\# a`, `\- a`, `1\. a`, `\---`, `\$$`. A line that
+ * reads as a table row (`|q|`), which a cell can hold as a nested table,
+ * starts with `&#124;` instead, since `\|` is how a cell's pipe is written.
+ */
+function escapeBlockStart(line: string): string {
+  if (TABLE_ROW_REG_EXP.test(line)) {
+    return '&#124;' + line.slice(1);
+  }
+  if (!BLOCK_START_REG_EXP.test(line)) {
+    return line;
+  }
+  const ordered = /^( {0,3}\d{1,9})([.)])/.exec(line);
+  return ordered !== null
+    ? ordered[1] + '\\' + line.slice(ordered[1].length)
+    : line.replace(/^( {0,3})/, '$1\\');
+}
+
+/** A space or tab as a character reference, which isn't trimmed. */
+function spaceReference(space: string): string {
+  return space && `&#${space.charCodeAt(0)};`;
+}
+
+/** A cell's content as the Markdown of one GFM cell. */
+function $exportTableCell(cell: TableCellNode): string {
+  // The marks must not be in the Markdown, which also holds what isn't
+  // text, such as link URLs, so a mark that turns up more often than it was
+  // written (a node written twice counts twice) is passed over. A retry
+  // avoids all of the last try's Markdown, so its marks can't collide.
+  let avoid = cell.getTextContent();
+  for (;;) {
+    const [mark, emptyMark] = unusedChars(avoid, 2);
+    const written: string[] = [];
+    const writtenEmpty: string[] = [];
+    const markdown = encodeTableCell(
+      $convertToMarkdownString(
+        [
+          tableCellLineBreak(mark, written),
+          tableCellParagraph(emptyMark, writtenEmpty),
+          ...PLAYGROUND_TRANSFORMERS,
+        ],
+        cell,
+      ).trim(),
+      emptyMark,
+    );
+    const parts = markdown.split(mark);
+    const emptyParts = markdown.split(emptyMark);
+    if (
+      parts.length - 1 === written.length &&
+      emptyParts.length - 1 === writtenEmpty.length
+    ) {
+      // An empty paragraph is an empty line between the `<br>`s around it.
+      // A line after a line break is escaped like a paragraph's first.
+      // Spaces beside a line break would read back as the cell's padding,
+      // so the one next to it is a character reference.
+      return emptyParts
+        .join('')
+        .split(mark)
+        .map((line, i) => (i > 0 ? escapeBlockStart(line) : line))
+        .join(mark)
+        .replace(
+          new RegExp(`([ \\t]?)${mark}([ \\t]?)`, 'g'),
+          (_, before: string, after: string) =>
+            spaceReference(before) + mark + spaceReference(after),
+        )
+        .split(mark)
+        .join('<br>');
+    }
+    avoid += markdown;
+  }
+}
+
 export const TABLE: ElementTransformer = {
   dependencies: [TableNode, TableRowNode, TableCellNode],
   export: (node: LexicalNode) => {
@@ -222,18 +407,21 @@ export const TABLE: ElementTransformer = {
       for (const cell of row.getChildren()) {
         // It's TableCellNode so it's just to make flow happy
         if ($isTableCellNode(cell)) {
-          rowOutput.push(
-            $convertToMarkdownString(PLAYGROUND_TRANSFORMERS, cell)
-              .replace(/\n/g, '\\n')
-              .trim(),
-          );
-          if (cell.__headerState === TableCellHeaderStates.ROW) {
+          rowOutput.push($exportTableCell(cell));
+          // The top-left cell of a table with both header kinds is ROW|COLUMN.
+          if (cell.hasHeaderState(TableCellHeaderStates.ROW)) {
             isHeaderRow = true;
           }
         }
       }
 
-      output.push(`| ${rowOutput.join(' | ')} |`);
+      // A row of dashes and colons would read as a delimiter row.
+      const line = `| ${rowOutput.join(' | ')} |`;
+      output.push(
+        isTableDelimiterRow(line)
+          ? `| ${rowOutput.map(cell => cell.replace(/[-:]/, '\\$&')).join(' | ')} |`
+          : line,
+      );
       if (isHeaderRow) {
         output.push(`| ${rowOutput.map(_ => '---').join(' | ')} |`);
       }
@@ -244,16 +432,17 @@ export const TABLE: ElementTransformer = {
   regExp: TABLE_ROW_REG_EXP,
   replace: (parentNode, _1, match) => {
     // Header row
-    if (isTableRowDivider(match[0])) {
+    if (isTableDelimiterRow(match[0])) {
+      // With no table above it, the line stays text.
       const table = parentNode.getPreviousSibling();
       if (!table || !$isTableNode(table)) {
-        return;
+        return false;
       }
 
       const rows = table.getChildren();
       const lastRow = rows[rows.length - 1];
       if (!lastRow || !$isTableRowNode(lastRow)) {
-        return;
+        return false;
       }
 
       // Add header state to row cells
@@ -297,7 +486,13 @@ export const TABLE: ElementTransformer = {
         break;
       }
 
-      const cells = mapToTableCells(firstChild.getTextContent());
+      const textContent = firstChild.getTextContent();
+      // A delimiter row with no table above it stayed text.
+      if (isTableDelimiterRow(textContent)) {
+        break;
+      }
+
+      const cells = mapToTableCells(textContent);
 
       if (cells == null) {
         break;
@@ -322,30 +517,545 @@ export const TABLE: ElementTransformer = {
     }
 
     const previousSibling = parentNode.getPreviousSibling();
+    let target = table;
     if (
       $isTableNode(previousSibling) &&
       getTableColumnsSize(previousSibling) === maxCells
     ) {
       previousSibling.append(...table.getChildren());
       parentNode.remove();
+      target = previousSibling;
     } else {
       parentNode.replace(table);
     }
 
-    table.selectEnd();
+    // Only a table in the document takes the selection: nodes generated
+    // apart from it leave the selection where it was.
+    if (target.isAttached()) {
+      target.selectEnd();
+    }
   },
   type: 'element',
 };
 
+/**
+ * Whether `line` is a GFM delimiter row, which has at least one dash in
+ * every cell. `isTableRowDivider` also accepts a row of empty cells
+ * (`|  |  |`), which is how an empty row is written.
+ */
+function isTableDelimiterRow(line: string): boolean {
+  if (!isTableRowDivider(line)) {
+    return false;
+  }
+  const match = line.match(TABLE_ROW_REG_EXP);
+  return (
+    match !== null && splitTableRow(match[1]).every(cell => cell.includes('-'))
+  );
+}
+
 function getTableColumnsSize(table: TableNode) {
   const row = table.getFirstChild();
   return $isTableRowNode(row) ? row.getChildrenSize() : 0;
 }
 
+/**
+ * Splits Markdown into the parts outside code spans and the code spans
+ * themselves (odd indices), whose closing backtick run is exactly as long
+ * as the opening one. An unmatched run is ordinary text.
+ */
+function splitCodeSpans(text: string): string[] {
+  const parts: string[] = [];
+  let start = 0;
+  let i = 0;
+  while (i < text.length) {
+    if (text[i] === '\\') {
+      i += 2;
+      continue;
+    }
+    if (text[i] !== '`') {
+      i++;
+      continue;
+    }
+    const close = codeSpanEnd(text, i);
+    if (close === -1) {
+      while (text[i] === '`') {
+        i++;
+      }
+      continue;
+    }
+    parts.push(text.slice(start, i), text.slice(i, close));
+    start = i = close;
+  }
+  parts.push(text.slice(start));
+  return parts;
+}
+
+/**
+ * The end of the code span that the backtick run at `start` opens: after a
+ * closing run exactly as long as the opening one, or -1 when there is none.
+ */
+function codeSpanEnd(text: string, start: number): number {
+  let end = start;
+  while (text[end] === '`') {
+    end++;
+  }
+  const fence = text.slice(start, end);
+  let close = text.indexOf(fence, end);
+  while (close !== -1 && text[close + fence.length] === '`') {
+    while (text[close] === '`') {
+      close++;
+    }
+    close = text.indexOf(fence, close);
+  }
+  return close === -1 ? -1 : close + fence.length;
+}
+
+const CODE_FENCE_OPEN_REG_EXP = /^[ \t]*(`{3,})[^`\n]*$/;
+const CODE_FENCE_CLOSE_REG_EXP = /^[ \t]*(`{3,})[ \t]*$/;
+
+// A pipe after an odd run of backslashes.
+const ESCAPED_PIPE_REG_EXP = /(?:^|[^\\])(?:\\\\)*\\\|/;
+
+/**
+ * A code span as it is written in a cell. GFM splits a row on each pipe
+ * that no backslash escapes, then drops the backslash of each `\|` in a
+ * cell, code spans included, so each pipe in code gets a backslash of its
+ * own. Code with a backslash right before a pipe can't be written that way,
+ * since `\\|` is an escaped backslash and then a pipe that splits the row,
+ * so it is written as HTML, with its punctuation as character references,
+ * which {@link codeFromHtml} reads back.
+ */
+function encodeCodeSpan(span: string): string {
+  if (!ESCAPED_PIPE_REG_EXP.test(span)) {
+    return span.replace(/\|/g, '\\|');
+  }
+  const fence = span.length - span.replace(/^`+/, '').length;
+  let code = span.slice(fence, -fence);
+  if (/^ [^]* $/.test(code) && code.trim() !== '') {
+    code = code.slice(1, -1);
+  }
+  return `<code>${code.replace(
+    /[^\p{L}\p{N} ]/gu,
+    char => `&#${char.codePointAt(0)};`,
+  )}</code>`;
+}
+
+// A `<code>` element that has only text, past backslash escapes.
+const CODE_HTML_REG_EXP = /\\[^]|<code>([^<]*)<\/code>/gi;
+
+/**
+ * The code of a `<code>` element that has only text, between the marks
+ * that {@link $marksToNodes} turns into a code span after the cell is
+ * parsed. A code span would read as a code block if its fence were three
+ * backticks or more at the start of a line, so the code is escaped instead.
+ */
+function codeFromHtml(html: string, marks: CellMarks): string {
+  const code = html.replace(
+    /&(?:#(\d+)|#x([\da-f]+)|(amp|lt|gt|quot));/gi,
+    (reference, decimal?: string, hex?: string, name?: string) => {
+      if (name !== undefined) {
+        return {amp: '&', gt: '>', lt: '<', quot: '"'}[
+          name.toLowerCase() as 'amp' | 'gt' | 'lt' | 'quot'
+        ];
+      }
+      const codePoint = decimal ? parseInt(decimal, 10) : parseInt(hex!, 16);
+      return codePoint > 0 && codePoint <= 0x10ffff
+        ? String.fromCodePoint(codePoint)
+        : reference;
+    },
+  );
+  return (
+    marks.codeStart +
+    // A character reference is decoded after backslash escapes, so `&` is
+    // one too.
+    code.replace(/[!-/:-@[-`{-~]/g, char =>
+      char === '&' ? '&#38;' : '\\' + char,
+    ) +
+    marks.codeEnd
+  );
+}
+
+/**
+ * Writes a cell's Markdown as one line. Outside code blocks, a line break
+ * and the blank line between paragraphs become `<br>`, and a `<br>` that is
+ * text is escaped (`\<br>`) except in code spans, which take no escapes.
+ * Inside a code block, which takes no escapes either, each newline becomes
+ * a `<br>` (so blank lines survive), and a backslash, a pipe and a `<br>`
+ * that are code are backslash-escaped, which {@link decodeTableCell} undoes.
+ */
+function encodeTableCell(markdown: string, emptyMark: string = ''): string {
+  const lines = markdown.split('\n');
+  let result = '';
+  let text = '';
+  const flushText = () => {
+    result += splitCodeSpans(text)
+      .map((part, i) =>
+        i % 2 === 1
+          ? encodeCodeSpan(part)
+          : // Escapes a pipe, a `<br>` and a `<code>` that are text, past
+            // what a backslash already escapes (in `\\|`, the backslash).
+            part.replace(/\\[^]|\||<(?=br\s*\/?>|code>)/gi, match =>
+              match.length > 1 ? match : '\\' + match,
+            ),
+      )
+      .join('')
+      .replace(/\n\n?/g, (separator, offset: number, encoded: string) => {
+        // The blank line that ends a list or a quote is kept as an empty
+        // line, or the paragraph after it would continue its last line.
+        // So does the line that ends one before an empty paragraph.
+        const start = encoded.lastIndexOf('\n\n', offset - 1);
+        const block = encoded.slice(start === -1 ? 0 : start + 2);
+        const endsBlock =
+          separator.length > 1 ||
+          (emptyMark !== '' &&
+            encoded[offset + 1] === emptyMark &&
+            encoded[offset - 1] !== emptyMark);
+        return endsBlock && CONTAINER_START_REG_EXP.test(block)
+          ? '<br><br>'
+          : '<br>';
+      });
+    text = '';
+  };
+  let fence: string | null = null;
+  lines.forEach((line, i) => {
+    const separator = i > 0 ? '\n' : '';
+    if (fence === null) {
+      const open = CODE_FENCE_OPEN_REG_EXP.exec(line);
+      if (open === null) {
+        text += separator + line;
+        return;
+      }
+      fence = open[1];
+      text += separator;
+      flushText();
+      // An info string is escaped like the code.
+      result += line.replace(/[\\|]|<(?=br\s*\/?>)/gi, '\\$&');
+      return;
+    }
+    const close = CODE_FENCE_CLOSE_REG_EXP.exec(line);
+    result +=
+      '<br>' +
+      (close !== null && close[1].length >= fence.length
+        ? line
+        : line.replace(/[\\|]|<(?=br\s*\/?>)/gi, '\\$&'));
+    if (close !== null && close[1].length >= fence.length) {
+      fence = null;
+    }
+  });
+  flushText();
+  return result;
+}
+
+/** One of a cell's lines, and where it is relative to a code block. */
+interface CellLine {
+  fence: 'open' | 'code' | 'close' | null;
+  text: string;
+}
+
+// The line separators in a cell: `<br>`, or the legacy `\n`.
+const CELL_BREAK_REG_EXP = /<br\s*\/?>/iy;
+const CELL_FENCE_OPEN_REG_EXP = /^[ \t]*(`{3,})[^`]*?(?=<br\s*\/?>|\\n|$)/i;
+const CELL_FENCE_CLOSE_REG_EXP = /^[ \t]*(`{3,})[ \t]*(?=<br\s*\/?>|\\n|$)/i;
+
+/** Splits a cell's Markdown into its lines. */
+function splitCellLines(text: string): CellLine[] {
+  const lines: CellLine[] = [];
+  let fence: string | null = null;
+  let i = 0;
+  for (;;) {
+    const rest = text.slice(i);
+    let kind: CellLine['fence'] = null;
+    if (fence === null) {
+      const open = CELL_FENCE_OPEN_REG_EXP.exec(rest);
+      if (open !== null) {
+        fence = open[1];
+        kind = 'open';
+      }
+    } else {
+      const close = CELL_FENCE_CLOSE_REG_EXP.exec(rest);
+      kind =
+        close !== null && close[1].length >= fence.length ? 'close' : 'code';
+    }
+    let end = i;
+    let separator = 0;
+    while (end < text.length) {
+      CELL_BREAK_REG_EXP.lastIndex = end;
+      const br = CELL_BREAK_REG_EXP.exec(text);
+      if (br !== null) {
+        separator = br[0].length;
+        break;
+      }
+      if (text[end] === '\\') {
+        if (text[end + 1] === 'n') {
+          separator = 2;
+          break;
+        }
+        end += 2;
+      } else if (text[end] === '`' && kind === null) {
+        // `<br>` in a code span is code.
+        const spanEnd = codeSpanEnd(text, end);
+        end = spanEnd === -1 ? end + 1 : spanEnd;
+      } else {
+        end++;
+      }
+    }
+    lines.push({fence: kind, text: text.slice(i, Math.min(end, text.length))});
+    if (kind === 'close') {
+      fence = null;
+    }
+    if (end >= text.length) {
+      return lines;
+    }
+    i = end + separator;
+  }
+}
+
+// A line that must start a block of its own: a heading, a quote, a list
+// item, a thematic break, or a block equation.
+const BLOCK_START_REG_EXP =
+  /^ {0,3}(?:#{1,6}(?:\s|$)|>|[-*+]\s|\d{1,9}[.)]\s|([-*_])(?:[ \t]*\1){2,}[ \t]*$|\$\$)/;
+// A line that a block of its own ends: a heading or a thematic break.
+const BLOCK_LINE_REG_EXP =
+  /^ {0,3}(?:#{1,6}(?:\s|$)|([-*_])(?:[ \t]*\1){2,}[ \t]*$)/;
+
+/**
+ * How each separator between a cell's lines reads: as a newline where a
+ * block needs one (in a code block, and beside a fence), as a newline that
+ * a block would start or end if it isn't inside inline syntax (before a
+ * line that starts a block, or after one that a block ends), or as a line
+ * break inside a paragraph.
+ */
+type CellBreak = 'newline' | 'block' | 'inline';
+
+function cellBreaks(lines: CellLine[]): CellBreak[] {
+  const breaks: CellBreak[] = [];
+  // Whether the block being read is a list or a quote, which an empty line
+  // ends.
+  let container = isContainerStart(lines[0]);
+  let ended = false;
+  for (let i = 1; i < lines.length; i++) {
+    const line = lines[i];
+    const prev = lines[i - 1];
+    let kind: CellBreak;
+    if (line.fence !== null || prev.fence !== null || ended) {
+      kind = 'newline';
+      ended = false;
+    } else if (container && line.text.trim() === '') {
+      kind = 'newline';
+      ended = true;
+    } else {
+      kind =
+        BLOCK_START_REG_EXP.test(line.text) ||
+        BLOCK_LINE_REG_EXP.test(prev.text) ||
+        // A nested list item is indented past the parent's content.
+        (container && NESTED_LIST_ITEM_REG_EXP.test(line.text))
+          ? 'block'
+          : 'inline';
+    }
+    if (ended) {
+      container = false;
+    } else if (kind !== 'inline') {
+      container =
+        isContainerStart(line) ||
+        (container && NESTED_LIST_ITEM_REG_EXP.test(line.text));
+    }
+    breaks.push(kind);
+  }
+  return breaks;
+}
+
+// A list item at any indentation.
+const NESTED_LIST_ITEM_REG_EXP = /^[ \t]*(?:[-*+]|\d{1,9}[.)])\s/;
+
+// A line that starts a list item or a quote.
+const CONTAINER_START_REG_EXP = /^ {0,3}(?:>|[-*+]\s|\d{1,9}[.)]\s)/;
+
+function isContainerStart(line: CellLine): boolean {
+  return line.fence === null && CONTAINER_START_REG_EXP.test(line.text);
+}
+
+/**
+ * A cell's Markdown with its line separators decoded, for
+ * `$convertFromMarkdownString`. `<br>` separates lines in a cell, and the
+ * literal `\n` this transformer used to write still does, but neither
+ * inside a code span nor after a backslash escape (`\<br>`, `C:\\new`).
+ * A separator that `newline` picks becomes a newline; any other becomes
+ * the line break mark, which {@link $marksToNodes} turns into a line break
+ * after parsing, so formatting and links that span it (`**a<br>b**`,
+ * `[a<br>b](url)`) stay whole. A pipe is escaped (`\|`) everywhere in a
+ * row, code spans included, so it is unescaped here.
+ */
+function decodeTableCell(
+  lines: CellLine[],
+  newline: readonly boolean[],
+  marks: CellMarks,
+): string {
+  const mark = marks.lineBreak;
+  // Each line's text, and the separator after it.
+  const parts: string[] = [];
+  lines.forEach((line, i) => {
+    if (i > 0) {
+      // Spaces at the end of a line of code are code.
+      if (lines[i - 1].fence !== 'code') {
+        parts.push(parts.pop()!.replace(/[ \t]+$/, ''));
+      }
+      parts.push(newline[i - 1] ? '\n' : mark);
+    }
+    if (line.fence === 'code') {
+      parts.push(
+        line.text.replace(/\\([\\|<n])/g, (_, char: string) =>
+          char === 'n' ? '\n' : char,
+        ),
+      );
+    } else if (line.fence === 'open') {
+      parts.push(line.text.replace(/\\([\\|<])/g, '$1'));
+    } else if (line.fence !== null) {
+      parts.push(line.text);
+    } else {
+      const body = splitCodeSpans(line.text)
+        .map((part, k) => {
+          const unescaped = part.replace(/\\\|/g, '|');
+          return k % 2 === 1
+            ? unescaped
+            : unescaped.replace(
+                CODE_HTML_REG_EXP,
+                (match, html: string | undefined) =>
+                  html === undefined ? match : codeFromHtml(html, marks),
+              );
+        })
+        .join('');
+      // Only the cell's padding is trimmed after a line break.
+      parts.push(
+        i > 0 && parts[parts.length - 1] === mark
+          ? body.replace(/^[ \t]+/, '')
+          : body,
+      );
+    }
+  });
+  const result = parts.join('');
+  // The line break mark is a space, which Markdown trims from the end of a
+  // line, so a line that ends with one ends with an empty code span too,
+  // which {@link $marksToNodes} removes.
+  return result
+    .split('\n')
+    .map(line =>
+      line.endsWith(mark) ? line + marks.codeStart + marks.codeEnd : line,
+    )
+    .join('\n');
+}
+
+/** The text nodes under `cell` that hold each `mark`, in order. */
+function $markNodes(cell: TableCellNode, mark: string): TextNode[] {
+  return cell.getAllTextNodes().flatMap(node =>
+    node
+      .getTextContent()
+      .split(mark)
+      .slice(1)
+      .map(() => node),
+  );
+}
+
+/**
+ * Turns each line break mark in the text under `cell` into a line break,
+ * and the text between code marks into a code span.
+ */
+function $marksToNodes(cell: TableCellNode, marks: CellMarks): void {
+  // Code marks can land in different text nodes.
+  let code = false;
+  for (const node of cell.getAllTextNodes()) {
+    const text = node.getTextContent();
+    // The nodes that replace `node`, built in one pass so that a cell with
+    // many line breaks is read in linear time.
+    const nodes: LexicalNode[] = [];
+    let start = 0;
+    const pushText = (end: number) => {
+      if (end > start) {
+        const piece = $copyNode(node).setTextContent(text.slice(start, end));
+        nodes.push(
+          code && !piece.hasFormat('code') ? piece.toggleFormat('code') : piece,
+        );
+      }
+    };
+    for (let i = 0; i < text.length; i++) {
+      const char = text[i];
+      if (
+        char === marks.lineBreak ||
+        char === marks.codeStart ||
+        char === marks.codeEnd
+      ) {
+        pushText(i);
+        start = i + 1;
+        if (char === marks.lineBreak) {
+          nodes.push($createLineBreakNode());
+        } else {
+          code = char === marks.codeStart;
+        }
+      }
+    }
+    if (start === 0) {
+      if (code && !node.hasFormat('code')) {
+        node.toggleFormat('code');
+      }
+      continue;
+    }
+    pushText(text.length);
+    node.getParentOrThrow().splice(node.getIndexWithinParent(), 1, nodes);
+  }
+}
+
 const $createTableCell = (textContent: string): TableCellNode => {
-  textContent = textContent.replace(/\\n/g, '\n');
-  const cell = $createTableCellNode(TableCellHeaderStates.NO_STATUS);
-  $convertFromMarkdownString(textContent, PLAYGROUND_TRANSFORMERS, cell);
+  // GFM trims a cell's padding, which is only spaces and tabs.
+  const text = textContent.replace(/^[ \t]+|[ \t]+$/g, '');
+  const [lineBreak] = unusedChars(text, 1, LINE_BREAK_MARKS);
+  const [codeStart, codeEnd] = unusedChars(text + lineBreak, 2);
+  const marks: CellMarks = {codeEnd, codeStart, lineBreak};
+  const lines = splitCellLines(text);
+  const breaks = cellBreaks(lines);
+  // Only inline syntax can span a line break.
+  if (breaks.includes('block') && /[*_~[$]/.test(text)) {
+    // Text that would start a block can't when it follows a `<br>` inside
+    // inline syntax (`**a<br># b**`, `[a<br>- b](url)`). Read every such
+    // separator as a line break first, and keep the ones that land in
+    // formatted text or an inline element.
+    const probe = $createTableCellNode().append(
+      ...$generateNodesFromMarkdownString(
+        decodeTableCell(
+          lines,
+          breaks.map(kind => kind === 'newline'),
+          marks,
+        ),
+        PLAYGROUND_TRANSFORMERS,
+      ),
+    );
+    const marked = $markNodes(probe, lineBreak);
+    const unmarked = breaks.flatMap((kind, i) =>
+      kind === 'newline' ? [] : [i],
+    );
+    if (marked.length === unmarked.length) {
+      marked.forEach((node, k) => {
+        const parent = node.getParent();
+        if (
+          node.getFormat() !== 0 ||
+          ($isElementNode(parent) && parent.isInline())
+        ) {
+          breaks[unmarked[k]] = 'inline';
+        }
+      });
+    }
+  }
+  // Generating the nodes, unlike converting into the cell, leaves the
+  // selection alone.
+  const cell = $createTableCellNode(TableCellHeaderStates.NO_STATUS).append(
+    ...$generateNodesFromMarkdownString(
+      decodeTableCell(
+        lines,
+        breaks.map(kind => kind !== 'inline'),
+        marks,
+      ),
+      PLAYGROUND_TRANSFORMERS,
+    ),
+  );
+  $marksToNodes(cell, marks);
   return cell;
 };
 
@@ -354,9 +1064,26 @@ const mapToTableCells = (textContent: string): TableCellNode[] | null => {
   if (!match || !match[1]) {
     return null;
   }
-  return match[1].split('|').map(text => $createTableCell(text));
+  return splitTableRow(match[1]).map(text => $createTableCell(text));
 };
 
+/** Splits a row on its pipes; escaped pipes (`\|`) are cell content. */
+function splitTableRow(text: string): string[] {
+  const cells = [''];
+  for (let i = 0; i < text.length; i++) {
+    if (text[i] === '|') {
+      cells.push('');
+    } else if (text[i] === '\\' && i + 1 < text.length) {
+      // A backslash escapes the next character, pipe or not (`\\|`).
+      cells[cells.length - 1] += text.slice(i, i + 2);
+      i++;
+    } else {
+      cells[cells.length - 1] += text[i];
+    }
+  }
+  return cells;
+}
+
 export const PLAYGROUND_TRANSFORMERS: Transformer[] = [
   TABLE,
   HR,
diff --git a/packages/lexical-website/docs/serialization/markdown-mdast.md b/packages/lexical-website/docs/serialization/markdown-mdast.md
index 9e063b633e7..f27f1e18c54 100644
--- a/packages/lexical-website/docs/serialization/markdown-mdast.md
+++ b/packages/lexical-website/docs/serialization/markdown-mdast.md
@@ -122,6 +122,31 @@ defer to the document-level serialization options, which can be
 configured by contributing `mdast-util-to-markdown` options through
 `toMarkdownExtensions`.
 
+GFM table cells hold a single line, so `MdastTableExtension` writes each
+paragraph or line break in a cell as `<br>`, the line separator GitHub and
+most renderers accept there, and reads `<br>`, `<br/>` and `<br />` back as
+paragraph boundaries. GFM allows inline HTML in a cell, so when the editor
+also has `MdastHtmlExtension`, the blocks Markdown can't express on one
+line (lists, task lists, headings, quotes, code blocks and rules) are
+written as one line of HTML around their Markdown content, such as
+`<ul><li>**a**</li><li>b</li></ul>`, and read back as the same blocks.
+Without it, they are flattened to one line per item. A column's alignment (`:-:`) is
+set as the element format of each of its cells, so it renders as their
+`text-align` and stays with the column when columns are added or removed.
+GFM can't align a single cell, so on export a column takes the alignment
+most of its cells have, or if none has a majority, the alignment of its
+header cell. Raw HTML in a cell is written on one line too: a newline in its text or in
+a quoted attribute value becomes `&#10;`, which reads back as the same
+newline, so whitespace that `<pre>` or CSS keeps survives; a newline
+between a tag's attributes or in a comment becomes a space; and every `|`
+becomes `&#124;`. The text of `<script>`, `<style>` and comments takes no
+character references, so a newline there becomes a space and a pipe can't
+be written as is. Documents saved before alignment moved to the cells kept it
+as one array on the table; when such a table loads, each alignment is moved
+onto the cells of its column that have no format of their own, and a cell
+that already has one, including one GFM can't write (`justify`, `start`,
+`end`), keeps it.
+
 ## unified / remark interop
 
 The mdast tree itself is part of the API, so editor content can flow
diff --git a/pnpm-lock.yaml b/pnpm-lock.yaml
index 1b583a7edb4..1a370cb071e 100644
--- a/pnpm-lock.yaml
+++ b/pnpm-lock.yaml
@@ -468,6 +468,9 @@ importers:
       '@lexical/selection':
         specifier: workspace:*
         version: link:../../packages/lexical-selection
+      '@lexical/table':
+        specifier: workspace:*
+        version: link:../../packages/lexical-table
       '@lexical/utils':
         specifier: workspace:*
         version: link:../../packages/lexical-utils