test(editor): add Playwright E2E suite, fix blocks.value staleness, document usage

- Add 27 E2E tests across block operations, code blocks, suggestion menu,
  toolbar, live preview, and smoke tests (playwright.config.ts + 6 spec files)
- Add __testUtils__ harness with selectText (multi-paragraph), replaceContent,
  focusAtEnd/focusAtStart — gated behind testMode prop
- Fix blocks.value staleness: onBlockContentChange now accepts blockId/newContent
  to update blocks.value before serialization (was ignoring update:content event)
- Fix onBlockBoundaryExit: blocks.value[index] → blocks.value[index + 1] for
  downward navigation (off-by-one)
- Add 68 unit tests: error recovery, table edges, depth exhaustion,
  code block + stripFences, classifyBlock, logger
- Extract shared e2e/helpers.ts (focusLastBlockAtEnd)
- Docs: README Usage section, concise Vision (no stale phase table),
  AGENTS.md description, 3-stage→2-stage pipeline alignment

AGENTS.md

@@ -2,7 +2,7 @@
 
 ## System Intent & Context
 
-This repository is a high-performance, rule-based **block markdown editor** built with Vue 3, TypeScript, and the Lezer parsing framework. Documents are structured as distinct, interactive **Blocks** rather than a single flat string. A 3-stage parsing pipeline bridges UI state down to ASTs, enabling real-time extraction of pages, references, task state, callouts, and inline decorations.
+This repository is a high-performance, rule-based **block markdown editor** built with Vue 3, TypeScript, and the Lezer parsing framework. Documents are structured as distinct, interactive **Blocks** rather than a single flat string. A 2-stage parsing pipeline bridges UI state down to ASTs, enabling real-time extraction of pages, references, task state, callouts, and inline decorations.
 
 ---
 
@@ -491,3 +491,41 @@ This prevents CM6 from parsing fence backticks as template literals.
 > **Test coverage is required.** A rule without a mirror test in `__tests__/markdown-parser.test.ts` is not complete.
 
 > **Strict types.** Do not introduce `any`. If a type is genuinely unknown, model it explicitly with a discriminated union or `unknown` with a type guard.
+
+---
+
+## E2E Test Utilities (`__testUtils__`)
+
+Injected in `Editor.vue` when `testMode` prop is true (gated by `?e2e=true`).
+
+### `selectText` position convention
+
+`selectText(blockId, from, to)` treats `from`/`to` as **0-based character offsets** within the block's content string (what `docToContent` returns). Internally these are mapped to PM positions by iterating through all `textblock` nodes via `doc.descendants()` and accounting for `\n\n` separators between paragraphs. This correctly handles multi-paragraph blocks (e.g. `doc(paragraph("abc"), paragraph("def"))` maps char offset 5 to PM position 6 = `"d"` in the second paragraph). Position 0 is before the first paragraph node and resolves outside any textblock, causing `currentBlock()` to return `null`.
+
+### Caret initialization — `focusAtEnd` / `focusAtStart`
+
+`page.keyboard.type()` inserts at the cursor. But `focus()` on a contenteditable leaves the cursor at a browser-dependent position (often position 0), and `press("End")` only reaches line-end, not doc-end. This causes text to land at the wrong position in a block.
+
+Use `focusAtEnd(blockId)` or `focusAtStart(blockId)` instead to set cursor position via PM's selection API before typing:
+
+```typescript
+const blockIds = await page.evaluate(() => window.__testUtils__?.getBlockIds())
+const lastId = blockIds![blockIds!.length - 1]
+await page.evaluate((bid: string) => window.__testUtils__?.focusAtEnd(bid), lastId)
+await page.keyboard.type("hello world")   // reliably appends at end of block
+```
+
+Both helpers call `view.focus()` + `view.dispatch(tr.setSelection(...))` — absolute position, no browser quirk.
+
+### When to use `page.keyboard.type()` vs `__testUtils__`
+
+| Action | Method | Reason |
+|---|---|---|
+| Set exact text content | `insertText()` | Fast, bypasses plugins |
+| **Replace entire block content** | **`replaceContent()`** | **Single PM transaction — deterministic undo history** |
+| Select precise range | `selectText()` | Unreliable via Playwright in contenteditable |
+| Caret positioning before typing | `focusAtEnd()` / `focusAtStart()` | Browser `focus()` + `End` is unreliable |
+| Typing `[[`, `((`, `/`, `#` | `page.keyboard.type()` | Must go through `handleTextInput` → pattern plugin |
+| Typing `(` for auto-close | `page.keyboard.type()` | Must go through auto-close handler |
+| Typing `` ``` `` | `page.keyboard.type()` | Must go through `tripleBacktickRule` |
+| Paste | `page.keyboard.press('Control+V')` | Must go through paste plugin |

README.md

@@ -9,30 +9,11 @@
   A high-performance <strong>block markdown editor</strong> built with Vue 3, TypeScript, ProseMirror, and the Lezer parsing framework.
 </p>
 
-Documents are structured as distinct, interactive **Blocks** rather than a single flat string. Each block is a self-contained ProseMirror editor instance that stores raw markdown as plain text — no AST conversion, no mark storage. A Lezer-based 3-stage parsing pipeline renders syntax as visual decorations in real time, enabling live-preview editing of Obsidian-style references, task states, callouts, headings, and inline formatting.
-
-The editor is designed for the philosophy that **plain text should stay plain text** — formatting is purely decorative, never structural. This makes it ideal for note-taking apps, knowledge bases, and any tool that needs to edit rich markdown with programmatic access to the raw source.
+Documents are structured as distinct, interactive **Blocks** rather than a single flat string. Each block is a self-contained ProseMirror editor instance that stores raw markdown as plain text — no AST conversion, no mark storage. A Lezer-based parsing pipeline renders syntax as visual decorations in real time, enabling live-preview editing of Obsidian-style references, task states, callouts, headings, and inline formatting.
 
 ## Vision
 
-Enesis is being built as a complete block-editing substrate:
-
-| Phase | Feature | Status |
-|---|---|---|---|
-| 1 | Clean content model — raw markdown in/out, ProseMirror never parses formatting | **Done** |
-| 2 | Keyboard & boundary behavior — Enter, Backspace, Tab, arrows, pattern triggers | **Done** |
-| 3 | Focus & cursor control — programmatic focus, expose API | **Done** |
-| 4 | Core decoration system — Lezer-based inline tokens, cursor-reveal, caching | **Done** |
-| 5 | Block-level decorations — headings, blockquotes, tasks, callouts, properties | **Done** |
-| 6 | Code & math node views — CM6 fenced code blocks, KaTeX LaTeX rendering | **Done** |
-| 6.5 | Formatting handlers — toggle bold/italic/code/strike/highlight, insertLink, setHeading, toggleTask | **Done** |
-| 7 | Reference & tag insertion handlers — `insertPageRef`, `insertBlockRef`, `insertTag` | **Done** |
-| 8 | Reference interactivity — clickable `[[page]]`, `((block))`, `#tag` chips with preview | Planned |
-| 9 | Asset handling — image drop, upload protocol, inline preview | Planned |
-| 10 | Multi-block editing — shared toolbar, insertion zones, suggestion/mention menus, undo/redo | **Done** (shell + history) |
-| 11 | WCAG 2.1 AA compliance, screen reader support, RTL, high contrast | Planned |
-| 12 | History orchestration API across blocks | Planned |
-| Post-v1 | Third-party decoration plugin system | Planned |
+Enesis is being built as a complete block-editing substrate where **plain text stays plain text** — formatting is purely decorative via Lezer-driven decorations, never structural. This makes it ideal for note-taking apps, knowledge bases, and any tool that needs to edit rich markdown with programmatic access to the raw source.
 
 ## Design Principles
 
