@ai-matrx/rich-content 0.0.0-stage → 0.2.2

package/dist/markdown-core/syntax/document-numbering.js

@@ -0,0 +1,184 @@
+import { DirectiveContainerTracker } from "@ai-matrx/content-ir/source";
+import { TITLED_IMAGE_LINE } from "@ai-matrx/content-ir/source";
+import { collectLinkDefinitions, fenceLineKinds } from "@ai-matrx/content-ir/source";
+import { sectionHeading } from "./linear-scan.js";
+const FIGURE_OPEN = /^[ \t]{0,3}:{3,}(figure|table)(?:\[((?:[^\]\\]|\\.)*)\])?(?:\{([^}]*)\})?/i;
+const LABEL = /\\label\{([^{}]+)\}/g;
+const TAG = /\\tag\*?\{([^{}]*)\}/;
+function captionKey(kind, caption) {
+  return `${kind}|${caption.replace(/[*_`~=]/g, "").replace(/\s+/g, " ").trim().toLowerCase()}`;
+}
+function idFromAttrs(attrs) {
+  if (!attrs) return null;
+  const hash = /(?:^|\s)#([\w:.-]+)/.exec(attrs);
+  if (hash) return hash[1] ?? null;
+  const id = /(?:^|\s)id=["']?([\w:.-]+)/.exec(attrs);
+  return id ? id[1] ?? null : null;
+}
+function displayMath(text) {
+  const out = [];
+  const finder = (needle) => {
+    let askedFrom = -1;
+    let answer = -1;
+    return (from) => {
+      if (askedFrom < 0 || from < askedFrom || answer !== -1 && answer < from) {
+        askedFrom = from;
+        answer = text.indexOf(needle, from);
+      }
+      return answer;
+    };
+  };
+  const openDollar = finder("$$");
+  const closeDollar = finder("$$");
+  const openBracket = finder("\\[");
+  const closeBracket = finder("\\]");
+  let pos = 0;
+  while (pos < text.length) {
+    const d = openDollar(pos);
+    const b = openBracket(pos);
+    if (d === -1 && b === -1) break;
+    const at = d !== -1 && (b === -1 || d < b) ? d : b;
+    const dollar = at === d;
+    const end = dollar ? closeDollar(at + 2) : closeBracket(at + 2);
+    if (end === -1) {
+      pos = at + 1;
+      continue;
+    }
+    out.push(text.slice(at + 2, end));
+    pos = end + 2;
+  }
+  return out;
+}
+function computeDocumentNumbering(source) {
+  const byLabel = /* @__PURE__ */ new Map();
+  const byCaption = /* @__PURE__ */ new Map();
+  const footnotes = /* @__PURE__ */ new Map();
+  if (!source) return { byLabel, byCaption, footnotes, footnoteMarkdown: "", linkDefinitions: "" };
+  const kinds = fenceLineKinds(source);
+  const prose = source.split("\n").map((line, i) => kinds[i] === "prose" ? line : "");
+  let figures = 0;
+  let tables = 0;
+  let insideFigure = null;
+  const addCaption = (key, display) => {
+    const list = byCaption.get(key) ?? [];
+    list.push(display);
+    byCaption.set(key, list);
+  };
+  for (const line of prose) {
+    if (insideFigure) {
+      if (insideFigure.consume(line)) insideFigure = null;
+      continue;
+    }
+    if (TITLED_IMAGE_LINE.test(line)) {
+      const title = /\s(?:"([^"\n]+)"|'([^'\n]+)')\s*\)[ \t]*$/.exec(line);
+      addCaption(captionKey("fig", title?.[1] ?? title?.[2] ?? ""), `Figure ${++figures}`);
+      continue;
+    }
+    const fig = FIGURE_OPEN.exec(line);
+    if (fig) {
+      insideFigure = new DirectiveContainerTracker(line);
+      const kind = fig[1].toLowerCase() === "table" ? "tbl" : "fig";
+      const display = kind === "fig" ? `Figure ${++figures}` : `Table ${++tables}`;
+      const id = idFromAttrs(fig[3]);
+      if (id) byLabel.set(id, { kind, display });
+      else addCaption(captionKey(kind, fig[2] ?? ""), display);
+      continue;
+    }
+    const sec = sectionHeading(line);
+    if (sec) byLabel.set(sec[1], { kind: "sec", display: sec[0].trim() });
+  }
+  let equations = 0;
+  for (const body of displayMath(prose.join("\n"))) {
+    const labels = [...body.matchAll(LABEL)].map((m) => (m[1] ?? "").trim());
+    if (labels.length === 0) continue;
+    const tag = TAG.exec(body);
+    const display = `(${tag ? tag[1] ?? "" : String(++equations)})`;
+    const first = labels[0];
+    if (first) byLabel.set(first, { kind: "eq", display });
+  }
+  const footnoteMarkdown = numberFootnotes(prose, footnotes);
+  return { byLabel, byCaption, footnotes, footnoteMarkdown, linkDefinitions: linkDefinitionLines(source) };
+}
+const DOCUMENT_FOOTNOTES_MARKER = "<!-- matrx:document-footnotes -->";
+function documentFootnoteSource(numbering) {
+  return numbering?.footnoteMarkdown ? `${DOCUMENT_FOOTNOTES_MARKER}
+
+${numbering.footnoteMarkdown}` : "";
+}
+const FOOTNOTE_DEF = /^ {0,3}\[\^([^\]\s]+)\]:[ \t]?(.*)$/;
+const FOOTNOTE_REF = /\[\^([^\]\s]+)\](?!:)/g;
+const INTERRUPTS_NOTE = /^ {0,3}(?:[-+*][ \t]|\d{1,9}[.)][ \t]|>|#{1,6}(?:[ \t]|$)|```|~~~|<|\[\^[^\]\s]+\]:|(?:-[ \t]*){3,}$|(?:\*[ \t]*){3,}$|(?:_[ \t]*){3,}$)/;
+function footnoteRefs(line) {
+  if (!line.includes("[^")) return [];
+  return [...line.replace(/`+[^`]*`+/g, "").matchAll(FOOTNOTE_REF)].map((m) => (m[1] ?? "").toLowerCase());
+}
+function numberFootnotes(prose, footnotes) {
+  const notes = /* @__PURE__ */ new Map();
+  const written = /* @__PURE__ */ new Map();
+  const body = [];
+  for (let i = 0; i < prose.length; i += 1) {
+    const def = FOOTNOTE_DEF.exec(prose[i] ?? "");
+    if (!def) {
+      body.push(prose[i] ?? "");
+      continue;
+    }
+    const label = (def[1] ?? "").toLowerCase();
+    const lines = [def[2] ?? ""];
+    const raw = [prose[i] ?? ""];
+    let previous = prose[i] ?? "";
+    let j = i + 1;
+    for (; j < prose.length; j += 1) {
+      const line = prose[j] ?? "";
+      const indented = /^(?: {4}|\t)/.test(line);
+      const lazy = line.trim() !== "" && previous.trim() !== "" && !INTERRUPTS_NOTE.test(line);
+      const blankThenIndented = line.trim() === "" && /^(?: {4}|\t)\S/.test(prose[j + 1] ?? "");
+      if (!indented && !lazy && !blankThenIndented) break;
+      lines.push(line);
+      raw.push(line);
+      previous = line;
+    }
+    if (!notes.has(label)) {
+      notes.set(label, lines);
+      written.set(label, raw);
+    }
+    i = j - 1;
+  }
+  if (notes.size === 0) return "";
+  const cite = (id) => {
+    if (notes.has(id) && !footnotes.has(id)) footnotes.set(id, footnotes.size + 1);
+  };
+  for (const line of body) footnoteRefs(line).forEach(cite);
+  for (const id of footnotes.keys()) for (const line of notes.get(id) ?? []) footnoteRefs(line).forEach(cite);
+  return [...footnotes.keys()].map((id) => (written.get(id) ?? []).join("\n").trimEnd()).join("\n\n");
+}
+function sameDocumentNumbering(a, b) {
+  if (a === b) return true;
+  if (a.linkDefinitions !== b.linkDefinitions || a.footnoteMarkdown !== b.footnoteMarkdown) return false;
+  if (a.byLabel.size !== b.byLabel.size || a.byCaption.size !== b.byCaption.size || a.footnotes.size !== b.footnotes.size) return false;
+  for (const [k, v] of a.byLabel) {
+    const o = b.byLabel.get(k);
+    if (!o || o.kind !== v.kind || o.display !== v.display) return false;
+  }
+  for (const [k, v] of a.byCaption) {
+    const o = b.byCaption.get(k);
+    if (!o || o.length !== v.length || o.some((d, i) => d !== v[i])) return false;
+  }
+  for (const [k, v] of a.footnotes) if (b.footnotes.get(k) !== v) return false;
+  return true;
+}
+function linkDefinitionLines(source) {
+  if (!source.includes("]:")) return "";
+  const lines = [];
+  for (const [label, def] of collectLinkDefinitions(source)) {
+    const title = def.title === null ? "" : ` "${def.title.replace(/["\\]/g, "\\$&")}"`;
+    lines.push(`[${label.replace(/[\[\]\\]/g, "\\$&")}]: <${def.url.replace(/[<>]/g, encodeURIComponent)}>${title}`);
+  }
+  return lines.join("\n");
+}
+export {
+  DOCUMENT_FOOTNOTES_MARKER,
+  captionKey,
+  computeDocumentNumbering,
+  documentFootnoteSource,
+  sameDocumentNumbering
+};

