@ai-matrx/rich-content 0.2.3 → 0.2.6

package/dist/host/ErrorActions.d.ts

@@ -1,4 +1,4 @@
 export declare function ErrorAlchemyMenu({ error }: {
-    error: unknown;
+    error?: unknown;
 }): import("react").JSX.Element | null;
 export { ErrorAlchemyMenu as ErrorActions };

package/dist/host/ErrorNotice.d.ts

@@ -0,0 +1,10 @@
+/** The host's error notice (matrx-frontend: components/errors/ErrorNotice); a bordered message on a bare host. */
+import type { ReactNode } from "react";
+export declare function ErrorNotice(props: {
+    message?: ReactNode;
+    error?: unknown;
+    title?: string;
+    className?: string;
+    size?: string;
+    children?: ReactNode;
+}): import("react").JSX.Element;

package/dist/host/ErrorNotice.js

@@ -0,0 +1,19 @@
+"use client";
+import { jsx, jsxs } from "react/jsx-runtime";
+import { BARE_HOST_ATTR, hostCapability } from "./registry.js";
+function ErrorNotice(props) {
+  const Impl = hostCapability("ErrorNotice");
+  if (Impl) return /* @__PURE__ */ jsx(Impl, { ...props, error: props.error ?? props.message });
+  const text = props.message ?? (props.error instanceof Error ? props.error.message : props.error ? String(props.error) : null);
+  return /* @__PURE__ */ jsxs("span", { ...BARE_HOST_ATTR, role: "alert", className: `rounded border border-destructive/40 px-2 py-1 text-xs text-destructive ${props.className ?? ""}`, children: [
+    props.title ? /* @__PURE__ */ jsxs("strong", { children: [
+      props.title,
+      ": "
+    ] }) : null,
+    text,
+    props.children
+  ] });
+}
+export {
+  ErrorNotice
+};

package/dist/host/app-bindings.d.ts