@@ -78,9 +59,9 @@ The multi-block architecture is the other major friction point. Each `EditorBloc
 │       ├── src/
 │       │   ├── index.ts               Public API (Block + Editor + EditorToolbar components)
 │       │   ├── components/
-│   │   │   ├── EditorBlock.vue     Self-contained ProseMirror block editor with draggable bullet
-│   │   │   ├── Editor.vue          Multi-block shell with insertion zones, drag-to-reorder, undo/redo
-│   │   │   ├── EditorInsertionZone.vue   32px hit target between blocks, hover-reveal, drag target
+│       │   │   ├── EditorBlock.vue     Self-contained ProseMirror block editor with draggable bullet
+│       │   │   ├── Editor.vue          Multi-block shell with insertion zones, drag-to-reorder, undo/redo
+│       │   │   ├── EditorInsertionZone.vue   32px hit target between blocks, hover-reveal, drag target
 │       │   │   └── EditorToolbar.vue   Shared toolbar bound to active block
 │       │   ├── composables/
 │       │   │   ├── useMarkdownDecorations.ts   ProseMirror decoration plugin
@@ -117,7 +98,7 @@ The multi-block architecture is the other major friction point. Each `EditorBloc
 │
 ├── package.json                    Workspace root
 ├── pnpm-workspace.yaml            pnpm workspace definition
-├── AGENTS.md                      Project conventions for AI coding agents
+├── AGENTS.md                      Context optimization file — strict rules and system boundaries to guide AI coding assistants safely through ProseMirror's state architecture
 └── biome.json                     Linting & formatting
 ```
 
@@ -130,6 +111,40 @@ pnpm test           # Run editor unit tests (Vitest)
 pnpm check          # Lint & format check (Biome)
 ```
 
+## Usage
+
+```bash
+pnpm install @enesis/editor
+```
+
+```vue
+<script setup lang="ts">
+import { ref } from "vue"
+import { Editor, EditorToolbar } from "@enesis/editor"
+import "@enesis/editor/dist/index.css"
+
+const content = ref(`* # Hello World
+
+  * A paragraph with **bold** and *italic* text.
+  * A TODO task with ::TODO:: status
+`)
+
+function onFocus(payload: { view: EditorView; handlers: FormattingHandlers }) {
+  // payload.handlers provides toggleBold, insertLink, setHeading, etc.
+}
+</script>
+
+<template>
+  <EditorToolbar />
+  <Editor
+    v-model:content="content"
+    @focus="onFocus"
+    @blur="() => console.log('blurred')"
+    @error="(e: any) => console.error(e)"
+  />
+</template>
+```
+
 ## Scripts
 
 | Script | Description |

packages/editor/e2e/block-operations.spec.ts

@@ -0,0 +1,59 @@
+import { expect, test } from "@playwright/test"
+import { focusLastBlockAtEnd } from "./helpers"
+
+test.describe("Block operations", () => {
+  test.beforeEach(async ({ page }) => {
+    await page.goto("/editor?e2e=true")
+  })
+
+  test("Enter splits a block and creates a new one", async ({ page }) => {
+    await focusLastBlockAtEnd(page)
+    await page.keyboard.type("hello world")
+    await page.keyboard.press("Enter")
+
+    const content = await page.evaluate(() => window.__testUtils__?.getContent())
+    expect(content).toContain("hello")
+    expect(content).toContain("world")
+  })
+
+  test("Shift+Enter creates a soft break, not a new block", async ({ page }) => {
+    const blockIds = await page.evaluate(() => window.__testUtils__?.getBlockIds())
+    const before = blockIds!.length
+
+    await focusLastBlockAtEnd(page)
+    await page.keyboard.type("line1")
+    await page.keyboard.press("Shift+Enter")
+    await page.keyboard.type("line2")
+
+    const afterIds = await page.evaluate(() => window.__testUtils__?.getBlockIds())
+    expect(afterIds!.length).toBe(before)
+  })
+
+  test("Backspace on new empty block removes it", async ({ page }) => {
+    const blockIds = await page.evaluate(() => window.__testUtils__?.getBlockIds())
+    const before = blockIds!.length
+
+    await focusLastBlockAtEnd(page)
+    await page.keyboard.press("Enter")
+
+    // The new empty block at the end should be focused. Backspace removes it.
+    await page.keyboard.press("Backspace")
+
+    const afterIds = await page.evaluate(() => window.__testUtils__?.getBlockIds())
+    expect(afterIds!.length).toBe(before)
+  })
+
+  test("ArrowDown navigates to next block", async ({ page }) => {
+    const blockIds = await page.evaluate(() => window.__testUtils__?.getBlockIds())
+    const firstId = blockIds![0]
+    const secondId = blockIds![1]
+    await page.evaluate((bid: string) => window.__testUtils__?.focusAtStart(bid), firstId)
+    await page.keyboard.type("First block ")
+    await page.evaluate((bid: string) => window.__testUtils__?.focusAtStart(bid), secondId)
+    await page.keyboard.type("Second block ")
+
+    const content = await page.evaluate(() => window.__testUtils__?.getContent())
+    expect(content).toContain("First block")
+    expect(content).toContain("Second block")
+  })
+})

packages/editor/e2e/code-block.spec.ts

