@ai-matrx/chat 0.7.5 → 0.7.6

package/dist/agents/redux/execution-system/utils/stream-block-accumulator.js

@@ -1,1572 +1,208 @@
-import { parseDecisionOptionsFromBody } from "@ai-matrx/rich-content/utils/decision-options";
-import { QuotedKindLift } from "@ai-matrx/content-ir/surfaces";
-import { canonicalizeCompletedLegacyQuizEnvelope } from "@ai-matrx/content-ir/surfaces";
-import { envelopeMatchesParsedSource } from "@ai-matrx/content-ir/surfaces";
-import { MarkdownEscapedKindJson } from "@ai-matrx/content-ir/surfaces";
-import { KindImageAltUnwrap } from "@ai-matrx/content-ir/surfaces";
-import { FENCE_META_KEY, splitFenceInfo } from "@ai-matrx/content-ir/source";
-import {
-  hasUnclosedBacktickRun,
-  indexOutsideInlineCode
-} from "@ai-matrx/content-ir/source";
-import {
-  hasKindKey,
-  isJsonFenceLanguage,
-  jsonKindSignal,
-  kindGrammar,
-  kindObjectProseBreak,
-  bareRegionBreaksIntoProse
-} from "@ai-matrx/content-ir/surfaces";
-import {
-  findBalancedXmlClose,
-  initialXmlBalance
-} from "@ai-matrx/content-ir/source";
-import {
-  classifyInnerFenceLine,
-  fenceNestsInnerFences,
-  fenceOpenerOf,
-  FenceReader,
-  findCodeRanges,
-  isHtmlBlockTagName,
-  trimFenceLine
-} from "@ai-matrx/content-ir/source";
-import {
-  DIRECTIVE_CONTAINER_OPEN,
-  DirectiveContainerTracker
-} from "@ai-matrx/content-ir/source";
-import { TITLED_IMAGE_LINE } from "@ai-matrx/content-ir/source";
-import { continuesTable, lineIndent, startsPipelessTable } from "@ai-matrx/content-ir/source";
+import { BlockSplitter } from "@ai-matrx/rich-content/display/markdown-classification/processors/utils/block-splitter";
 import {
-  classifyLine,
-  isPlainText,
-  hasCandidate,
-  Candidate
-} from "./content-prefilter.js";
-import {
-  detectJsonBlockType,
-  parseXmlAttributes,
-  extractAudioLink,
-  detectImageMarkdown,
-  countInlineImages,
-  detectVideoMarkdown,
-  detectMatrxFileMarkdown,
-  isCompleteUnrecognizedXmlContainer,
-  isUnclosedGenericXmlOpening,
-  startUnrecognizedXmlContainer,
-  normalizeCodeLanguage,
-  SPECIAL_CODE_LANGUAGES
+  clientSplitterEnvelopes,
+  wrapperSourceOf
 } from "@ai-matrx/rich-content/display/markdown-classification/processors/utils/content-splitter-v2";
+import { FENCE_META_KEY } from "@ai-matrx/content-ir/source";
+import { canonicalizeCompletedLegacyQuizEnvelope } from "@ai-matrx/content-ir/surfaces";
 import { kindRegistry } from "@ai-matrx/rich-content/host/kind-registry";
 import { componentRegistry } from "@ai-matrx/rich-content/host/component-registry";
-import { hostSplitterEnvelopes } from "@ai-matrx/rich-content/host/splitter-envelopes";
-import { withIrEnvelope } from "@ai-matrx/rich-content/kinds/registry/region-envelope-memo";
 import { sessionEnvelope } from "@ai-matrx/rich-content/kinds/registry/kind-correctors";
 import { disposeParseSession, openParseSession } from "@ai-matrx/content-ir";
-import {
-  IR_ENVELOPE_KEY
-} from "@ai-matrx/content-ir";
-import {
-  normalizeRecoveredContainerPiece,
-  splitAroundEmbeddedKindJson
-} from "@ai-matrx/content-ir/surfaces";
+import { IR_ENVELOPE_KEY } from "@ai-matrx/content-ir";
 import { captureError } from "../../../../host/diagnostics.js";
-const isSpecialCodeLanguage = (language) => SPECIAL_CODE_LANGUAGES.includes(language);
-const envelopeForCompletedXmlRegion = (tag, regionText) => hostSplitterEnvelopes()?.xmlRegion(tag, regionText) ?? null;
-const envelopeForCompletedFenceRegion = (language, regionText) => hostSplitterEnvelopes()?.fenceRegion(language, regionText) ?? null;
-function countStructuralObjectBraces(source) {
-  let opens = 0;
-  let closes = 0;
-  let inString = false;
-  let escaped = false;
-  for (const char of source) {
-    if (inString) {
-      if (escaped) escaped = false;
-      else if (char === "\\") escaped = true;
-      else if (char === '"') inString = false;
-      continue;
-    }
-    if (char === '"') inString = true;
-    else if (char === "{") opens++;
-    else if (char === "}") closes++;
-  }
-  return { opens, closes };
-}
-function firstCompleteRootObjectEnd(source, initialDepth = 0) {
-  let depth = initialDepth;
-  let sawRoot = initialDepth > 0;
-  let inString = false;
-  let escaped = false;
-  for (let index = 0; index < source.length; index++) {
-    const char = source[index];
-    if (inString) {
-      if (escaped) escaped = false;
-      else if (char === "\\") escaped = true;
-      else if (char === '"') inString = false;
-      continue;
-    }
-    if (char === '"') {
-      inString = true;
-    } else if (char === "{") {
-      depth++;
-      sawRoot = true;
-    } else if (char === "}") {
-      depth--;
-      if (sawRoot && depth === 0) return index + 1;
-    }
-  }
-  return null;
-}
-const ORPHAN_REASONING_CLOSE = /<\/(thinking|think|reasoning)\s*>/i;
-const ORPHAN_REASONING_CLOSE_GLOBAL = /<\/(thinking|think|reasoning)\s*>/gi;
-const REASONING_OPEN_TAG = /<(thinking|think|reasoning)(\s[^>]*)?>/i;
+const LATER_PARTIAL_KIND_KEY = /,\s*"(?:_(?:_(?:k(?:i(?:n(?:d)?)?)?)?)?)?$/;
 const REASONING_BLOCK_TYPES = /* @__PURE__ */ new Set(["thinking", "reasoning"]);