package/dist/markdown-core/syntax/elements/CalloutIcon.d.ts

@@ -0,0 +1,3 @@
+export declare function CalloutIcon(props: {
+    "data-type"?: string;
+}): import("react").JSX.Element;

package/dist/markdown-core/syntax/elements/CalloutIcon.js

@@ -0,0 +1,41 @@
+import { jsx } from "react/jsx-runtime";
+import {
+  ChevronRight,
+  CircleCheck,
+  CircleHelp,
+  Info,
+  Lightbulb,
+  MessageSquareWarning,
+  OctagonAlert,
+  Pencil,
+  Quote,
+  TriangleAlert
+} from "lucide-react";
+const ICONS = {
+  note: Pencil,
+  tip: Lightbulb,
+  important: MessageSquareWarning,
+  warning: TriangleAlert,
+  caution: OctagonAlert,
+  info: Info,
+  success: CircleCheck,
+  question: CircleHelp,
+  quote: Quote
+};
+function CalloutIcon(props) {
+  const type = props["data-type"] ?? "note";
+  if (type === "chevron") {
+    return /* @__PURE__ */ jsx(
+      ChevronRight,
+      {
+        "aria-hidden": true,
+        className: "ml-auto h-4 w-4 shrink-0 opacity-70 transition-transform group-open/callout:rotate-90"
+      }
+    );
+  }
+  const Icon = ICONS[type] ?? Info;
+  return /* @__PURE__ */ jsx(Icon, { "aria-hidden": true, className: "h-4 w-4 shrink-0" });
+}
+export {
+  CalloutIcon
+};

