@ai-matrx/rich-content 0.2.162 → 0.2.164

package/CHANGELOG.md

@@ -1,5 +1,20 @@
 # Changelog
 
+## 0.2.164
+
+UNVERIFIED: this release has no Unreleased entry and the source comparison could not be made (the caller supplied no source comparison). Whether source changed is unknown; consumer action is unknown.
+Check the package's gitHead on npm against this version's gitHead: `git diff <previous gitHead> <this gitHead> -- apps/shared/rich-content/src`.
+
+## 0.2.163
+
+SOURCE CHANGED WITH NO RELEASE NOTE. This release shipped source changes that nobody described in an Unreleased entry,
+so they may include breaking API changes. Consumer action is UNKNOWN: read the diff before upgrading.
+Diff: `git diff 3260b81ccf bd8cc634ac -- apps/shared/rich-content/src`
+
+Changed shipped source files (2):
+- `apps/shared/rich-content/src/display/chat-markdown/block-registry/BlockRenderer.tsx`
+- `apps/shared/rich-content/src/display/chat-markdown/block-registry/render-ratchet.ts`
+
 ## 0.2.162
 ### Unreleased
 

package/dist/display/chat-markdown/block-registry/BlockRenderer.d.ts

@@ -82,6 +82,12 @@ export interface BlockRenderDecision {
     /** The routed block — what the dispatch registry receives. */
     block: RenderBlock;
     gate: BlockRenderGate;
+    /**
+     * CERTAIN evidence this block is not a kind: a JSON code region whose first key
+     * arrived complete and is not `__kind` (the first-key rule). The render ratchet
+     * releases a held loader on it at once; a transient frame never sets it.
+     */
+    notKind?: boolean;
 }
 /**
  * THE DECISION BlockRenderer makes, as a pure function (V5): terminal

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

@@ -1,7 +1,7 @@
 "use client";
 import { jsx, jsxs } from "react/jsx-runtime";
 import { durableRecordId } from "@ai-matrx/kit/ids";
-import React, { useCallback, useRef } from "react";
+import React, { useCallback, useState } from "react";
 import { RichContentHostGate } from "../../../host/RichContentHostGate.js";
 import { BlockComponents, LoadingComponents } from "./BlockComponentRegistry.js";
 import { resolveArtifactDef } from "../../../host/app-bindings.js";
@@ -53,7 +53,12 @@ import {
   KindRecordChrome,
   kindHasRecordChrome
 } from "../../../host/app-bindings.js";
-import { advanceRatchet, EMPTY_RATCHET } from "./render-ratchet.js";
+import {
+  advanceRatchet,
+  EMPTY_RATCHET,
+  ratchetClock,
+  sameRatchetState
+} from "./render-ratchet.js";
 import {
   isBlockLoading,
   resolveBlockDispatch,
@@ -251,7 +256,13 @@ function decideBlockRender(inputBlock, {
       }
     }
   }
-  return decided(null);
+  return isCertainlyNotKind(block) ? { ...decided(null), notKind: true } : decided(null);
+}
+function isCertainlyNotKind(block) {
+  if (block.type !== "code") return false;
+  const text = typeof block.content === "string" ? block.content : "";
+  if (!/^\s*[[{]/.test(withoutLeadingJsonComments(text))) return false;
+  return jsonKindSignal(text, { json5: isJson5Language(block.language) }) === "not_kind";
 }
 const PendingStructuredBlock = ({
   envelope
@@ -298,14 +309,53 @@ const BlockRendererGated = ({
     suppressLoadingGate,
     route: (b) => routeBlockAtRegistryVersion(b, kindRouteVersion)
   });
-  const ratchetRef = useRef(EMPTY_RATCHET);
+  const [ratchetState, setRatchetState] = useState(EMPTY_RATCHET);
   const settledBlock = !isStreamActive || inputBlock.isStreamingBlock === false;
-  const ratcheted = suppressLoadingGate ? { state: ratchetRef.current, decision: frameDecision } : advanceRatchet(ratchetRef.current, frameDecision, {
+  const ratcheted = suppressLoadingGate ? { state: ratchetState, decision: frameDecision } : advanceRatchet(ratchetState, frameDecision, {
     settled: settledBlock,
-    now: Date.now()
+    messageEnded: !isStreamActive,
+    now: ratchetClock()
   });
-  ratchetRef.current = ratcheted.state;
-  const decision = ratcheted.decision;
+  if (!sameRatchetState(ratcheted.state, ratchetState)) setRatchetState(ratcheted.state);
+  return /* @__PURE__ */ jsx(
+    BlockRendererDrawn,
+    {
+      requestId,
+      index,
+      isStreamActive,
+      onContentChange,
+      conversationId,
+      messageId,
+      taskId,
+      isLastReasoningBlock,
+      replaceBlockContent,
+      handleOpenEditor,
+      suppressLoadingGate,
+      outputSchema,
+      decision: ratcheted.decision,
+      envelopeKind,
+      durableMessageId
+    },
+    ratcheted.state.generation
+  );
+};
+const BlockRendererDrawn = ({
+  requestId,
+  index,
+  isStreamActive,
+  onContentChange,
+  conversationId,
+  messageId,
+  taskId,
+  isLastReasoningBlock,
+  replaceBlockContent,
+  handleOpenEditor,
+  suppressLoadingGate = false,
+  outputSchema = null,
+  decision,
+  envelopeKind,
+  durableMessageId
+}) => {
   const block = decision.block;
   const interruptedEnvelope = readEnvelope(block.metadata);
   const hasInterruptedKind = Boolean(

package/dist/display/chat-markdown/block-registry/render-ratchet.d.ts

@@ -24,6 +24,8 @@
  *     the final decision is the truth, whatever stage it is;
  *   - the content stopped CONTINUING the held block (the slot now holds a different block):
  *     the ratchet starts over for the new one;
+ *   - the frame carries CERTAIN evidence the held loader was wrong: the region's first key
+ *     arrived complete and is not `__kind` (`decision.notKind`) — loader → text at once;
  *   - mid-stream, the frames have disagreed for at least RATCHET_RELEASE_MIN_FRAMES distinct
  *     content updates AND RATCHET_RELEASE_MIN_MS of wall time, both — a region that really
  *     turned into something else keeps saying so, a transient hiccup never lasts that long.
@@ -59,18 +61,41 @@ export interface RatchetState {
     /** Consecutive distinct frames that wanted to go backward, and since when. */
     disagreeFrames: number;
     disagreeSince: number | null;
+    /**
+     * Which logical block this slot holds. Bumped when a DIFFERENT block takes the slot
+     * mid-stream (the content stopped continuing the held one): the renderer keys its
+     * subtree on it, so a new block never inherits the previous block's component state.
+     */
+    generation: number;
 }
 export declare const EMPTY_RATCHET: RatchetState;
 export interface RatchetInput {
     /** The block settled: its own stream closed, or the message stream ended. */
     settled: boolean;
+    /**
+     * The MESSAGE stream is over. An emptied block while the message still streams is a
+     * retraction or a re-split, never a final value — even when its frame says "complete".
+     */
+    messageEnded?: boolean;
     /** Wall clock (ms). */
     now: number;
 }
 /**
  * One frame through the ratchet: the state to keep and the decision to draw.
  */
-export declare function advanceRatchet(state: RatchetState, next: BlockRenderDecision, { settled, now }: RatchetInput): {
+export declare function advanceRatchet(state: RatchetState, next: BlockRenderDecision, { settled, now, messageEnded }: RatchetInput): {
     state: RatchetState;
     decision: BlockRenderDecision;
 };
+/**
+ * Two states that draw the same thing and will judge the next frame the same way. The
+ * renderer keeps the state in React state and stores a new one only when this is false,
+ * so re-rendering the same frame converges instead of looping.
+ */
+export declare function sameRatchetState(a: RatchetState, b: RatchetState): boolean;
+/**
+ * The ratchet's wall clock. Only the mid-stream release reads it (a backward verdict must
+ * persist RATCHET_RELEASE_MIN_MS); a re-render of the same frame never counts a frame, so
+ * reading it during render cannot change what is drawn.
+ */
+export declare function ratchetClock(): number;

package/dist/display/chat-markdown/block-registry/render-ratchet.js

@@ -18,7 +18,8 @@ const EMPTY_RATCHET = {
   heldContent: "",
   lastContent: "",
   disagreeFrames: 0,
-  disagreeSince: null
+  disagreeSince: null,
+  generation: 0
 };
 function contentOf(decision) {
   const content = decision.rawBlock.content;
@@ -29,8 +30,9 @@ function continues(heldContent, next) {
   if (!prefix) return true;
   return next.startsWith(prefix) || prefix.startsWith(next.slice(0, CONTINUATION_PREFIX).trimEnd());
 }
-function accept(next, stage, content) {
+function accept(next, stage, content, generation) {
   return {
+    generation,
     held: next,
     heldStage: stage,
     heldContent: content,
@@ -39,19 +41,20 @@ function accept(next, stage, content) {
     disagreeSince: null
   };
 }
-function advanceRatchet(state, next, { settled, now }) {
+function advanceRatchet(state, next, { settled, now, messageEnded = false }) {
   const stage = renderStageOf(next);
   const content = contentOf(next);
-  const take = () => {
-    const accepted = accept(next, stage, content);
+  const take = (generation = state.generation) => {
+    const accepted = accept(next, stage, content, generation);
     return { state: accepted, decision: next };
   };
-  if (!state.held || settled) return take();
-  if (!content.trim() && state.heldContent.trim()) {
+  if (state.held && !messageEnded && !content.trim() && state.heldContent.trim()) {
     return { state: { ...state, lastContent: content }, decision: state.held };
   }
-  if (!continues(state.heldContent, content)) return take();
+  if (!state.held || settled) return take();
+  if (!continues(state.heldContent, content)) return take(state.generation + 1);
   if (stage >= state.heldStage) return take();
+  if (state.heldStage === 1 && stage === 0 && next.notKind === true) return take();
   const isNewFrame = content !== state.lastContent;
   const disagreeFrames = state.disagreeFrames + (isNewFrame ? 1 : 0);
   const disagreeSince = state.disagreeSince ?? now;
@@ -63,11 +66,19 @@ function advanceRatchet(state, next, { settled, now }) {
     decision: state.held
   };
 }
+function sameRatchetState(a, b) {
+  return a.heldStage === b.heldStage && a.heldContent === b.heldContent && a.lastContent === b.lastContent && a.disagreeFrames === b.disagreeFrames && a.disagreeSince === b.disagreeSince && a.generation === b.generation && a.held === null === (b.held === null);
+}
+function ratchetClock() {
+  return Date.now();
+}
 export {
   EMPTY_RATCHET,
   RATCHET_RELEASE_MIN_FRAMES,
   RATCHET_RELEASE_MIN_MS,
   RENDER_STAGE_NAMES,
   advanceRatchet,
-  renderStageOf
+  ratchetClock,
+  renderStageOf,
+  sameRatchetState
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ai-matrx/rich-content",
-  "version": "0.2.162",
+  "version": "0.2.164",
   "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",
@@ -130,6 +130,7 @@
     "unist-util-visit": "^5.1.0",
     "unist-util-visit-parents": "^6.0.2",
     "yaml": "^2.9.1",
+    "@ai-matrx/agents": "latest",
     "@ai-matrx/alchemy": "latest",
     "@ai-matrx/api": "latest",
     "@ai-matrx/canvas": "latest",
@@ -138,13 +139,12 @@
     "@ai-matrx/data": "latest",
     "@ai-matrx/design-system": "latest",
     "@ai-matrx/icons": "latest",
-    "@ai-matrx/agents": "latest",
+    "@ai-matrx/kit": "latest",
     "@ai-matrx/media": "latest",
     "@ai-matrx/print": "latest",
+    "@ai-matrx/diff": "latest",
     "@ai-matrx/records": "latest",
-    "@ai-matrx/records-ui": "latest",
-    "@ai-matrx/kit": "latest",
-    "@ai-matrx/diff": "latest"
+    "@ai-matrx/records-ui": "latest"
   },
   "peerDependencies": {
     "react": ">=19.0.0",
@@ -205,5 +205,5 @@
     "verify:modules-tarball": "node ./scripts/verify-modules-tarball.mjs",
     "verify:tarball": "node ./scripts/verify-tarball.mjs"
   },
-  "gitHead": "3260b81ccf1721d1a6a0ba08b238fdfa7d609ba5"
+  "gitHead": "1b4c21ab92d61a09b5d50abcdb456e52984b2b02"
 }