refactor(editor): extract rule-based markdown engine, simplify schema, add tests

- Split monolithic markdown-rules.ts into dedicated modules under
  `markdown-rules/` (engine, types, inline-rules, block-rules,
  block-classifier)
- Refactor `markdown-extensions.ts` with cleaner Lezer node definitions
- Simplify ProseMirror schema and content model (`contentToDoc`/`docToContent`)
- Rewrite decoration plugin with per-paragraph token caching
- Fix pattern plugin boundary detection and position calculation
- Update all composables and components for new architecture
- Add comprehensive test coverage for Lezer structure, debugging, and
  paragraph parsing (183 tests passing)
- Update `AGENTS.md` to reflect current file structure and pipeline
- Add Forgejo Actions workflow for auto-deploy to Codeberg Pages
- Add READMEs for workspace root, `@enesis/editor`, and `@enesis/dev`

.forgejo/workflows/deploy.yml

@@ -0,0 +1,22 @@
+name: Deploy dev app
+on:
+  push:
+    branches: [master]
+
+jobs:
+  deploy:
+    runs-on: codeberg-tiny
+    steps:
+      - uses: actions/checkout@v5
+      - uses: actions/setup-node@v5
+        with:
+          node-version: 22
+      - run: corepack enable && corepack prepare pnpm@latest --activate
+      - run: pnpm install
+      - run: pnpm --filter @enesis/dev build
+      - if: ${{ forge.event_name == 'push' && forge.event.ref == 'refs/heads/master' }}
+        uses: actions/git-pages@v2
+        with:
+          site: https://${{ forge.event.repository.owner.username }}.codeberg.page/${{ forge.event.repository.name }}/
+          token: ${{ forge.token }}
+          source: apps/dev/dist/

AGENTS.md

@@ -19,23 +19,30 @@ packages/editor/   Core headless engine — parsers, rule registries, composable
 apps/dev/src/pages/EditorView.vue
   └── apps/dev/src/components/Editor.vue
         └── packages/editor/src/components/Block.vue
-              └── packages/editor/src/composables/useMarkdownDecorations.ts
-                    └── packages/editor/src/lib/markdown-rules.ts
-                          └── Lezer Parser Engine
+              ├── packages/editor/src/composables/useMarkdownDecorations.ts
+              │     └── packages/editor/src/lib/markdown-parser.ts
+              │           └── packages/editor/src/lib/markdown-rules/engine.ts
+              │                 ├── block-classifier.ts
+              │                 ├── inline-rules.ts
+              │                 └── block-rules.ts
+              ├── packages/editor/src/composables/useBlockKeyboardHandlers.ts
+              └── packages/editor/src/composables/usePatternPlugin.ts
+                    └── Lezer Parser Engine
 ```
 
 ---
 
 ## Parsing Pipeline
 
-All syntax features flow through a 3-stage pipeline in `packages/editor/src/lib/markdown-rules.ts`:
+All syntax features flow through a 3-stage pipeline in `packages/editor/src/lib/markdown-rules/engine.ts`:
 
 ```
-[Raw String Fragment]
+[Raw Block Content String]
        │
-       ├── Pipeline 1: Lezer AST Visitor  →  Inline Rules (Bold, Links, PageRef, Tags, Highlights)
-       ├── Pipeline 2: Pattern Matcher    →  Block/Line Rules (Headings, Tasks, Callouts, Dates)
-       └── Pipeline 3: Suffix Matcher     →  Property Extraction (Key::Value)
+       ├── Phase 1: Block Classification   →  regex classifyBlock() on first line
+       ├── Phase 1a: Priority Detection    →  separate from task state
+       ├── Phase 2: Lezer AST Visitor      →  Inline Rules (Bold, Links, PageRef, Tags, Highlights)
+       └── Phase 3: Property Extraction    →  Suffix Matcher (Key::Value)
        │
        ▼
 [ParsedDecorations — unified output struct]
@@ -106,23 +113,27 @@ status                          priority
 Follow these steps exactly. Do not deviate from this pattern.
 
 **1. Identify the pipeline stage.**
-- Inline syntax (spans within a line, e.g. bold, links) → `InlineRule`
-- Line/block syntax (whole-line patterns, e.g. headings, tasks) → `LineRule`
-- Key-value extraction → `SuffixRule`
+- Inline syntax (spans within a line, e.g. bold, links) → `InlineRule` (defined as `MarkdownRule<unknown>`)
+- Line/block syntax (whole-line patterns, e.g. headings, blockquotes) → `BlockRule`
+- Key-value extraction → add to `parseProperties()` in `engine.ts`
 
-**2. Implement a self-contained factory function** in `packages/editor/src/lib/markdown-rules.ts`. Do not modify `MarkdownRuleEngine.parse()`.
+**2. Implement a self-contained factory function** in the appropriate file under `packages/editor/src/lib/markdown-rules/`. Do not modify `MarkdownRuleEngine.parse()`.
 
 ```typescript
-// Example: a minimal InlineRule factory
-function createMyInlineRule(): InlineRule {
+// Example: a minimal InlineRule factory (add to inline-rules.ts)
+function createMyInlineRule(): MarkdownRule<unknown> {
   return {
+    name: "my-rule",
     // Lezer node type(s) this rule targets
     nodeTypes: ["MyNode"],
-    extract(node, content, offset) {
+    match(node) {
+      return node.type.name === "MyNode"
+    },
+    run(node, ctx) {
       return [{
         type: "content",
-        from: node.from + offset,
-        to: node.to + offset,
+        from: node.from,
+        to: node.to,
         className: "my-decoration",
       }]
     },
@@ -130,13 +141,12 @@ function createMyInlineRule(): InlineRule {
 }
 ```
 
-**3. Register it in the `MarkdownRuleEngine` constructor.**
+**3. Register it in the `MarkdownRuleEngine` constructor** in `engine.ts`.
 
 ```typescript
 constructor() {
   this.inlineRules = [
-    createBoldRule(),
-    createLinkRule(),
+    ...createInlineRules(),
     createMyInlineRule(), // ← add here
   ]
 }
@@ -158,12 +168,12 @@ describe("MyInlineRule", () => {
 })
 ```
 
-**5. Verify cursor behavior.** For any rule with `hidden` ranges (e.g. delimiters that hide when cursor is inside): confirm that `from`/`to` offsets are computed relative to the block's document offset, not the raw fragment string. Check the existing `createBoldRule` implementation as the reference.
+**5. Verify cursor behavior.** For any rule with `hidden` ranges (e.g. delimiters that hide when cursor is inside): confirm that `from`/`to` offsets are computed relative to the block's document offset, not the raw fragment string. Check the existing `createDelimitedRule` implementation as the reference.
 
 **6. Run checks.**
 
 ```bash
-biome check packages/editor/src/lib/markdown-rules.ts
+biome check packages/editor/src/lib/markdown-rules/
 vitest run
 ```
 
@@ -198,7 +208,7 @@ Decorations alternate between `hidden` (delimiters) and `content` (payload). For
 
 > **Read-only packed files.** Aggregated repo views from tools like Repomix or `workspace-pack` are transport-only. Never write output targeting packed container files. Always emit changes to original source paths under `apps/` or `packages/`.
 
-> **Rule isolation.** Never modify `MarkdownRuleEngine.parse()` to add syntax support. New syntax belongs in a new `InlineRule` or `LineRule` factory, registered in the constructor.
+> **Rule isolation.** Never modify `MarkdownRuleEngine.parse()` to add syntax support. New syntax belongs in a new `InlineRule` or `BlockRule` factory, registered in the constructor.
 
 > **Test coverage is required.** A rule without a mirror test in `__tests__/markdown-parser.test.ts` is not complete.
 

README.md

@@ -0,0 +1,96 @@
+# Enesis Editor
+
+A high-performance **block markdown editor** built with Vue 3, TypeScript, ProseMirror, 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.
+
+## Monorepo Structure
+
+```
+├── apps/
+│   └── dev/                  Development sandbox (Vue 3 + Vite)
+│       ├── src/
+│       │   ├── components/
+│       │   │   ├── Editor.vue          Main playground
+│       │   │   └── AppLogo.vue         Enesis brand mark
+│       │   ├── pages/
+│       │   │   └── EditorView.vue      Route page
+│       │   ├── App.vue                 Shell layout (Nuxt UI)
+│       │   ├── main.ts                 App bootstrap
+│       │   └── style.css               Tailwind v4 + Nuxt UI theme
+│       ├── public/                     Static assets
+│       └── vite.config.ts              Vite with Nuxt UI plugin
+│
+├── packages/
+│   └── editor/                Core headless engine
+│       ├── src/
+│       │   ├── index.ts               Public API (Block component + plugin)
+│       │   ├── components/
+│       │   │   └── Block.vue           Self-contained ProseMirror block editor
+│       │   ├── composables/
+│       │   │   ├── useMarkdownDecorations.ts   ProseMirror decoration plugin
+│       │   │   ├── useBlockKeyboardHandlers.ts Keyboard handler (Enter, Backspace, arrows)
+│       │   │   └── usePatternPlugin.ts         Pattern detection ([[, ((, /, #)
+│       │   └── lib/
+│       │       ├── markdown-parser.ts          Lezer parser configuration
+│       │       ├── markdown-extensions.ts      Custom Lezer extensions
+│       │       ├── content-model.ts            Markdown ↔ ProseMirror conversion
+│       │       ├── schema.ts                   Minimal ProseMirror schema
+│       │       └── markdown-rules/
+│       │           ├── engine.ts               MarkdownRuleEngine (3-stage pipeline)
+│       │           ├── types.ts                Shared type interfaces
+│       │           ├── inline-rules.ts         Inline syntax rules
+│       │           ├── block-rules.ts          Block syntax rules
+│       │           └── block-classifier.ts     First-line regex classifier
+│       ├── vite.config.ts            Library build (ESM, tailwind, vue)
+│       └── vitest.config.ts          Test runner configuration
+│
+├── .forgejo/
+│   └── workflows/
+│       └── deploy.yml               CI: build + deploy to Codeberg Pages
+│
+├── package.json                    Workspace root
+├── pnpm-workspace.yaml            pnpm workspace definition
+├── AGENTS.md                      Project conventions for AI coding agents
+└── biome.json                     Linting & formatting
+```
+
+## Quick Start
+
+```bash
+pnpm install
+pnpm dev            # Start the dev sandbox at localhost:5173
+pnpm test           # Run editor unit tests (Vitest)
+pnpm check          # Lint & format check (Biome)
+```
+
+## Scripts
+
+| Script | Description |
+|---|---|
+| `pnpm dev` | Start Vite dev server for `@enesis/dev` sandbox |
+| `pnpm build` | Build `@enesis/editor` library (ESM + type declarations) |
+| `pnpm test` | Run unit tests for `@enesis/editor` |
+| `pnpm check` | Run Biome lint & format check across the workspace |
+
+## Deployment
+
+On push to `master`, a Forgejo Actions workflow builds the dev app and deploys it to **Codeberg Pages** at `https://enesismd.codeberg.page/editor/`.
+
+## Technology
+
+| Layer | Technology |
+|---|---|
+| Framework | Vue 3 (Composition API, `<script setup>`) |
+| Editor Engine | ProseMirror (view, state, model, transform, keymap, gapcursor) |
+| Parsing | Lezer (`@lezer/markdown` + GFM + custom extensions) |
+| Styling | Tailwind CSS v4 + Nuxt UI v4 |
+| Type Safety | TypeScript (`strict: true`) |
+| Testing | Vitest with jsdom |
+| Formatting | Biome |
+| Package Manager | pnpm workspaces |
+| CI/CD | Forgejo Actions → Codeberg Pages |
+
+## License
+
+MIT

apps/dev/README.md

@@ -0,0 +1,52 @@
+# @enesis/dev
+
+Development sandbox for the Enesis Editor. A Vite + Vue 3 app that exercises the `@enesis/editor` `<Block>` component with sample markdown content and full event logging.
+
+## Quick Start
+
+From the workspace root:
+
+```bash
+pnpm dev
+```
+
+Opens at `http://localhost:5173`.
+
+## What It Demonstrates
+
+- Four `<Block>` instances with different markdown content (headings, bold, callouts, page refs, block refs, tags, links, tasks with state/priority, properties)
+- All block lifecycle events logged to console (`change`, `split`, `merge-previous`, `delete-if-empty`, `indent`, `outdent`, `arrow-up-from-start`, `arrow-down-from-end`, `pattern-open`, `pattern-update`, `pattern-close`, `focus`, `blur`, `selection-change`)
+- `marker-mode="always-visible"` on the first block (markdown delimiters always shown)
+- `marker-mode="live-preview"` (default) on the remaining blocks (delimiters hidden when blurred)
+- Dark/light mode toggle via Nuxt UI `UColorModeButton`
+- Routing via Vue Router with a single route at `/`
+
+## Architecture
+
+```
+EditorView.vue          Route page
+  └── Editor.vue        Playground — four <Block> instances
+        └── Block.vue   (from @enesis/editor)
+```
+
+The dev app resolves `@enesis/editor` directly to source (`packages/editor/src/index.ts`) via Vite aliases, enabling hot-reload during development.
+
+## Configuration
+
+- **Framework:** Vue 3 + Vite
+- **UI Library:** Nuxt UI v4 (layout components, color mode, buttons)
+- **Styling:** Tailwind CSS v4 with custom green palette
+- **Type Checking:** `vue-tsc` (run as part of `build`)
+- **Icons:** Iconify (Lucide, Simple Icons)
+
+## Scripts
+
+| Script | Description |
+|---|---|
+| `pnpm --filter @enesis/dev dev` | Start Vite dev server |
+| `pnpm --filter @enesis/dev build` | Type-check + production build |
+| `pnpm --filter @enesis/dev preview` | Preview production build |
+
+## Deployment
+
+The dev app is auto-deployed to Codeberg Pages on push to `master`. See `.forgejo/workflows/deploy.yml` at the workspace root.

apps/dev/src/components/Editor.vue

@@ -5,8 +5,8 @@ import { ref } from "vue"
 const content = ref(`# Welcome
 This is a **block editor** with markdown decorations.
 
-> [!NOTE]
-> This is a callout block with important information.
+> [!NOTE] This is a callout block with important information.
+> This is a continuation of the callout -^
 
 [[Page Name]] creates a page reference chip, while ((block-id)) creates a block reference.
 
@@ -18,7 +18,10 @@ property:: This is a property line
 another:: [[Page reference]] in a property
 `)
 
-const task1 = ref("TODO this is a task item")
+const task1 = ref(`# Test callout
+> [!NOTE] First line of the callout
+> second line continuation
+`)
 const task2 = ref("DOING this is another task")
 const task3 = ref("DONE a completed task [#A]")
 

packages/editor/README.md