package/dist/markdown-core/syntax/elements/CrossRef.d.ts

@@ -0,0 +1,12 @@
+import { type ReactNode } from "react";
+interface CrossRefProps {
+    href?: string;
+    title?: string;
+    children?: ReactNode;
+    "data-xref"?: string;
+    "data-xref-kind"?: string;
+    "data-xref-style"?: string;
+    "data-xref-resolved"?: string;
+}
+export declare function CrossRef(props: CrossRefProps): import("react").JSX.Element;
+export {};

package/dist/markdown-core/syntax/elements/CrossRef.js

@@ -0,0 +1,57 @@
+"use client";
+import { jsx, jsxs } from "react/jsx-runtime";
+import { useEffect, useRef, useState } from "react";
+import { cn } from "@ai-matrx/design-system";
+import { InDocAnchor } from "./InDocAnchor.js";
+import { findInDocument } from "./find-in-document.js";
+function labelFor(target, style) {
+  const label = target.getAttribute("data-xref-label");
+  if (label) {
+    if (label.startsWith("Equation ")) {
+      const n = label.slice("Equation ".length);
+      return style === "ref" ? n.replace(/[()]/g, "") : n;
+    }
+    return label;
+  }
+  if (/^H[1-6]$/.test(target.tagName)) {
+    const clone = target.cloneNode(true);
+    clone.querySelectorAll("[data-heading-anchor]").forEach((a) => a.remove());
+    return (clone.textContent ?? "").trim() || null;
+  }
+  return null;
+}
+function CrossRef(props) {
+  const label = String(props["data-xref"] ?? "");
+  const resolvedStatically = props["data-xref-resolved"] === "true";
+  const probe = useRef(null);
+  const [runtime, setRuntime] = useState(null);
+  const [looked, setLooked] = useState(resolvedStatically);
+  const style = props["data-xref-style"];
+  useEffect(() => {
+    if (resolvedStatically) return;
+    const target = findInDocument(probe.current, label);
+    setRuntime(target ? labelFor(target, style) : null);
+    setLooked(true);
+  }, [label, resolvedStatically, style]);
+  if (resolvedStatically || runtime) {
+    return /* @__PURE__ */ jsx(InDocAnchor, { href: `#${label}`, "data-xref": label, "data-content-chrome": "", className: "no-underline hover:underline", children: runtime ?? props.children });
+  }
+  return /* @__PURE__ */ jsxs(
+    "span",
+    {
+      ref: probe,
+      "data-xref": label,
+      "data-content-chrome": "",
+      "data-xref-missing": looked ? "" : void 0,
+      title: props.title,
+      className: cn(looked && "rounded-sm bg-amber-500/15 px-0.5 text-amber-700 dark:text-amber-300"),
+      children: [
+        props.children,
+        looked ? "?" : null
+      ]
+    }
+  );
+}
+export {
+  CrossRef
+};

