@latentic/live-markdown 0.3.0 → 0.4.0

package/dist/codemirror/core/paint.d.ts

@@ -0,0 +1,118 @@
+import { EditorState, Facet } from '@codemirror/state';
+import { Decoration } from '@codemirror/view';
+
+/**
+ * The rendering contract: one polymorphic shape for "how does a Lezer node
+ * render", replacing three parallel dispatch surfaces (a data-entry union, a
+ * widget-name union + builders map, and a contextual-override switch).
+ *
+ *   NodeRule  = (ctx) => Paint      — one function per node NAME
+ *   Paint     = which CM6 mechanism  — a CLOSED union
+ *
+ * The openness is split on the right axis: CONSTRUCTS grow (every new node
+ * adds a rule — one entry, one place, usually one line via the combinators
+ * below), while the ways to PAINT don't (line class / span mark / hide /
+ * widget / nothing — CodeMirror's own vocabulary). The single switch over
+ * `Paint` lives in the painter (plugin.ts) and never changes when a
+ * construct is added.
+ *
+ * Context (the bare-URL lesson: a node name can mean different things in
+ * different parents) is not a bolt-on — every rule IS a function of context;
+ * simple rules just ignore it.
+ *
+ * Extensions contribute rules through {@link nodeRulesFacet}: a plugin that
+ * introduces node names ships its rules alongside its grammar, touching no
+ * core file.
+ */
+
+interface NodeLike {
+    readonly name: string;
+    readonly from: number;
+    readonly to: number;
+    readonly parent: NodeLike | null;
+    readonly firstChild: NodeLike | null;
+    readonly nextSibling: NodeLike | null;
+    readonly prevSibling: NodeLike | null;
+    getChild(type: string): NodeLike | null;
+}
+/** Everything a rule may consult. */
+interface NodeContext {
+    readonly name: string;
+    readonly from: number;
+    readonly to: number;
+    /** The parent node's name — the common contextual discriminator. */
+    readonly parentName: string | undefined;
+    /** Full structural node, for rules that need siblings/children. */
+    readonly node: NodeLike;
+    /** Rules are pure over state — no view dependency, so non-editor
+     *  renderers (table cells) can invoke the same rules. */
+    readonly state: EditorState;
+}
+/** One painting instruction, in CodeMirror's own vocabulary. */
+type Paint = 
+/** Stamp a line class — on the node's first line, or every spanned line. */
+{
+    readonly paint: "lineClass";
+    readonly className: string;
+    readonly span: "first" | "all";
+}
+/** Style the node's span. */
+ | {
+    readonly paint: "mark";
+    readonly className: string;
+}
+/**
+ * Hide a range (default: the node, plus its one separator space when
+ * line-leading) and make it atomic to caret motion. `atomicTo` widens the
+ * atom past the hidden range (marker + space move as one unit).
+ */
+ | {
+    readonly paint: "hide";
+    readonly range?: {
+        readonly from: number;
+        readonly to: number;
+    };
+    readonly expandSpace?: boolean;
+    readonly atomicTo?: number;
+}
+/** Replace the (hidden) span with a widget decoration. */
+ | {
+    readonly paint: "widget";
+    readonly deco: Decoration;
+    readonly atomicTo?: number;
+}
+/** Leave the node alone — visible raw source. */
+ | {
+    readonly paint: "none";
+};
+interface RuleMeta {
+    readonly intent: "render-raw" | "structural";
+    readonly why: string;
+}
+/** How one node name renders. `meta` tags the deliberate do-nothing rules so
+ *  the coverage test can insist their reason is documented. */
+type NodeRule = ((ctx: NodeContext) => Paint) & {
+    readonly meta?: RuleMeta;
+};
+type NodeRules = Readonly<Record<string, NodeRule>>;
+/** Style the node's span with a class. */
+declare function mark(className: string): NodeRule;
+/** Stamp a line class on every line the node spans. */
+declare function line(className: string): NodeRule;
+/** Stamp a line class on the node's first line only (headings). */
+declare function headingLine(className: string): NodeRule;
+/** Hide the node (marker chrome), atomically. */
+declare function hideAlways(): NodeRule;
+/** Deliberately unstyled-for-now, visible raw — `why` documents the intent. */
+declare function raw(why: string): NodeRule;
+/** A parser grouping construct, never directly visible — `why` says which. */
+declare function structural(why: string): NodeRule;
+declare const none: Paint;
+/**
+ * Rules contributed by extensions, merged over the base table (an extension
+ * may also deliberately override a base rule — last provider wins). The
+ * painter reads THIS, never the base table directly.
+ */
+declare const nodeRulesFacet: Facet<Readonly<Record<string, NodeRule>>, Readonly<Record<string, NodeRule>>>;
+
+export { type NodeContext, type NodeLike, type NodeRule, type NodeRules, type Paint, type RuleMeta, headingLine, hideAlways, line, mark, nodeRulesFacet, none, raw, structural };

package/dist/codemirror/core/paint.js

@@ -0,0 +1,42 @@
+import "../../chunk-V6TY7KAL.js";
+import { Facet } from "@codemirror/state";
+const NONE = { paint: "none" };
+function mark(className) {
+  const paint = { paint: "mark", className };
+  return () => paint;
+}
+function line(className) {
+  const paint = { paint: "lineClass", className, span: "all" };
+  return () => paint;
+}
+function headingLine(className) {
+  const paint = { paint: "lineClass", className, span: "first" };
+  return () => paint;
+}
+function hideAlways() {
+  const paint = { paint: "hide" };
+  return () => paint;
+}
+function raw(why) {
+  return Object.assign(() => NONE, { meta: { intent: "render-raw", why } });
+}
+function structural(why) {
+  return Object.assign(() => NONE, { meta: { intent: "structural", why } });
+}
+const none = NONE;
+const nodeRulesFacet = Facet.define({
+  combine(values) {
+    return Object.assign({}, ...values);
+  }
+});
+export {
+  headingLine,
+  hideAlways,
+  line,
+  mark,
+  nodeRulesFacet,
+  none,
+  raw,
+  structural
+};
+//# sourceMappingURL=paint.js.map

