@latentic/live-markdown 0.3.1 → 0.4.1

package/CHANGELOG.md

@@ -1,5 +1,49 @@
 # Changelog
 
+## [0.4.1] - 2026-09-10
+
+### Changed
+
+- **KaTeX is fetched on the first expression, not at every launch.** It is the
+  largest single dependency this package pulls into a host's bundle — 293KB
+  measured in Compose, 13% of its eager chunk — and most documents contain no
+  `$` at all. Compose's eager chunk goes 2,061KB → 1,793KB and its `entry` mark
+  167ms → 150ms.
+
+  The cost is one frame on the first expression in a session; every one after is
+  synchronous. Until KaTeX lands the source stands in, which is also the existing
+  failure mode, so a document that never loads it still shows what was written.
+
+- `mathTypesettingSettled()` is exported for anything that MEASURES rendered
+  math rather than displaying it — a document export, a test.
+
+## [0.4.0] - 2026-09-10
+
+### Fixed
+
+- **The caret was black in dark mode.** CodeMirror paints the cursor from
+  `caret-color`, which the theme never set, so it fell back to the page's text
+  colour instead of the editor's.
+
+### Changed
+
+- **The package ships a mirror of `src/` instead of one bundled module**, so a
+  consumer's bundler can follow the real import graph.
+
+  A single 216KB module is opaque to tree-shaking at the granularity that
+  matters. Reaching for one link helper retained everything it had been bundled
+  with — `yaml`, `dompurify` and the whole CodeMirror surface — and once any
+  eagerly-loaded module in a host app touched the package, all of it landed in
+  that app's launch bundle. Measured in Compose: importing `resolveWorkspaceLink`
+  from the chat panel put 468KB of unrelated source on the path to first paint.
+  The same app's eager chunk is 40% smaller against this build, with no change
+  to a single import site.
+
+  Import paths are unchanged: `.` still resolves to the same exports, now via a
+  2.7KB re-export barrel. Subpaths (`@latentic/live-markdown/links/wikilink`)
+  are additionally available. Relative specifiers in the output carry real `.js`
+  extensions, so the output is valid Node ESM as well — it was not before.
+
 ## [0.3.1] - 2026-08-29
 
 ### Fixed

package/README.md

@@ -49,9 +49,9 @@ The boundary semantics this demands — what every keystroke does at every const
 | Tables | GFM, cell navigation | Plugin | Basic | Plugin | Slash command |
 | Image paste/drop | Built-in | Plugin | No | Plugin | Plugin |
 | Framework | React | React / Vue / vanilla | Vanilla / adapters | React | React |
-| Bundle size | 57 KB gzipped* | ~120 KB+ | ~40 KB | ~150 KB+ | ~200 KB+ |
+| Bundle size | 67 KB gzipped* | ~120 KB+ | ~40 KB | ~150 KB+ | ~200 KB+ |
 
-\* Measured on the published bundle. CodeMirror, KaTeX and Mermaid are external, so you pay for a renderer only where your documents use one — the other figures are the projects' own published numbers and are not all drawn on the same basis.
+\* The whole surface. The package ships one module per source file rather than one bundle, so a host pulls only what it reaches — Compose reaches 90 of 113 — at the cost of ~10 KB in lost cross-module minification if you use all of it. CodeMirror, KaTeX and Mermaid are external, so you pay for a renderer only where your documents use one — the other figures are the projects' own published numbers and are not all drawn on the same basis.
 
 ### Key differentiators
 

package/dist/chunk-V6TY7KAL.js

@@ -0,0 +1,8 @@
+var __defProp = Object.defineProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+
+export {
+  __publicField
+};
+//# sourceMappingURL=chunk-V6TY7KAL.js.map

package/dist/chunk-V6TY7KAL.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}

package/dist/codemirror/CodeMirrorMarkdownEditor.d.ts

