refactor(editor): share durable block codecs

docs/ABSTRACTIONS.md

@@ -336,7 +336,7 @@ The renderer uses `viewOrdering` helpers to convert drag or command-palette move
 
 ## Command Surface
 
-`src/shared/appCommandManifest.json` is the cross-runtime source for stable app command IDs, menu structure, display labels, accelerators, deterministic shortcut QA metadata, and native menu enablement groups. The renderer imports it through `src/hooks/appCommandCatalog.ts`, which derives `APP_COMMAND_IDS`, shortcut lookup maps, Linux titlebar menu sections, native-menu command membership, and test helpers. Tauri includes the same JSON in `src-tauri/src/menu.rs` and uses it to build custom menu items, emit overridden menu item IDs such as the quick-open alias as their primary command IDs, and toggle state-dependent menu items from manifest groups.
+`src/shared/appCommandManifest.json` is the cross-runtime source for stable app command IDs, menu structure, display labels, accelerators, deterministic shortcut QA metadata, and native menu enablement groups. The renderer imports it through `src/hooks/appCommandCatalog.ts`, which derives `APP_COMMAND_IDS`, shortcut lookup maps, Linux titlebar menu sections, native-menu command membership, and test helpers. Tauri includes the same JSON in `src-tauri/src/menu.rs` and uses it to build custom menu items, emit overridden menu item IDs such as the quick-open alias as their primary command IDs, register the Windows main-window menu event bridge, and toggle state-dependent menu items from manifest groups.
 
 Domain command builders still own context-sensitive command-palette entries, availability, and execution callbacks. The manifest owns metadata that must stay identical across native menus, renderer shortcuts, deterministic QA bridges, and the Linux fallback menu; OS-native menu items such as Undo, Copy/Paste, Services, Quit, and Window controls remain local to the native menu implementation.
 
@@ -546,21 +546,22 @@ Defined in `src/utils/mathMarkdown.ts`, `src/components/editorSchema.tsx`, and s
 
 ### Mermaid Diagrams
 
-Defined in `src/utils/mermaidMarkdown.ts`, `src/components/MermaidDiagram.tsx`, `src/components/editorSchema.tsx`, and styled in `src/components/EditorTheme.css`:
+Defined in `src/utils/durableMarkdownBlocks.ts`, `src/utils/editorDurableMarkdown.ts`, `src/utils/mermaidMarkdown.ts`, `src/components/MermaidDiagram.tsx`, `src/components/editorSchema.tsx`, and styled in `src/components/EditorTheme.css`:
 
 - Fenced `mermaid` blocks become `mermaidBlock` schema nodes before BlockNote sees the Markdown body.
 - Each `mermaidBlock` stores the original fenced Markdown plus the diagram body, so raw-mode entry and saves can restore the canonical source instead of serializing generated SVG.
 - The rich editor renders diagrams with the `mermaid` package and uses the original source as an inline fallback when rendering fails.
-- `serializeMermaidAwareBlocks()` wraps the math-aware serializer so math, wikilinks, and diagrams share the same Markdown-first save path.
+- `serializeDurableEditorBlocks()` wraps the math-aware serializer so math, wikilinks, Mermaid diagrams, and whiteboards share the same Markdown-first save path.
 - The `/mermaid` slash command inserts a placeholder rectangle diagram using the same schema-backed Markdown storage path, avoiding an invalid empty diagram state.
 
 ### Tldraw Whiteboards
 
-Defined in `src/utils/tldrawMarkdown.ts`, `src/components/TldrawWhiteboard.tsx`, `src/components/editorSchema.tsx`, and styled in `src/components/EditorTheme.css`:
+Defined in `src/utils/durableMarkdownBlocks.ts`, `src/utils/editorDurableMarkdown.ts`, `src/utils/tldrawMarkdown.ts`, `src/components/TldrawWhiteboard.tsx`, `src/components/editorSchema.tsx`, and styled in `src/components/EditorTheme.css`:
 
 - Fenced `tldraw` blocks become `tldrawBlock` schema nodes before BlockNote sees the Markdown body.
 - Each `tldrawBlock` stores a stable `boardId` plus the tldraw document snapshot JSON. Session state such as camera, selected tool, and current selection is not persisted into the note.
 - The rich editor renders the block with the `tldraw` package and saves debounced document snapshot changes back into the block props, so normal Tolaria autosave writes the board into the `.md` file.
+- Mermaid and tldraw both register small codecs with the shared durable fenced-block pipeline; scanner, token, block injection, and mixed serialization mechanics live in one owner.
 - The `/whiteboard` slash command inserts an empty tldraw block using the same Markdown-durable storage path. Preview images are intentionally omitted; thumbnails can be added later as derived cache artifacts.
 
 ### Formatting Surface Policy
@@ -570,7 +571,7 @@ Defined in `src/components/tolariaEditorFormatting.tsx` and `src/components/tola
 - `SingleEditorView` disables BlockNote's default formatting toolbar, `/` menu, and side menu, then mounts Tolaria-owned controllers so the visible formatting surface matches Tolaria's markdown round-trip guarantees.
 - The formatting toolbar only exposes inline controls that persist through `blocksToMarkdownLossy()` in Tolaria's save pipeline: bold, italic, strike, nesting, and link creation. Controls that BlockNote can render temporarily but Tolaria cannot faithfully persist, such as underline, color, alignment, and the block-type dropdown, are hidden instead of appearing to work and later disappearing.
 - Tolaria's formatting-toolbar controller also keeps file/image actions mounted across the tiny hover gap between an image block and the floating toolbar, and while the toolbar itself is hovered, so image controls remain usable instead of collapsing mid-interaction.
-- `useEditorComposing` tracks `compositionstart` and `compositionend` events that target the BlockNote editor and closes the floating formatting toolbar while IME text is being composed, keeping CJK candidate windows unobstructed without changing normal selection toolbar behavior.
+- `useEditorComposing` tracks editor-owned IME composition events and closes the floating formatting toolbar during composition plus a short post-composition settle window, keeping CJK candidate windows unobstructed without changing normal selection toolbar behavior.
 - `useImageLightbox` listens for `dblclick` on the rich-editor container and opens `ImageLightbox` only when the event target resolves to a viewable BlockNote image. The target resolver handles media wrappers, ignores image captions/resize controls, missing sources, and tiny tracking-style images, preserving BlockNote's ordinary single-click image selection path.
 - The `/` slash menu remains the supported path for markdown-safe block transformations such as headings, quotes, list blocks, Mermaid diagrams, and whiteboards. Tolaria filters out BlockNote's toggle-heading and toggle-list variants because those do not map cleanly to the markdown note model.
 - The block-handle side menu keeps only actions that survive Tolaria's markdown round-trip. Delete and table-header toggles remain available; BlockNote's `Colors` submenu is removed because block colors are not part of Tolaria's supported markdown surface. Tolaria renders the add-block button outside the drag handle so the handle stays next to the block content. The side menu aligns itself to the first rendered text line for the hovered block, so H1/H2 typography, line-height, wrapping, and theme changes do not need per-heading offsets. Block reordering uses a Tolaria-owned pointer gesture and direct BlockNote block moves instead of HTML5 `DataTransfer`, keeping it independent from Tauri's native file-drop system. Block-handle actions re-resolve the current live BlockNote block before mutating or dragging, so note reloads and sync churn cannot leave controls acting on stale block references.
@@ -585,16 +586,15 @@ Defined in `src/components/tolariaEditorFormatting.tsx` and `src/components/tola
 ```mermaid
 flowchart LR
     A["📄 Raw markdown\n(from disk)"] --> B["splitFrontmatter()\n→ yaml + body"]
-    B --> C["preProcessTldrawMarkdown(body)\ntldraw fence → token"]
-    C --> D["preProcessMermaidMarkdown(body)\nmermaid fence → token"]
-    D --> E["preProcessWikilinks(body)\n[[target]] → ‹token›"]
-    E --> F["preProcessMathMarkdown(body)\n$...$ / $$...$$ → tokens"]
-    F --> G["tryParseMarkdownToBlocks()\n→ BlockNote block tree"]
-    G --> H["injectWikilinks + injectMathInBlocks + injectMermaidInBlocks + injectTldrawInBlocks\n tokens → schema nodes"]
-    H --> I["editor.replaceBlocks()\n→ rendered editor"]
+    B --> C["preProcessDurableEditorMarkdown(body)\nmermaid/tldraw fences → tokens"]
+    C --> D["preProcessWikilinks(body)\n[[target]] → ‹token›"]
+    D --> E["preProcessMathMarkdown(body)\n$...$ / $$...$$ → tokens"]
+    E --> F["tryParseMarkdownToBlocks()\n→ BlockNote block tree"]
+    F --> G["injectWikilinks + injectMathInBlocks + injectDurableEditorMarkdownBlocks\n tokens → schema nodes"]
+    G --> H["editor.replaceBlocks()\n→ rendered editor"]
 
     style A fill:#f8f9fa,stroke:#6c757d,color:#000
-    style I fill:#d4edda,stroke:#28a745,color:#000
+    style H fill:#d4edda,stroke:#28a745,color:#000
 ```
 
 > Wikilink placeholder tokens use `\u2039` and `\u203A`; math, Mermaid, and tldraw placeholder tokens use ASCII sentinels with URI-encoded payloads.
@@ -604,7 +604,7 @@ flowchart LR
 ```mermaid
 flowchart LR
     A["✏️ BlockNote blocks\n(editor state)"] --> B["blocksToMarkdownLossy()"]
-    B --> C["restoreWikilinks + serializeMermaidAwareBlocks()\nschema nodes → Markdown source"]
+    B --> C["restoreWikilinks + serializeDurableEditorBlocks()\nschema nodes → Markdown source"]
     C --> D["prepend frontmatter yaml"]
     D --> E["invoke('save_note_content')\n→ disk write"]
 
@@ -796,7 +796,7 @@ interface Settings {
 }
 ```
 
-Managed by `useSettings` hook and `SettingsPanel` component. `theme_mode` is installation-local because it controls device comfort rather than vault structure; the Settings panel and command-palette light/dark actions both update that same value. `ui_language` is also installation-local: `null` follows the supported system language with English fallback, while explicit values pin the UI language for this installation. Stored legacy aliases such as `zh-Hans` are normalized to canonical locale codes before the setting reaches React state. `note_width_mode` is the installation-local default for rich-editor note width; individual notes can override it with `_width` when they already have frontmatter. `default_ai_agent` remains the legacy installation-local CLI fallback. `default_ai_target` is the active AI target used by the AI panel and status bar; it can point at a coding agent or a configured direct model. `ai_model_providers` stores non-secret provider metadata for local/API model targets, while hosted API keys live in Tolaria's local app-data secrets file or user-managed environment variables instead of being persisted in app settings. `hide_gitignored_files` is also installation-local and defaults to `true`; changing it reloads entries, search, saved views, and folders without restarting. The `all_notes_show_pdfs`, `all_notes_show_images`, and `all_notes_show_unsupported` flags are installation-local All Notes category toggles that default off and update the list/counts without changing vault files. The AutoGit fields are also installation-local: `useAutoGit` consumes them to schedule automatic checkpoints, while `useCommitFlow` and the status bar quick action reuse the same checkpoint runner and deterministic automatic commit message generation.
+Managed by `useSettings` hook and `SettingsPanel` component. `theme_mode` is installation-local because it controls device comfort rather than vault structure; the Settings panel and command-palette light/dark actions both update that same value. `ui_language` is also installation-local: `null` follows the supported system language with English fallback, while explicit values pin the UI language for this installation. Stored legacy aliases such as `zh-Hans` are normalized to canonical locale codes before the setting reaches React state. `note_width_mode` is the installation-local default for rich-editor note width; individual notes can override it with `_width` when they already have frontmatter. `default_ai_agent` remains the legacy installation-local CLI fallback. `default_ai_target` is the active AI target used by the AI panel and status bar; it can point at a coding agent or a configured direct model. `ai_model_providers` stores non-secret provider metadata for local/API model targets, while hosted API keys live in Tolaria's local app-data secrets file or user-managed environment variables instead of being persisted in app settings. Provider defaults and local/API grouping come from the shared `src/shared/aiModelProviderCatalog.json` catalog used by both renderer settings and the Tauri direct-model runtime. `hide_gitignored_files` is also installation-local and defaults to `true`; changing it reloads entries, search, saved views, and folders without restarting. The `all_notes_show_pdfs`, `all_notes_show_images`, and `all_notes_show_unsupported` flags are installation-local All Notes category toggles that default off and update the list/counts without changing vault files. The AutoGit fields are also installation-local: `useAutoGit` consumes them to schedule automatic checkpoints, while `useCommitFlow` and the status bar quick action reuse the same checkpoint runner and deterministic automatic commit message generation.
 
 ## Telemetry
 

docs/ARCHITECTURE.md

@@ -217,7 +217,7 @@ The main Tauri window also persists its last normal size and screen position in
 
 Tauri setup keeps launch-time filesystem and subprocess work off the window creation critical path. Legacy `~/Laputa` housekeeping and the initial persisted-vault MCP bridge sync run on named background threads, so large legacy vaults, stale active-vault paths, or slow process startup cannot beachball the macOS app before React mounts. React still resyncs the bridge from `useVaultSwitcher` after the persisted selection loads, and no selected vault stops the bridge. The HTML bootstrap also installs a Tauri-only one-shot watchdog: React reports readiness from an effect after the root commits, and if that readiness signal never arrives the WebView reloads once instead of leaving macOS users in an inert rendered shell.
 
-Linux uses custom React-rendered window chrome instead of the native Tauri menu bar. `setup_linux_window_chrome()` drops server-side decorations on the main window, `openNoteInNewWindow()` does the same for detached note windows, and `LinuxTitlebar`/`LinuxMenuButton` route both window controls and menu actions back through the same shared command pipeline that the desktop native menus use. The native app menu keeps macOS-only Services/Hide entries off Windows and Linux, while cross-platform custom items such as Check for Updates emit Tolaria command IDs and show visible updater feedback.
+Linux uses custom React-rendered window chrome instead of the native Tauri menu bar. `setup_linux_window_chrome()` drops server-side decorations on the main window, `openNoteInNewWindow()` does the same for detached note windows, and `LinuxTitlebar`/`LinuxMenuButton` route both window controls and menu actions back through the same shared command pipeline that the desktop native menus use. The native app menu keeps macOS-only Services/Hide entries off Windows and Linux, registers a window-scoped menu event handler on Windows where Tauri delivers menu clicks through the main `WebviewWindow`, and cross-platform custom items such as Check for Updates emit Tolaria command IDs with visible updater feedback.
 When Tolaria is launched from a Linux AppImage, `run()` also applies AppImage-only WebKitGTK startup safeguards without changing native package installs. It injects `WEBKIT_DISABLE_DMABUF_RENDERER=1` and `WEBKIT_DISABLE_COMPOSITING_MODE=1` independently unless the user already set either variable, and on Wayland sessions it re-execs once with the first architecture-matching system `libwayland-client.so` in `LD_PRELOAD` when the user has not provided their own preload. The candidate order prefers Fedora-style `lib64` and Debian-style `x86_64-linux-gnu` paths before generic `/usr/lib`, and the ELF header is checked so a 64-bit Tolaria process does not retry with a 32-bit Wayland client library. The same AppImage path checks whether `fc-match` resolves the default emoji font to `Noto-COLRv1.ttf`; when the user has not provided `FONTCONFIG_FILE` or `FONTCONFIG_PATH`, Tolaria writes a cache-local fontconfig file that rejects only that matched font file and exports it before WebKit starts. The rendering overrides keep AppImage WebViews from blanking after accelerated compositing/DMA-BUF failures, the re-exec addresses AppImage library-order failures that can surface as `Could not create default EGL display: EGL_BAD_PARAMETER`, and the fontconfig guard avoids known WebKit crashes in COLRv1 emoji font rendering while leaving other emoji fonts available.
 
 ## Multi-Window (Note Windows)