package/dist/codemirror/core/paint.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/codemirror/core/paint.ts"],"sourcesContent":["/**\n * The rendering contract: one polymorphic shape for \"how does a Lezer node\n * render\", replacing three parallel dispatch surfaces (a data-entry union, a\n * widget-name union + builders map, and a contextual-override switch).\n *\n *   NodeRule  = (ctx) => Paint      — one function per node NAME\n *   Paint     = which CM6 mechanism  — a CLOSED union\n *\n * The openness is split on the right axis: CONSTRUCTS grow (every new node\n * adds a rule — one entry, one place, usually one line via the combinators\n * below), while the ways to PAINT don't (line class / span mark / hide /\n * widget / nothing — CodeMirror's own vocabulary). The single switch over\n * `Paint` lives in the painter (plugin.ts) and never changes when a\n * construct is added.\n *\n * Context (the bare-URL lesson: a node name can mean different things in\n * different parents) is not a bolt-on — every rule IS a function of context;\n * simple rules just ignore it.\n *\n * Extensions contribute rules through {@link nodeRulesFacet}: a plugin that\n * introduces node names ships its rules alongside its grammar, touching no\n * core file.\n */\n\nimport { Facet, type EditorState } from \"@codemirror/state\";\nimport { type Decoration } from \"@codemirror/view\";\n\n// Structural stand-in for a Lezer node (`@lezer/common` is a transitive dep\n// this package deliberately doesn't import from).\nexport interface NodeLike {\n  readonly name: string;\n  readonly from: number;\n  readonly to: number;\n  readonly parent: NodeLike | null;\n  readonly firstChild: NodeLike | null;\n  readonly nextSibling: NodeLike | null;\n  readonly prevSibling: NodeLike | null;\n  getChild(type: string): NodeLike | null;\n}\n\n/** Everything a rule may consult. */\nexport interface NodeContext {\n  readonly name: string;\n  readonly from: number;\n  readonly to: number;\n  /** The parent node's name — the common contextual discriminator. */\n  readonly parentName: string | undefined;\n  /** Full structural node, for rules that need siblings/children. */\n  readonly node: NodeLike;\n  /** Rules are pure over state — no view dependency, so non-editor\n   *  renderers (table cells) can invoke the same rules. */\n  readonly state: EditorState;\n}\n\n/** One painting instruction, in CodeMirror's own vocabulary. */\nexport type Paint =\n  /** Stamp a line class — on the node's first line, or every spanned line. */\n  | { readonly paint: \"lineClass\"; readonly className: string; readonly span: \"first\" | \"all\" }\n  /** Style the node's span. */\n  | { readonly paint: \"mark\"; readonly className: string }\n  /**\n   * Hide a range (default: the node, plus its one separator space when\n   * line-leading) and make it atomic to caret motion. `atomicTo` widens the\n   * atom past the hidden range (marker + space move as one unit).\n   */\n  | {\n      readonly paint: \"hide\";\n      readonly range?: { readonly from: number; readonly to: number };\n      readonly expandSpace?: boolean;\n      readonly atomicTo?: number;\n    }\n  /** Replace the (hidden) span with a widget decoration. */\n  | { readonly paint: \"widget\"; readonly deco: Decoration; readonly atomicTo?: number }\n  /** Leave the node alone — visible raw source. */\n  | { readonly paint: \"none\" };\n\nexport interface RuleMeta {\n  readonly intent: \"render-raw\" | \"structural\";\n  readonly why: string;\n}\n\n/** How one node name renders. `meta` tags the deliberate do-nothing rules so\n *  the coverage test can insist their reason is documented. */\nexport type NodeRule = ((ctx: NodeContext) => Paint) & { readonly meta?: RuleMeta };\n\nexport type NodeRules = Readonly<Record<string, NodeRule>>;\n\n/* ---------------- Combinators — the common rules as one-liners ------------ */\n\nconst NONE: Paint = { paint: \"none\" };\n\n/** Style the node's span with a class. */\nexport function mark(className: string): NodeRule {\n  const paint: Paint = { paint: \"mark\", className };\n  return () => paint;\n}\n\n/** Stamp a line class on every line the node spans. */\nexport function line(className: string): NodeRule {\n  const paint: Paint = { paint: \"lineClass\", className, span: \"all\" };\n  return () => paint;\n}\n\n/** Stamp a line class on the node's first line only (headings). */\nexport function headingLine(className: string): NodeRule {\n  const paint: Paint = { paint: \"lineClass\", className, span: \"first\" };\n  return () => paint;\n}\n\n/** Hide the node (marker chrome), atomically. */\nexport function hideAlways(): NodeRule {\n  const paint: Paint = { paint: \"hide\" };\n  return () => paint;\n}\n\n/** Deliberately unstyled-for-now, visible raw — `why` documents the intent. */\nexport function raw(why: string): NodeRule {\n  return Object.assign(() => NONE, { meta: { intent: \"render-raw\", why } as RuleMeta });\n}\n\n/** A parser grouping construct, never directly visible — `why` says which. */\nexport function structural(why: string): NodeRule {\n  return Object.assign(() => NONE, { meta: { intent: \"structural\", why } as RuleMeta });\n}\n\nexport const none: Paint = NONE;\n\n/* ---------------- Extension seam ----------------------------------------- */\n\n/**\n * Rules contributed by extensions, merged over the base table (an extension\n * may also deliberately override a base rule — last provider wins). The\n * painter reads THIS, never the base table directly.\n */\nexport const nodeRulesFacet = Facet.define<NodeRules, NodeRules>({\n  combine(values) {\n    return Object.assign({}, ...values);\n  },\n});\n"],"mappings":";AAwBA,SAAS,aAA+B;AAiExC,MAAM,OAAc,EAAE,OAAO,OAAO;AAG7B,SAAS,KAAK,WAA6B;AAChD,QAAM,QAAe,EAAE,OAAO,QAAQ,UAAU;AAChD,SAAO,MAAM;AACf;AAGO,SAAS,KAAK,WAA6B;AAChD,QAAM,QAAe,EAAE,OAAO,aAAa,WAAW,MAAM,MAAM;AAClE,SAAO,MAAM;AACf;AAGO,SAAS,YAAY,WAA6B;AACvD,QAAM,QAAe,EAAE,OAAO,aAAa,WAAW,MAAM,QAAQ;AACpE,SAAO,MAAM;AACf;AAGO,SAAS,aAAuB;AACrC,QAAM,QAAe,EAAE,OAAO,OAAO;AACrC,SAAO,MAAM;AACf;AAGO,SAAS,IAAI,KAAuB;AACzC,SAAO,OAAO,OAAO,MAAM,MAAM,EAAE,MAAM,EAAE,QAAQ,cAAc,IAAI,EAAc,CAAC;AACtF;AAGO,SAAS,WAAW,KAAuB;AAChD,SAAO,OAAO,OAAO,MAAM,MAAM,EAAE,MAAM,EAAE,QAAQ,cAAc,IAAI,EAAc,CAAC;AACtF;AAEO,MAAM,OAAc;AASpB,MAAM,iBAAiB,MAAM,OAA6B;AAAA,EAC/D,QAAQ,QAAQ;AACd,WAAO,OAAO,OAAO,CAAC,GAAG,GAAG,MAAM;AAAA,EACpC;AACF,CAAC;","names":[]}