@@ -0,0 +1,155 @@
+/**
+ * APP BINDINGS — the host's own windows, records, canvas, menus and kind views that the engine's
+ * blocks offer when a host has them. Each export keeps the name the engine code used when it
+ * lived in matrx-frontend, so call sites read the same; each one delegates to
+ * `configureRichContent({ app: { … } })` and falls back to an honest default (absent control,
+ * plain rendering, announced once) on a bare host.
+ *
+ * Typing debt (recorded in FEATURE.md): these host callables are typed loosely (`HostFn`,
+ * `HostComponent`) because their real signatures live in the host app. Tighten each one when it
+ * gets a package-owned contract.
+ */
+import { type ComponentType } from "react";
+export type HostFn = (...args: any[]) => any;
+export type HostComponent = ComponentType<any>;
+/** Every binding a host may supply (all optional). */
+export interface RichContentAppBindings {
+    useCanvas: HostFn;
+    useCanvasOpenGuard: HostFn;
+    useOpenArtifactInCanvas: HostFn;
+    reportCanvasOpenDrop: HostFn;
+    getArtifactDef: HostFn;
+    resolveArtifactDef: HostFn;
+    hasArtifactRenderer: HostFn;
+    ArtifactRender: HostComponent;
+    CodeBlockWithContextAttach: HostComponent;
+    useOpenConvertToShapeWindow: HostFn;
+    useOpenSmartCodeEditorWindow: HostFn;
+    useOpenTableViewerWindow: HostFn;
+    useSaveAndOpenInCodeEditor: HostFn;
+    useOpenOverlay: HostFn;
+    useThemeMode: HostFn;
+    useHostUser: HostFn;
+    useIsAdminDebugger: HostFn;
+    useIsAuthenticated: HostFn;
+    useMermaidPreferences: HostFn;
+    useSetMermaidPreferences: HostFn;
+    useImageKnob: HostFn;
+    imageKnobPrincipals: HostFn;
+    setImageKnobMapEntry: HostFn;
+    StructuredValueView: HostComponent;
+    KindDataGate: HostComponent;
+    KindValueFrontDoor: HostComponent;
+    KindInstanceRender: HostComponent;
+    KindRecordChrome: HostComponent;
+    kindHasRecordChrome: HostFn;
+    KindFixItBar: HostComponent;
+    MarkdownStream: HostComponent;
+    CitationMarkerInline: HostComponent;
+    InlineCopyButton: HostComponent;
+    AdvancedMenu: HostComponent;
+    useAdvancedMenu: HostFn;
+    EntityRef: HostComponent;
+    JsonTreeViewer: HostComponent;
+    RawJsonExplorer: HostComponent;
+    NonEditableContextMenu: HostComponent;
+    IconInputWithValidation: HostComponent;
+    LocatedTableViewer: HostComponent;
+    OpenDestinationDialog: HostComponent;
+    HTMLPageService: unknown;
+    ensureOrganizationContext: HostFn;
+    isOrganizationSelectionCancelled: HostFn;
+    loadExportTargets: HostFn;
+    loadSendToGoogle: HostFn;
+    announceProposedGoogleWrite: HostFn;
+    isProposedGoogleWrite: HostFn;
+    codeEditorAgents: unknown;
+    mermaidEditorManifest: unknown;
+    createMermaidEditorScope: HostFn;
+    useDiagramAgents: HostFn;
+    useHideReasoning: HostFn;
+    useHideToolResults: HostFn;
+    useMachineFramesVisible: HostFn;
+}
+/** A block menu row (matrx-frontend components/official/AdvancedMenu `MenuItem`). */
+export interface MenuItem {
+    key: string;
+    icon: ComponentType<{
+        className?: string;
+    }>;
+    iconColor?: string;
+    label: string;
+    description?: string;
+    action: () => void | Promise<void>;
+    category?: string;
+    disabled?: boolean;
+    hidden?: boolean;
+    children?: MenuItem[];
+    [extra: string]: unknown;
+}
+/** The full renderer's props (matrx-frontend components/MarkdownStream `MarkdownStreamProps`), as the engine passes them. */
+export interface MarkdownStreamProps {
+    content?: string;
+    className?: string;
+    isStreamActive?: boolean;
+    onContentChange?: (newContent: string, previousContent?: string) => void;
+    hideCopyButton?: boolean;
+    allowFullScreenEditor?: boolean;
+    [extra: string]: unknown;
+}
+export declare const useCanvas: HostFn;
+export declare const useCanvasOpenGuard: HostFn;
+export declare const useOpenArtifactInCanvas: HostFn;
+export declare const reportCanvasOpenDrop: HostFn;
+export declare const getArtifactDef: HostFn;
+export declare const resolveArtifactDef: HostFn;
+export declare const hasArtifactRenderer: HostFn;
+export declare const ArtifactRender: HostComponent;
+export declare const CodeBlockWithContextAttach: HostComponent;
+export declare const useOpenConvertToShapeWindow: HostFn;
+export declare const useOpenSmartCodeEditorWindow: HostFn;
+export declare const useOpenTableViewerWindow: HostFn;
+export declare const useSaveAndOpenInCodeEditor: HostFn;
+export declare const useOpenOverlay: HostFn;
+export declare const useThemeMode: HostFn;
+export declare const useHostUser: HostFn;
+export declare const useIsAdminDebugger: HostFn;
+export declare const useIsAuthenticated: HostFn;
+export declare const useMermaidPreferences: HostFn;
+export declare const useSetMermaidPreferences: HostFn;
+export declare const useImageKnob: HostFn;
+export declare const imageKnobPrincipals: HostFn;
+export declare const setImageKnobMapEntry: HostFn;
+export declare const StructuredValueView: HostComponent;
+export declare const KindDataGate: HostComponent;
+export declare const KindValueFrontDoor: HostComponent;
+export declare const KindInstanceRender: HostComponent;
+export declare const KindRecordChrome: HostComponent;
+export declare const kindHasRecordChrome: HostFn;
+export declare const KindFixItBar: HostComponent;
+export declare const MarkdownStream: HostComponent;
+export declare const CitationMarkerInline: HostComponent;
+export declare const InlineCopyButton: HostComponent;
+export declare const AdvancedMenu: HostComponent;
+export declare const useAdvancedMenu: HostFn;
+export declare const EntityRef: HostComponent;
+export declare const JsonTreeViewer: HostComponent;
+export declare const RawJsonExplorer: HostComponent;
+export declare const NonEditableContextMenu: HostComponent;
+export declare const IconInputWithValidation: HostComponent;
+export declare const LocatedTableViewer: HostComponent;
+export declare const OpenDestinationDialog: HostComponent;
+export declare function hostHtmlPageService(): unknown;
+export declare const ensureOrganizationContext: HostFn;
+export declare const isOrganizationSelectionCancelled: HostFn;
+export declare const loadExportTargets: HostFn;
+export declare const loadSendToGoogle: HostFn;
+export declare const announceProposedGoogleWrite: HostFn;
+export declare const isProposedGoogleWrite: HostFn;
+export declare function hostCodeEditorAgents(): Record<string, unknown>;
+export declare function hostMermaidEditorManifest(): unknown;
+export declare const useDiagramAgents: HostFn;
+export declare const createMermaidEditorScope: HostFn;
+export declare const useHideReasoning: HostFn;
+export declare const useHideToolResults: HostFn;
+export declare const useMachineFramesVisible: HostFn;