package/dist/markdown-core/syntax/elements/CsvFence.d.ts

@@ -0,0 +1,4 @@
+export declare function CsvFence(props: {
+    "data-source"?: string;
+    "data-delimiter"?: string;
+}): import("react").JSX.Element;

package/dist/markdown-core/syntax/elements/CsvFence.js

@@ -0,0 +1,18 @@
+"use client";
+import { jsx } from "react/jsx-runtime";
+import { lazy, Suspense } from "react";
+const CsvBlock = lazy(() => import("../../../display/blocks/csv/CsvBlock.js"));
+function CsvFence(props) {
+  const source = String(props["data-source"] ?? "");
+  const delimiter = props["data-delimiter"] === "tab" ? "	" : ",";
+  return /* @__PURE__ */ jsx(
+    Suspense,
+    {
+      fallback: /* @__PURE__ */ jsx("pre", { className: "my-3 overflow-x-auto rounded-md border border-border bg-muted/40 p-3 font-mono text-xs", children: source }),
+      children: /* @__PURE__ */ jsx(CsvBlock, { content: source, delimiter, className: "my-3" })
+    }
+  );
+}
+export {
+  CsvFence
+};

package/dist/markdown-core/syntax/elements/DetailsElements.d.ts

@@ -0,0 +1,12 @@
+import type { ReactNode } from "react";
+type Props = {
+    children?: ReactNode;
+    className?: string;
+    open?: boolean;
+    id?: string;
+    node?: unknown;
+} & Record<string, unknown>;
+export declare function DetailsElement({ children, className, open, id, node: _node, ...rest }: Props): import("react").JSX.Element;
+export declare function SummaryElement({ children, className }: Props): import("react").JSX.Element;
+export declare function KbdElement({ children, className }: Props): import("react").JSX.Element;
+export {};

package/dist/markdown-core/syntax/elements/DetailsElements.js

@@ -0,0 +1,38 @@
+import { jsx } from "react/jsx-runtime";
+import { cn } from "@ai-matrx/design-system";
+function DetailsElement({ children, className, open, id, node: _node, ...rest }) {
+  if (className?.includes("matrx-callout")) {
+    return /* @__PURE__ */ jsx("details", { ...rest, className, open, id, children });
+  }
+  return /* @__PURE__ */ jsx(
+    "details",
+    {
+      ...rest,
+      open,
+      id,
+      className: cn("matrx-details group/details my-3 rounded-md border border-border bg-card px-3 py-2 text-sm [&[open]>summary]:mb-2", className),
+      children
+    }
+  );
+}
+function SummaryElement({ children, className }) {
+  if (className?.includes("matrx-callout-title")) return /* @__PURE__ */ jsx("summary", { className, children });
+  return /* @__PURE__ */ jsx("summary", { className: cn("cursor-pointer select-none font-medium text-foreground marker:text-muted-foreground", className), children });
+}
+function KbdElement({ children, className }) {
+  return /* @__PURE__ */ jsx(
+    "kbd",
+    {
+      className: cn(
+        "rounded border border-b-2 border-border bg-muted px-1.5 py-px font-mono text-[0.8em] text-foreground",
+        className
+      ),
+      children
+    }
+  );
+}
+export {
+  DetailsElement,
+  KbdElement,
+  SummaryElement
+};