package/dist/codemirror/core/parseToEnd.d.ts

@@ -0,0 +1,24 @@
+import { Extension } from '@codemirror/state';
+
+/**
+ * Drives the parse to the end of the document, establishing the invariant the
+ * rest of the editor is written against: **the installed syntax tree covers
+ * the whole document**, not just what the viewport happened to render.
+ *
+ * Without it, CodeMirror's own background work stops 100,000 characters past
+ * the viewport (measured: the tree plateaus at 100,739 for a 167k-character
+ * document and a 341k one alike, and never advances again). Everything
+ * downstream of the tree is then silently wrong for the rest of the document:
+ * table and mermaid widgets never materialize, code-language affordances never
+ * appear, and structural commands are left to re-parse at the caret
+ * ({@link treeAt} — still wanted, since a keystroke can land before this
+ * finishes).
+ *
+ * Scheduled with `setTimeout`, not `requestIdleCallback`: WebKit stops
+ * delivering idle callbacks to an unfocused window, and a note opened while
+ * the app is in the background must still be parsed when the user comes back
+ * to it.
+ */
+declare const parseToEnd: Extension;
+
+export { parseToEnd };

package/dist/codemirror/core/parseToEnd.js

@@ -0,0 +1,38 @@
+import {
+  __publicField
+} from "../../chunk-V6TY7KAL.js";
+import { forceParsing, language, syntaxTree } from "@codemirror/language";
+import { ViewPlugin } from "@codemirror/view";
+const SLICE_MS = 10;
+const GAP_MS = 25;
+const parseToEnd = ViewPlugin.fromClass(
+  class {
+    constructor(view) {
+      __publicField(this, "view", view);
+      __publicField(this, "timer", null);
+      __publicField(this, "work", () => {
+        this.timer = null;
+        const { state } = this.view;
+        if (!state.facet(language)) return;
+        if (syntaxTree(state).length >= state.doc.length) return;
+        forceParsing(this.view, state.doc.length, SLICE_MS);
+        this.schedule();
+      });
+      this.schedule();
+    }
+    update(update) {
+      if (update.docChanged) this.schedule();
+    }
+    destroy() {
+      if (this.timer !== null) window.clearTimeout(this.timer);
+    }
+    schedule() {
+      if (this.timer !== null) return;
+      this.timer = window.setTimeout(this.work, GAP_MS);
+    }
+  }
+);
+export {
+  parseToEnd
+};
+//# sourceMappingURL=parseToEnd.js.map