package/dist/host/app-bindings.js

@@ -0,0 +1,160 @@
+"use client";
+import { createElement } from "react";
+import { GenericStructuredView } from "@ai-matrx/content-ir-react";
+import { announceBareHost, BARE_HOST_ATTR, hostCapability } from "./registry.js";
+function binding(key) {
+  return hostCapability("app")?.[key];
+}
+function fn(key, fallback, degraded) {
+  return (...args) => {
+    const impl = binding(key);
+    if (impl) return impl(...args);
+    announceBareHost(`app.${String(key)}`, degraded);
+    return fallback(...args);
+  };
+}
+function component(key, Fallback, degraded) {
+  function HostBound(props) {
+    const Impl = binding(key);
+    if (Impl) return createElement(Impl, props);
+    announceBareHost(`app.${String(key)}`, degraded);
+    return Fallback ? createElement(Fallback, props) : null;
+  }
+  HostBound.displayName = `HostBound(${String(key)})`;
+  return HostBound;
+}
+const nothing = () => null;
+const noop = () => {
+};
+const prefersDark = () => typeof window !== "undefined" && window.matchMedia?.("(prefers-color-scheme: dark)").matches ? "dark" : "light";
+function ValueFloor(props) {
+  const value = props.value ?? props.data;
+  if (value === void 0) return createElement("div", BARE_HOST_ATTR, props.children ?? null);
+  return createElement("div", BARE_HOST_ATTR, createElement(GenericStructuredView, { value, kind: props.kind ?? void 0 }));
+}
+function Passthrough(props) {
+  return createElement("div", BARE_HOST_ATTR, props.children ?? null);
+}
+function TextOnly(props) {
+  return createElement("span", BARE_HOST_ATTR, props.label ?? props.children ?? props.id ?? null);
+}
+const useCanvas = fn("useCanvas", () => ({ open: () => false, close: noop, clear: noop, update: noop, isCanvasAvailable: false }), "nothing opens in a canvas");
+const useCanvasOpenGuard = fn("useCanvasOpenGuard", () => ({ isCanvasAvailable: false, ensureCanvasReachable: () => false }), "nothing opens in a canvas");
+const useOpenArtifactInCanvas = fn("useOpenArtifactInCanvas", () => ({ openArtifact: async () => false, busy: false, lastResult: null }), "nothing opens in a canvas");
+const reportCanvasOpenDrop = fn("reportCanvasOpenDrop", () => false, "canvas drops are not reported");
+const getArtifactDef = fn("getArtifactDef", nothing, "no artifact types are known");
+const resolveArtifactDef = fn("resolveArtifactDef", nothing, "no artifact types are known");
+const hasArtifactRenderer = fn("hasArtifactRenderer", () => false, "no artifact renderers are known");
+const ArtifactRender = component("ArtifactRender", ValueFloor, "artifacts render through the generic structured view");
+const CodeBlockWithContextAttach = component("CodeBlockWithContextAttach", null, "code blocks render without the attach-to-context action");
+const useOpenConvertToShapeWindow = fn("useOpenConvertToShapeWindow", nothing, "no convert-to-shape window");
+const useOpenSmartCodeEditorWindow = fn("useOpenSmartCodeEditorWindow", nothing, "no code editor window");
+const useOpenTableViewerWindow = fn("useOpenTableViewerWindow", nothing, "no table viewer window");
+const useSaveAndOpenInCodeEditor = fn("useSaveAndOpenInCodeEditor", nothing, "code cannot be saved to files");
+const useOpenOverlay = fn("useOpenOverlay", () => noop, "no overlays open");
+const useThemeMode = fn("useThemeMode", prefersDark, "theme follows prefers-color-scheme");
+const useHostUser = fn("useHostUser", nothing, "no signed-in user is known");
+const useIsAdminDebugger = fn("useIsAdminDebugger", () => false, "admin diagnostics are off");
+const useIsAuthenticated = fn("useIsAuthenticated", () => false, "the viewer is treated as signed out");
+const useMermaidPreferences = fn("useMermaidPreferences", () => ({}), "mermaid uses default preferences");
+const useSetMermaidPreferences = fn("useSetMermaidPreferences", () => noop, "mermaid preferences are not saved");
+const useImageKnob = fn("useImageKnob", () => void 0, "remote images follow the default policy");
+const imageKnobPrincipals = fn("imageKnobPrincipals", () => ({ organizationId: null, userId: null }), "no one can trust an image host");
+const setImageKnobMapEntry = fn("setImageKnobMapEntry", async () => ({ ok: false, reason: "This app does not save image preferences." }), "image preferences are not saved");
+const StructuredValueView = component("StructuredValueView", ValueFloor, "values render through the generic structured view");
+const KindDataGate = component("KindDataGate", Passthrough, "kind data shows as written");
+const KindValueFrontDoor = component("KindValueFrontDoor", ValueFloor, "kind values render through the generic structured view");
+const KindInstanceRender = component("KindInstanceRender", ValueFloor, "kind instances render through the generic structured view");
+const KindRecordChrome = component("KindRecordChrome", Passthrough, "kind records show without record chrome");
+const kindHasRecordChrome = fn("kindHasRecordChrome", () => false, "kind records show without record chrome");
+const KindFixItBar = component("KindFixItBar", null, "no fix-it bar on broken kinds");
+const MarkdownStream = component("MarkdownStream", null, "the full renderer is not registered");
+const CitationMarkerInline = component("CitationMarkerInline", TextOnly, "citation markers show as text");
+const InlineCopyButton = component("InlineCopyButton", null, "no inline copy button");
+const AdvancedMenu = component("AdvancedMenu", null, "no block menus");
+const useAdvancedMenu = fn("useAdvancedMenu", () => ({ isOpen: false, open: noop, close: noop, toggle: noop, menuProps: {} }), "no block menus");
+const EntityRef = component("EntityRef", TextOnly, "record references show as text");
+const JsonTreeViewer = component("JsonTreeViewer", ValueFloor, "JSON renders through the generic structured view");
+const RawJsonExplorer = component("RawJsonExplorer", ValueFloor, "JSON renders through the generic structured view");
+const NonEditableContextMenu = component("NonEditableContextMenu", Passthrough, "no context menu");
+const IconInputWithValidation = component("IconInputWithValidation", null, "no icon picker");
+const LocatedTableViewer = component("LocatedTableViewer", null, "no table viewer");
+const OpenDestinationDialog = component("OpenDestinationDialog", null, "no destination dialog");
+function hostHtmlPageService() {
+  return binding("HTMLPageService") ?? null;
+}
+const ensureOrganizationContext = fn("ensureOrganizationContext", async () => null, "no organization can be chosen");
+const isOrganizationSelectionCancelled = fn("isOrganizationSelectionCancelled", () => false, "no organization can be chosen");
+const loadExportTargets = fn("loadExportTargets", async () => null, "no workbook export");
+const loadSendToGoogle = fn("loadSendToGoogle", async () => null, "no Google Sheets export");
+const announceProposedGoogleWrite = fn("announceProposedGoogleWrite", noop, "no Google Sheets export");
+const isProposedGoogleWrite = fn("isProposedGoogleWrite", () => false, "no Google Sheets export");
+function hostCodeEditorAgents() {
+  return binding("codeEditorAgents") ?? {};
+}
+function hostMermaidEditorManifest() {
+  return binding("mermaidEditorManifest") ?? null;
+}
+const useDiagramAgents = fn("useDiagramAgents", () => [], "no AI actions on diagrams");
+const createMermaidEditorScope = fn("createMermaidEditorScope", nothing, "no AI actions on diagrams");
+const useHideReasoning = fn("useHideReasoning", () => false, "reasoning is shown");
+const useHideToolResults = fn("useHideToolResults", () => false, "tool results are shown");
+const useMachineFramesVisible = fn("useMachineFramesVisible", () => false, "machine frames are hidden");
+export {
+  AdvancedMenu,
+  ArtifactRender,
+  CitationMarkerInline,
+  CodeBlockWithContextAttach,
+  EntityRef,
+  IconInputWithValidation,
+  InlineCopyButton,
+  JsonTreeViewer,
+  KindDataGate,
+  KindFixItBar,
+  KindInstanceRender,
+  KindRecordChrome,
+  KindValueFrontDoor,
+  LocatedTableViewer,
+  MarkdownStream,
+  NonEditableContextMenu,
+  OpenDestinationDialog,
+  RawJsonExplorer,
+  StructuredValueView,
+  announceProposedGoogleWrite,
+  createMermaidEditorScope,
+  ensureOrganizationContext,
+  getArtifactDef,
+  hasArtifactRenderer,
+  hostCodeEditorAgents,
+  hostHtmlPageService,
+  hostMermaidEditorManifest,
+  imageKnobPrincipals,
+  isOrganizationSelectionCancelled,
+  isProposedGoogleWrite,
+  kindHasRecordChrome,
+  loadExportTargets,
+  loadSendToGoogle,
+  reportCanvasOpenDrop,
+  resolveArtifactDef,
+  setImageKnobMapEntry,
+  useAdvancedMenu,
+  useCanvas,
+  useCanvasOpenGuard,
+  useDiagramAgents,
+  useHideReasoning,
+  useHideToolResults,
+  useHostUser,
+  useImageKnob,
+  useIsAdminDebugger,
+  useIsAuthenticated,
+  useMachineFramesVisible,
+  useMermaidPreferences,
+  useOpenArtifactInCanvas,
+  useOpenConvertToShapeWindow,
+  useOpenOverlay,
+  useOpenSmartCodeEditorWindow,
+  useOpenTableViewerWindow,
+  useSaveAndOpenInCodeEditor,
+  useSetMermaidPreferences,
+  useThemeMode
+};