@@ -311,7 +311,7 @@ Large active notes are compacted into a head/tail body snapshot before they ente
 
 ### Direct Model Targets
 
-Tolaria also supports direct model targets for local servers and API providers. These targets are stored as app-level provider metadata and can be selected in Settings or the status bar alongside coding agents. Direct model targets run in Chat mode: they receive the same note-context snapshot and conversation history, but they do not receive vault-write tools or shell access. The backend `stream_ai_model` command supports OpenAI-compatible chat completions and Anthropic Messages-compatible calls, including Ollama, LM Studio, OpenRouter, OpenAI, Anthropic, Gemini, and custom compatible endpoints.
+Tolaria also supports direct model targets for local servers and API providers. These targets are stored as app-level provider metadata and can be selected in Settings or the status bar alongside coding agents. `src/shared/aiModelProviderCatalog.json` is the shared source for provider defaults, local/API grouping, API-key environment placeholders, and runtime fallback base URLs; the renderer imports it through `aiTargets.ts`, and Tauri includes the same JSON in `ai_models.rs`. Direct model targets run in Chat mode: they receive the same note-context snapshot and conversation history, but they do not receive vault-write tools or shell access. The backend `stream_ai_model` command supports OpenAI-compatible chat completions and Anthropic Messages-compatible calls, including Ollama, LM Studio, OpenRouter, OpenAI, Anthropic, Gemini, and custom compatible endpoints.
 
 Provider secrets are not written to `settings.json`. Hosted API targets can use Tolaria's local app-data secrets file (`ai-provider-secrets.json`, outside vaults/worktrees and owner-only on Unix) or reference an environment variable name. Local endpoints can omit authentication.
 
@@ -579,9 +579,10 @@ sequenceDiagram
     A->>T: invoke('get_note_content')
     T-->>A: raw markdown
     A->>A: splitFrontmatter → [yaml, body]
+    A->>A: preProcessDurableEditorMarkdown(body)
     A->>A: preProcessWikilinks(body)
     A->>A: tryParseMarkdownToBlocks()