package/dist/codemirror/core/parseToEnd.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/codemirror/core/parseToEnd.ts"],"sourcesContent":["import { forceParsing, language, syntaxTree } from \"@codemirror/language\";\nimport type { Extension } from \"@codemirror/state\";\nimport { ViewPlugin, type EditorView, type ViewUpdate } from \"@codemirror/view\";\n\n/** Work per slice. Small enough to never register as jank between frames. */\nconst SLICE_MS = 10;\n\n/** Gap between slices, leaving the main thread mostly idle while the tail of a\n * large document parses. Markdown covers ~240k characters in ~43ms of work, so\n * even a very large note finishes within a few hundred ms of opening. */\nconst GAP_MS = 25;\n\n/**\n * Drives the parse to the end of the document, establishing the invariant the\n * rest of the editor is written against: **the installed syntax tree covers\n * the whole document**, not just what the viewport happened to render.\n *\n * Without it, CodeMirror's own background work stops 100,000 characters past\n * the viewport (measured: the tree plateaus at 100,739 for a 167k-character\n * document and a 341k one alike, and never advances again). Everything\n * downstream of the tree is then silently wrong for the rest of the document:\n * table and mermaid widgets never materialize, code-language affordances never\n * appear, and structural commands are left to re-parse at the caret\n * ({@link treeAt} — still wanted, since a keystroke can land before this\n * finishes).\n *\n * Scheduled with `setTimeout`, not `requestIdleCallback`: WebKit stops\n * delivering idle callbacks to an unfocused window, and a note opened while\n * the app is in the background must still be parsed when the user comes back\n * to it.\n */\nexport const parseToEnd: Extension = ViewPlugin.fromClass(\n  class {\n    private timer: number | null = null;\n\n    constructor(private readonly view: EditorView) {\n      this.schedule();\n    }\n\n    update(update: ViewUpdate) {\n      if (update.docChanged) this.schedule();\n    }\n\n    destroy() {\n      if (this.timer !== null) window.clearTimeout(this.timer);\n    }\n\n    private schedule() {\n      if (this.timer !== null) return;\n      this.timer = window.setTimeout(this.work, GAP_MS);\n    }\n\n    private readonly work = () => {\n      this.timer = null;\n      const { state } = this.view;\n      // Without a language nothing will ever parse; rescheduling would poll\n      // forever for a tree that never comes.\n      if (!state.facet(language)) return;\n      if (syntaxTree(state).length >= state.doc.length) return;\n      forceParsing(this.view, state.doc.length, SLICE_MS);\n      // Reschedule until covered, not until progress: a slice can spend its\n      // whole budget without committing a longer tree (measured: the resume\n      // from CodeMirror's own stop point commits nothing on the first slice,\n      // then covers the rest of the document on the next).\n      this.schedule();\n    };\n  },\n);\n"],"mappings":";;;AAAA,SAAS,cAAc,UAAU,kBAAkB;AAEnD,SAAS,kBAAoD;AAG7D,MAAM,WAAW;AAKjB,MAAM,SAAS;AAqBR,MAAM,aAAwB,WAAW;AAAA,EAC9C,MAAM;AAAA,IAGJ,YAA6B,MAAkB;AAAlB;AAF7B,0BAAQ,SAAuB;AAmB/B,0BAAiB,QAAO,MAAM;AAC5B,aAAK,QAAQ;AACb,cAAM,EAAE,MAAM,IAAI,KAAK;AAGvB,YAAI,CAAC,MAAM,MAAM,QAAQ,EAAG;AAC5B,YAAI,WAAW,KAAK,EAAE,UAAU,MAAM,IAAI,OAAQ;AAClD,qBAAa,KAAK,MAAM,MAAM,IAAI,QAAQ,QAAQ;AAKlD,aAAK,SAAS;AAAA,MAChB;AA7BE,WAAK,SAAS;AAAA,IAChB;AAAA,IAEA,OAAO,QAAoB;AACzB,UAAI,OAAO,WAAY,MAAK,SAAS;AAAA,IACvC;AAAA,IAEA,UAAU;AACR,UAAI,KAAK,UAAU,KAAM,QAAO,aAAa,KAAK,KAAK;AAAA,IACzD;AAAA,IAEQ,WAAW;AACjB,UAAI,KAAK,UAAU,KAAM;AACzB,WAAK,QAAQ,OAAO,WAAW,KAAK,MAAM,MAAM;AAAA,IAClD;AAAA,EAgBF;AACF;","names":[]}

package/dist/codemirror/core/plugin.d.ts

@@ -0,0 +1,32 @@
+import { ViewPlugin, DecorationSet, ViewUpdate } from '@codemirror/view';
+
+/**
+ * Markdown decoration plugin — the PAINTER. Walks the Lezer tree against the
+ * visible viewport, asks each node's {@link NodeRule} how to render, and
+ * applies the returned {@link Paint}.
+ *
+ * The painter contains *no* construct knowledge: rules live in the base
+ * table (`NODE_RULES`) merged with any extension-contributed rules
+ * (`nodeRulesFacet`). The one switch here is over `Paint` — CodeMirror's
+ * closed set of mechanisms — so adding a construct, widget, contextual
+ * override, or whole extension never edits this file.
+ *
+ * Perf shape (unchanged from the spike):
+ *   * Walks `view.visibleRanges` against `syntaxTree(view.state)` —
+ *     the work is proportional to the viewport, not the document.
+ *   * Rebuilt on doc change or viewport change.
+ *
+ * Decoration ordering (CM6 requires `from`-then-`startSide` ascending):
+ *   * Line decorations collected in one bucket, mark / replace in
+ *     another. The final `Decoration.set` lets CM6 sort defensively,
+ *     costing ~µs on the typical viewport — cheaper than risking the
+ *     "decorations out of order" runtime error.
+ */
+
+declare const markdownDecorationsPlugin: ViewPlugin<{
+    decorations: DecorationSet;
+    atomic: DecorationSet;
+    update(update: ViewUpdate): void;
+}, undefined>;
+
+export { markdownDecorationsPlugin };

package/dist/codemirror/core/plugin.js