package/dist/host/diagnostics.d.ts

@@ -1,2 +1,2 @@
-import type { RichContentErrorReport } from "./types.js";
-export declare function captureError(report: RichContentErrorReport): void;
+import type { RichContentErrorInput } from "./types.js";
+export declare function captureError(input: RichContentErrorInput): void;

package/dist/host/diagnostics.js

@@ -1,5 +1,6 @@
 import { hostCapability } from "./registry.js";
-function captureError(report) {
+function captureError(input) {
+  const report = { source: "rich-content", message: "", ...input };
   const sink = hostCapability("captureError");
   if (sink) {
     try {

package/dist/host/tables.d.ts

@@ -1,6 +1 @@
-export declare function useOpenSaveToTable(): ((options: {
-    grid: {
-        headers: string[];
-        rows: string[][];
-    };
-}) => unknown) | null;
+export declare function useOpenSaveToTable(): ((options: Record<string, unknown>) => unknown) | null;

package/dist/host/types.d.ts

@@ -59,6 +59,12 @@ export interface RichContentErrorReport {
     message: string;
     [field: string]: unknown;
 }
+/** Anything an engine module reports (a delimiter-guard capture, a kind incident, …). */
+export type RichContentErrorInput = {
+    source?: string;
+    message?: string;
+    [field: string]: unknown;
+};
 /** A wikilink target resolved against the host's records. */
 export type WikiResolution = {
     status: "found";
@@ -107,6 +113,8 @@ export interface RichContentSplitterEnvelopes {
     xmlRegion(tag: string, regionText: string): unknown;
 }
 export interface RichContentHost {
+    /** The host's windows, canvas, menus, kind views and services (`host/app-bindings`). Each has an announced default. */
+    app: Partial<import("./app-bindings.js").RichContentAppBindings>;
     /** User-visible notices. Default: the console (announced). */
     toast: RichContentToast;
     /** The Error Inspector sink. Default: `console.error`. */
@@ -121,7 +129,7 @@ export interface RichContentHost {
     }>;
     /** Extra actions beside an error message (matrx-frontend: the Alchemy error menu). Default: none — the message itself always shows. */
     ErrorActions: ComponentType<{
-        error: unknown;
+        error?: unknown;
     }>;
     /** Renders nested markdown at the `standard` level, one depth deeper. Default: the source as plain text. */
     NestedContent: ComponentType<{
@@ -140,12 +148,11 @@ export interface RichContentHost {
     /** The splitter's kind-envelope hooks. Default: no envelopes (regions carry no `metadata.__ir`). */
     splitterEnvelopes: RichContentSplitterEnvelopes;
     /** A hook returning the host's "save these rows as a table" opener, or null. Default: no opener (the button is absent). */
-    useOpenSaveToTable: () => ((options: {
-        grid: {
-            headers: string[];
-            rows: string[][];
-        };
-    }) => unknown) | null;
+    useOpenSaveToTable: () => ((options: Record<string, unknown>) => unknown) | null;
+    /** Loads mermaid (`() => import("mermaid").then((m) => m.default)`). Default: none — diagrams show their source. */
+    loadMermaid: () => Promise<unknown>;
+    /** Loads the ELK layout loaders (`() => import("@mermaid-js/layout-elk").then((m) => m.default)`). Default: dagre only. */
+    loadMermaidElk: () => Promise<unknown>;
     /** The kind registry. Default: no kinds known (kind JSON renders through the generic structured floor). */
     kindRegistry: RichContentKindRegistry;
     /** The (kind, platform, role) component resolver. Default: a resolver with no rows. */

package/dist/levels/RichContent.d.ts

@@ -0,0 +1,3 @@
+import type { RichContentProps } from "./rich-content-types.js";
+export declare function RichContent({ source, level, isStreaming, className, depthCap, variant, links, headingAnchors, imagePolicy, gfmCell, onContentChange, applyLocalEdits, analysisData, messageId, conversationId, allowFullScreenEditor, hideCopyButton, }: RichContentProps): import("react").JSX.Element;
+export default RichContent;

package/dist/levels/RichContent.js

@@ -0,0 +1,102 @@
+"use client";
+import { jsx } from "react/jsx-runtime";
+import { clientLazy } from "../utils/client-lazy.js";
+import { MarkdownStream } from "../host/app-bindings.js";
+import { RichContentDepthProvider } from "./depth.js";
+import { HeadingAnchorsProvider } from "../markdown-core/heading-anchors-context.js";
+import { RichContentInline } from "./RichContentInline.js";
+import { RichContentVariantRoot } from "./prose/variant-root.js";
+const RichContentStandardImpl = clientLazy(
+  () => import("./RichContentStandardImpl.js"),
+  { loading: () => null }
+);
+function RichContent({
+  source,
+  level,
+  isStreaming,
+  className,
+  depthCap,
+  variant,
+  links,
+  headingAnchors = true,
+  imagePolicy,
+  gfmCell,
+  onContentChange,
+  applyLocalEdits,
+  analysisData,
+  messageId,
+  conversationId,
+  allowFullScreenEditor,
+  hideCopyButton
+}) {
+  if (level === "inline") {
+    return /* @__PURE__ */ jsx(
+      RichContentInline,
+      {
+        source,
+        className,
+        links,
+        streaming: isStreaming,
+        imagePolicy,
+        gfmCell
+      }
+    );
+  }
+  if (!headingAnchors) {
+    return /* @__PURE__ */ jsx(HeadingAnchorsProvider, { value: false, children: /* @__PURE__ */ jsx(
+      RichContent,
+      {
+        source,
+        level,
+        isStreaming,
+        className,
+        depthCap,
+        variant,
+        imagePolicy,
+        onContentChange,
+        applyLocalEdits,
+        analysisData,
+        messageId,
+        conversationId,
+        allowFullScreenEditor,
+        hideCopyButton
+      }
+    ) });
+  }
+  if (level === "standard") {
+    return /* @__PURE__ */ jsx(
+      RichContentStandardImpl,
+      {
+        source,
+        isStreaming,
+        className,
+        depthCap,
+        variant,
+        imagePolicy
+      }
+    );
+  }
+  const full = /* @__PURE__ */ jsx(
+    MarkdownStream,
+    {
+      imagePolicy,
+      content: source,
+      isStreamActive: isStreaming,
+      className,
+      onContentChange,
+      applyLocalEdits,
+      analysisData,
+      messageId,
+      conversationId,
+      allowFullScreenEditor,
+      hideCopyButton
+    }
+  );
+  const rendered = /* @__PURE__ */ jsx(RichContentVariantRoot, { variant, children: depthCap === void 0 ? full : /* @__PURE__ */ jsx(RichContentDepthProvider, { depth: 0, cap: depthCap, children: full }) });
+  return rendered;
+}
+var RichContent_default = RichContent;
+export {
+  RichContent,
+  RichContent_default as default
+};

package/dist/levels/RichContentInline.d.ts

@@ -0,0 +1,28 @@
+import { INLINE_LEVEL_ELEMENTS, type InlineLinks } from "./prose/inline-level-elements.js";
+import { type ImagePolicyDeclaration } from "./prose/remote-image-policy.js";
+export { INLINE_LEVEL_ELEMENTS };
+export interface RichContentInlineProps {
+    source: string;
+    className?: string;
+    /** `text` inside a link (card previews): formatting kept, no nested anchor. */
+    links?: InlineLinks;
+    /**
+     * The source is still arriving (a table cell of a streaming row): the core
+     * heals half-arrived links, emphasis, code and math. Omit to inherit from a
+     * live MarkdownStreamingProvider; `false` for text that is already whole.
+     */
+    streaming?: boolean;
+    /**
+     * Who wrote this text — decides whether remote images load by themselves
+     * (remote-image-policy.tsx). Omit to inherit the surrounding declaration;
+     * with none anywhere, remote images wait for a click.
+     */
+    imagePolicy?: ImagePolicyDeclaration;
+    /**
+     * The source is ONE GFM table cell: inline constructs only (block syntax is
+     * text, as GFM reads a cell) and `\|` shows as `|`. verify-RC-B4 R6-1.
+     */
+    gfmCell?: boolean;
+}
+export declare function RichContentInline({ source, className, links, streaming, imagePolicy, gfmCell, }: RichContentInlineProps): import("react").JSX.Element | null;
+export default RichContentInline;

package/dist/levels/RichContentInline.js

@@ -0,0 +1,61 @@
+"use client";
+import { Fragment, jsx } from "react/jsx-runtime";
+import { useEffect } from "react";
+import MarkdownCore from "../markdown-core/MarkdownCore.js";
+import {
+  guardMarkdownDelimiters,
+  reportDelimiterViolations
+} from "@ai-matrx/kit/delimiter-guard";
+import { captureError } from "../host/diagnostics.js";
+import { cn } from "@ai-matrx/design-system";
+import { preprocessCellProse, preprocessProse } from "./prose/prose-prepare.js";
+import { unescapeCellPipes } from "../markdown-core/syntax/gfm-cell-pipes.js";
+import {
+  INLINE_LEVEL_ELEMENTS,
+  INLINE_LEVEL_WRAPPER_CLASS,
+  inlineLevelElements
+} from "./prose/inline-level-elements.js";
+import { withImagePolicy } from "./prose/remote-image-policy.js";
+import { inlineKindText, nonJsonKindsAsCode } from "@ai-matrx/content-ir/surfaces";
+function RichContentInline({
+  source,
+  className,
+  links = "link",
+  streaming,
+  imagePolicy,
+  gfmCell = false
+}) {
+  const prose = nonJsonKindsAsCode(inlineKindText(gfmCell ? unescapeCellPipes(source) : source));
+  const { text, violations } = guardMarkdownDelimiters(gfmCell ? preprocessCellProse(prose) : preprocessProse(prose));
+  useEffect(() => {
+    if (violations.length === 0) return;
+    reportDelimiterViolations(violations, {
+      renderPath: "RichContentInline",
+      capture: (input) => captureError({ ...input })
+    });
+  }, [violations]);
+  if (!source.trim()) return null;
+  const rendered = /* @__PURE__ */ jsx(
+    "span",
+    {
+      "data-rich-content": "inline",
+      className: cn(INLINE_LEVEL_WRAPPER_CLASS, className),
+      children: /* @__PURE__ */ jsx(
+        MarkdownCore,
+        {
+          preset: gfmCell ? "chat-cell" : "chat",
+          components: inlineLevelElements(links),
+          streaming,
+          children: text
+        }
+      )
+    }
+  );
+  return /* @__PURE__ */ jsx(Fragment, { children: withImagePolicy(imagePolicy, rendered) });
+}
+var RichContentInline_default = RichContentInline;
+export {
+  INLINE_LEVEL_ELEMENTS,
+  RichContentInline,
+  RichContentInline_default as default
+};

package/dist/levels/RichContentPreview.d.ts

@@ -0,0 +1,12 @@
+/** Cut at a line boundary: the first non-empty lines, bounded by characters. */
+export declare function previewSource(source: string, lines: number, maxChars: number): string;
+export interface RichContentPreviewProps {
+    source: string | null | undefined;
+    /** CSS line clamp (1 = single-line truncate). Default 2. */
+    lines?: 1 | 2 | 3 | 4 | 6;
+    /** Hard cap on source characters handed to the renderer. Default 400. */
+    maxChars?: number;
+    className?: string;
+}
+export declare function RichContentPreview({ source, lines, maxChars, className, }: RichContentPreviewProps): import("react").JSX.Element | null;
+export default RichContentPreview;