package/dist/markdown-core/syntax/elements/DocumentNumbering.d.ts

@@ -0,0 +1,20 @@
+import { type ReactNode } from "react";
+import { type DocumentNumbering } from "../document-numbering.js";
+export declare function DocumentNumberingProvider({ source, children }: {
+    source: string;
+    children: ReactNode;
+}): import("react").JSX.Element;
+export declare function useDocumentNumbering(): DocumentNumbering | null;
+/**
+ * THE DOCUMENT'S ONE FOOTNOTE SECTION (verify-RC-B4 round 16 ruling: notes go
+ * after the whole document, as in GFM, Google Docs and print). Every root that
+ * splits a document into blocks places this after its last block, inside its
+ * `data-matrx-doc-root`, and hands it its own prose renderer, so the notes look
+ * like the document's text. It renders the cited notes once (the numbering's
+ * `documentFootnoteSource`); a block never renders a definition itself. Beneath
+ * a nested provider (a container body, a nested section) it renders nothing —
+ * the root owns the section.
+ */
+export declare function DocumentFootnotes({ render }: {
+    render: (markdown: string) => ReactNode;
+}): import("react").JSX.Element | null;

package/dist/markdown-core/syntax/elements/DocumentNumbering.js

@@ -0,0 +1,37 @@
+"use client";
+import { Fragment, jsx } from "react/jsx-runtime";
+import { createContext, useContext, useState } from "react";
+import {
+  computeDocumentNumbering,
+  documentFootnoteSource,
+  sameDocumentNumbering
+} from "../document-numbering.js";
+const DocumentNumberingContext = createContext(null);
+const NestedDocumentContext = createContext(false);
+function DocumentNumberingProvider({ source, children }) {
+  const outer = useContext(DocumentNumberingContext);
+  if (outer) return /* @__PURE__ */ jsx(NestedDocumentContext.Provider, { value: true, children });
+  return /* @__PURE__ */ jsx(RootNumbering, { source, children });
+}
+function RootNumbering({ source, children }) {
+  const computed = computeDocumentNumbering(source);
+  const [stable, setStable] = useState(computed);
+  if (stable !== computed && !sameDocumentNumbering(stable, computed)) {
+    setStable(computed);
+  }
+  return /* @__PURE__ */ jsx(DocumentNumberingContext.Provider, { value: stable, children });
+}
+function useDocumentNumbering() {
+  return useContext(DocumentNumberingContext);
+}
+function DocumentFootnotes({ render }) {
+  const numbering = useContext(DocumentNumberingContext);
+  const nested = useContext(NestedDocumentContext);
+  const markdown = nested ? "" : documentFootnoteSource(numbering);
+  return markdown ? /* @__PURE__ */ jsx(Fragment, { children: render(markdown) }) : null;
+}
+export {
+  DocumentFootnotes,
+  DocumentNumberingProvider,
+  useDocumentNumbering
+};

package/dist/markdown-core/syntax/elements/DocumentPropertiesPanel.d.ts

@@ -0,0 +1,4 @@
+export declare function DocumentPropertiesPanel({ source, className }: {
+    source: string;
+    className?: string;
+}): import("react").JSX.Element | null;

package/dist/markdown-core/syntax/elements/DocumentPropertiesPanel.js