@@ -0,0 +1,161 @@
+import {
+  __publicField
+} from "../../chunk-V6TY7KAL.js";
+import { ensureSyntaxTree, syntaxTree } from "@codemirror/language";
+import { RangeSetBuilder } from "@codemirror/state";
+import {
+  Decoration,
+  EditorView,
+  ViewPlugin
+} from "@codemirror/view";
+import { nodeRulesFacet } from "./paint.js";
+import { NODE_RULES } from "./registry.js";
+const lineDecoCache = /* @__PURE__ */ new Map();
+const markDecoCache = /* @__PURE__ */ new Map();
+const HIDE_MARKER = Decoration.replace({});
+function lineDeco(className) {
+  let d = lineDecoCache.get(className);
+  if (!d) {
+    d = Decoration.line({ class: className });
+    lineDecoCache.set(className, d);
+  }
+  return d;
+}
+function markDeco(className) {
+  let d = markDecoCache.get(className);
+  if (!d) {
+    d = Decoration.mark({ class: className });
+    markDecoCache.set(className, d);
+  }
+  return d;
+}
+const mergedRulesCache = /* @__PURE__ */ new WeakMap();
+function effectiveRules(view) {
+  const extra = view.state.facet(nodeRulesFacet);
+  if (Object.keys(extra).length === 0) return NODE_RULES;
+  let merged = mergedRulesCache.get(extra);
+  if (!merged) {
+    merged = Object.assign({}, NODE_RULES, extra);
+    mergedRulesCache.set(extra, merged);
+  }
+  return merged;
+}
+function expandTrailingSpace(view, range) {
+  const line = view.state.doc.lineAt(range.from);
+  if (range.from !== line.from) return range.to;
+  const charAfter = view.state.doc.sliceString(range.to, range.to + 1);
+  return charAfter === " " ? range.to + 1 : range.to;
+}
+function buildDecorations(view) {
+  const rules = effectiveRules(view);
+  const lineDecs = [];
+  const markDecs = [];
+  const atomicBuilder = new RangeSetBuilder();
+  const tree = ensureSyntaxTree(view.state, view.viewport.to, 100) ?? syntaxTree(view.state);
+  const stampLineRange = (deco, from, to) => {
+    let pos = from;
+    while (pos <= to) {
+      const line = view.state.doc.lineAt(pos);
+      lineDecs.push(deco.range(line.from));
+      if (line.to >= to) break;
+      pos = line.to + 1;
+    }
+  };
+  for (const { from, to } of view.visibleRanges) {
+    tree.iterate({
+      from,
+      to,
+      enter: (node) => {
+        const rule = rules[node.name];
+        if (!rule) {
+          return;
+        }
+        const paint = rule({
+          name: node.name,
+          from: node.from,
+          to: node.to,
+          get parentName() {
+            return node.node.parent?.name;
+          },
+          get node() {
+            return node.node;
+          },
+          state: view.state
+        });
+        switch (paint.paint) {
+          case "lineClass": {
+            if (paint.span === "first") {
+              const line = view.state.doc.lineAt(node.from);
+              lineDecs.push(lineDeco(paint.className).range(line.from));
+            } else {
+              stampLineRange(lineDeco(paint.className), node.from, node.to);
+            }
+            return;
+          }
+          case "mark": {
+            markDecs.push(markDeco(paint.className).range(node.from, node.to));
+            return;
+          }
+          case "hide": {
+            const range = paint.range ?? node;
+            const hideEnd = paint.expandSpace === false ? range.to : expandTrailingSpace(view, range);
+            markDecs.push(HIDE_MARKER.range(range.from, hideEnd));
+            atomicBuilder.add(
+              range.from,
+              Math.max(hideEnd, paint.atomicTo ?? hideEnd),
+              HIDE_MARKER
+            );
+            return;
+          }
+          case "widget": {
+            const hideEnd = expandTrailingSpace(view, node);
+            markDecs.push(paint.deco.range(node.from, hideEnd));
+            atomicBuilder.add(
+              node.from,
+              Math.max(hideEnd, paint.atomicTo ?? hideEnd),
+              paint.deco
+            );
+            return;
+          }
+          case "none":
+            return;
+        }
+      }
+    });
+  }
+  const all = lineDecs.concat(markDecs);
+  return {
+    decorations: Decoration.set(
+      all,
+      /* sort */
+      true
+    ),
+    atomic: atomicBuilder.finish()
+  };
+}
+const markdownDecorationsPlugin = ViewPlugin.fromClass(
+  class {
+    constructor(view) {
+      __publicField(this, "decorations");
+      __publicField(this, "atomic");
+      const built = buildDecorations(view);
+      this.decorations = built.decorations;
+      this.atomic = built.atomic;
+    }
+    update(update) {
+      if (update.docChanged || update.viewportChanged) {
+        const built = buildDecorations(update.view);
+        this.decorations = built.decorations;
+        this.atomic = built.atomic;
+      }
+    }
+  },
+  {
+    decorations: (v) => v.decorations,
+    provide: (plugin) => EditorView.atomicRanges.of((view) => view.plugin(plugin)?.atomic ?? Decoration.none)
+  }
+);
+export {
+  markdownDecorationsPlugin
+};
+//# sourceMappingURL=plugin.js.map