-const SIMPLE_XML_TAGS = /* @__PURE__ */ new Set([
-  "thinking",
-  "think",
-  "reasoning",
-  "info",
-  "task",
-  "database",
-  "private",
-  "plan",
-  "event",
-  "tool",
-  "questionnaire",
-  "flashcards",
-  "cooking_recipe",
-  "timeline",
-  "progress_tracker",
-  "troubleshooting",
-  "resources",
-  "research"
-]);
-const ATTR_XML_TAGS = /* @__PURE__ */ new Set([
-  "decision",
-  "artifact",
-  // Editor pills — round-trip representation of code-editor errors and selected
-  // code snippets. Attributes carry file/line/severity/language; the body
-  // carries `<message>`+`<surrounding_code>` for errors, raw code for snippets.
-  // Must mirror ATTRIBUTE_XML_BLOCKS in content-splitter-v2.ts.
-  "editor_error",
-  "editor_code_snippet"
-]);
-function isParseableJsonObject(text) {
+const MEDIA_BLOCK_TYPES = /* @__PURE__ */ new Set(["image", "video", "audio"]);
+const FRONT_MATTER_OPEN = /^(?:)?(---|\+\+\+)[ \t]*\r?\n/;
+function isWholeJson(source) {
+  const text = source.trim();
+  if (!text.endsWith("}")) return false;
   try {
-    const parsed = JSON.parse(text);
-    return parsed !== null && typeof parsed === "object";
+    JSON.parse(text);
+    return true;
   } catch {
     return false;
   }
 }
-function endsInsideXmlLiteral(source) {
-  const lastComment = source.lastIndexOf("<!--");
-  if (lastComment !== -1 && source.indexOf("-->", lastComment + 4) === -1) return true;
-  const lastCdata = source.lastIndexOf("<![CDATA[");
-  if (lastCdata !== -1 && source.indexOf("]]>", lastCdata + 9) === -1) return true;
-  const last = findCodeRanges(source).at(-1);
-  if (!last || last.kind !== "fence") return false;
-  const closer = /\n[ \t]*(`{3,}|~{3,})[ \t]*$/.test(source.slice(last.start, last.end));
-  return last.end >= source.length && !closer;
-}
-function genericCandidateBody(candidate) {
-  return (candidate.fence ? candidate.lines.slice(1) : candidate.lines).join("\n");
-}
-function isFenceCloserLine(line, fence) {
-  const trimmed = trimFenceLine(line);
-  return trimmed.length >= fence.ticks && [...trimmed].every((ch) => ch === fence.char);
-}
-const BARE_JSON_OPEN_RE = /^\{\s*"[^"]*"\s*:/;
-const regionBreaksIntoProse = bareRegionBreaksIntoProse;
-const LITERAL_KIND_KEY_AT = /(?<!\\)"(?:__kind|\\u005[fF]_kind)"\s*:/;
-function ownsKindKey(line, at) {
-  const key = line.slice(at).search(LITERAL_KIND_KEY_AT);
-  if (key < 0) return true;
-  const keyAt = at + key;
-  const verdict = kindGrammar(line, "json", at);
-  if (verdict.status === "prefix") return true;
-  if (verdict.status === "complete") return verdict.end > keyAt;
-  return verdict.at > keyAt;
-}
-function proseKindObjectStart(line) {
-  if (!hasKindKey(line)) return -1;
-  for (let at = indexOutsideInlineCode(line, "{", 1); at > 0; at = indexOutsideInlineCode(line, "{", at + 1)) {
-    const rest = line.slice(at);
-    if (BARE_JSON_OPEN_RE.test(rest) && hasKindKey(rest) && ownsKindKey(line, at)) {
-      return line.slice(0, at).trim() ? at : -1;
-    }
-  }
-  return -1;
-}
-const HTML_PHRASING_TAGS = /* @__PURE__ */ new Set([
-  "a",
-  "abbr",
-  "b",
-  "bdi",
-  "bdo",
-  "big",
-  "br",
-  "cite",
-  "code",
-  "data",
-  "del",
-  "dfn",
-  "em",
-  "font",
-  "i",
-  "img",
-  "ins",
-  "kbd",
-  "mark",
-  "q",
-  "s",
-  "samp",
-  "small",
-  "span",
-  "strike",
-  "strong",
-  "sub",
-  "sup",
-  "time",
-  "tt",
-  "u",
-  "var",
-  "wbr"
-]);
-function startsStructuralLine(line) {
-  if (/^\s*(?:\{|\[\s*\{|\||`{3,}|~{3,}|:::)/.test(line)) return true;
-  if (/^\s*<!--/.test(line)) return false;
-  const tag = /^\s*<\/?([A-Za-z][\w-]*)/.exec(line);
-  if (!tag) return /^\s*</.test(line);
-  const name = tag[1].toLowerCase();
-  return !isHtmlBlockTagName(name) && !HTML_PHRASING_TAGS.has(name);
-}
-function extractFenceInfo(trimmed) {
-  const char = trimmed[0];
-  if (char !== "`" && char !== "~") return null;
-  let ticks = 0;
-  while (ticks < trimmed.length && trimmed[ticks] === char) ticks++;
-  if (ticks < 3) return null;
-  const { language, meta } = splitFenceInfo(trimmed.slice(ticks));
-  return { language: language ?? "", meta, ticks, char };
-}
-function extractOpeningXmlTag(trimmed) {
-  if (trimmed[0] !== "<") return null;
-  let i = 1;
-  while (i < trimmed.length) {
-    const c = trimmed.charCodeAt(i);
-    if (c >= 97 && c <= 122 || c >= 65 && c <= 90 || c >= 48 && c <= 57 || c === 95) {
-      i++;
-    } else {
-      break;
-    }
-  }
-  if (i === 1) return null;
-  const tag = trimmed.substring(1, i).toLowerCase();
-  if (SIMPLE_XML_TAGS.has(tag) || ATTR_XML_TAGS.has(tag)) return tag;
+function jsonRegionSource(block) {
+  if (block.type === "matrx" || block.type === "matrx_file") return null;
+  const body = block.content.trimStart();
+  if (!body.startsWith("{")) return null;
+  const language = (block.language ?? "").toLowerCase();
+  if (block.type === "code" && (language === "json" || language === "")) return block.content;
+  if (block.type === "artifact") return block.content.replace(/\n?[ \t]*<\/?[a-z]*$/i, (tail) => "</artifact>".startsWith(tail.trim().toLowerCase()) ? "" : tail);
   return null;
 }
-function mapXmlTagToBlockType(tag) {
-  if (tag === "think") return "thinking";
-  return tag;
-}
-function extractOpeningTagText(trimmed, tag) {
-  const close = trimmed.indexOf(">");
-  if (close === -1) return `<${tag}>`;
-  return trimmed.slice(0, close + 1);
-}
-function findMidLineAttrXml(rawLine) {
-  for (const tag of ATTR_XML_TAGS) {
-    const prefix = `<${tag}`;
-    const idx = indexOutsideInlineCode(rawLine, prefix);
-    if (idx === -1) continue;
-    if (rawLine.trimStart().startsWith(prefix)) continue;
-    const after = rawLine[idx + prefix.length];
-    if (after !== " " && after !== ">") continue;
-    const close = rawLine.indexOf(">", idx);
-    if (close === -1) continue;
-    const openingTagText = rawLine.slice(idx, close + 1);
-    return {
-      tagStart: idx,
-      tag,
-      openingTagText,
-      attributes: parseXmlAttributes(openingTagText)
-    };
-  }
-  return null;
-}
-function parseDecisionOptions(blockSourceText, decisionId) {
-  const options = parseDecisionOptionsFromBody(blockSourceText).map(
-    (o) => ({ id: o.id, label: o.label, text: o.text })
-  );
-  return options;
-}
 class StreamBlockAccumulator {
   requestId;
-  currentBlockIndex = 0;
-  currentBlockType = "text";
-  currentBlockContent = "";
-  /**
-   * Number of lines appended to the current block. Used to preserve LEADING
-   * blank lines: the first appended line is written verbatim (even if it's an
-   * empty string), and every subsequent line is joined with "\n". Without this
-   * counter, appending "" to an empty `currentBlockContent` was a no-op, which
-   * silently swallowed a block's first blank line and produced a 1-byte drift
-   * vs the V2 splitter / Python server (which keep that blank line).
-   */
-  currentBlockLineCount = 0;
-  pendingLineFragment = "";
-  /**
-   * True once the block at the current index has been dispatched to Redux —
-   * including speculative streaming projections of `pendingLineFragment`
-   * (see `emitCurrentBlock`). Reset whenever a new block is opened. Used by
-   * `closeCurrentBlock` to retract a speculative block whose line turned out
-   * to be a different typed block (see the bare-JSON duplication note there).
-   */
-  currentBlockEmitted = false;
-  /**
-   * THE DATA KEEPS ITS KINDS. A JSON wrapper that holds kinds is drawn as its
-   * kinds plus a residual (A7) — the residual is the wrapper's data WITH ITS
-   * KINDS REMOVED, so it is a display projection, never the answer. Every
-   * such split remembers the bytes it was cut from, keyed by its first block
-   * index, so data capture (`deriveAnswerDataText`) reads what the model wrote.
-   * Live only; a rewind forgets every split at or past its boundary.
-   */
-  wrapperSplits = /* @__PURE__ */ new Map();
-  subState = { kind: "none" };
-  /**
-   * URL + label for the current `audio` block. The accumulator's single-line
-   * media blocks (image/video) leave `data` null, which is why the legacy
-   * client image/video markdown path never populated `src`. Audio MUST carry
-   * its URL on `data.src` or BlockRenderer's `audio` case renders nothing —
-   * so we stash the extracted link here and emit it via buildBlockData.
-   */
-  pendingMediaData = null;
-  ingestCount = 0;
-  emitCount = 0;
-  // ── content-ir delegation (ALWAYS ON — no env flag, per repo rule) ────────
-  /** Live kind-parser session for the OPEN JSON region (fence or bare). */
-  irSession = null;
-  /** Lines fed to the session for this region (drives the "\n" separators). */
-  irRegionLineCount = 0;
-  /** How many chars of the current pendingLineFragment were already fed. */
-  irFedFragmentLen = 0;
-  /** Final envelope of the region being closed — consumed by the complete emit. */
-  irEnvelope = null;
-  /**
-   * True only between seeing a LITERAL closing fence line and the block's
-   * emit (set in the code_fence close branch). Stream-death finalize never
-   * sets it, so the fence-surface convergence hook fires exclusively on
-   * genuinely completed fence regions.
-   */
-  fenceClosedCleanly = false;
-  /**
-   * True once a simple-XML region's LITERAL closing tag has been seen — the twin
-   * of `fenceClosedCleanly`. Never set by stream-death `finalize()`, so a
-   * truncated region keeps today's legacy rendering (no envelope).
-   *
-   * MUST NOT be re-derived by scanning `currentBlockContent` for the closing
-   * tag: the accumulator STRIPS the literal tag text out of a simple-XML
-   * block's content (so `</reasoning>` can't leak into visible chat), which
-   * silently killed the XML keystone once already. The state machine already
-   * knows when the region closed; ask it, don't re-parse its output.
-   */
-  xmlClosedCleanly = false;
-  /**
-   * True while the OPEN ir region is the JSON BODY of an attribute-XML block
-   * (`<artifact …>{"__kind":…}</artifact>`) rather than a block that IS the
-   * JSON region. Two consequences, both required:
-   *
-   *  - the parity check is skipped — it compares the envelope against
-   *    `JSON.parse(currentBlockContent)`, and an attr-XML block's content is
-   *    the tag chrome PLUS the body, which never parses as JSON. Without this
-   *    every wrapped payload would fire a false "stream parity" alarm.
-   *  - the fragment feed stays off the closing-tag line (see `ingest`).
-   */
-  irRegionIsXmlBody = false;
-  /** Every session identity opened during this stream (disposed at finalize). */
-  irIdentities = [];
-  /**
-   * True only for the closeCurrentBlock call that closes the FIRST HALF of a
-   * region split by a tool boundary (breakTextBlock keeps the region open in
-   * a fresh block). Metadata built during that close must not report
-   * `isComplete: true` — the region genuinely continues.
-   */
-  regionContinuesAfterClose = false;
   upsertAction;
-  /** Same-line remainders are queued, never recursively reclassified. */
-  lineQueue = [];
-  /**
-   * The current line held a kind object that broke into prose
-   * (`{"__kind":"note","title":"Hi" and then…`, L-4 round 9): it is prose to
-   * its end — no opener re-reads it as JSON — and the prose leaf reads the
-   * broken object as its one-line label, exactly as a reload does.
-   */
-  kindLineIsProse = false;
-  isProcessingLineQueue = false;
-  /** Incomplete generic XML must never promote embedded JSON on finalize. */
-  genericXmlRecoverySuppressed = false;
-  /**
-   * The unused text slot opened after a clean container close is omitted.
-   *
-   * A completed bare JSON root opens a fresh text slot so subsequent source
-   * can continue in document order. If the stream ends there, emitting that
-   * slot creates a second, empty terminal block after the actual answer.
-   */
-  suppressEmptyTrailingSlot = false;
-  /** Lifts JSON regions out of blockquotes before the line machine (V1). */
-  quoteLift = new QuotedKindLift();
-  /** Un-escapes a markdown-escaped kind (`"\_\_kind"`) before the quote lift (P8). */
-  kindUnescape = new MarkdownEscapedKindJson();
-  /** Drops the `![`…`](url)` wrapper of a kind written as image alt text (P9). */
-  imageAlt = new KindImageAltUnwrap();
+  envelopes = clientSplitterEnvelopes();
+  splitter = new BlockSplitter({ envelopes: this.envelopes });
+  /** Absolute index of the current text run's first block (tool boundaries start a new run). */
+  base = 0;
+  /** How many blocks the current run has drawn (retraction bookkeeping). */
+  drawn = 0;
+  /** Last dispatched signature per absolute block index. */
+  signatures = /* @__PURE__ */ new Map();
+  region = null;
+  /** Final envelope of a region closed at a run's end (stream death or tool boundary). */
+  closedEnvelopes = /* @__PURE__ */ new Map();
+  identities = [];
+  unclosedReasoningReported = false;
+  orphanReasoningCloseReported = false;
+  /** A7: the bytes each JSON-wrapper split was cut from, keyed by its first block index. */
+  wrapperSplits = /* @__PURE__ */ new Map();
   constructor(requestId, upsertAction) {
     this.requestId = requestId;
     this.upsertAction = upsertAction;
   }
   // ── Public API ──────────────────────────────────────────────────────────
-  /**
-   * Ingest a text delta (the rAF-batched textBuffer content).
-   * Processes only complete lines; the trailing fragment is held until the
-   * next call or finalize().
-   */
+  /** Ingest a text delta (the rAF-batched textBuffer content). */
   ingest(delta, dispatch) {
-    this.ingestCount++;
-    this.ingestText(
-      this.quoteLift.push(this.imageAlt.push(this.kindUnescape.push(delta))),
-      dispatch
-    );
-  }
-  /** Release what the quote lift still holds (stream end or a hard boundary). */
-  flushQuoteLift(dispatch) {
-    const unescaped = this.imageAlt.push(this.kindUnescape.flush()) + this.imageAlt.flush();
-    const held = (unescaped ? this.quoteLift.push(unescaped) : "") + this.quoteLift.flush();
-    if (held) this.ingestText(held, dispatch);
+    if (!delta) return;
+    this.splitter.append(delta);
+    this.sync(dispatch, false);
   }
-  ingestText(text, dispatch) {
-    const combined = this.pendingLineFragment + text;
-    const parts = combined.split("\n");
-    this.pendingLineFragment = parts[parts.length - 1];
-    parts.length -= 1;
-    for (const rawLine of parts) {
-      this.processLine(rawLine, dispatch);
-    }
-    if (this.subState.kind === "xml_tag" && !this.subState.isAttrXml) {
-      const closeIdx = this.pendingLineFragment.indexOf(
-        this.subState.closingTag
-      );
-      if (closeIdx !== -1) {
-        const upto = closeIdx + this.subState.closingTag.length;
-        const rest = this.pendingLineFragment.slice(upto);
-        if (rest.trimStart().length > 0) {
-          const tagLine = this.pendingLineFragment.slice(0, upto);
-          this.pendingLineFragment = rest;
-          this.processLine(tagLine, dispatch);
-        }
-      }
-    }
-    this.maybeSplitProseBeforeKindFragment(dispatch);
-    this.maybeEnterKindArrayFromFragment(dispatch);
-    this.maybeSplitKindFromXmlFragment(dispatch);
-    this.maybeSplitKindFromGenericXmlFragment(dispatch);
-    this.maybeOpenBareJsonFromFragment(dispatch);
-    while (this.subState.kind === "bare_json") {
-      const rootEnd = firstCompleteRootObjectEnd(
-        this.pendingLineFragment,
-        this.subState.openBraces - this.subState.closeBraces
-      );
-      if (rootEnd === null) break;
-      const remainder = this.pendingLineFragment.slice(rootEnd);
-      if (!remainder.trim()) break;
-      const completeRoot = this.pendingLineFragment.slice(0, rootEnd);
-      this.pendingLineFragment = remainder.trimStart();
-      this.processLine(completeRoot, dispatch);
-      this.maybeOpenBareJsonFromFragment(dispatch);
-    }
-    if (this.subState.kind === "bare_json" && (!this.currentBlockContent && kindObjectProseBreak(this.pendingLineFragment.trimStart()) !== null || regionBreaksIntoProse(
-      this.currentBlockContent ? `${this.currentBlockContent}
-${this.pendingLineFragment}` : this.pendingLineFragment
-    ))) {
-      this.demoteKindLineToProse();
-    }
-    if (!this.irSession) {
-      this.maybeOpenXmlBodyIrRegion(this.pendingLineFragment, false);
-    }
-    if (this.irSession && (this.subState.kind === "bare_json" || this.subState.kind === "code_fence" && !/^[`~]/.test(this.pendingLineFragment.trimStart()) || this.irRegionIsXmlBody && this.subState.kind === "xml_tag" && !this.pendingLineFragment.trimStart().startsWith("<")) && this.pendingLineFragment.length > this.irFedFragmentLen) {
-      this.irWriteLinePart(
-        this.pendingLineFragment.slice(this.irFedFragmentLen),
-        false
-      );
-    }
-    this.emitCurrentBlock(dispatch, "streaming");
-  }
-  /**
-   * Flush remaining content and mark the final block as complete.
-   * Called once after the stream loop ends.
-   */
+  /** The stream ended: every block becomes complete. Called once after the stream loop. */
   finalize(dispatch) {
-    this.flushQuoteLift(dispatch);
-    if (this.pendingLineFragment) {
-      this.processLine(this.pendingLineFragment, dispatch);
-      this.pendingLineFragment = "";
-    }
-    this.releaseHeldArray(dispatch);
-    if (this.subState.kind === "xml_tag" && !this.subState.isAttrXml && REASONING_BLOCK_TYPES.has(mapXmlTagToBlockType(this.subState.tagName))) {
-      this.reportUnclosedReasoningRegion(this.subState.tagName);
-    }
-    if (this.subState.kind === "bare_json") {
-      const jsonType = detectJsonBlockType(this.currentBlockContent);
-      if (jsonType) {
-        this.currentBlockType = jsonType;
-      }
-    }
-    if (this.irSession) {
-      this.irCloseRegion();
-    }
-    if (!this.emitRecoveredEmbeddedKindBlocks(dispatch)) {
-      this.emitCurrentBlock(dispatch, "complete");
-    }
-    this.irEnvelope = null;
-    this.irRegionIsXmlBody = false;
-    this.irDisposeAll();
+    this.endRun(dispatch);
+    this.disposeAll();
   }
   /**
-   * Forget every in-flight parser/block byte at and after a durable content
-   * boundary. Redux owns removal of the already-dispatched suffix; this resets
-   * the local streaming state so the replacement provider attempt cannot
-   * concatenate onto or resurrect the failed attempt.
+   * The source bytes behind every live A7 wrapper split. The splitter's reading of the stored
+   * text is the reading every surface draws, so no live block stands for bytes it does not hold.
    */
-  /** The source bytes behind every live A7 wrapper split (see `wrapperSplits`). */
   getWrapperSplitSources() {
     return [...this.wrapperSplits.values()].map((split) => ({
       blockIds: split.indices.map((i) => `client_block_${i}`),
       source: split.source
     }));
   }
+  /**
+   * Forget every in-flight byte at and after a durable content boundary (a provider retry).
+   * Redux owns removal of the already-dispatched suffix; the replacement attempt starts a fresh
+   * run at `blockCount`.
+   */
   rewindToBlockCount(blockCount) {
+    this.disposeAll();
+    this.splitter = new BlockSplitter({ envelopes: clientSplitterEnvelopes() });
+    this.base = Math.max(0, blockCount);
+    this.drawn = 0;
+    for (const index of [...this.signatures.keys()]) if (index >= this.base) this.signatures.delete(index);
+    for (const index of [...this.closedEnvelopes.keys()]) if (index >= this.base) this.closedEnvelopes.delete(index);
     for (const [start, split] of this.wrapperSplits) {
-      if (start >= blockCount || split.indices.some((i) => i >= blockCount)) {
-        this.wrapperSplits.delete(start);
-      }
+      if (start >= this.base || split.indices.some((i) => i >= this.base)) this.wrapperSplits.delete(start);
     }
-    this.irDisposeAll();
-    this.currentBlockIndex = Math.max(0, blockCount);
-    this.currentBlockType = "text";
-    this.currentBlockContent = "";
-    this.currentBlockLineCount = 0;
-    this.pendingLineFragment = "";
-    this.currentBlockEmitted = false;
-    this.subState = { kind: "none" };
-    this.pendingMediaData = null;
-    this.irSession = null;
-    this.irRegionLineCount = 0;
-    this.irFedFragmentLen = 0;
-    this.irEnvelope = null;
-    this.irRegionIsXmlBody = false;
-    this.fenceClosedCleanly = false;
-    this.xmlClosedCleanly = false;
-    this.regionContinuesAfterClose = false;
-    this.lineQueue = [];
-    this.isProcessingLineQueue = false;
-    this.genericXmlRecoverySuppressed = false;
-    this.suppressEmptyTrailingSlot = false;
-    this.quoteLift = new QuotedKindLift();
-    this.kindUnescape = new MarkdownEscapedKindJson();
-    this.imageAlt = new KindImageAltUnwrap();
   }
   /**
-   * Close the current text block at an interleaved-content boundary — a tool
-   * call that lands BETWEEN two text runs. The NEXT text run then opens a
-   * FRESH render block instead of appending onto the block that held the text
-   * BEFORE the tool.
-   *
-   * Why this exists: the accumulator lives for the whole stream and is never
-   * otherwise told about tool calls. Without this break, "text → tool → text"
-   * collapses both runs into a single `client_block_N`. The timeline still
-   * records a `text_end` for the second run, but its
-   * `[blockStartIndex, blockEndIndex)` range comes out EMPTY (no new blockId
-   * was pushed), so `selectUnifiedSlots` emits `[merged_text, tool]` — the
-   * tool card renders AFTER all the text, destroying chronological order.
-   * (The persisted/DB path is unaffected because it rebuilds each run's text
-   * from `text_end.rawText`, which is why a reload renders correctly.)
-   *
-   * Call this once per tool event, BEFORE the tool's `appendTimeline` dispatch
-   * and AFTER the pre-tool text has been flushed into the accumulator
-   * (process-stream's `dispatchBatch()` does that flush). It is a no-op when
-   * there is nothing open to break (back-to-back tool events, a tool with no
-   * preceding text, a tool right after a media block), so it is always safe.
+   * Close the current text run at an interleaved-content boundary (a tool call between two text
+   * runs): the next text opens fresh blocks after this run's, so "text → tool → text" keeps its
+   * chronological order. Reload splits each run's stored text on its own, and so does this.
+   * A no-op when nothing is open.
    */
   breakTextBlock(dispatch) {
-    this.flushQuoteLift(dispatch);
-    if (!this.currentBlockContent && !this.pendingLineFragment && !this.currentBlockEmitted) {
-      return;
-    }
-    if (this.pendingLineFragment) {
-      this.processLine(this.pendingLineFragment, dispatch);
-      this.pendingLineFragment = "";
-    }
-    this.releaseHeldArray(dispatch);
-    if (this.subState.kind === "bare_json") {
-      const jsonType = detectJsonBlockType(this.currentBlockContent);
-      if (jsonType) this.currentBlockType = jsonType;
-    }
-    const openRegion = this.subState.kind === "xml_tag" || this.subState.kind === "code_fence" || this.subState.kind === "generic_xml" ? this.subState : null;
-    const resumeBlockType = this.currentBlockType;
-    if (openRegion) this.regionContinuesAfterClose = true;
-    this.closeCurrentBlock(dispatch);
-    this.regionContinuesAfterClose = false;
-    if (openRegion) {
-      this.openBlock(
-        openRegion.kind === "xml_tag" ? mapXmlTagToBlockType(openRegion.tagName) : resumeBlockType,
-        dispatch
-      );
-      this.subState = { ...openRegion };
-    } else {
-      this.subState = { kind: "none" };
-      this.openBlock("text", dispatch);
-    }
-  }
-  // ── Reasoning-boundary honesty ──────────────────────────────────────────
-  //
-  // Both halves of an unbalanced provider wrapper are REPORTED, once per
-  // stream each, with the remedy. They are not recoverable here — only the
-  // provider knows where its thinking ended — so the one thing the client owes
-  // the reader is that the failure is never silent.
-  orphanReasoningCloseReported = false;
-  unclosedReasoningReported = false;
-  reportOrphanReasoningClose(tag, rawLine) {
-    if (this.orphanReasoningCloseReported) return;
-    this.orphanReasoningCloseReported = true;
-    captureError({
-      source: "reasoning-leak",
-      message: `A closing reasoning tag (${tag}) arrived with NO open reasoning region: the provider's <reasoning> wrapper is unbalanced, so this turn's chain-of-thought streamed to the reader as the answer. The tag itself was stripped from the visible content. Remedy: the wrapper is per-stream state in aidream providers/reasoning_stream_state.py \u2014 an unbalanced wrapper means a provider parser is sharing it across concurrent turns again.`,
-      requestId: this.requestId,
-      raw: { sample: rawLine.slice(0, 500) }
+    if (!this.splitter.text) return;
+    this.endRun(dispatch);
+    this.base += this.drawn;
+    this.drawn = 0;
+    this.splitter = new BlockSplitter({ envelopes: clientSplitterEnvelopes() });
+  }
+  // ── The driver ──────────────────────────────────────────────────────────
+  endRun(dispatch) {
+    if (!this.splitter.text) return;
+    const blocks = this.splitter.blocks();
+    const last = blocks[blocks.length - 1];
+    if (last && this.region && this.region.index === this.base + blocks.length - 1) {
+      this.feedRegion(last);
+      this.closeRegion();
+    }
+    this.sync(dispatch, true);
+    if (last && REASONING_BLOCK_TYPES.has(last.type) && last.metadata?.isComplete === false) {
+      this.reportUnclosedReasoningRegion(last.type, last.content);
+    }
+  }
+  sync(dispatch, final) {
+    const text = this.splitter.text;
+    if (!final && this.base === 0 && FRONT_MATTER_OPEN.test(text) && this.frontMatterStillOpen(text)) return;
+    let blocks = this.splitter.blocks();
+    if (!final && blocks.length > 0 && this.holdsNascentJson(blocks[blocks.length - 1])) {
+      blocks = blocks.slice(0, -1);
+    }
+    const lastIndex = blocks.length - 1;
+    blocks.forEach((block, i) => {
+      const index = this.base + i;
+      const open = !final && i === lastIndex && block.metadata?.isComplete !== true;
+      const metadata = this.metadataFor(block, index, open);
+      this.emit(dispatch, index, block, open ? "streaming" : "complete", metadata);
     });
-  }
-  reportUnclosedReasoningRegion(tag) {
-    if (this.unclosedReasoningReported) return;
-    this.unclosedReasoningReported = true;
-    captureError({
-      source: "reasoning-leak",
-      message: `The stream ended INSIDE a <${tag}> region \u2014 its closing tag never arrived, so every token after the model stopped thinking (the whole visible ANSWER) is inside a thinking block and the assistant message renders empty behind a collapsed "Thought process". Remedy: the wrapper is per-stream state in aidream providers/reasoning_stream_state.py \u2014 a stranded open means a provider parser is sharing it across concurrent turns again.`,
-      requestId: this.requestId,
-      raw: { sample: this.currentBlockContent.slice(0, 500) }
-    });
-  }
-  // ── Internal ────────────────────────────────────────────────────────────
-  get currentBlockId() {
-    return `client_block_${this.currentBlockIndex}`;
-  }
-  processLine(rawLine, dispatch) {
-    this.lineQueue.push({ rawLine, dispatch });
-    this.drainLineQueue();
-  }
-  /** The open bare-JSON region on this line is prose after all: drop its parse, keep its block as text. */
-  demoteKindLineToProse() {
-    this.irSession = null;
-    this.irEnvelope = null;
-    this.irFedFragmentLen = 0;
-    this.currentBlockType = "text";
-    this.subState = { kind: "none" };
-    this.kindLineIsProse = true;
-  }
-  /** Process queued lines in order (re-entrant calls return; the outer loop drains). */
-  drainLineQueue() {
-    if (this.isProcessingLineQueue) return;
-    this.isProcessingLineQueue = true;
-    try {
-      while (this.lineQueue.length > 0) {
-        const next = this.lineQueue.shift();
-        if (next) this.processLineNow(next.rawLine, next.dispatch);
-      }
-    } finally {
-      this.isProcessingLineQueue = false;
-    }
-  }
-  /** Lines this accumulator has read (the first may open front matter). */
-  linesRead = 0;
-  processLineNow(rawLine, dispatch) {
-    if (this.kindLineIsProse) {
-      this.kindLineIsProse = false;
-      this.linesRead++;
-      this.appendToCurrentBlock(rawLine);
-      return;
-    }
-    const trimmed = rawLine.trim();
-    const isFirstLine = this.linesRead === 0;
-    this.linesRead++;
-    const fenceLine = rawLine.replace(/\r$/, "").replace(isFirstLine ? /^\uFEFF/ : /$^/, "");
-    if (this.subState.kind === "none" && isFirstLine && (fenceLine === "---" || fenceLine === "+++")) {
-      if (this.currentBlockType !== "text") {
-        this.closeCurrentBlock(dispatch);
-        this.openBlock("text", dispatch);
-      }
-      this.appendToCurrentBlock(rawLine);
-      this.subState = { kind: "frontmatter", fence: fenceLine };
-      return;
-    }
-    if (this.subState.kind !== "none") {
-      this.processSubStateLine(rawLine, trimmed, dispatch);
-      return;
-    }
-    if (DIRECTIVE_CONTAINER_OPEN.test(rawLine)) {
-      if (this.currentBlockType !== "text") {
-        this.closeCurrentBlock(dispatch);
-        this.openBlock("text", dispatch);
-      }
-      this.appendToCurrentBlock(rawLine);
-      this.subState = { kind: "directive", tracker: new DirectiveContainerTracker(rawLine) };
-      return;
-    }
-    const genericXml = startUnrecognizedXmlContainer(rawLine);
-    if (genericXml) {
-      this.closeCurrentBlock(dispatch);
-      this.openBlock("code", dispatch);
-      this.subState = { kind: "generic_xml", tracker: genericXml.tracker };
-      const source = rawLine.slice(genericXml.rootStart);
-      const rootEnd = genericXml.tracker.consumeLine(source);
-      if (rootEnd === null) {
-        this.appendToCurrentBlock(source);
-      } else {
-        this.appendToCurrentBlock(source.slice(0, rootEnd));
-        this.closeCurrentBlock(dispatch);
-        this.subState = { kind: "none" };
-        this.openBlock("text", dispatch);
-        const remainder = source.slice(rootEnd).trim();
-        if (remainder) this.processLine(remainder, dispatch);
-        else this.suppressEmptyTrailingSlot = true;
-      }
-      return;
-    }
-    const orphanClose = rawLine.match(ORPHAN_REASONING_CLOSE);
-    const selfOpened = orphanClose?.index !== void 0 && REASONING_OPEN_TAG.test(rawLine.slice(0, orphanClose.index));
-    if (orphanClose && !selfOpened) {
-      this.reportOrphanReasoningClose(orphanClose[0], rawLine);
-      const stripped = rawLine.replace(ORPHAN_REASONING_CLOSE_GLOBAL, "");
-      if (stripped.trim().length === 0) return;
-      this.processLine(stripped, dispatch);
-      return;
-    }
-    if (/^\[\s*(?:\{|$)/.test(trimmed)) {
-      const signal = jsonKindSignal(trimmed);
-      if (signal !== "not_kind") {
-        this.subState = { kind: "kind_array", held: [rawLine] };
-        if (signal === "kind") this.commitKindArray(dispatch);
-        return;
-      }
-    }
-    if (!startsStructuralLine(rawLine)) {
-      const at = proseKindObjectStart(rawLine);
-      if (at > 0 && kindObjectProseBreak(rawLine.slice(at)) === null) {
-        const rest = rawLine.slice(at);
-        const rootEnd = firstCompleteRootObjectEnd(rest);
-        const parts = [rawLine.slice(0, at)];
-        if (rootEnd === null) parts.push(rest);
-        else {
-          parts.push(rest.slice(0, rootEnd));
-          const tail = rest.slice(rootEnd).replace(/^[ \t]+/, "");
-          if (tail.trim()) parts.push(tail);
-        }
-        this.lineQueue.unshift(...parts.map((part) => ({ rawLine: part, dispatch })));
-        this.linesRead--;
-        return;
-      }
-    }
-    const flags = classifyLine(rawLine, trimmed);
-    if (this.currentBlockType === "text" && this.currentBlockLineCount > 0) {
-      const cut = this.currentBlockContent.lastIndexOf("\n");
-      const header = this.currentBlockContent.slice(cut + 1);
-      if (startsPipelessTable(header, rawLine)) {
-        this.currentBlockContent = cut >= 0 ? this.currentBlockContent.slice(0, cut) : "";
-        this.currentBlockLineCount -= 1;
-        this.closeCurrentBlock(dispatch);
-        this.openBlock("table", dispatch);
-        this.subState = { kind: "table", container: lineIndent(header) };
-        this.appendToCurrentBlock(header);
-        this.appendToCurrentBlock(rawLine);
-        return;
-      }
-    }
-    if (isPlainText(flags)) {
-      this.appendToCurrentBlock(rawLine);
-      return;
-    }
-    if (hasCandidate(flags, Candidate.CODE)) {
-      const fence = extractFenceInfo(trimmed);
-      if (fence) {
-        this.closeCurrentBlock(dispatch);
-        const normalizedLang = normalizeCodeLanguage(fence.language);
-        const blockType = normalizedLang && isSpecialCodeLanguage(normalizedLang) ? normalizedLang : "code";
-        this.openBlock(blockType, dispatch);
-        this.subState = {
-          kind: "code_fence",
-          language: fence.language,
-          meta: fence.meta,
-          fenceTicks: fence.ticks,
-          tildeReader: fence.char === "~" ? new FenceReader({
-            char: "~",
-            ticks: fence.ticks,
-            lang: fence.language
-          }) : null,
-          nestedFences: 0,
-          earlyTypeResolved: false,
-          resumeXml: this.nextBareJsonResumeXml ?? void 0
-        };
-        this.nextBareJsonResumeXml = null;
-        if (normalizedLang === "json") {
-          this.irOpenRegion();
-        }
-        return;
-      }
-    }
-    if (hasCandidate(flags, Candidate.XML_SIMPLE) || hasCandidate(flags, Candidate.XML_ATTR)) {
-      const tag = extractOpeningXmlTag(trimmed);
-      if (tag) {
-        this.openXmlTagBlock(tag, rawLine, trimmed, dispatch);
-        return;
-      }
-    }
-    {
-      const midLine = findMidLineAttrXml(rawLine);
-      if (midLine) {
-        const before = rawLine.slice(0, midLine.tagStart);
-        const fromTag = rawLine.slice(midLine.tagStart);
-        if (before.trimEnd()) {
-          this.appendToCurrentBlock(before.trimEnd());
-        }
-        this.closeCurrentBlock(dispatch);
-        const blockType = mapXmlTagToBlockType(midLine.tag);
-        this.openBlock(blockType, dispatch);
-        this.subState = {
-          kind: "xml_tag",
-          tagName: midLine.tag,
-          closingTag: `</${midLine.tag}>`,
-          openingTagText: midLine.openingTagText,
-          attributes: midLine.attributes,
-          isAttrXml: true,
-          balance: initialXmlBalance()
-        };
-        this.appendToCurrentBlock(fromTag);
-        if (fromTag.includes(`</${midLine.tag}>`)) {
-          this.closeCurrentBlock(dispatch);
-          this.subState = { kind: "none" };
-          this.openBlock("text", dispatch);
-          this.suppressEmptyTrailingSlot = true;
-        }
-        return;
-      }
-    }
-    if (hasCandidate(flags, Candidate.TABLE) && this.currentBlockType !== "table") {
-      this.closeCurrentBlock(dispatch);
-      this.openBlock("table", dispatch);
-      this.subState = { kind: "table", container: lineIndent(rawLine) };
-      this.appendToCurrentBlock(rawLine);
-      return;
-    }
-    const image = hasCandidate(flags, Candidate.IMAGE) ? detectImageMarkdown(rawLine) : null;
-    if (image?.isImage && image.src && countInlineImages(rawLine) < 2 && !TITLED_IMAGE_LINE.test(rawLine)) {
-      this.closeCurrentBlock(dispatch);
-      this.openBlock("image", dispatch);
-      this.pendingMediaData = { src: image.src, alt: image.alt ?? "" };
-      this.appendToCurrentBlock(trimmed);
-      this.closeCurrentBlock(dispatch);
-      this.openBlock("text", dispatch);
-      return;
-    }
-    const video = hasCandidate(flags, Candidate.VIDEO) ? detectVideoMarkdown(rawLine) : null;
-    if (video?.isVideo && video.src) {
-      this.closeCurrentBlock(dispatch);
-      this.openBlock("video", dispatch);
-      this.pendingMediaData = { src: video.src, alt: video.alt ?? "" };
-      this.appendToCurrentBlock(trimmed);
-      this.closeCurrentBlock(dispatch);
-      this.openBlock("text", dispatch);
-      return;
-    }
-    if (hasCandidate(flags, Candidate.AUDIO)) {
-      const audio = extractAudioLink(rawLine);
-      if (audio) {
-        this.closeCurrentBlock(dispatch);
-        this.openBlock("audio", dispatch);
-        this.pendingMediaData = audio;
-        this.appendToCurrentBlock(rawLine);
-        this.closeCurrentBlock(dispatch);
-        this.openBlock("text", dispatch);
-        return;
-      }
-    }
-    if (hasCandidate(flags, Candidate.MATRX_FILE) && detectMatrxFileMarkdown(rawLine).isMatrxFile) {
-      this.closeCurrentBlock(dispatch);
-      this.openBlock("matrx_file", dispatch);
-      this.appendToCurrentBlock(rawLine);
-      this.closeCurrentBlock(dispatch);
-      this.openBlock("text", dispatch);
-      return;
-    }
-    if (hasCandidate(flags, Candidate.DIVIDER)) {
-      this.closeCurrentBlock(dispatch);
-      const isHeavy = trimmed.startsWith("#");
-      this.openBlock(isHeavy ? "heavy-divider" : "accent-divider", dispatch);
-      this.appendToCurrentBlock(rawLine);
-      this.closeCurrentBlock(dispatch);
-      this.openBlock("text", dispatch);
-      return;
-    }
-    if (hasCandidate(flags, Candidate.BARE_JSON) && trimmed.startsWith("{")) {
-      const { opens: openCount, closes: closeCount } = countStructuralObjectBraces(trimmed);
-      if (openCount === closeCount && openCount > 0 && !isParseableJsonObject(trimmed) || // A line whose JSON grammar already broke into prose is prose (round 10).
-      regionBreaksIntoProse(trimmed)) {
-        this.appendToCurrentBlock(rawLine);
-        return;
-      }
-      const inArray = this.nextBareJsonInArray;
-      this.nextBareJsonInArray = false;
-      const resumeXml = this.nextBareJsonResumeXml ?? void 0;
-      this.nextBareJsonResumeXml = null;
-      this.closeCurrentBlock(dispatch);
-      this.openBlock("code", dispatch);
-      this.subState = {
-        kind: "bare_json",
-        openBraces: openCount,
-        closeBraces: closeCount,
-        earlyTypeResolved: false,
-        inArray,
-        resumeXml
-      };
-      this.irOpenRegion();
-      this.irFeedLine(rawLine);
-      this.appendToCurrentBlock(rawLine);
-      if (openCount === closeCount && openCount > 0) {
-        const jsonType = detectJsonBlockType(this.currentBlockContent);
-        this.currentBlockType = jsonType ?? "code";
-        this.closeCurrentBlock(dispatch);
-        if (resumeXml) {
-          this.resumeXmlSection(resumeXml, dispatch);
-          return;
-        }
-        this.subState = inArray ? { kind: "kind_array", held: null } : { kind: "none" };
-        this.openBlock("text", dispatch);
-        if (inArray) this.suppressEmptyTrailingSlot = true;
-      } else {
-        const jsonType = detectJsonBlockType(this.currentBlockContent);
-        if (jsonType) {
-          this.subState.earlyTypeResolved = true;
-          this.currentBlockType = jsonType;
-        }
-      }
-      return;
-    }
-    this.appendToCurrentBlock(rawLine);
-  }
-  /** Set while the next bare-JSON region opens as an array element (A6). */
-  nextBareJsonInArray = false;
-  /** Set while the next bare-JSON region is a kind split out of a section (A8). */
-  nextBareJsonResumeXml = null;
-  /** True while a split kind's earlier lines replay into its region (the XML tracker already saw them). */
-  replayingSplitKind = false;
-  /**
-   * Track a JSON object inside a simple XML section; split it out the moment
-   * it carries a `__kind` key (A8). `line` is the section body part of a
-   * line. Returns true when the line was consumed by the split.
-   */
-  trackXmlKindCandidate(line, dispatch) {
-    if (this.subState.kind !== "xml_tag" || this.subState.isAttrXml) return false;
-    let candidate = this.subState.jsonCandidate ?? null;
-    if (!candidate) {
-      if (!line.trimStart().startsWith("{")) return false;
-      candidate = {
-        contentLen: this.currentBlockContent.length,
-        lineCount: this.currentBlockLineCount,
-        lines: [],
-        depth: 0
-      };
-    }
-    candidate.lines.push(line);
-    const { opens, closes } = countStructuralObjectBraces(line);
-    candidate.depth += opens - closes;
-    if (hasKindKey(candidate.lines.join("\n"))) {
-      this.splitKindOutOfXmlSection(candidate, dispatch);
-      return true;
-    }
-    this.subState.jsonCandidate = candidate.depth > 0 ? candidate : null;
-    return false;
-  }
-  /**
-   * Close the section's part before the kind (trimmed, like the reload's
-   * piece), then replay the kind's lines so far as a bare-JSON region that
-   * resumes the section when it balances (A8).
-   */
-  splitKindOutOfXmlSection(candidate, dispatch) {
-    if (this.subState.kind !== "xml_tag") return;
-    const section = {
-      ...this.subState,
-      jsonCandidate: null,
-      balance: { ...this.subState.balance }
-    };
-    this.currentBlockContent = this.currentBlockContent.slice(0, candidate.contentLen).trim();
-    this.currentBlockLineCount = this.currentBlockContent ? candidate.lineCount : 0;
-    this.regionContinuesAfterClose = true;
-    this.closeCurrentBlock(dispatch);
-    this.regionContinuesAfterClose = false;
-    this.subState = { kind: "none" };
-    this.openBlock("text", dispatch);
-    this.suppressEmptyTrailingSlot = true;
-    this.nextBareJsonResumeXml = section;
-    const [first, ...rest] = candidate.lines;
-    if (first !== void 0) {
-      const trimmedFirst = first.trimStart();
-      const end = firstCompleteRootObjectEnd(trimmedFirst);
-      if (rest.length === 0 && end !== null && trimmedFirst.slice(end).trim()) {
-        this.processLineNow(trimmedFirst.slice(0, end), dispatch);
-        this.processLine(trimmedFirst.slice(end), dispatch);
-        return;
-      }
-      this.processLineNow(trimmedFirst, dispatch);
-    }
-    for (const line of rest) this.processLineNow(line, dispatch);
-  }
-  /** The section a kind was split out of continues in a fresh block (A8). */
-  resumeXmlSection(section, dispatch) {
-    if (section.kind === "generic_xml") {
-      this.openBlock("code", dispatch);
-      this.subState = { ...section, kindCandidate: null };
-      this.currentBlockLineCount = 1;
-      this.suppressEmptyTrailingSlot = true;
-      return;
-    }
-    this.openBlock(mapXmlTagToBlockType(section.tagName), dispatch);
-    this.subState = { ...section, jsonCandidate: null, resumedAfterKind: true };
-    this.suppressEmptyTrailingSlot = true;
-  }
-  /**
-   * Track a JSON object or JSON-family fence inside a generic XML container
-   * (an XML TAG — structure, ruling (b), round 3); split it out the moment its
-   * text carries a `__kind` key (X1). Returns true when the line was consumed.
-   */
-  trackGenericXmlKindCandidate(line, dispatch) {
-    if (this.subState.kind !== "generic_xml") return false;
-    let candidate = this.subState.kindCandidate ?? null;
-    if (!candidate) {
-      if (endsInsideXmlLiteral(this.currentBlockContent)) return false;
-      const trimmed = line.trimStart();
-      const opener = /^ {0,3}[`~]/.test(line) ? fenceOpenerOf(trimmed) : null;
-      const fence = opener && isJsonFenceLanguage(opener.lang) ? opener : null;
-      if (!fence && !trimmed.startsWith("{")) return false;
-      candidate = {
-        contentLen: this.currentBlockContent.length,
-        lineCount: this.currentBlockLineCount,
-        lines: [],
-        depth: 0,
-        fence: fence ? { char: fence.char, ticks: fence.ticks } : null
-      };
-      if (fence) {
-        candidate.lines.push(line);
-        this.subState.kindCandidate = candidate;
-        return false;
-      }
-    } else if (candidate.fence && isFenceCloserLine(line, candidate.fence)) {
-      this.subState.kindCandidate = null;
-      return false;
-    }
-    candidate.lines.push(line);
-    if (!candidate.fence) {
-      const { opens, closes } = countStructuralObjectBraces(line);
-      candidate.depth += opens - closes;
-    }
-    if (hasKindKey(genericCandidateBody(candidate))) {
-      this.splitKindOutOfGenericXml(candidate, dispatch);
-      return true;
-    }
-    this.subState.kindCandidate = candidate.fence || candidate.depth > 0 ? candidate : null;
-    return false;
-  }
-  /**
-   * Close the XML card's part before the kind, then replay the kind's lines
-   * so far as its own region (bare JSON or the JSON fence) that resumes the
-   * container when it closes (X1). The reload's recovery splits the same bytes.
-   */
-  splitKindOutOfGenericXml(candidate, dispatch) {
-    if (this.subState.kind !== "generic_xml") return;
-    const container = { ...this.subState, kindCandidate: null };
-    const before = this.currentBlockContent.slice(0, candidate.contentLen);
-    this.currentBlockContent = before.trim() ? `${before}
-` : "";
-    this.currentBlockLineCount = before.trim() ? candidate.lineCount : 0;
-    this.closeCurrentBlock(dispatch);
-    this.subState = { kind: "none" };
-    this.openBlock("text", dispatch);
-    this.suppressEmptyTrailingSlot = true;
-    this.nextBareJsonResumeXml = container;
-    this.replayingSplitKind = true;
+    this.recordWrapperSplits(blocks);
+    if (blocks.some((block) => block.metadata?.continuation === true)) this.reportOrphanReasoningClose(text);
+    for (let i = blocks.length; i < this.drawn; i++) this.retract(dispatch, this.base + i);
+    this.drawn = blocks.length;
+  }
+  recordWrapperSplits(blocks) {
+    for (const [start] of this.wrapperSplits) if (start >= this.base) this.wrapperSplits.delete(start);
+    let i = 0;
+    while (i < blocks.length) {
+      const source = wrapperSourceOf(blocks[i]);
+      if (!source) {
+        i++;
+        continue;
+      }
+      const indices = [];
+      while (i < blocks.length && wrapperSourceOf(blocks[i]) === source) indices.push(this.base + i++);
+      this.wrapperSplits.set(indices[0], { indices, source });
+    }
+  }
+  metadataFor(block, index, open) {
+    const metadata = block.metadata;
+    if (metadata?.[IR_ENVELOPE_KEY]) return metadata;
+    const source = jsonRegionSource(block);
+    if (!source) {
+      if (this.region?.index === index) this.closeRegion();
+      return metadata;
+    }
+    if (open) {
+      if (block.type === "artifact" && isWholeJson(source)) return this.envelopes.withIrEnvelope(source.trim(), metadata);
+      const envelope = this.feedRegion(block, index);
+      return envelope ? { ...metadata ?? {}, [IR_ENVELOPE_KEY]: envelope } : metadata;
+    }
+    const closed = this.closedEnvelopes.get(index);
+    if (closed) return { ...metadata ?? {}, [IR_ENVELOPE_KEY]: closed };
+    if (this.region?.index === index) {
+      this.feedRegion(block, index);
+      const envelope = this.closeRegion();
+      if (envelope) return { ...metadata ?? {}, [IR_ENVELOPE_KEY]: envelope };
+    }
+    return this.envelopes.withIrEnvelope(source, metadata);
+  }
+  /** Feed the open region's new bytes; reopen when the block is a different region. */
+  feedRegion(block, index = this.region?.index ?? -1) {
+    const source = jsonRegionSource(block);
+    if (!source) return null;
+    if (this.region && (this.region.index !== index || !source.startsWith(this.region.fed))) {
+      this.dropRegion();
+    }
+    if (!this.region) {
+      const session = this.openRegion(index);
+      if (!session) return null;
+      this.region = { index, identity: `${this.requestId}:client_block_${index}`, session, fed: "" };
+    }
+    const delta = source.slice(this.region.fed.length);
+    if (delta) {
+      this.region.session.write(delta);
+      this.region.fed = source;
+    }
+    return sessionEnvelope(this.region.session);
+  }
+  openRegion(index) {
+    const identity = `${this.requestId}:client_block_${index}`;
     try {
-      const [first, ...rest] = candidate.lines;
-      if (first !== void 0) {
-        const trimmedFirst = first.trimStart();
-        const end = candidate.fence ? null : firstCompleteRootObjectEnd(trimmedFirst);
-        if (rest.length === 0 && end !== null && trimmedFirst.slice(end).trim()) {
-          this.processLineNow(trimmedFirst.slice(0, end), dispatch);
-          this.replayingSplitKind = false;
-          this.processLine(trimmedFirst.slice(end), dispatch);
-          return;
-        }
-        this.processLineNow(candidate.fence ? first : trimmedFirst, dispatch);
-      }
-      for (const line of rest) this.processLineNow(line, dispatch);
-    } finally {
-      this.replayingSplitKind = false;
-    }
-  }
-  /** The fragment twin of the generic-XML split (X1): `<output>\n{"__kind":…` with no newline yet. */
-  maybeSplitKindFromGenericXmlFragment(dispatch) {
-    if (this.subState.kind !== "generic_xml") return;
-    const fragment = this.pendingLineFragment;
-    if (fragment.includes(`</${this.subState.tracker.rootTag}`)) return;
-    const candidate = this.subState.kindCandidate ?? null;
-    if (!candidate && !BARE_JSON_OPEN_RE.test(fragment.trimStart())) return;
-    if (!candidate && endsInsideXmlLiteral(this.currentBlockContent)) return;
-    const text = candidate ? genericCandidateBody({ ...candidate, lines: [...candidate.lines, fragment] }) : fragment;
-    if (!hasKindKey(text)) return;
-    this.splitKindOutOfGenericXml(
-      candidate ?? {
-        contentLen: this.currentBlockContent.length,
-        lineCount: this.currentBlockLineCount,
-        lines: [],
-        depth: 0,
-        fence: null
-      },
-      dispatch
-    );
-    if (!candidate) this.pendingLineFragment = fragment.trimStart();
-  }
-  /**
-   * The fragment twin of the section split: a newline-less kind object inside
-   * a simple section (`<info>{"__kind":…`) leaves it as soon as `__kind` is
-   * visible, and the fragment opens the region below (A8).
-   */
-  maybeSplitKindFromXmlFragment(dispatch) {
-    if (this.subState.kind !== "xml_tag" || this.subState.isAttrXml) return;
-    const fragment = this.pendingLineFragment;
-    if (fragment.includes(this.subState.closingTag)) return;
-    const candidate = this.subState.jsonCandidate;
-    const text = candidate ? [...candidate.lines, fragment].join("\n") : fragment;
-    if (!candidate && !BARE_JSON_OPEN_RE.test(fragment.trimStart())) return;
-    if (!hasKindKey(text)) return;
-    this.splitKindOutOfXmlSection(
-      candidate ?? {
-        contentLen: this.currentBlockContent.length,
-        lineCount: this.currentBlockLineCount,
-        lines: [],
-        depth: 0
-      },
-      dispatch
-    );
-    if (!candidate) this.pendingLineFragment = fragment.trimStart();
-  }
-  /**
-   * The held array start is a kind array: close the prose before it, drop the
-   * `[`, and replay the held lines as array content (A6).
-   */
-  commitKindArray(dispatch) {
-    if (this.subState.kind !== "kind_array" || this.subState.held === null) return;
-    const [first, ...rest] = this.subState.held;
-    this.subState = { kind: "kind_array", held: null };
-    this.closeCurrentBlock(dispatch);
-    this.openBlock("text", dispatch);
-    this.suppressEmptyTrailingSlot = true;
-    this.continueKindArray((first ?? "").replace(/^\s*\[/, ""), dispatch);
-    for (const line of rest) this.processLineNow(line, dispatch);
-  }
-  /** Not a kind array after all: the held lines are ordinary lines, in order. */
-  releaseHeldArray(dispatch) {
-    if (this.subState.kind !== "kind_array" || this.subState.held === null) return;
-    const [first, ...rest] = this.subState.held;
-    this.subState = { kind: "none" };
-    this.appendToCurrentBlock(first ?? "");
-    this.lineQueue.unshift(...rest.map((rawLine) => ({ rawLine, dispatch })));
-    this.drainLineQueue();
-  }
-  /**
-   * Array content between (or opening) elements: `,` and whitespace are
-   * chrome, `]` ends the array, `{` opens the next element as its own
-   * bare-JSON region. Anything else ends the array as ordinary source.
-   */
-  continueKindArray(text, dispatch) {
-    let rest = text;
-    while (this.subState.kind === "kind_array") {
-      rest = rest.replace(/^[\s,]*/, "");
-      if (!rest) return;
-      if (rest.startsWith("]")) {
-        this.subState = { kind: "none" };
-        const after = rest.slice(1);
-        if (after.trim()) this.processLineNow(after, dispatch);
-        return;
-      }
-      if (!rest.startsWith("{")) {
-        this.subState = { kind: "none" };
-        this.processLineNow(rest, dispatch);
-        return;
-      }
-      const end = firstCompleteRootObjectEnd(rest);
-      this.subState = { kind: "none" };
-      this.nextBareJsonInArray = true;
-      if (end === null) {
-        this.processLineNow(rest, dispatch);
-        this.nextBareJsonInArray = false;
-        return;
-      }
-      this.processLineNow(rest.slice(0, end), dispatch);
-      this.nextBareJsonInArray = false;
-      rest = rest.slice(end);
-    }
-    if (rest.trim()) this.processLineNow(rest, dispatch);
-  }
-  /**
-   * The fragment twin of the array entry in processLineNow: a newline-less
-   * `[{"__kind":…` decides on its first key while it streams (A6).
-   */
-  maybeEnterKindArrayFromFragment(dispatch) {
-    if (this.subState.kind === "kind_array" && this.subState.held !== null) {
-      const signal = jsonKindSignal(
-        [...this.subState.held, this.pendingLineFragment].join("\n")
-      );
-      if (signal !== "kind") return;
-      this.commitKindArray(dispatch);
-      return;
-    }
-    if (this.subState.kind !== "none") return;
-    const fragment = this.pendingLineFragment;
-    if (!/^\s*\[\s*\{/.test(fragment)) return;
-    if (jsonKindSignal(fragment) !== "kind") return;
-    this.closeCurrentBlock(dispatch);
-    this.openBlock("text", dispatch);
-    this.suppressEmptyTrailingSlot = true;
-    this.subState = { kind: "kind_array", held: null };
-    this.pendingLineFragment = fragment.replace(/^\s*\[/, "");
-  }
-  /** The fragment twin of the complete-line split in processLineNow (A5). */
-  maybeSplitProseBeforeKindFragment(dispatch) {
-    if (this.subState.kind !== "none" || this.kindLineIsProse) return;
-    const fragment = this.pendingLineFragment;
-    if (startsStructuralLine(fragment)) return;
-    const at = proseKindObjectStart(fragment);
-    if (at <= 0) return;
-    if (hasUnclosedBacktickRun(fragment.slice(0, at))) return;
-    this.pendingLineFragment = fragment.slice(at);
-    this.processLine(fragment.slice(0, at), dispatch);
-  }
-  /**
-   * Open a bare_json region directly from the trailing line fragment — the
-   * newline-less minified JSON case (`{"__kind":…}` streamed as one line with
-   * no `\n` until the end). Without this, processLine (which only sees COMPLETE
-   * lines) never opens the region and the raw JSON projects as a text block
-   * until finalize — the "shows the whole JSON, converts only when done" bug.
-   *
-   * Mirrors processLine's bare-JSON branch but fragment-driven: it commits the
-   * moment the fragment reveals `{ "key":` (unambiguous JSON), retracting the
-   * speculative text projection of those same chars, and lets the existing
-   * fragment-feed path (in ingest) and finalize/newline completion carry the
-   * region the rest of the way. openBraces/closeBraces start at 0 — the
-   * completing line counts them exactly once (see the bare_json substate case).
-   */
-  maybeOpenBareJsonFromFragment(dispatch) {
-    let inArray = false;
-    if (this.subState.kind === "kind_array" && this.subState.held === null) {
-      const chrome = /^\s*,?\s*/.exec(this.pendingLineFragment)[0];
-      this.pendingLineFragment = this.pendingLineFragment.slice(chrome.length);
-      if (this.pendingLineFragment.startsWith("]")) {
-        this.pendingLineFragment = this.pendingLineFragment.slice(1);
-        this.subState = { kind: "none" };
-        return;
-      }
-      inArray = true;
-    } else if (this.subState.kind !== "none" || this.kindLineIsProse) return;
-    const completeTag = /^\s*<([A-Za-z][\w-]*)>[\s\S]*?<\/\1>/.exec(
-      this.pendingLineFragment
-    );
-    if (completeTag && this.pendingLineFragment.slice(completeTag[0].length).trimStart().startsWith("{")) {
-      this.pendingLineFragment = this.pendingLineFragment.slice(
-        completeTag[0].length
-      );
-      this.processLine(completeTag[0], dispatch);
-      if (this.subState.kind !== "none" || this.currentBlockContent) return;
-    }
-    const frag = this.pendingLineFragment;
-    if (!BARE_JSON_OPEN_RE.test(frag.trimStart())) return;
-    const resumeXml = this.nextBareJsonResumeXml ?? void 0;
-    this.nextBareJsonResumeXml = null;
-    this.closeCurrentBlock(dispatch);
-    this.openBlock("code", dispatch);
-    this.subState = {
-      kind: "bare_json",
-      openBraces: 0,
-      closeBraces: 0,
-      earlyTypeResolved: false,
-      inArray,
-      resumeXml
-    };
-    this.irOpenRegion();
-    this.irWriteLinePart(frag, false);
-    const jsonType = detectJsonBlockType(frag.trimStart());
-    if (jsonType) {
-      this.subState.earlyTypeResolved = true;
-      this.currentBlockType = jsonType;
-    }
-  }
-  processSubStateLine(rawLine, trimmed, dispatch) {
-    switch (this.subState.kind) {
-      case "directive": {
-        this.appendToCurrentBlock(rawLine);
-        if (this.subState.tracker.consume(rawLine)) this.subState = { kind: "none" };
-        return;
-      }
-      case "frontmatter": {
-        this.appendToCurrentBlock(rawLine);
-        const line = rawLine.replace(/\r$/, "");
-        if (line === this.subState.fence || this.subState.fence === "---" && line === "...") {
-          this.subState = { kind: "none" };
-        }
-        return;
-      }
-      case "code_fence": {
-        if (this.subState.resumeXml?.kind === "generic_xml" && !this.replayingSplitKind) {
-          this.subState.resumeXml.tracker.consumeLine(rawLine);
-        }
-        const fenceLine = this.subState.tildeReader ? this.subState.tildeReader.feed(rawLine) ? "close-outer" : "content" : classifyInnerFenceLine(
-          trimFenceLine(rawLine),
-          this.subState.fenceTicks,
-          fenceNestsInnerFences(this.subState.language),
-          this.subState.nestedFences
-        );
-        if (fenceLine === "open-nested") this.subState.nestedFences++;
-        if (fenceLine === "close-nested") this.subState.nestedFences--;
-        if (fenceLine === "close-outer") {
-          if (normalizeCodeLanguage(this.subState.language) === "json") {
-            const confirmed = detectJsonBlockType(this.currentBlockContent);
-            this.currentBlockType = confirmed ?? "code";
-          }
-          this.fenceClosedCleanly = true;
-          const resumeXml = this.subState.resumeXml;
-          this.closeCurrentBlock(dispatch);
-          if (resumeXml) {
-            this.resumeXmlSection(resumeXml, dispatch);
-            return;
-          }
-          this.subState = { kind: "none" };
-          this.openBlock("text", dispatch);
-        } else {
-          if (normalizeCodeLanguage(this.subState.language) === "json" && !this.subState.earlyTypeResolved) {
-            const soFar = this.currentBlockContent ? this.currentBlockContent + "\n" + rawLine : rawLine;
-            const jsonType = detectJsonBlockType(soFar);
-            if (jsonType) {
-              this.subState.earlyTypeResolved = true;
-              this.currentBlockType = jsonType;
-            }
-          }
-          this.irFeedLine(rawLine);
-          this.appendToCurrentBlock(rawLine);
-        }
-        return;
-      }
-      case "xml_tag": {
-        const { closingTag, isAttrXml, tagName, balance } = this.subState;
-        const closingIdxRaw = findBalancedXmlClose(rawLine, tagName, balance, {
-          trackFences: false
-        });
-        const remainder = closingIdxRaw === -1 ? "" : rawLine.slice(closingIdxRaw + closingTag.length);
-        let lineToAppend = rawLine;
-        if (closingIdxRaw !== -1) {
-          lineToAppend = isAttrXml ? rawLine.slice(0, closingIdxRaw + closingTag.length) : rawLine.slice(0, closingIdxRaw);
-        }
-        const isClosingLine = closingIdxRaw !== -1;
-        if (!isAttrXml) {
-          const body = isClosingLine ? rawLine.slice(0, closingIdxRaw) : rawLine;
-          if (this.trackXmlKindCandidate(body, dispatch)) {
-            if (isClosingLine) this.processLine(rawLine.slice(closingIdxRaw), dispatch);
-            return;
-          }
-        }
-        if (isAttrXml && !isClosingLine) {
-          if (this.irSession) {
-            this.irFeedLine(rawLine);
-          } else {
-            this.maybeOpenXmlBodyIrRegion(rawLine, true);
-          }
-        }
-        this.appendToCurrentBlock(lineToAppend);
-        if (isClosingLine && this.subState.resumedAfterKind) {
-          this.currentBlockContent = this.currentBlockContent.trim();
-        }
-        if (isClosingLine) {
-          this.xmlClosedCleanly = true;
-          this.closeCurrentBlock(dispatch);
-          this.subState = { kind: "none" };
-          this.openBlock("text", dispatch);
-          if (remainder.length > 0) {
-            this.processLine(remainder, dispatch);
-          }
-        }
-        return;
-      }
-      case "kind_array": {
-        const held = this.subState.held;
-        if (held === null) {
-          this.continueKindArray(rawLine, dispatch);
-          return;
-        }
-        held.push(rawLine);
-        const signal = jsonKindSignal(held.join("\n"));
-        if (signal === "kind") this.commitKindArray(dispatch);
-        else if (signal === "not_kind") this.releaseHeldArray(dispatch);
-        return;
-      }
-      case "generic_xml": {
-        const rootEnd = this.subState.tracker.consumeLine(rawLine);
-        if (rootEnd === null) {
-          if (this.trackGenericXmlKindCandidate(rawLine, dispatch)) return;
-          this.appendToCurrentBlock(rawLine);
-          return;
-        }
-        this.subState.kindCandidate = null;
-        this.appendToCurrentBlock(rawLine.slice(0, rootEnd));
-        this.closeCurrentBlock(dispatch);
-        this.subState = { kind: "none" };
-        this.openBlock("text", dispatch);
-        const remainder = rawLine.slice(rootEnd).trim();
-        if (remainder) this.processLine(remainder, dispatch);
-        else this.suppressEmptyTrailingSlot = true;
-        return;
-      }
-      case "table": {
-        const flags = classifyLine(rawLine, trimmed);
-        const { container } = this.subState;
-        const indented = lineIndent(rawLine) - container >= 4;
-        if (hasCandidate(flags, Candidate.TABLE) && !indented || continuesTable(rawLine, container)) {
-          this.appendToCurrentBlock(rawLine);
-        } else {
-          this.closeCurrentBlock(dispatch);
-          this.subState = { kind: "none" };
-          this.openBlock("text", dispatch);
-          this.processLine(rawLine, dispatch);
-        }
-        return;
-      }
-      case "bare_json": {
-        if (!this.currentBlockContent && kindObjectProseBreak(rawLine.trimStart()) !== null || regionBreaksIntoProse(this.currentBlockContent ? `${this.currentBlockContent}
-${rawLine}` : rawLine)) {
-          this.demoteKindLineToProse();
-          this.kindLineIsProse = false;
-          this.appendToCurrentBlock(rawLine);
-          return;
-        }
-        const completionEnd = firstCompleteRootObjectEnd(
-          rawLine,
-          this.subState.openBraces - this.subState.closeBraces
-        );
-        if (completionEnd !== null && rawLine.slice(completionEnd).trim().length > 0) {
-          this.processSubStateLine(
-            rawLine.slice(0, completionEnd),
-            rawLine.slice(0, completionEnd).trim(),
-            dispatch
-          );
-          this.processLine(rawLine.slice(completionEnd).trimStart(), dispatch);
-          return;
-        }
-        const { opens: lineOpens, closes: lineCloses } = countStructuralObjectBraces(trimmed);
-        const willBalance = this.subState.openBraces + lineOpens === this.subState.closeBraces + lineCloses && this.subState.openBraces + lineOpens > 0;
-        if (!willBalance && !this.subState.earlyTypeResolved) {
-          const soFar = this.currentBlockContent ? this.currentBlockContent + "\n" + rawLine : rawLine;
-          const jsonType = detectJsonBlockType(soFar);
-          if (jsonType) {
-            this.subState.earlyTypeResolved = true;
-            this.currentBlockType = jsonType;
-          }
-        }
-        this.irFeedLine(rawLine);
-        this.appendToCurrentBlock(rawLine);
-        this.subState.openBraces += lineOpens;
-        this.subState.closeBraces += lineCloses;
-        if (this.subState.openBraces === this.subState.closeBraces && this.subState.openBraces > 0) {
-          const jsonType = detectJsonBlockType(this.currentBlockContent);
-          this.currentBlockType = jsonType ?? "code";
-          const inArray = this.subState.inArray === true;
-          const resumeXml = this.subState.resumeXml;
-          this.closeCurrentBlock(dispatch);
-          if (resumeXml) {
-            this.resumeXmlSection(resumeXml, dispatch);
-            return;
-          }
-          this.subState = inArray ? { kind: "kind_array", held: null } : { kind: "none" };
-          this.openBlock("text", dispatch);
-          this.suppressEmptyTrailingSlot = true;
-        }
-        return;
-      }
-    }
-  }
-  // ── XML opening helper ──────────────────────────────────────────────
-  openXmlTagBlock(tag, rawLine, trimmed, dispatch) {
-    this.closeCurrentBlock(dispatch);
-    const blockType = mapXmlTagToBlockType(tag);
-    this.openBlock(blockType, dispatch);
-    const isAttrXml = ATTR_XML_TAGS.has(tag);
-    const openingTagText = extractOpeningTagText(trimmed, tag);
-    const attributes = isAttrXml ? parseXmlAttributes(openingTagText) : {};
-    const closingTag = `</${tag}>`;
-    this.subState = {
-      kind: "xml_tag",
-      tagName: tag,
-      closingTag,
-      openingTagText,
-      attributes,
-      isAttrXml,
-      balance: initialXmlBalance()
-    };
-    const closingIdxRaw = rawLine.indexOf(closingTag);
-    const remainder = closingIdxRaw === -1 ? "" : rawLine.slice(closingIdxRaw + closingTag.length);
-    let lineToAppend = rawLine;
-    if (!isAttrXml) {
-      const openIdx = rawLine.indexOf(openingTagText);
-      if (openIdx !== -1) {
-        lineToAppend = rawLine.slice(0, openIdx) + rawLine.slice(openIdx + openingTagText.length);
-      }
-      const closingIdx = lineToAppend.indexOf(closingTag);
-      if (closingIdx !== -1) {
-        lineToAppend = lineToAppend.slice(0, closingIdx);
-      }
-    } else if (closingIdxRaw !== -1) {
-      lineToAppend = rawLine.slice(0, closingIdxRaw + closingTag.length);
-    }
-    this.appendToCurrentBlock(lineToAppend);
-    if (closingIdxRaw !== -1) {
-      this.closeCurrentBlock(dispatch);
-      this.subState = { kind: "none" };
-      this.openBlock("text", dispatch);
-      if (remainder.length > 0) {
-        this.processLine(remainder, dispatch);
-      }
-    }
-  }
-  // ── content-ir region delegation (Phase 2) ─────────────────────────
-  //
-  // Boundary rule: the accumulator (host) finds the JSON region and remains
-  // the region-end oracle (fence close / brace balance); the kind parser owns
-  // everything INSIDE the region. Blocks gain a dark `metadata.__ir` envelope
-  // while rendering stays content-driven — the parity check below proves the
-  // two paths agree on real traffic before Phase 4 flips anything visible.
-  irOpenRegion() {
-    const identity = `${this.requestId}:${this.currentBlockId}`;
-    try {
-      this.irSession = openParseSession({
+      const session = openParseSession({
         identity,
         schemas: kindRegistry.resolver(),
         onSchemaArrived: (deliver) => kindRegistry.onSchemaArrived(deliver),
-        // EAGER LIGHTWEIGHT FETCH: the instant a cloud kind is identified
-        // mid-stream, fire the schema cold-fetch (the parser also requests
-        // it — deduped) AND the targeted component fetch in parallel, so by
-        // the time the region completes both registries can answer.
-        // (web, output) is DELIBERATE: chat streaming renders exactly that
-        // surface; other roles/platforms ride the warm/refresh path by
-        // design (see SHAPE_SYSTEM.md § streaming db/cloud kinds).
         onEvent: (event) => {
           if (event.type === "kind_identified" || event.type === "pending_schema") {
             void kindRegistry.ensureWarm();
@@ -1576,398 +212,134 @@ ${rawLine}` : rawLine)) {
           }
         }
       });
-      this.irIdentities.push(identity);
-      this.irRegionLineCount = 0;
-      this.irFedFragmentLen = 0;
-      this.irEnvelope = null;
-      this.irRegionIsXmlBody = false;
+      this.identities.push(identity);
+      return session;
     } catch (error) {
       captureError({
         source: "content-ir",
         message: `failed to open parse region ${identity}: ${error instanceof Error ? error.message : String(error)}`,
         raw: error
       });
-      this.irSession = null;
-    }
-  }
-  /**
-   * Feed region text. `part` is either the unfed remainder of a completing
-   * line (isLineComplete) or a pendingLineFragment delta (streaming chars of
-   * a line that hasn't finished — how minified single-line JSON gets live
-   * parsing instead of waiting for a newline).
-   */
-  irWriteLinePart(part, isLineComplete) {
-    if (!this.irSession) return;
-    if (this.irRegionLineCount > 0 && this.irFedFragmentLen === 0) {
-      this.irSession.write("\n");
-    }
-    if (part) {
-      this.irSession.write(part);
-    }
-    if (isLineComplete) {
-      this.irRegionLineCount++;
-      this.irFedFragmentLen = 0;
-    } else {
-      this.irFedFragmentLen += part.length;
-    }
-  }
-  /** Complete a region line, accounting for any fragment chars already fed. */
-  irFeedLine(line) {
-    if (!this.irSession) return;
-    this.irWriteLinePart(line.slice(this.irFedFragmentLen), true);
-  }
-  /** End the open region: final envelope + shadow parity telemetry. */
-  irCloseRegion() {
-    const session = this.irSession;
-    if (!session) return;
-    this.irSession = null;
-    session.end();
-    session.flushNotify();
-    const parsedEnvelope = sessionEnvelope(session);
-    this.irEnvelope = canonicalizeCompletedLegacyQuizEnvelope(
-      parsedEnvelope,
-      this.currentBlockContent
+      return null;
+    }
+  }
+  /** End the open region; its final envelope is kept for the block it belongs to. */
+  closeRegion() {
+    const region = this.region;
+    if (!region) return null;
+    this.region = null;
+    region.session.end();
+    region.session.flushNotify();
+    const envelope = canonicalizeCompletedLegacyQuizEnvelope(
+      sessionEnvelope(region.session),
+      region.fed
     );
-    this.irParityCheck(this.irEnvelope, parsedEnvelope !== this.irEnvelope);
-  }
-  /**
-   * Open an ir region for the JSON BODY of an attribute-XML block.
-   *
-   * THE WRAPPED-PAYLOAD CLASS. A structured-output agent whose answer is
-   * wrapped by the artifact system arrives as
-   *
-   *     <artifact type="flashcards" id="…" title="…">
-   *     {"__kind":"flashcard_set","cards":[…]}
-   *     </artifact>
-   *
-   * The accumulator opens ir regions for fences and for bare JSON, but an
-   * attr-XML region swallowed every body line whole — no region, no
-   * `metadata.__ir`, so `selectKindEnvelope` answered null for the entire run
-   * AND after it. Every surface reading the envelope (the flashcard
-   * card-by-card preview, D170's `<image_prompt>` step) therefore showed a
-   * spinner over a stream that was arriving perfectly. The wrapper is not the
-   * payload: parse the body exactly as a bare JSON region.
-   *
-   * Rendering is deliberately UNCHANGED — the artifact block keeps the
-   * artifact renderer (kind-route.ts refuses to re-type an artifact); the
-   * envelope is attached for selectors, which is what was missing.
-   *
-   * `part` is a whole body line (isLineComplete) or the streaming fragment of
-   * one, so a minified single-line body parses live instead of at the close.
-   */
-  maybeOpenXmlBodyIrRegion(part, isLineComplete) {
-    if (this.irSession || this.irEnvelope) return;
-    if (this.subState.kind !== "xml_tag" || !this.subState.isAttrXml) return;
-    if (!BARE_JSON_OPEN_RE.test(part.trimStart())) return;
-    this.irOpenRegion();
-    if (!this.irSession) return;
-    this.irRegionIsXmlBody = true;
-    this.irWriteLinePart(part, isLineComplete);
-  }
-  irParityCheck(envelope, usesLegacySourceAdapter = false) {
-    if (this.irRegionIsXmlBody) return;
-    if (envelope.root.status !== "complete") return;
-    if (usesLegacySourceAdapter) return;
-    let parsed;
-    try {
-      parsed = JSON.parse(this.currentBlockContent);
-    } catch {
-      captureError({
-        source: "content-ir",
-        message: `stream parity: JSON.parse failed where the kind parser completed (kind "${envelope.root.kind || "raw"}")`,
-        relation: envelope.root.kind || "raw",
-        raw: { content: this.currentBlockContent.slice(0, 500) }
-      });
-      return;
-    }
-    if (!envelopeMatchesParsedSource(envelope, parsed)) {
-      captureError({
-        source: "content-ir",
-        message: `stream parity mismatch for kind "${envelope.root.kind || "raw"}" \u2014 envelope != JSON.parse(content)`,
-        relation: envelope.root.kind || "raw",
-        raw: { fingerprint: envelope.fingerprint }
-      });
-    }
-  }
-  /** Dispose all sessions this stream opened (finalize-time cleanup). */
-  irDisposeAll() {
-    for (const identity of this.irIdentities) {
-      disposeParseSession(identity);
-    }
-    this.irIdentities = [];
-  }
-  // ── Block lifecycle helpers ─────────────────────────────────────────
-  appendToCurrentBlock(line) {
-    this.suppressEmptyTrailingSlot = false;
-    if (this.currentBlockLineCount === 0) {
-      this.currentBlockContent = line;
-    } else {
-      this.currentBlockContent += "\n" + line;
-    }
-    this.currentBlockLineCount++;
-  }
-  closeCurrentBlock(dispatch) {
-    if (this.irSession) {
-      this.irCloseRegion();
-    }
-    if (!this.currentBlockContent.trim()) {
-      if (this.currentBlockEmitted) {
-        this.retractCurrentBlock(dispatch);
-        this.currentBlockEmitted = false;
-      }
-      this.irEnvelope = null;
-      this.irRegionIsXmlBody = false;
-      return;
-    }
-    if (this.subState.kind === "xml_tag" && !this.subState.isAttrXml && this.xmlClosedCleanly) {
-      const openTag = this.subState.openingTagText;
-      const tagName = this.subState.tagName;
-      const xmlEnvelope = envelopeForCompletedXmlRegion(
-        tagName,
-        openTag && openTag !== `<${tagName}>` ? `${openTag}
-${this.currentBlockContent}
-</${tagName}>` : this.currentBlockContent
-      );
-      if (xmlEnvelope) this.irEnvelope = xmlEnvelope;
-    }
-    if (this.subState.kind === "code_fence" && this.fenceClosedCleanly) {
-      const normalizedLang = normalizeCodeLanguage(this.subState.language);
-      if (normalizedLang) {
-        const fenceEnvelope = envelopeForCompletedFenceRegion(
-          normalizedLang,
-          this.currentBlockContent
-        );
-        if (fenceEnvelope) this.irEnvelope = fenceEnvelope;
-      }
-    }
-    if (this.emitRecoveredEmbeddedKindBlocks(dispatch)) {
-      this.fenceClosedCleanly = false;
-      this.xmlClosedCleanly = false;
-      this.irEnvelope = null;
-      this.irRegionIsXmlBody = false;
-      this.currentBlockContent = "";
-      this.currentBlockLineCount = 0;
-      return;
-    }
-    this.fenceClosedCleanly = false;
-    this.xmlClosedCleanly = false;
-    this.emitCurrentBlock(dispatch, "complete");
-    this.irEnvelope = null;
-    this.irRegionIsXmlBody = false;
-    this.currentBlockContent = "";
-    this.currentBlockLineCount = 0;
-  }
-  /**
-   * A surrounding Markdown/code/XML classification never outranks an inner
-   * complete object carrying `__kind`. Replace the formerly monolithic Redux
-   * block with lossless container fragments plus independently routable JSON
-   * blocks. The first fragment reuses the already-streamed block id; later
-   * fragments take consecutive ids, so the next ordinary openBlock continues
-   * at the correct document position.
-   */
-  emitRecoveredEmbeddedKindBlocks(dispatch) {
-    if (this.currentBlockType === "artifact" || this.irEnvelope?.root.kind) {
-      return false;
-    }
-    if (this.genericXmlRecoverySuppressed || this.currentBlockType === "text" && this.currentBlockContent.split("\n").some(isUnclosedGenericXmlOpening)) {
-      return false;
-    }
-    const recoverySource = this.subState.kind === "xml_tag" && !this.subState.isAttrXml ? this.currentBlockContent.trim() : this.currentBlockContent;
-    const fence = this.subState.kind === "code_fence" ? this.subState : null;
-    if (fence && this.currentBlockType === "code" && !isJsonFenceLanguage(fence.language)) {
-      return false;
-    }
-    const genericXml = this.subState.kind === "generic_xml";
-    const pieces = splitAroundEmbeddedKindJson(recoverySource, {
-      excludeLiteralContexts: genericXml,
-      liftJsonFences: genericXml,
-      // Prose, tables and sections: an inline code span is quoted source.
-      // A JSON fence's body is JSON — a backtick inside a string is no span.
-      excludeQuotedSource: !genericXml && !(fence && isJsonFenceLanguage(fence.language))
-    });
-    if (pieces.length === 1 && pieces[0]?.type === "container") return false;
-    const recoveredXmlContainer = this.currentBlockType === "text" && isCompleteUnrecognizedXmlContainer(recoverySource);
-    const containerType = recoveredXmlContainer ? "code" : this.currentBlockType;
-    const containerData = recoveredXmlContainer ? { language: "xml" } : this.buildBlockData();
-    const containerMetadata = genericXml || recoveredXmlContainer ? { genericXmlContainer: true } : void 0;
-    let emitted = 0;
-    let followsKind = false;
-    const splitStart = this.currentBlockIndex;
-    const splitIndices = [];
-    const isWrapperSplit = pieces.some((piece) => piece.type === "residual");
-    for (const piece of pieces) {
-      if (piece.type === "chrome") continue;
-      const isKind = piece.type === "kind";
-      const isResidual = piece.type === "residual";
-      const content = isResidual ? piece.json : isKind ? piece.content : normalizeRecoveredContainerPiece(piece.content, containerType, followsKind);
-      followsKind = isKind;
-      if (!content) continue;
-      if (emitted > 0) this.currentBlockIndex++;
-      const asJson = isKind || isResidual;
-      const block = {
-        blockId: this.currentBlockId,
-        blockIndex: this.currentBlockIndex,
-        type: asJson ? "code" : containerType,
-        status: "complete",
-        content,
-        data: asJson ? { language: "json" } : containerData,
-        metadata: asJson ? withIrEnvelope(content, void 0) : containerMetadata
-      };
-      dispatch(this.upsertAction({ requestId: this.requestId, block }));
-      splitIndices.push(this.currentBlockIndex);
-      emitted++;
-      this.emitCount++;
-    }
-    if (isWrapperSplit && emitted > 0) {
-      this.wrapperSplits.set(splitStart, { indices: splitIndices, source: recoverySource });
+    this.closedEnvelopes.set(region.index, envelope);
+    return envelope;
+  }
+  dropRegion() {
+    if (!this.region) return;
+    disposeParseSession(this.region.identity);
+    this.region = null;
+  }
+  disposeAll() {
+    this.region = null;
+    for (const identity of this.identities) disposeParseSession(identity);
+    this.identities = [];
+  }
+  /** `{` (or `[{`) with no key yet may become a JSON region next frame: draw nothing yet. */
+  holdsNascentJson(block) {
+    if (block.type !== "text" && block.type !== "code") return false;
+    const lines = block.content.split("\n");
+    const lastLine = lines[lines.length - 1].trimStart();
+    if (block.type === "text" && lines.length > 1) return false;
+    return /^\[?\s*\{[^"]*$|^\[?\s*\{\s*"[^"]*$/.test(lastLine) || /^\[\s*$/.test(lastLine);
+  }
+  frontMatterStillOpen(text) {
+    const match = FRONT_MATTER_OPEN.exec(text);
+    const fence = match[1];
+    const rest = text.slice(match[0].length).split(/\r?\n/);
+    return !rest.slice(0, -1).some((line) => line.trim() === fence || fence === "---" && line.trim() === "...");
+  }
+  emit(dispatch, index, block, status, metadata) {
+    let content = block.content;
+    if (status === "streaming" && jsonRegionSource(block)) content = content.replace(LATER_PARTIAL_KIND_KEY, ",");
+    const payload = {
+      blockId: `client_block_${index}`,
+      blockIndex: index,
+      type: block.type,
+      status,
+      content: content || null,
+      data: this.dataFor(block),
+      metadata
+    };
+    if (block.language && !payload.data?.language) payload.language = block.language;
+    const signature = this.signatureOf(payload);
+    if (this.signatures.get(index) === signature) return;
+    this.signatures.set(index, signature);
+    dispatch(this.upsertAction({ requestId: this.requestId, block: payload }));
+  }
+  /** `data` as the renderer has always read it: a code block's language, a media block's link. */
+  dataFor(block) {
+    if (MEDIA_BLOCK_TYPES.has(block.type) && block.src) {
+      return { src: block.src, alt: block.alt ?? "" };
+    }
+    if (block.type === "code") {
+      const meta = block.metadata?.[FENCE_META_KEY];
+      if (!block.language && !meta) return null;
+      return { ...block.language ? { language: block.language } : {}, ...meta ? { [FENCE_META_KEY]: meta } : {} };
     }
-    this.currentBlockEmitted = emitted > 0;
-    return emitted > 0;
+    return null;
   }
-  /**
-   * Overwrites the block at the current index with an empty, completed payload
-   * so a previously-projected speculative streaming block is removed from the
-   * rendered output. Keyed by `currentBlockId`, so it replaces the exact
-   * Redux entry the speculative projection created.
-   */
-  retractCurrentBlock(dispatch) {
+  signatureOf(payload) {
+    const { [IR_ENVELOPE_KEY]: envelope, ...rest } = payload.metadata ?? {};
+    const ir = envelope;
+    return JSON.stringify([
+      payload.type,
+      payload.status,
+      payload.content,
+      payload.data,
+      payload.language,
+      rest,
+      ir ? [ir.fingerprint, ir.root.status, ir.root.kind] : null
+    ]);
+  }
+  retract(dispatch, index) {
     const block = {
-      blockId: this.currentBlockId,
-      blockIndex: this.currentBlockIndex,
-      type: this.currentBlockType,
+      blockId: `client_block_${index}`,
+      blockIndex: index,
+      type: "text",
       status: "complete",
       content: null,
       data: null,
       metadata: void 0
     };
+    const signature = this.signatureOf(block);
+    if (this.signatures.get(index) === signature) return;
+    this.signatures.set(index, signature);
     dispatch(this.upsertAction({ requestId: this.requestId, block }));
   }
-  openBlock(type, _dispatch) {
-    this.currentBlockIndex++;
-    this.currentBlockType = type;
-    this.currentBlockContent = "";
-    this.currentBlockLineCount = 0;
-    this.currentBlockEmitted = false;
-    this.pendingMediaData = null;
-    this.genericXmlRecoverySuppressed = false;
-    this.suppressEmptyTrailingSlot = false;
-  }
-  emitCurrentBlock(dispatch, status) {
-    if (status === "streaming" && this.subState.kind === "frontmatter") return;
-    let content = this.currentBlockContent;
-    if (status === "streaming" && this.pendingLineFragment) {
-      if (this.subState.kind === "none" || this.subState.kind === "code_fence" || this.subState.kind === "bare_json" || this.subState.kind === "generic_xml") {
-        const holdNascentJson = this.subState.kind === "none" && !this.kindLineIsProse && (!this.currentBlockContent && this.pendingLineFragment.trimStart().startsWith("{") || // A nascent array of objects waits for its first element's first
-        // key the same way (A6) — a kindless one shows once it is known.
-        /^\s*\[\s*(?:\{|$)/.test(this.pendingLineFragment) && jsonKindSignal(this.pendingLineFragment) !== "not_kind");
-        if (!holdNascentJson) {
-          content = content ? content + "\n" + this.pendingLineFragment : this.pendingLineFragment;
-        }
-      }
-    }
-    if (this.currentBlockType === "text") {
-      content = content.trimEnd();
-    }
-    if (!content && status === "streaming") return;
-    if (!content && status === "complete" && this.suppressEmptyTrailingSlot)
-      return;
-    this.emitCount++;
-    const unclosedXmlOpening = this.currentBlockType === "text" && isUnclosedGenericXmlOpening(content);
-    const block = {
-      blockId: this.currentBlockId,
-      blockIndex: this.currentBlockIndex,
-      type: unclosedXmlOpening ? "code" : this.currentBlockType,
-      status,
-      content: content || null,
-      data: unclosedXmlOpening ? { language: "xml" } : this.buildBlockData(),
-      metadata: unclosedXmlOpening ? { isComplete: false, genericXmlContainer: true } : this.buildBlockMetadata(status, content)
-    };
-    dispatch(this.upsertAction({ requestId: this.requestId, block }));
-    this.currentBlockEmitted = true;
-  }
-  /**
-   * Builds metadata for the block currently being emitted.
-   *
-   * Critical for attribute-XML tags (`<decision>`, `<artifact>`, `<editor_*>`):
-   * BlockRenderer reads `metadata.decision` / `metadata.artifactId` /
-   * `metadata.rawXml` etc. and falls back to raw-markdown rendering when those
-   * are missing — which is exactly the bug we're fixing (decision tags
-   * appearing as plain text mid-stream because metadata was hard-coded to
-   * `undefined` here previously).
-   *
-   * For simple XML tags we emit `{ isComplete, rawXml }` so consumers (loaders,
-   * inline-edit flows) can both gate on completion and round-trip the source.
-   */
-  buildBlockMetadata(status, emittedContent) {
-    const base = this.subState.kind === "generic_xml" ? (
-      // An XML TAG is structure (ruling (b), round 3): its card draws kinds as kinds.
-      { genericXmlContainer: true }
-    ) : this.buildXmlBlockMetadata(status, emittedContent);
-    if (this.currentBlockType === "matrx") {
-      return base;
-    }
-    const envelope = this.irEnvelope ?? sessionEnvelope(this.irSession);
-    if (envelope) {
-      return { ...base ?? {}, [IR_ENVELOPE_KEY]: envelope };
-    }
-    return base;
-  }
-  buildXmlBlockMetadata(status, emittedContent) {
-    if (this.subState.kind !== "xml_tag") return void 0;
-    const { tagName, attributes, isAttrXml } = this.subState;
-    const isComplete = status === "complete" && !this.regionContinuesAfterClose;
-    const rawXml = emittedContent;
-    if (tagName === "decision") {
-      const decisionId = this.currentBlockId;
-      const prompt = attributes.prompt || "Make a selection";
-      const options = parseDecisionOptions(rawXml, decisionId);
-      const decision = { id: decisionId, prompt, options };
-      return { isComplete, decision, rawXml };
-    }
-    if (tagName === "artifact") {
-      const artifactId = attributes.id || `artifact-client-${this.currentBlockIndex}`;
-      const artifactIndex = artifactId.includes("_") ? parseInt(artifactId.split("_").pop() || "0", 10) || this.currentBlockIndex : this.currentBlockIndex;
-      return {
-        isComplete,
-        artifactId,
-        artifactIndex,
-        artifactType: attributes.type || "text",
-        artifactTitle: attributes.title || "",
-        rawXml
-      };
-    }
-    if (tagName === "editor_error" || tagName === "editor_code_snippet") {
-      return {
-        isComplete,
-        ...attributes,
-        rawXml
-      };
-    }
-    if (isAttrXml) {
-      return { isComplete, ...attributes, rawXml };
-    }
-    return { isComplete, rawXml };
+  // ── Reasoning-boundary honesty ──────────────────────────────────────────
+  reportOrphanReasoningClose(text) {
+    if (this.orphanReasoningCloseReported) return;
+    this.orphanReasoningCloseReported = true;
+    const tag = /<\/(thinking|think|reasoning)\s*>/i.exec(text)?.[0] ?? "</thinking>";
+    captureError({
+      source: "reasoning-leak",
+      message: `A closing reasoning tag (${tag}) arrived with NO open reasoning region: the provider's <reasoning> wrapper is unbalanced, so this turn's chain-of-thought streamed to the reader as the answer. The tag itself was stripped from the visible content. Remedy: the wrapper is per-stream state in aidream providers/reasoning_stream_state.py \u2014 an unbalanced wrapper means a provider parser is sharing it across concurrent turns again.`,
+      requestId: this.requestId,
+      raw: { sample: text.slice(0, 500) }
+    });
   }
-  buildBlockData() {
-    if ((this.currentBlockType === "audio" || this.currentBlockType === "image" || this.currentBlockType === "video") && this.pendingMediaData) {
-      return { ...this.pendingMediaData };
-    }
-    if (this.subState.kind === "code_fence") {
-      if (this.currentBlockType !== "code") return null;
-      if (!this.subState.language && !this.subState.meta) return null;
-      return {
-        ...this.subState.language ? { language: this.subState.language } : {},
-        ...this.subState.meta ? { [FENCE_META_KEY]: this.subState.meta } : {}
-      };
-    }
-    if (this.subState.kind === "generic_xml") {
-      return { language: "xml" };
-    }
-    if (this.subState.kind === "bare_json") {
-      if (this.currentBlockType !== "code") return null;
-      return { language: "json" };
-    }
-    return null;
+  reportUnclosedReasoningRegion(tag, content) {
+    if (this.unclosedReasoningReported) return;
+    this.unclosedReasoningReported = true;
+    captureError({
+      source: "reasoning-leak",
+      message: `The stream ended INSIDE a <${tag}> region \u2014 its closing tag never arrived, so every token after the model stopped thinking (the whole visible ANSWER) is inside a thinking block and the assistant message renders empty behind a collapsed "Thought process". Remedy: the wrapper is per-stream state in aidream providers/reasoning_stream_state.py \u2014 a stranded open means a provider parser is sharing it across concurrent turns again.`,
+      requestId: this.requestId,
+      raw: { sample: content.slice(0, 500) }
+    });
   }
 }
 export {