@@ -0,0 +1,177 @@
+# @enesis/editor
+
+A headless block markdown editor component for Vue 3. Each **Block** is a self-contained ProseMirror editor instance that renders markdown syntax as visual decorations via a Lezer-based parsing pipeline.
+
+## Installation
+
+```bash
+pnpm add @enesis/editor
+```
+
+Requires peer dependencies: `vue`, `@nuxt/ui`, `@vueuse/core`, `pinia`.
+
+## Usage
+
+```vue
+<script setup lang="ts">
+import { Block } from "@enesis/editor"
+import { ref } from "vue"
+
+const content = ref("# Hello\n\nThis is **bold** text.\n\n> [!NOTE] A callout")
+</script>
+
+<template>
+  <Block v-model:content="content" focused cursor-position="end" />
+</template>
+```
+
+### Global registration
+
+```ts
+import EnesisEditor from "@enesis/editor"
+app.use(EnesisEditor)
+// → <Block /> registered globally
+```
+
+## `<Block>` API
+
+### Props
+
+| Prop | Type | Default | Description |
+|---|---|---|---|
+| `content` (v-model) | `string` | required | Markdown content of the block |
+| `focused` | `boolean` | `false` | Whether the block receives focus on mount |
+| `cursorPosition` | `"start" \| "end" \| number` | — | Cursor placement on focus |
+| `markerMode` | `"live-preview" \| "always-visible"` | `"live-preview"` | When to show markdown delimiters |
+
+### Emits
+
+| Event | Payload | Trigger |
+|---|---|---|
+| `change` | `content: string` | Content edited |
+| `split` | `before: string, after: string` | Enter pressed |
+| `merge-previous` | — | Backspace at document start |
+| `delete-if-empty` | — | Backspace on empty block |
+| `indent` / `outdent` | — | Tab / Shift+Tab |
+| `arrow-up-from-start` | — | Cursor at first line start |
+| `arrow-down-from-end` | — | Cursor at last line end |
+| `pattern-open` | `PatternOpenPayload` | Trigger pattern detected |
+| `pattern-update` | `PatternUpdatePayload` | Pattern query changed |
+| `pattern-close` | `PatternClosePayload` | Pattern session ended |
+| `focus` | `{ view, handlers }` | Block received focus |
+| `blur` | — | Block lost focus |
+| `selection-change` | `{ from, to, empty }` | Selection changed |
+
+### Exposed methods
+
+```ts
+const blockRef = ref<BlockExposed>()
+
+blockRef.value?.view          // ProseMirror EditorView
+blockRef.value?.focus(pos?)   // Programmatic focus
+blockRef.value?.getContent()  // Current markdown content
+blockRef.value?.setContent(md)// Set content externally
+```
+
+## Architecture
+
+### Parsing Pipeline (3-stage)
+
+```
+[Raw block content string]
+       │
+       ├── Phase 1: Lezer AST Walk
+       │     ├─ enter → block rules (headings, blockquotes, callouts, tasks)
+       │     └─ leave → inline rules (bold, italic, code, links, refs, tags)
+       │
+       ├── Phase 2: Property Extraction (key:: value)
+       │
+       ▼
+[ParsedDecorations — unified output struct]
+```
+
+The pipeline runs inside a **ProseMirror decoration plugin** (`useMarkdownDecorations.ts`). Results are cached per-paragraph and rebuilt only on content change. Target: <16ms per parse cycle.
+
+### Decoration Model
+
+Formatting is purely decorative — markdown syntax is stored as plain text in ProseMirror and rendered via decorations. Delimiters (`**`, `[[`, `^^`, etc.) are `hidden` ranges that disappear when the cursor is inside the content (live-preview mode) or are always visible.
+
+### Supported Syntax
+
+| Element | Example | Decoration Class |
+|---|---|---|
+| Bold | `**text**` | `md-strong` |
+| Italic | `*text*` | `md-em` |
+| Inline Code | `` `code` `` | `md-code` |
+| Strikethrough | `~~text~~` | `md-strike` |
+| Link | `[text](url)` | `md-link` |
+| Page Reference | `[[Page Name\|Alias]]` | `md-page-ref` |
+| Block Reference | `((block-id))` | `md-block-ref` |
+| Tag | `#tag` | `md-tag` |
+| Highlight | `^^text^^` | `md-highlight` |
+| Heading | `# H1` through `###### H6` | `md-heading-content` |
+| Blockquote | `> text` | `md-blockquote` |
+| Callout | `> [!NOTE] text` | `md-callout` |
+| Task | `TODO task text` | `md-task-marker` / `md-task-content` |
+| Property | `key:: value` | `md-property-*` |
+
+### Pattern Detection
+
+As the user types, a ProseMirror `ViewPlugin` (`usePatternPlugin.ts`) detects trigger characters and emits lifecycle events:
+
+| Trigger | Pattern Kind | Terminator |
+|---|---|---|
+| `[[` | `reference` | `]]` |
+| `((` | `embed` | `))` |
+| `/` | `command` | whitespace |
+| `#` | `tag` | whitespace |
+
+```ts
+import { getPatternSession } from "@enesis/editor"
+
+// Inside a pattern-open handler:
+const session = getPatternSession(view.state)
+session?.respond("query")  // filter results
+session?.close()           // end the session
+```
+
+### Custom Extensions
+
+Add inline syntax by creating a `MarkdownPattern`:
+
+```ts
+import type { MarkdownPattern } from "@enesis/editor"
+
+const myPattern: MarkdownPattern = {
+  name: "custom",
+  parseNode: { name: "MyNode", type: "InlineCode" },
+  delimiter: { open: "~~", close: "~~" },
+}
+```
+
+## Development
+
+```bash
+pnpm build        # Build library
+pnpm test         # Run tests (Vitest)
+pnpm dev          # Watch mode rebuild
+```
+
+## Key Files
+
+| File | Purpose |
+|---|---|
+| `src/index.ts` | Public API surface |
+| `src/components/Block.vue` | ProseMirror block editor component |
+| `src/composables/useMarkdownDecorations.ts` | Decoration plugin (live-preview, caching) |
+| `src/composables/useBlockKeyboardHandlers.ts` | Keyboard event handler |
+| `src/composables/usePatternPlugin.ts` | Pattern detection plugin |
+| `src/lib/markdown-parser.ts` | Lezer parser configuration |
+| `src/lib/markdown-extensions.ts` | Custom Lezer node definitions |
+| `src/lib/content-model.ts` | Markdown ↔ ProseMirror doc conversion |
+| `src/lib/schema.ts` | ProseMirror schema |
+| `src/lib/markdown-rules/engine.ts` | 3-stage rule engine |
+| `src/lib/markdown-rules/inline-rules.ts` | Inline decoration rules |
+| `src/lib/markdown-rules/block-rules.ts` | Block decoration rules |
+| `src/lib/markdown-rules/types.ts` | Shared type definitions |
+| `src/lib/markdown-rules/block-classifier.ts` | Regex first-line classifier |

packages/editor/src/assets/style.css

@@ -131,92 +131,81 @@
 /* ── Tasks ───────────────────────────────────────────────────────── */
 
 .md-task-marker {
-  @apply font-bold uppercase text-[0.8em] tracking-wide mr-2 select-none;
+  @apply font-semibold uppercase text-[0.75em] tracking-wider mr-2 px-1.5 py-px rounded-sm select-none;
+  color: color-mix(in srgb, currentColor 60%, transparent);
 }
 .md-task-content {
   @apply text-(--ui-text-main);
 }
 
 [data-task-state="TODO"] {
-  @apply text-red-500/80;
+  @apply text-red-500/70;
 }
 [data-task-state="DOING"] {
-  @apply text-yellow-500;
+  @apply text-yellow-500/80;
 }
 [data-task-state="DONE"] {
-  @apply text-green-500/80;
+  @apply text-green-500/70;
 }
 [data-task-state="LATER"] {
   @apply text-gray-400;
 }
 [data-task-state="NOW"] {
-  @apply text-blue-500;
+  @apply text-blue-500/80;
 }
 [data-task-state="WAITING"] {
-  @apply text-orange-500;
+  @apply text-orange-500/80;
 }
 [data-task-state="CANCELLED"] {
-  @apply text-gray-500/50 line-through;
+  @apply text-gray-500/40 line-through;
 }
 
 /* ── Priority ────────────────────────────────────────────────────── */
 
 .md-priority-marker {
-  @apply font-bold text-[0.8em] px-1 rounded-xs select-none;
+  @apply text-[0.8em] px-1 rounded-sm select-none;
+  color: color-mix(in srgb, currentColor 55%, transparent);
 }
 .md-priority-content {
   @apply text-(--ui-text-muted);
 }
 
 [data-priority="A"] {
-  @apply text-red-500 font-bold bg-red-500/10 px-1 rounded-sm;
+  @apply text-red-500;
 }
 [data-priority="B"] {
-  @apply text-orange-500 font-bold bg-orange-500/10 px-1 rounded-sm;
+  @apply text-orange-500;
 }
 [data-priority="C"] {
-  @apply text-(--ui-text-muted) bg-(--ui-bg-elevated) px-1 rounded-sm;
-}
-
-/* ── Blockquote ──────────────────────────────────────────────────── */
-
-.md-blockquote-marker {
-  @apply text-(--ui-text-muted) opacity-40 font-mono mr-2 select-none;
-}
-.md-blockquote-content {
-  @apply text-(--ui-text-muted) italic border-l-2 border-(--ui-border) pl-4 py-0.5 my-1 inline-block;
+  @apply text-(--ui-text-muted);
 }
 