package/dist/codemirror/core/plugin.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/codemirror/core/plugin.ts"],"sourcesContent":["/**\n * Markdown decoration plugin — the PAINTER. Walks the Lezer tree against the\n * visible viewport, asks each node's {@link NodeRule} how to render, and\n * applies the returned {@link Paint}.\n *\n * The painter contains *no* construct knowledge: rules live in the base\n * table (`NODE_RULES`) merged with any extension-contributed rules\n * (`nodeRulesFacet`). The one switch here is over `Paint` — CodeMirror's\n * closed set of mechanisms — so adding a construct, widget, contextual\n * override, or whole extension never edits this file.\n *\n * Perf shape (unchanged from the spike):\n *   * Walks `view.visibleRanges` against `syntaxTree(view.state)` —\n *     the work is proportional to the viewport, not the document.\n *   * Rebuilt on doc change or viewport change.\n *\n * Decoration ordering (CM6 requires `from`-then-`startSide` ascending):\n *   * Line decorations collected in one bucket, mark / replace in\n *     another. The final `Decoration.set` lets CM6 sort defensively,\n *     costing ~µs on the typical viewport — cheaper than risking the\n *     \"decorations out of order\" runtime error.\n */\n\nimport { ensureSyntaxTree, syntaxTree } from \"@codemirror/language\";\nimport { RangeSetBuilder, type Range } from \"@codemirror/state\";\nimport {\n  Decoration,\n  EditorView,\n  type DecorationSet,\n  ViewPlugin,\n  type PluginValue,\n  type ViewUpdate,\n} from \"@codemirror/view\";\n\nimport { nodeRulesFacet, type NodeLike, type NodeRules } from \"./paint\";\nimport { NODE_RULES } from \"./registry\";\n\n/* ---------------- Decoration instances ----------------- */\n//\n// Cached per `className` so we don't allocate a Decoration per node\n// per build. CM6 dedups internally, but skipping the call is cheaper.\n\nconst lineDecoCache = new Map<string, Decoration>();\nconst markDecoCache = new Map<string, Decoration>();\nconst HIDE_MARKER = Decoration.replace({});\n\nfunction lineDeco(className: string): Decoration {\n  let d = lineDecoCache.get(className);\n  if (!d) {\n    d = Decoration.line({ class: className });\n    lineDecoCache.set(className, d);\n  }\n  return d;\n}\n\nfunction markDeco(className: string): Decoration {\n  let d = markDecoCache.get(className);\n  if (!d) {\n    d = Decoration.mark({ class: className });\n    markDecoCache.set(className, d);\n  }\n  return d;\n}\n\n/* ---------------- Effective rules ---------------- */\n\n// Base + extension rules, merged once per distinct facet value (the facet\n// result is referentially stable until providers change).\nconst mergedRulesCache = new WeakMap<NodeRules, NodeRules>();\n\nfunction effectiveRules(view: EditorView): NodeRules {\n  const extra = view.state.facet(nodeRulesFacet);\n  if (Object.keys(extra).length === 0) return NODE_RULES;\n  let merged = mergedRulesCache.get(extra);\n  if (!merged) {\n    merged = Object.assign({}, NODE_RULES, extra);\n    mergedRulesCache.set(extra, merged);\n  }\n  return merged;\n}\n\n/* ---------------- The painter ---------------- */\n\ninterface BuildResult {\n  decorations: DecorationSet;\n  /**\n   * Every hidden/replaced range, surfaced as `EditorView.atomicRanges` so\n   * cursor motion (arrow keys, drag-select, double-click) treats hidden\n   * markup as a single atom — the user moves \"around\" hidden `**` instead\n   * of getting stranded between two invisible characters.\n   */\n  atomic: DecorationSet;\n}\n\n/**\n * Block-level markers (`# ` heading, `> ` quote, `- ` list item) are\n * followed by exactly one separator space; we hide that space along\n * with the marker so the rendered line starts at the first content\n * char. Inline markers (`*`, backticks) don't have this — only the\n * line-leading case applies.\n */\nfunction expandTrailingSpace(\n  view: EditorView,\n  range: { from: number; to: number },\n): number {\n  const line = view.state.doc.lineAt(range.from);\n  if (range.from !== line.from) return range.to;\n  const charAfter = view.state.doc.sliceString(range.to, range.to + 1);\n  return charAfter === \" \" ? range.to + 1 : range.to;\n}\n\nfunction buildDecorations(view: EditorView): BuildResult {\n  const rules = effectiveRules(view);\n  const lineDecs: Range<Decoration>[] = [];\n  const markDecs: Range<Decoration>[] = [];\n  const atomicBuilder = new RangeSetBuilder<Decoration>();\n  // Force-parse through the viewport so a list/task marker stays rendered while\n  // typing: the incremental tree can lag for the just-edited line on a large\n  // doc, briefly dropping the widget back to raw source (#37). Bounded to the\n  // viewport + a timeout, so a large note doesn't pay a full re-parse per key.\n  const tree = ensureSyntaxTree(view.state, view.viewport.to, 100) ?? syntaxTree(view.state);\n\n  // Stamp a Decoration.line on every line overlapping the given\n  // range. CM6 requires `Decoration.line` to be anchored at a line\n  // start; this helper does the line-iteration once for callers.\n  const stampLineRange = (deco: Decoration, from: number, to: number) => {\n    let pos = from;\n    while (pos <= to) {\n      const line = view.state.doc.lineAt(pos);\n      lineDecs.push(deco.range(line.from));\n      if (line.to >= to) break;\n      pos = line.to + 1;\n    }\n  };\n\n  for (const { from, to } of view.visibleRanges) {\n    tree.iterate({\n      from,\n      to,\n      enter: (node) => {\n        const rule = rules[node.name];\n        if (!rule) {\n          // Unknown node — the coverage test prevents this for the base\n          // grammar; an extension grammar's node without a contributed rule\n          // lands here. Skip silently rather than throw: a missing rule\n          // must not break editing.\n          return;\n        }\n        // `node.node` materializes a SyntaxNode (lezer's documented-expensive\n        // path); most rules are constant combinators that never read it, so\n        // the context exposes it — and the parent walk — through lazy getters\n        // that only pay when a contextual rule actually asks.\n        const paint = rule({\n          name: node.name,\n          from: node.from,\n          to: node.to,\n          get parentName() {\n            return node.node.parent?.name;\n          },\n          get node() {\n            return node.node as unknown as NodeLike;\n          },\n          state: view.state,\n        });\n\n        switch (paint.paint) {\n          case \"lineClass\": {\n            if (paint.span === \"first\") {\n              const line = view.state.doc.lineAt(node.from);\n              lineDecs.push(lineDeco(paint.className).range(line.from));\n            } else {\n              stampLineRange(lineDeco(paint.className), node.from, node.to);\n            }\n            return;\n          }\n          case \"mark\": {\n            markDecs.push(markDeco(paint.className).range(node.from, node.to));\n            return;\n          }\n          case \"hide\": {\n            const range = paint.range ?? node;\n            const hideEnd =\n              paint.expandSpace === false ? range.to : expandTrailingSpace(view, range);\n            markDecs.push(HIDE_MARKER.range(range.from, hideEnd));\n            atomicBuilder.add(\n              range.from,\n              Math.max(hideEnd, paint.atomicTo ?? hideEnd),\n              HIDE_MARKER,\n            );\n            return;\n          }\n          case \"widget\": {\n            const hideEnd = expandTrailingSpace(view, node);\n            markDecs.push(paint.deco.range(node.from, hideEnd));\n            atomicBuilder.add(\n              node.from,\n              Math.max(hideEnd, paint.atomicTo ?? hideEnd),\n              paint.deco,\n            );\n            return;\n          }\n          case \"none\":\n            return;\n        }\n      },\n    });\n  }\n\n  // Line decorations before mark/replace at the same point — this is\n  // the canonical CM6 ordering. Concat-then-sort is one O(n log n)\n  // for the whole viewport, dwarfed by the parse cost.\n  const all: Range<Decoration>[] = lineDecs.concat(markDecs);\n  return {\n    decorations: Decoration.set(all, /* sort */ true),\n    atomic: atomicBuilder.finish(),\n  };\n}\n\nexport const markdownDecorationsPlugin = ViewPlugin.fromClass(\n  class implements PluginValue {\n    decorations: DecorationSet;\n    atomic: DecorationSet;\n    constructor(view: EditorView) {\n      const built = buildDecorations(view);\n      this.decorations = built.decorations;\n      this.atomic = built.atomic;\n    }\n    update(update: ViewUpdate) {\n      // No decoration depends on the cursor (markers never reveal on\n      // proximity), so caret-only transactions skip the whole build path.\n      if (update.docChanged || update.viewportChanged) {\n        const built = buildDecorations(update.view);\n        this.decorations = built.decorations;\n        this.atomic = built.atomic;\n      }\n    }\n  },\n  {\n    decorations: (v) => v.decorations,\n    provide: (plugin) =>\n      EditorView.atomicRanges.of((view) => view.plugin(plugin)?.atomic ?? Decoration.none),\n  },\n);\n"],"mappings":"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","names":[]}