-    A->>A: injectWikilinks(blocks)
+    A->>A: injectWikilinks + injectDurableEditorMarkdownBlocks(blocks)
     A-->>U: Editor renders note
 ```
 
@@ -869,7 +870,7 @@ Shortcut routing is explicit:
 - macOS browser-reserved chords such as `Cmd+O`, `Cmd+F`, and `Cmd+Shift+L` are unblocked at webview init via `tauri-plugin-prevent-default`, then continue through the same renderer-first command path
 - `Cmd+Shift+V` uses the same command path for "Paste without Formatting"; `plainTextPaste.ts` reads text through the native clipboard command in Tauri and inserts it through the active rich/raw editor target or the focused browser text control
 - `Cmd+F` is surface-aware: editor focus opens current-note find/replace in raw CodeMirror, note-list focus preserves note-list search, and native menu enablement follows focus availability events so only one `Cmd+F` menu item is active
-- `menu.rs`, `useMenuEvents`, and Linux's `LinuxMenuButton` emit the same manifest-derived command IDs for native menu clicks, accelerators, and custom titlebar menu actions
+- `menu.rs`, `useMenuEvents`, and Linux's `LinuxMenuButton` emit the same manifest-derived command IDs for native menu clicks, accelerators, and custom titlebar menu actions; on Windows, `menu.rs` also listens to main-window menu events because Tauri attaches the native menu to the `WebviewWindow`
 - `appCommandDispatcher.ts` suppresses the paired native-menu/renderer echo from a single shortcut so the command runs once
 - Deterministic QA uses two explicit proof paths from the shared manifest:
   - renderer shortcut-event proof through `window.__laputaTest.triggerShortcutCommand()`

docs/GETTING-STARTED.md

@@ -364,7 +364,7 @@ type SidebarSelection =
 
 ### Command Registry
 
-`useCommandRegistry` + `useAppCommands` build a centralized command registry. Commands are registered with labels, shortcuts, and handlers. The `CommandPalette` (Cmd+K) fuzzy-searches this registry. Settings commands can update installation-local preferences directly when they reuse an existing settings path, such as the light/dark theme-mode actions writing `settings.theme_mode`. Shortcut combos live in `appCommandCatalog.ts`; real keypresses always flow through `useAppKeyboard`, native menu clicks emit the same command IDs through `useMenuEvents`, and `appCommandDispatcher.ts` suppresses the duplicate native/renderer echo from a single shortcut. Plain-text paste follows this same path: the command owns `Cmd+Shift+V`, the menu and palette expose the same action, and `plainTextPaste.ts` resolves the active rich/raw editor target or focused text control before reading clipboard text. On macOS, any browser-reserved chord that WKWebView swallows before that path must also be added to the narrow `tauri-plugin-prevent-default` registration in `src-tauri/src/lib.rs`. On Linux, `LinuxTitlebar.tsx` and `LinuxMenuButton.tsx` reuse the same command IDs through `trigger_menu_command` because the native GTK menu bar is intentionally not mounted. The same shortcut manifest also declares the deterministic QA mode for each shortcut-capable command.
+`useCommandRegistry` + `useAppCommands` build a centralized command registry. Commands are registered with labels, shortcuts, and handlers. The `CommandPalette` (Cmd+K) fuzzy-searches this registry. Settings commands can update installation-local preferences directly when they reuse an existing settings path, such as the light/dark theme-mode actions writing `settings.theme_mode`. Shortcut combos live in `appCommandCatalog.ts`; real keypresses always flow through `useAppKeyboard`, native menu clicks emit the same command IDs through `useMenuEvents`, and `appCommandDispatcher.ts` suppresses the duplicate native/renderer echo from a single shortcut. Plain-text paste follows this same path: the command owns `Cmd+Shift+V`, the menu and palette expose the same action, and `plainTextPaste.ts` resolves the active rich/raw editor target or focused text control before reading clipboard text. On macOS, any browser-reserved chord that WKWebView swallows before that path must also be added to the narrow `tauri-plugin-prevent-default` registration in `src-tauri/src/lib.rs`. On Windows, native menu clicks arrive from the main `WebviewWindow`, so `src-tauri/src/menu.rs` must keep its window-scoped menu event handler in addition to the app-level handler. On Linux, `LinuxTitlebar.tsx` and `LinuxMenuButton.tsx` reuse the same command IDs through `trigger_menu_command` because the native GTK menu bar is intentionally not mounted. The same shortcut manifest also declares the deterministic QA mode for each shortcut-capable command.
 
 Commands whose availability depends on the current note or Git state must also flow through `update_menu_state` so the native menu stays in sync with the command palette. The deleted-note restore action in Changes view is the reference example: the row opens a deleted diff preview, the command palette exposes "Restore Deleted Note", and the Note menu enables the same action only while that preview is active.
 

pnpm-lock.yaml

@@ -16,7 +16,7 @@ overrides:
 
 patchedDependencies:
   '@blocknote/core@0.46.2':
-    hash: 93736b5b6fa4b9d257d510af50da44c5192f3e3115dfb9548a11f1a4865027e4
+    hash: c93b0eab9c8a1800cc1489627146cbe9037999f409efcc8234b33f670d2ccf8d
     path: patches/@blocknote__core@0.46.2.patch
   '@blocknote/react@0.46.2':
     hash: e09f7011df33f4ff92c0d3fd8c9060e62f08997d076f3e438e1e82f8c1ab2f76
@@ -37,10 +37,10 @@ importers:
         version: 0.78.0(zod@4.3.6)
       '@blocknote/code-block':
         specifier: ^0.46.2
-        version: 0.46.2(@blocknote/core@0.46.2(patch_hash=93736b5b6fa4b9d257d510af50da44c5192f3e3115dfb9548a11f1a4865027e4)(@types/hast@3.0.4)(highlight.js@11.11.1)(lowlight@3.3.0))
+        version: 0.46.2(@blocknote/core@0.46.2(patch_hash=c93b0eab9c8a1800cc1489627146cbe9037999f409efcc8234b33f670d2ccf8d)(@types/hast@3.0.4)(highlight.js@11.11.1)(lowlight@3.3.0))
       '@blocknote/core':
         specifier: ^0.46.2
-        version: 0.46.2(patch_hash=93736b5b6fa4b9d257d510af50da44c5192f3e3115dfb9548a11f1a4865027e4)(@types/hast@3.0.4)(highlight.js@11.11.1)(lowlight@3.3.0)
+        version: 0.46.2(patch_hash=c93b0eab9c8a1800cc1489627146cbe9037999f409efcc8234b33f670d2ccf8d)(@types/hast@3.0.4)(highlight.js@11.11.1)(lowlight@3.3.0)
       '@blocknote/mantine':
         specifier: ^0.46.2
         version: 0.46.2(@floating-ui/dom@1.7.5)(@mantine/core@8.3.14(@mantine/hooks@8.3.14(react@19.2.4))(@types/react@19.2.14)(react-dom@19.2.4(react@19.2.4))(react@19.2.4))(@mantine/hooks@8.3.14(react@19.2.4))(@mantine/utils@6.0.22(react@19.2.4))(@types/hast@3.0.4)(@types/react-dom@19.2.3(@types/react@19.2.14))(@types/react@19.2.14)(highlight.js@11.11.1)(lowlight@3.3.0)(react-dom@19.2.4(react@19.2.4))(react@19.2.4)
@@ -5608,9 +5608,9 @@ snapshots:
 
   '@bcoe/v8-coverage@1.0.2': {}
 
-  '@blocknote/code-block@0.46.2(@blocknote/core@0.46.2(patch_hash=93736b5b6fa4b9d257d510af50da44c5192f3e3115dfb9548a11f1a4865027e4)(@types/hast@3.0.4)(highlight.js@11.11.1)(lowlight@3.3.0))':
+  '@blocknote/code-block@0.46.2(@blocknote/core@0.46.2(patch_hash=c93b0eab9c8a1800cc1489627146cbe9037999f409efcc8234b33f670d2ccf8d)(@types/hast@3.0.4)(highlight.js@11.11.1)(lowlight@3.3.0))':
     dependencies:
-      '@blocknote/core': 0.46.2(patch_hash=93736b5b6fa4b9d257d510af50da44c5192f3e3115dfb9548a11f1a4865027e4)(@types/hast@3.0.4)(highlight.js@11.11.1)(lowlight@3.3.0)
+      '@blocknote/core': 0.46.2(patch_hash=c93b0eab9c8a1800cc1489627146cbe9037999f409efcc8234b33f670d2ccf8d)(@types/hast@3.0.4)(highlight.js@11.11.1)(lowlight@3.3.0)
       '@shikijs/core': 3.23.0
       '@shikijs/engine-javascript': 3.23.0
       '@shikijs/langs': 3.23.0
@@ -5618,7 +5618,7 @@ snapshots:
       '@shikijs/themes': 3.23.0
       '@shikijs/types': 3.22.0
 
-  '@blocknote/core@0.46.2(patch_hash=93736b5b6fa4b9d257d510af50da44c5192f3e3115dfb9548a11f1a4865027e4)(@types/hast@3.0.4)(highlight.js@11.11.1)(lowlight@3.3.0)':
+  '@blocknote/core@0.46.2(patch_hash=c93b0eab9c8a1800cc1489627146cbe9037999f409efcc8234b33f670d2ccf8d)(@types/hast@3.0.4)(highlight.js@11.11.1)(lowlight@3.3.0)':
     dependencies:
       '@emoji-mart/data': 1.2.1
       '@handlewithcare/prosemirror-inputrules': 0.1.4(prosemirror-model@1.25.4)(prosemirror-state@1.4.4)(prosemirror-view@1.41.6)
@@ -5670,7 +5670,7 @@ snapshots:
 
   '@blocknote/mantine@0.46.2(@floating-ui/dom@1.7.5)(@mantine/core@8.3.14(@mantine/hooks@8.3.14(react@19.2.4))(@types/react@19.2.14)(react-dom@19.2.4(react@19.2.4))(react@19.2.4))(@mantine/hooks@8.3.14(react@19.2.4))(@mantine/utils@6.0.22(react@19.2.4))(@types/hast@3.0.4)(@types/react-dom@19.2.3(@types/react@19.2.14))(@types/react@19.2.14)(highlight.js@11.11.1)(lowlight@3.3.0)(react-dom@19.2.4(react@19.2.4))(react@19.2.4)':
     dependencies:
-      '@blocknote/core': 0.46.2(patch_hash=93736b5b6fa4b9d257d510af50da44c5192f3e3115dfb9548a11f1a4865027e4)(@types/hast@3.0.4)(highlight.js@11.11.1)(lowlight@3.3.0)
+      '@blocknote/core': 0.46.2(patch_hash=c93b0eab9c8a1800cc1489627146cbe9037999f409efcc8234b33f670d2ccf8d)(@types/hast@3.0.4)(highlight.js@11.11.1)(lowlight@3.3.0)
       '@blocknote/react': 0.46.2(patch_hash=e09f7011df33f4ff92c0d3fd8c9060e62f08997d076f3e438e1e82f8c1ab2f76)(@floating-ui/dom@1.7.5)(@types/hast@3.0.4)(@types/react-dom@19.2.3(@types/react@19.2.14))(@types/react@19.2.14)(highlight.js@11.11.1)(lowlight@3.3.0)(react-dom@19.2.4(react@19.2.4))(react@19.2.4)
       '@mantine/core': 8.3.14(@mantine/hooks@8.3.14(react@19.2.4))(@types/react@19.2.14)(react-dom@19.2.4(react@19.2.4))(react@19.2.4)
       '@mantine/hooks': 8.3.14(react@19.2.4)
@@ -5692,7 +5692,7 @@ snapshots:
 
   '@blocknote/react@0.46.2(patch_hash=e09f7011df33f4ff92c0d3fd8c9060e62f08997d076f3e438e1e82f8c1ab2f76)(@floating-ui/dom@1.7.5)(@types/hast@3.0.4)(@types/react-dom@19.2.3(@types/react@19.2.14))(@types/react@19.2.14)(highlight.js@11.11.1)(lowlight@3.3.0)(react-dom@19.2.4(react@19.2.4))(react@19.2.4)':
     dependencies:
-      '@blocknote/core': 0.46.2(patch_hash=93736b5b6fa4b9d257d510af50da44c5192f3e3115dfb9548a11f1a4865027e4)(@types/hast@3.0.4)(highlight.js@11.11.1)(lowlight@3.3.0)
+      '@blocknote/core': 0.46.2(patch_hash=c93b0eab9c8a1800cc1489627146cbe9037999f409efcc8234b33f670d2ccf8d)(@types/hast@3.0.4)(highlight.js@11.11.1)(lowlight@3.3.0)
       '@emoji-mart/data': 1.2.1
       '@floating-ui/react': 0.27.17(react-dom@19.2.4(react@19.2.4))(react@19.2.4)
       '@floating-ui/utils': 0.2.10

src-tauri/src/ai_models.rs

@@ -3,6 +3,7 @@ use serde::{Deserialize, Serialize};
 use std::collections::BTreeMap;
 use std::fs;
 use std::path::Path;
+use std::sync::OnceLock;
 
 #[derive(Debug, Clone, Deserialize, Serialize, PartialEq, Eq)]
 #[serde(rename_all = "snake_case")]
@@ -70,11 +71,35 @@ pub struct AiModelProviderTestRequest {
     pub api_key_override: Option<String>,
 }
 
+#[derive(Debug, Clone, Deserialize)]
+struct AiModelProviderCatalogEntry {
+    kind: AiModelProviderKind,
+    runtime_base_url: Option<String>,
+}
+
 #[derive(Debug, Clone, Default, Deserialize, Serialize, PartialEq, Eq)]
 struct AiProviderSecrets {
     provider_api_keys: BTreeMap<String, String>,
 }
 
+static AI_MODEL_PROVIDER_CATALOG: OnceLock<Vec<AiModelProviderCatalogEntry>> = OnceLock::new();
+
+fn provider_catalog() -> &'static [AiModelProviderCatalogEntry] {
+    AI_MODEL_PROVIDER_CATALOG
+        .get_or_init(|| {
+            serde_json::from_str(include_str!("../../src/shared/aiModelProviderCatalog.json"))
+                .expect("bundled AI model provider catalog must be valid JSON")
+        })
+        .as_slice()
+}
+
+fn provider_default_base_url(kind: &AiModelProviderKind) -> Option<&'static str> {
+    provider_catalog()
+        .iter()
+        .find(|entry| entry.kind == *kind)
+        .and_then(|entry| entry.runtime_base_url.as_deref())
+}
+
 pub fn normalize_ai_model_providers(
     providers: Option<Vec<AiModelProvider>>,
 ) -> Option<Vec<AiModelProvider>> {
@@ -211,15 +236,7 @@ fn selected_max_tokens(request: &AiModelStreamRequest) -> u32 {
 }
 
 fn normalized_base_url(request: &AiModelStreamRequest) -> Result<String, String> {
-    let fallback = match request.provider.kind {
-        AiModelProviderKind::OpenAi => "https://api.openai.com/v1",
-        AiModelProviderKind::Anthropic => "https://api.anthropic.com/v1",
-        AiModelProviderKind::OpenRouter => "https://openrouter.ai/api/v1",
-        AiModelProviderKind::Gemini => "https://generativelanguage.googleapis.com/v1beta/openai",
-        AiModelProviderKind::Ollama => "http://localhost:11434/v1",
-        AiModelProviderKind::LmStudio => "http://127.0.0.1:1234/v1",
-        AiModelProviderKind::OpenAiCompatible => "",
-    };
+    let fallback = provider_default_base_url(&request.provider.kind).unwrap_or("");
     let base = request
         .provider
         .base_url
@@ -588,6 +605,22 @@ mod tests {
         assert_eq!(headers, vec![("X-Demo", "demo")]);
     }
 
+    #[test]
+    fn shared_provider_catalog_supplies_runtime_base_urls() {
+        assert_eq!(
+            provider_default_base_url(&AiModelProviderKind::OpenAi),
+            Some("https://api.openai.com/v1")
+        );
+        assert_eq!(
+            provider_default_base_url(&AiModelProviderKind::Ollama),
+            Some("http://localhost:11434/v1")
+        );
+        assert_eq!(
+            provider_default_base_url(&AiModelProviderKind::OpenAiCompatible),
+            None
+        );
+    }
+
     #[test]
     fn custom_provider_requires_base_url() {
         let mut provider = provider(AiModelProviderKind::OpenAiCompatible);

src-tauri/src/menu.rs

@@ -1,9 +1,13 @@
+#[cfg(not(target_os = "macos"))]
+use crate::window_state::MAIN_WINDOW_LABEL;
 use serde::{Deserialize, Deserializer};
 use std::{
     collections::{BTreeMap, HashSet},
     error::Error,
     sync::OnceLock,
 };
+#[cfg(not(target_os = "macos"))]
+use tauri::{menu::MenuEvent, Manager};
 use tauri::{
     menu::{MenuBuilder, MenuItem, MenuItemBuilder, MenuItemKind, Submenu, SubmenuBuilder},
     App, AppHandle, Emitter,
@@ -234,6 +238,10 @@ fn app_menu_includes_services(target_os: &str) -> bool {
     target_os == "macos"
 }
 
+fn window_menu_event_handler_required(target_os: &str) -> bool {
+    target_os != "macos"
+}
+
 fn build_manifest_menu_item(
     app: &App,
     item: &ManifestMenuItem,
@@ -383,6 +391,28 @@ pub fn setup_menu(app: &App) -> Result<(), Box<dyn Error>> {
         let _ = emit_custom_menu_event(app_handle, id);
     });
 
+    register_window_menu_event_handler(app)?;
+
+    Ok(())
+}
+
+#[cfg(not(target_os = "macos"))]
+fn register_window_menu_event_handler(app: &App) -> Result<(), Box<dyn Error>> {
+    debug_assert!(window_menu_event_handler_required(std::env::consts::OS));
+    let window = app.get_webview_window(MAIN_WINDOW_LABEL).ok_or_else(|| {
+        format!("setup_menu: window '{MAIN_WINDOW_LABEL}' not found; menu events will not fire")
+    })?;
+    let app_handle = app.handle().clone();
+    window.on_menu_event(move |_window, event: MenuEvent| {
+        let id = event.id().0.as_str();
+        let _ = emit_custom_menu_event(&app_handle, id);
+    });
+    Ok(())
+}
+
+#[cfg(target_os = "macos")]
+fn register_window_menu_event_handler(_app: &App) -> Result<(), Box<dyn Error>> {
+    debug_assert!(!window_menu_event_handler_required(std::env::consts::OS));
     Ok(())
 }
 
@@ -564,4 +594,11 @@ mod tests {
         assert!(!app_menu_includes_services("windows"));
         assert!(!app_menu_includes_services("linux"));
     }
+
+    #[test]
+    fn window_menu_event_handler_is_required_off_macos() {
+        assert!(!window_menu_event_handler_required("macos"));
+        assert!(window_menu_event_handler_required("windows"));
+        assert!(window_menu_event_handler_required("linux"));
+    }
 }

src-tauri/src/window_state.rs

@@ -7,7 +7,7 @@ use tauri::{
     WindowEvent,
 };
 
-const MAIN_WINDOW_LABEL: &str = "main";
+pub(crate) const MAIN_WINDOW_LABEL: &str = "main";
 const WINDOW_STATE_FILE: &str = "window-state.json";
 const MIN_WINDOW_WIDTH: u32 = 480;
 const MIN_WINDOW_HEIGHT: u32 = 400;

src/App.test.tsx

@@ -654,6 +654,39 @@ describe('App', () => {
     })
   })
 
+  it('shows immediate feedback while a menu-driven update check is pending', async () => {
+    let resolveUpdate: ((result: { kind: 'up-to-date' }) => void) | null = null
+    const checkForUpdates = vi.fn(() => new Promise<{ kind: 'up-to-date' }>((resolve) => {
+      resolveUpdate = resolve
+    }))
+    vi.mocked(useUpdater).mockReturnValue(createMockUpdaterResult(checkForUpdates))
+
+    render(<App />)
+
+    await waitFor(() => {
+      expect(screen.getByText('All Notes')).toBeInTheDocument()
+      expect(typeof window.__laputaTest?.dispatchBrowserMenuCommand).toBe('function')
+    })
+
+    act(() => {
+      window.__laputaTest?.dispatchBrowserMenuCommand?.('app-check-for-updates')
+    })
+
+    await waitFor(() => {
+      expect(screen.getByText('Checking for updates...')).toBeInTheDocument()
+    })
+    expect(checkForUpdates).toHaveBeenCalledOnce()
+
+    await act(async () => {
+      resolveUpdate?.({ kind: 'up-to-date' })
+      await Promise.resolve()
+    })
+
+    await waitFor(() => {
+      expect(screen.getByText('No newer stable update is available right now')).toBeInTheDocument()
+    })
+  })
+
   it('shows the external AI setup dialog from the menu when AI onboarding is active', async () => {
     localStorage.removeItem(AI_AGENTS_ONBOARDING_DISMISSED_KEY)
     localStorage.removeItem(CLAUDE_CODE_ONBOARDING_DISMISSED_KEY)

src/App.tsx

@@ -101,6 +101,7 @@ import {
   getBrowserLanguagePreferences,
   resolveEffectiveLocale,
   serializeUiLanguagePreference,
+  translate,
   type UiLanguagePreference,
 } from './lib/i18n'
 import { normalizeReleaseChannel } from './lib/releaseChannel'
@@ -1280,6 +1281,7 @@ function App() {
       await restartApp()
       return
     }
+    setToastMessage(translate(appLocale, 'update.checking'))
     const result = await updateActions.checkForUpdates()
     if (result.kind === 'up-to-date') {
       const checkedChannel = normalizeReleaseChannel(settings.release_channel)
@@ -1289,7 +1291,7 @@ function App() {
     } else {
       setToastMessage(result.message)
     }
-  }, [settings.release_channel, updateActions, updateStatus.state, setToastMessage])
+  }, [appLocale, settings.release_channel, updateActions, updateStatus.state, setToastMessage])
 
   const handleRepairVault = useCallback(async () => {
     if (!resolvedPath) return

src/components/AiProviderSettings.tsx

@@ -1,9 +1,12 @@
 import { useState } from 'react'
 import {
   DEFAULT_MODEL_CAPABILITIES,
+  aiModelProviderCatalog,
+  aiModelProviderCatalogEntry,
   configuredModelTargets,
   isLocalAiProvider,
   normalizeAiModelProviders,
+  type AiModelApiKeyStorage,
   type AiModelProvider,
   type AiModelProviderKind,
 } from '../lib/aiTargets'
@@ -21,7 +24,6 @@ import {
 
 type Translate = ReturnType<typeof createTranslator>
 type ProviderMode = 'local' | 'api'
-type ApiKeyStorage = 'none' | 'local_file' | 'env'
 type TestState = 'idle' | 'testing' | 'success'
 
 interface AiProviderSettingsProps {
@@ -36,67 +38,52 @@ interface ProviderDraft {
   name: string
   baseUrl: string
   modelId: string
-  apiKeyStorage: ApiKeyStorage
+  apiKeyStorage: AiModelApiKeyStorage
   apiKey: string
   apiKeyEnvVar: string
 }
 
-const LOCAL_PROVIDER_KINDS: AiModelProviderKind[] = ['ollama', 'lm_studio']
-const API_PROVIDER_KINDS: AiModelProviderKind[] = ['open_ai', 'anthropic', 'gemini', 'open_router', 'open_ai_compatible']
-
-const PROVIDER_PRESETS: Record<AiModelProviderKind, { name: string; baseUrl: string }> = {
-  ollama: { name: 'Ollama', baseUrl: 'http://localhost:11434/v1' },
-  lm_studio: { name: 'LM Studio', baseUrl: 'http://127.0.0.1:1234/v1' },
-  open_ai: { name: 'OpenAI', baseUrl: 'https://api.openai.com/v1' },
-  anthropic: { name: 'Anthropic', baseUrl: 'https://api.anthropic.com/v1' },
-  gemini: { name: 'Gemini', baseUrl: 'https://generativelanguage.googleapis.com/v1beta/openai' },
-  open_router: { name: 'OpenRouter', baseUrl: 'https://openrouter.ai/api/v1' },
-  open_ai_compatible: { name: 'Custom provider', baseUrl: 'https://api.example.com/v1' },
+function providerKindsForMode(mode: ProviderMode): AiModelProviderKind[] {
+  return aiModelProviderCatalog()
+    .filter((entry) => entry.local === (mode === 'local'))
+    .map((entry) => entry.kind)
 }
 
 function initialDraft(mode: ProviderMode): ProviderDraft {
-  const kind = mode === 'local' ? 'ollama' : 'open_ai'
+  const [kind] = providerKindsForMode(mode)
+  if (!kind) throw new Error(`No AI model providers are configured for ${mode} mode`)
+  return draftFromProviderKind(kind)
+}
+
+function draftFromProviderKind(kind: AiModelProviderKind): ProviderDraft {
+  const defaults = aiModelProviderCatalogEntry(kind)
   return {
     kind,
-    name: PROVIDER_PRESETS[kind].name,
-    baseUrl: PROVIDER_PRESETS[kind].baseUrl,
+    name: defaults.name,
+    baseUrl: defaults.base_url,
     modelId: '',
-    apiKeyStorage: mode === 'local' ? 'none' : 'local_file',
+    apiKeyStorage: defaults.api_key_storage,
     apiKey: '',
-    apiKeyEnvVar: '',
+    apiKeyEnvVar: defaults.api_key_env_var ?? '',
   }
 }
 
 function providerKindOptions(mode: ProviderMode, t: Translate): Array<{ value: AiModelProviderKind; label: string }> {
-  const kinds = mode === 'local' ? LOCAL_PROVIDER_KINDS : API_PROVIDER_KINDS
-  return kinds.map((kind) => ({ value: kind, label: providerKindLabel(kind, t) }))
+  return providerKindsForMode(mode).map((kind) => {
+    const defaults = aiModelProviderCatalogEntry(kind)
+    return { value: kind, label: t(defaults.label_key) }
+  })
 }
 
-function providerKindLabel(kind: AiModelProviderKind, t: Translate): string {
+function providerPresetPatch(kind: AiModelProviderKind): Pick<ProviderDraft, 'kind' | 'name' | 'baseUrl' | 'apiKeyStorage' | 'apiKeyEnvVar'> {
+  const defaults = draftFromProviderKind(kind)
   return {
-    ollama: t('settings.aiProviders.kind.ollama'),
-    lm_studio: t('settings.aiProviders.kind.lmStudio'),
-    open_ai: t('settings.aiProviders.kind.openAi'),
-    anthropic: t('settings.aiProviders.kind.anthropic'),
-    gemini: t('settings.aiProviders.kind.gemini'),
-    open_router: t('settings.aiProviders.kind.openRouter'),
-    open_ai_compatible: t('settings.aiProviders.kind.compatible'),
-  }[kind]
-}
-
-function modelPlaceholder(kind: AiModelProviderKind, mode: ProviderMode): string {
-  if (mode === 'local') return 'llama3.2'
-  if (kind === 'anthropic') return 'claude-3-5-sonnet-latest'
-  if (kind === 'gemini') return 'gemini-2.5-flash'
-  if (kind === 'open_router') return 'openai/gpt-4.1-mini'
-  return 'gpt-4.1-mini'
-}
-
-function apiKeyEnvPlaceholder(kind: AiModelProviderKind): string {
-  if (kind === 'anthropic') return 'ANTHROPIC_API_KEY'
-  if (kind === 'gemini') return 'GEMINI_API_KEY'
-  if (kind === 'open_router') return 'OPENROUTER_API_KEY'
-  return 'OPENAI_API_KEY'
+    kind,
+    name: defaults.name,
+    baseUrl: defaults.baseUrl,
+    apiKeyStorage: defaults.apiKeyStorage,
+    apiKeyEnvVar: defaults.apiKeyEnvVar,
+  }
 }
 
 function buildProvider(draft: ProviderDraft, providerId: string): AiModelProvider {
@@ -210,7 +197,7 @@ function ApiKeyStorageFields({
     <>
       <label className="space-y-1.5 text-xs font-medium text-foreground">
         <span>{t('settings.aiProviders.keyStorage')}</span>
-        <Select value={draft.apiKeyStorage} onValueChange={(next) => updateDraft({ apiKeyStorage: next as ApiKeyStorage })}>
+        <Select value={draft.apiKeyStorage} onValueChange={(next) => updateDraft({ apiKeyStorage: next as AiModelApiKeyStorage })}>
           <SelectTrigger className={`h-9 ${editableInputClassName()}`}>
             <SelectValue />
           </SelectTrigger>
@@ -235,7 +222,7 @@ function ApiKeyStorageFields({
           label={t('settings.aiProviders.keyEnv')}
           value={draft.apiKeyEnvVar}
           onChange={(apiKeyEnvVar) => updateDraft({ apiKeyEnvVar })}
-          placeholder={apiKeyEnvPlaceholder(draft.kind)}
+          placeholder={aiModelProviderCatalogEntry(draft.kind).api_key_env_var ?? ''}
         />
       ) : null}
     </>
@@ -290,7 +277,7 @@ export function AiProviderSettings({ t, mode, providers, onChange }: AiProviderS
     resetTest()
     updateDraft(patch)
   }
-  const updateKind = (kind: AiModelProviderKind) => updateForm({ kind, ...PROVIDER_PRESETS[kind] })
+  const updateKind = (kind: AiModelProviderKind) => updateForm(providerPresetPatch(kind))
   const canSave = draft.name.trim() && draft.modelId.trim() && (draft.apiKeyStorage !== 'local_file' || draft.apiKey.trim())
   const apiKeyOverride = draft.apiKeyStorage === 'local_file' ? draft.apiKey : null
 
@@ -302,7 +289,7 @@ export function AiProviderSettings({ t, mode, providers, onChange }: AiProviderS
         await saveAiModelProviderApiKey(providerId, draft.apiKey)
       }
       onChange(normalizeAiModelProviders([...providers, buildProvider(draft, providerId)]))
-      setDraft((current) => ({ ...initialDraft(mode), kind: current.kind, name: current.name, baseUrl: current.baseUrl }))
+      setDraft((current) => ({ ...draftFromProviderKind(current.kind), name: current.name, baseUrl: current.baseUrl }))
       setTestState('idle')
     } catch (error) {
       setError(error instanceof Error ? error.message : String(error))
@@ -335,7 +322,7 @@ export function AiProviderSettings({ t, mode, providers, onChange }: AiProviderS
         <ProviderKindSelect mode={mode} t={t} value={draft.kind} onChange={updateKind} />
         <LabeledInput label={t('settings.aiProviders.name')} value={draft.name} onChange={(name) => updateForm({ name })} />
         <LabeledInput label={t('settings.aiProviders.baseUrl')} value={draft.baseUrl} onChange={(baseUrl) => updateForm({ baseUrl })} />
-        <LabeledInput label={t('settings.aiProviders.model')} value={draft.modelId} onChange={(modelId) => updateForm({ modelId })} placeholder={modelPlaceholder(draft.kind, mode)} />
+        <LabeledInput label={t('settings.aiProviders.model')} value={draft.modelId} onChange={(modelId) => updateForm({ modelId })} placeholder={aiModelProviderCatalogEntry(draft.kind).default_model_id} />
         {mode === 'api' ? <ApiKeyStorageFields t={t} draft={draft} updateDraft={updateForm} /> : null}
       </div>
       <div className="text-xs leading-5 text-muted-foreground">

src/components/StatusBar.test.tsx

@@ -567,6 +567,7 @@ describe('StatusBar', () => {
       />
     )
     fireEvent.click(screen.getByTestId('status-sync'))
+    expect(screen.getByTestId('status-bar')).toHaveStyle({ zIndex: '30' })
     expect(screen.getByTestId('git-status-popup')).toBeInTheDocument()
     expect(screen.getByText('main')).toBeInTheDocument()
     expect(screen.getByText(/2 ahead/)).toBeInTheDocument()

src/components/StatusBar.tsx

@@ -17,6 +17,7 @@ import type { VaultOption } from './status-bar/types'
 export type { VaultOption } from './status-bar/types'
 
 const COMPACT_STATUS_BAR_MAX_WIDTH = 1000
+const STATUS_BAR_STACKING_Z_INDEX = 30
 
 function getWindowWidth() {
   return typeof window === 'undefined' ? Number.POSITIVE_INFINITY : window.innerWidth
@@ -246,7 +247,7 @@ function StatusBarFooter(props: StatusBarFooterProps) {
         fontSize: 12,
         color: 'var(--muted-foreground)',
         position: 'relative',
-        zIndex: 10,
+        zIndex: STATUS_BAR_STACKING_Z_INDEX,
       }}
     >
       <StatusBarPrimaryFromFooter {...props} />

src/components/editorModePosition.ts

@@ -1,6 +1,6 @@
 import { compactMarkdown } from '../utils/compact-markdown'
 import { restoreWikilinksInBlocks, splitFrontmatter } from '../utils/wikilinks'
-import { serializeMermaidAwareBlocks } from '../utils/mermaidMarkdown'
+import { serializeDurableEditorBlocks } from '../utils/editorDurableMarkdown'
 import { findNearestTextCursorBlockById } from './blockNoteCursorTarget'
 
 interface BlockLike {
@@ -133,11 +133,11 @@ function getLineIndexFromRatio({ totalLines, ratio }: { totalLines: number; rati
 }
 
 function serializeBlock(editor: BlockNotePositionEditor, block: BlockLike): string {
-  return compactMarkdown(serializeMermaidAwareBlocks(editor, restoreWikilinksInBlocks([block])))
+  return compactMarkdown(serializeDurableEditorBlocks(editor, restoreWikilinksInBlocks([block])))
 }
 
 function serializeEditorBody(editor: BlockNotePositionEditor): string {
-  return compactMarkdown(serializeMermaidAwareBlocks(editor, restoreWikilinksInBlocks(editor.document)))
+  return compactMarkdown(serializeDurableEditorBlocks(editor, restoreWikilinksInBlocks(editor.document)))
 }
 
 function buildBlockLineRanges({

src/components/editorRawModeSync.mermaid.test.ts

@@ -1,6 +1,7 @@
 import { describe, expect, it, vi } from 'vitest'
 import { MERMAID_BLOCK_TYPE } from '../utils/mermaidMarkdown'
-import { serializeEditorDocumentToMarkdown } from './editorRawModeSync'
+import { TLDRAW_BLOCK_TYPE } from '../utils/tldrawMarkdown'
+import { serializeEditorDocumentToMarkdown, syncActiveTabIntoRawBuffer } from './editorRawModeSync'
 
 describe('editorRawModeSync Mermaid serialization', () => {
   it('keeps the original fenced Mermaid source when rich content enters raw mode', () => {
@@ -28,4 +29,39 @@ describe('editorRawModeSync Mermaid serialization', () => {
       '---\ntitle: Flow\n---\n\n# Flow\n',
     )).toBe(`---\ntitle: Flow\n---\n${source}\n`)
   })
+
+  it('serializes durable blocks into raw mode even when no pending rich edit was flushed', () => {
+    const rawLatestContentRef = { current: null as string | null }
+    const editor = {
+      document: [{
+        id: 'board-1',
+        type: TLDRAW_BLOCK_TYPE,
+        props: {
+          boardId: 'planning-map',
+          height: '520',
+          snapshot: '{}',
+          width: '',
+        },
+        children: [],
+      }],
+      blocksToMarkdownLossy: vi.fn(),
+    }
+
+    const synced = syncActiveTabIntoRawBuffer({
+      editor: editor as never,
+      activeTabPath: 'note/whiteboard-embed.md',
+      activeTabContent: [
+        '# Whiteboard Embed',
+        '',
+        '```tldraw id="planning-map"',
+        '{}',
+        '```',
+      ].join('\n'),
+      rawLatestContentRef,
+      serializeRichEditorContent: false,
+    })
+
+    expect(synced).toContain('```tldraw id="planning-map" height="520"')
+    expect(rawLatestContentRef.current).toBe(synced)
+  })
 })