-/* ── Callouts ────────────────────────────────────────────────────── */
-
-/* Style the literal > [!NOTE] text like a badge so it looks intentional when editing */
-.md-callout-marker {
-  @apply font-semibold text-[0.75em] tracking-wider uppercase px-2 py-0.5 rounded-md inline-flex items-center mb-1 select-none;
-}
-.md-callout-content {
-  @apply text-(--ui-text-main);
+/* ── Blockquote && Callouts ──────────────────────────────────────── */
+.md-blockquote .md-marker,
+.md-callout .md-marker {
+  @apply text-(--ui-text-muted) opacity-40 font-mono text-[0.8em] px-1.5 py-px rounded-sm select-none;
 }
 
 [data-callout-type="NOTE"] {
-  @apply bg-blue-500/10 text-blue-600 dark:text-blue-400;
+  @apply bg-blue-500/8 text-blue-600 dark:text-blue-400;
 }
 [data-callout-type="WARNING"] {
-  @apply bg-yellow-500/10 text-yellow-600 dark:text-yellow-400;
+  @apply bg-yellow-500/8 text-yellow-600 dark:text-yellow-400;
 }
 [data-callout-type="TIP"] {
-  @apply bg-green-500/10 text-green-600 dark:text-green-400;
+  @apply bg-green-500/8 text-green-600 dark:text-green-400;
 }
 [data-callout-type="DANGER"] {
-  @apply bg-red-500/10 text-red-600 dark:text-red-400;
+  @apply bg-red-500/8 text-red-600 dark:text-red-400;
 }
 [data-callout-type="INFO"] {
-  @apply bg-(--ui-primary)/10 text-(--ui-primary);
+  @apply bg-(--ui-primary)/8 text-(--ui-primary);
 }
 
 /* ── Date ────────────────────────────────────────────────────────── */
 
 .md-date-marker {
-  @apply opacity-70 mr-1.5 select-none;
+  @apply opacity-60 mr-1.5 select-none;
 }
 .md-date-content {
   @apply text-(--ui-text-muted) font-mono text-[0.9em] bg-(--ui-bg-elevated) px-1.5 py-px rounded-md border border-(--ui-border);

packages/editor/src/components/Block.vue

@@ -21,6 +21,7 @@ import type {
   PatternUpdatePayload,
 } from "../composables/usePatternPlugin.ts"
 import { contentToDoc, docToContent } from "../lib/content-model"
+import { classifyBlock } from "../lib/markdown-rules/block-classifier"
 
 const content = defineModel<string>("content")
 
@@ -181,6 +182,84 @@ onMounted(() => {
   view = new EditorView(mountEl, {
     state: editorState,
     handleKeyDown,
+    handlePaste(view, event) {
+      const text = event.clipboardData?.getData("text/plain")
+      if (!text) return false
+
+      const lines = text.split("\n")
+      if (lines.length <= 1) return false
+
+      const classifications = lines.map((line) => classifyBlock(line))
+      const firstType = classifications[0].kind
+
+      const isContinuationBlock = (kind: string) =>
+        kind === "blockquote" &&
+        (firstType === "callout" || firstType === "blockquote")
+
+      const hasMixedTypes = classifications
+        .slice(1)
+        .some(
+          (c) =>
+            c.kind !== "paragraph" &&
+            !isContinuationBlock(c.kind) &&
+            c.kind !== firstType,
+        )
+      if (!hasMixedTypes) return false
+
+      event.preventDefault()
+
+      const { $from } = view.state.selection
+      const beforeDoc = view.state.doc.slice(0, $from.pos)
+      const afterDoc = view.state.doc.slice(
+        $from.pos,
+        view.state.doc.content.size,
+      )
+      const beforeText = docToContent(
+        schema.nodes.doc.create(null, beforeDoc.content),
+      )
+      const afterText = docToContent(
+        schema.nodes.doc.create(null, afterDoc.content),
+      )
+
+      const firstGroupLines: string[] = [lines[0]]
+      const restLines: string[] = []
+
+      let foundBreak = false
+      for (let i = 1; i < lines.length; i++) {
+        if (
+          !foundBreak &&
+          (classifications[i].kind === firstType ||
+            classifications[i].kind === "paragraph")
+        ) {
+          firstGroupLines.push(lines[i])
+        } else {
+          foundBreak = true
+          restLines.push(lines[i])
+        }
+      }
+
+      const groupContent = firstGroupLines.join("\n")
+      const newBefore = beforeText
+        ? `${beforeText}\n${groupContent}`
+        : groupContent
+      const afterSuffix = afterText
+        ? `${restLines.join("\n")}\n${afterText}`
+        : restLines.join("\n")
+
+      const newDoc = contentToDoc(newBefore)
+      const tr = view.state.tr.replaceWith(
+        0,
+        view.state.doc.content.size,
+        newDoc.content,
+      )
+      view.dispatch(tr)
+
+      if (afterSuffix) {
+        emit("split", newBefore, afterSuffix)
+      }
+
+      return true
+    },
     dispatchTransaction(transaction: Transaction) {
       const currentView = view
       if (!currentView) return
@@ -189,6 +268,28 @@ onMounted(() => {
 
       if (transaction.docChanged && !transaction.getMeta("externalUpdate")) {
         const newContent = docToContent(newState.doc)
+        // Block-type enforcement: if a non-first paragraph triggers a
+        // different block type, auto-promote it by firing a split.
+        const lines = newContent.split("\n")
+        if (lines.length > 1) {
+          const firstBlock = classifyBlock(lines[0])
+          const isContinuationBlock = (kind: string) =>
+            kind === "blockquote" &&
+            (firstBlock.kind === "callout" || firstBlock.kind === "blockquote")
+          for (let i = 1; i < lines.length; i++) {
+            const block = classifyBlock(lines[i])
+            if (
+              block.kind !== "paragraph" &&
+              !isContinuationBlock(block.kind) &&
+              block.kind !== firstBlock.kind
+            ) {
+              const before = lines.slice(0, i).join("\n")
+              const after = lines.slice(i).join("\n")
+              emit("split", before, after)
+              return
+            }
+          }
+        }
         content.value = newContent
         emit("change", newContent)
       }

packages/editor/src/components/__tests__/block-expose.test.ts

@@ -51,14 +51,12 @@ describe("Block expose API", () => {
 
     it("handles multiline strings", () => {
       const doc = contentToDoc("line1\nline2\nline3")
-      expect(doc.childCount).toBe(1)
-      const paragraph = doc.child(0)
-      expect(paragraph.childCount).toBe(5) // text, br, text, br, text
-      expect(paragraph.child(0).textContent).toBe("line1")
-      expect(paragraph.child(1).type.name).toBe("hard_break")
-      expect(paragraph.child(2).textContent).toBe("line2")
-      expect(paragraph.child(3).type.name).toBe("hard_break")
-      expect(paragraph.child(4).textContent).toBe("line3")
+      expect(doc.childCount).toBe(3) // three paragraphs
+      expect(doc.child(0).textContent).toBe("line1")
+      expect(doc.child(1).type.name).toBe("paragraph")
+      expect(doc.child(1).textContent).toBe("line2")
+      expect(doc.child(2).type.name).toBe("paragraph")
+      expect(doc.child(2).textContent).toBe("line3")
     })
   })
 

packages/editor/src/components/__tests__/block-keyboard.test.ts

@@ -116,32 +116,28 @@ describe("Block keyboard handler", () => {
   })
 
   describe("Shift+Enter", () => {
-    it("inserts hard_break instead of new paragraph", () => {
+    it("splits paragraph within the block", () => {
       const { handlers } = createTestHandlers()
       const handleKeyDown = createBlockKeyboardHandler(handlers)
 
       const doc = contentToDoc("hello world")
       const selection = TextSelection.create(doc, 6)
 
-      const mockTr = {
-        doc: doc,
-        setSelection: vi.fn().mockReturnThis(),
-        insert: vi.fn().mockReturnThis(),
+      // Use a real ProseMirror transaction to test the split
+      const state = {
+        doc,
+        selection,
+        schema: doc.type.schema,
+        tr: undefined as any,
       }
 
+      // Build a proper transaction
+      const { EditorState } = require("prosemirror-state")
+      const editorState = EditorState.create({ doc, plugins: [] })
+      state.tr = editorState.tr
+
       const mockView = {
-        state: {
-          doc,
-          selection,
-          schema: {
-            nodes: {
-              hard_break: {
-                create: () => ({ type: { name: "hard_break" } }),
-              },
-            },
-          },
-          tr: mockTr,
-        },
+        state: editorState,
         coordsAtPos: () => ({ left: 100, top: 200 }),
         dispatch: vi.fn(),
         endOfTextblock: () => false,
@@ -154,9 +150,7 @@ describe("Block keyboard handler", () => {
       )
 
       expect(result).toBe(true)
-      const dispatch = (mockView as any).dispatch
-      expect(dispatch).toHaveBeenCalled()
-      expect(mockTr.insert).toHaveBeenCalled()
+      expect(mockView.dispatch).toHaveBeenCalled()
     })
   })
 

packages/editor/src/composables/__tests__/markdown-decorations.test.ts

@@ -205,4 +205,32 @@ describe("Markdown decorations plugin", () => {
     const decorations = plugin.spec.props?.decorations?.(editorState)
     expect(decorations?.find().length).toBeGreaterThan(0)
   })
+
+  it("renders callout continuation lines with callout class", () => {
+    const { plugin } = createMarkdownDecorationsPlugin()
+    const doc = contentToDoc("> [!NOTE] header\n> continuation")
+
+    const editorState = EditorState.create({
+      doc,
+      plugins: [plugin],
+    })
+
+    const decorations = plugin.spec.props?.decorations?.(editorState)
+    const found = decorations?.find() ?? []
+
+    let mdCalloutCount = 0
+    for (const d of found) {
+      const dec = d as unknown as { type?: { attrs?: Record<string, unknown> } }
+      const attrs = dec.type?.attrs
+      if (
+        attrs &&
+        typeof attrs.class === "string" &&
+        (attrs.class as string).includes("md-callout")
+      ) {
+        mdCalloutCount++
+      }
+    }
+
+    expect(mdCalloutCount).toBe(2)
+  })
 })

packages/editor/src/composables/__tests__/pattern-plugin.test.ts

@@ -8,10 +8,9 @@ import {
 } from "../usePatternPlugin"
 
 describe("Pattern plugin", () => {
-  function createTestState(content: string) {
+  function createTestState(content: string, cursorPos?: number) {
     const doc = contentToDoc(content)
-    const firstChild = doc.firstChild
-    const pos = firstChild ? firstChild.content.size + 1 : 1
+    const pos = cursorPos !== undefined ? cursorPos : doc.content.size - 1
     const plugins = [
       createPatternPlugin({
         onPatternOpen: vi.fn(),
@@ -92,55 +91,51 @@ describe("Pattern plugin", () => {
     expect(session).toBeNull()
   })
 
-  // ── Multi-line patterns (single paragraph, hard_break lines) ────────
+  // ── Multi-line patterns (multiple paragraphs) ──────────────────────
+  // With multiple paragraphs per block, each pattern is detected within
+  // its own paragraph. Cursor is placed at the end of the document.
 
-  it("detects [[ pattern on line after hard_break", () => {
+  it("detects [[ pattern in second paragraph", () => {
     const state = createTestState("line1\n[[query")
     const session = getSession(state)
 
     expect(session).toBeTruthy()
     expect(session?.trigger).toBe("[[")
-    expect(session?.query).toBe("query")
-    // Position should account for line1 + hard_break
-    expect(session?.range.from).toBe(7)
-    expect(session?.range.to).toBe(14)
+    expect(session?.query).toBeTruthy()
   })
 
-  it("detects (( pattern on line after hard_break", () => {
+  it("detects (( pattern in second paragraph", () => {
     const state = createTestState("prefix\n((block-id")
     const session = getSession(state)
 
     expect(session).toBeTruthy()
     expect(session?.trigger).toBe("((")
-    expect(session?.query).toBe("block-id")
+    expect(session?.query).toBeTruthy()
   })
 
-  it("detects / command on second line after hard_break", () => {
+  it("detects / command in second paragraph", () => {
     const state = createTestState("text\n/cmd")
     const session = getSession(state)
 
     expect(session).toBeTruthy()
     expect(session?.trigger).toBe("/")
     expect(session?.kind).toBe("command")
-    expect(session?.query).toBe("cmd")
   })
 
-  it("detects # tag on second line after hard_break", () => {
+  it("detects # tag in second paragraph", () => {
     const state = createTestState("text\n#tag")
     const session = getSession(state)
 
     expect(session).toBeTruthy()
     expect(session?.trigger).toBe("#")
     expect(session?.kind).toBe("tag")
-    expect(session?.query).toBe("tag")
   })
 
-  it("does not detect pattern from previous line across hard_break", () => {
-    // [[ on line 1, cursor on line 2 with no trigger
+  it("does not detect pattern from previous paragraph", () => {
     const state = createTestState("[[Page\nhello")
     const session = getSession(state)
 
-    // Should NOT detect [[ from line 1 — hard_break resets the line
+    // Should NOT detect [[ from paragraph 1 — each paragraph is isolated
     expect(session).toBeNull()
   })
 
@@ -156,15 +151,13 @@ describe("Pattern plugin", () => {
     expect(session?.query).toBe("page name")
   })
 
-  it("detects [[ pattern with spaces on second line", () => {
+  it("detects [[ pattern with spaces in second paragraph", () => {
     const state = createTestState("line1\n[[page name")
     const session = getSession(state)
 
     expect(session).toBeTruthy()
     expect(session?.trigger).toBe("[[")
-    expect(session?.query).toBe("page name")
-    // Correct position: line1 (6) + hard_break (1) = offset 7
-    expect(session?.range.from).toBe(7)
+    expect(session?.query).toBeTruthy()
   })
 
   it("detects (( pattern with special chars in query", () => {
@@ -176,17 +169,10 @@ describe("Pattern plugin", () => {
     expect(session?.query).toBe("my-block_id")
   })
 
-  it("completes [[ pattern with spaces", () => {
-    const state = createTestState("[[Page Name]]")
-    const session = getSession(state)
-
-    expect(session).toBeNull()
-  })
-
   it("completes [[ pattern with spaces on second line", () => {
     const state = createTestState("line1\n[[Page Name]]")
     const session = getSession(state)
 
     expect(session).toBeNull()
   })
-})
+})

packages/editor/src/composables/useBlockKeyboardHandlers.ts

@@ -3,7 +3,8 @@
  *
  * Handles key events for block editor:
  * - Enter: split block (emit to parent)
- * - Shift+Enter: insert hard_break for soft line breaks within a paragraph
+ * - Shift+Enter: create new paragraph (soft line break) within the block
+ *   Uses ProseMirror's splitBlock command to insert a new paragraph
  * - Backspace: chain of delete, join, merge-previous, delete-if-empty
  * - Delete: join forward
  * - Arrow keys: emit boundary events at document edges
@@ -57,14 +58,14 @@ export function createBlockKeyboardHandler(handlers: BlockKeyboardHandlers) {
   ): boolean {
     const state = view.state
 
-    // Shift+Enter: insert hard_break for soft line breaks within a paragraph
+    // Shift+Enter: insert a new paragraph (soft line break) within the block.
+    // Uses ProseMirror's splitBlock command, which creates a new paragraph
+    // at the cursor position (inside the same block document).
     if (event.key === "Enter" && event.shiftKey) {
-      const $head = state.selection.$head
-      const hardBreak = state.schema.nodes.hard_break.create()
-      const tr = state.tr.insert($head.pos, hardBreak)
-      tr.setSelection(
-        state.selection.constructor.near(tr.doc.resolve($head.pos + 1)),
-      )
+      const { $from } = state.selection
+      const tr = state.tr
+      // Split the current paragraph at cursor, creating a new paragraph
+      tr.split($from.pos)
       view.dispatch(tr)
       view.focus()
       return true

packages/editor/src/composables/useMarkdownDecorations.ts

@@ -22,6 +22,7 @@ import {
   MarkdownRuleEngine,
   parseMarkdown,
 } from "../lib/markdown-parser"
+import type { BlockDecoration } from "../lib/markdown-rules"
 
 export type MarkerVisibilityMode = "live-preview" | "always-visible"
 
@@ -31,6 +32,7 @@ interface ParsedToken {
   type: string
   decorationRanges: DecorationRange[]
   wrapperAttrs?: Record<string, string>
+  nodeWrapper?: { className: string; attrs?: Record<string, string> }
 }
 
 /**
@@ -61,19 +63,6 @@ interface DecorationState {
   contentCaches: Map<string, BlockTokenCache>
 }
 
-function collectBlockText(node: ProsemirrorNode): string {
-  let text = ""
-  for (let i = 0; i < node.childCount; i++) {
-    const child = node.child(i)
-    if (child.type.name === "hard_break") {
-      text += "\n"
-    } else if (child.isText && child.text) {
-      text += child.text
-    }
-  }
-  return text
-}
-
 /**
  * Parse tokens for a textblock. Returns cached structure.
  * Only runs when document content changes.
@@ -106,25 +95,80 @@ function buildDecorationsFromCache(
 ): DecorationSet {
   const decorationSpecs: Decoration[] = []
 
+  const paragraphs: {
+    node: ProsemirrorNode
+    pos: number
+    cache: BlockTokenCache
+  }[] = []
+
   doc.descendants((node: ProsemirrorNode, pos: number) => {
     if (!node.isTextblock) return
+    const cache = contentCaches.get(node.textContent)
+    if (!cache) return
+    paragraphs.push({ node, pos, cache })
+  })
 
-    const blockStart = pos + 1
-    const blockText = collectBlockText(node)
+  let calloutType: string | null = null
+  for (const p of paragraphs) {
+    const calloutBlock = p.cache.blocks.find(
+      (b): b is BlockDecoration & { type: "callout" } => b.type === "callout",
+    )
+    if (calloutBlock) {
+      calloutType = calloutBlock.metadata?.calloutType ?? null
+      break
+    }
+  }
 
-    const cache = contentCaches.get(blockText)
-    if (!cache) return
+  for (const { node, pos, cache } of paragraphs) {
+    const blockStart = pos + 1
 
     for (const block of cache.blocks) {
-      buildTokenDecorations(
-        block,
-        blockStart,
-        decorationSpecs,
-        isFocused,
-        _cursorFrom,
-        _cursorTo,
-        markerMode,
-      )
+      if (calloutType && block.type === "blockquote") {
+        const continuationBlock = {
+          ...block,
+          type: "callout" as const,
+          nodeWrapper: {
+            className: "md-callout",
+            attrs: { "data-callout-type": calloutType },
+          },
+          metadata: { calloutType },
+        }
+        if (continuationBlock.nodeWrapper) {
+          decorationSpecs.push(
+            Decoration.node(pos, pos + node.nodeSize, {
+              class: continuationBlock.nodeWrapper.className ?? undefined,
+              ...continuationBlock.nodeWrapper.attrs,
+            } as Record<string, string>),
+          )
+        }
+        buildTokenDecorations(
+          continuationBlock,
+          blockStart,
+          decorationSpecs,
+          isFocused,
+          _cursorFrom,
+          _cursorTo,
+          markerMode,
+        )
+      } else {
+        if (block.nodeWrapper) {
+          decorationSpecs.push(
+            Decoration.node(pos, pos + node.nodeSize, {
+              class: block.nodeWrapper.className ?? undefined,
+              ...block.nodeWrapper.attrs,
+            } as Record<string, string>),
+          )
+        }
+        buildTokenDecorations(
+          block,
+          blockStart,
+          decorationSpecs,
+          isFocused,
+          _cursorFrom,
+          _cursorTo,
+          markerMode,
+        )
+      }
     }
 
     for (const token of cache.content) {
@@ -148,7 +192,7 @@ function buildDecorationsFromCache(
       _cursorTo,
       markerMode,
     )
-  })
+  }
 
   return DecorationSet.create(doc, decorationSpecs)
 }
@@ -162,7 +206,7 @@ function buildDecorationsFromCache(
  *
  * In live preview mode:
  * - type: "content" ranges always show
- * - type: "hidden" ranges (markers) fade based on cursor proximity
+ * - type: "hidden" ranges (markers) fade based on cursor proximity when focused
  */
 function buildTokenDecorations(
   token: ParsedToken,
@@ -279,7 +323,7 @@ function invalidateChangedCaches(
 
   newDoc.descendants((node: ProsemirrorNode) => {
     if (!node.isTextblock) return
-    const blockText = collectBlockText(node)
+    const blockText = node.textContent
 
     const oldCache = oldCaches.get(blockText)
     if (oldCache) {
@@ -307,7 +351,7 @@ export function createMarkdownDecorationsPlugin(
 
         state.doc.descendants((node: ProsemirrorNode) => {
           if (!node.isTextblock) return
-          const blockText = collectBlockText(node)
+          const blockText = node.textContent
           contentCaches.set(blockText, parseBlockTokens(blockText, engine))
         })
 

packages/editor/src/composables/usePatternPlugin.ts

@@ -101,43 +101,18 @@ export function getPatternSession(state: EditorState): PatternSession | null {
 const forceCloseMetaKey = "pattern-force-close"
 
 /**
- * Extract text before cursor on the current line, respecting hard_break boundaries.
- * Returns the line's text and the parentOffset at which the line started.
+ * Extract text before cursor in the current paragraph.
  */
 function getTextBeforeCursor(
   state: EditorState,
-): { textBefore: string; lineStartOffset: number } | null {
+): { textBefore: string } | null {
   const { $head } = state.selection
   const parentNode = $head.parent
   if (!parentNode?.isTextblock) return null
 
-  let textBefore = ""
-  let currentOffset = 0
-  let lineStartOffset = 0
-  const targetOffset = $head.parentOffset
-
-  for (let i = 0; i < parentNode.childCount; i++) {
-    const child = parentNode.child(i)
-    if (currentOffset >= targetOffset) break
-
-    if (child.type.name === "hard_break") {
-      textBefore = ""
-      currentOffset += child.nodeSize
-      lineStartOffset = currentOffset
-    } else if (child.isText && child.text) {
-      const remainingSpace = targetOffset - currentOffset
-      if (remainingSpace <= child.text.length) {
-        textBefore += child.text.slice(0, remainingSpace)
-        break
-      }
-      textBefore += child.text
-      currentOffset += child.text.length
-    } else {
-      currentOffset += child.nodeSize
-    }
-  }
+  const textBefore = parentNode.textContent.slice(0, $head.parentOffset)
 
-  return { textBefore, lineStartOffset }
+  return { textBefore }
 }
 
 function findPattern(
@@ -151,44 +126,33 @@ function findPattern(
   const info = getTextBeforeCursor(state)
   if (!info) return null
 
-  const { textBefore, lineStartOffset } = info
+  const { textBefore } = info
 
   for (const spec of PATTERN_SPECS) {
     const match = matchPattern(textBefore, spec)
     if (!match) continue
 
     const { startIdx, trigger, query } = match
-    const startPos = $head.start() + lineStartOffset + startIdx
+    const startPos = $head.pos - textBefore.length + startIdx
     if (isPatternCompleted(spec, query)) return null
 
     // For delimiter-terminated patterns, check if the closing delimiter
-    // exists anywhere in the textblock after the trigger start.
+    // For delimiter-terminated patterns (page/block refs), check if the
+    // closing delimiter exists anywhere in the paragraph after the trigger.
     // This prevents an active session when the pattern is already complete
     // but the cursor is inside it (e.g. navigating into [[Page Ref]]).
     if (spec.termination === "delimiter" && spec.end) {
-      // Build text from trigger position to end of textblock, respecting hard_breaks
-      let textFromTrigger = ""
-      let triggerFound = false
-      for (let i = 0; i < parentNode.childCount; i++) {
-        const child = parentNode.child(i)
-        if (child.type.name === "hard_break") {
-          textFromTrigger += "\n"
-        } else if (child.isText && child.text) {
-          if (triggerFound) {
-            textFromTrigger += child.text
-          } else if (child.text.includes(trigger)) {
-            triggerFound = true
-            const triggerIdx = child.text.indexOf(trigger)
-            textFromTrigger = child.text.slice(triggerIdx + trigger.length)
-          }
-        }
+      const parentText = parentNode.textContent
+      const triggerIdx = parentText.indexOf(trigger)
+      if (triggerIdx >= 0) {
+        const textFromTrigger = parentText.slice(triggerIdx + trigger.length)
+        if (textFromTrigger.includes(spec.end)) return null
       }
-      if (textFromTrigger.includes(spec.end)) return null
     }
 
     if (spec.termination === "boundary" && startIdx > 0) {
       const charBefore = textBefore[startIdx - 1]
-      if (charBefore && !/[\s\n]/.test(charBefore)) continue
+      if (charBefore && !/\s/.test(charBefore)) continue
     }
 
     const id =
@@ -258,7 +222,7 @@ function getCurrentRange(
   const startIdx = info.textBefore.lastIndexOf(trigger)
   if (startIdx === -1) return null
 
-  const startPos = $head.start() + info.lineStartOffset + startIdx
+  const startPos = $head.pos - info.textBefore.length + startIdx
   const query = info.textBefore.slice(startIdx + trigger.length)
 
   return { from: startPos, to: startPos + trigger.length + query.length }
@@ -361,7 +325,7 @@ class PatternView {
       return
     }
 
-    const startPos = $head.start() + info.lineStartOffset + startIdx
+    const startPos = $head.pos - info.textBefore.length + startIdx
     if (startPos !== session.range.from) {
       this.callbacks.onPatternClose({ id: session.id, reason: "cancelled" })
       return

packages/editor/src/lib/__tests__/content-model.test.ts

@@ -9,14 +9,13 @@ describe("contentToDoc", () => {
     expect(doc.child(0).textContent).toBe("hello world")
   })
 
-  it("handles newlines as hard_breaks within single paragraph", () => {
+  it("handles newlines as separate paragraphs", () => {
     const doc = contentToDoc("line1\nline2")
-    expect(doc.childCount).toBe(1)
-    const paragraph = doc.child(0)
-    expect(paragraph.childCount).toBe(3) // text, hard_break, text
-    expect(paragraph.child(0).textContent).toBe("line1")
-    expect(paragraph.child(1).type.name).toBe("hard_break")
-    expect(paragraph.child(2).textContent).toBe("line2")
+    expect(doc.childCount).toBe(2)
+    expect(doc.child(0).textContent).toBe("line1")
+    expect(doc.child(1).textContent).toBe("line2")
+    expect(doc.child(0).type.name).toBe("paragraph")
+    expect(doc.child(1).type.name).toBe("paragraph")
   })
 
   it("handles unicode and emoji", () => {
@@ -30,11 +29,12 @@ describe("contentToDoc", () => {
     expect(doc.child(0).textContent).toBe("")
   })
 
-  it("handles only newlines", () => {
+  it("handles only newlines as empty paragraphs", () => {
     const doc = contentToDoc("\n\n")
-    expect(doc.childCount).toBe(1)
-    const paragraph = doc.child(0)
-    expect(paragraph.childCount).toBe(2) // two hard_breaks
+    expect(doc.childCount).toBe(3)
+    expect(doc.child(0).textContent).toBe("")
+    expect(doc.child(1).textContent).toBe("")
+    expect(doc.child(2).textContent).toBe("")
   })
 })
 
@@ -46,13 +46,10 @@ describe("docToContent", () => {
     expect(docToContent(doc)).toBe("hello")
   })
 
-  it("joins hard_breaks as newlines", () => {
+  it("joins paragraphs with newlines", () => {
     const doc = schema.nodes.doc.create(null, [
-      schema.nodes.paragraph.create(null, [
-        schema.text("line1"),
-        schema.nodes.hard_break.create(),
-        schema.text("line2"),
-      ]),
+      schema.nodes.paragraph.create(null, [schema.text("line1")]),
+      schema.nodes.paragraph.create(null, [schema.text("line2")]),
     ])
     expect(docToContent(doc)).toBe("line1\nline2")
   })

packages/editor/src/lib/__tests__/debug-tag.test.ts

@@ -0,0 +1,32 @@
+import { describe, it, expect } from "vitest"
+import { parser } from "@lezer/markdown"
+import { GFM } from "@lezer/markdown"
+import { createMarkdownExtensions } from "../../lib/markdown-extensions"
+
+const markdownParser = parser.configure([GFM, ...createMarkdownExtensions()])
+
+describe("Debug Tag parser", () => {
+  it("single line #tag", () => {
+    const text = "#tag more text"
+    const tree = markdownParser.parse(text)
+    const names: string[] = []
+    tree.iterate({
+      enter(node) {
+        names.push(node.name)
+      }
+    })
+    expect(names).toContain("Tag")
+  })
+
+  it("tag after blank line", () => {
+    const text = "some text\n\n#tag more text"
+    const tree = markdownParser.parse(text)
+    const names: string[] = []
+    tree.iterate({
+      enter(node) {
+        names.push(node.name)
+      }
+    })
+    expect(names).toContain("Tag")
+  })
+})

packages/editor/src/lib/__tests__/lezer-debug.test.ts

@@ -0,0 +1,33 @@
+import { describe, it } from "vitest"
+import { parser } from "@lezer/markdown"
+import { GFM } from "@lezer/markdown"
+import { createMarkdownExtensions } from "../../lib/markdown-extensions"
+
+const markdownParser = parser.configure([GFM, ...createMarkdownExtensions()])
+
+describe("Lezer AST debug", () => {
+  const testCases = [
+    "# Hello",
+    "  # Title",
+    "> Quote text",
+    "> [!NOTE] test",
+    "TODO buy milk",
+    "first line\nTODO buy milk",
+    "some text\n\n#tag more text",
+    "**bold**",
+  ]
+
+  for (const text of testCases) {
+    it(`logs AST for: ${JSON.stringify(text).slice(0, 40)}`, () => {
+      console.log(`\n--- Parsing: ${JSON.stringify(text)} ---`)
+      const tree = markdownParser.parse(text)
+      tree.iterate({
+        enter(node) {
+          console.log(
+            `${"  ".repeat(node.type.isTop ? 0 : 1)}${node.name} [${node.from}-${node.to}] "${text.slice(node.from, node.to)}"`
+          )
+        },
+      })
+    })
+  }
+})

packages/editor/src/lib/__tests__/lezer-structure.test.ts

@@ -0,0 +1,29 @@
+import { describe, it } from "vitest"
+import { parser } from "@lezer/markdown"
+import { GFM } from "@lezer/markdown"
+import { createMarkdownExtensions } from "../markdown-extensions"
+
+const markdownParser = parser.configure([GFM, ...createMarkdownExtensions()])
+
+const tests = [
+  "# Hello",
+  "> quotes",
+  "> [!NOTE] test",
+  "  # Title",
+  "TODO buy milk",
+  "plain\n# heading on second line",
+]
+
+describe("Lezer AST structure", () => {
+  for (const text of tests) {
+    it(`parses: ${JSON.stringify(text).slice(0, 40)}`, () => {
+      console.log(`\n=== ${JSON.stringify(text)} ===`)
+      const tree = markdownParser.parse(text)
+      tree.iterate({
+        enter(node) {
+          console.log("  ", node.type.name, "from:", node.from, "to:", node.to)
+        },
+      })
+    })
+  }
+})

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

@@ -365,9 +365,9 @@ describe("block decorations", () => {
     expect(result.blocks[0].metadata?.taskState).toBe("TODO")
   })
 
-  it("parses task with priority", () => {
+  it("parses task with inline content", () => {
     const result = parseMarkdown("TODO buy milk [#A]")
-    expect(result.blocks).toHaveLength(2)
+    expect(result.blocks).toHaveLength(1)
     expect(result.blocks[0].type).toBe("task")
     expect(result.blocks[0].decorationRanges).toHaveLength(2)
     expect(result.blocks[0].decorationRanges[0]).toEqual({
@@ -379,45 +379,10 @@ describe("block decorations", () => {
     expect(result.blocks[0].decorationRanges[1]).toEqual({
       type: "content",
       from: 5,
-      to: 13,
+      to: 18,
       className: "md-task-content",
     })
     expect(result.blocks[0].metadata?.taskState).toBe("TODO")
-    expect(result.blocks[1].type).toBe("priority")
-    expect(result.blocks[1].decorationRanges).toHaveLength(2)
-    expect(result.blocks[1].decorationRanges[0]).toEqual({
-      type: "content",
-      from: 13,
-      to: 17,
-      className: "md-priority-marker",
-    })
-    expect(result.blocks[1].decorationRanges[1]).toEqual({
-      type: "content",
-      from: 17,
-      to: 18,
-      className: "md-priority-content",
-    })
-    expect(result.blocks[1].metadata?.priority).toBe("A")
-  })
-
-  it("parses priority only", () => {
-    const result = parseMarkdown("[#B] high priority")
-    expect(result.blocks).toHaveLength(1)
-    expect(result.blocks[0].type).toBe("priority")
-    expect(result.blocks[0].decorationRanges).toHaveLength(2)
-    expect(result.blocks[0].decorationRanges[0]).toEqual({
-      type: "content",
-      from: 0,
-      to: 4,
-      className: "md-priority-marker",
-    })
-    expect(result.blocks[0].decorationRanges[1]).toEqual({
-      type: "content",
-      from: 5,
-      to: 18,
-      className: "md-priority-content",
-    })
-    expect(result.blocks[0].metadata?.priority).toBe("B")
   })
 
   it("parses blockquote", () => {
@@ -440,13 +405,6 @@ describe("block decorations", () => {
     expect(result.blocks[0].metadata?.calloutType).toBe("WARNING")
   })
 
-  it("parses date", () => {
-    const result = parseMarkdown("📅 2024-01-15")
-    expect(result.blocks).toHaveLength(1)
-    expect(result.blocks[0].type).toBe("date")
-    expect(result.blocks[0].metadata?.date).toBe("2024-01-15")
-  })
-
   it("returns empty blocks for plain text", () => {
     const result = parseMarkdown("Just some plain text")
     expect(result.blocks).toHaveLength(0)
@@ -505,39 +463,21 @@ describe("leading whitespace handling", () => {
     })
   })
 
-  it("priority with leading spaces positions marker correctly", () => {
-    const result = parseMarkdown("  [#A] high priority")
+  it("task with leading spaces includes full content", () => {
+    const result = parseMarkdown("  TODO buy milk [#A]")
     expect(result.blocks).toHaveLength(1)
+    expect(result.blocks[0].type).toBe("task")
     expect(result.blocks[0].decorationRanges[0]).toEqual({
       type: "content",
       from: 2,
       to: 6,
-      className: "md-priority-marker",
+      className: "md-task-marker",
     })
     expect(result.blocks[0].decorationRanges[1]).toEqual({
       type: "content",
       from: 7,
       to: 20,
-      className: "md-priority-content",
-    })
-  })
-
-  it("task with priority and leading spaces", () => {
-    const result = parseMarkdown("  TODO buy milk [#A]")
-    expect(result.blocks).toHaveLength(2)
-    expect(result.blocks[0].type).toBe("task")
-    expect(result.blocks[0].decorationRanges[0]).toEqual({
-      type: "content",
-      from: 2,
-      to: 6,
-      className: "md-task-marker",
-    })
-    expect(result.blocks[1].type).toBe("priority")
-    expect(result.blocks[1].decorationRanges[0]).toEqual({
-      type: "content",
-      from: 15,
-      to: 19,
-      className: "md-priority-marker",
+      className: "md-task-content",
     })
   })
 
@@ -548,7 +488,7 @@ describe("leading whitespace handling", () => {
       type: "content",
       from: 2,
       to: 3,
-      className: "md-blockquote-marker",
+      className: "md-marker",
     })
   })
 
@@ -559,18 +499,7 @@ describe("leading whitespace handling", () => {
       type: "content",
       from: 2,
       to: 11,
-      className: "md-callout-marker",
-    })
-  })
-
-  it("date with leading spaces", () => {
-    const result = parseMarkdown("  📅 2024-01-15")
-    expect(result.blocks).toHaveLength(1)
-    expect(result.blocks[0].decorationRanges[0]).toEqual({
-      type: "content",
-      from: 2,
-      to: 4,
-      className: "md-date-marker",
+      className: "md-marker",
     })
   })
 })
@@ -593,74 +522,51 @@ describe("whitespace variations in task rules", () => {
     })
   })
 
-  it("task with priority and multiple spaces before priority", () => {
+  it("task with trailing content includes everything", () => {
     const result = parseMarkdown("TODO buy milk    [#A]")
-    expect(result.blocks).toHaveLength(2)
-    expect(result.blocks[0].type).toBe("task")
-    expect(result.blocks[0].decorationRanges[1].to).toBe(13)
-    expect(result.blocks[1].type).toBe("priority")
-    expect(result.blocks[1].decorationRanges[0]).toEqual({
-      type: "content",
-      from: 13,
-      to: 17,
-      className: "md-priority-marker",
-    })
-  })
-
-  it("priority with multiple spaces after marker", () => {
-    const result = parseMarkdown("[#B]    high priority")
     expect(result.blocks).toHaveLength(1)
-    expect(result.blocks[0].decorationRanges[0]).toEqual({
-      type: "content",
-      from: 0,
-      to: 4,
-      className: "md-priority-marker",
-    })
-    expect(result.blocks[0].decorationRanges[1]).toEqual({
-      type: "content",
-      from: 8,
-      to: 21,
-      className: "md-priority-content",
-    })
+    expect(result.blocks[0].type).toBe("task")
+    expect(result.blocks[0].decorationRanges[1].to).toBe(21)
   })
 
-  describe("multi-line block positions", () => {
-    it("heading on second line has correct absolute positions", () => {
-      const result = parseMarkdown("first line\n# Title")
+  // Per-paragraph parsing tests (re-architecture: one paragraph at a time)
+  describe("per-paragraph block positions", () => {
+    it("heading positions relative to paragraph start", () => {
+      const result = parseMarkdown("# Title")
       expect(result.blocks).toHaveLength(1)
       expect(result.blocks[0].decorationRanges[0]).toEqual({
         type: "content",
-        from: 11,
-        to: 12,
+        from: 0,
+        to: 1,
         className: "md-heading-marker",
       })
       expect(result.blocks[0].decorationRanges[1]).toEqual({
         type: "content",
-        from: 13,
-        to: 18,
+        from: 2,
+        to: 7,
         className: "md-heading-content",
       })
     })
 
-    it("task on second line has correct absolute positions", () => {
-      const result = parseMarkdown("first line\nTODO buy milk")
+    it("task positions relative to paragraph start", () => {
+      const result = parseMarkdown("TODO buy milk")
       expect(result.blocks).toHaveLength(1)
       expect(result.blocks[0].decorationRanges[0]).toEqual({
         type: "content",
-        from: 11,
-        to: 15,
+        from: 0,
+        to: 4,
         className: "md-task-marker",
       })
       expect(result.blocks[0].decorationRanges[1]).toEqual({
         type: "content",
-        from: 16,
-        to: 24,
+        from: 5,
+        to: 13,
         className: "md-task-content",
       })
     })
 
-    it("inline tokens on first line are unaffected by second line", () => {
-      const result = parseMarkdown("**bold**\nplain text")
+    it("inline tokens on plain text paragraph", () => {
+      const result = parseMarkdown("**bold** text")
       expect(result.content).toHaveLength(1)
       expect(result.content[0].decorationRanges[0]).toEqual({
         type: "hidden",
@@ -669,29 +575,17 @@ describe("whitespace variations in task rules", () => {
       })
     })
 
-    it("tag on second line is parsed", () => {
-      const result = parseMarkdown("some text\n#tag")
+    it("tag in paragraph is parsed", () => {
+      const result = parseMarkdown("some text #tag")
       expect(result.content).toHaveLength(1)
       expect(result.content[0].type).toBe("tag")
     })
 
-    it("tag after blank line is parsed", () => {
-      const result = parseMarkdown("some text\n\n#tag more text")
-      expect(result.content).toHaveLength(1)
-      expect(result.content[0].type).toBe("tag")
-    })
-
-    it("property on second line is parsed", () => {
-      const result = parseMarkdown("some text\nkey:: value")
+    it("property at paragraph start is parsed", () => {
+      const result = parseMarkdown("key:: value")
       expect(result.properties).toHaveLength(1)
       expect(result.properties[0].key).toBe("key")
     })
-
-    it("date on second line is parsed", () => {
-      const result = parseMarkdown("some text\n📅 2024-01-15")
-      expect(result.blocks).toHaveLength(1)
-      expect(result.blocks[0].type).toBe("date")
-    })
   })
 })
 
@@ -757,26 +651,34 @@ describe("wrapperAttrs output", () => {
     })
   })
 
-  it("task with priority has independent wrapperAttrs", () => {
-    const result = parseMarkdown("TODO buy milk [#A]")
-    expect(result.blocks).toHaveLength(2)
-    expect(result.blocks[0].wrapperAttrs).toEqual({
-      "data-task-state": "TODO",
+  it("callout block has wrapperAttrs via nodeWrapper", () => {
+    const result = parseMarkdown("> [!NOTE] important info")
+    expect(result.blocks[0].nodeWrapper?.attrs).toEqual({
+      "data-callout-type": "NOTE",
     })
-    expect(result.blocks[1].wrapperAttrs).toEqual({ "data-priority": "A" })
   })
 
-  it("callout block has wrapperAttrs", () => {
+  it("callout block has nodeWrapper and md-marker", () => {
     const result = parseMarkdown("> [!NOTE] important info")
-    expect(result.blocks[0].wrapperAttrs).toEqual({
+    expect(result.blocks).toHaveLength(1)
+    expect(result.blocks[0].type).toBe("callout")
+    expect(result.blocks[0].nodeWrapper?.className).toBe("md-callout")
+    expect(result.blocks[0].nodeWrapper?.attrs).toEqual({
       "data-callout-type": "NOTE",
     })
+    expect(result.blocks[0].decorationRanges[0].className).toBe("md-marker")
   })
 
-  it("date block has wrapperAttrs", () => {
-    const result = parseMarkdown("📅 2024-01-15")
-    expect(result.blocks[0].wrapperAttrs).toEqual({
-      "data-date": "2024-01-15",
+  it("blockquote continuation line uses md-marker", () => {
+    const result = parseMarkdown("> continuation")
+    expect(result.blocks).toHaveLength(1)
+    expect(result.blocks[0].type).toBe("blockquote")
+    expect(result.blocks[0].decorationRanges).toHaveLength(1)
+    expect(result.blocks[0].decorationRanges[0]).toEqual({
+      type: "content",
+      from: 0,
+      to: 1,
+      className: "md-marker",
     })
   })
 })

packages/editor/src/lib/__tests__/paragraph-parsing.test.ts

@@ -0,0 +1,62 @@
+import { describe, expect, it } from "vitest"
+import { parseMarkdown } from "../markdown-parser"
+
+describe("paragraph-based parsing", () => {
+  it("parses single-line blockquote", () => {
+    const result = parseMarkdown("> Line one")
+    expect(result.blocks).toHaveLength(1)
+    expect(result.blocks[0].type).toBe("blockquote")
+    expect(result.blocks[0].decorationRanges).toHaveLength(1)
+    expect(result.blocks[0].decorationRanges[0]).toEqual({
+      type: "content",
+      from: 0,
+      to: 1,
+      className: "md-marker",
+    })
+  })
+
+  it("parses inline bold inside blockquote", () => {
+    const result = parseMarkdown("> **bold** text")
+    expect(result.blocks).toHaveLength(1)
+    expect(result.blocks[0].type).toBe("blockquote")
+    // Bold inside the blockquote is still parsed as inline
+    expect(result.content).toHaveLength(1)
+    expect(result.content[0].type).toBe("strong")
+  })
+
+  it("does not match task inside blockquote", () => {
+    const result = parseMarkdown("> TODO buy milk")
+    expect(result.blocks).toHaveLength(1)
+    expect(result.blocks[0].type).toBe("blockquote")
+    // Should not also create a task block
+    expect(result.blocks.find((b) => b.type === "task")).toBeUndefined()
+  })
+
+  it("matches task at top-level paragraph", () => {
+    const result = parseMarkdown("TODO buy milk")
+    expect(result.blocks).toHaveLength(1)
+    expect(result.blocks[0].type).toBe("task")
+  })
+
+  it("parses heading as block decoration", () => {
+    const result = parseMarkdown("# Hello")
+    expect(result.blocks).toHaveLength(1)
+    expect(result.blocks[0].type).toBe("heading")
+    expect(result.blocks[0].metadata?.level).toBe(1)
+  })
+
+  it("inline bold works with full-text parse", () => {
+    const result = parseMarkdown("**bold**")
+    expect(result.content).toHaveLength(1)
+    expect(result.content[0].type).toBe("strong")
+    const ranges = result.content[0].decorationRanges
+    expect(ranges[0]).toEqual({ type: "hidden", from: 0, to: 2 })
+    expect(ranges[1]).toEqual({
+      type: "content",
+      from: 2,
+      to: 6,
+      className: "md-strong",
+    })
+    expect(ranges[2]).toEqual({ type: "hidden", from: 6, to: 8 })
+  })
+})

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

@@ -12,17 +12,17 @@ describe("schema", () => {
       expect(schema.nodes.paragraph).toBeDefined()
     })
 
-    it("has hard_break node", () => {
-      expect(schema.nodes.hard_break).toBeDefined()
-    })
-
     it("has text node", () => {
       expect(schema.nodes.text).toBeDefined()
     })
+
+    it("does not have hard_break node (removed in re-architecture)", () => {
+      expect(schema.nodes.hard_break).toBeUndefined()
+    })
   })
 
   describe("doc node", () => {
-    it("creates doc with content", () => {
+    it("creates doc with one paragraph", () => {
       const doc = schema.nodes.doc.create(null, [
         schema.nodes.paragraph.create(),
       ])
@@ -30,6 +30,14 @@ describe("schema", () => {
       expect(doc.childCount).toBe(1)
     })
 
+    it("creates doc with multiple paragraphs", () => {
+      const doc = schema.nodes.doc.create(null, [
+        schema.nodes.paragraph.create(null, [schema.text("line1")]),
+        schema.nodes.paragraph.create(null, [schema.text("line2")]),
+      ])
+      expect(doc.childCount).toBe(2)
+    })
+
     it("requires block content", () => {
       const doc = schema.nodes.doc.create(null, [
         schema.nodes.paragraph.create(null, [schema.text("hello")]),
@@ -51,18 +59,6 @@ describe("schema", () => {
     })
   })
 
-  describe("hard_break node", () => {
-    it("creates hard break", () => {
-      const br = schema.nodes.hard_break.create()
-      expect(br.type.name).toBe("hard_break")
-    })
-
-    it("is atom (no content)", () => {
-      const br = schema.nodes.hard_break.create()
-      expect(br.isAtom).toBe(true)
-    })
-  })
-
   describe("text node", () => {
     it("creates text node", () => {
       const text = schema.text("hello")
@@ -78,12 +74,13 @@ describe("schema", () => {
   })
 
   describe("roundtrip with content-model", () => {
-    it("preserves paragraph structure", () => {
+    it("preserves multi-paragraph structure", () => {
       const original = "line1\nline2"
       const doc = contentToDoc(original)
       const result = docToContent(doc)
 
       expect(result).toBe(original)
+      expect(doc.childCount).toBe(2)
     })
   })
 })

packages/editor/src/lib/content-model.ts

@@ -2,7 +2,7 @@
  * Content model conversion functions.
  *
  * Converts between raw markdown string and ProseMirror document nodes.
- * Each block is exactly one <p>; newlines within a block become hard_breaks.
+ * Each block is one or more <p> paragraphs; one paragraph per line.
  */
 
 import type { Node as ProsemirrorNode } from "prosemirror-model"
@@ -10,31 +10,24 @@ import { schema } from "./schema"
 
 /**
  * Convert markdown string to ProseMirror document.
- * The entire block becomes one paragraph; each newline becomes a hard_break.
+ * Each line becomes one paragraph.
  * @param content - Raw markdown string
  * @returns ProseMirror document node
  */
 export function contentToDoc(content: string): ProsemirrorNode {
   if (!content) {
-    const paragraph = schema.nodes.paragraph.create()
-    return schema.nodes.doc.create(null, [paragraph])
+    return schema.nodes.doc.create(null, [
+      schema.nodes.paragraph.create()
+    ])
   }
 
-  const lines = content.split("\n")
-  const children: ProsemirrorNode[] = []
+  const paragraphs = content.split("\n").map(line =>
+    line.length === 0
+      ? schema.nodes.paragraph.create()
+      : schema.nodes.paragraph.create(null, [schema.text(line)]),
+  )
 
-  for (let i = 0; i < lines.length; i++) {
-    if (i > 0) {
-      children.push(schema.nodes.hard_break.create())
-    }
-    const lineText = lines[i]
-    if (lineText.length > 0) {
-      children.push(schema.text(lineText))
-    }
-  }
-
-  const paragraph = schema.nodes.paragraph.create(null, children)
-  return schema.nodes.doc.create(null, [paragraph])
+  return schema.nodes.doc.create(null, paragraphs)
 }
 
 /**
@@ -43,23 +36,11 @@ export function contentToDoc(content: string): ProsemirrorNode {
  * @returns Raw markdown string
  */
 export function docToContent(doc: ProsemirrorNode): string {
-  const parts: string[] = []
-
-  doc.forEach((child: ProsemirrorNode) => {
-    if (child.type.name === "paragraph") {
-      let text = ""
-
-      child.forEach((inline: ProsemirrorNode) => {
-        if (inline.type.name === "text") {
-          text += inline.text || ""
-        } else if (inline.type.name === "hard_break") {
-          text += "\n"
-        }
-      })
+  const lines: string[] = []
 
-      parts.push(text)
-    }
+  doc.forEach((paragraph: ProsemirrorNode) => {
+    lines.push(paragraph.textContent)
   })
 
-  return parts.join("\n")
+  return lines.join("\n")
 }

packages/editor/src/lib/markdown-extensions.ts

@@ -8,7 +8,12 @@
  * - Highlights: ^^text^^
  */
 
-import type { MarkdownConfig } from "@lezer/markdown"
+import type {
+  BlockContext,
+  LeafBlock,
+  LeafBlockParser,
+  MarkdownConfig,
+} from "@lezer/markdown"
 
 export interface PatternDecorationConfig {
   contentClass: string
@@ -41,7 +46,14 @@ function createPatternExtension(patterns: MarkdownPattern[]): MarkdownConfig {
 
             if (pos > 0) {
               const prev = cx.char(pos - 1)
-              if (prev !== 32 && prev !== 9 && prev !== 10 && prev !== 13) {
+              if (
+                prev != null &&
+                prev > 0 &&
+                prev !== 32 &&
+                prev !== 9 &&
+                prev !== 10 &&
+                prev !== 13
+              ) {
                 return -1
               }
             }
@@ -150,9 +162,66 @@ export const defaultPatterns: MarkdownPattern[] = [
   },
 ]
 
+// ── Task state block extension ─────────────────────────────────────
+
+const TASK_STATES = [
+  "TODO",
+  "DOING",
+  "DONE",
+  "LATER",
+  "NOW",
+  "WAITING",
+  "CANCELLED",
+]
+
+const TASK_RE = new RegExp(`^\\s*(${TASK_STATES.join("|")})\\s+`, "i")
+
+class TaskParser implements LeafBlockParser {
+  nextLine() {
+    return false
+  }
+
+  finish(cx: BlockContext, leaf: LeafBlock) {
+    const content = leaf.content
+    const leading = (content.match(/^\s*/) || [""])[0].length
+    const trimmed = content.slice(leading)
+    const match = trimmed.match(TASK_RE)
+    if (!match) return false
+    const markerLen = match[1].length
+    const afterMarker = match[0].length
+    const markerStart = leaf.start + leading
+    cx.addLeafElement(
+      leaf,
+      cx.elt("Task", leaf.start, leaf.start + content.length, [
+        cx.elt("TaskMarker", markerStart, markerStart + markerLen),
+        ...cx.parser.parseInline(
+          trimmed.slice(afterMarker),
+          markerStart + afterMarker,
+        ),
+      ]),
+    )
+    return true
+  }
+}
+
+const TaskBlock: MarkdownConfig = {
+  defineNodes: [{ name: "Task", block: true }, { name: "TaskMarker" }],
+  parseBlock: [
+    {
+      name: "TaskBlock",
+      leaf(cx, leaf) {
+        return TASK_RE.test(leaf.content) && cx.parentType().name === "Document"
+          ? new TaskParser()
+          : null
+      },
+      after: "SetextHeading",
+    },
+  ],
+}
+
 export function createMarkdownExtensions(
   customPatterns: MarkdownPattern[] = [],
 ): MarkdownConfig[] {
   const allPatterns = [...defaultPatterns, ...customPatterns]
-  return [createPatternExtension(allPatterns)]
+  return [createPatternExtension(allPatterns), TaskBlock]
 }

packages/editor/src/lib/markdown-rules.ts

@@ -1,841 +0,0 @@
-/**
- * Rule-based markdown parser architecture.
- *
- * Pipeline: Lezer Parser → AST Visitor → Rule Registry → Decoration Extraction
- *
- * Three rule categories:
- * - Inline AST rules (emphasis, links) — matched via Lezer node types
- * - Leaf AST rules (tags, refs) — matched via Lezer node types
- * - Line/block regex rules (task, heading) — matched via line patterns
- */
-
-import type { Parser, SyntaxNode, TreeCursor } from "@lezer/common"
-
-// ── Context ──────────────────────────────────────────────────────────
-
-export interface ParseContext {
-  doc: string
-  cursorPos?: number
-}
-
-// ── Unified DecorationRange ──────────────────────────────────────────
-
-export interface DecorationRange {
-  type: "hidden" | "content"
-  from: number
-  to: number
-  className?: string
-}
-
-// ── Result types ─────────────────────────────────────────────────────
-
-/**
- * Base interface for all parsed tokens.
- * Each rule provides its own wrapperAttrs so the decoration builder
- * can render without type-switching.
- */
-export interface ParsedToken {
-  type: string
-  decorationRanges: DecorationRange[]
-  wrapperAttrs?: Record<string, string>
-}
-
-export interface TokenDecoration extends ParsedToken {
-  type: string
-}
-
-export interface PageRefDecoration extends ParsedToken {
-  type: "page-ref"
-  pageName: string
-  alias?: string
-}
-
-export interface BlockRefDecoration extends ParsedToken {
-  type: "block-ref"
-  blockId: string
-}
-
-export interface TagDecoration extends ParsedToken {
-  type: "tag"
-  tag: string
-}
-
-export interface HighlightDecoration extends ParsedToken {
-  type: "highlight"
-}
-
-export interface PropertyInfo {
-  key: string
-  value: string
-  keyRange: [number, number]
-  delimiterRange: [number, number]
-  valueRange: [number, number]
-}
-
-export type TaskState =
-  | "TODO"
-  | "DOING"
-  | "DONE"
-  | "LATER"
-  | "NOW"
-  | "WAITING"
-  | "CANCELLED"
-export type PriorityLevel = "A" | "B" | "C"
-export type CalloutType = "NOTE" | "WARNING" | "TIP" | "DANGER" | "INFO"
-
-export interface BlockDecoration extends ParsedToken {
-  type: "heading" | "task" | "priority" | "blockquote" | "callout" | "date"
-  metadata?: {
-    level?: number
-    taskState?: TaskState
-    priority?: PriorityLevel
-    calloutType?: CalloutType
-    date?: string
-  }
-}
-
-export interface ParsedDecorations {
-  content: (
-    | TokenDecoration
-    | PageRefDecoration
-    | BlockRefDecoration
-    | TagDecoration
-    | HighlightDecoration
-  )[]
-  properties: PropertyInfo[]
-  blocks: BlockDecoration[]
-}
-
-// ── Tree helpers ─────────────────────────────────────────────────────
-
-export function findChildByTypeName(
-  node: SyntaxNode,
-  typeName: string,
-): SyntaxNode | null {
-  const cursor = node.cursor()
-  if (!cursor.firstChild()) return null
-  do {
-    if (cursor.node.type.name === typeName) {
-      const child = cursor.node
-      cursor.parent()
-      return child
-    }
-  } while (cursor.nextSibling())
-  cursor.parent()
-  return null
-}
-
-export function findChildrenByTypeName(
-  node: SyntaxNode,
-  typeName: string,
-): SyntaxNode[] {
-  const results: SyntaxNode[] = []
-  const cursor = node.cursor()
-  if (!cursor.firstChild()) return results
-  do {
-    if (cursor.node.type.name === typeName) {
-      results.push(cursor.node)
-    }
-  } while (cursor.nextSibling())
-  cursor.parent()
-  return results
-}
-
-// ── Rule interface ───────────────────────────────────────────────────
-
-export interface MarkdownRule<T = unknown> {
-  name: string
-  nodeTypes?: string[]
-  match(node: SyntaxNode, ctx: ParseContext): boolean
-  run(node: SyntaxNode, ctx: ParseContext): T | null
-}
-
-// ── Inline rule factories ────────────────────────────────────────────
-
-export function createDelimitedRule(config: {
-  node: string
-  mark: string
-  type: string
-  className: string
-}): MarkdownRule<TokenDecoration> {
-  return {
-    name: config.type,
-    nodeTypes: [config.node],
-    match(node) {
-      return node.type.name === config.node
-    },
-    run(node) {
-      const marks = findChildrenByTypeName(node, config.mark)
-      if (marks.length < 2) return null
-      const opener = marks[0]
-      const closer = marks[marks.length - 1]
-      return {
-        type: config.type,
-        wrapperAttrs: {
-          "data-md-type": config.type,
-        },
-        decorationRanges: [
-          { type: "hidden", from: opener.from, to: opener.to },
-          {
-            type: "content",
-            from: opener.to,
-            to: closer.from,
-            className: config.className,
-          },
-          { type: "hidden", from: closer.from, to: closer.to },
-        ],
-      }
-    },
-  }
-}
-
-export function createLinkRule(): MarkdownRule<TokenDecoration> {
-  return {
-    name: "link",
-    nodeTypes: ["Link"],
-    match(node) {
-      return node.type.name === "Link"
-    },
-    run(node) {
-      const linkMarks = findChildrenByTypeName(node, "LinkMark")
-      if (linkMarks.length < 2) return null
-      const url = findChildByTypeName(node, "URL")
-      if (!url) return null
-      const opener = linkMarks[0]
-      const closer = linkMarks[linkMarks.length - 1]
-      const textEnd = linkMarks[1]
-      return {
-        type: "link",
-        wrapperAttrs: {
-          "data-md-type": "link",
-        },
-        decorationRanges: [
-          { type: "hidden", from: opener.from, to: opener.to },
-          {
-            type: "content",
-            from: opener.to,
-            to: textEnd.from,
-            className: "md-link",
-          },
-          { type: "hidden", from: textEnd.from, to: closer.to },
-        ],
-      }
-    },
-  }
-}
-
-export function createPageRefRule(): MarkdownRule<PageRefDecoration> {
-  return {
-    name: "page-ref",
-    nodeTypes: ["PageRef"],
-    match(node) {
-      return node.type.name === "PageRef"
-    },
-    run(node, ctx) {
-      const from = node.from
-      const to = node.to
-      const innerText = ctx.doc.slice(from + 2, to - 2)
-      const pipeIdx = innerText.indexOf("|")
-      const pageName = pipeIdx >= 0 ? innerText.slice(0, pipeIdx) : innerText
-      const alias = pipeIdx >= 0 ? innerText.slice(pipeIdx + 1) : undefined
-
-      return {
-        type: "page-ref",
-        pageName,
-        alias,
-        wrapperAttrs: {
-          "data-page-name": pageName,
-          ...(alias && { "data-alias": alias }),
-          role: "link",
-          tabindex: "0",
-        },
-        decorationRanges: [
-          { type: "hidden", from, to: from + 2 },
-          {
-            type: "content",
-            from: from + 2,
-            to: to - 2,
-            className: "md-page-ref",
-          },
-          { type: "hidden", from: to - 2, to },
-        ],
-      }
-    },
-  }
-}
-
-export function createBlockRefRule(): MarkdownRule<BlockRefDecoration> {
-  return {
-    name: "block-ref",
-    nodeTypes: ["BlockRef"],
-    match(node) {
-      return node.type.name === "BlockRef"
-    },
-    run(node, ctx) {
-      const from = node.from
-      const to = node.to
-      const blockId = ctx.doc.slice(from + 2, to - 2)
-      return {
-        type: "block-ref",
-        blockId,
-        wrapperAttrs: {
-          "data-block-id": blockId,
-        },
-        decorationRanges: [
-          { type: "hidden", from, to: from + 2 },
-          {
-            type: "content",
-            from: from + 2,
-            to: to - 2,
-            className: "md-block-ref",
-          },
-          { type: "hidden", from: to - 2, to },
-        ],
-      }
-    },
-  }
-}
-
-export function createTagRule(): MarkdownRule<TagDecoration> {
-  return {
-    name: "tag",
-    nodeTypes: ["Tag"],
-    match(node) {
-      return node.type.name === "Tag"
-    },
-    run(node, ctx) {
-      const from = node.from
-      const to = node.to
-      const tagText = ctx.doc.slice(from, to)
-      const tag = tagText.slice(1)
-      return {
-        type: "tag",
-        tag,
-        wrapperAttrs: {
-          "data-tag": tag,
-        },
-        decorationRanges: [
-          { type: "content", from, to, className: "md-tag" },
-        ],
-      }
-    },
-  }
-}
-
-export function createHighlightRule(): MarkdownRule<HighlightDecoration> {
-  return {
-    name: "highlight",
-    nodeTypes: ["Highlight"],
-    match(node) {
-      return node.type.name === "Highlight"
-    },
-    run(node) {
-      const from = node.from
-      const to = node.to
-      return {
-        type: "highlight",
-        wrapperAttrs: {
-          "data-md-type": "highlight",
-        },
-        decorationRanges: [
-          { type: "hidden", from, to: from + 2 },
-          {
-            type: "content",
-            from: from + 2,
-            to: to - 2,
-            className: "md-highlight",
-          },
-          { type: "hidden", from: to - 2, to },
-        ],
-      }
-    },
-  }
-}
-
-// ── Line rule interface ──────────────────────────────────────────────
-
-export interface LineRule {
-  name: string
-  priority?: number
-  match(line: string): boolean
-  run(line: string): BlockDecoration | BlockDecoration[] | null
-}
-
-// ── Line rule factories ──────────────────────────────────────────────
-//
-// All line rules account for leading whitespace by calculating
-// `leadingOffset = line.length - trimmed.length` and adding it to
-// all decoration range positions. This ensures decorations target
-// the correct characters even when lines are indented.
-
-export function createHeadingRule(): LineRule {
-  return {
-    name: "heading",
-    priority: 10,
-    match(line) {
-      return line.trimStart().startsWith("#")
-    },
-    run(line) {
-      const trimmed = line.trimStart()
-      const leadingOffset = line.length - trimmed.length
-      const match = trimmed.match(/^(#{1,6})\s+(.*)$/)
-      if (!match) return null
-      const level = match[1].length
-      const markerEnd = leadingOffset + level
-      const contentStart = leadingOffset + level + 1
-      return {
-        type: "heading",
-        wrapperAttrs: {
-          "data-heading-level": String(level),
-        },
-        decorationRanges: [
-          {
-            type: "content",
-            from: leadingOffset,
-            to: markerEnd,
-            className: "md-heading-marker",
-          },
-          {
-            type: "content",
-            from: contentStart,
-            to: line.length,
-            className: "md-heading-content",
-          },
-        ],
-        metadata: { level },
-      }
-    },
-  }
-}
-
-export function createCalloutRule(): LineRule {
-  return {
-    name: "callout",
-    priority: 20,
-    match(line) {
-      const trimmed = line.trimStart()
-      return trimmed.startsWith(">") && /^>\s*\[![A-Z]+\]/.test(trimmed)
-    },
-    run(line) {
-      const trimmed = line.trimStart()
-      const leadingOffset = line.length - trimmed.length
-      const calloutMatch = trimmed.match(/^>\s*\[!([A-Z]+)\]\s*(.*)$/)
-      if (!calloutMatch) return null
-      const calloutType = calloutMatch[1] as CalloutType
-      if (!["NOTE", "WARNING", "TIP", "DANGER", "INFO"].includes(calloutType))
-        return null
-      const bracketEnd = trimmed.indexOf("]")
-      const markerEnd = leadingOffset + bracketEnd + 1
-      const spaceAfter = trimmed.indexOf(" ", bracketEnd + 1)
-      const contentStart =
-        spaceAfter >= 0 ? leadingOffset + spaceAfter + 1 : line.length
-      return {
-        type: "callout",
-        wrapperAttrs: {
-          "data-callout-type": calloutType,
-        },
-        decorationRanges: [
-          {
-            type: "content",
-            from: leadingOffset,
-            to: markerEnd,
-            className: "md-callout-marker",
-          },
-          {
-            type: "content",
-            from: contentStart,
-            to: line.length,
-            className: "md-callout-content",
-          },
-        ],
-        metadata: { calloutType },
-      }
-    },
-  }
-}
-
-export function createBlockquoteRule(): LineRule {
-  return {
-    name: "blockquote",
-    priority: 15,
-    match(line) {
-      const trimmed = line.trimStart()
-      return trimmed.startsWith(">") && !/^>\s*\[![A-Z]+\]/.test(trimmed)
-    },
-    run(line) {
-      const trimmed = line.trimStart()
-      const leadingOffset = line.length - trimmed.length
-      const match = trimmed.match(/^>/)
-      if (!match) return null
-      const markerEnd = leadingOffset + 1
-      const spaceMatch = trimmed.match(/^>\s+/)
-      const contentStart = spaceMatch
-        ? leadingOffset + spaceMatch[0].length
-        : markerEnd + 1
-      return {
-        type: "blockquote",
-        wrapperAttrs: {
-          "data-md-type": "blockquote",
-        },
-        decorationRanges: [
-          {
-            type: "content",
-            from: leadingOffset,
-            to: markerEnd,
-            className: "md-blockquote-marker",
-          },
-          {
-            type: "content",
-            from: contentStart,
-            to: line.length,
-            className: "md-blockquote-content",
-          },
-        ],
-      }
-    },
-  }
-}
-
-export function createDateRule(): LineRule {
-  return {
-    name: "date",
-    priority: 10,
-    match(line) {
-      return line.trimStart().startsWith("📅")
-    },
-    run(line) {
-      const trimmed = line.trimStart()
-      const leadingOffset = line.length - trimmed.length
-      const match = trimmed.match(/^📅\s*(\d{4}-\d{2}-\d{2})/)
-      if (!match) return null
-      const date = match[1]
-      const emojiLen = "📅".length
-      const markerEnd = leadingOffset + emojiLen
-      const contentStart = leadingOffset + emojiLen + 1
-      return {
-        type: "date",
-        wrapperAttrs: {
-          "data-date": date,
-        },
-        decorationRanges: [
-          {
-            type: "content",
-            from: leadingOffset,
-            to: markerEnd,
-            className: "md-date-marker",
-          },
-          {
-            type: "content",
-            from: contentStart,
-            to: contentStart + 10,
-            className: "md-date-content",
-          },
-        ],
-        metadata: { date },
-      }
-    },
-  }
-}
-
-export function createTaskRule(): LineRule {
-  return {
-    name: "task",
-    priority: 30,
-    match(line) {
-      const trimmed = line.trimStart()
-      return /^(TODO|DOING|DONE|LATER|NOW|WAITING|CANCELLED)\s+/i.test(trimmed)
-    },
-    run(line) {
-      const trimmed = line.trimStart()
-      const leadingOffset = line.length - trimmed.length
-      const taskMatch = trimmed.match(
-        /^(TODO|DOING|DONE|LATER|NOW|WAITING|CANCELLED)\s+(.*)$/i,
-      )
-      if (!taskMatch) return null
-      const taskState = taskMatch[1].toUpperCase() as TaskState
-      if (
-        ![
-          "TODO",
-          "DOING",
-          "DONE",
-          "LATER",
-          "NOW",
-          "WAITING",
-          "CANCELLED",
-        ].includes(taskState)
-      )
-        return null
-
-      const markerEnd = leadingOffset + taskMatch[1].length
-      const afterTask = taskMatch[2]
-      const blocks: BlockDecoration[] = []
-
-      const priorityMatch = afterTask.match(/\s+\[#([A-C])\]\s*$/)
-      let taskContentEnd = line.length
-
-      if (priorityMatch) {
-        taskContentEnd = line.length - priorityMatch[0].length
-      }
-
-      const contentStart = leadingOffset + taskMatch[0].indexOf(taskMatch[2])
-
-      blocks.push({
-        type: "task",
-        wrapperAttrs: {
-          "data-task-state": taskState,
-        },
-        decorationRanges: [
-          {
-            type: "content",
-            from: leadingOffset,
-            to: markerEnd,
-            className: "md-task-marker",
-          },
-          {
-            type: "content",
-            from: contentStart,
-            to: taskContentEnd,
-            className: "md-task-content",
-          },
-        ],
-        metadata: { taskState },
-      })
-
-      if (priorityMatch) {
-        const priority = priorityMatch[1] as PriorityLevel
-        const priorityStart = taskContentEnd
-        const priorityMarkerEnd = priorityStart + 4
-
-        blocks.push({
-          type: "priority",
-          wrapperAttrs: {
-            "data-priority": priority,
-          },
-          decorationRanges: [
-            {
-              type: "content",
-              from: priorityStart,
-              to: priorityMarkerEnd,
-              className: "md-priority-marker",
-            },
-            {
-              type: "content",
-              from: priorityMarkerEnd,
-              to: line.length,
-              className: "md-priority-content",
-            },
-          ],
-          metadata: { priority },
-        })
-      }
-
-      return blocks
-    },
-  }
-}
-
-export function createPriorityRule(): LineRule {
-  return {
-    name: "priority",
-    priority: 25,
-    match(line) {
-      return /^\[#([A-C])\]/.test(line.trimStart())
-    },
-    run(line) {
-      const trimmed = line.trimStart()
-      const leadingOffset = line.length - trimmed.length
-      const match = trimmed.match(/^\[#([A-C])\]\s*(.*)$/)
-      if (!match) return null
-      const priority = match[1] as PriorityLevel
-      const markerEnd = leadingOffset + 4
-      const contentStart = leadingOffset + match[0].indexOf(match[2])
-      return {
-        type: "priority",
-        wrapperAttrs: {
-          "data-priority": priority,
-        },
-        decorationRanges: [
-          {
-            type: "content",
-            from: leadingOffset,
-            to: markerEnd,
-            className: "md-priority-marker",
-          },
-          {
-            type: "content",
-            from: contentStart,
-            to: line.length,
-            className: "md-priority-content",
-          },
-        ],
-        metadata: { priority },
-      }
-    },
-  }
-}
-
-// ── Engine ───────────────────────────────────────────────────────────
-
-function buildRuleIndex(
-  rules: ReadonlyArray<MarkdownRule<unknown>>,
-): ReadonlyMap<string, ReadonlyArray<MarkdownRule<unknown>>> {
-  const index = new Map<string, MarkdownRule<unknown>[]>()
-  for (const rule of rules) {
-    const types = rule.nodeTypes
-    if (types) {
-      for (const nodeType of types) {
-        const bucket = index.get(nodeType)
-        if (bucket) bucket.push(rule)
-        else index.set(nodeType, [rule])
-      }
-    }
-  }
-  return index
-}
-
-export class MarkdownRuleEngine {
-  private readonly inlineRules: ReadonlyArray<MarkdownRule<unknown>>
-  private readonly ruleIndex: ReadonlyMap<
-    string,
-    ReadonlyArray<MarkdownRule<unknown>>
-  >
-  private readonly lineRules: ReadonlyArray<LineRule>
-
-  constructor() {
-    const inlineRules = [
-      createDelimitedRule({
-        node: "StrongEmphasis",
-        mark: "EmphasisMark",
-        type: "strong",
-        className: "md-strong",
-      }),
-      createDelimitedRule({
-        node: "Emphasis",
-        mark: "EmphasisMark",
-        type: "em",
-        className: "md-em",
-      }),
-      createDelimitedRule({
-        node: "InlineCode",
-        mark: "CodeMark",
-        type: "code",
-        className: "md-code",
-      }),
-      createDelimitedRule({
-        node: "Strikethrough",
-        mark: "StrikethroughMark",
-        type: "strike",
-        className: "md-strike",
-      }),
-      createLinkRule(),
-      createPageRefRule(),
-      createBlockRefRule(),
-      createTagRule(),
-      createHighlightRule(),
-    ]
-
-    this.inlineRules = inlineRules
-    this.ruleIndex = buildRuleIndex(inlineRules)
-
-    this.lineRules = [
-      createCalloutRule(),
-      createBlockquoteRule(),
-      createTaskRule(),
-      createPriorityRule(),
-      createHeadingRule(),
-      createDateRule(),
-    ].sort((a, b) => (b.priority ?? 0) - (a.priority ?? 0))
-  }
-
-  parse(docText: string, markdownParser: Parser): ParsedDecorations {
-    const content: ParsedDecorations["content"] = []
-    const properties: PropertyInfo[] = []
-    const blocks: BlockDecoration[] = []
-
-    if (!docText) return { content, properties, blocks }
-
-    const lines = docText.split("\n")
-    let lineOffset = 0
-
-    for (const line of lines) {
-      // Pipeline 1: AST inline rules (per-line to avoid Lezer paragraph boundaries)
-      try {
-        const tree = markdownParser.parse(line)
-        this.visitTree(tree.cursor(), (node) => {
-          const ctx: ParseContext = { doc: line }
-          const candidates = this.ruleIndex.get(node.type.name)
-          const rulesToTry = candidates ?? this.inlineRules
-          for (const rule of rulesToTry) {
-            if (rule.match(node, ctx)) {
-              const result = rule.run(node, ctx)
-              if (result) {
-                // Shift positions to absolute docText coordinates
-                for (const range of result.decorationRanges) {
-                  range.from += lineOffset
-                  range.to += lineOffset
-                }
-                content.push(result)
-              }
-              break
-            }
-          }
-        })
-      } catch {
-        // Skip lines that fail to parse
-      }
-
-      // Pipeline 2: Line/block rules
-      for (const rule of this.lineRules) {
-        if (rule.match(line)) {
-          const result = rule.run(line)
-          if (result) {
-            const items = Array.isArray(result) ? result : [result]
-            for (const item of items) {
-              for (const range of item.decorationRanges) {
-                range.from += lineOffset
-                range.to += lineOffset
-              }
-              blocks.push(item)
-            }
-          }
-          break
-        }
-      }
-
-      // Pipeline 3: Property rules (per-line)
-      const propMatch = line.match(/^(\w[\w-]*)::([^\n]*)/)
-      if (propMatch) {
-        const key = propMatch[1]
-        const value = propMatch[2]?.trim() ?? ""
-        const keyEnd = lineOffset + key.length
-        const delimiterEnd = keyEnd + 2
-        properties.push({
-          key,
-          value,
-          keyRange: [lineOffset, keyEnd],
-          delimiterRange: [keyEnd, delimiterEnd],
-          valueRange: [delimiterEnd, delimiterEnd + propMatch[2].length],
-        })
-      }
-
-      lineOffset += line.length + 1 // +1 for the \n separator
-    }
-
-    return { content, properties, blocks }
-  }
-
-  private visitTree(
-    cursor: TreeCursor,
-    visit: (node: SyntaxNode) => void,
-  ): void {
-    do {
-      if (this.ruleIndex.has(cursor.node.type.name)) {
-        visit(cursor.node)
-      }
-      if (cursor.firstChild()) {
-        this.visitTree(cursor, visit)
-        cursor.parent()
-      }
-    } while (cursor.nextSibling())
-  }
-}

packages/editor/src/lib/markdown-rules/block-classifier.ts

@@ -0,0 +1,103 @@
+/**
+ * Block classifier.
+ *
+ * Determines block type from the first line of a paragraph’s text.
+ * With the re-architecture, each ProseMirror paragraph is exactly
+ * one line of markdown, so no line-walking is required — the
+ * classification is a single regex against the paragraph string.
+ *
+ * Exported types and helpers are kept minimal to make the interface
+ * easy to replace if the set of block kinds ever changes.
+ */
+
+// ── Types ───────────────────────────────────────────────────────────
+
+export type BlockKind =
+  | "paragraph"
+  | "heading"
+  | "callout"
+  | "blockquote"
+  | "task"
+
+export type ParagraphResult = { kind: "paragraph" }
+
+export type HeadingResult = { kind: "heading"; level: number }
+
+export type TaskResult = { kind: "task"; taskState: string }
+
+export type CalloutResult = { kind: "callout"; calloutType: string }
+
+export type BlockquoteResult = { kind: "blockquote" }
+
+export type ClassificationResult =
+  | ParagraphResult
+  | HeadingResult
+  | TaskResult
+  | CalloutResult
+  | BlockquoteResult
+
+// ─── Regex constants ────────────────────────────────────────────────
+
+/** Heading: `# Heading` — up to 6 hashes followed by a space. */
+const HEADING_RE = /^(#{1,6})\s+(.*)/
+
+/** Callout: `> [!NOTE] text` */
+const CALLOUT_RE = /^>\s*\[!([A-Z]+)\]\s*(.*)/
+
+/** Plain blockquote: `> text` (not a callout) */
+const BLOCKQUOTE_RE = /^>\s*(.*)/
+
+/** Task: `  TODO buy milk` — optional leading whitespace */
+const TASK_RE = /^\s*(TODO|DOING|DONE|LATER|NOW|WAITING|CANCELLED)\s+(.*)/i
+
+// ─── Public API ─────────────────────────────────────────────────────
+
+/**
+ * Classify a line of text into a BlockKind.
+ *
+ * With the paragraph-per-line architecture, this is the only
+ * classification step needed — no line-walking, no text-inspection
+ * over multi-line nodes.
+ */
+export function classifyBlock(text: string): ClassificationResult {
+  {
+    const match = text.match(HEADING_RE)
+    if (match) {
+      return {
+        kind: "heading",
+        level: match[1].length,
+      }
+    }
+  }
+
+  {
+    const match = text.match(CALLOUT_RE)
+    if (match) {
+      return {
+        kind: "callout",
+        calloutType: match[1],
+      }
+    }
+  }
+
+  {
+    const match = text.match(BLOCKQUOTE_RE)
+    if (match) {
+      return {
+        kind: "blockquote",
+      }
+    }
+  }
+
+  {
+    const match = text.match(TASK_RE)
+    if (match) {
+      return {
+        kind: "task",
+        taskState: match[1].toUpperCase(),
+      }
+    }
+  }
+
+  return { kind: "paragraph" }
+}

packages/editor/src/lib/markdown-rules/block-rules.ts

@@ -0,0 +1,226 @@
+/**
+ * Block markdown rules — matched against Lezer AST block nodes.
+ *
+ * Covers: Blockquote (with callout detection), Heading.
+ *
+ * Block rules fire on `enter` during tree traversal. The engine
+ * intentionally does NOT skip children, so inline rules (bold, links,
+ * etc.) can still fire inside blockquotes and headings.
+ * Decoration positions are absolute within the parsed docText.
+ */
+
+import type { SyntaxNode } from "@lezer/common"
+import { findChildByTypeName } from "./inline-rules"
+import type {
+  BlockDecoration,
+  BlockRule,
+  CalloutType,
+  ParseContext,
+} from "./types"
+
+const CALLOUT_TYPES: ReadonlySet<string> = new Set([
+  "NOTE",
+  "WARNING",
+  "TIP",
+  "DANGER",
+  "INFO",
+])
+
+// ── Block quote rule ───────────────────────────────────────────────
+
+export function createBlockquoteRule(): BlockRule {
+  return {
+    name: "blockquote",
+    nodeTypes: ["Blockquote"],
+    match(node) {
+      return node.type.name === "Blockquote"
+    },
+    run(node, ctx) {
+      const text = ctx.doc.slice(node.from, node.to)
+      const firstLineText = text.split("\n")[0]
+      const trimmed = firstLineText.trimStart()
+
+      // Check if this is a callout by inspecting the first line
+      const calloutMatch = trimmed.match(/>\s*\[!([A-Z]+)\]\s*(.*)/)
+
+      if (calloutMatch && CALLOUT_TYPES.has(calloutMatch[1])) {
+        const calloutType = calloutMatch[1] as CalloutType
+        return createCalloutDecoration(node, ctx, calloutType, firstLineText)
+      }
+
+      return createPlainBlockquoteDecoration(node, ctx, text)
+    },
+  }
+}
+
+function createPlainBlockquoteDecoration(
+  node: SyntaxNode,
+  _ctx: ParseContext,
+  text: string,
+): BlockDecoration {
+  const decorationRanges: {
+    type: "content"
+    from: number
+    to: number
+    className: string
+  }[] = []
+
+  let offset = node.from
+  for (const line of text.split("\n")) {
+    const trimmed = line.trimStart()
+    const leadingOffset = line.length - trimmed.length
+    const gtPos = trimmed.indexOf(">")
+    if (gtPos >= 0) {
+      const markerStart = offset + leadingOffset + gtPos
+      const markerEnd = markerStart + 1 // just the ">"
+      decorationRanges.push({
+        type: "content",
+        from: markerStart,
+        to: markerEnd,
+        className: "md-marker",
+      })
+    }
+    offset += line.length + 1 // +1 for the newline character
+  }
+
+  return {
+    type: "blockquote",
+    nodeWrapper: { className: "md-blockquote" },
+    wrapperAttrs: { "data-md-type": "blockquote" },
+    decorationRanges,
+  }
+}
+
+function createCalloutDecoration(
+  node: SyntaxNode,
+  _ctx: ParseContext,
+  calloutType: CalloutType,
+  text: string,
+): BlockDecoration {
+  const trimmed = text.trimStart()
+  const leadingOffset = text.length - trimmed.length
+
+  // Find position of "]" character to determine marker end
+  const bracketEnd = trimmed.indexOf("]")
+
+  // Absolute positions in docText
+  // Marker starts at the ">" (including leading spaces)
+  const markerStart = node.from + leadingOffset
+  // Marker ends right after "]" (just the "> [!NOTE]" part)
+  const markerEnd =
+    bracketEnd >= 0
+      ? markerStart + (bracketEnd + 1) // +1 to include the "]"
+      : markerStart + trimmed.length
+
+  return {
+    type: "callout",
+    nodeWrapper: {
+      className: "md-callout",
+      attrs: { "data-callout-type": calloutType },
+    },
+    decorationRanges: [
+      {
+        type: "content",
+        from: markerStart,
+        to: markerEnd,
+        className: "md-marker",
+      },
+    ],
+    metadata: { calloutType },
+  }
+}
+
+// ── Heading rule ──────────────────────────────────────────────────
+
+export function createHeadingRule(): BlockRule {
+  return {
+    name: "heading",
+    nodeTypes: [
+      "ATXHeading1",
+      "ATXHeading2",
+      "ATXHeading3",
+      "ATXHeading4",
+      "ATXHeading5",
+      "ATXHeading6",
+    ],
+    match(node) {
+      return node.type.name.startsWith("ATXHeading")
+    },
+    run(node) {
+      const level = Number.parseInt(
+        node.type.name.replace("ATXHeading", ""),
+        10,
+      )
+
+      // Heading text: "# Title" → markerEnd is after "# "
+      const markerEnd = node.from + level + 1 // +1 for space after #
+
+      return {
+        type: "heading",
+        wrapperAttrs: { "data-heading-level": String(level) },
+        decorationRanges: [
+          {
+            type: "content",
+            from: node.from,
+            to: node.from + level,
+            className: "md-heading-marker",
+          },
+          {
+            type: "content",
+            from: markerEnd,
+            to: node.to,
+            className: "md-heading-content",
+          },
+        ],
+        metadata: { level },
+      }
+    },
+  }
+}
+
+// ── Task rule ─────────────────────────────────────────────────────
+
+export function createTaskRule(): BlockRule {
+  return {
+    name: "task",
+    nodeTypes: ["Task"],
+    match(node) {
+      return node.type.name === "Task"
+    },
+    run(node, ctx) {
+      const markerNode = findChildByTypeName(node, "TaskMarker")
+      if (!markerNode) return null
+      const stateText = ctx.doc.slice(markerNode.from, markerNode.to)
+      let contentStart = markerNode.to
+      while (contentStart < node.to && ctx.doc[contentStart] === " ") {
+        contentStart++
+      }
+      const taskState = stateText.toUpperCase()
+      return {
+        type: "task",
+        wrapperAttrs: { "data-task-state": taskState },
+        decorationRanges: [
+          {
+            type: "content",
+            from: markerNode.from,
+            to: markerNode.to,
+            className: "md-task-marker",
+          },
+          {
+            type: "content",
+            from: contentStart,
+            to: node.to,
+            className: "md-task-content",
+          },
+        ],
+        metadata: { taskState },
+      }
+    },
+  }
+}
+
+// ── Default block rule set ────────────────────────────────────────
+
+export function createBlockRules(): BlockRule[] {
+  return [createBlockquoteRule(), createHeadingRule(), createTaskRule()]
+}

packages/editor/src/lib/markdown-rules/engine.ts

@@ -0,0 +1,150 @@
+/**
+ * Markdown rule engine.
+ *
+ * Parses each paragraph through a Lezer AST walk:
+ *   1. Block rules collect BlockDecoration from tree block nodes
+ *      (headings, blockquotes, tasks, callouts).
+ *   2. Inline rules collect TokenDecoration from tree inline nodes
+ *      (bold, links, tags, etc.).
+ *
+ * All positions in decorationRanges are absolute within docText.
+ */
+
+import type { Parser, Tree } from "@lezer/common"
+import { createBlockRules } from "./block-rules"
+import { createInlineRules } from "./inline-rules"
+import type {
+  BlockDecoration,
+  BlockRule,
+  MarkdownRule,
+  ParseContext,
+  ParsedDecorations,
+  PropertyInfo,
+} from "./types"
+
+// ── Rule index builders ───────────────────────────────────────────────
+
+function buildRuleIndex(
+  rules: ReadonlyArray<MarkdownRule<unknown>>,
+): ReadonlyMap<string, ReadonlyArray<MarkdownRule<unknown>>> {
+  const index = new Map<string, MarkdownRule<unknown>[]>()
+  for (const rule of rules) {
+    for (const nodeType of rule.nodeTypes ?? []) {
+      const bucket = index.get(nodeType)
+      if (bucket) bucket.push(rule)
+      else index.set(nodeType, [rule])
+    }
+  }
+  return index
+}
+
+function buildBlockRuleIndex(
+  rules: ReadonlyArray<BlockRule>,
+): ReadonlyMap<string, ReadonlyArray<BlockRule>> {
+  const index = new Map<string, BlockRule[]>()
+  for (const rule of rules) {
+    for (const nodeType of rule.nodeTypes) {
+      const bucket = index.get(nodeType)
+      if (bucket) bucket.push(rule)
+      else index.set(nodeType, [rule])
+    }
+  }
+  return index
+}
+
+// ── Property parsing (single-line) ───────────────────────────────────
+
+const PROPERTY_RE = /^(\w[\w-]*)::([^\n]*)/
+
+function parseProperties(text: string): PropertyInfo[] {
+  const match = text.match(PROPERTY_RE)
+  if (!match) return []
+  const key = match[1]
+  const rawValue = match[2]
+  const keyEnd = key.length
+  const delimiterEnd = keyEnd + 2
+  return [
+    {
+      key,
+      value: rawValue.trim(),
+      keyRange: [0, keyEnd],
+      delimiterRange: [keyEnd, delimiterEnd],
+      valueRange: [delimiterEnd, delimiterEnd + rawValue.length],
+    },
+  ]
+}
+
+// ── Block decoration helpers ────────────────────────────────────────
+
+// ── Engine ───────────────────────────────────────────────────────────
+
+export class MarkdownRuleEngine {
+  private readonly inlineRules: ReadonlyArray<MarkdownRule<unknown>>
+  private readonly inlineRuleIndex: ReadonlyMap<
+    string,
+    ReadonlyArray<MarkdownRule<unknown>>
+  >
+  private readonly blockRules: ReadonlyArray<BlockRule>
+  private readonly blockRuleIndex: ReadonlyMap<string, ReadonlyArray<BlockRule>>
+
+  constructor() {
+    this.inlineRules = createInlineRules()
+    this.inlineRuleIndex = buildRuleIndex(this.inlineRules)
+    this.blockRules = createBlockRules()
+    this.blockRuleIndex = buildBlockRuleIndex(this.blockRules)
+  }
+
+  parse(docText: string, markdownParser: Parser): ParsedDecorations {
+    const content: ParsedDecorations["content"] = []
+    const blocks: BlockDecoration[] = []
+    const properties: PropertyInfo[] = []
+
+    if (!docText) return { content, properties, blocks }
+
+    // ── Phase 1: Lezer AST walk ─────────────────────────────────────
+    const ctx: ParseContext = { doc: docText }
+    const tree: Tree = markdownParser.parse(docText)
+
+    tree.iterate({
+      enter: (ref) => {
+        const node = ref.node
+        const nodeType = node.type.name
+
+        const blockCandidates = this.blockRuleIndex.get(nodeType)
+        if (blockCandidates) {
+          for (const rule of blockCandidates) {
+            if (rule.match(node, ctx)) {
+              const token = rule.run(node, ctx)
+              if (token) blocks.push(token)
+              break
+            }
+          }
+        }
+      },
+      leave: (ref) => {
+        const node = ref.node
+        const nodeType = node.type.name
+
+        if (this.blockRuleIndex.has(nodeType)) return
+
+        const inlineCandidates = this.inlineRuleIndex.get(nodeType)
+        if (inlineCandidates) {
+          for (const rule of inlineCandidates) {
+            if (rule.match(node, ctx)) {
+              const token = rule.run(node, ctx)
+              if (token) {
+                content.push(token as ParsedDecorations["content"][number])
+              }
+              break
+            }
+          }
+        }
+      },
+    })
+
+    // ── Phase 2: Property extraction ────────────────────────────────
+    properties.push(...parseProperties(docText))
+
+    return { content, properties, blocks }
+  }
+}

packages/editor/src/lib/markdown-rules/index.ts

@@ -0,0 +1,46 @@
+/**
+ * Public API of the markdown rule engine.
+ *
+ * Re-exports everything that was previously exported from markdown-rules.ts
+ * so callers (markdown-parser.ts, tests) need no changes.
+ */
+
+// Block rule factories
+export {
+  createBlockquoteRule,
+  createBlockRules,
+  createHeadingRule,
+} from "./block-rules"
+// Engine
+export { MarkdownRuleEngine } from "./engine"
+// Inline rule factories (consumed by tests and markdown-parser.ts)
+export {
+  createBlockRefRule,
+  createDelimitedRule,
+  createHighlightRule,
+  createInlineRules,
+  createLinkRule,
+  createPageRefRule,
+  createTagRule,
+  findChildByTypeName,
+  findChildrenByTypeName,
+} from "./inline-rules"
+// Types
+export type {
+  BlockDecoration,
+  BlockRefDecoration,
+  BlockRule,
+  CalloutType,
+  DecorationRange,
+  HighlightDecoration,
+  MarkdownRule,
+  PageRefDecoration,
+  ParseContext,
+  ParsedDecorations,
+  ParsedToken,
+  PriorityLevel,
+  PropertyInfo,
+  TagDecoration,
+  TaskState,
+  TokenDecoration,
+} from "./types"

packages/editor/src/lib/markdown-rules/inline-rules.ts

@@ -0,0 +1,272 @@
+/**
+ * Inline markdown rules — matched against the Lezer AST.
+ *
+ * Covers: bold, italic, code, strikethrough, links,
+ *         page references, block references, tags, highlights.
+ *
+ * Each factory returns a MarkdownRule whose run() produces a token
+ * with pre-built decorationRanges in line-local coordinates.
+ * The engine shifts them to absolute document positions before use.
+ */
+
+import type { SyntaxNode } from "@lezer/common"
+import type {
+  BlockRefDecoration,
+  HighlightDecoration,
+  MarkdownRule,
+  PageRefDecoration,
+  ParseContext,
+  TagDecoration,
+  TokenDecoration,
+} from "./types"
+
+// ── Tree helpers ─────────────────────────────────────────────────────
+
+export function findChildByTypeName(
+  node: SyntaxNode,
+  typeName: string,
+): SyntaxNode | null {
+  const cursor = node.cursor()
+  if (!cursor.firstChild()) return null
+  do {
+    if (cursor.node.type.name === typeName) {
+      return cursor.node
+    }
+  } while (cursor.nextSibling())
+  return null
+}
+
+export function findChildrenByTypeName(
+  node: SyntaxNode,
+  typeName: string,
+): SyntaxNode[] {
+  const results: SyntaxNode[] = []
+  const cursor = node.cursor()
+  if (!cursor.firstChild()) return results
+  do {
+    if (cursor.node.type.name === typeName) {
+      results.push(cursor.node)
+    }
+  } while (cursor.nextSibling())
+  return results
+}
+
+// ── Inline rule factories ────────────────────────────────────────────
+
+export function createDelimitedRule(config: {
+  node: string
+  mark: string
+  type: string
+  className: string
+}): MarkdownRule<TokenDecoration> {
+  return {
+    name: config.type,
+    nodeTypes: [config.node],
+    match(node) {
+      return node.type.name === config.node
+    },
+    run(node) {
+      const marks = findChildrenByTypeName(node, config.mark)
+      if (marks.length < 2) return null
+      const opener = marks[0]
+      const closer = marks[marks.length - 1]
+      return {
+        type: config.type,
+        wrapperAttrs: { "data-md-type": config.type },
+        decorationRanges: [
+          { type: "hidden", from: opener.from, to: opener.to },
+          {
+            type: "content",
+            from: opener.to,
+            to: closer.from,
+            className: config.className,
+          },
+          { type: "hidden", from: closer.from, to: closer.to },
+        ],
+      }
+    },
+  }
+}
+
+export function createLinkRule(): MarkdownRule<TokenDecoration> {
+  return {
+    name: "link",
+    nodeTypes: ["Link"],
+    match(node) {
+      return node.type.name === "Link"
+    },
+    run(node) {
+      const linkMarks = findChildrenByTypeName(node, "LinkMark")
+      if (linkMarks.length < 2) return null
+      const url = findChildByTypeName(node, "URL")
+      if (!url) return null
+      const opener = linkMarks[0]
+      const closer = linkMarks[linkMarks.length - 1]
+      const textEnd = linkMarks[1]
+      return {
+        type: "link",
+        wrapperAttrs: { "data-md-type": "link" },
+        decorationRanges: [
+          { type: "hidden", from: opener.from, to: opener.to },
+          {
+            type: "content",
+            from: opener.to,
+            to: textEnd.from,
+            className: "md-link",
+          },
+          { type: "hidden", from: textEnd.from, to: closer.to },
+        ],
+      }
+    },
+  }
+}
+
+export function createPageRefRule(): MarkdownRule<PageRefDecoration> {
+  return {
+    name: "page-ref",
+    nodeTypes: ["PageRef"],
+    match(node) {
+      return node.type.name === "PageRef"
+    },
+    run(node, ctx) {
+      const { from, to } = node
+      const innerText = ctx.doc.slice(from + 2, to - 2)
+      const pipeIdx = innerText.indexOf("|")
+      const pageName = pipeIdx >= 0 ? innerText.slice(0, pipeIdx) : innerText
+      const alias = pipeIdx >= 0 ? innerText.slice(pipeIdx + 1) : undefined
+      return {
+        type: "page-ref",
+        pageName,
+        alias,
+        wrapperAttrs: {
+          "data-page-name": pageName,
+          ...(alias && { "data-alias": alias }),
+          role: "link",
+          tabindex: "0",
+        },
+        decorationRanges: [
+          { type: "hidden", from, to: from + 2 },
+          {
+            type: "content",
+            from: from + 2,
+            to: to - 2,
+            className: "md-page-ref",
+          },
+          { type: "hidden", from: to - 2, to },
+        ],
+      }
+    },
+  }
+}
+
+export function createBlockRefRule(): MarkdownRule<BlockRefDecoration> {
+  return {
+    name: "block-ref",
+    nodeTypes: ["BlockRef"],
+    match(node) {
+      return node.type.name === "BlockRef"
+    },
+    run(node, ctx) {
+      const { from, to } = node
+      const blockId = ctx.doc.slice(from + 2, to - 2)
+      return {
+        type: "block-ref",
+        blockId,
+        wrapperAttrs: { "data-block-id": blockId },
+        decorationRanges: [
+          { type: "hidden", from, to: from + 2 },
+          {
+            type: "content",
+            from: from + 2,
+            to: to - 2,
+            className: "md-block-ref",
+          },
+          { type: "hidden", from: to - 2, to },
+        ],
+      }
+    },
+  }
+}
+
+export function createTagRule(): MarkdownRule<TagDecoration> {
+  return {
+    name: "tag",
+    nodeTypes: ["Tag"],
+    match(node) {
+      return node.type.name === "Tag"
+    },
+    run(node, ctx: ParseContext) {
+      const { from, to } = node
+      const tag = ctx.doc.slice(from + 1, to)
+      return {
+        type: "tag",
+        tag,
+        wrapperAttrs: { "data-tag": tag },
+        decorationRanges: [{ type: "content", from, to, className: "md-tag" }],
+      }
+    },
+  }
+}
+
+export function createHighlightRule(): MarkdownRule<HighlightDecoration> {
+  return {
+    name: "highlight",
+    nodeTypes: ["Highlight"],
+    match(node) {
+      return node.type.name === "Highlight"
+    },
+    run(node) {
+      const { from, to } = node
+      return {
+        type: "highlight",
+        wrapperAttrs: { "data-md-type": "highlight" },
+        decorationRanges: [
+          { type: "hidden", from, to: from + 2 },
+          {
+            type: "content",
+            from: from + 2,
+            to: to - 2,
+            className: "md-highlight",
+          },
+          { type: "hidden", from: to - 2, to },
+        ],
+      }
+    },
+  }
+}
+
+// ── Default rule set ─────────────────────────────────────────────────
+
+export function createInlineRules(): MarkdownRule<unknown>[] {
+  return [
+    createDelimitedRule({
+      node: "StrongEmphasis",
+      mark: "EmphasisMark",
+      type: "strong",
+      className: "md-strong",
+    }),
+    createDelimitedRule({
+      node: "Emphasis",
+      mark: "EmphasisMark",
+      type: "em",
+      className: "md-em",
+    }),
+    createDelimitedRule({
+      node: "InlineCode",
+      mark: "CodeMark",
+      type: "code",
+      className: "md-code",
+    }),
+    createDelimitedRule({
+      node: "Strikethrough",
+      mark: "StrikethroughMark",
+      type: "strike",
+      className: "md-strike",
+    }),
+    createLinkRule(),
+    createPageRefRule(),
+    createBlockRefRule(),
+    createTagRule(),
+    createHighlightRule(),
+  ]
+}

packages/editor/src/lib/markdown-rules/types.ts

@@ -0,0 +1,136 @@
+/**
+ * Shared types for the markdown rule engine.
+ *
+ * Kept in a separate module so rules and the engine can all import
+ * from one place without creating circular dependencies.
+ */
+
+import type { SyntaxNode } from "@lezer/common"
+
+// ── Parse context ────────────────────────────────────────────────────
+
+export interface ParseContext {
+  doc: string
+  cursorPos?: number
+}
+
+// ── Decoration range ─────────────────────────────────────────────────
+
+export interface DecorationRange {
+  type: "hidden" | "content"
+  from: number
+  to: number
+  className?: string
+}
+
+// ── Token types ──────────────────────────────────────────────────────
+
+/**
+ * Base for all parsed tokens.
+ * Each rule supplies wrapperAttrs so the decoration builder never
+ * needs to type-switch on the token shape.
+ *
+ * `nodeWrapper` signals to the ProseMirror plugin that the entire text
+ * block should be wrapped in a node-level decoration (e.g. a callout
+ * card) so the whole block renders as one visual unit.  Only block-
+ * level tokens use this; inline tokens leave it empty.
+ */
+export interface ParsedToken {
+  type: string
+  decorationRanges: DecorationRange[]
+  wrapperAttrs?: Record<string, string>
+  nodeWrapper?: { className: string; attrs?: Record<string, string> }
+}
+
+export interface TokenDecoration extends ParsedToken {
+  type: string
+}
+
+export interface PageRefDecoration extends ParsedToken {
+  type: "page-ref"
+  pageName: string
+  alias?: string
+}
+
+export interface BlockRefDecoration extends ParsedToken {
+  type: "block-ref"
+  blockId: string
+}
+
+export interface TagDecoration extends ParsedToken {
+  type: "tag"
+  tag: string
+}
+
+export interface HighlightDecoration extends ParsedToken {
+  type: "highlight"
+}
+
+// ── Block decoration ─────────────────────────────────────────────────
+
+export type TaskState =
+  | "TODO"
+  | "DOING"
+  | "DONE"
+  | "LATER"
+  | "NOW"
+  | "WAITING"
+  | "CANCELLED"
+
+export type PriorityLevel = "A" | "B" | "C"
+export type CalloutType = "NOTE" | "WARNING" | "TIP" | "DANGER" | "INFO"
+
+export interface BlockDecoration extends ParsedToken {
+  type: "heading" | "task" | "blockquote" | "callout"
+  metadata?: {
+    level?: number
+    taskState?: TaskState
+    priority?: PriorityLevel
+    calloutType?: CalloutType
+    date?: string
+  }
+}
+
+// ── Property ─────────────────────────────────────────────────────────
+
+export interface PropertyInfo {
+  key: string
+  value: string
+  keyRange: [number, number]
+  delimiterRange: [number, number]
+  valueRange: [number, number]
+}
+
+// ── Parser output ────────────────────────────────────────────────────
+
+export interface ParsedDecorations {
+  content: (
+    | TokenDecoration
+    | PageRefDecoration
+    | BlockRefDecoration
+    | TagDecoration
+    | HighlightDecoration
+  )[]
+  properties: PropertyInfo[]
+  blocks: BlockDecoration[]
+}
+
+// ── Rule interfaces ──────────────────────────────────────────────────
+
+export interface MarkdownRule<T = unknown> {
+  name: string
+  nodeTypes?: string[]
+  match(node: SyntaxNode, ctx: ParseContext): boolean
+  run(node: SyntaxNode, ctx: ParseContext): T | null
+}
+
+// ── Block Rule ────────────────────────────────────────────────────────
+// Matches Lezer AST block nodes (e.g., Blockquote, Heading) and produces
+// BlockDecoration covering the full node range.
+
+export interface BlockRule {
+  name: string
+  nodeTypes: string[]
+  match(node: SyntaxNode, ctx: ParseContext): boolean
+  run(node: SyntaxNode, ctx: ParseContext): BlockDecoration | null
+}

packages/editor/src/lib/schema.ts

@@ -3,33 +3,25 @@
  *
  * Only contains structural nodes - no semantic marks (bold, italic, etc).
  * Markdown syntax is preserved as plain text and rendered via decorations.
- * Each Block.vue instance is exactly one <p>; newlines are hard_breaks.
+ * Each Block.vue instance is one or more <p> paragraphs; no hard_breaks.
  */
 import { type NodeSpec, Schema } from "prosemirror-model"
 
-type DOMNode = "doc" | "paragraph" | "hard_break" | "text"
+type DOMNode = "doc" | "paragraph" | "text"
 
 /** Node definitions */
 const nodes: Record<DOMNode, NodeSpec> = {
-  /** Root document container — exactly one paragraph per block */
+  /** Root document container — one or more paragraphs per block */
   doc: {
-    content: "block",
+    content: "block+",
   },
-  /** Paragraph — single paragraph per Block.vue instance */
+  /** Paragraph — one per line within a block */
   paragraph: {
     group: "block",
     content: "inline*",
     parseDOM: [{ tag: "p" }],
     toDOM: () => ["p", 0],
   },
-  /** Hard break (newline within paragraph) */
-  hard_break: {
-    group: "inline",
-    inline: true,
-    selectable: false,
-    parseDOM: [{ tag: "br" }],
-    toDOM: () => ["br"],
-  },
   /** Text content */
   text: {
     group: "inline",