package/dist/codemirror/core/registry.d.ts

@@ -0,0 +1,38 @@
+import { NodeRules } from './paint.js';
+import '@codemirror/state';
+import '@codemirror/view';
+
+/**
+ * Canonical table: every Lezer markdown node name → its {@link NodeRule} —
+ * ONE place answering "how does this construct render". The Lezer parser
+ * handles CommonMark + GFM spec compliance; this file is the visual contract.
+ *
+ * Why a table of rules (functions), not data:
+ *
+ *   1. **Completeness is auditable.** `registry.test.ts` reads the live
+ *      parser's node set and fails when any node Lezer emits has no entry
+ *      here — a lezer-markdown bump that adds a node trips the gate before
+ *      it ships unstyled. Only the KEYS matter for that, so entries are free
+ *      to be behavior.
+ *   2. **Context is first-class.** A node name can mean different things in
+ *      different parents (a URL inside `[text](url)` is chrome; a bare
+ *      pasted URL is content — hiding it made an invisible dead zone).
+ *      Every rule receives context; contextual entries are ordinary inline
+ *      functions, readable at the point of definition.
+ *   3. **Adding a construct touches one place.** A styled span is a
+ *      one-liner via the combinators; a widget construct exports its rule
+ *      from its own module and is listed here; an EXTENSION with its own
+ *      grammar ships rules via `nodeRulesFacet` and never touches this file.
+ *   4. **Deliberate non-styling stays documented.** `raw(why)` /
+ *      `structural(why)` tag their rules; the coverage test insists the
+ *      `why` is present.
+ *
+ * The rules speak {@link Paint} — CodeMirror's own mechanisms (line class,
+ * span mark, hide, widget, nothing). That union is CLOSED: constructs grow,
+ * ways to paint don't, so the single switch over Paint lives in the painter
+ * (plugin.ts) and no new construct ever edits it.
+ */
+
+declare const NODE_RULES: NodeRules;
+
+export { NODE_RULES };

package/dist/codemirror/core/registry.js