@@ -0,0 +1,106 @@
+import * as react from 'react';
+import { ReactNode } from 'react';
+import { EditorView } from '@codemirror/view';
+import { DocumentTextChange, SourceRange } from '../types.js';
+import { RenderClipboardHtml } from './clipboard/copyRich.js';
+import { ResolveImageSrc, SaveImageBytes, OpenExternalUrl, CommentOnExcerpt } from './core/hostFacets.js';
+import { MarkdownExtension, ToolbarContribution } from './extensions/types.js';
+import '@codemirror/state';
+import '../imageSrcResolver.js';
+import './core/paint.js';
+
+type CodeMirrorEditorMode = "wysiwyg" | "source";
+/** A non-empty editor selection, in document byte offsets. */
+interface EditorSelectionSnapshot {
+    range: SourceRange;
+    text: string;
+}
+interface CodeMirrorMarkdownEditorProps {
+    mode?: CodeMirrorEditorMode;
+    onChange: (value: string, changes: DocumentTextChange[]) => void;
+    value: string;
+    workspaceRoot?: string;
+    filePath?: string;
+    linkTargets?: ReadonlySet<string>;
+    onNavigateToLink?: (path: string) => void;
+    /**
+     * Extension modules contributed by the host, merged AFTER the built-ins so a
+     * host can deliberately override a construct (the merger warns when a node
+     * rule is redefined).
+     *
+     * Read when an editor state is built — on mount, and on the swaps that
+     * rebuild one — not on every render, so passing a fresh array each time costs
+     * nothing and cannot remount the editor. Changing it mid-session therefore
+     * takes effect at the next rebuild.
+     *
+     * Applies in BOTH modes: a module's node rules simply go unread while the
+     * decoration painter is off, but its keymaps and plain CodeMirror extensions
+     * are not markdown-rendering concerns and should not be silently dropped in
+     * source mode.
+     */
+    extensions?: readonly MarkdownExtension[];
+    /** Host-rendered toolbar. `contributions` carries the toolbar items the
+     *  extension modules asked for; the host decides whether and how to render
+     *  them alongside its own. */
+    toolbar?: (ctx: {
+        view: EditorView;
+        contributions: readonly ToolbarContribution[];
+    }) => ReactNode;
+    /**
+     * Host-rendered actions for the current text selection (e.g. a comment / ask
+     * bubble). Called with the live selection (or `null` when collapsed) and a
+     * `dismiss` that collapses the selection back to a caret. Omit for none.
+     */
+    selectionActions?: (ctx: {
+        selection: EditorSelectionSnapshot | null;
+        dismiss: () => void;
+    }) => ReactNode;
+    /**
+     * Map a markdown image `src` to a loadable URL. Default: render the reference
+     * as-is. A desktop host maps workspace-relative paths onto its asset protocol.
+     */
+    resolveImageSrc?: ResolveImageSrc;
+    /**
+     * Persist a pasted/dropped image's bytes at a workspace-relative path.
+     * Default: omitted ⇒ the image is inlined as a `data:` URL.
+     */
+    saveImageBytes?: SaveImageBytes;
+    /**
+     * Open a clicked external link. Default: a new browser tab. A desktop host
+     * overrides this to leave the app's webview.
+     */
+    onOpenExternalUrl?: OpenExternalUrl;
+    /**
+     * Comment on a selected table row/column — wired to the table context menu's
+     * "Comment on this row / column". The host opens its comment composer at the
+     * given anchor, seeded with the excerpt. Default: omitted ⇒ no such menu items.
+     */
+    onCommentOnExcerpt?: CommentOnExcerpt;
+    /**
+     * Render a markdown selection to HTML for the clipboard, so a copy pastes
+     * formatted into Google Docs / Slack / Word (the markdown source always
+     * rides along as text/plain). Default: omitted ⇒ plain-only copies.
+     */
+    renderClipboardHtml?: RenderClipboardHtml;
+    /**
+     * Called once, right after a tab-switch content swap commits and paints.
+     * Used by the host for latency instrumentation; no-op by default.
+     */
+    onAfterContentSwap?: () => void;
+    /**
+     * Receives a synchronous `flush()` that pulls the editor's live (debounce-
+     * lagged) content into the last `onChange` immediately — the host calls it
+     * before persisting. `null` is passed on unmount. Lets a host avoid writing
+     * stale buffers on Cmd+S / tab close.
+     */
+    onFlushReady?: (flush: (() => void) | null) => void;
+}
+declare function CodeMirrorMarkdownEditorInner({ mode, onChange, value, workspaceRoot, filePath, linkTargets, onNavigateToLink, extensions: hostExtensions, toolbar, selectionActions, resolveImageSrc, saveImageBytes, onOpenExternalUrl, onCommentOnExcerpt, renderClipboardHtml, onAfterContentSwap, onFlushReady, }: CodeMirrorMarkdownEditorProps): react.JSX.Element;
+/**
+ * Memoised export — same reason as the Tiptap editor. AppShell
+ * re-renders on every chat-thread token; without memoisation each
+ * token would blow through the editor's render path.
+ */
+declare const CodeMirrorMarkdownEditor: react.MemoExoticComponent<typeof CodeMirrorMarkdownEditorInner>;
+
+export { type CodeMirrorEditorMode, CodeMirrorMarkdownEditor, type CodeMirrorMarkdownEditorProps, type EditorSelectionSnapshot };

