@ai-matrx/rich-content 0.2.4 → 0.2.7

package/dist/display/chat-markdown/block-registry/block-dispatch.js

@@ -0,0 +1,495 @@
+"use client";
+import { jsx } from "react/jsx-runtime";
+import { NestedRichContent } from "../../../levels/standard/NestedRichContent.js";
+import { BlockComponents } from "./BlockComponentRegistry.js";
+import { InlineStatusIndicator } from "../internal-handlers/InlineStatusIndicator.js";
+import { EXPERT_WORKING_LABEL } from "../../block-interaction.js";
+import { looksLikeDiff } from "../diff-blocks/diff-style-registry.js";
+import { InlineCodeSnippet } from "../InlineCodeSnippet.js";
+import { isQuotedSourceXmlBlock } from "@ai-matrx/content-ir/surfaces";
+import {
+  GENERIC_STRUCTURED_COMPONENT_KEY
+} from "../../../kinds/react/kind-route.js";
+import GenericStructuredBlock from "../../blocks/generic/GenericStructuredBlock.js";
+import MarkdownKindBlock from "../../blocks/markdown/MarkdownKindBlock.js";
+import { CodeBlockWithContextAttach } from "../../../host/app-bindings.js";
+import { captureError } from "../../../host/diagnostics.js";
+import { FENCE_META_KEY } from "@ai-matrx/content-ir/source";
+import {
+  detectImageMarkdown
+} from "../../markdown-classification/processors/utils/content-splitter-v2.js";
+import { readEnvelope } from "../../../kinds/redux/render-block-envelope.js";
+import { jsonAnswerRenderer } from "../../block-interaction.js";
+const DEFAULT_UNLABELED_FENCE_LANGUAGE = "markdown";
+const JSON_CODE_LANGUAGES = /* @__PURE__ */ new Set(["json"]);
+function audioMimeFromUrl(url) {
+  const ext = url.split(/[?#]/)[0].match(/\.([a-z0-9]+)$/i)?.[1]?.toLowerCase();
+  switch (ext) {
+    case "mp3":
+      return "audio/mpeg";
+    case "wav":
+      return "audio/wav";
+    case "m4a":
+      return "audio/mp4";
+    case "aac":
+      return "audio/aac";
+    case "ogg":
+    case "oga":
+      return "audio/ogg";
+    case "opus":
+      return "audio/opus";
+    case "flac":
+      return "audio/flac";
+    case "weba":
+    case "webm":
+      return "audio/webm";
+    default:
+      return void 0;
+  }
+}
+function isGenuinelyIncomplete(content) {
+  const trimmed = content.trim();
+  const openBraces = (trimmed.match(/\{/g) || []).length;
+  const closeBraces = (trimmed.match(/\}/g) || []).length;
+  return openBraces > closeBraces;
+}
+function isBlockLoading(block) {
+  if (block.isStreamingBlock) return true;
+  const envelope = readEnvelope(block.metadata);
+  if (envelope?.root.kind && envelope.root.status !== "complete") return true;
+  if (block.metadata?.isComplete === false && isGenuinelyIncomplete(block.content))
+    return true;
+  return false;
+}
+const reportedUnregisteredTypes = /* @__PURE__ */ new Set();
+function reportUnregisteredBlockType(type, meta) {
+  const message = `[block-dispatch] UNREGISTERED render-block type "${type}" \u2014 no dispatch registration exists. Rendering as basic markdown. Classify it in block-dispatch.tsx (per the content-vocab crosswalk) and register a renderer.`;
+  if (!reportedUnregisteredTypes.has(type)) {
+    reportedUnregisteredTypes.add(type);
+    console.error(message, meta);
+  }
+  captureError({
+    source: "content-ir",
+    message,
+    requestId: meta.requestId,
+    conversationId: meta.conversationId,
+    raw: { blockType: type, ...meta }
+  });
+}
+const reportedArtifactStageMisses = /* @__PURE__ */ new Set();
+const expectUnifiedArtifactStage = (ctx) => {
+  const { block } = ctx;
+  const message = `[block-dispatch] block type "${block.type}" should have rendered via the unified artifact stage (features/canvas/artifact-types/artifact-renderers.tsx) but fell through to the dispatch table \u2014 its unified renderer registration is missing. Rendering as basic markdown.`;
+  if (!reportedArtifactStageMisses.has(block.type)) {
+    reportedArtifactStageMisses.add(block.type);
+    console.error(message);
+  }
+  captureError({
+    source: "content-ir",
+    message,
+    conversationId: ctx.conversationId,
+    requestId: ctx.requestId,
+    raw: { blockType: block.type }
+  });
+  return block.content ? ctx.renderBasicMarkdown(block.content) : null;
+};
+const renderControlTagMarkdown = (ctx) => ctx.block.content ? ctx.renderBasicMarkdown(ctx.block.content) : null;
+const renderNestedSection = ({ block, index, isStreamActive }) => block.content ? /* @__PURE__ */ jsx(
+  NestedRichContent,
+  {
+    source: block.content,
+    isStreaming: isStreamActive
+  },
+  index
+) : null;
+function missingMediaFallback(ctx, kind) {
+  console.warn(
+    `[BlockRenderer] ${kind} block without a readable URL \u2014 showing its text.`,
+    ctx.block.content.slice(0, 200)
+  );
+  return ctx.block.content ? ctx.renderBasicMarkdown(ctx.block.content) : null;
+}
+function readFenceMeta(source) {
+  const value = source?.[FENCE_META_KEY];
+  return typeof value === "string" && value ? value : void 0;
+}
+const META_PREFERS_CODE_BLOCK = /* @__PURE__ */ new Set([
+  "yaml",
+  "yml",
+  "toml",
+  "csv",
+  "tsv",
+  "xml"
+]);
+const CODE_LANGUAGE_DISPATCH = {
+  yaml: renderYamlCode,
+  yml: renderYamlCode,
+  // HTML used to be lumped in with XmlBlock, which broke the standard code
+  // block (and with it the "convert to actual webpage" feature) — see the
+  // `html` entry below.
+  xml: renderXmlCode,
+  svg: renderXmlCode,
+  html: renderHtmlCode,
+  jsx: renderReactCode,
+  tsx: renderReactCode,
+  react: renderReactCode,
+  csv: renderCsvCode,
+  tsv: renderCsvCode,
+  toml: renderTomlCode,
+  json: renderJsonCode,
+  jsonc: renderJsonCode,
+  json5: renderJsonCode,
+  markdown: renderMarkdownPreviewCode,
+  md: renderMarkdownPreviewCode,
+  mdx: renderMarkdownPreviewCode
+};
+function renderYamlCode({ block, index }) {
+  return /* @__PURE__ */ jsx(
+    BlockComponents.YamlBlock,
+    {
+      content: block.content,
+      className: "my-3"
+    },
+    index
+  );
+}
+function renderXmlCode({ block, index }) {
+  return /* @__PURE__ */ jsx(
+    BlockComponents.XmlBlock,
+    {
+      content: block.content,
+      language: block.language?.toLowerCase(),
+      quotedSource: isQuotedSourceXmlBlock(block),
+      className: "my-3"
+    },
+    index
+  );
+}
+function renderPlainCodeFallback({ block, index }) {
+  return /* @__PURE__ */ jsx(BlockComponents.CodeBlock, { code: block.content, language: block.language ?? DEFAULT_UNLABELED_FENCE_LANGUAGE, className: "my-3" }, index);
+}
+function renderHtmlCode(ctx) {
+  const { block, index, isStreamActive, messageId, conversationId } = ctx;
+  const HtmlInlinePreview = BlockComponents.HtmlInlinePreview;
+  if (!HtmlInlinePreview) return renderPlainCodeFallback(ctx);
+  return /* @__PURE__ */ jsx(
+    HtmlInlinePreview,
+    {
+      code: block.content,
+      language: block.language,
+      isComplete: !isStreamActive && !isBlockLoading(block),
+      messageId,
+      conversationId,
+      onCodeChange: isStreamActive ? void 0 : (newCode) => ctx.replaceBlockContent(block.content, newCode)
+    },
+    index
+  );
+}
+function renderReactCode(ctx) {
+  const { block, index, isStreamActive } = ctx;
+  const ReactCodeBlock = BlockComponents.ReactCodeBlock;
+  if (!ReactCodeBlock) return renderPlainCodeFallback(ctx);
+  return /* @__PURE__ */ jsx(
+    ReactCodeBlock,
+    {
+      code: block.content,
+      language: block.language,
+      isComplete: !isStreamActive && !isBlockLoading(block),
+      onCodeChange: isStreamActive ? void 0 : (newCode) => ctx.replaceBlockContent(block.content, newCode)
+    },
+    index
+  );
+}
+function renderCsvCode(ctx) {
+  const { block, index, isStreamActive } = ctx;
+  return /* @__PURE__ */ jsx(
+    BlockComponents.CsvBlock,
+    {
+      content: block.content,
+      delimiter: block.language?.toLowerCase() === "tsv" ? "	" : ",",
+      className: "my-3",
+      onInnerContentChange: isStreamActive ? void 0 : (inner) => ctx.replaceBlockContent(block.content, inner)
+    },
+    index
+  );
+}
+function renderTomlCode({ block, index }) {
+  return /* @__PURE__ */ jsx(
+    BlockComponents.TomlBlock,
+    {
+      content: block.content,
+      className: "my-3"
+    },
+    index
+  );
+}
+function renderJsonCode(ctx) {
+  const { block, index, isStreamActive, conversationId, messageId } = ctx;
+  return /* @__PURE__ */ jsx(
+    BlockComponents.JsonBlock,
+    {
+      content: block.content,
+      meta: readFenceMeta(block.metadata) ?? readFenceMeta(block.serverData),
+      className: "my-3",
+      isStreamActive,
+      conversationId,
+      messageId,
+      irEnvelope: readEnvelope(block.metadata),
+      onCodeChange: isStreamActive ? void 0 : (newCode) => ctx.replaceBlockContent(block.content, newCode)
+    },
+    index
+  );
+}
+function renderMarkdownPreviewCode(ctx) {
+  const { block, index, isStreamActive } = ctx;
+  return /* @__PURE__ */ jsx(
+    BlockComponents.MarkdownPreviewBlock,
+    {
+      content: block.content,
+      className: "my-3",
+      isStreamActive,
+      onCodeChange: isStreamActive ? void 0 : (newCode) => ctx.replaceBlockContent(block.content, newCode)
+    },
+    index
+  );
+}
+const PROTOCOL_BLOCK_DISPATCH = {
+  thinking: renderReasoningEntry,
+  reasoning: renderReasoningEntry,
+  consolidated_reasoning: (ctx) => {
+    const { block, index } = ctx;
+    if (ctx.hideReasoning || ctx.machineFramesVisible === false) return null;
+    return /* @__PURE__ */ jsx(
+      BlockComponents.ConsolidatedReasoningVisualization,
+      {
+        reasoningTexts: block.metadata?.reasoningTexts ?? [
+          block.content
+        ],
+        showReasoning: true
+      },
+      index
+    );
+  },
+  info: renderNestedSection,
+  task: renderNestedSection,
+  database: renderNestedSection,
+  private: renderNestedSection,
+  plan: renderNestedSection,
+  event: renderNestedSection,
+  tool: (ctx) => {
+    if (ctx.hideToolResults) return null;
+    return renderNestedSection(ctx);
+  },
+  search_replace: ({ block, index, isStreamActive }) => /* @__PURE__ */ jsx(
+    BlockComponents.SearchReplaceBlock,
+    {
+      serverData: block.serverData,
+      content: block.serverData ? void 0 : block.content,
+      language: block.metadata?.language || "typescript",
+      isStreamActive,
+      className: "my-3"
+    },
+    index
+  )
+};
+function renderReasoningEntry(ctx) {
+  const { block, index, isStreamActive, isLastReasoningBlock } = ctx;
+  if (ctx.hideReasoning) return null;
+  const isStreaming = isStreamActive === true && (isLastReasoningBlock === true || block.isStreamingBlock === true);
+  if (ctx.machineFramesVisible === false) {
+    return isStreaming ? /* @__PURE__ */ jsx(InlineStatusIndicator, { label: EXPERT_WORKING_LABEL }, index) : null;
+  }
+  return /* @__PURE__ */ jsx(
+    BlockComponents.ReasoningVisualization,
+    {
+      reasoningText: block.content,
+      showReasoning: true,
+      isStreaming
+    },
+    index
+  );
+}
+const SCALAR_GENERIC_BLOCK_DISPATCH = {
+  text: renderControlTagMarkdown,
+  code: (ctx) => {
+    const { block, index, isStreamActive, conversationId, messageId } = ctx;
+    const lang = block.language?.toLowerCase();
+    if (lang && JSON_CODE_LANGUAGES.has(lang) && !isStreamActive && !isBlockLoading(block)) {
+      const answer = jsonAnswerRenderer()?.(ctx);
+      if (answer) return answer;
+    }
+    if (block.language === "diff" && looksLikeDiff(block.content)) {
+      return /* @__PURE__ */ jsx(
+        BlockComponents.StreamingDiffBlock,
+        {
+          content: block.content,
+          language: block.language || "typescript",
+          isStreamActive,
+          className: "my-3"
+        },
+        index
+      );
+    }
+    const hasFenceMeta = !!(readFenceMeta(block.metadata) ?? readFenceMeta(block.serverData));
+    const languageRenderer = lang && !(hasFenceMeta && META_PREFERS_CODE_BLOCK.has(lang)) ? CODE_LANGUAGE_DISPATCH[lang] : void 0;
+    if (languageRenderer) {
+      return languageRenderer(ctx);
+    }
+    const sizingProbe = block.content.trim();
+    const lineCount = sizingProbe.split("\n").length;
+    const fenceMeta = readFenceMeta(block.metadata) ?? readFenceMeta(block.serverData);
+    const isSmallBlock = !fenceMeta && lineCount <= 2 && sizingProbe.length < 120;
+    if (!sizingProbe) return null;
+    if (isSmallBlock) {
+      return /* @__PURE__ */ jsx(
+        InlineCodeSnippet,
+        {
+          code: block.content,
+          language: block.language,
+          className: "my-3"
+        },
+        index
+      );
+    }
+    return /* @__PURE__ */ jsx(
+      CodeBlockWithContextAttach,
+      {
+        code: block.content,
+        language: block.language || DEFAULT_UNLABELED_FENCE_LANGUAGE,
+        meta: fenceMeta,
+        fontSize: 16,
+        className: "my-3",
+        onCodeChange: isStreamActive ? void 0 : (newCode) => ctx.replaceBlockContent(block.content, newCode),
+        isStreamActive,
+        conversationId,
+        messageId
+      },
+      index
+    );
+  },
+  // NOTE: standalone `table` blocks are normally consumed by the unified
+  // artifact stage (TableArtifact); this registration is the preserved legacy
+  // path should that stage ever decline.
+  table: (ctx) => {
+    const { block, index, isStreamActive } = ctx;
+    return /* @__PURE__ */ jsx(
+      BlockComponents.StreamingTableRenderer,
+      {
+        content: block.content,
+        metadata: block.metadata,
+        isStreamActive,
+        onContentChange: isStreamActive ? void 0 : (updatedTable) => ctx.replaceBlockContent(block.content, updatedTable)
+      },
+      index
+    );
+  },
+  image: (ctx) => {
+    const { block, index } = ctx;
+    const media = block.src ? { src: block.src, alt: block.alt } : detectImageMarkdown(block.content);
+    if (!media.src) return missingMediaFallback(ctx, "image");
+    return /* @__PURE__ */ jsx(BlockComponents.ImageBlock, { src: media.src, alt: media.alt }, index);
+  },
+  // NOTE: like `table` — normally consumed by the unified artifact stage
+  // (TreeArtifact); preserved legacy path below.
+  tree: ({ block, index }) => /* @__PURE__ */ jsx(
+    BlockComponents.TreeBlock,
+    {
+      content: block.content,
+      className: "my-3"
+    },
+    index
+  ),
+  "accent-divider": ({ index }) => /* @__PURE__ */ jsx("div", { className: "my-4 flex items-center gap-3", children: /* @__PURE__ */ jsx("div", { className: "h-0.5 flex-1 bg-primary/60 rounded-full" }) }, index),
+  "heavy-divider": ({ index }) => /* @__PURE__ */ jsx("div", { className: "my-6 flex items-center gap-2", children: /* @__PURE__ */ jsx("div", { className: "h-1 flex-1 rounded-full bg-gradient-to-r from-primary/20 via-primary to-primary/20" }) }, index),
+  // ```svg fences are consumed by the unified artifact stage (SvgArtifact).
+  svg: expectUnifiedArtifactStage
+};
+const SHAPE_BLOCK_DISPATCH = {
+  // Consumed by the unified artifact stage (Stage 3) — each of these types has
+  // a registered unified renderer (artifact-renderers.tsx). Reaching the
+  // dispatch table means that registration was lost: scream + markdown.
+  flashcards: expectUnifiedArtifactStage,
+  quiz: expectUnifiedArtifactStage,
+  presentation: expectUnifiedArtifactStage,
+  cooking_recipe: expectUnifiedArtifactStage,
+  timeline: expectUnifiedArtifactStage,
+  progress_tracker: expectUnifiedArtifactStage,
+  comparison_table: expectUnifiedArtifactStage,
+  troubleshooting: expectUnifiedArtifactStage,
+  resources: expectUnifiedArtifactStage,
+  decision_tree: expectUnifiedArtifactStage,
+  research: expectUnifiedArtifactStage,
+  diagram: expectUnifiedArtifactStage,
+  mermaid: expectUnifiedArtifactStage,
+  math_problem: expectUnifiedArtifactStage,
+  questionnaire: expectUnifiedArtifactStage,
+  tasks: expectUnifiedArtifactStage,
+  chart: expectUnifiedArtifactStage,
+  map: expectUnifiedArtifactStage,
+  stats: expectUnifiedArtifactStage,
+  diff: expectUnifiedArtifactStage,
+  // The R6 generic fallback (features/content-ir/react/kind-route.ts): the
+  // envelope resolved a kind the platform KNOWS, but nothing render-trusted
+  // claims it. Rather than dropping to a raw code block, show every field
+  // readably plus an honest "unverified shape" affordance. Reached ONLY via
+  // applyIrKindRoute — nothing emits this block type upstream.
+  [GENERIC_STRUCTURED_COMPONENT_KEY]: ({ block, index }) => /* @__PURE__ */ jsx(
+    GenericStructuredBlock,
+    {
+      content: block.content,
+      metadata: block.metadata
+    },
+    index
+  ),
+  // The `markdown` kind route (features/content-ir/react/kind-route.ts
+  // resolver-only path): `{ text }` goes to MarkdownStream — the SAME engine
+  // that renders every streamed assistant message — so prose renders as prose
+  // and any kind payload fenced inside it routes to its own component. Reached
+  // ONLY via applyIrKindRoute.
+  markdown_stream: ({ block, index, isStreamActive }) => /* @__PURE__ */ jsx(
+    MarkdownKindBlock,
+    {
+      content: block.content,
+      metadata: block.metadata,
+      isStreamActive
+    },
+    index
+  )
+};
+const OPAQUE_BLOCK_DISPATCH = {};
+const BLOCK_DISPATCH = {
+  ...PROTOCOL_BLOCK_DISPATCH,
+  ...SCALAR_GENERIC_BLOCK_DISPATCH,
+  ...SHAPE_BLOCK_DISPATCH,
+  ...OPAQUE_BLOCK_DISPATCH
+};
+const BLOCK_DISPATCH_CLASSIFICATION = {
+  protocol: Object.keys(PROTOCOL_BLOCK_DISPATCH),
+  scalar_generic: Object.keys(SCALAR_GENERIC_BLOCK_DISPATCH),
+  shape: Object.keys(SHAPE_BLOCK_DISPATCH),
+  intentionally_opaque: Object.keys(OPAQUE_BLOCK_DISPATCH)
+};
+const DISPATCH_MAP = new Map(
+  Object.entries(BLOCK_DISPATCH)
+);
+const REGISTERED_KEY = /* @__PURE__ */ Symbol.for("ai-matrx.rich-content.block-dispatch");
+function registered() {
+  const g = globalThis;
+  return g[REGISTERED_KEY] ??= /* @__PURE__ */ new Map();
+}
+function registerBlockDispatch(entries) {
+  for (const [type, fn] of Object.entries(entries)) if (fn) registered().set(type, fn);
+}
+function resolveBlockDispatch(type) {
+  return registered().get(type) ?? DISPATCH_MAP.get(type) ?? null;
+}
+export {
+  BLOCK_DISPATCH,
+  BLOCK_DISPATCH_CLASSIFICATION,
+  DEFAULT_UNLABELED_FENCE_LANGUAGE,
+  audioMimeFromUrl,
+  isBlockLoading,
+  registerBlockDispatch,
+  reportUnregisteredBlockType,
+  resolveBlockDispatch
+};

package/dist/display/chat-markdown/block-registry/json-parse-utils.d.ts

@@ -0,0 +1,13 @@
+/**
+ * JSON parse helpers for block content (LaTeX-aware, never throw).
+ * Used by BlockRenderer for quiz, presentation, math blocks.
+ */
+/**
+ * Preprocess JSON content to fix common escape sequence issues before parsing.
+ * CRITICAL: Must never throw. Always returns a string (original or fixed).
+ */
+export declare function preprocessJsonContent(jsonString: string): string;
+/**
+ * Safe JSON parsing with preprocessing. Returns null if parsing fails.
+ */
+export declare function safeJsonParse(jsonString: string): unknown;