@@ -0,0 +1,133 @@
+import "../../chunk-V6TY7KAL.js";
+import { horizontalRuleRule } from "./hrWidget.js";
+import { htmlBlockRule, htmlInlineRule } from "../html/htmlWidget.js";
+import { imageRule } from "../image/imageWidget.js";
+import { linkHasVisibleLabel, linkResolves } from "./linkResolution.js";
+import { listMarkRule } from "../list/bulletWidget.js";
+import {
+  headingLine,
+  hideAlways,
+  line,
+  mark,
+  none,
+  raw,
+  structural
+} from "./paint.js";
+import { taskMarkerRule } from "../list/taskCheckboxWidget.js";
+function parentLink(ctx) {
+  return ctx.parentName === "Link" ? ctx.node.parent : null;
+}
+const NODE_RULES = {
+  // ----- Structural wrappers (never directly styled) -----
+  Document: structural("top-level wrapper"),
+  Paragraph: structural("body font is the default"),
+  // ----- ATX headings (`# H1` … `###### H6`) -----
+  ATXHeading1: headingLine("cm-heading cm-heading--1"),
+  ATXHeading2: headingLine("cm-heading cm-heading--2"),
+  ATXHeading3: headingLine("cm-heading cm-heading--3"),
+  ATXHeading4: headingLine("cm-heading cm-heading--4"),
+  ATXHeading5: headingLine("cm-heading cm-heading--5"),
+  ATXHeading6: headingLine("cm-heading cm-heading--6"),
+  // ----- Setext headings (`=====` / `-----` under text) -----
+  SetextHeading1: raw("Phase 2: same line scaling as ATXHeading1"),
+  SetextHeading2: raw("Phase 2: same line scaling as ATXHeading2"),
+  // ----- Block-level constructs -----
+  Blockquote: line("cm-blockquote"),
+  BulletList: structural("ListItem children carry the styling"),
+  OrderedList: structural("ListItem children carry the styling"),
+  ListItem: line("cm-list-line"),
+  FencedCode: line("cm-fenced-code"),
+  CodeBlock: raw("Phase 2: indented code-block, same style as FencedCode"),
+  HorizontalRule: horizontalRuleRule,
+  // `---` → styled `<hr>` widget
+  HTMLBlock: htmlBlockRule,
+  LinkReference: raw("Phase 2: reference-style links resolve in click handler"),
+  // ----- Inline styling -----
+  Emphasis: mark("cm-emphasis"),
+  StrongEmphasis: mark("cm-strong"),
+  InlineCode: mark("cm-inline-code"),
+  // A `Link` node is not yet a link: Lezer emits one for every `[…]`, and the
+  // reference lookup CommonMark requires is left to us. Unresolved, it is the
+  // literal brackets the author typed — most `[…]` in prose, and every optional
+  // argument in a LaTeX block.
+  Link: (ctx) => linkResolves(ctx.node, ctx.state) ? { paint: "mark", className: "cm-link" } : none,
+  Image: imageRule,
+  // `![alt](src)` → inline `<img>` widget
+  // ----- Inline literal sub-nodes (rendered inside their parent) -----
+  // Inside a Link the URL is chrome ONLY when a visible label exists — for
+  // `[](url)` / `[ ](url)` the URL is the link's entire visible content, and
+  // hiding it (with the marks already hidden) left an invisible dead zone.
+  // Bare GFM autolinks and <angle> autolinks emit the SAME node name, and
+  // there the URL IS the content — same class of bug when hidden.
+  URL: (ctx) => {
+    const link = parentLink(ctx);
+    if (!link) return { paint: "mark", className: "cm-link" };
+    return linkHasVisibleLabel(link, ctx.state) ? { paint: "hide" } : { paint: "mark", className: "cm-link" };
+  },
+  LinkLabel: raw("visible inside Link; parent mark styles it"),
+  LinkTitle: hideAlways(),
+  // `[text](URL "title")` — title never visible
+  CodeText: raw("interior of FencedCode/InlineCode; parent decoration covers it"),
+  CodeInfo: mark("cm-code-info"),
+  // language tag on the opener row — visible so typing there is never invisible (§12.4)
+  HardBreak: structural("trailing two-spaces or backslash, no visible glyph"),
+  Comment: raw("Phase 2: dim inline HTML comments"),
+  CommentBlock: raw("Phase 2: dim block HTML comments"),
+  ProcessingInstruction: raw("Phase 2: dim like HTML comments"),
+  ProcessingInstructionBlock: raw("Phase 2: dim like HTML comments"),
+  Entity: raw("HTML entities like &amp; render as-is, by design"),
+  // Backslash-escape: hide only the leading `\`, so `\'` renders as `'` per
+  // CommonMark rather than showing a literal backslash.
+  Escape: (ctx) => ({
+    paint: "hide",
+    range: { from: ctx.from, to: ctx.from + 1 },
+    expandSpace: false
+  }),
+  HTMLTag: htmlInlineRule,
+  // ----- Syntax markers (hidden always — non-technical UX, distinct from Obsidian's Live Preview) -----
+  // `#` marks on ATX headings hide; a SETEXT heading's underline is that
+  // heading's only marker on its own line — hiding it left an invisible,
+  // unclickable dead line. Visible until setext gets real styling.
+  HeaderMark: (ctx) => ctx.parentName?.startsWith("SetextHeading") ? { paint: "none" } : { paint: "hide" },
+  EmphasisMark: hideAlways(),
+  // `*` / `_`
+  CodeMark: hideAlways(),
+  // backticks for inline / fence pairs for blocks
+  // `[`/`]`/`(`/`)` — chrome only where they really are chrome. An unresolved
+  // link's brackets are content, and hiding them rewrote the document on screen.
+  LinkMark: (ctx) => {
+    const link = parentLink(ctx);
+    return link && !linkResolves(link, ctx.state) ? none : { paint: "hide" };
+  },
+  QuoteMark: hideAlways(),
+  // `>`
+  ListMark: listMarkRule,
+  // `-`/`1.` → bullet / number / nothing beside a checkbox
+  TaskMarker: taskMarkerRule,
+  // `[ ]` / `[x]` → real checkbox
+  // ----- GFM extensions (enabled via `markdownLanguage`) -----
+  Strikethrough: mark("cm-strikethrough"),
+  // `~~` joins the hidden-marker system like EmphasisMark — the flanking
+  // guard and delete normalizer already assume these semantics; leaving the
+  // marks visible made deletion eat single tildes (interaction-spec §8.1).
+  StrikethroughMark: hideAlways(),
+  Subscript: raw("Phase 2: vertical-align: sub"),
+  SubscriptMark: raw("Phase 2: hide `~` off-parent"),
+  Superscript: raw("Phase 2: vertical-align: super"),
+  SuperscriptMark: raw("Phase 2: hide `^` off-parent"),
+  Emoji: raw("Phase 2: replace `:smile:` with the emoji glyph"),
+  Autolink: raw("wrapper of a visible URL child; Phase 2 wires click-to-open"),
+  Task: raw("Phase 2: render task list items with a real checkbox"),
+  // GFM tables — handled by a dedicated StateField that emits the block
+  // widget on Table nodes (CM6 forbids multi-line replace from a ViewPlugin,
+  // so this rules-driven plugin can't do that shape; see tableField.ts).
+  Table: structural("tableField StateField owns Table rendering"),
+  TableHeader: structural("covered by Table widget"),
+  TableRow: structural("covered by Table widget"),
+  TableCell: structural("covered by Table widget"),
+  TableDelimiter: structural("covered by Table widget")
+};
+export {
+  NODE_RULES
+};
+//# sourceMappingURL=registry.js.map