@ai-matrx/rich-content 0.2.89 → 0.2.91

package/CHANGELOG.md

@@ -1,5 +1,17 @@
 # Changelog
 
+## 0.2.91
+
+Automatic changed-only republish (docs/metadata drift since the last tag — see
+`git diff npm/rich-content/v0.2.90..npm/rich-content/v0.2.91 -- apps/shared/rich-content`).
+No source changes intended and no consumer action required.
+
+## 0.2.90
+
+Automatic changed-only republish (docs/metadata drift since the last tag — see
+`git diff npm/rich-content/v0.2.89..npm/rich-content/v0.2.90 -- apps/shared/rich-content`).
+No source changes intended and no consumer action required.
+
 ## 0.2.89
 
 Automatic changed-only republish (docs/metadata drift since the last tag — see

package/dist/display/markdown-classification/processors/utils/content-splitter-core.d.ts

@@ -78,15 +78,7 @@ export interface SplitterBlock {
  * Kept as an alias so existing imports continue to compile during migration.
  */
 export type ContentBlock = SplitterBlock;
-/**
- * Detection is recursive across arrival containers: a complete object that
- * directly declares `__kind` becomes its own JSON/Content-IR block even when
- * Markdown first captured it inside prose, a non-JSON fence, or XML. Every
- * byte around recovered objects stays in document order as its original block
- * type. Artifact wrappers already carry their body envelope for selectors and
- * retain their identity/chrome; they are the one container that must not be
- * exploded into anonymous fragments.
- */
+export declare function wrapperSourceOf(block: SplitterBlock): string | undefined;
 export declare function recoverEmbeddedKindJsonBlocksWith(input: SplitterBlock[], envelopes: SplitterEnvelopes): SplitterBlock[];
 /**
  * Code-fence languages that promote to a first-class block type (the fence

package/dist/display/markdown-classification/processors/utils/content-splitter-core.js

@@ -43,6 +43,7 @@ import {
   XmlContainerTracker
 } from "@ai-matrx/content-ir/source";
 import { indexOutsideInlineCode } from "@ai-matrx/content-ir/source";
+import { recoverPartialKindTailWith, splitAdjacentJsonRootsWith } from "./partial-kind-tail.js";
 import {
   findBalancedXmlClose,
   initialXmlBalance
@@ -90,6 +91,15 @@ function isJsonFenceBlock(block) {
 function isQuotedSourceFenceBlock(block) {
   return block.type === "code" && block.metadata?.genericXmlContainer !== true && !isJsonFenceLanguage(block.language);
 }
+function withFenceSurface(metadata, language, content, envelopes) {
+  if (!language) return metadata;
+  const envelope = envelopes.fenceRegion(language, content);
+  return envelope ? { ...metadata ?? {}, [IR_ENVELOPE_KEY]: envelope } : metadata;
+}
+const wrapperSources = /* @__PURE__ */ new WeakMap();
+function wrapperSourceOf(block) {
+  return wrapperSources.get(block);
+}
 function recoverEmbeddedKindJsonBlocksWith(input, envelopes) {
   const recovered = [];
   for (const block of input) {
@@ -116,6 +126,8 @@ function recoverEmbeddedKindJsonBlocksWith(input, envelopes) {
       recovered.push(block);
       continue;
     }
+    const isWrapperSplit = pieces.some((piece) => piece.type === "residual");
+    const firstPiece = recovered.length;
     let followsKind = false;
     for (const piece of pieces) {
       if (piece.type === "chrome") continue;
@@ -162,6 +174,9 @@ function recoverEmbeddedKindJsonBlocksWith(input, envelopes) {
         metadata: genericXml ? { genericXmlContainer: true } : void 0
       });
     }
+    if (isWrapperSplit) {
+      for (const piece of recovered.slice(firstPiece)) wrapperSources.set(piece, block.content);
+    }
   }
   return recovered;
 }
@@ -890,8 +905,11 @@ function extractCodeBlock(language, openTicks, startIndex, lines, fenceChar = "`
     { char: fenceChar, ticks: openTicks, lang: language ?? "" }
   );
   if (!end.closed) {
+    const body2 = lines.slice(startIndex);
+    const tail = (body2[body2.length - 1] ?? "").trim();
+    if (body2.length > 0 && tail && tail.length < openTicks && [...tail].every((c) => c === fenceChar)) body2.pop();
     return {
-      content: lines.slice(startIndex).join("\n"),
+      content: body2.join("\n"),
       nextIndex: lines.length + 1,
       metadata: { language },
       closedCleanly: false
@@ -1288,18 +1306,29 @@ const splitContentIntoBlocksWith = (mdContent, envelopes) => {
             type: "code",
             content: extraction.content,
             language: codeCheck.language,
-            metadata: envelopes.withIrEnvelope(
+            metadata: withFenceSurface(
+              envelopes.withIrEnvelope(
+                extraction.content,
+                codeCheck.meta ? { [FENCE_META_KEY]: codeCheck.meta } : void 0
+              ),
+              extraction.closedCleanly ? normalizedLanguage : void 0,
               extraction.content,
-              codeCheck.meta ? { [FENCE_META_KEY]: codeCheck.meta } : void 0
+              envelopes
             )
           });
         }
       } else {
+        const codeMetadata = withFenceSurface(
+          codeCheck.meta ? { [FENCE_META_KEY]: codeCheck.meta } : void 0,
+          extraction.closedCleanly ? normalizedLanguage : void 0,
+          extraction.content,
+          envelopes
+        );
         blocks.push({
           type: "code",
           content: extraction.content,
           language: codeCheck.language,
-          ...codeCheck.meta ? { metadata: { [FENCE_META_KEY]: codeCheck.meta } } : {}
+          ...codeMetadata ? { metadata: codeMetadata } : {}
         });
       }
       i = extraction.nextIndex;
@@ -1341,7 +1370,7 @@ const splitContentIntoBlocksWith = (mdContent, envelopes) => {
         i,
         lines
       );
-      let xmlMetadata = extraction.metadata;
+      let xmlMetadata = extraction.metadata ? { rawXml: extraction.content, ...extraction.metadata } : extraction.metadata;
       if (xmlMetadata?.isComplete === true) {
         const xmlTag = xmlTagNameOf(xmlMatch.matchedTag);
         const attributed = xmlMatch.matchedTag !== `<${xmlTag}>`;
@@ -1776,7 +1805,10 @@ ${extraction.content}
   if (currentText.trim()) {
     blocks.push({ type: "text", content: currentText.trimEnd() });
   }
-  return recoverEmbeddedKindJsonBlocksWith(blocks, envelopes);
+  return recoverPartialKindTailWith(
+    recoverEmbeddedKindJsonBlocksWith(splitAdjacentJsonRootsWith(blocks, envelopes), envelopes),
+    envelopes
+  );
 };
 export {
   AUDIO_URL_EXT,
@@ -1795,5 +1827,6 @@ export {
   parseXmlAttributes,
   recoverEmbeddedKindJsonBlocksWith,
   splitContentIntoBlocksWith,
-  startUnrecognizedXmlContainer
+  startUnrecognizedXmlContainer,
+  wrapperSourceOf
 };

package/dist/display/markdown-classification/processors/utils/partial-kind-tail.d.ts

@@ -0,0 +1,22 @@
+/**
+ * THE OPEN KIND AT THE END OF THE TEXT — the splitter's reading of a text that stops inside a kind.
+ *
+ * `recoverEmbeddedKindJsonBlocksWith` lifts every COMPLETE kind object out of its container
+ * (prose, an XML tag, a reasoning region, a JSON wrapper). A text that ends inside a kind — every
+ * frame of a stream, or a truncated answer on reload — holds an object that never closes, so
+ * that pass cannot see it and the kind would print as prose, sit inside an XML card, or draw as
+ * a raw JSON card (the never-raw law, Arman 2026-09-30). This pass reads the same thing for the
+ * open object: the last block is cut where the still-open root object (or array of objects)
+ * starts, the moment a `__kind` key is visible in it. Complete elements of an open array of
+ * kinds become their own kinds (A6); its array punctuation draws nothing.
+ *
+ * One reading for both paths: the live stream and a reload of the same text call this the same
+ * way, so a stream never draws a layout its own reload does not.
+ */
+import type { SplitterBlock, SplitterEnvelopes } from "./content-splitter-core.js";
+export declare function recoverPartialKindTailWith(blocks: SplitterBlock[], envelopes: SplitterEnvelopes): SplitterBlock[];
+/**
+ * Root objects written back to back (`{…}{…}{…}`, a provider concatenating answers): each root is
+ * its own JSON region — one block per root, the reading the live stream always drew.
+ */
+export declare function splitAdjacentJsonRootsWith(blocks: SplitterBlock[], envelopes: SplitterEnvelopes): SplitterBlock[];

package/dist/display/markdown-classification/processors/utils/partial-kind-tail.js

@@ -0,0 +1,209 @@
+import {
+  bareRegionBreaksIntoProse,
+  hasKindKey,
+  jsonKindSignal,
+  kindObjectProseBreak,
+  normalizeRecoveredContainerPiece
+} from "@ai-matrx/content-ir/surfaces";
+import { hasUnclosedBacktickRun } from "@ai-matrx/content-ir/source";
+const unescapeKey = (source) => source.replace(/\\_/g, "_");
+const isKindSource = (source) => hasKindKey(source) || hasKindKey(unescapeKey(source));
+const QUOTE_MARKERS = /\n[ \t]{0,3}(?:> ?)+/g;
+const unquote = (source) => source.replace(QUOTE_MARKERS, "\n");
+const NEVER_CUT = /* @__PURE__ */ new Set(["artifact", "matrx", "matrx_file", "table", "tree", "image", "video", "audio"]);
+const JSON_LANGUAGES = /* @__PURE__ */ new Set(["", "json", "jsonc", "json5"]);
+function scan(text, from) {
+  const stack = [];
+  let inString = false;
+  let escaped = false;
+  const isArray = text[from] === "[";
+  const elements = [];
+  let elementStart = -1;
+  for (let i = from; i < text.length; i++) {
+    const ch = text[i];
+    if (inString) {
+      if (escaped) escaped = false;
+      else if (ch === "\\") escaped = true;
+      else if (ch === '"') inString = false;
+      continue;
+    }
+    if (isArray && stack.length === 1 && elementStart === -1 && !/[\s,\]]/.test(ch)) elementStart = i;
+    if (ch === '"') inString = true;
+    else if (ch === "{" || ch === "[") stack.push(ch);
+    else if (ch === "}" || ch === "]") {
+      stack.pop();
+      if (stack.length === 0) return { closedAt: i + 1 };
+      if (isArray && stack.length === 1 && elementStart !== -1) {
+        elements.push({ start: elementStart, end: i + 1, complete: true });
+        elementStart = -1;
+      }
+    } else if (isArray && stack.length === 1 && ch === ",") {
+      if (elementStart !== -1) elements.push({ start: elementStart, end: i, complete: true });
+      elementStart = -1;
+    }
+  }
+  if (isArray && elementStart !== -1) elements.push({ start: elementStart, end: text.length, complete: false });
+  return { open: { start: from, elements, isArray } };
+}
+function openRootOf(text, prose, xml) {
+  let i = 0;
+  while (i < text.length) {
+    const ch = text[i];
+    if (ch !== "{" && ch !== "[") {
+      i++;
+      continue;
+    }
+    if (prose) {
+      const lineStart = text.lastIndexOf("\n", i - 1) + 1;
+      if (hasUnclosedBacktickRun(text.slice(lineStart, i))) {
+        i++;
+        continue;
+      }
+    }
+    if (xml && text.lastIndexOf("<", i) > text.lastIndexOf(">", i)) {
+      i++;
+      continue;
+    }
+    if (ch === "{" && !/^\{\s*(?:"|\}|$)/.test(unquote(text.slice(i)))) {
+      i++;
+      continue;
+    }
+    if (ch === "[" && !/^\[\s*(?:\{|$)/.test(text.slice(i))) {
+      i++;
+      continue;
+    }
+    const result = scan(text, i);
+    if ("open" in result) return result.open;
+    i = result.closedAt;
+  }
+  return null;
+}
+function isCuttable(block) {
+  if (NEVER_CUT.has(block.type)) return false;
+  if (block.type === "code") {
+    if (block.metadata?.genericXmlContainer === true) return true;
+    return JSON_LANGUAGES.has((block.language ?? "").toLowerCase());
+  }
+  return true;
+}
+const TRAILING_JSON_FENCE_OPENER = /\n?[ \t]*(?:`{3,}|~{3,})[ \t]*(?:json5?|jsonc)?[ \t]*\n?[ \t]*$/i;
+function recoverPartialKindTail(blocks, envelopes) {
+  const last = blocks[blocks.length - 1];
+  if (!last || !isCuttable(last)) return blocks;
+  const content = last.content;
+  const isJsonCode = last.type === "code" && last.metadata?.genericXmlContainer !== true;
+  if (isJsonCode && blocks.length > 1 && content.trim() && /^[\s,\]]+$/.test(content)) return blocks.slice(0, -1);
+  if (!content.includes("{")) return blocks;
+  const isCodeJson = last.type === "code" && last.metadata?.genericXmlContainer !== true;
+  const xml = last.type !== "text" && content.trimStart().startsWith("<");
+  const root = openRootOf(content, last.type === "text", xml);
+  if (!root) return blocks;
+  const lead = content.slice(0, root.start);
+  if (isCodeJson && !root.isArray) {
+    if (!lead.trim() || !/^[\s,[\]]*$/.test(lead)) return blocks;
+    return [
+      ...blocks.slice(0, -1),
+      { type: "code", content: content.slice(root.start), language: "json", metadata: { isComplete: false } }
+    ];
+  }
+  const rootText = last.type === "text" ? unquote(content.slice(root.start)) : content.slice(root.start);
+  if (kindObjectProseBreak(rootText.trimStart()) !== null || bareRegionBreaksIntoProse(rootText)) return blocks;
+  const opensLine = !lead || lead.endsWith("\n");
+  const bareRegion = last.type === "text" && opensLine && (/^(?:\[\s*)?\{\s*"[^"]*"\s*:/.test(rootText) || /^(?:\[\s*)?\{\s*(?:"[^"]*"?\s*)?$/.test(rootText)) && !bareRegionBreaksIntoProse(rootText);
+  const headOf = () => {
+    const before2 = lead.trimEnd();
+    return before2.trim() ? [{ ...last, content: before2 }] : [];
+  };
+  const splitAsRegion = () => [
+    ...blocks.slice(0, -1),
+    ...headOf(),
+    { type: "code", content: rootText, language: "json", metadata: { isComplete: false } }
+  ];
+  const pieces = [];
+  if (root.isArray) {
+    for (const element of root.elements) {
+      const source = content.slice(element.start, element.end).trim();
+      if (!source.startsWith("{") || !isKindSource(source)) {
+        if (element.complete) return bareRegion ? splitAsRegion() : blocks;
+        if (jsonKindSignal(source) === "not_kind") return bareRegion ? splitAsRegion() : blocks;
+      }
+      pieces.push(
+        element.complete ? { type: "code", content: source, language: "json", metadata: envelopes.withIrEnvelope(source, void 0) } : { type: "code", content: source, language: "json", metadata: { isComplete: false } }
+      );
+    }
+    if (pieces.length === 0) return blocks;
+  } else {
+    const raw = last.type === "text" ? unquote(content.slice(root.start)) : content.slice(root.start);
+    if (!isKindSource(raw)) return bareRegion ? splitAsRegion() : blocks;
+    const source = /"[^"]*\\_/.test(raw) ? unescapeKey(raw) : raw;
+    pieces.push({ type: "code", content: source, language: "json", metadata: { isComplete: false } });
+  }
+  let before = content.slice(0, root.start);
+  if (last.type !== "text") before = before.replace(TRAILING_JSON_FENCE_OPENER, "");
+  const container = isCodeJson ? "" : normalizeRecoveredContainerPiece(before, last.type, false);
+  const head = container && container.trim() ? [{ ...last, content: last.type === "text" ? container.trimEnd() : container }] : [];
+  return withoutArrayChrome([...blocks.slice(0, -1), ...head, ...pieces]);
+}
+function recoverPartialKindTailWith(blocks, envelopes) {
+  const out = recoverPartialKindTail(blocks, envelopes);
+  const cleaned = withoutArrayChrome(out);
+  return cleaned.length === out.length ? out : cleaned;
+}
+const isJsonBlock = (block) => block?.type === "code" && block.language === "json";
+function withoutArrayChrome(blocks) {
+  return blocks.filter(
+    (block, i) => !((block.type === "text" || isJsonBlock(block)) && /^[\s[\],]+$/.test(block.content) && (isJsonBlock(blocks[i - 1]) || isJsonBlock(blocks[i + 1])))
+  );
+}
+function splitAdjacentJsonRootsWith(blocks, envelopes) {
+  let changed = false;
+  const out = [];
+  for (const block of blocks) {
+    const roots = block.type === "text" ? adjacentRoots(block.content) : null;
+    if (!roots) {
+      out.push(block);
+      continue;
+    }
+    changed = true;
+    roots.forEach((root, n) => {
+      const open = n === roots.length - 1 && scan(root, 0) && !("closedAt" in scan(root, 0));
+      out.push({
+        type: "code",
+        content: root,
+        language: "json",
+        metadata: open ? { isComplete: false } : envelopes.withIrEnvelope(root, void 0)
+      });
+    });
+  }
+  return changed ? out : blocks;
+}
+function adjacentRoots(content) {
+  const text = content.trim();
+  if (!text.startsWith("{")) return null;
+  const roots = [];
+  let i = 0;
+  while (i < text.length) {
+    if (text[i] !== "{") return null;
+    const result = scan(text, i);
+    if (!("closedAt" in result)) {
+      if (roots.length === 0) return null;
+      roots.push(text.slice(i));
+      return roots;
+    }
+    const root = text.slice(i, result.closedAt);
+    try {
+      const value = JSON.parse(root);
+      if (!value || typeof value !== "object" || Array.isArray(value)) return null;
+    } catch {
+      return null;
+    }
+    roots.push(root);
+    i = result.closedAt;
+    while (i < text.length && /\s/.test(text[i])) i++;
+  }
+  return roots.length >= 2 ? roots : null;
+}
+export {
+  recoverPartialKindTailWith,
+  splitAdjacentJsonRootsWith
+};

package/dist/display/themes.js

@@ -833,7 +833,7 @@ const THEMES = {
       headerText: "text-neutral-900 dark:text-neutral-100",
       row: {
         even: "bg-white dark:bg-neutral-800",
-        odd: "bg-neutral-50 dark:bg-neutral-850",
+        odd: "bg-neutral-50 dark:bg-neutral-900",
         hover: "hover:bg-neutral-100 dark:hover:bg-neutral-700"
       },
       border: "border-neutral-200 dark:border-neutral-700",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ai-matrx/rich-content",
-  "version": "0.2.89",
+  "version": "0.2.91",
   "description": "The AI Matrx formatted-text engine: the one markdown renderer, streaming markdown, the block splitter and renderer, the generic blocks, <RichContent> levels, the rich-document action registry and menus, copy, and the selection toolbar — as portable React.",
   "type": "module",
   "license": "MIT",
@@ -131,19 +131,19 @@
     "unist-util-visit-parents": "^6.0.2",
     "yaml": "^2.9.1",
     "@ai-matrx/agents": "latest",
+    "@ai-matrx/alchemy": "latest",
     "@ai-matrx/content-ir": "latest",
     "@ai-matrx/content-ir-react": "latest",
     "@ai-matrx/data": "latest",
-    "@ai-matrx/alchemy": "latest",
     "@ai-matrx/canvas": "latest",
-    "@ai-matrx/icons": "latest",
     "@ai-matrx/diff": "latest",
+    "@ai-matrx/icons": "latest",
     "@ai-matrx/kit": "latest",
-    "@ai-matrx/design-system": "latest",
+    "@ai-matrx/media": "latest",
     "@ai-matrx/print": "latest",
-    "@ai-matrx/records-ui": "latest",
     "@ai-matrx/records": "latest",
-    "@ai-matrx/media": "latest"
+    "@ai-matrx/design-system": "latest",
+    "@ai-matrx/records-ui": "latest"
   },
   "peerDependencies": {
     "react": ">=19.0.0",
@@ -204,5 +204,5 @@
     "verify:modules-tarball": "node ./scripts/verify-modules-tarball.mjs",
     "verify:tarball": "node ./scripts/verify-tarball.mjs"
   },
-  "gitHead": "f454ad2b6bb89fd398ef3fb05603ded30ca95dc0"
+  "gitHead": "aeb33c88d654862267985a12ae7e1880d216bda8"
 }