@ai-matrx/chat 0.1.77 → 0.2.0

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

@@ -0,0 +1,1945 @@
+import { parseDecisionOptionsFromBody } from "../../../../utils/inline-decision/decision-options.js";
+import { QuotedKindLift } from "../../../../utils/content-ir/surfaces/quoted-kind-lift.js";
+import { canonicalizeCompletedLegacyQuizEnvelope } from "../../../../utils/content-ir/legacy-quiz-envelope.js";
+import { envelopeMatchesParsedSource } from "../../../../utils/content-ir/envelope-parity.js";
+import { MarkdownEscapedKindJson } from "../../../../utils/content-ir/surfaces/markdown-escaped-kind.js";
+import { KindImageAltUnwrap } from "../../../../utils/content-ir/surfaces/kind-image-alt.js";
+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 "../../../../utils/content-ir/surfaces/json-kind-signal.js";
+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 {
+  classifyLine,
+  isPlainText,
+  hasCandidate,
+  Candidate
+} from "./content-prefilter.js";
+import {
+  detectJsonBlockType,
+  parseXmlAttributes,
+  extractAudioLink,
+  detectImageMarkdown,
+  countInlineImages,
+  detectVideoMarkdown,
+  detectMatrxFileMarkdown,
+  isCompleteUnrecognizedXmlContainer,
+  isUnclosedGenericXmlOpening,
+  startUnrecognizedXmlContainer,
+  normalizeCodeLanguage,
+  isSpecialCodeLanguage,
+  kindRegistry,
+  componentRegistry,
+  envelopeForCompletedFenceRegion,
+  envelopeForCompletedXmlRegion,
+  withIrEnvelope,
+  sessionEnvelope
+} from "../../../../host/content-ir-slots.js";
+import { disposeParseSession, openParseSession } from "@ai-matrx/content-ir";
+import {
+  IR_ENVELOPE_KEY
+} from "@ai-matrx/content-ir";
+import {
+  normalizeRecoveredContainerPiece,
+  splitAroundEmbeddedKindJson
+} from "../../../../utils/content-ir/surfaces/embedded-kind-json.js";
+import { captureError } from "../../../../host/diagnostics.js";
+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 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) {
+  try {
+    const parsed = JSON.parse(text);
+    return parsed !== null && typeof parsed === "object";
+  } 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;
+  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;
+  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();
+  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(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);
+  }
+  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.
+   */
+  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();
+  }
+  /**
+   * 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.
+   */
+  rewindToBlockCount(blockCount) {
+    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.
+   */
+  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) }
+    });
+  }
+  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;
+    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({
+        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();
+            void componentRegistry.ensureWarm();
+            kindRegistry.requestSchema(event.kind);
+            componentRegistry.requestComponent(event.kind, "web", "output");
+          }
+        }
+      });
+      this.irIdentities.push(identity);
+      this.irRegionLineCount = 0;
+      this.irFedFragmentLen = 0;
+      this.irEnvelope = null;
+      this.irRegionIsXmlBody = false;
+    } 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
+    );
+    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;
+    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 }));
+      emitted++;
+      this.emitCount++;
+    }
+    this.currentBlockEmitted = emitted > 0;
+    return emitted > 0;
+  }
+  /**
+   * 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) {
+    const block = {
+      blockId: this.currentBlockId,
+      blockIndex: this.currentBlockIndex,
+      type: this.currentBlockType,
+      status: "complete",
+      content: null,
+      data: null,
+      metadata: void 0
+    };
+    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 };
+  }
+  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;
+  }
+}
+export {
+  StreamBlockAccumulator
+};