@@ -0,0 +1,46 @@
+"use client";
+import { jsx, jsxs } from "react/jsx-runtime";
+import { TriangleAlert } from "lucide-react";
+import { cn } from "@ai-matrx/design-system";
+import { useDocumentProperties } from "../useDocumentProperties.js";
+import { ErrorAlchemyMenu } from "../../../host/ErrorActions.js";
+function show(value) {
+  if (value === null || value === void 0) return "\u2014";
+  if (Array.isArray(value)) return value.map(show).join(", ");
+  if (value instanceof Date) return value.toISOString().slice(0, 10);
+  if (typeof value === "object") return JSON.stringify(value);
+  return String(value);
+}
+function DocumentPropertiesPanel({ source, className }) {
+  const { properties, format, error } = useDocumentProperties(source);
+  const entries = Object.entries(properties);
+  if (!format) return null;
+  return /* @__PURE__ */ jsxs(
+    "section",
+    {
+      "aria-label": "Document properties",
+      "data-document-properties": "",
+      className: cn("rounded-md border border-border bg-muted/30 px-3 py-2 text-xs", className),
+      children: [
+        /* @__PURE__ */ jsxs("p", { className: "mb-1 font-semibold uppercase tracking-wide text-muted-foreground", children: [
+          "Properties ",
+          /* @__PURE__ */ jsxs("span", { className: "font-normal normal-case", children: [
+            "\xB7 ",
+            format.toUpperCase()
+          ] })
+        ] }),
+        error ? /* @__PURE__ */ jsxs("p", { className: "flex items-center gap-1.5 text-amber-700 dark:text-amber-300", children: [
+          /* @__PURE__ */ jsx(TriangleAlert, { className: "h-3.5 w-3.5 shrink-0", "aria-hidden": true }),
+          error,
+          /* @__PURE__ */ jsx(ErrorAlchemyMenu, { error })
+        ] }) : entries.length === 0 ? /* @__PURE__ */ jsx("p", { className: "text-muted-foreground", children: "The properties block is empty." }) : /* @__PURE__ */ jsx("dl", { className: "grid grid-cols-[max-content_1fr] gap-x-3 gap-y-0.5", children: entries.map(([key, value]) => /* @__PURE__ */ jsxs("div", { className: "contents", children: [
+          /* @__PURE__ */ jsx("dt", { className: "font-medium text-muted-foreground", children: key }),
+          /* @__PURE__ */ jsx("dd", { className: "min-w-0 break-words text-foreground", children: show(value) })
+        ] }, key)) })
+      ]
+    }
+  );
+}
+export {
+  DocumentPropertiesPanel
+};

package/dist/markdown-core/syntax/elements/InDocAnchor.d.ts

@@ -0,0 +1,11 @@
+import { type ReactNode } from "react";
+type AnchorProps = React.AnchorHTMLAttributes<HTMLAnchorElement> & {
+    href: string;
+    children?: ReactNode;
+    "data-footnote-ref"?: unknown;
+    "data-footnote-backref"?: unknown;
+    "data-heading-anchor"?: unknown;
+    node?: unknown;
+};
+export declare function InDocAnchor({ href, children, className, node: _node, onClick, ...rest }: AnchorProps): import("react").JSX.Element;
+export {};

package/dist/markdown-core/syntax/elements/InDocAnchor.js

@@ -0,0 +1,87 @@
+"use client";
+import { jsx, jsxs } from "react/jsx-runtime";
+import { useRef, useState } from "react";
+import { createPortal } from "react-dom";
+import { cn } from "@ai-matrx/design-system";
+import { findInDocument } from "./find-in-document.js";
+import { replaceAddressWithoutNavigating } from "../../../utils/addressWithoutNavigating.js";
+function targetId(href) {
+  try {
+    return decodeURIComponent(href.slice(1));
+  } catch {
+    return href.slice(1);
+  }
+}
+function noteText(target) {
+  const clone = target.cloneNode(true);
+  clone.querySelectorAll("[data-footnote-backref]").forEach((el) => el.remove());
+  return (clone.textContent ?? "").replace(/\s+/g, " ").trim();
+}
+function InDocAnchor({ href, children, className, node: _node, onClick, ...rest }) {
+  const ref = useRef(null);
+  const [preview, setPreview] = useState(null);
+  const isFootnoteRef = rest["data-footnote-ref"] !== void 0 && rest["data-footnote-ref"] !== false;
+  const id = targetId(href);
+  const show = () => {
+    if (!isFootnoteRef) return;
+    const target = findInDocument(ref.current, id);
+    const rect = ref.current?.getBoundingClientRect();
+    if (!target || !rect) return;
+    const text = noteText(target);
+    if (!text) return;
+    setPreview({ text, top: rect.bottom + 6, left: Math.max(8, Math.min(rect.left, window.innerWidth - 336)) });
+  };
+  return /* @__PURE__ */ jsxs(
+    "a",
+    {
+      ref,
+      href,
+      ...rest,
+      className: cn(
+        !rest["data-heading-anchor"] && "text-primary underline-offset-2 hover:underline",
+        className
+      ),
+      onMouseEnter: show,
+      onFocus: show,
+      onMouseLeave: () => setPreview(null),
+      onBlur: () => setPreview(null),
+      onClick: (event) => {
+        onClick?.(event);
+        if (event.defaultPrevented || event.metaKey || event.ctrlKey || event.shiftKey) return;
+        const target = findInDocument(ref.current, id);
+        if (!target) return;
+        event.preventDefault();
+        setPreview(null);
+        target.scrollIntoView({ behavior: "smooth", block: "start" });
+        if (typeof target.animate === "function") {
+          target.animate(
+            [{ backgroundColor: "hsl(var(--primary) / 0.18)" }, { backgroundColor: "transparent" }],
+            { duration: 1600, easing: "ease-out" }
+          );
+        }
+        try {
+          replaceAddressWithoutNavigating(`#${encodeURIComponent(id)}`);
+        } catch {
+        }
+      },
+      children: [
+        children,
+        preview && typeof document !== "undefined" && createPortal(
+          /* @__PURE__ */ jsx(
+            "span",
+            {
+              role: "tooltip",
+              style: { top: preview.top, left: preview.left },
+              className: "pointer-events-none fixed z-[100] block w-80 max-w-[calc(100vw-16px)] rounded-md border border-border bg-popover px-3 py-2 text-xs font-normal leading-relaxed text-popover-foreground shadow-lg",
+              children: preview.text
+            }
+          ),
+          document.body
+        )
+      ]
+    }
+  );
+}
+export {
+  InDocAnchor
+};