src/components/editorRawModeSync.ts

@@ -2,7 +2,7 @@ import type { useCreateBlockNote } from '@blocknote/react'
 import type { VaultEntry } from '../types'
 import { splitFrontmatter, restoreWikilinksInBlocks } from '../utils/wikilinks'
 import { compactMarkdown } from '../utils/compact-markdown'
-import { serializeMermaidAwareBlocks } from '../utils/mermaidMarkdown'
+import { hasDurableEditorBlocks, serializeDurableEditorBlocks } from '../utils/editorDurableMarkdown'
 import { portableImageUrls } from '../utils/vaultImages'
 
 interface Tab {
@@ -30,7 +30,7 @@ export function serializeEditorDocumentToMarkdown(
 ): string {
   const blocks = editor.document
   const restored = restoreWikilinksInBlocks(blocks)
-  const rawBodyMarkdown = compactMarkdown(serializeMermaidAwareBlocks(editor, restored))
+  const rawBodyMarkdown = compactMarkdown(serializeDurableEditorBlocks(editor, restored))
   const bodyMarkdown = vaultPath ? portableImageUrls(rawBodyMarkdown, vaultPath) : rawBodyMarkdown
   const [frontmatter] = splitFrontmatter(tabContent)
   return `${frontmatter}${bodyMarkdown}`
@@ -91,7 +91,8 @@ export function syncActiveTabIntoRawBuffer(options: {
   } = options
   if (!activeTabPath || activeTabContent === null) return null
 
-  const syncedContent = serializeRichEditorContent
+  const shouldSerializeRichEditorContent = serializeRichEditorContent || hasDurableEditorBlocks(editor.document)
+  const syncedContent = shouldSerializeRichEditorContent
     ? serializeEditorDocumentToMarkdown(editor, activeTabContent, vaultPath)
     : activeTabContent
   rawLatestContentRef.current = syncedContent

src/components/tolariaEditorFormatting.behavior.test.tsx

@@ -330,35 +330,102 @@ describe('tolariaEditorFormatting behavior', () => {
   })
 
   it('hides the floating toolbar while the editor is composing IME text', () => {
-    const editor = createMockEditor('paragraph')
-    const editorInput = editor.domElement.firstElementChild as HTMLElement
+    vi.useFakeTimers()
+    try {
+      const editor = createMockEditor('paragraph')
+      const editorInput = editor.domElement.firstElementChild as HTMLElement
 
-    useBlockNoteEditorMock.mockReturnValue(editor)
+      useBlockNoteEditorMock.mockReturnValue(editor)
 
-    render(<TolariaFormattingToolbarController />)
+      render(<TolariaFormattingToolbarController />)
 
-    expect(positionPopoverState.lastProps).toEqual(expect.objectContaining({
-      position: { from: 1, to: 5 },
-      useFloatingOptions: expect.objectContaining({ open: true }),
-    }))
+      expect(positionPopoverState.lastProps).toEqual(expect.objectContaining({
+        position: { from: 1, to: 5 },
+        useFloatingOptions: expect.objectContaining({ open: true }),
+      }))
 
-    act(() => {
-      fireEvent.compositionStart(editorInput)
-    })
+      act(() => {
+        fireEvent.compositionStart(editorInput)
+      })
 
-    expect(positionPopoverState.lastProps).toEqual(expect.objectContaining({
-      position: undefined,
-      useFloatingOptions: expect.objectContaining({ open: false }),
-    }))
+      expect(positionPopoverState.lastProps).toEqual(expect.objectContaining({
+        position: undefined,
+        useFloatingOptions: expect.objectContaining({ open: false }),
+      }))
 
-    act(() => {
-      fireEvent.compositionEnd(editorInput)
-    })
+      act(() => {
+        fireEvent.compositionEnd(editorInput)
+      })
 
-    expect(positionPopoverState.lastProps).toEqual(expect.objectContaining({
-      position: { from: 1, to: 5 },
-      useFloatingOptions: expect.objectContaining({ open: true }),
-    }))
+      expect(positionPopoverState.lastProps).toEqual(expect.objectContaining({
+        position: undefined,
+        useFloatingOptions: expect.objectContaining({ open: false }),
+      }))
+
+      act(() => {
+        vi.advanceTimersByTime(250)
+      })
+
+      expect(positionPopoverState.lastProps).toEqual(expect.objectContaining({
+        position: { from: 1, to: 5 },
+        useFloatingOptions: expect.objectContaining({ open: true }),
+      }))
+    } finally {
+      vi.useRealTimers()
+    }
+  })
+
+  it('keeps the floating toolbar hidden through rapid Zhuyin composition settle cycles', () => {
+    vi.useFakeTimers()
+    try {
+      const editor = createMockEditor('paragraph')
+      const editorInput = editor.domElement.firstElementChild as HTMLElement
+
+      useBlockNoteEditorMock.mockReturnValue(editor)
+
+      render(<TolariaFormattingToolbarController />)
+
+      act(() => {
+        fireEvent.compositionStart(editorInput)
+        fireEvent.compositionEnd(editorInput)
+      })
+
+      expect(positionPopoverState.lastProps).toEqual(expect.objectContaining({
+        position: undefined,
+        useFloatingOptions: expect.objectContaining({ open: false }),
+      }))
+
+      act(() => {
+        vi.advanceTimersByTime(120)
+        fireEvent.compositionStart(editorInput)
+        fireEvent.compositionEnd(editorInput)
+      })
+
+      expect(positionPopoverState.lastProps).toEqual(expect.objectContaining({
+        position: undefined,
+        useFloatingOptions: expect.objectContaining({ open: false }),
+      }))
+
+      act(() => {
+        vi.advanceTimersByTime(249)
+      })
+
+      expect(positionPopoverState.lastProps).toEqual(expect.objectContaining({
+        position: undefined,
+        useFloatingOptions: expect.objectContaining({ open: false }),
+      }))
+
+      act(() => {
+        vi.advanceTimersByTime(1)
+      })
+
+      expect(positionPopoverState.lastProps).toEqual(expect.objectContaining({
+        position: { from: 1, to: 5 },
+        useFloatingOptions: expect.objectContaining({ open: true }),
+      }))
+    } finally {
+      vi.useRealTimers()
+    }
   })
 
   it('ignores composition events that start outside the editor', () => {

src/components/useEditorComposing.ts

@@ -6,10 +6,31 @@ import type {
 } from '@blocknote/core'
 import { useEffect, useRef, useState } from 'react'
 
+const COMPOSITION_SETTLE_MS = 250
+
 function eventTargetsEditor(editorElement: Element, target: EventTarget | null) {
   return target instanceof Node && editorElement.contains(target)
 }
 
+function focusTargetsEditor(editorElement: Element) {
+  const activeElement = editorElement.ownerDocument.activeElement
+  return activeElement instanceof Node && editorElement.contains(activeElement)
+}
+
+function selectionTargetsEditor(editorElement: Element) {
+  const anchorNode = editorElement.ownerDocument.getSelection()?.anchorNode
+  return anchorNode instanceof Node && editorElement.contains(anchorNode)
+}
+
+function compositionEventTargetsEditor(
+  editorElement: Element,
+  event: CompositionEvent,
+) {
+  return eventTargetsEditor(editorElement, event.target)
+    || focusTargetsEditor(editorElement)
+    || selectionTargetsEditor(editorElement)
+}
+
 export function useEditorComposing<
   BSchema extends BlockSchema,
   ISchema extends InlineContentSchema,
@@ -17,41 +38,82 @@ export function useEditorComposing<
 >(editor: BlockNoteEditor<BSchema, ISchema, SSchema>) {
   const [isComposing, setIsComposing] = useState(false)
   const composingRef = useRef(false)
+  const settleTimeoutRef = useRef<number | null>(null)
   const editorElement = editor.domElement ?? null
 
   useEffect(() => {
+    const clearSettleTimeout = () => {
+      if (settleTimeoutRef.current === null) return
+      window.clearTimeout(settleTimeoutRef.current)
+      settleTimeoutRef.current = null
+    }
+
     const updateComposing = (nextIsComposing: boolean) => {
       if (composingRef.current === nextIsComposing) return
       composingRef.current = nextIsComposing
       setIsComposing(nextIsComposing)
     }
 
+    const startComposing = () => {
+      clearSettleTimeout()
+      updateComposing(true)
+    }
+
+    const finishComposing = () => {
+      clearSettleTimeout()
+      settleTimeoutRef.current = window.setTimeout(() => {
+        settleTimeoutRef.current = null
+        updateComposing(false)
+      }, COMPOSITION_SETTLE_MS)
+    }
+
+    clearSettleTimeout()
     updateComposing(false)
 
     if (!editorElement) return
 
     const handleCompositionStart = (event: CompositionEvent) => {
-      if (!eventTargetsEditor(editorElement, event.target)) return
-      updateComposing(true)
+      if (!compositionEventTargetsEditor(editorElement, event)) return
+      startComposing()
+    }
+
+    const handleCompositionUpdate = (event: CompositionEvent) => {
+      if (!compositionEventTargetsEditor(editorElement, event)) return
+      startComposing()
     }
 
     const handleCompositionEnd = (event: CompositionEvent) => {
       if (
         !composingRef.current
-        && !eventTargetsEditor(editorElement, event.target)
+        && !compositionEventTargetsEditor(editorElement, event)
       ) {
         return
       }
 
-      updateComposing(false)
+      finishComposing()
+    }
+
+    const handleCompositionCancel: EventListener = (event) => {
+      if (event instanceof CompositionEvent) {
+        handleCompositionEnd(event)
+        return
+      }
+
+      if (!composingRef.current) return
+      finishComposing()
     }
 
     document.addEventListener('compositionstart', handleCompositionStart, true)
+    document.addEventListener('compositionupdate', handleCompositionUpdate, true)
     document.addEventListener('compositionend', handleCompositionEnd, true)
+    document.addEventListener('compositioncancel', handleCompositionCancel, true)
 
     return () => {
+      clearSettleTimeout()
       document.removeEventListener('compositionstart', handleCompositionStart, true)
+      document.removeEventListener('compositionupdate', handleCompositionUpdate, true)
       document.removeEventListener('compositionend', handleCompositionEnd, true)
+      document.removeEventListener('compositioncancel', handleCompositionCancel, true)
     }
   }, [editorElement])
 

src/hooks/editorBlockResolution.ts

@@ -1,8 +1,7 @@
 import type { useCreateBlockNote } from '@blocknote/react'
 import { preProcessWikilinks, injectWikilinks } from '../utils/wikilinks'
 import { preProcessMathMarkdown, injectMathInBlocks } from '../utils/mathMarkdown'
-import { preProcessMermaidMarkdown, injectMermaidInBlocks } from '../utils/mermaidMarkdown'
-import { preProcessTldrawMarkdown, injectTldrawInBlocks } from '../utils/tldrawMarkdown'
+import { injectDurableEditorMarkdownBlocks, preProcessDurableEditorMarkdown } from '../utils/editorDurableMarkdown'
 import { resolveImageUrls } from '../utils/vaultImages'
 import { repairMalformedEditorBlocks } from './editorBlockRepair'
 import { inferCodeBlockLanguages } from '../utils/codeBlockLanguage'
@@ -134,9 +133,8 @@ async function parseMarkdownBlocks(
 }
 
 function preProcessEditorMarkdown(markdown: MarkdownBody, vaultPath?: VaultPath): PreprocessedMarkdown {
-  const withTldraw = preProcessTldrawMarkdown({ markdown })
-  const withMermaid = preProcessMermaidMarkdown({ markdown: withTldraw })
-  const withImages = vaultPath ? resolveImageUrls(withMermaid, vaultPath) : withMermaid
+  const withDurableBlocks = preProcessDurableEditorMarkdown({ markdown })
+  const withImages = vaultPath ? resolveImageUrls(withDurableBlocks, vaultPath) : withDurableBlocks
   const withWikilinks = preProcessWikilinks(withImages)
   return preProcessMathMarkdown({ markdown: withWikilinks })
 }
@@ -144,8 +142,7 @@ function preProcessEditorMarkdown(markdown: MarkdownBody, vaultPath?: VaultPath)
 function injectEditorMarkdownBlocks(blocks: EditorBlocks): EditorBlocks {
   const withWikilinks = injectWikilinks(blocks)
   const withMath = injectMathInBlocks(withWikilinks)
-  const withMermaid = injectMermaidInBlocks(withMath)
-  return injectTldrawInBlocks(withMermaid) as EditorBlocks
+  return injectDurableEditorMarkdownBlocks(withMath) as EditorBlocks
 }
 
 function repairParsedMarkdownBlocks(parsed: MarkdownParseResult): EditorBlocks {

src/hooks/useEditorTabSwap.ts

@@ -3,7 +3,7 @@ import type { useCreateBlockNote } from '@blocknote/react'
 import type { VaultEntry } from '../types'
 import { splitFrontmatter, restoreWikilinksInBlocks } from '../utils/wikilinks'
 import { compactMarkdown } from '../utils/compact-markdown'
-import { serializeMermaidAwareBlocks } from '../utils/mermaidMarkdown'
+import { serializeDurableEditorBlocks } from '../utils/editorDurableMarkdown'
 import { failNoteOpenTrace, finishNoteOpenTrace } from '../utils/noteOpenPerformance'
 import { portableImageUrls } from '../utils/vaultImages'
 import { useEditorMountState, useLatestRef } from './editorTabSwapLifecycle'
@@ -123,7 +123,7 @@ function findActiveTab(options: {
 
 function serializeEditorBody(editor: ReturnType<typeof useCreateBlockNote>): string {
   const restored = restoreWikilinksInBlocks(editor.document)
-  return compactMarkdown(serializeMermaidAwareBlocks(editor, restored))
+  return compactMarkdown(serializeDurableEditorBlocks(editor, restored))
 }
 
 function trySerializeEditorBody(

src/hooks/useNoteCreation.extra.test.ts

@@ -8,6 +8,7 @@ import {
   buildNoteContent,
   resolveNewNote,
   resolveNewType,
+  planNewTypeCreation,
   DEFAULT_TEMPLATES,
   resolveTemplate,
 } from './useNoteCreation'
@@ -319,3 +320,28 @@ describe('resolveNewType', () => {
     expect(entry.path).not.toContain('/Users/luca/Laputa')
   })
 })
+
+describe('planNewTypeCreation', () => {
+  it('blocks creating a type when a same-slug non-Type note already exists', () => {
+    const plan = planNewTypeCreation({
+      entries: [makeEntry({ path: '/my/vault/tasks.md', filename: 'tasks.md', title: 'Tasks', isA: 'Note' })],
+      typeName: 'Tasks',
+      vaultPath: '/my/vault',
+    })
+
+    expect(plan).toEqual({
+      status: 'blocked',
+      message: 'Cannot create type "Tasks" because tasks.md already exists',
+    })
+  })
+
+  it('blocks type collisions case-insensitively for cross-platform vaults', () => {
+    const plan = planNewTypeCreation({
+      entries: [makeEntry({ path: '/my/vault/TASKS.md', filename: 'TASKS.md', title: 'Tasks', isA: 'Note' })],
+      typeName: 'tasks',
+      vaultPath: '/my/vault',
+    })
+
+    expect(plan.status).toBe('blocked')
+  })
+})

src/hooks/useNoteCreation.test.ts

@@ -584,11 +584,8 @@ describe('useNoteCreation hook', () => {
     expect(setToastMessage).toHaveBeenCalledWith('Cannot create type "Note" because note.md already exists')
   })
 
-  it('handleCreateType lets disk creation decide when a stale entry collides with the target type path', async () => {
+  it('handleCreateType blocks when a loaded non-Type entry collides with the target type path', async () => {
     vi.mocked(isTauri).mockReturnValue(true)
-    vi.mocked(invoke)
-      .mockRejectedValueOnce(new Error('not found'))
-      .mockResolvedValueOnce(undefined)
     const staleEntry = makeEntry({
       path: '/test/vault/pttep.md',
       filename: 'pttep.md',
@@ -597,26 +594,16 @@ describe('useNoteCreation hook', () => {
     })
     const { result } = renderHook(() => useNoteCreation(makeConfig([staleEntry]), tabDeps))
 
-    let created = false
+    let created = true
     await act(async () => {
       created = await result.current.handleCreateType('PTTEP')
     })
 
-    expect(created).toBe(true)
-    expect(vi.mocked(invoke)).toHaveBeenCalledWith('get_note_content', {
-      path: '/test/vault/pttep.md',
-    })
-    expect(vi.mocked(invoke)).toHaveBeenCalledWith('create_note_content', {
-      path: '/test/vault/pttep.md',
-      content: expect.stringContaining('type: Type'),
-    })
-    expect(addEntry).toHaveBeenCalledWith(expect.objectContaining({
-      path: '/test/vault/pttep.md',
-      filename: 'pttep.md',
-      title: 'PTTEP',
-      isA: 'Type',
-    }))
-    expect(setToastMessage).not.toHaveBeenCalled()
+    expect(created).toBe(false)
+    expect(vi.mocked(invoke)).not.toHaveBeenCalled()
+    expect(addEntry).not.toHaveBeenCalled()
+    expect(openTabWithContent).not.toHaveBeenCalled()
+    expect(setToastMessage).toHaveBeenCalledWith('Cannot create type "PTTEP" because pttep.md already exists')
   })
 
   it('handleCreateType writes new type entries to the vault root even when older type entries live in a folder', async () => {

src/hooks/useNoteCreation.ts

@@ -200,6 +200,14 @@ export function planNewTypeCreation({
   if (existingType) return { status: 'existing', entry: existingType }
 
   const resolved = resolveNewType({ typeName, vaultPath })
+  const collision = findPathCollision(entries, resolved.entry.path)
+  if (collision) {
+    return {
+      status: 'blocked',
+      message: buildCreationCollisionMessage({ noun: 'type', title: typeName, path: resolved.entry.path }),
+    }
+  }
+
   return { status: 'create', resolved }
 }
 

src/lib/aiTargets.test.ts

@@ -0,0 +1,88 @@
+import { describe, expect, it } from 'vitest'
+import {
+  LOCAL_AI_PROVIDER_KINDS,
+  aiModelProviderCatalog,
+  aiModelProviderCatalogEntry,
+  isLocalAiProvider,
+  normalizeAiModelProviders,
+  type AiModelProvider,
+} from './aiTargets'
+
+function provider(kind: AiModelProvider['kind']): AiModelProvider {
+  return {
+    id: ' Demo ',
+    name: ' Demo Provider ',
+    kind,
+    base_url: ' https://example.com/v1 ',
+    api_key_storage: null,
+    api_key_env_var: ' DEMO_API_KEY ',
+    headers: null,
+    models: [{
+      id: ' demo-model ',
+      display_name: ' Demo Model ',
+      context_window: null,
+      max_output_tokens: null,
+      capabilities: {
+        streaming: true,
+        tools: false,
+        vision: false,
+        json_mode: true,
+        reasoning: false,
+      },
+    }],
+  }
+}
+
+describe('ai target provider contract', () => {
+  it('keeps provider defaults in one catalog with stable grouping metadata', () => {
+    const entries = aiModelProviderCatalog()
+    const kinds = entries.map((entry) => entry.kind)
+
+    expect(kinds).toEqual([
+      'ollama',
+      'lm_studio',
+      'open_ai',
+      'anthropic',
+      'gemini',
+      'open_router',
+      'open_ai_compatible',
+    ])
+    expect(new Set(kinds).size).toBe(kinds.length)
+    expect(LOCAL_AI_PROVIDER_KINDS).toEqual(['ollama', 'lm_studio'])
+    expect(aiModelProviderCatalogEntry('anthropic')).toMatchObject({
+      name: 'Anthropic',
+      base_url: 'https://api.anthropic.com/v1',
+      api_key_storage: 'local_file',
+      api_key_env_var: 'ANTHROPIC_API_KEY',
+      default_model_id: 'claude-3-5-sonnet-latest',
+      local: false,
+    })
+    expect(aiModelProviderCatalogEntry('open_ai_compatible')).toMatchObject({
+      base_url: 'https://api.example.com/v1',
+      api_key_env_var: 'OPENAI_API_KEY',
+      local: false,
+    })
+  })
+
+  it('normalizes saved providers while using the catalog for local/provider classification', () => {
+    const normalized = normalizeAiModelProviders([
+      provider('open_ai_compatible'),
+      { ...provider('ollama'), id: ' ', name: 'Missing ID' },
+    ])
+
+    expect(normalized).toHaveLength(1)
+    expect(normalized[0]).toMatchObject({
+      id: 'demo',
+      name: 'Demo Provider',
+      base_url: 'https://example.com/v1',
+      api_key_env_var: 'DEMO_API_KEY',
+      api_key_storage: 'env',
+    })
+    expect(normalized[0].models[0]).toMatchObject({
+      id: 'demo-model',
+      display_name: 'Demo Model',
+    })
+    expect(isLocalAiProvider(provider('lm_studio'))).toBe(true)
+    expect(isLocalAiProvider(provider('open_router'))).toBe(false)
+  })
+})

src/lib/aiTargets.ts

@@ -5,10 +5,13 @@ import {
   type AiAgentId,
   type AiAgentsStatus,
 } from './aiAgents'
+import providerCatalog from '../shared/aiModelProviderCatalog.json' with { type: 'json' }
 import type { Settings } from '../types'
+import type { TranslationKey } from './i18n'
 
 export type AiModelProviderKind = 'open_ai' | 'anthropic' | 'open_ai_compatible' | 'ollama' | 'lm_studio' | 'open_router' | 'gemini'
 export type AiTargetKind = 'agent' | 'api_model'
+export type AiModelApiKeyStorage = 'none' | 'env' | 'local_file'
 
 export interface AiModelCapabilities {
   streaming: boolean
@@ -31,12 +34,24 @@ export interface AiModelProvider {
   name: string
   kind: AiModelProviderKind
   base_url?: string | null
-  api_key_storage?: 'none' | 'env' | 'local_file' | null
+  api_key_storage?: AiModelApiKeyStorage | null
   api_key_env_var?: string | null
   headers?: Record<string, string> | null
   models: AiModelDefinition[]
 }
 
+export interface AiModelProviderCatalogEntry {
+  kind: AiModelProviderKind
+  name: string
+  label_key: TranslationKey
+  base_url: string
+  runtime_base_url: string | null
+  default_model_id: string
+  api_key_storage: AiModelApiKeyStorage
+  api_key_env_var: string | null
+  local: boolean
+}
+
 export type AiTarget =
   | { kind: 'agent'; agent: AiAgentId; id: string; label: string; shortLabel: string }
   | { kind: 'api_model'; provider: AiModelProvider; model: AiModelDefinition; id: string; label: string; shortLabel: string }
@@ -45,7 +60,14 @@ export type AiModelTarget = Extract<AiTarget, { kind: 'api_model' }>
 export const AI_TARGET_PREFIX_AGENT = 'agent:'
 export const AI_TARGET_PREFIX_MODEL = 'model:'
 
-export const LOCAL_AI_PROVIDER_KINDS: readonly AiModelProviderKind[] = ['ollama', 'lm_studio']
+const AI_MODEL_PROVIDER_CATALOG = providerCatalog as readonly AiModelProviderCatalogEntry[]
+const AI_MODEL_PROVIDER_CATALOG_BY_KIND = new Map<AiModelProviderKind, AiModelProviderCatalogEntry>(
+  AI_MODEL_PROVIDER_CATALOG.map((entry) => [entry.kind, entry]),
+)
+
+export const LOCAL_AI_PROVIDER_KINDS: readonly AiModelProviderKind[] = AI_MODEL_PROVIDER_CATALOG
+  .filter((entry) => entry.local)
+  .map((entry) => entry.kind)
 
 export const DEFAULT_MODEL_CAPABILITIES: AiModelCapabilities = {
   streaming: false,
@@ -55,6 +77,16 @@ export const DEFAULT_MODEL_CAPABILITIES: AiModelCapabilities = {
   reasoning: false,
 }
 
+export function aiModelProviderCatalog(): readonly AiModelProviderCatalogEntry[] {
+  return AI_MODEL_PROVIDER_CATALOG
+}
+
+export function aiModelProviderCatalogEntry(kind: AiModelProviderKind): AiModelProviderCatalogEntry {
+  const entry = AI_MODEL_PROVIDER_CATALOG_BY_KIND.get(kind)
+  if (!entry) throw new Error(`Unknown AI model provider kind: ${kind}`)
+  return entry
+}
+
 export function agentTargetId(agent: AiAgentId): string {
   return `${AI_TARGET_PREFIX_AGENT}${agent}`
 }
@@ -148,7 +180,7 @@ function emptyToNull(value: string | null | undefined): string | null {
 }
 
 export function isLocalAiProvider(provider: AiModelProvider): boolean {
-  return LOCAL_AI_PROVIDER_KINDS.includes(provider.kind)
+  return aiModelProviderCatalogEntry(provider.kind).local
 }
 
 export function aiTargetReady(target: AiTarget, statuses: AiAgentsStatus): boolean {

src/lib/blockNoteCopyCompatibility.regression.test.ts

@@ -0,0 +1,58 @@
+import { BlockNoteEditor } from '@blocknote/core'
+import { afterEach, describe, expect, it } from 'vitest'
+
+const arrayToReversedDescriptor = Object.getOwnPropertyDescriptor(Array.prototype, 'toReversed')
+
+function removeArrayToReversed() {
+  Object.defineProperty(Array.prototype, 'toReversed', {
+    configurable: true,
+    writable: true,
+    value: undefined,
+  })
+}
+
+function restoreArrayToReversed() {
+  if (arrayToReversedDescriptor) {
+    Object.defineProperty(Array.prototype, 'toReversed', arrayToReversedDescriptor)
+    return
+  }
+
+  delete Array.prototype.toReversed
+}
+
+afterEach(() => {
+  restoreArrayToReversed()
+})
+
+describe('patched BlockNote rich text copy compatibility', () => {
+  it('serializes marked rich text without Array.prototype.toReversed', () => {
+    removeArrayToReversed()
+
+    const editor = BlockNoteEditor.create({
+      initialContent: [
+        {
+          type: 'paragraph',
+          content: [
+            {
+              type: 'text',
+              text: 'Copied rich text',
+              styles: { bold: true, italic: true },
+            },
+          ],
+        },
+      ],
+    })
+
+    try {
+      const html = editor.blocksToHTMLLossy(editor.document)
+      const fullHtml = editor.blocksToFullHTML(editor.document)
+      const markdown = editor.blocksToMarkdownLossy(editor.document)
+
+      expect(html).toContain('Copied rich text')
+      expect(fullHtml).toContain('Copied rich text')
+      expect(markdown).toContain('Copied rich text')
+    } finally {
+      editor._tiptapEditor.destroy()
+    }
+  })
+})

src/shared/aiModelProviderCatalog.json

@@ -0,0 +1,79 @@
+[
+  {
+    "kind": "ollama",
+    "name": "Ollama",
+    "label_key": "settings.aiProviders.kind.ollama",
+    "base_url": "http://localhost:11434/v1",
+    "runtime_base_url": "http://localhost:11434/v1",
+    "default_model_id": "llama3.2",
+    "api_key_storage": "none",
+    "api_key_env_var": null,
+    "local": true
+  },
+  {
+    "kind": "lm_studio",
+    "name": "LM Studio",
+    "label_key": "settings.aiProviders.kind.lmStudio",
+    "base_url": "http://127.0.0.1:1234/v1",
+    "runtime_base_url": "http://127.0.0.1:1234/v1",
+    "default_model_id": "llama3.2",
+    "api_key_storage": "none",
+    "api_key_env_var": null,
+    "local": true
+  },
+  {
+    "kind": "open_ai",
+    "name": "OpenAI",
+    "label_key": "settings.aiProviders.kind.openAi",
+    "base_url": "https://api.openai.com/v1",
+    "runtime_base_url": "https://api.openai.com/v1",
+    "default_model_id": "gpt-4.1-mini",
+    "api_key_storage": "local_file",
+    "api_key_env_var": "OPENAI_API_KEY",
+    "local": false
+  },
+  {
+    "kind": "anthropic",
+    "name": "Anthropic",
+    "label_key": "settings.aiProviders.kind.anthropic",
+    "base_url": "https://api.anthropic.com/v1",
+    "runtime_base_url": "https://api.anthropic.com/v1",
+    "default_model_id": "claude-3-5-sonnet-latest",
+    "api_key_storage": "local_file",
+    "api_key_env_var": "ANTHROPIC_API_KEY",
+    "local": false
+  },
+  {
+    "kind": "gemini",
+    "name": "Gemini",
+    "label_key": "settings.aiProviders.kind.gemini",
+    "base_url": "https://generativelanguage.googleapis.com/v1beta/openai",
+    "runtime_base_url": "https://generativelanguage.googleapis.com/v1beta/openai",
+    "default_model_id": "gemini-2.5-flash",
+    "api_key_storage": "local_file",
+    "api_key_env_var": "GEMINI_API_KEY",
+    "local": false
+  },
+  {
+    "kind": "open_router",
+    "name": "OpenRouter",
+    "label_key": "settings.aiProviders.kind.openRouter",
+    "base_url": "https://openrouter.ai/api/v1",
+    "runtime_base_url": "https://openrouter.ai/api/v1",
+    "default_model_id": "openai/gpt-4.1-mini",
+    "api_key_storage": "local_file",
+    "api_key_env_var": "OPENROUTER_API_KEY",
+    "local": false
+  },
+  {
+    "kind": "open_ai_compatible",
+    "name": "Custom provider",
+    "label_key": "settings.aiProviders.kind.compatible",
+    "base_url": "https://api.example.com/v1",
+    "runtime_base_url": null,
+    "default_model_id": "gpt-4.1-mini",
+    "api_key_storage": "local_file",
+    "api_key_env_var": "OPENAI_API_KEY",
+    "local": false
+  }
+]

src/utils/durableMarkdownBlocks.ts

@@ -0,0 +1,293 @@
+export interface InlineItem {
+  type: string
+  text?: string
+  props?: Record<string, string>
+  content?: unknown
+  [key: string]: unknown
+}
+
+export interface BlockLike {
+  type?: string
+  content?: InlineItem[]
+  props?: Record<string, string>
+  children?: BlockLike[]
+  [key: string]: unknown
+}
+
+export interface MarkdownSerializer {
+  blocksToMarkdownLossy: (blocks: unknown[]) => string
+}
+
+export interface DurableFencePayloadInput {
+  lines: string[]
+  start: number
+  end: number
+  metadata: unknown
+}
+
+export interface DurableBlockCodec {
+  tokenPrefix: string
+  tokenSuffix: string
+  readFenceMetadata: (info: string) => unknown | null
+  buildPayload: (input: DurableFencePayloadInput) => unknown
+  decodePayload: (payload: unknown) => unknown | null
+  buildBlock: (block: BlockLike, payload: unknown) => BlockLike
+  readCodeBlock?: (block: BlockLike) => unknown | null
+  isBlock: (block: BlockLike) => boolean
+  serializeBlock: (block: BlockLike) => string
+}
+
+type FenceCharacter = '`' | '~'
+
+interface MarkdownLine {
+  line: string
+}
+
+interface FenceOpening {
+  character: FenceCharacter
+  length: number
+  metadata: unknown
+}
+
+interface MatchedFenceOpening {
+  codec: DurableBlockCodec
+  opening: FenceOpening
+}
+
+interface FenceSearch {
+  lines: string[]
+  start: number
+  opening: FenceOpening
+}
+
+interface SerializeDurableBlocksOptions {
+  blocks: unknown[]
+  codecs: readonly DurableBlockCodec[]
+  serializeOrdinaryBlocks: (blocks: unknown[]) => string
+}
+
+export function lineEnding({ line }: MarkdownLine): string {
+  if (line.endsWith('\r\n')) return '\r\n'
+  return line.endsWith('\n') ? '\n' : ''
+}
+
+export function lineText({ line }: MarkdownLine): string {
+  const ending = lineEnding({ line })
+  return ending ? line.slice(0, -ending.length) : line
+}
+
+function splitMarkdownLines(markdown: string): string[] {
+  const lines = markdown.match(/[^\n]*(?:\n|$)/g) ?? []
+  return lines.filter((line, index) => line !== '' || index < lines.length - 1)
+}
+
+function encodePayload(payload: unknown): string {
+  return encodeURIComponent(JSON.stringify(payload))
+}
+
+function decodePayload(codec: DurableBlockCodec, encoded: string): unknown | null {
+  try {
+    return codec.decodePayload(JSON.parse(decodeURIComponent(encoded)))
+  } catch {
+    return null
+  }
+}
+
+function durableToken(codec: DurableBlockCodec, payload: unknown): string {
+  return `${codec.tokenPrefix}${encodePayload(payload)}${codec.tokenSuffix}`
+}
+
+function readDurableToken(codec: DurableBlockCodec, text: string): unknown | null {
+  const trimmed = text.trim()
+  if (!trimmed.startsWith(codec.tokenPrefix) || !trimmed.endsWith(codec.tokenSuffix)) return null
+  return decodePayload(codec, trimmed.slice(codec.tokenPrefix.length, -codec.tokenSuffix.length))
+}
+
+function readFenceOpening(line: string, codec: DurableBlockCodec): FenceOpening | null {
+  const match = /^( {0,3})(`{3,}|~{3,})[ \t]*(.*)$/.exec(line)
+  if (!match) return null
+
+  const metadata = codec.readFenceMetadata(match[3])
+  if (metadata === null) return null
+
+  const fence = match[2]
+  return {
+    character: fence[0] as FenceCharacter,
+    length: fence.length,
+    metadata,
+  }
+}
+
+function readMatchedFenceOpening(line: string, codecs: readonly DurableBlockCodec[]): MatchedFenceOpening | null {
+  for (const codec of codecs) {
+    const opening = readFenceOpening(line, codec)
+    if (opening) return { codec, opening }
+  }
+  return null
+}
+
+function isClosingFence({ line, opening }: MarkdownLine & { opening: FenceOpening }): boolean {
+  const match = /^( {0,3})(`{3,}|~{3,})[ \t]*$/.exec(line)
+  if (!match) return false
+
+  const fence = match[2]
+  return fence[0] === opening.character && fence.length >= opening.length
+}
+
+function findClosingFence({ lines, start, opening }: FenceSearch): number {
+  for (let index = start + 1; index < lines.length; index++) {
+    if (isClosingFence({ line: lineText({ line: lines[index] }), opening })) return index
+  }
+
+  return -1
+}
+
+export function preProcessDurableMarkdownBlocks({
+  markdown,
+  codecs,
+}: {
+  markdown: string
+  codecs: readonly DurableBlockCodec[]
+}): string {
+  const lines = splitMarkdownLines(markdown)
+  const result: string[] = []
+
+  for (let index = 0; index < lines.length; index++) {
+    const matched = readMatchedFenceOpening(lineText({ line: lines[index] }), codecs)
+    if (!matched) {
+      result.push(lines[index])
+      continue
+    }
+
+    const closingIndex = findClosingFence({ lines, start: index, opening: matched.opening })
+    if (closingIndex === -1) {
+      result.push(lines[index])
+      continue
+    }
+
+    const payload = matched.codec.buildPayload({
+      lines,
+      start: index,
+      end: closingIndex,
+      metadata: matched.opening.metadata,
+    })
+    result.push(`${durableToken(matched.codec, payload)}${lineEnding({ line: lines[closingIndex] })}`)
+    index = closingIndex
+  }
+
+  return result.join('')
+}
+
+function readSingleTextContent(content: InlineItem[] | undefined): string | null {
+  const onlyItem = content?.length === 1 ? content[0] : null
+  if (onlyItem?.type !== 'text' || typeof onlyItem.text !== 'string') return null
+  return onlyItem.text
+}
+
+function readTokenPayload(block: BlockLike, codecs: readonly DurableBlockCodec[]): { codec: DurableBlockCodec; payload: unknown } | null {
+  const text = readSingleTextContent(block.content)
+  if (text === null) return null
+
+  for (const codec of codecs) {
+    const payload = readDurableToken(codec, text)
+    if (payload !== null) return { codec, payload }
+  }
+  return null
+}
+
+function readCodeBlockPayload(block: BlockLike, codecs: readonly DurableBlockCodec[]): { codec: DurableBlockCodec; payload: unknown } | null {
+  for (const codec of codecs) {
+    const payload = codec.readCodeBlock?.(block) ?? null
+    if (payload !== null) return { codec, payload }
+  }
+  return null
+}
+
+function injectDurableMarkdownBlock(block: BlockLike, codecs: readonly DurableBlockCodec[]): BlockLike {
+  const tokenPayload = readTokenPayload(block, codecs)
+  if (tokenPayload) return tokenPayload.codec.buildBlock(block, tokenPayload.payload)
+
+  const codeBlockPayload = readCodeBlockPayload(block, codecs)
+  if (codeBlockPayload) return codeBlockPayload.codec.buildBlock(block, codeBlockPayload.payload)
+
+  const children = Array.isArray(block.children)
+    ? block.children.map(child => injectDurableMarkdownBlock(child, codecs))
+    : block.children
+  return { ...block, children }
+}
+
+export function injectDurableMarkdownBlocks({
+  blocks,
+  codecs,
+}: {
+  blocks: unknown[]
+  codecs: readonly DurableBlockCodec[]
+}): unknown[] {
+  return (blocks as BlockLike[]).map(block => injectDurableMarkdownBlock(block, codecs))
+}
+
+function findBlockCodec(block: BlockLike, codecs: readonly DurableBlockCodec[]): DurableBlockCodec | null {
+  return codecs.find(codec => codec.isBlock(block)) ?? null
+}
+
+function hasDurableMarkdownBlock(block: BlockLike, codecs: readonly DurableBlockCodec[]): boolean {
+  if (findBlockCodec(block, codecs)) return true
+  return Array.isArray(block.children)
+    ? block.children.some(child => hasDurableMarkdownBlock(child, codecs))
+    : false
+}
+
+export function hasDurableMarkdownBlocks({
+  blocks,
+  codecs,
+}: {
+  blocks: unknown[]
+  codecs: readonly DurableBlockCodec[]
+}): boolean {
+  return (blocks as BlockLike[]).some(block => hasDurableMarkdownBlock(block, codecs))
+}
+
+export function serializeDurableMarkdownBlocks({
+  blocks,
+  codecs,
+  serializeOrdinaryBlocks,
+}: SerializeDurableBlocksOptions): string {
+  const chunks: string[] = []
+  let pending: unknown[] = []
+
+  const flushPending = () => {
+    if (pending.length === 0) return
+
+    const markdown = serializeOrdinaryBlocks(pending).trimEnd()
+    if (markdown) chunks.push(markdown)
+    pending = []
+  }
+
+  for (const block of blocks as BlockLike[]) {
+    const codec = findBlockCodec(block, codecs)
+    if (!codec) {
+      pending.push(block)
+      continue
+    }
+
+    flushPending()
+    chunks.push(codec.serializeBlock(block))
+  }
+
+  flushPending()
+  return chunks.join('\n\n')
+}
+
+export function readCodeBlockLanguage({ block }: { block: BlockLike }): string | null {
+  const language = block.props?.language
+  if (typeof language !== 'string') return null
+
+  return language.trim().split(/\s+/u)[0]?.toLowerCase() ?? null
+}
+
+export function readInlineText(content: InlineItem[] | undefined): string | null {
+  if (!Array.isArray(content)) return null
+  return content.map((item) => (
+    item.type === 'text' && typeof item.text === 'string' ? item.text : ''
+  )).join('')
+}

src/utils/editorDurableMarkdown.test.ts

@@ -0,0 +1,45 @@
+import { describe, expect, it, vi } from 'vitest'
+import {
+  injectDurableEditorMarkdownBlocks,
+  preProcessDurableEditorMarkdown,
+  serializeDurableEditorBlocks,
+} from './editorDurableMarkdown'
+import { MERMAID_BLOCK_TYPE } from './mermaidMarkdown'
+import { TLDRAW_BLOCK_TYPE } from './tldrawMarkdown'
+
+describe('editor durable markdown blocks', () => {
+  it('round-trips Mermaid and tldraw blocks through one durable pipeline', () => {
+    const markdown = [
+      'Intro',
+      '',
+      '```tldraw id="map" height="640" width="900"',
+      '{ "store": {} }',
+      '```',
+      '',
+      '```mermaid',
+      'flowchart LR',
+      '  A --> B',
+      '```',
+    ].join('\n')
+    const preprocessed = preProcessDurableEditorMarkdown({ markdown })
+    const blocks = injectDurableEditorMarkdownBlocks([
+      { type: 'paragraph', content: [{ type: 'text', text: 'Intro', styles: {} }], children: [] },
+      { type: 'paragraph', content: [{ type: 'text', text: preprocessed.split('\n\n')[1], styles: {} }], children: [] },
+      { type: 'paragraph', content: [{ type: 'text', text: preprocessed.split('\n\n')[2], styles: {} }], children: [] },
+    ]) as Array<{ type: string; props?: Record<string, string>; content?: Array<{ text?: string }> }>
+
+    expect(blocks.map(block => block.type)).toEqual(['paragraph', TLDRAW_BLOCK_TYPE, MERMAID_BLOCK_TYPE])
+    expect(blocks[1].props).toMatchObject({ boardId: 'map', height: '640', snapshot: '{ "store": {} }', width: '900' })
+    expect(blocks[2].props).toMatchObject({ diagram: 'flowchart LR\n  A --> B\n' })
+
+    const editor = {
+      blocksToMarkdownLossy: vi.fn((ordinaryBlocks: unknown[]) => {
+        return (ordinaryBlocks as Array<{ content?: Array<{ text?: string }> }>)
+          .map(block => block.content?.map(item => item.text ?? '').join('') ?? '')
+          .join('\n\n')
+      }),
+    }
+
+    expect(serializeDurableEditorBlocks(editor, blocks)).toBe(markdown)
+  })
+})

src/utils/editorDurableMarkdown.ts

@@ -0,0 +1,44 @@
+import {
+  hasDurableMarkdownBlocks,
+  injectDurableMarkdownBlocks,
+  preProcessDurableMarkdownBlocks,
+  serializeDurableMarkdownBlocks,
+  type MarkdownSerializer,
+} from './durableMarkdownBlocks'
+import { serializeMathAwareBlocks } from './mathMarkdown'
+import { mermaidMarkdownCodec } from './mermaidMarkdown'
+import { tldrawMarkdownCodec } from './tldrawMarkdown'
+
+const EDITOR_DURABLE_MARKDOWN_CODECS = [
+  mermaidMarkdownCodec,
+  tldrawMarkdownCodec,
+] as const
+
+export function preProcessDurableEditorMarkdown({ markdown }: { markdown: string }): string {
+  return preProcessDurableMarkdownBlocks({
+    markdown,
+    codecs: EDITOR_DURABLE_MARKDOWN_CODECS,
+  })
+}
+
+export function injectDurableEditorMarkdownBlocks(blocks: unknown[]): unknown[] {
+  return injectDurableMarkdownBlocks({
+    blocks,
+    codecs: EDITOR_DURABLE_MARKDOWN_CODECS,
+  })
+}
+
+export function serializeDurableEditorBlocks(editor: MarkdownSerializer, blocks: unknown[]): string {
+  return serializeDurableMarkdownBlocks({
+    blocks,
+    codecs: EDITOR_DURABLE_MARKDOWN_CODECS,
+    serializeOrdinaryBlocks: ordinaryBlocks => serializeMathAwareBlocks(editor, ordinaryBlocks),
+  })
+}
+
+export function hasDurableEditorBlocks(blocks: unknown[]): boolean {
+  return hasDurableMarkdownBlocks({
+    blocks,
+    codecs: EDITOR_DURABLE_MARKDOWN_CODECS,
+  })
+}

src/utils/mermaidMarkdown.test.ts

@@ -3,8 +3,8 @@ import {
   MERMAID_BLOCK_TYPE,
   injectMermaidInBlocks,
   preProcessMermaidMarkdown,
-  serializeMermaidAwareBlocks,
 } from './mermaidMarkdown'
+import { serializeDurableEditorBlocks } from './editorDurableMarkdown'
 import { TLDRAW_BLOCK_TYPE } from './tldrawMarkdown'
 
 describe('mermaid markdown round-trip', () => {
@@ -49,7 +49,7 @@ describe('mermaid markdown round-trip', () => {
       { type: MERMAID_BLOCK_TYPE, props: { source: secondSource, diagram: 'sequenceDiagram\nAlice->>Bob: Hi\n' }, children: [] },
     ]
 
-    expect(serializeMermaidAwareBlocks(editor, blocks)).toBe([
+    expect(serializeDurableEditorBlocks(editor, blocks)).toBe([
       'Intro',
       firstSource,
       'Between',
@@ -129,7 +129,7 @@ describe('mermaid markdown round-trip', () => {
       children: [],
     }]
 
-    expect(serializeMermaidAwareBlocks(editor, blocks)).toBe(
+    expect(serializeDurableEditorBlocks(editor, blocks)).toBe(
       '```mermaid\nflowchart LR\nA --> B\n```',
     )
   })
@@ -148,7 +148,7 @@ describe('mermaid markdown round-trip', () => {
       { type: MERMAID_BLOCK_TYPE, props: { source: '', diagram: 'flowchart LR\nA --> B' }, children: [] },
     ]
 
-    expect(serializeMermaidAwareBlocks(editor, blocks)).toBe([
+    expect(serializeDurableEditorBlocks(editor, blocks)).toBe([
       'Intro',
       '```tldraw id="map" height="640" width="900"\n{ "store": {} }\n```',
       '```mermaid\nflowchart LR\nA --> B\n```',

src/utils/mermaidMarkdown.ts

@@ -1,182 +1,51 @@
-import { serializeMathAwareBlocks } from './mathMarkdown'
-import { isTldrawBlock, tldrawMarkdown } from './tldrawMarkdown'
+import {
+  type BlockLike,
+  type DurableBlockCodec,
+  type DurableFencePayloadInput,
+  injectDurableMarkdownBlocks,
+  preProcessDurableMarkdownBlocks,
+  readCodeBlockLanguage,
+  readInlineText,
+} from './durableMarkdownBlocks'
 
 export const MERMAID_BLOCK_TYPE = 'mermaidBlock'
 
 const TOKEN_PREFIX = '@@TOLARIA_MERMAID_BLOCK:'
 const TOKEN_SUFFIX = '@@'
 
-interface InlineItem {
-  type: string
-  text?: string
-  props?: Record<string, string>
-  content?: unknown
-  [key: string]: unknown
-}
-
-interface BlockLike {
-  type?: string
-  content?: InlineItem[]
-  props?: Record<string, string>
-  children?: BlockLike[]
-  [key: string]: unknown
-}
-
-interface MarkdownSerializer {
-  blocksToMarkdownLossy: (blocks: unknown[]) => string
-}
-
 interface MermaidPayload {
   source: string
   diagram: string
 }
 
-interface MermaidFenceStart {
-  character: '`' | '~'
-  length: number
-}
-
-interface MarkdownLine {
-  line: string
-}
-
-interface EncodedPayload {
-  encoded: string
-}
-
-interface TokenText {
-  text: string
-}
-
-interface FenceSearch {
-  lines: string[]
-  start: number
-  opening: MermaidFenceStart
-}
-
-interface FenceRange {
-  lines: string[]
-  start: number
-  end: number
-}
-
 interface DiagramSource {
   diagram: string
 }
 
-interface CodeBlockSource {
-  block: BlockLike
+function isRecord(value: unknown): value is Record<string, unknown> {
+  return typeof value === 'object' && value !== null && !Array.isArray(value)
 }
 
-function lineEnding({ line }: MarkdownLine): string {
-  if (line.endsWith('\r\n')) return '\r\n'
-  return line.endsWith('\n') ? '\n' : ''
+function decodeMermaidPayload(payload: unknown): MermaidPayload | null {
+  if (!isRecord(payload)) return null
+  if (typeof payload.source !== 'string') return null
+  if (typeof payload.diagram !== 'string') return null
+  return { source: payload.source, diagram: payload.diagram }
 }
 
-function lineText({ line }: MarkdownLine): string {
-  const ending = lineEnding({ line })
-  return ending ? line.slice(0, -ending.length) : line
+function readMermaidFenceMetadata(info: string): Record<string, never> | null {
+  const language = info.trim().split(/\s+/u)[0]?.toLowerCase()
+  return language === 'mermaid' ? {} : null
 }
 
-function splitMarkdownLines(markdown: string): string[] {
-  const lines = markdown.match(/[^\n]*(?:\n|$)/g) ?? []
-  return lines.filter((line, index) => line !== '' || index < lines.length - 1)
-}
-
-function encodePayload(payload: MermaidPayload): string {
-  return encodeURIComponent(JSON.stringify(payload))
-}
-
-function decodePayload({ encoded }: EncodedPayload): MermaidPayload | null {
-  try {
-    const payload = JSON.parse(decodeURIComponent(encoded)) as Partial<MermaidPayload>
-    if (typeof payload.source !== 'string') return null
-    if (typeof payload.diagram !== 'string') return null
-    return { source: payload.source, diagram: payload.diagram }
-  } catch {
-    return null
-  }
-}
-
-function mermaidToken(payload: MermaidPayload): string {
-  return `${TOKEN_PREFIX}${encodePayload(payload)}${TOKEN_SUFFIX}`
-}
-
-function readMermaidToken({ text }: TokenText): MermaidPayload | null {
-  const trimmed = text.trim()
-  if (!trimmed.startsWith(TOKEN_PREFIX) || !trimmed.endsWith(TOKEN_SUFFIX)) return null
-  return decodePayload({ encoded: trimmed.slice(TOKEN_PREFIX.length, -TOKEN_SUFFIX.length) })
-}
-
-function readMermaidFenceStart({ line }: MarkdownLine): MermaidFenceStart | null {
-  const match = /^( {0,3})(`{3,}|~{3,})[ \t]*(.*)$/.exec(line)
-  if (!match) return null
-
-  const fence = match[2]
-  const language = match[3].trim().split(/\s+/)[0]?.toLowerCase()
-  if (language !== 'mermaid') return null
-
-  return {
-    character: fence[0] as '`' | '~',
-    length: fence.length,
-  }
-}
-
-function isClosingFence({ line, opening }: MarkdownLine & { opening: MermaidFenceStart }): boolean {
-  const match = /^( {0,3})(`{3,}|~{3,})[ \t]*$/.exec(line)
-  if (!match) return false
-
-  const fence = match[2]
-  return fence[0] === opening.character && fence.length >= opening.length
-}
-
-function findClosingFence({ lines, start, opening }: FenceSearch): number {
-  for (let index = start + 1; index < lines.length; index++) {
-    if (isClosingFence({ line: lineText({ line: lines[index] }), opening })) return index
-  }
-
-  return -1
-}
-
-function buildPayload({ lines, start, end }: FenceRange): MermaidPayload {
+function buildMermaidPayload({ lines, start, end }: DurableFencePayloadInput): MermaidPayload {
   return {
     source: lines.slice(start, end + 1).join(''),
     diagram: lines.slice(start + 1, end).join(''),
   }
 }
 
-export function preProcessMermaidMarkdown({ markdown }: { markdown: string }): string {
-  const lines = splitMarkdownLines(markdown)
-  const result: string[] = []
-
-  for (let index = 0; index < lines.length; index++) {
-    const opening = readMermaidFenceStart({ line: lineText({ line: lines[index] }) })
-    if (!opening) {
-      result.push(lines[index])
-      continue
-    }
-
-    const closingIndex = findClosingFence({ lines, start: index, opening })
-    if (closingIndex === -1) {
-      result.push(lines[index])
-      continue
-    }
-
-    const payload = buildPayload({ lines, start: index, end: closingIndex })
-    result.push(`${mermaidToken(payload)}${lineEnding({ line: lines[closingIndex] })}`)
-    index = closingIndex
-  }
-
-  return result.join('')
-}
-
-function readMermaidPayload(content: InlineItem[] | undefined): MermaidPayload | null {
-  const onlyItem = content?.length === 1 ? content[0] : null
-  if (onlyItem?.type !== 'text' || typeof onlyItem.text !== 'string') return null
-  return readMermaidToken({ text: onlyItem.text })
-}
-
-function buildMermaidBlock({ block, payload }: { block: BlockLike; payload: MermaidPayload }): BlockLike {
+function buildMermaidBlock(block: BlockLike, payload: MermaidPayload): BlockLike {
   return {
     ...block,
     type: MERMAID_BLOCK_TYPE,
@@ -195,23 +64,9 @@ export function mermaidFenceSource({ diagram }: DiagramSource): string {
   return `\`\`\`mermaid\n${body}\`\`\``
 }
 
-function readCodeBlockLanguage({ block }: CodeBlockSource): string | null {
-  const language = block.props?.language
-  if (typeof language !== 'string') return null
-
-  return language.trim().split(/\s+/)[0]?.toLowerCase() ?? null
-}
-
-function readInlineText(content: InlineItem[] | undefined): string | null {
-  if (!Array.isArray(content)) return null
-  return content.map((item) => (
-    item.type === 'text' && typeof item.text === 'string' ? item.text : ''
-  )).join('')
-}
-
 function looksLikeMermaidDiagram(diagram: string): boolean {
   const firstStatement = diagram
-    .split(/\r?\n/)
+    .split(/\r?\n/u)
     .map(line => line.trim())
     .find(line => line.length > 0 && !line.startsWith('%%'))
 
@@ -232,7 +87,7 @@ function shouldInjectCodeBlockAsMermaid({
   return looksLikeMermaidDiagram(diagram)
 }
 
-function readMermaidCodeBlock({ block }: CodeBlockSource): MermaidPayload | null {
+function readMermaidCodeBlock(block: BlockLike): MermaidPayload | null {
   if (block.type !== 'codeBlock') return null
 
   const diagram = readInlineText(block.content)
@@ -246,17 +101,6 @@ function readMermaidCodeBlock({ block }: CodeBlockSource): MermaidPayload | null
   }
 }
 
-function injectMermaidInBlock(block: BlockLike): BlockLike {
-  const payload = readMermaidPayload(block.content)
-  if (payload) return buildMermaidBlock({ block, payload })
-
-  const codeBlockPayload = readMermaidCodeBlock({ block })
-  if (codeBlockPayload) return buildMermaidBlock({ block, payload: codeBlockPayload })
-
-  const children = Array.isArray(block.children) ? block.children.map(injectMermaidInBlock) : block.children
-  return { ...block, children }
-}
-
 function isMermaidBlock(block: BlockLike): boolean {
   return block.type === MERMAID_BLOCK_TYPE
     && typeof block.props?.source === 'string'
@@ -270,34 +114,22 @@ function mermaidMarkdown(block: BlockLike): string {
   return mermaidFenceSource({ diagram: block.props?.diagram ?? '' })
 }
 
+export const mermaidMarkdownCodec: DurableBlockCodec = {
+  tokenPrefix: TOKEN_PREFIX,
+  tokenSuffix: TOKEN_SUFFIX,
+  readFenceMetadata: readMermaidFenceMetadata,
+  buildPayload: buildMermaidPayload,
+  decodePayload: decodeMermaidPayload,
+  buildBlock: (block, payload) => buildMermaidBlock(block, payload as MermaidPayload),
+  readCodeBlock: readMermaidCodeBlock,
+  isBlock: isMermaidBlock,
+  serializeBlock: mermaidMarkdown,
+}
+
+export function preProcessMermaidMarkdown({ markdown }: { markdown: string }): string {
+  return preProcessDurableMarkdownBlocks({ markdown, codecs: [mermaidMarkdownCodec] })
+}
+
 export function injectMermaidInBlocks(blocks: unknown[]): unknown[] {
-  return (blocks as BlockLike[]).map(injectMermaidInBlock)
-}
-
-export function serializeMermaidAwareBlocks(editor: MarkdownSerializer, blocks: unknown[]): string {
-  const chunks: string[] = []
-  let pending: unknown[] = []
-
-  const flushPending = () => {
-    if (pending.length === 0) return
-
-    const markdown = serializeMathAwareBlocks(editor, pending).trimEnd()
-    if (markdown) chunks.push(markdown)
-    pending = []
-  }
-
-  for (const block of blocks as BlockLike[]) {
-    if (isMermaidBlock(block)) {
-      flushPending()
-      chunks.push(mermaidMarkdown(block))
-    } else if (isTldrawBlock(block)) {
-      flushPending()
-      chunks.push(tldrawMarkdown(block))
-    } else {
-      pending.push(block)
-    }
-  }
-
-  flushPending()
-  return chunks.join('\n\n')
+  return injectDurableMarkdownBlocks({ blocks, codecs: [mermaidMarkdownCodec] })
 }

src/utils/tldrawMarkdown.ts

@@ -1,25 +1,19 @@
+import {
+  type BlockLike,
+  type DurableBlockCodec,
+  type DurableFencePayloadInput,
+  injectDurableMarkdownBlocks,
+  preProcessDurableMarkdownBlocks,
+  readCodeBlockLanguage,
+  readInlineText,
+} from './durableMarkdownBlocks'
+
 export const TLDRAW_BLOCK_TYPE = 'tldrawBlock'
 export const TLDRAW_DEFAULT_HEIGHT = '520'
 
 const TOKEN_PREFIX = '@@TOLARIA_TLDRAW_BLOCK:'
 const TOKEN_SUFFIX = '@@'
 
-interface InlineItem {
-  type: string
-  text?: string
-  props?: Record<string, string>
-  content?: unknown
-  [key: string]: unknown
-}
-
-interface BlockLike {
-  type?: string
-  content?: InlineItem[]
-  props?: Record<string, string>
-  children?: BlockLike[]
-  [key: string]: unknown
-}
-
 interface TldrawPayload {
   boardId: string
   height: string
@@ -27,39 +21,6 @@ interface TldrawPayload {
   width: string
 }
 
-interface TldrawFenceStart {
-  character: '`' | '~'
-  length: number
-  boardId: string
-  height: string
-  width: string
-}
-
-interface MarkdownLine {
-  line: string
-}
-
-interface EncodedPayload {
-  encoded: string
-}
-
-interface TokenText {
-  text: string
-}
-
-interface FenceSearch {
-  lines: string[]
-  start: number
-  opening: TldrawFenceStart
-}
-
-interface FenceRange {
-  lines: string[]
-  start: number
-  end: number
-  opening: TldrawFenceStart
-}
-
 interface SnapshotSource {
   snapshot: string
 }
@@ -68,64 +29,28 @@ interface FenceAttribute {
   value: string
 }
 
-interface CodeBlockSource {
-  block: BlockLike
-}
-
-interface FenceMetadata {
-  info: string
-}
-
 interface FenceAttributeRequest {
   info: string
   name: 'height' | 'id' | 'width'
 }
 
-function lineEnding({ line }: MarkdownLine): string {
-  if (line.endsWith('\r\n')) return '\r\n'
-  return line.endsWith('\n') ? '\n' : ''
+function isRecord(value: unknown): value is Record<string, unknown> {
+  return typeof value === 'object' && value !== null && !Array.isArray(value)
 }
 
-function lineText({ line }: MarkdownLine): string {
-  const ending = lineEnding({ line })
-  return ending ? line.slice(0, -ending.length) : line
-}
+function decodeTldrawPayload(payload: unknown): TldrawPayload | null {
+  if (!isRecord(payload)) return null
+  if (typeof payload.boardId !== 'string') return null
+  if (typeof payload.snapshot !== 'string') return null
 
-function splitMarkdownLines({ markdown }: { markdown: string }): string[] {
-  const lines = markdown.match(/[^\n]*(?:\n|$)/g) ?? []
-  return lines.filter((line, index) => line !== '' || index < lines.length - 1)
-}
-
-function encodePayload(payload: TldrawPayload): string {
-  return encodeURIComponent(JSON.stringify(payload))
-}
-
-function decodePayload({ encoded }: EncodedPayload): TldrawPayload | null {
-  try {
-    const payload = JSON.parse(decodeURIComponent(encoded)) as Partial<TldrawPayload>
-    if (typeof payload.boardId !== 'string') return null
-    if (typeof payload.snapshot !== 'string') return null
-    return {
-      boardId: payload.boardId,
-      height: typeof payload.height === 'string' ? payload.height : TLDRAW_DEFAULT_HEIGHT,
-      snapshot: payload.snapshot,
-      width: typeof payload.width === 'string' ? payload.width : '',
-    }
-  } catch {
-    return null
+  return {
+    boardId: payload.boardId,
+    height: typeof payload.height === 'string' ? payload.height : TLDRAW_DEFAULT_HEIGHT,
+    snapshot: payload.snapshot,
+    width: typeof payload.width === 'string' ? payload.width : '',
   }
 }
 
-function tldrawToken(payload: TldrawPayload): string {
-  return `${TOKEN_PREFIX}${encodePayload(payload)}${TOKEN_SUFFIX}`
-}
-
-function readTldrawToken({ text }: TokenText): TldrawPayload | null {
-  const trimmed = text.trim()
-  if (!trimmed.startsWith(TOKEN_PREFIX) || !trimmed.endsWith(TOKEN_SUFFIX)) return null
-  return decodePayload({ encoded: trimmed.slice(TOKEN_PREFIX.length, -TOKEN_SUFFIX.length) })
-}
-
 function readFenceAttribute({ info, name }: FenceAttributeRequest): string {
   for (const match of info.matchAll(/\b([A-Za-z][\w-]*)=(?:"([^"]+)"|'([^']+)'|([^\s]+))/gu)) {
     if (match[1] === name) return match[2] ?? match[3] ?? match[4] ?? ''
@@ -133,7 +58,7 @@ function readFenceAttribute({ info, name }: FenceAttributeRequest): string {
   return ''
 }
 
-function readFenceMetadata({ info }: FenceMetadata): Pick<TldrawPayload, 'boardId' | 'height' | 'width'> {
+function readFenceMetadata(info: string): Pick<TldrawPayload, 'boardId' | 'height' | 'width'> {
   return {
     boardId: readFenceAttribute({ info, name: 'id' }),
     height: readFenceAttribute({ info, name: 'height' }) || TLDRAW_DEFAULT_HEIGHT,
@@ -141,77 +66,20 @@ function readFenceMetadata({ info }: FenceMetadata): Pick<TldrawPayload, 'boardI
   }
 }
 
-function readTldrawFenceStart({ line }: MarkdownLine): TldrawFenceStart | null {
-  const match = /^( {0,3})(`{3,}|~{3,})[ \t]*(.*)$/.exec(line)
-  if (!match) return null
-
-  const fence = match[2]
-  const [language = '', ...infoParts] = match[3].trim().split(/\s+/u)
+function readTldrawFenceMetadata(info: string): Pick<TldrawPayload, 'boardId' | 'height' | 'width'> | null {
+  const [language = '', ...infoParts] = info.trim().split(/\s+/u)
   if (language.toLowerCase() !== 'tldraw') return null
-  const metadata = readFenceMetadata({ info: infoParts.join(' ') })
+  return readFenceMetadata(infoParts.join(' '))
+}
 
+function buildTldrawPayload({ lines, start, end, metadata }: DurableFencePayloadInput): TldrawPayload {
+  const fenceMetadata = metadata as Pick<TldrawPayload, 'boardId' | 'height' | 'width'>
   return {
-    character: fence[0] as '`' | '~',
-    length: fence.length,
-    ...metadata,
-  }
-}
-
-function isClosingFence({ line, opening }: MarkdownLine & { opening: TldrawFenceStart }): boolean {
-  const match = /^( {0,3})(`{3,}|~{3,})[ \t]*$/.exec(line)
-  if (!match) return false
-
-  const fence = match[2]
-  return fence[0] === opening.character && fence.length >= opening.length
-}
-
-function findClosingFence({ lines, start, opening }: FenceSearch): number {
-  for (let index = start + 1; index < lines.length; index++) {
-    if (isClosingFence({ line: lineText({ line: lines[index] }), opening })) return index
-  }
-
-  return -1
-}
-
-function buildPayload({ lines, start, end, opening }: FenceRange): TldrawPayload {
-  return {
-    boardId: opening.boardId,
-    height: opening.height,
+    ...fenceMetadata,
     snapshot: lines.slice(start + 1, end).join('').trim(),
-    width: opening.width,
   }
 }
 
-export function preProcessTldrawMarkdown({ markdown }: { markdown: string }): string {
-  const lines = splitMarkdownLines({ markdown })
-  const result: string[] = []
-
-  for (let index = 0; index < lines.length; index++) {
-    const opening = readTldrawFenceStart({ line: lineText({ line: lines[index] }) })
-    if (!opening) {
-      result.push(lines[index])
-      continue
-    }
-
-    const closingIndex = findClosingFence({ lines, start: index, opening })
-    if (closingIndex === -1) {
-      result.push(lines[index])
-      continue
-    }
-
-    result.push(`${tldrawToken(buildPayload({ lines, start: index, end: closingIndex, opening }))}${lineEnding({ line: lines[closingIndex] })}`)
-    index = closingIndex
-  }
-
-  return result.join('')
-}
-
-function readTldrawPayload(content: InlineItem[] | undefined): TldrawPayload | null {
-  const onlyItem = content?.length === 1 ? content[0] : null
-  if (onlyItem?.type !== 'text' || typeof onlyItem.text !== 'string') return null
-  return readTldrawToken({ text: onlyItem.text })
-}
-
 function buildTldrawBlock(block: BlockLike, payload: TldrawPayload): BlockLike {
   return {
     ...block,
@@ -228,21 +96,7 @@ function buildTldrawBlock(block: BlockLike, payload: TldrawPayload): BlockLike {
   }
 }
 
-function readCodeBlockLanguage({ block }: CodeBlockSource): string | null {
-  const language = block.props?.language
-  if (typeof language !== 'string') return null
-
-  return language.trim().split(/\s+/u)[0]?.toLowerCase() ?? null
-}
-
-function readInlineText(content: InlineItem[] | undefined): string | null {
-  if (!Array.isArray(content)) return null
-  return content.map((item) => (
-    item.type === 'text' && typeof item.text === 'string' ? item.text : ''
-  )).join('')
-}
-
-function readTldrawCodeBlock({ block }: CodeBlockSource): TldrawPayload | null {
+function readTldrawCodeBlock(block: BlockLike): TldrawPayload | null {
   if (block.type !== 'codeBlock') return null
   if (readCodeBlockLanguage({ block }) !== 'tldraw') return null
 
@@ -257,17 +111,6 @@ function readTldrawCodeBlock({ block }: CodeBlockSource): TldrawPayload | null {
   }
 }
 
-function injectTldrawInBlock(block: BlockLike): BlockLike {
-  const payload = readTldrawPayload(block.content)
-  if (payload) return buildTldrawBlock(block, payload)
-
-  const codeBlockPayload = readTldrawCodeBlock({ block })
-  if (codeBlockPayload) return buildTldrawBlock(block, codeBlockPayload)
-
-  const children = Array.isArray(block.children) ? block.children.map(injectTldrawInBlock) : block.children
-  return { ...block, children }
-}
-
 function fenceLengthForSnapshot({ snapshot }: SnapshotSource): number {
   const longestRun = Math.max(0, ...Array.from(snapshot.matchAll(/`+/gu), match => match[0].length))
   return Math.max(3, longestRun + 1)
@@ -292,10 +135,6 @@ function tldrawFenceMetadata({ boardId, height, width }: Omit<TldrawPayload, 'sn
   return attributes.length > 0 ? ` ${attributes.join(' ')}` : ''
 }
 
-export function injectTldrawInBlocks(blocks: unknown[]): unknown[] {
-  return (blocks as BlockLike[]).map(injectTldrawInBlock)
-}
-
 export function isTldrawBlock(block: BlockLike): boolean {
   return block.type === TLDRAW_BLOCK_TYPE
     && typeof block.props?.snapshot === 'string'
@@ -310,3 +149,23 @@ export function tldrawMarkdown(block: BlockLike): string {
     width: block.props?.width ?? '',
   })
 }
+
+export const tldrawMarkdownCodec: DurableBlockCodec = {
+  tokenPrefix: TOKEN_PREFIX,
+  tokenSuffix: TOKEN_SUFFIX,
+  readFenceMetadata: readTldrawFenceMetadata,
+  buildPayload: buildTldrawPayload,
+  decodePayload: decodeTldrawPayload,
+  buildBlock: (block, payload) => buildTldrawBlock(block, payload as TldrawPayload),
+  readCodeBlock: readTldrawCodeBlock,
+  isBlock: isTldrawBlock,
+  serializeBlock: tldrawMarkdown,
+}
+
+export function preProcessTldrawMarkdown({ markdown }: { markdown: string }): string {
+  return preProcessDurableMarkdownBlocks({ markdown, codecs: [tldrawMarkdownCodec] })
+}
+
+export function injectTldrawInBlocks(blocks: unknown[]): unknown[] {
+  return injectDurableMarkdownBlocks({ blocks, codecs: [tldrawMarkdownCodec] })
+}