package/dist/codemirror/CodeMirrorMarkdownEditor.js

@@ -0,0 +1,482 @@
+import "../chunk-V6TY7KAL.js";
+import { jsx, jsxs } from "react/jsx-runtime";
+import {
+  memo,
+  useCallback,
+  useEffect,
+  useLayoutEffect,
+  useMemo,
+  useRef,
+  useState
+} from "react";
+import { defaultKeymap, history, historyKeymap } from "@codemirror/commands";
+import { markdown, markdownKeymap, markdownLanguage } from "@codemirror/lang-markdown";
+import { languages } from "@codemirror/language-data";
+import { Annotation, EditorSelection, EditorState } from "@codemirror/state";
+import { EditorView, keymap } from "@codemirror/view";
+import { parseFrontmatter, serializeMarkdown } from "../frontmatter.js";
+import { byteRangeOf } from "./byteOffset.js";
+import { drawnCaret } from "./caretLayer.js";
+import { drawnSelection } from "./selectionLayer.js";
+import { markdownPaste } from "./clipboard/pasteMarkdown.js";
+import {
+  renderClipboardHtmlFacet,
+  richCopy
+} from "./clipboard/copyRich.js";
+import { onEditorUpdate, updateBus } from "./updateBus.js";
+import {
+  codeHighlight,
+  codeLanguageUI,
+  fenceAutoCloseKeymap,
+  fenceCaretGuard,
+  fenceTabKeymap,
+  fenceTypeAutoClose
+} from "./code/index.js";
+import {
+  commentOnExcerptFacet,
+  editorBaseTheme,
+  markdownDecorationsPlugin,
+  openExternalUrlFacet,
+  parseToEnd,
+  resolveImageSrcFacet,
+  saveImageBytesFacet
+} from "./core/index.js";
+import {
+  clickModel,
+  cursorModelKeymap,
+  deleteNormalizerKeymap,
+  flankingGuard,
+  navigateToFacet
+} from "./interaction/index.js";
+import { tightListKeymap, listIndentKeymap } from "./list/index.js";
+import { formatCommandsKeymap, blockCommandsKeymap } from "./format/index.js";
+import { imageContextFacet, imageInsertHandlers } from "./image/index.js";
+import { computeFileDir } from "../imageSrcResolver.js";
+import { wikilinkFromPathFacet, wikilinkTargetsFacet } from "./wikilink/index.js";
+import {
+  mergeExtensions,
+  footnoteExtension,
+  highlightExtension,
+  mathExtension,
+  mermaidExtension,
+  tableExtension,
+  wikilinkExtension
+} from "./extensions/index.js";
+const programmaticSwap = Annotation.define();
+const AUTOSAVE_DEBOUNCE_MS = 500;
+function hashString(s) {
+  let h = 2166136261;
+  for (let i = 0; i < s.length; i += 1) {
+    h ^= s.charCodeAt(i);
+    h = h * 16777619 >>> 0;
+  }
+  return h.toString(16);
+}
+function CodeMirrorMarkdownEditorInner({
+  mode = "wysiwyg",
+  onChange,
+  value,
+  workspaceRoot,
+  filePath,
+  linkTargets,
+  onNavigateToLink,
+  extensions: hostExtensions,
+  toolbar,
+  selectionActions,
+  resolveImageSrc,
+  saveImageBytes,
+  onOpenExternalUrl,
+  onCommentOnExcerpt,
+  renderClipboardHtml,
+  onAfterContentSwap,
+  onFlushReady
+}) {
+  const parsedRef = useRef(parseFrontmatter(value));
+  const frontmatterRef = useRef(parsedRef.current.frontmatter);
+  const bodyRef = useRef(parsedRef.current.body);
+  const lastEmittedHashRef = useRef(hashString(value));
+  const autosaveTimerRef = useRef(null);
+  const hostRef = useRef(null);
+  const viewRef = useRef(null);
+  const [viewForToolbar, setViewForToolbar] = useState(null);
+  const [bubbleSelection, setBubbleSelection] = useState(null);
+  const onChangeRef = useRef(onChange);
+  useLayoutEffect(function syncLatestOnChangeRef() {
+    onChangeRef.current = onChange;
+  });
+  const resolveImageSrcRef = useRef(resolveImageSrc);
+  const saveImageBytesRef = useRef(saveImageBytes);
+  const openExternalUrlRef = useRef(onOpenExternalUrl);
+  const onCommentOnExcerptRef = useRef(onCommentOnExcerpt);
+  const renderClipboardHtmlRef = useRef(renderClipboardHtml);
+  const onAfterContentSwapRef = useRef(onAfterContentSwap);
+  const onFlushReadyRef = useRef(onFlushReady);
+  useLayoutEffect(function syncHostSeamRefs() {
+    resolveImageSrcRef.current = resolveImageSrc;
+    saveImageBytesRef.current = saveImageBytes;
+    openExternalUrlRef.current = onOpenExternalUrl;
+    onCommentOnExcerptRef.current = onCommentOnExcerpt;
+    renderClipboardHtmlRef.current = renderClipboardHtml;
+    onAfterContentSwapRef.current = onAfterContentSwap;
+    onFlushReadyRef.current = onFlushReady;
+  });
+  const decorationsEnabled = mode === "wysiwyg";
+  const imageCtx = useMemo(
+    () => ({ fileDir: computeFileDir(workspaceRoot, filePath) }),
+    [workspaceRoot, filePath]
+  );
+  const editorStatesRef = useRef(/* @__PURE__ */ new Map());
+  const syncedHashRef = useRef(/* @__PURE__ */ new Map());
+  const currentFileRef = useRef(filePath);
+  const modeInitializedRef = useRef(decorationsEnabled);
+  const hostExtensionsRef = useRef(hostExtensions);
+  hostExtensionsRef.current = hostExtensions;
+  const toolbarContributionsRef = useRef([]);
+  function buildExtensions() {
+    const base = [
+      history(),
+      // Update fan-out for reactive chrome (toolbar pressed-states, selection
+      // bubble). Must ride the BASE extensions: anything appended to a single
+      // state's config dies on the next setState (tab switch) and the chrome
+      // freezes at the previous document's context.
+      updateBus,
+      // Whitespace typed at a bold/italic/strike content edge lands outside
+      // the markers, or the closing delimiter stops parsing (#94).
+      flankingGuard,
+      // Caret and selection both draw from the editor's own selection state:
+      // the native contentEditable caret double-paints at atomic widget
+      // boundaries (#62), and native ::selection can only highlight rendered
+      // DOM, so a whole-document selection loses its highlight outside the
+      // virtualized viewport (#166). Table cells run their own subview
+      // without either, keeping their native caret and selection.
+      drawnCaret,
+      drawnSelection,
+      // Tight list continuation — Enter drops the next bullet directly below,
+      // never with a blank-line gap (overrides the stock markdown Enter for
+      // non-empty list items; see listContinuation.ts).
+      tightListKeymap,
+      // Enter on a just-typed ``` closes the fence with the caret inside —
+      // an unclosed fence would swallow the rest of the document (#91).
+      fenceAutoCloseKeymap,
+      // The keystroke completing a bare ``` closes the fence immediately, so
+      // an unclosed opener never swallows the document below (§9.5).
+      fenceTypeAutoClose,
+      // Tab indents inside a code block (Shift-Tab dedents) — otherwise the
+      // browser's focus navigation steals the key mid-code (§12.8).
+      fenceTabKeymap,
+      // The caret never parks on a fence's marker rows: clicks land on the
+      // nearest content edge, arrow motion crosses out of the block (§12.9).
+      fenceCaretGuard,
+      // Opener-row language pill (+ "plain" placeholder) opens the chooser;
+      // right-click a block for set-language / copy-code (ADR 0002).
+      codeLanguageUI,
+      // Tab / Shift-Tab nest / promote a list item by the parent marker width
+      // (list-aware; falls through to normal Tab outside a list — listIndent.ts).
+      listIndentKeymap,
+      keymap.of([...defaultKeymap, ...historyKeymap, ...markdownKeymap]),
+      // markdownLanguage = CommonMark + GFM (tables, task lists,
+      // strikethrough). Without `base`, `markdown()` uses bare
+      // CommonMark — Lezer never produces Table / Task / Strikethrough
+      // nodes and our registry can't decorate them.
+      //
+      // `remove: ["SetextHeading"]` disables setext headings — the rule that a
+      // line of text immediately followed by a line of `---` (or `===`) turns
+      // the text into a heading. That rule silently rewrites the line ABOVE
+      // when you type `-` under a paragraph, which is surprising in a rich
+      // editor (and fought our "lone `-` is literal until a space" bullet
+      // rule). ATX `#` headings are unaffected.
+      // `codeLanguages` gives fenced blocks a real nested parse (lazily
+      // loaded per info string) — actual syntax highlighting via
+      // codeHighlight, which styles only code-emitted tags (ADR 0002).
+      markdown({
+        base: markdownLanguage,
+        codeLanguages: languages,
+        extensions: [{ remove: ["SetextHeading"] }]
+      }),
+      codeHighlight,
+      EditorView.lineWrapping,
+      // Editor-internal styling (font, line-height, heading sizes,
+      // marker widget styling) lives in `editorBaseTheme` so it
+      // participates in CM6's line-metric measurement cycle. Don't
+      // duplicate these rules in `global.scss` — that's where the
+      // earlier click-drift bug came from.
+      editorBaseTheme,
+      // Image-src resolution context for the inline image widget.
+      imageContextFacet.of(imageCtx),
+      // Image paste / drop pipeline. Pulls bytes off the clipboard
+      // or DataTransfer, saves through `insertImageBlob`, inserts
+      // `![alt](path)` at the caret.
+      imageInsertHandlers,
+      // Clipboard interop (#134/#135): rich pastes convert to markdown
+      // (image-file pastes stay with the handler above); copies carry
+      // markdown + rendered HTML. After imageInsertHandlers so file pastes
+      // resolve there first.
+      markdownPaste,
+      richCopy,
+      renderClipboardHtmlFacet.of(
+        (markdown2) => (renderClipboardHtmlRef.current ?? (() => null))(markdown2)
+      ),
+      // Host-environment seams. Registered as stable wrappers (reading the
+      // latest prop through a ref) only when the host provides the capability;
+      // otherwise the facet's browser default applies. See hostFacets.ts.
+      ...resolveImageSrc ? [
+        resolveImageSrcFacet.of(
+          (rawSrc, ctx) => (resolveImageSrcRef.current ?? ((s) => s))(rawSrc, ctx)
+        )
+      ] : [],
+      ...saveImageBytes ? [
+        saveImageBytesFacet.of((relPath, bytes) => {
+          const fn = saveImageBytesRef.current;
+          return fn ? fn(relPath, bytes) : Promise.reject(new Error("no saver"));
+        })
+      ] : [],
+      ...onOpenExternalUrl ? [
+        openExternalUrlFacet.of((url) => {
+          openExternalUrlRef.current?.(url);
+        })
+      ] : [],
+      ...onCommentOnExcerpt ? [
+        commentOnExcerptFacet.of((excerpt, anchor) => {
+          onCommentOnExcerptRef.current?.(excerpt, anchor);
+        })
+      ] : [],
+      // Wikilink resolution facets stay in both modes so Cmd-click
+      // can navigate from Raw view too — only the decorating plugin
+      // itself is gated by `decorationsEnabled` below.
+      wikilinkFromPathFacet.of(filePath),
+      wikilinkTargetsFacet.of(linkTargets ?? /* @__PURE__ */ new Set()),
+      ...onNavigateToLink ? [navigateToFacet.of(onNavigateToLink)] : [],
+      // Cursor model: arrow/shift+arrow → next visible source
+      // position, skipping hidden markdown syntax in one step.
+      cursorModelKeymap,
+      // Backspace / Delete: removes visible content; collapses an
+      // emptied styled span (no dangling `****`).
+      deleteNormalizerKeymap,
+      // Cmd+B / Cmd+I / Cmd+E: toggle bold / italic / inline code.
+      formatCommandsKeymap,
+      // Cmd+1..3 / Cmd+Shift+7..9: heading levels, lists, blockquote.
+      blockCommandsKeymap,
+      // Click model: Cmd/Ctrl-click on a link opens it; caret
+      // placement never lands inside a hidden marker (snap-to-content).
+      clickModel,
+      // The editor invariant: the syntax tree covers the whole document, not
+      // just what the viewport rendered — widgets, affordances and structural
+      // commands anywhere in the note are wrong without it.
+      parseToEnd,
+      EditorView.updateListener.of((update) => {
+        if (!update.docChanged) return;
+        if (update.transactions.every((tr) => tr.annotation(programmaticSwap))) {
+          return;
+        }
+        if (autosaveTimerRef.current !== null) {
+          window.clearTimeout(autosaveTimerRef.current);
+        }
+        autosaveTimerRef.current = window.setTimeout(() => {
+          autosaveTimerRef.current = null;
+          const body = update.view.state.doc.toString();
+          bodyRef.current = body;
+          const full = serializeMarkdown({
+            frontmatter: frontmatterRef.current,
+            body
+          });
+          const hash = hashString(full);
+          if (hash === lastEmittedHashRef.current) return;
+          lastEmittedHashRef.current = hash;
+          if (currentFileRef.current !== void 0) {
+            syncedHashRef.current.set(currentFileRef.current, hash);
+          }
+          onChangeRef.current(full, []);
+        }, AUTOSAVE_DEBOUNCE_MS);
+      })
+    ];
+    if (decorationsEnabled) {
+      base.push(markdownDecorationsPlugin);
+    }
+    const merged = mergeExtensions([
+      ...decorationsEnabled ? [
+        wikilinkExtension,
+        highlightExtension,
+        footnoteExtension,
+        mathExtension,
+        mermaidExtension,
+        tableExtension()
+      ] : [],
+      ...hostExtensionsRef.current ?? []
+    ]);
+    base.push(...merged.extensions);
+    toolbarContributionsRef.current = merged.toolbar;
+    return base;
+  }
+  const buildExtensionsRef = useRef(buildExtensions);
+  useLayoutEffect(function syncBuildExtensionsRef() {
+    buildExtensionsRef.current = buildExtensions;
+  });
+  useLayoutEffect(function mountEditorView() {
+    const host = hostRef.current;
+    if (!host) return;
+    const initial = EditorState.create({
+      doc: bodyRef.current,
+      extensions: buildExtensionsRef.current()
+    });
+    if (currentFileRef.current !== void 0) {
+      editorStatesRef.current.set(currentFileRef.current, initial);
+      syncedHashRef.current.set(currentFileRef.current, lastEmittedHashRef.current);
+    }
+    const view = new EditorView({ state: initial, parent: host });
+    viewRef.current = view;
+    setViewForToolbar(view);
+    return function teardownEditorView() {
+      bodyRef.current = view.state.doc.toString();
+      view.destroy();
+      viewRef.current = null;
+      setViewForToolbar(null);
+    };
+  }, []);
+  useEffect(function syncEditorToActiveFile() {
+    const view = viewRef.current;
+    if (!view) return;
+    const incomingHash = hashString(value);
+    const switchingFile = currentFileRef.current !== filePath;
+    if (!switchingFile) {
+      if (incomingHash === lastEmittedHashRef.current) return;
+      const parsed2 = parseFrontmatter(value);
+      frontmatterRef.current = parsed2.frontmatter;
+      bodyRef.current = parsed2.body;
+      lastEmittedHashRef.current = incomingHash;
+      view.dispatch({
+        changes: { from: 0, to: view.state.doc.length, insert: parsed2.body },
+        annotations: programmaticSwap.of(true)
+      });
+      if (filePath !== void 0) syncedHashRef.current.set(filePath, incomingHash);
+      return;
+    }
+    const prev = currentFileRef.current;
+    if (autosaveTimerRef.current !== null) {
+      window.clearTimeout(autosaveTimerRef.current);
+      autosaveTimerRef.current = null;
+      const outgoingBody = view.state.doc.toString();
+      const outgoingFull = serializeMarkdown({
+        frontmatter: frontmatterRef.current,
+        body: outgoingBody
+      });
+      const outgoingHash = hashString(outgoingFull);
+      if (outgoingHash !== lastEmittedHashRef.current) {
+        if (prev !== void 0) syncedHashRef.current.set(prev, outgoingHash);
+        onChangeRef.current(outgoingFull, []);
+      }
+    }
+    if (prev !== void 0) editorStatesRef.current.set(prev, view.state);
+    const parsed = parseFrontmatter(value);
+    frontmatterRef.current = parsed.frontmatter;
+    bodyRef.current = parsed.body;
+    lastEmittedHashRef.current = incomingHash;
+    currentFileRef.current = filePath;
+    const key = filePath ?? "";
+    const cached = editorStatesRef.current.get(key);
+    const cachedHash = syncedHashRef.current.get(key);
+    if (cached && cachedHash === incomingHash) {
+      view.setState(cached);
+    } else {
+      const state = EditorState.create({
+        doc: parsed.body,
+        extensions: buildExtensionsRef.current()
+      });
+      editorStatesRef.current.set(key, state);
+      syncedHashRef.current.set(key, incomingHash);
+      view.setState(state);
+    }
+    requestAnimationFrame(() => onAfterContentSwapRef.current?.());
+  }, [filePath, value]);
+  useEffect(function rebuildOnModeChange() {
+    const view = viewRef.current;
+    if (!view) return;
+    if (modeInitializedRef.current === decorationsEnabled) return;
+    modeInitializedRef.current = decorationsEnabled;
+    const liveBody = view.state.doc.toString();
+    editorStatesRef.current.clear();
+    syncedHashRef.current.clear();
+    const state = EditorState.create({
+      doc: liveBody,
+      extensions: buildExtensionsRef.current()
+    });
+    if (currentFileRef.current !== void 0) {
+      editorStatesRef.current.set(currentFileRef.current, state);
+      syncedHashRef.current.set(currentFileRef.current, lastEmittedHashRef.current);
+    }
+    view.setState(state);
+  }, [decorationsEnabled]);
+  const flushPendingToBuffer = useCallback(function flushPendingToBuffer2() {
+    const view = viewRef.current;
+    if (!view) return;
+    if (autosaveTimerRef.current !== null) {
+      window.clearTimeout(autosaveTimerRef.current);
+      autosaveTimerRef.current = null;
+    }
+    const body = view.state.doc.toString();
+    bodyRef.current = body;
+    const full = serializeMarkdown({ frontmatter: frontmatterRef.current, body });
+    const hash = hashString(full);
+    if (hash === lastEmittedHashRef.current) return;
+    lastEmittedHashRef.current = hash;
+    onChangeRef.current(full, []);
+  }, []);
+  useEffect(function registerFlushBridge() {
+    onFlushReadyRef.current?.(flushPendingToBuffer);
+    return function unregisterFlushBridge() {
+      onFlushReadyRef.current?.(null);
+    };
+  }, [flushPendingToBuffer]);
+  useEffect(function cancelPendingAutosaveOnUnmount() {
+    return function clearAutosaveTimer() {
+      if (autosaveTimerRef.current !== null) {
+        window.clearTimeout(autosaveTimerRef.current);
+      }
+    };
+  }, []);
+  useEffect(
+    function trackSelectionForCommentBubble() {
+      const view = viewForToolbar;
+      if (!view) return;
+      const refresh = () => {
+        const main = view.state.selection.main;
+        if (main.empty) {
+          setBubbleSelection(null);
+        } else {
+          setBubbleSelection({
+            range: byteRangeOf(view.state, main.from, main.to),
+            text: view.state.sliceDoc(main.from, main.to)
+          });
+        }
+      };
+      refresh();
+      return onEditorUpdate(view, (update) => {
+        if (update.docChanged || update.selectionSet) refresh();
+      });
+    },
+    [viewForToolbar]
+  );
+  const dismissSelection = useCallback(() => {
+    const view = viewRef.current;
+    if (!view) return;
+    const head = view.state.selection.main.head;
+    view.dispatch({ selection: EditorSelection.cursor(head) });
+  }, []);
+  const toolbarNode = useMemo(
+    () => viewForToolbar && toolbar ? toolbar({ view: viewForToolbar, contributions: toolbarContributionsRef.current }) : null,
+    [viewForToolbar, toolbar]
+  );
+  const selectionNode = useMemo(
+    () => selectionActions ? selectionActions({ selection: bubbleSelection, dismiss: dismissSelection }) : null,
+    [selectionActions, bubbleSelection, dismissSelection]
+  );
+  return /* @__PURE__ */ jsxs("div", { className: "tiptap-editor cm-editor-host", children: [
+    toolbarNode,
+    /* @__PURE__ */ jsx("div", { className: "tiptap-editor__scroll cm-editor-host__scroll", ref: hostRef }),
+    selectionNode
+  ] });
+}
+const CodeMirrorMarkdownEditor = memo(CodeMirrorMarkdownEditorInner);
+export {
+  CodeMirrorMarkdownEditor
+};
+//# sourceMappingURL=CodeMirrorMarkdownEditor.js.map