@@ -0,0 +1,107 @@
+import { expect, test } from "@playwright/test"
+import { focusLastBlockAtEnd } from "./helpers"
+
+test.describe("Code block", () => {
+  test.beforeEach(async ({ page }) => {
+    await page.goto("/editor?e2e=true")
+  })
+
+  test("triple backtick creates a code block", async ({ page }) => {
+    await focusLastBlockAtEnd(page)
+    await page.keyboard.press("Enter")
+    await page.keyboard.type("```")
+
+    const blockIds = await page.evaluate(() => window.__testUtils__?.getBlockIds())
+    const lastId = blockIds![blockIds!.length - 1]
+    const codeBlock = page.locator(
+      `[role="textbox"][data-block-id="${lastId}"] [data-codeblock-editor]`,
+    )
+    await expect(codeBlock).toBeVisible({ timeout: 5000 })
+  })
+
+  test("typing in code block updates content", async ({ page }) => {
+    await focusLastBlockAtEnd(page)
+    await page.keyboard.press("Enter")
+    await page.keyboard.type("```")
+
+    const blockIds = await page.evaluate(() => window.__testUtils__?.getBlockIds())
+    const lastId = blockIds![blockIds!.length - 1]
+
+    const codeBlock = page.locator(
+      `[role="textbox"][data-block-id="${lastId}"] [data-codeblock-editor]`,
+    )
+    await expect(codeBlock).toBeVisible({ timeout: 5000 })
+    await codeBlock.locator(".cm-content").click()
+    await page.keyboard.type("const x = 1;")
+
+    const content = await page.evaluate(() => window.__testUtils__?.getContent())
+    expect(content).toContain("const x = 1;")
+  })
+
+  test("code block content is wrapped in fences", async ({ page }) => {
+    await focusLastBlockAtEnd(page)
+    await page.keyboard.press("Enter")
+    await page.keyboard.type("```")
+
+    const blockIds = await page.evaluate(() => window.__testUtils__?.getBlockIds())
+    const lastId = blockIds![blockIds!.length - 1]
+
+    const codeBlock = page.locator(
+      `[role="textbox"][data-block-id="${lastId}"] [data-codeblock-editor]`,
+    )
+    await expect(codeBlock).toBeVisible({ timeout: 5000 })
+    await codeBlock.locator(".cm-content").click()
+    await page.keyboard.type("const x = 1;")
+
+    const content = await page.evaluate(() => window.__testUtils__?.getContent())
+    expect(content).toContain("```")
+    expect(content).toContain("const x = 1;")
+  })
+
+  test("ArrowUp at code block start exits to paragraph above", async ({ page }) => {
+    await focusLastBlockAtEnd(page)
+    await page.keyboard.press("Enter")
+    await page.keyboard.type("paragraph above")
+    await page.keyboard.press("Enter")
+    await page.keyboard.type("```")
+
+    const blockIds = await page.evaluate(() => window.__testUtils__?.getBlockIds())
+    const lastId = blockIds![blockIds!.length - 1]
+
+    const codeBlock = page.locator(
+      `[role="textbox"][data-block-id="${lastId}"] [data-codeblock-editor]`,
+    )
+    await expect(codeBlock).toBeVisible({ timeout: 5000 })
+    await codeBlock.locator(".cm-content").click()
+
+    // ArrowUp should exit the code block to the previous block
+    await page.keyboard.press("ArrowUp")
+    await page.waitForTimeout(100)
+
+    // Type should go to the paragraph above
+    await page.keyboard.type(" added above")
+
+    const content = await page.evaluate(() => window.__testUtils__?.getContent())
+    expect(content).toContain("paragraph above added above")
+  })
+
+  test("empty code block removed by Backspace", async ({ page }) => {
+    await focusLastBlockAtEnd(page)
+    await page.keyboard.press("Enter")
+    await page.keyboard.type("```")
+
+    const blockIds = await page.evaluate(() => window.__testUtils__?.getBlockIds())
+    const lastId = blockIds![blockIds!.length - 1]
+    const scoped = `[role="textbox"][data-block-id="${lastId}"]`
+
+    const codeBlock = page.locator(`${scoped} [data-codeblock-editor]`)
+    await expect(codeBlock).toBeVisible({ timeout: 5000 })
+    await codeBlock.locator(".cm-content").click()
+
+    // Backspace in empty code block should remove it
+    await page.keyboard.press("Backspace")
+    await page.waitForTimeout(100)
+
+    await expect(page.locator(`${scoped} [data-codeblock-editor]`)).not.toBeVisible()
+  })
+})

packages/editor/e2e/helpers.ts

@@ -0,0 +1,7 @@
+import { type Page } from "@playwright/test"
+
+export async function focusLastBlockAtEnd(page: Page) {
+  const blockIds = await page.evaluate(() => window.__testUtils__?.getBlockIds())
+  const lastId = blockIds![blockIds!.length - 1]
+  await page.evaluate((bid: string) => window.__testUtils__?.focusAtEnd(bid), lastId)
+}

packages/editor/e2e/live-preview.spec.ts

@@ -0,0 +1,45 @@
+import { expect, test } from "@playwright/test"
+
+test.describe("Live preview markers", () => {
+  test.beforeEach(async ({ page }) => {
+    await page.goto("/editor?e2e=true")
+  })
+
+  test("bold markers visible when block is focused", async ({ page }) => {
+    const pm = page.locator('[role="textbox"][data-block-id]').first()
+    await pm.focus()
+
+    const boldMarker = pm.locator(".md-strong")
+    await expect(boldMarker.first()).toBeVisible()
+  })
+
+  test("page ref chip rendered after blur", async ({ page }) => {
+    const blockIds = await page.evaluate(() => window.__testUtils__?.getBlockIds())
+    expect(blockIds).toBeDefined()
+    const id = blockIds![2] // block with "References" content
+
+    await page.evaluate(
+      ({ bid }) => window.__testUtils__?.insertText(bid, " [[Test Page]]"),
+      { bid: id },
+    )
+
+    // Blur triggers live-preview decoration rendering
+    await page.evaluate(() => window.__testUtils__?.toggleBlur())
+
+    // The ref chip renders within the modified block
+    const refBlock = page.locator(`[role="textbox"][data-block-id="${id}"]`)
+    await expect(refBlock.locator('.md-page-ref[data-page-name="Test Page"]')).toBeVisible()
+  })
+
+  test("bold markers persist after blur in always-visible mode", async ({ page }) => {
+    const pm = page.locator('[role="textbox"][data-block-id]').first()
+    await pm.focus()
+
+    await expect(pm.locator(".md-strong").first()).toBeVisible()
+
+    await page.evaluate(() => window.__testUtils__?.toggleBlur())
+
+    // always-visible mode keeps markers rendered regardless of focus
+    await expect(pm.locator(".md-strong").first()).toBeVisible()
+  })
+})

packages/editor/e2e/suggestion-menu.spec.ts