package/dist/markdown-core/syntax/elements/MarkdownSourceEdit.d.ts

@@ -0,0 +1,24 @@
+import { type ReactNode } from "react";
+export interface MarkdownSourceEdit {
+    /** The stored source exactly as saved (not a render-prepared copy). */
+    source: string;
+    /** Persist a new source. May be async; a rejection is shown to the person. */
+    save: (next: string) => void | Promise<void>;
+}
+export declare function MarkdownSourceEditProvider({ source, save, children, }: MarkdownSourceEdit & {
+    children: ReactNode;
+}): import("react").JSX.Element;
+export declare function useMarkdownSourceEdit(): MarkdownSourceEdit | null;
+/**
+ * The adapter for a level that can save only SOMETIMES (a streamed answer
+ * saves once it has settled). It renders the same element either way, so
+ * gaining or losing `save` never remounts the document below it — a remount
+ * there unmounted every tool card at the instant a stream completed. With no
+ * `save`, the outer adapter (if any) stays in effect, exactly as if this level
+ * rendered nothing.
+ */
+export declare function OptionalMarkdownSourceEditProvider({ source, save, children, }: {
+    source: string;
+    save?: MarkdownSourceEdit["save"];
+    children: ReactNode;
+}): import("react").JSX.Element;

package/dist/markdown-core/syntax/elements/MarkdownSourceEdit.js

@@ -0,0 +1,28 @@
+"use client";
+import { jsx } from "react/jsx-runtime";
+import { createContext, useContext } from "react";
+const MarkdownSourceEditContext = createContext(null);
+function MarkdownSourceEditProvider({
+  source,
+  save,
+  children
+}) {
+  return /* @__PURE__ */ jsx(MarkdownSourceEditContext.Provider, { value: { source, save }, children });
+}
+function useMarkdownSourceEdit() {
+  return useContext(MarkdownSourceEditContext);
+}
+function OptionalMarkdownSourceEditProvider({
+  source,
+  save,
+  children
+}) {
+  const outer = useContext(MarkdownSourceEditContext);
+  const value = save ? { source, save } : outer;
+  return /* @__PURE__ */ jsx(MarkdownSourceEditContext.Provider, { value, children });
+}
+export {
+  MarkdownSourceEditProvider,
+  OptionalMarkdownSourceEditProvider,
+  useMarkdownSourceEdit
+};

package/dist/markdown-core/syntax/elements/MatrxTabs.d.ts

@@ -0,0 +1,10 @@
+import { type ReactNode } from "react";
+export declare function MatrxTabs(props: {
+    "data-labels"?: string;
+    id?: string;
+    children?: ReactNode;
+}): import("react").JSX.Element | null;
+/** One tab's body; the label lives on the parent (`data-labels`). */
+export declare function MatrxTab(props: {
+    children?: ReactNode;
+}): import("react").JSX.Element;