@ai-matrx/rich-content 0.0.0 → 0.2.3

package/CHANGELOG.md

@@ -0,0 +1,80 @@
+# Changelog
+
+## 0.2.3
+
+The packaged artifact now includes the MIT attribution notice for the vendored math plugins.
+
+### Consumer action
+
+None. Math rendering and public imports are unchanged.
+
+## 0.2.2
+
+`remark-math`, `rehype-katex` and the syntax half of `micromark-extension-math` are vendored
+(`markdown-core/math/vendor/`, MIT, notice beside them): upstream pins `katex ^0.16`, which
+carries GHSA-238p-pmpm-9mq7 (fixed in 0.18.2), so every npm consumer installed a vulnerable KaTeX
+and the publish audit refused 0.2.1. The only KaTeX in a consumer graph is now this package's
+`katex ^0.18.9` (packed consumer: `npm audit` 0 vulnerabilities; the render canary still draws
+math). Behavior unchanged.
+
+## 0.2.1
+
+The adversarial linear-time guard now runs alone before the parallel Jest suite, preserving its
+strict budget while removing unrelated worker contention from its measurement.
+
+## 0.2.0
+
+### The kind runtime (`kinds/*`)
+
+Moved from matrx-frontend `features/content-ir` (the app's bindings over content-ir-react): the
+kind route and partial/provisional route, route-at-version, registry repaint, ensure-renderable,
+the loading-skeleton registry and slug inference, kind problems, escaped-kind notice, `KindSlot`,
+`useIrNode`, `useLiveJsonRegion`, the region-envelope memo, kind correctors, render-block envelope
+helpers (with the inbound-envelope sanitizer that lived in the chat package), and the route env.
+
+New host capabilities: `kindRegistry`, `componentRegistry` (content-ir-react's resolver plus
+`wasRefused` / `debugSnapshot`), `contentIrHost`, `reportKindComponentIncident`. A bare host knows
+no kinds (announced) and resolves no kind components beyond the compiled floor.
+`registerKindCorrector(kind, fn)` replaces the hard-wired CRM `draft_critique` corrector (the host
+registers its own kinds' correctors).
+
+`tsx` is a devDependency (the regex linear-time guard runs its worker through it; CI had none).
+
+### Consumer action
+
+- matrx-frontend: register `kindRegistry`, `componentRegistry`, `contentIrHost`,
+  `reportKindComponentIncident` and the `draft_critique` corrector in the host setup; import
+  `@ai-matrx/rich-content/kinds/...` for the moved modules.
+
+## 0.1.1
+
+Same package contents as 0.1.0; the release carries the conformant packed-tarball canary
+(`scripts/verify-tarball.mjs`) the sibling-graph publish gate requires (the 0.1.0 tag predates it).
+
+## 0.1.0
+
+First release — the formatted-text engine leaves matrx-frontend (Arman, 2026-10-06: chat depends
+on the engine directly, as a package). This release carries:
+
+- `markdown-core/*` — the one markdown renderer: presets, the syntax layer (wikilinks, embeds,
+  mentions, footnotes, task lists, directives, document numbering, CSV fences), streaming heal,
+  the server renderer and the HTML projection. Moved verbatim from `components/markdown-core`.
+- `display/markdown-classification/processors/utils/*` — the block splitter (core + client
+  entry), GFM table lines and vectors, thinking parser, client blocks; `display/render-block`;
+  the remark/rehype plugins (cite, variable, page break, safe raw HTML); the CSV block; the
+  markdown table parser.
+- `utils/*` — plain titles, decision options, JSON helpers, address-without-navigating, YouTube
+  URLs, the GFM table source and lexer, `clientLazy` (replaces `next/dynamic` `ssr:false`).
+- `host` — `configureRichContent` with the capabilities in the README; every default announces
+  itself.
+
+Changes from the app copies: `next/dynamic` → `clientLazy`; app imports → host capabilities
+(toast, error sink, error actions, nested content, wikilinks, people, record peek, splitter
+envelopes, save-to-table); the wikilink "create" reads the organization on the host side
+(the Redux store read is gone). `remend` is pinned at 1.3.1 (1.4.0 trims trailing whitespace in
+held-back streaming text; the heal tests encode 1.3.1's behavior).
+
+### Consumer action
+
+- matrx-frontend: call `configureRichContent` at the root (see README) and import from
+  `@ai-matrx/rich-content/<domain>/<module>`.

package/LICENSE

@@ -1,6 +1,6 @@
 MIT License
 
-Copyright (c) 2026 AI Matrx
+Copyright (c) 2026 AI Matrix Engine
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

package/README.md

@@ -1,7 +1,62 @@
 # @ai-matrx/rich-content
 
-Name reservation and publishing bootstrap only. This version contains no runtime implementation or usable API. Do not adopt it in applications yet.
+The AI Matrx formatted-text engine as portable React: the one markdown renderer (GFM, math,
+directives, wikilinks, mentions, footnotes, streaming heal), the block splitter (static and
+streaming), and — as the extraction completes — the block renderer and generic blocks,
+`<RichContent>` levels, the rich-document action registry and menus, copy, and the selection
+toolbar. The editor is the sibling package `@ai-matrx/rich-editor`.
 
-The planned text engine displays formatted text, streaming answers, blocks, copy actions, menus, and the selection toolbar. Its intended source home is `aidream/apps/shared/rich-content` in [AI-Matrix-Engine/aidream](https://github.com/AI-Matrix-Engine/aidream).
+## Install
 
-License: MIT.
+```bash
+pnpm add @ai-matrx/rich-content
+```
+
+Peers: `react`, `react-dom` (>= 19). Tailwind consumers add the package's `dist` to their
+content sources (`@source "../node_modules/@ai-matrx/rich-content/dist";`).
+
+## Use
+
+Import modules by path — one specifier is one module, so client/server boundaries and lazy
+chunks stay intact:
+
+```tsx
+import MarkdownCore from "@ai-matrx/rich-content/markdown-core/MarkdownCore";
+import { splitContentIntoBlocksV2 } from "@ai-matrx/rich-content/display/markdown-classification/processors/utils/content-splitter-v2";
+```
+
+## Host
+
+The engine renders with no host at all. Every capability it can ask for has a default that
+announces itself once on the console and marks degraded elements `data-rich-content-host="bare"`.
+Configure once at the app root:
+
+```ts
+import { configureRichContent } from "@ai-matrx/rich-content/host";
+
+configureRichContent({
+  toast,                 // your toast (structural: success/error/info/warning/loading/dismiss)
+  captureError,          // your error sink
+  ErrorActions,          // extra actions beside an error message
+  NestedContent,         // nested markdown renderer (standard level)
+  wikilinks,             // { resolve, create, loadBody } against your records
+  resolvePerson,         // @mentions
+  ResourcePeek,          // your record peek
+  splitterEnvelopes,     // content-IR envelope hooks for complete regions
+  useOpenSaveToTable,    // "save these rows as a table"
+});
+```
+
+| Capability | Default on a bare host |
+|---|---|
+| `toast` | the console |
+| `captureError` | `console.error` |
+| `ErrorActions` | none (the message always shows) |
+| `NestedContent` | the source as plain text |
+| `wikilinks` | every link reads "unavailable" |
+| `resolvePerson` | the mention label as written |
+| `ResourcePeek` | the chip is not clickable |
+| `splitterEnvelopes` | regions carry no `metadata.__ir` |
+| `useOpenSaveToTable` | no "save as table" button |
+
+MIT licensed.

package/dist/display/blocks/csv/CsvBlock.d.ts

@@ -0,0 +1,10 @@
+import React from "react";
+interface CsvBlockProps {
+    content: string;
+    delimiter?: string;
+    className?: string;
+    /** Fires when the user commits an inline cell edit — inner markdown body only (no fence). */
+    onInnerContentChange?: (inner: string) => void;
+}
+declare const CsvBlock: React.FC<CsvBlockProps>;
+export default CsvBlock;

package/dist/display/blocks/csv/CsvBlock.js

@@ -0,0 +1,245 @@
+"use client";
+import { Fragment, jsx, jsxs } from "react/jsx-runtime";
+import { useState, useEffect } from "react";
+import { cn } from "@ai-matrx/design-system";
+import {
+  Copy,
+  Check,
+  ArrowUpDown,
+  ArrowUp,
+  ArrowDown,
+  Pencil,
+  X,
+  Check as CheckIcon,
+  Table2
+} from "lucide-react";
+import { toast } from "../../../host/toast.js";
+import { useOpenSaveToTable } from "../../../host/tables.js";
+import { Button } from "@ai-matrx/design-system/controls";
+function parseCsv(content, delimiter) {
+  const rows = [];
+  const lines = content.split("\n");
+  for (const line of lines) {
+    if (!line.trim()) continue;
+    const cells = [];
+    let current = "";
+    let inQuotes = false;
+    for (let i = 0; i < line.length; i++) {
+      const ch = line[i];
+      if (inQuotes) {
+        if (ch === '"' && line[i + 1] === '"') {
+          current += '"';
+          i++;
+        } else if (ch === '"') {
+          inQuotes = false;
+        } else {
+          current += ch;
+        }
+      } else {
+        if (ch === '"') {
+          inQuotes = true;
+        } else if (ch === delimiter) {
+          cells.push(current.trim());
+          current = "";
+        } else {
+          current += ch;
+        }
+      }
+    }
+    cells.push(current.trim());
+    rows.push(cells);
+  }
+  return rows;
+}
+function rowsToDelimitedContent(rows, delimiter) {
+  return rows.map(
+    (row) => row.map((cell) => {
+      const needsQuote = cell.includes(delimiter) || cell.includes('"') || cell.includes("\n") || cell.includes("\r");
+      const escaped = cell.replace(/"/g, '""');
+      return needsQuote ? `"${escaped}"` : escaped;
+    }).join(delimiter)
+  ).join("\n");
+}
+const CsvBlock = ({
+  content,
+  delimiter = ",",
+  className,
+  onInnerContentChange
+}) => {
+  const [copied, setCopied] = useState(false);
+  const [sortCol, setSortCol] = useState(null);
+  const [sortDir, setSortDir] = useState(null);
+  const [editCell, setEditCell] = useState(
+    null
+  );
+  const [editValue, setEditValue] = useState("");
+  const [data, setData] = useState(() => parseCsv(content, delimiter));
+  const openSaveToTable = useOpenSaveToTable();
+  useEffect(() => {
+    setData(parseCsv(content, delimiter));
+    setEditCell(null);
+  }, [content, delimiter]);
+  const headers = data[0] || [];
+  const bodyRows = data.slice(1);
+  const handleCopy = async () => {
+    await navigator.clipboard.writeText(content);
+    setCopied(true);
+    setTimeout(() => setCopied(false), 2e3);
+  };
+  const handleSaveAsTable = () => {
+    if (headers.length === 0 || bodyRows.length === 0) {
+      toast.error("No CSV rows to save.");
+      return;
+    }
+    openSaveToTable?.({ grid: { headers, rows: bodyRows } });
+  };
+  const handleSort = (colIdx) => {
+    if (sortCol === colIdx) {
+      if (sortDir === "asc") setSortDir("desc");
+      else if (sortDir === "desc") {
+        setSortCol(null);
+        setSortDir(null);
+      }
+    } else {
+      setSortCol(colIdx);
+      setSortDir("asc");
+    }
+  };
+  const sortedRows = [...bodyRows];
+  if (sortCol !== null && sortDir) {
+    sortedRows.sort((a, b) => {
+      const aVal = a[sortCol] ?? "";
+      const bVal = b[sortCol] ?? "";
+      const aNum = Number(aVal);
+      const bNum = Number(bVal);
+      if (!isNaN(aNum) && !isNaN(bNum)) {
+        return sortDir === "asc" ? aNum - bNum : bNum - aNum;
+      }
+      return sortDir === "asc" ? aVal.localeCompare(bVal) : bVal.localeCompare(aVal);
+    });
+  }
+  const startEdit = (rowIdx, colIdx) => {
+    setEditCell({ row: rowIdx, col: colIdx });
+    setEditValue(bodyRows[rowIdx]?.[colIdx] ?? "");
+  };
+  const commitEdit = () => {
+    if (!editCell) return;
+    const newData = [...data];
+    const actualRow = editCell.row + 1;
+    if (!newData[actualRow]) return;
+    newData[actualRow] = [...newData[actualRow]];
+    newData[actualRow][editCell.col] = editValue;
+    setData(newData);
+    setEditCell(null);
+    const inner = rowsToDelimitedContent(newData, delimiter);
+    onInnerContentChange?.(inner);
+  };
+  const cancelEdit = () => {
+    setEditCell(null);
+  };
+  const getSortIcon = (colIdx) => {
+    if (sortCol !== colIdx)
+      return /* @__PURE__ */ jsx(ArrowUpDown, { className: "w-3 h-3 opacity-0 group-hover/th:opacity-50" });
+    if (sortDir === "asc") return /* @__PURE__ */ jsx(ArrowUp, { className: "w-3 h-3 text-primary" });
+    return /* @__PURE__ */ jsx(ArrowDown, { className: "w-3 h-3 text-primary" });
+  };
+  return /* @__PURE__ */ jsxs(
+    "div",
+    {
+      className: cn(
+        "my-3 rounded-lg border border-border bg-card overflow-hidden",
+        className
+      ),
+      children: [
+        /* @__PURE__ */ jsxs("div", { className: "flex items-center justify-between px-3 py-1.5 border-b border-border/50 bg-muted/30", children: [
+          /* @__PURE__ */ jsxs("div", { className: "flex items-center gap-2", children: [
+            /* @__PURE__ */ jsx("span", { className: "text-xs font-mono font-semibold text-green-600 dark:text-green-400", children: "CSV" }),
+            /* @__PURE__ */ jsxs("span", { className: "text-xs text-muted-foreground", children: [
+              bodyRows.length,
+              " rows x ",
+              headers.length,
+              " cols"
+            ] })
+          ] }),
+          /* @__PURE__ */ jsxs("div", { className: "flex items-center gap-1", children: [
+            openSaveToTable ? /* @__PURE__ */ jsx(Button, { variant: "quiet", icon: /* @__PURE__ */ jsx(Table2, {}), onClick: handleSaveAsTable, title: "Save to a table", children: /* @__PURE__ */ jsx("span", { children: "Save to a table" }) }) : null,
+            /* @__PURE__ */ jsx(Button, { variant: "quiet", icon: copied ? /* @__PURE__ */ jsx(Check, {}) : /* @__PURE__ */ jsx(Copy, {}), glyphTone: copied ? "success" : void 0, onClick: handleCopy, "aria-label": "Copy" })
+          ] })
+        ] }),
+        /* @__PURE__ */ jsx("div", { className: "overflow-x-auto", children: /* @__PURE__ */ jsxs("table", { className: "w-full text-sm border-collapse", children: [
+          /* @__PURE__ */ jsx("thead", { children: /* @__PURE__ */ jsxs("tr", { className: "bg-muted/50", children: [
+            /* @__PURE__ */ jsx("th", { className: "px-1 py-1 text-center text-xs text-muted-foreground font-mono border-r border-border/30 w-8", children: "#" }),
+            headers.map((h, colIdx) => /* @__PURE__ */ jsx(
+              "th",
+              {
+                onClick: () => handleSort(colIdx),
+                className: "group/th px-3 py-1.5 text-left text-xs font-semibold text-foreground border-r border-border/30 last:border-r-0 cursor-pointer hover:bg-muted/70 transition-colors select-none",
+                children: /* @__PURE__ */ jsxs("div", { className: "flex items-center gap-1", children: [
+                  /* @__PURE__ */ jsx("span", { children: h }),
+                  getSortIcon(colIdx)
+                ] })
+              },
+              colIdx
+            ))
+          ] }) }),
+          /* @__PURE__ */ jsx("tbody", { children: sortedRows.map((row, rowIdx) => /* @__PURE__ */ jsxs(
+            "tr",
+            {
+              className: "border-t border-border/20 hover:bg-muted/20 transition-colors",
+              children: [
+                /* @__PURE__ */ jsx("td", { className: "px-1 py-1 text-center text-xs text-muted-foreground font-mono border-r border-border/30", children: rowIdx + 1 }),
+                headers.map((_, colIdx) => {
+                  const isEditing = editCell?.row === rowIdx && editCell?.col === colIdx;
+                  const cellValue = row[colIdx] ?? "";
+                  return /* @__PURE__ */ jsx(
+                    "td",
+                    {
+                      className: "group/cell px-3 py-1.5 text-foreground border-r border-border/30 last:border-r-0 relative",
+                      onDoubleClick: () => startEdit(rowIdx, colIdx),
+                      children: isEditing ? /* @__PURE__ */ jsxs("div", { className: "flex items-center gap-1", children: [
+                        /* @__PURE__ */ jsx(
+                          "input",
+                          {
+                            type: "text",
+                            value: editValue,
+                            onChange: (e) => setEditValue(e.target.value),
+                            onKeyDown: (e) => {
+                              if (e.key === "Enter") commitEdit();
+                              if (e.key === "Escape") cancelEdit();
+                            },
+                            className: "w-full px-1 py-0 text-sm bg-background border border-primary rounded focus:outline-none",
+                            style: { fontSize: "16px" },
+                            autoFocus: true
+                          }
+                        ),
+                        /* @__PURE__ */ jsx(Button, { variant: "quiet", icon: /* @__PURE__ */ jsx(CheckIcon, {}), onClick: commitEdit, "aria-label": "Done" }),
+                        /* @__PURE__ */ jsx(Button, { variant: "quiet", icon: /* @__PURE__ */ jsx(X, {}), removes: true, onClick: cancelEdit, "aria-label": "Close" })
+                      ] }) : /* @__PURE__ */ jsxs(Fragment, { children: [
+                        /* @__PURE__ */ jsx(
+                          "span",
+                          {
+                            className: cn(
+                              !isNaN(Number(cellValue)) && cellValue !== "" && "text-purple-600 dark:text-purple-400 font-mono tabular-nums"
+                            ),
+                            children: cellValue
+                          }
+                        ),
+                        /* @__PURE__ */ jsx(Button, { variant: "quiet", icon: /* @__PURE__ */ jsx(Pencil, {}), onClick: () => startEdit(rowIdx, colIdx), "aria-label": "Edit", className: "absolute right-1 top-1/2 opacity-0 hover:!opacity-100" })
+                      ] })
+                    },
+                    colIdx
+                  );
+                })
+              ]
+            },
+            rowIdx
+          )) })
+        ] }) })
+      ]
+    }
+  );
+};
+var CsvBlock_default = CsvBlock;
+export {
+  CsvBlock_default as default
+};

package/dist/display/blocks/table/parseMarkdownTable.d.ts

@@ -0,0 +1,20 @@
+/**
+ * parseMarkdownTable — the ONE markdown-table parser.
+ *
+ * Extracted from StreamingTableRenderer so the renderer AND the artifact
+ * "Convert to table" path parse identically (no forked regex — the doctrine
+ * primitive). Returns null for anything that isn't a well-formed markdown table
+ * (header row + separator row + data rows); tolerant of streaming (0 data rows
+ * yet) and of leading/trailing pipes.
+ */
+export interface ParsedTable {
+    headers: string[];
+    rows: string[][];
+    /** Rows keyed by markdown-stripped header — the shape DB save / JSON export want. */
+    normalizedData: Array<{
+        [key: string]: string;
+    }>;
+}
+/** Strip inline markdown from a header so it forms a clean object key. */
+export declare function cleanTableHeaderKey(header: string): string;
+export declare function parseMarkdownTable(content: string): ParsedTable | null;

package/dist/display/blocks/table/parseMarkdownTable.js

@@ -0,0 +1,35 @@
+import { unwrapCodeSpans } from "@ai-matrx/content-ir/source";
+import { dataRowIndexes, rowCells } from "../../../utils/table-source.js";
+import { isGfmDelimiterRow } from "../../markdown-classification/processors/utils/gfm-table-lines.js";
+function cleanTableHeaderKey(header) {
+  return unwrapCodeSpans(header).replace(/\*\*([^*]+)\*\*/g, "$1").replace(/\*([^*]+)\*/g, "$1").replace(/(?<![A-Za-z0-9])_([^_\n]+?)_(?![A-Za-z0-9])/g, "$1").replace(/\[([^\]]+)\]\(([^)]+)\)/g, "$1|$2").trim();
+}
+function parseMarkdownTable(content) {
+  try {
+    const lines = content.split("\n").filter((line) => line.trim().length > 0);
+    if (lines.length < 2) return null;
+    const headerLine = lines[0];
+    const separatorLine = lines[1];
+    if (!isGfmDelimiterRow(separatorLine)) return null;
+    const parseRow = rowCells;
+    const headers = parseRow(headerLine);
+    if (headers.length === 0) return null;
+    const dataLines = lines.slice(2);
+    const validRows = dataRowIndexes(dataLines, dataLines.map((_line, index) => index)).map((index) => parseRow(dataLines[index] ?? ""));
+    const normalizedData = validRows.map((row) => {
+      const rowData = {};
+      headers.forEach((header, index) => {
+        rowData[cleanTableHeaderKey(header)] = index < row.length ? row[index] : "";
+      });
+      return rowData;
+    });
+    return { headers, rows: validRows, normalizedData };
+  } catch (error) {
+    console.error("[parseMarkdownTable] Parse error:", error);
+    return null;
+  }
+}
+export {
+  cleanTableHeaderKey,
+  parseMarkdownTable
+};

package/dist/display/chat-markdown/citations/remarkMatrxCite.d.ts

@@ -0,0 +1,33 @@
+/**
+ * Remark plugin: recognizes inline citation markers `<matrxcite n="3" />`
+ * inside markdown TEXT nodes and emits inline `matrx-cite` custom elements so
+ * `react-markdown` renders them via the `components` map
+ * (→ `CitationMarkerInline`).
+ *
+ * Why text nodes (mirroring `remarkMatrxVariable`), not raw HTML / the block
+ * splitter: `preprocessContent` in BasicMarkdownContent escapes every
+ * non-allow-listed tag to `&lt;matrxcite …&gt;`, and CommonMark decodes the
+ * entities back to literal `<matrxcite n="3" />` inside text nodes — so the
+ * marker arrives here as plain text, safely inside the paragraph flow. The
+ * splitter path (audiocite-style) would make each marker its OWN vertically
+ * stacked block and re-break citation-split sentences mid-line — the exact
+ * regression fixed on 2026-07-16.
+ *
+ * Design rules (same as remarkMatrxVariable):
+ *  - Runs at render time on the mdast AST — source strings are never mutated.
+ *  - Only transforms `text` nodes; code spans/fences keep the literal text.
+ *  - The source number lives on the DOM as `data-n`.
+ *
+ * Markers are inserted into display text by
+ * `features/agents/redux/execution-system/messages/message-citations.ts`
+ * (`insertCitationMarkers`) — this plugin is the render-side half.
+ */
+interface MdastNode {
+    type: string;
+    value?: string;
+    children?: MdastNode[];
+    data?: Record<string, unknown>;
+    [key: string]: unknown;
+}
+export default function remarkMatrxCite(): (tree: MdastNode) => void;
+export {};

package/dist/display/chat-markdown/citations/remarkMatrxCite.js

@@ -0,0 +1,71 @@
+const CITE_PATTERN = /<matrxcite\s+n="(\d+)"\s*\/>/g;
+function expandTextNode(value) {
+  CITE_PATTERN.lastIndex = 0;
+  const parts = [];
+  let lastIdx = 0;
+  let match;
+  let matched = false;
+  while ((match = CITE_PATTERN.exec(value)) !== null) {
+    matched = true;
+    const start = match.index;
+    const end = start + match[0].length;
+    const n = match[1];
+    if (start > lastIdx) {
+      parts.push({ type: "text", value: value.slice(lastIdx, start) });
+    }
+    parts.push({
+      type: "matrxCite",
+      data: {
+        hName: "matrx-cite",
+        hProperties: { "data-n": n }
+      }
+    });
+    lastIdx = end;
+  }
+  if (!matched) {
+    return [{ type: "text", value }];
+  }
+  if (lastIdx < value.length) {
+    parts.push({ type: "text", value: value.slice(lastIdx) });
+  }
+  return parts;
+}
+const SKIP_TYPES = /* @__PURE__ */ new Set([
+  "code",
+  "inlineCode",
+  "html",
+  "yaml",
+  "toml",
+  "math",
+  "inlineMath"
+]);
+function walk(node) {
+  if (!node || SKIP_TYPES.has(node.type)) return;
+  const children = node.children;
+  if (!Array.isArray(children) || children.length === 0) return;
+  const next = [];
+  let mutated = false;
+  for (const child of children) {
+    if (child?.type === "text" && typeof child.value === "string" && child.value.includes("<matrxcite")) {
+      const expanded = expandTextNode(child.value);
+      if (expanded.length !== 1 || expanded[0].type !== "text") {
+        mutated = true;
+      }
+      next.push(...expanded);
+    } else {
+      next.push(child);
+      walk(child);
+    }
+  }
+  if (mutated) {
+    node.children = next;
+  }
+}
+function remarkMatrxCite() {
+  return (tree) => {
+    walk(tree);
+  };
+}
+export {
+  remarkMatrxCite as default
+};

package/dist/display/chat-markdown/matrx-variables/remarkMatrxVariable.d.ts

@@ -0,0 +1,29 @@
+/**
+ * Remark plugin: recognizes `{{variable_name}}` tokens inside markdown text
+ * and emits inline `matrx-variable` custom elements so `react-markdown` can
+ * render them via the `components` map.
+ *
+ * Design rules:
+ *  - Runs at render time on the mdast AST — the source `content` string is
+ *    never modified. Redis/Redux/DB copies of the message are untouched.
+ *  - Only transforms `text` nodes. `inlineCode`, `code` blocks, `link`, etc.
+ *    are left alone, so `` `{{literal}}` `` and ```` ```js\n{{foo}}\n``` ````
+ *    stay as plain text. Inside links/headings/emphasis the pattern still
+ *    applies because those wrap `text` children.
+ *  - Pattern requires a closed `}}`. Partial tokens during streaming (e.g.
+ *    `{{user_na`) stay plain text until the closing braces arrive.
+ *  - Emits a custom element `matrx-variable` with `data-name="..."` so the
+ *    renderer can look up the raw snake_case key.
+ *
+ * Pattern: `{{identifier}}` where identifier starts with a letter or underscore,
+ *          followed by letters, digits, underscores, or dots.
+ */
+interface MdastNode {
+    type: string;
+    value?: string;
+    children?: MdastNode[];
+    data?: Record<string, unknown>;
+    [key: string]: unknown;
+}
+export default function remarkMatrxVariable(): (tree: MdastNode) => void;
+export {};

package/dist/display/chat-markdown/matrx-variables/remarkMatrxVariable.js

@@ -0,0 +1,71 @@
+const VARIABLE_PATTERN = /\{\{([a-zA-Z_][a-zA-Z0-9_.]*)\}\}/g;
+function expandTextNode(value) {
+  VARIABLE_PATTERN.lastIndex = 0;
+  const parts = [];
+  let lastIdx = 0;
+  let match;
+  let matched = false;
+  while ((match = VARIABLE_PATTERN.exec(value)) !== null) {
+    matched = true;
+    const start = match.index;
+    const end = start + match[0].length;
+    const name = match[1];
+    if (start > lastIdx) {
+      parts.push({ type: "text", value: value.slice(lastIdx, start) });
+    }
+    parts.push({
+      type: "matrxVariable",
+      data: {
+        hName: "matrx-variable",
+        hProperties: { "data-name": name }
+      }
+    });
+    lastIdx = end;
+  }
+  if (!matched) {
+    return [{ type: "text", value }];
+  }
+  if (lastIdx < value.length) {
+    parts.push({ type: "text", value: value.slice(lastIdx) });
+  }
+  return parts;
+}
+const SKIP_TYPES = /* @__PURE__ */ new Set([
+  "code",
+  "inlineCode",
+  "html",
+  "yaml",
+  "toml",
+  "math",
+  "inlineMath"
+]);
+function walk(node) {
+  if (!node || SKIP_TYPES.has(node.type)) return;
+  const children = node.children;
+  if (!Array.isArray(children) || children.length === 0) return;
+  const next = [];
+  let mutated = false;
+  for (const child of children) {
+    if (child?.type === "text" && typeof child.value === "string" && child.value.includes("{{")) {
+      const expanded = expandTextNode(child.value);
+      if (expanded.length !== 1 || expanded[0].type !== "text") {
+        mutated = true;
+      }
+      next.push(...expanded);
+    } else {
+      next.push(child);
+      walk(child);
+    }
+  }
+  if (mutated) {
+    node.children = next;
+  }
+}
+function remarkMatrxVariable() {
+  return (tree) => {
+    walk(tree);
+  };
+}
+export {
+  remarkMatrxVariable as default
+};