@@ -0,0 +1,90 @@
+import { expect, test } from "@playwright/test"
+
+test.describe("Suggestion menu", () => {
+  test.beforeEach(async ({ page }) => {
+    await page.goto("/editor?e2e=true")
+  })
+
+  test("typing / opens the suggestion menu", async ({ page }) => {
+    const firstBlock = page.locator("[data-block-id]").first()
+    await firstBlock.focus()
+    await page.keyboard.type("/")
+
+    await expect(page.locator("[data-command-palette]")).toBeVisible({
+      timeout: 3000,
+    })
+  })
+
+  test("suggestion menu shows items with data-menu-item-index", async ({ page }) => {
+    const firstBlock = page.locator("[data-block-id]").first()
+    await firstBlock.focus()
+    await page.keyboard.type("/")
+
+    const menu = page.locator("[data-command-palette]")
+    await expect(menu).toBeVisible({ timeout: 3000 })
+
+    const items = menu.locator("[data-menu-item-index]")
+    const count = await items.count()
+    expect(count).toBeGreaterThan(0)
+  })
+
+  test("Escape closes the suggestion menu", async ({ page }) => {
+    const firstBlock = page.locator("[data-block-id]").first()
+    await firstBlock.focus()
+    await page.keyboard.type("/")
+
+    const menu = page.locator("[data-command-palette]")
+    await expect(menu).toBeVisible({ timeout: 3000 })
+
+    await page.keyboard.press("Escape")
+    await expect(menu).not.toBeVisible()
+  })
+
+  test("ArrowDown highlights next item", async ({ page }) => {
+    const firstBlock = page.locator("[data-block-id]").first()
+    await firstBlock.focus()
+    await page.keyboard.type("/")
+
+    const menu = page.locator("[data-command-palette]")
+    await expect(menu).toBeVisible({ timeout: 3000 })
+
+    // First item should be highlighted initially
+    const firstItem = menu.locator('[data-menu-item-index="0"]')
+    await expect(firstItem).toHaveAttribute("data-highlighted")
+
+    await page.keyboard.press("ArrowDown")
+
+    // Second item should now be highlighted
+    const secondItem = menu.locator('[data-menu-item-index="1"]')
+    await expect(secondItem).toHaveAttribute("data-highlighted")
+  })
+
+  test("ArrowUp wraps to last item", async ({ page }) => {
+    const firstBlock = page.locator("[data-block-id]").first()
+    await firstBlock.focus()
+    await page.keyboard.type("/")
+
+    const menu = page.locator("[data-command-palette]")
+    await expect(menu).toBeVisible({ timeout: 3000 })
+
+    await page.keyboard.press("ArrowUp")
+
+    const items = menu.locator("[data-menu-item-index]")
+    const lastIndex = (await items.count()) - 1
+    const lastItem = menu.locator(`[data-menu-item-index="${lastIndex}"]`)
+    await expect(lastItem).toHaveAttribute("data-highlighted")
+  })
+
+  test("Enter selects the highlighted item and closes menu", async ({ page }) => {
+    const firstBlock = page.locator("[data-block-id]").first()
+    await firstBlock.focus()
+    await page.keyboard.type("/")
+
+    const menu = page.locator("[data-command-palette]")
+    await expect(menu).toBeVisible({ timeout: 3000 })
+
+    // Slash commands insert content — just verify the menu closes
+    await page.keyboard.press("Enter")
+    await expect(menu).not.toBeVisible()
+  })
+})

packages/editor/e2e/toolbar.spec.ts

@@ -0,0 +1,85 @@
+import { expect, test } from "@playwright/test"
+
+test.describe("Toolbar", () => {
+  test.beforeEach(async ({ page }) => {
+    await page.goto("/editor?e2e=true")
+  })
+
+  async function replaceFirstBlockContent(page: any, text: string) {
+    const blockIds = await page.evaluate(() => window.__testUtils__?.getBlockIds())
+    const firstId = blockIds![0]
+    await page.evaluate(
+      ({ bid, t }: { bid: string; t: string }) =>
+        window.__testUtils__?.replaceContent(bid, t),
+      { bid: firstId, t: text },
+    )
+  }
+
+  test("bold button wraps selected text in **", async ({ page }) => {
+    await replaceFirstBlockContent(page, "bold this")
+
+    const blockIds = await page.evaluate(() => window.__testUtils__?.getBlockIds())
+    const firstId = blockIds![0]
+    await page.evaluate(
+      ({ bid, from, to }) => window.__testUtils__?.selectText(bid, from, to),
+      { bid: firstId, from: 0, to: 9 },
+    )
+
+    await page.locator('[data-toolbar-action="bold"]').click()
+
+    const content = await page.evaluate(() => window.__testUtils__?.getContent())
+    expect(content).toContain("**bold this**")
+  })
+
+  test("italic button wraps selected text in *", async ({ page }) => {
+    await replaceFirstBlockContent(page, "italic this")
+
+    const blockIds = await page.evaluate(() => window.__testUtils__?.getBlockIds())
+    const firstId = blockIds![0]
+    await page.evaluate(
+      ({ bid, from, to }) => window.__testUtils__?.selectText(bid, from, to),
+      { bid: firstId, from: 0, to: 11 },
+    )
+
+    await page.locator('[data-toolbar-action="italic"]').click()
+
+    const content = await page.evaluate(() => window.__testUtils__?.getContent())
+    expect(content).toContain("*italic this*")
+  })
+
+  test("undo button reverts last change", async ({ page }) => {
+    const blockIds = await page.evaluate(() => window.__testUtils__?.getBlockIds())
+    const firstId = blockIds![0]
+    await page.evaluate((bid: string) => window.__testUtils__?.focusAtEnd(bid), firstId)
+    await page.keyboard.type("X")
+
+    const before = await page.evaluate(() => window.__testUtils__?.getContent())
+
+    await page.locator('[data-toolbar-action="undo"]').click()
+
+    const after = await page.evaluate(() => window.__testUtils__?.getContent())
+    expect(after).not.toBe(before)
+  })
+
+  test("redo button restores undone change", async ({ page }) => {
+    const blockIds = await page.evaluate(() => window.__testUtils__?.getBlockIds())
+    const firstId = blockIds![0]
+    await page.evaluate((bid: string) => window.__testUtils__?.focusAtEnd(bid), firstId)
+    await page.keyboard.type("X")
+
+    const beforeUndo = await page.evaluate(() => window.__testUtils__?.getContent())
+
+    await page.locator('[data-toolbar-action="undo"]').click()
+    await page.locator('[data-toolbar-action="redo"]').click()
+
+    const afterRedo = await page.evaluate(() => window.__testUtils__?.getContent())
+    expect(afterRedo).toBe(beforeUndo)
+  })
+
+  test("toolbar buttons are visible", async ({ page }) => {
+    await expect(page.locator('[data-toolbar-action="bold"]')).toBeVisible()
+    await expect(page.locator('[data-toolbar-action="italic"]')).toBeVisible()
+    await expect(page.locator('[data-toolbar-action="undo"]')).toBeVisible()
+    await expect(page.locator('[data-toolbar-action="redo"]')).toBeVisible()
+  })
+})

packages/editor/src/__test-utils__/harness.d.ts

@@ -5,8 +5,14 @@ export interface EditorTestUtils {
   getBlockIds: () => string[]
   /** Dispatch a PM transaction to insert text (bypasses auto-close & pattern plugins) */
   insertText: (blockId: string, text: string) => void
+  /** Replace the block's entire content in a single PM transaction (deterministic undo history) */
+  replaceContent: (blockId: string, text: string) => void
   /** Serialize all blocks to unified markdown */
   getContent: () => string
+  /** Focus a block with cursor at end of its content (reliable caret positioning) */
+  focusAtEnd: (blockId: string) => void
+  /** Focus a block with cursor at start of its content */
+  focusAtStart: (blockId: string) => void
   /** Click outside the editor to trigger live-preview (blur) */
   toggleBlur: () => Promise<void>
   /** Return the Lezer AST tree snapshot for assertion */

packages/editor/src/components/Editor.vue

@@ -393,7 +393,13 @@ watch(
 )
 
 // Serialize and emit when any block's content changes.
-function onBlockContentChange() {
+function onBlockContentChange(blockId?: string, newContent?: string) {
+  if (blockId && newContent) {
+    const idx = blocks.value.findIndex((b) => b.id === blockId)
+    if (idx >= 0) {
+      blocks.value[idx] = { ...blocks.value[idx], content: newContent }
+    }
+  }
   lastSerialized = serializeBlocks(blocks.value)
   content.value = lastSerialized
 }
@@ -603,8 +609,22 @@ function onArrowDownFromEnd(index: number, leftOffset?: number) {
 }
 
 function onBlockBoundaryExit(index: number, direction: "up" | "down") {
+  log.info("onBlockBoundaryExit", { index, direction })
+  if (direction === "up") {
+    const prev = blocks.value[index - 1]
+    if (prev) {
+      registry.focus(prev.id, "end")
+      return
+    }
+  } else {
+    const next = blocks.value[index + 1]
+    if (next) {
+      registry.focus(next.id, "start")
+      return
+    }
+  }
+  // Fallback to insertion zone if no adjacent block
   const zoneIndex = direction === "up" ? index : index + 1
-  log.info("onBlockBoundaryExit", { index, direction, zoneIndex })
   focusZone(zoneIndex)
 }
 
@@ -765,29 +785,94 @@ function onZoneActivate(index: number, content: string) {
 // tree-shaken since the prop is never true.
 onMounted(() => {
   if (!props.testMode) return
-  window.__testUtils__ = {
-    selectText(blockId, from, to) {
+  ;(window as any).__testUtils__ = {
+    selectText(blockId: string, from: number, to: number) {
       const api = blockRefs.get(blockId) as any
       if (!api?.view) return
       const v = api.view as EditorView
       v.focus()
+      // Map 0-based character offsets (as returned by docToContent) → PM document positions.
+      // Walks all textblocks accounting for "\n\n" separators between them.
+      const doc = v.state.doc
+      let charPos = 0
+      let pmFrom: number | null = null
+      let pmTo: number | null = null
+      doc.descendants((node, pos) => {
+        if (!node.isTextblock) return true
+        const textLen = node.textContent.length
+        const contentStart = pos + 1
+        const charEnd = charPos + textLen
+        if (pmFrom === null && from < charEnd) {
+          pmFrom = contentStart + Math.max(0, from - charPos)
+        }
+        if (pmTo === null && to <= charEnd) {
+          pmTo = contentStart + Math.max(0, to - charPos)
+        }
+        charPos = charEnd + 2 // docToContent joins with "\n\n"
+        return pmFrom === null || pmTo === null
+      })
+      if (pmFrom === null) pmFrom = doc.content.size
+      if (pmTo === null) pmTo = doc.content.size
       v.dispatch(
-        v.state.tr.setSelection(TextSelection.create(v.state.doc, from, to)),
+        v.state.tr.setSelection(
+          TextSelection.create(doc, pmFrom, pmTo),
+        ),
       )
     },
     getBlockIds() {
       return Array.from(blockRefs.keys())
     },
-    insertText(blockId, text) {
+    insertText(blockId: string, text: string) {
       const api = blockRefs.get(blockId) as any
       if (!api?.view) return
       const v = api.view as EditorView
       v.focus()
       v.dispatch(v.state.tr.insertText(text))
     },
+    /** Replace the block's entire content in a single PM transaction */
+    replaceContent(blockId: string, text: string) {
+      const api = blockRefs.get(blockId) as any
+      if (!api?.setContent) {
+        console.warn(
+          `[Editor] replaceContent: block ${blockId} has no setContent method`,
+        )
+        return
+      }
+      api.setContent(text)
+    },
     getContent() {
       return serializeBlocks(blocks.value)
     },
+    focusAtEnd(blockId: string) {
+      const api = blockRefs.get(blockId) as any
+      if (!api?.view) return
+      const v = api.view as EditorView
+      const end = v.state.doc.content.size
+      v.focus()
+      v.dispatch(
+        v.state.tr.setSelection(
+          TextSelection.create(v.state.doc, end, end),
+        ).scrollIntoView(),
+      )
+    },
+    focusAtStart(blockId: string) {
+      const api = blockRefs.get(blockId) as any
+      if (!api?.view) return
+      const v = api.view as EditorView
+      v.focus()
+      let start = 0
+      v.state.doc.descendants((node, pos) => {
+        if (node.isTextblock) {
+          start = pos + 1
+          return false
+        }
+      })
+      v.dispatch(
+        v.state.tr.setSelection(
+          TextSelection.create(v.state.doc, start, start),
+        ).scrollIntoView(),
+      )
+    },
     toggleBlur() {
       return new Promise<void>((resolve) => {
         const btn = document.createElement("button")
@@ -807,7 +892,7 @@ onMounted(() => {
       if (!firstApi?.view) return ""
       return (firstApi.view as EditorView).state.doc.toString()
     },
-    setTimeSource(fakeMs) {
+    setTimeSource(fakeMs: number) {
       ;(window as any).__testTimeSource = fakeMs
     },
   }
@@ -898,7 +983,7 @@ defineExpose({
           :resolved-refs-version="resolvedRefsVersion"
           :resolve-asset="resolveAsset"
           class="flex-1 min-w-0"
-          @update:content="onBlockContentChange"
+          @update:content="(val: string) => onBlockContentChange(block.id, val)"
           @split="(before, after) => onSplit(i, before, after)"
           @merge-previous="onMergePrevious(i)"
           @delete-if-empty="onDeleteIfEmpty(i)"

packages/editor/src/composables/__tests__/node-views.test.ts

@@ -142,4 +142,139 @@ describe("CodeBlockView", () => {
 
     nodeView.destroy()
   })
+
+  it("stopEvent returns true for keyboard events", async () => {
+    const { CodeBlockView } = await import("@/composables/useCodeBlockView")
+
+    const textNode = schema.text("```\ncode\n```")
+    const node = schema.nodes.code_block.create({ language: "" }, [textNode])
+    const doc = schema.node("doc", {}, [node])
+    const state = EditorState.create({ doc, schema })
+    const dom = document.createElement("div")
+    const view = new EditorView(dom, { state })
+    views.push(view)
+
+    const nodeView = new CodeBlockView(node, view, () => 0)
+
+    expect(nodeView.stopEvent(new Event("keydown"))).toBe(true)
+    expect(nodeView.stopEvent(new Event("keypress"))).toBe(true)
+    expect(nodeView.stopEvent(new Event("keyup"))).toBe(true)
+
+    nodeView.destroy()
+  })
+
+  it("stopEvent returns false for clipboard events", async () => {
+    const { CodeBlockView } = await import("@/composables/useCodeBlockView")
+
+    const textNode = schema.text("```\ncode\n```")
+    const node = schema.nodes.code_block.create({ language: "" }, [textNode])
+    const doc = schema.node("doc", {}, [node])
+    const state = EditorState.create({ doc, schema })
+    const dom = document.createElement("div")
+    const view = new EditorView(dom, { state })
+    views.push(view)
+
+    const nodeView = new CodeBlockView(node, view, () => 0)
+
+    expect(nodeView.stopEvent(new Event("copy"))).toBe(false)
+    expect(nodeView.stopEvent(new Event("cut"))).toBe(false)
+    expect(nodeView.stopEvent(new Event("paste"))).toBe(false)
+
+    nodeView.destroy()
+  })
+
+  it("stopEvent returns false for composition events", async () => {
+    const { CodeBlockView } = await import("@/composables/useCodeBlockView")
+
+    const textNode = schema.text("```\ncode\n```")
+    const node = schema.nodes.code_block.create({ language: "" }, [textNode])
+    const doc = schema.node("doc", {}, [node])
+    const state = EditorState.create({ doc, schema })
+    const dom = document.createElement("div")
+    const view = new EditorView(dom, { state })
+    views.push(view)
+
+    const nodeView = new CodeBlockView(node, view, () => 0)
+
+    expect(nodeView.stopEvent(new Event("compositionstart"))).toBe(false)
+    expect(nodeView.stopEvent(new Event("compositionupdate"))).toBe(false)
+    expect(nodeView.stopEvent(new Event("compositionend"))).toBe(false)
+
+    nodeView.destroy()
+  })
+})
+
+describe("stripFences / addFences", () => {
+  it("stripFences removes first and last fence lines", async () => {
+    const { stripFences } = await import("@/composables/useCodeBlockView")
+    expect(stripFences("```js\nconst x = 1\n```")).toBe("const x = 1")
+  })
+
+  it("stripFences handles empty body", async () => {
+    const { stripFences } = await import("@/composables/useCodeBlockView")
+    expect(stripFences("```js\n```")).toBe("")
+  })
+
+  it("stripFences handles multiline body", async () => {
+    const { stripFences } = await import("@/composables/useCodeBlockView")
+    expect(stripFences("```\nline1\nline2\n```")).toBe("line1\nline2")
+  })
+
+  it("stripFences handles no language", async () => {
+    const { stripFences } = await import("@/composables/useCodeBlockView")
+    expect(stripFences("```\nconst x = 1\n```")).toBe("const x = 1")
+  })
+
+  it("addFences wraps body with fence markers and language", async () => {
+    const { addFences } = await import("@/composables/useCodeBlockView")
+    expect(addFences("const x = 1", "js")).toBe("```js\nconst x = 1\n```")
+  })
+
+  it("addFences handles empty language", async () => {
+    const { addFences } = await import("@/composables/useCodeBlockView")
+    expect(addFences("const x = 1", "")).toBe("```\nconst x = 1\n```")
+  })
+
+  it("addFences normalizes trailing newline", async () => {
+    const { addFences } = await import("@/composables/useCodeBlockView")
+    expect(addFences("const x = 1\n", "js")).toBe("```js\nconst x = 1\n```")
+  })
+
+  it("addFences handles empty body", async () => {
+    const { addFences } = await import("@/composables/useCodeBlockView")
+    expect(addFences("", "js")).toBe("```js\n\n```")
+  })
+
+  it("stripFences / addFences roundtrip preserves content", async () => {
+    const { stripFences, addFences } = await import(
+      "@/composables/useCodeBlockView"
+    )
+    const original = "```ts\nconst x: number = 1\n```"
+    const body = stripFences(original)
+    const restored = addFences(body, "ts")
+    expect(restored).toBe(original)
+  })
+
+  it("addFences adds newline after empty body", async () => {
+    // addFences always appends a trailing newline after the body to ensure
+    // the closing ``` is on its own line. This means stripFences→addFences
+    // is not idempotent for the edge case of an empty code block
+    // ("```\n```" → "```\n\n```"). The fence format is normalized on write.
+    const { stripFences, addFences } = await import(
+      "@/composables/useCodeBlockView"
+    )
+    const original = "```\n```"
+    const body = stripFences(original)
+    const restored = addFences(body, "")
+    expect(restored).toBe("```\n\n```")
+  })
+
+  it("addFences preserves trailing whitespace in body", async () => {
+    const { addFences } = await import("@/composables/useCodeBlockView")
+    const body = "line with trailing   "
+    const result = addFences(body, "")
+    expect(result).toContain("line with trailing   ")
+    expect(result.startsWith("```")).toBe(true)
+    expect(result).toBe("```\nline with trailing   \n```")
+  })
 })

packages/editor/src/lib/__tests__/editor-operations.test.ts

@@ -1,6 +1,7 @@
 import { describe, expect, it, vi } from "vitest"
 import { stableId } from "@/__test-utils__"
 import type { EditorBlockData } from "@/lib/block-parser"
+import { classifyBlock } from "@/lib/markdown-rules/block-classifier"
 import {
   deleteIfEmpty,
   indentBlock,
@@ -326,3 +327,106 @@ describe("moveBlock", () => {
     expect(result[1].id).toBe("b")
   })
 })
+
+describe("classifyBlock", () => {
+  it("classifies heading at various levels", () => {
+    expect(classifyBlock("# H1").kind).toBe("heading")
+    expect(classifyBlock("## H2").kind).toBe("heading")
+    expect(classifyBlock("###### H6").kind).toBe("heading")
+  })
+
+  it("classifies heading with correct level", () => {
+    const result = classifyBlock("### H3")
+    if (result.kind === "heading") {
+      expect(result.level).toBe(3)
+    }
+  })
+
+  it("classifies code fence with language", () => {
+    const result = classifyBlock("```python")
+    expect(result.kind).toBe("code")
+    if (result.kind === "code") {
+      expect(result.language).toBe("python")
+    }
+  })
+
+  it("classifies code fence without language", () => {
+    const result = classifyBlock("```")
+    expect(result.kind).toBe("code")
+    if (result.kind === "code") {
+      expect(result.language).toBe("")
+    }
+  })
+
+  it("classifies tilde code fence", () => {
+    const result = classifyBlock("~~~")
+    expect(result.kind).toBe("code")
+  })
+
+  it("classifies lowercase task state", () => {
+    const result = classifyBlock("todo buy milk")
+    expect(result.kind).toBe("task")
+    if (result.kind === "task") {
+      expect(result.taskState).toBe("TODO")
+    }
+  })
+
+  it("classifies all task states", () => {
+    const states = ["TODO", "DOING", "DONE", "LATER", "NOW", "WAITING", "CANCELLED"]
+    for (const s of states) {
+      const result = classifyBlock(`${s} task`)
+      expect(result.kind).toBe("task")
+      if (result.kind === "task") {
+        expect(result.taskState).toBe(s)
+      }
+    }
+  })
+
+  it("classifies empty callout as callout", () => {
+    const result = classifyBlock("> [!NOTE]")
+    expect(result.kind).toBe("callout")
+    if (result.kind === "callout") {
+      expect(result.calloutType).toBe("NOTE")
+    }
+  })
+
+  it("classifies callout with arbitrary type", () => {
+    const result = classifyBlock("> [!CUSTOM] text")
+    expect(result.kind).toBe("callout")
+    if (result.kind === "callout") {
+      expect(result.calloutType).toBe("CUSTOM")
+    }
+  })
+
+  it("classifies callout with extra whitespace", () => {
+    const result = classifyBlock(">  [!NOTE]  text")
+    expect(result.kind).toBe("callout")
+  })
+
+  it("classifies blockquote", () => {
+    const result = classifyBlock("> quoted text")
+    expect(result.kind).toBe("blockquote")
+  })
+
+  it("classifies plain text as paragraph", () => {
+    expect(classifyBlock("some text").kind).toBe("paragraph")
+  })
+
+  it("classifies empty string as paragraph", () => {
+    expect(classifyBlock("").kind).toBe("paragraph")
+  })
+
+  it("classifies string with only whitespace as paragraph", () => {
+    expect(classifyBlock("   ").kind).toBe("paragraph")
+  })
+
+  it("classifies heading with leading spaces as paragraph (classifyBlock is regex-based)", () => {
+    const result = classifyBlock("  # Title")
+    expect(result.kind).toBe("paragraph")
+  })
+
+  it("classifies blockquote with leading space as paragraph (classifyBlock is regex-based)", () => {
+    const result = classifyBlock(" > text")
+    expect(result.kind).toBe("paragraph")
+  })
+})

packages/editor/src/lib/__tests__/logger.test.ts

@@ -0,0 +1,186 @@
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest"
+
+beforeEach(() => {
+  localStorage.clear()
+})
+
+afterEach(() => {
+  vi.restoreAllMocks()
+})
+
+async function freshLogger() {
+  vi.resetModules()
+  return import("@/lib/logger")
+}
+
+describe("createLogger", () => {
+  it("logs debug when global filter is wildcard", async () => {
+    localStorage.setItem("editor:debug", "*")
+    const { createLogger } = await freshLogger()
+    const log = createLogger("MyFeature")
+    const spy = vi.spyOn(console, "debug").mockImplementation(() => {})
+    log.debug("test message")
+    expect(spy).toHaveBeenCalledWith("[MyFeature]", "test message")
+  })
+
+  it("logs info when global filter is wildcard", async () => {
+    localStorage.setItem("editor:debug", "*")
+    const { createLogger } = await freshLogger()
+    const log = createLogger("MyFeature")
+    const spy = vi.spyOn(console, "info").mockImplementation(() => {})
+    log.info("info message")
+    expect(spy).toHaveBeenCalledWith("[MyFeature]", "info message")
+  })
+
+  it("does not log debug when no global filter matches", async () => {
+    localStorage.setItem("editor:debug", "OtherNamespace")
+    const { createLogger } = await freshLogger()
+    const log = createLogger("MyFeature")
+    const spy = vi.spyOn(console, "debug").mockImplementation(() => {})
+    log.debug("should not appear")
+    expect(spy).not.toHaveBeenCalled()
+  })
+
+  it("logs when namespace matches specific global filter", async () => {
+    localStorage.setItem("editor:debug", "Block,MyFeature,Parse")
+    const { createLogger } = await freshLogger()
+    const log = createLogger("MyFeature")
+    const spy = vi.spyOn(console, "info").mockImplementation(() => {})
+    log.info("visible")
+    expect(spy).toHaveBeenCalled()
+  })
+
+  it("does not log for non-matching namespace in comma-separated filter", async () => {
+    localStorage.setItem("editor:debug", "Block,Parse")
+    const { createLogger } = await freshLogger()
+    const log = createLogger("Other")
+    const spy = vi.spyOn(console, "info").mockImplementation(() => {})
+    log.info("invisible")
+    expect(spy).not.toHaveBeenCalled()
+  })
+})
+
+describe("component filter", () => {
+  it("component filter wildcard logs regardless of global", async () => {
+    localStorage.setItem("editor:debug", "Unrelated")
+    const { createLogger } = await freshLogger()
+    const log = createLogger("MyFeature", "*")
+    const spy = vi.spyOn(console, "debug").mockImplementation(() => {})
+    log.debug("visible via component filter")
+    expect(spy).toHaveBeenCalled()
+  })
+
+  it("component filter with matching namespace logs", async () => {
+    localStorage.setItem("editor:debug", "Unrelated")
+    const { createLogger } = await freshLogger()
+    const log = createLogger("MyFeature", "MyFeature,Other")
+    const spy = vi.spyOn(console, "info").mockImplementation(() => {})
+    log.info("visible")
+    expect(spy).toHaveBeenCalled()
+  })
+
+  it("component filter with non-matching namespace suppresses logs", async () => {
+    localStorage.setItem("editor:debug", "*")
+    const { createLogger } = await freshLogger()
+    const log = createLogger("MyFeature", "Other")
+    const spy = vi.spyOn(console, "debug").mockImplementation(() => {})
+    log.debug("suppressed by component filter")
+    expect(spy).not.toHaveBeenCalled()
+  })
+})
+
+describe("level filtering", () => {
+  it("does not log debug when minLevel is info", async () => {
+    const { createLogger } = await freshLogger()
+    const log = createLogger("MyFeature")
+    const spy = vi.spyOn(console, "debug").mockImplementation(() => {})
+    log.debug("should not appear")
+    expect(spy).not.toHaveBeenCalled()
+  })
+
+  it("logs warn when namespace matches global filter", async () => {
+    localStorage.setItem("editor:debug", "MyFeature")
+    const { createLogger } = await freshLogger()
+    const log = createLogger("MyFeature")
+    const spy = vi.spyOn(console, "warn").mockImplementation(() => {})
+    log.warn("warning is visible")
+    expect(spy).toHaveBeenCalled()
+  })
+
+  it("logs error when namespace matches global filter", async () => {
+    localStorage.setItem("editor:debug", "MyFeature")
+    const { createLogger } = await freshLogger()
+    const log = createLogger("MyFeature")
+    const spy = vi.spyOn(console, "error").mockImplementation(() => {})
+    log.error("error is always visible")
+    expect(spy).toHaveBeenCalled()
+  })
+})
+
+describe("configureDebug", () => {
+  it("updates namespace at runtime", async () => {
+    const { configureDebug, createLogger } = await freshLogger()
+    configureDebug({ namespaces: "RuntimeNS", minLevel: "debug" })
+
+    const matchingLog = createLogger("RuntimeNS")
+    const spyMatch = vi.spyOn(console, "debug").mockImplementation(() => {})
+    matchingLog.debug("matches runtime config")
+    expect(spyMatch).toHaveBeenCalled()
+    spyMatch.mockRestore()
+
+    const nonMatchingLog = createLogger("Other")
+    const spyNoMatch = vi.spyOn(console, "debug").mockImplementation(() => {})
+    nonMatchingLog.debug("does not match")
+    expect(spyNoMatch).not.toHaveBeenCalled()
+  })
+
+  it("updates minLevel at runtime to allow debug", async () => {
+    const { configureDebug, createLogger } = await freshLogger()
+    configureDebug({ namespaces: "*", minLevel: "debug" })
+
+    const log = createLogger("Any")
+    const spy = vi.spyOn(console, "debug").mockImplementation(() => {})
+    log.debug("now visible")
+    expect(spy).toHaveBeenCalled()
+  })
+
+  it("updates minLevel at runtime to suppress info", async () => {
+    const { configureDebug, createLogger } = await freshLogger()
+    configureDebug({ namespaces: "*", minLevel: "warn" })
+
+    const log = createLogger("Any")
+    const infoSpy = vi.spyOn(console, "info").mockImplementation(() => {})
+    log.info("suppressed by minLevel")
+    expect(infoSpy).not.toHaveBeenCalled()
+
+    const warnSpy = vi.spyOn(console, "warn").mockImplementation(() => {})
+    log.warn("warn is above minLevel")
+    expect(warnSpy).toHaveBeenCalled()
+  })
+})
+
+describe("default config", () => {
+  it("uses default config when localStorage is empty", async () => {
+    const { createLogger } = await freshLogger()
+    const log = createLogger("Any")
+    const warnSpy = vi.spyOn(console, "warn").mockImplementation(() => {})
+    log.warn("warn visible by default")
+    expect(warnSpy).toHaveBeenCalled()
+
+    const debugSpy = vi.spyOn(console, "debug").mockImplementation(() => {})
+    log.debug("debug not visible by default")
+    expect(debugSpy).not.toHaveBeenCalled()
+  })
+
+  it("handles localStorage unavailable gracefully", async () => {
+    const getItem = vi.spyOn(Storage.prototype, "getItem").mockImplementation(() => {
+      throw new Error("storage unavailable")
+    })
+    const { createLogger } = await freshLogger()
+    const log = createLogger("Any")
+    const spy = vi.spyOn(console, "info").mockImplementation(() => {})
+    log.info("still works")
+    expect(spy).toHaveBeenCalled()
+    getItem.mockRestore()
+  })
+})

packages/editor/src/lib/__tests__/markdown-parser.test.ts

@@ -825,6 +825,76 @@ describe("horizontal-rule", () => {
   })
 })
 
+describe("error recovery", () => {
+  it("handles empty callout > [!NOTE]", () => {
+    const result = parseMarkdown("> [!NOTE]")
+    expect(result.blocks).toHaveLength(1)
+    expect(result.blocks[0].type).toBe("callout")
+    expect(result.blocks[0].metadata?.calloutType).toBe("NOTE")
+  })
+
+  it("handles callout with unrecognized type as blockquote", () => {
+    const result = parseMarkdown("> [!INVALID] text")
+    expect(result.blocks).toHaveLength(1)
+    expect(result.blocks[0].type).toBe("blockquote")
+  })
+
+  it("handles callout with no space after type", () => {
+    const result = parseMarkdown("> [!NOTE]text")
+    expect(result.blocks).toHaveLength(1)
+    expect(result.blocks[0].type).toBe("callout")
+  })
+
+  it("handles heading with no content", () => {
+    const result = parseMarkdown("# ")
+    expect(result.blocks).toHaveLength(1)
+    expect(result.blocks[0].type).toBe("heading")
+    expect(result.blocks[0].metadata?.level).toBe(1)
+  })
+
+  it("handles task with no content after keyword", () => {
+    const result = parseMarkdown("TODO ")
+    expect(result.blocks).toHaveLength(1)
+    expect(result.blocks[0].type).toBe("task")
+    expect(result.blocks[0].metadata?.taskState).toBe("TODO")
+  })
+
+  it("handles extra closing bold delimiters", () => {
+    const result = parseMarkdown("**bold**text**")
+    expect(result.content).toHaveLength(1)
+    expect(result.content[0].type).toBe("strong")
+  })
+
+  it("handles unclosed link URL", () => {
+    const result = parseMarkdown("[link](url")
+    expect(Array.isArray(result.content)).toBe(true)
+  })
+
+  it("handles triple nested brackets [[[Page]]]", () => {
+    const result = parseMarkdown("[[[Page]]]")
+    expect(result.content).toHaveLength(1)
+    expect(result.content[0].type).toBe("page-ref")
+  })
+
+  it("handles trailing text after blockquote", () => {
+    const result = parseMarkdown("> Quote")
+    expect(result.blocks).toHaveLength(1)
+    expect(result.blocks[0].type).toBe("blockquote")
+  })
+
+  it("handles empty heading marker only", () => {
+    const result = parseMarkdown("#")
+    expect(result.blocks).toHaveLength(1)
+    expect(result.blocks[0].type).toBe("heading")
+  })
+
+  it("handles multiple blockquotes sequentially in same block", () => {
+    const result = parseMarkdown("> Line 1")
+    expect(result.blocks).toHaveLength(1)
+    expect(result.blocks[0].type).toBe("blockquote")
+  })
+})
+
 describe("table", () => {
   it("parses a simple table as block decoration", () => {
     const result = parseMarkdown("| A | B |\n| --- | --- |\n| C | D |")
@@ -891,4 +961,71 @@ describe("table", () => {
     expect(result.blocks[0].type).toBe("heading")
     expect(result.blocks[1].type).toBe("table")
   })
+
+  it("parses table with inline markdown in header cells", () => {
+    const result = parseMarkdown("| `code` | **bold** |\n| --- | --- |\n| a | b |")
+    expect(result.blocks).toHaveLength(1)
+    expect(result.blocks[0].type).toBe("table")
+  })
+
+  it("parses table with pipes inside cell content (escaped)", () => {
+    const result = parseMarkdown("| A \\| B | C |\n| --- | --- |\n| D | E |")
+    expect(result.blocks).toHaveLength(1)
+    expect(result.blocks[0].type).toBe("table")
+  })
+
+  it("handles table with uneven columns as non-table (column count mismatch)", () => {
+    const result = parseMarkdown("| A | B | C |\n| --- | --- |\n| D | E | F |")
+    expect(result.blocks).toHaveLength(0)
+  })
+
+  it("handles table with missing separator row", () => {
+    const result = parseMarkdown("| A | B |\n| C | D |")
+    expect(result.blocks).toHaveLength(0)
+  })
+
+  it("handles table with empty cells", () => {
+    const result = parseMarkdown("| A || B |\n| --- | --- | --- |\n| C | | D |")
+    expect(result.blocks).toHaveLength(1)
+    expect(result.blocks[0].type).toBe("table")
+  })
+
+  it("handles table with inline markdown in cells", () => {
+    const result = parseMarkdown("| **bold** | *italic* |\n| --- | --- |\n| `code` | text |")
+    expect(result.blocks).toHaveLength(1)
+    expect(result.blocks[0].type).toBe("table")
+  })
+})
+
+describe("tokenization depth exhaustion", () => {
+  it("handles deeply nested bold delimiters without crashing", () => {
+    const result = parseMarkdown("******deep******")
+    expect(Array.isArray(result.content)).toBe(true)
+  })
+
+  it("handles 10+ layers of emphasis nesting without crashing", () => {
+    const input = "*".repeat(20) + "text" + "*".repeat(20)
+    const result = parseMarkdown(input)
+    expect(Array.isArray(result.content)).toBe(true)
+  })
+
+  it("handles extreme nested brackets for page refs", () => {
+    const input = "[[" + "[[" + "Page" + "]]" + "]]"
+    const result = parseMarkdown(input)
+    expect(Array.isArray(result.content)).toBe(true)
+  })
+
+  it("handles very long unbroken inline syntax", () => {
+    const input = "**" + "x".repeat(500) + "**"
+    const result = parseMarkdown(input)
+    expect(result.content).toHaveLength(1)
+    expect(result.content[0].type).toBe("strong")
+  })
+
+  it("handles many inline tokens in a single paragraph", () => {
+    const tokens = Array.from({ length: 50 }, (_, i) => `**bold${i}**`)
+    const input = tokens.join(" ")
+    const result = parseMarkdown(input)
+    expect(result.content.length).toBeGreaterThan(0)
+  })
 })