@ai-matrx/rich-content 0.0.0 → 0.2.2

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

@@ -0,0 +1,1791 @@
+import { RESERVED_PREFIX, tryDecodeDirective } from "@ai-matrx/content-ir";
+import { isJsonObject } from "../../../../utils/json.js";
+import { parseDecisionOptionsFromBody } from "../../../../utils/decision-options.js";
+import {
+  DIRECTIVE_CONTAINER_OPEN,
+  DirectiveContainerTracker
+} from "@ai-matrx/content-ir/source";
+import { TITLED_IMAGE_LINE } from "@ai-matrx/content-ir/source";
+import { continuesTable, isGfmDelimiterRow, opensTable, tableContainerIndent, tableStartsAt } from "./gfm-table-lines.js";
+import {
+  parseYouTubeUrl,
+  isYouTubeThumbnailUrl,
+  youTubeWatchUrl
+} from "../../../../utils/youtube.js";
+import {
+  recognizeOurFileUrl,
+  mightBeOurFileUrl
+} from "@ai-matrx/media/files/engine/media/our-file-sources";
+import {
+  normalizeRecoveredContainerPiece,
+  splitAroundEmbeddedKindJson
+} from "@ai-matrx/content-ir/surfaces";
+import {
+  isJsonFenceLanguage,
+  jsonKindSignal,
+  bareRegionBreaksIntoProse
+} from "@ai-matrx/content-ir/surfaces";
+import { liftQuotedKindRegions } from "@ai-matrx/content-ir/surfaces";
+import {
+  decodeDoubleEncodedKindText,
+  unescapeMarkdownKindJson
+} from "@ai-matrx/content-ir/surfaces";
+import { unwrapKindImageAlt } from "@ai-matrx/content-ir/surfaces";
+import { IR_ENVELOPE_KEY } from "@ai-matrx/content-ir";
+import { ALLOWED_RAW_HTML_TAGS } from "../../../chat-markdown/rehypeSafeRawHtml.js";
+import { isPageBreakLine } from "@ai-matrx/print/directives";
+import { readXmlTag } from "@ai-matrx/content-ir/source";
+import { FENCE_META_KEY, splitFenceInfo } from "@ai-matrx/content-ir/source";
+import {
+  closeFence,
+  fenceOpenerOf,
+  isHtmlBlockTagName,
+  XmlContainerTracker
+} from "@ai-matrx/content-ir/source";
+import { indexOutsideInlineCode } from "@ai-matrx/content-ir/source";
+import {
+  findBalancedXmlClose,
+  initialXmlBalance
+} from "@ai-matrx/content-ir/source";
+const NO_SPLITTER_ENVELOPES = {
+  withIrEnvelope: (_source, metadata) => metadata,
+  fenceRegion: () => null,
+  xmlRegion: () => null
+};
+const DIRECTIVE_HEAD_RE = new RegExp(
+  String.raw`^\{\s*"__kind"\s*:\s*"${RESERVED_PREFIX}`
+);
+function looksLikeDirectiveHead(content) {
+  return DIRECTIVE_HEAD_RE.test(content.trimStart());
+}
+function countStructuralBraces(source, open = "{", close = "}") {
+  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 === open) opens++;
+    else if (char === close) closes++;
+  }
+  return { opens, closes };
+}
+function blockHasResolvedRootKind(block) {
+  const envelope = block.metadata?.[IR_ENVELOPE_KEY];
+  if (typeof envelope !== "object" || envelope === null) return false;
+  const root = envelope.root;
+  if (typeof root !== "object" || root === null) return false;
+  const kind = root.kind;
+  return typeof kind === "string" && kind.length > 0;
+}
+function isJsonFenceBlock(block) {
+  return block.type === "code" && isJsonFenceLanguage(block.language);
+}
+function isQuotedSourceFenceBlock(block) {
+  return block.type === "code" && block.metadata?.genericXmlContainer !== true && !isJsonFenceLanguage(block.language);
+}
+function recoverEmbeddedKindJsonBlocksWith(input, envelopes) {
+  const recovered = [];
+  for (const block of input) {
+    if (block.type === "artifact" || block.type === "matrx" || block.type === "matrx_file" || // An XML TAG — closed or never closed — is STRUCTURE, not quoted
+    // source (the owner's ruling (b), round 3): a kind inside it is data
+    // and leaves the card below, exactly as the live stream lifts it. A
+    // ```xml FENCE stays quoted source (`isQuotedSourceFenceBlock`).
+    blockHasResolvedRootKind(block) || // A fence of another language (```ts, ```xml, ```markdown …) is the
+    // model QUOTING SOURCE: a kind inside it stays as written (the owner's
+    // ruling, 2026-09-30 — the same definition the leaf gate reads).
+    isQuotedSourceFenceBlock(block)) {
+      recovered.push(block);
+      continue;
+    }
+    const genericXml = block.metadata?.genericXmlContainer === true;
+    const pieces = splitAroundEmbeddedKindJson(block.content, {
+      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 && !isJsonFenceBlock(block)
+    });
+    if (pieces.length === 1 && pieces[0]?.type === "container") {
+      recovered.push(block);
+      continue;
+    }
+    let followsKind = false;
+    for (const piece of pieces) {
+      if (piece.type === "chrome") continue;
+      if (piece.type === "residual") {
+        recovered.push({
+          type: "code",
+          content: piece.json,
+          language: "json",
+          metadata: envelopes.withIrEnvelope(piece.json, void 0)
+        });
+        followsKind = false;
+        continue;
+      }
+      if (piece.type === "kind") {
+        followsKind = true;
+        if (looksLikeDirectiveHead(piece.content)) {
+          recovered.push({
+            type: "matrx",
+            content: piece.content,
+            language: "json"
+          });
+          continue;
+        }
+        recovered.push({
+          type: "code",
+          content: piece.content,
+          language: "json",
+          metadata: envelopes.withIrEnvelope(piece.content, void 0)
+        });
+        continue;
+      }
+      const content = normalizeRecoveredContainerPiece(
+        piece.content,
+        block.type,
+        followsKind
+      );
+      followsKind = false;
+      if (!content) continue;
+      recovered.push({
+        ...block,
+        content,
+        // An XML piece stays STRUCTURE (`isQuotedSourceXmlBlock`) — the card
+        // draws whatever kind it still holds as the kind.
+        metadata: genericXml ? { genericXmlContainer: true } : void 0
+      });
+    }
+  }
+  return recovered;
+}
+const SPECIAL_CODE_LANGUAGES = [
+  "transcript",
+  "tasks",
+  "structured_info",
+  "questionnaire",
+  "flashcards",
+  "cooking_recipe",
+  "mermaid",
+  "svg",
+  "chart",
+  "map",
+  "stats",
+  "diff",
+  // html + react are DELIVERABLES (a webpage / a live component), not throwaway
+  // code snippets — promote them so they materialize into persistent artifacts
+  // (render-by-id, no re-creation), unlike a bare ```code fence.
+  "html",
+  "react",
+  // A ```matrx fence carries one Matrx Envelope (reference / secret / directive
+  // / validation). Promoted to a first-class block so MatrxEnvelopeBlock renders
+  // it (chips for references, a muted card otherwise) instead of raw JSON. The
+  // in-content position only resolves reference/secret — see MATRX_REFERENCES.md.
+  "matrx"
+];
+const CODE_LANGUAGE_ALIASES = {
+  mmd: "mermaid",
+  // jsx/tsx render + materialize as a live React component (same as ```react).
+  jsx: "react",
+  tsx: "react"
+};
+function normalizeCodeLanguage(language) {
+  if (!language) return language;
+  const lower = language.toLowerCase();
+  return CODE_LANGUAGE_ALIASES[lower] ?? lower;
+}
+const JSON_BLOCK_PATTERNS = {
+  quiz: {
+    rootKey: "quiz_title",
+    validate: (parsed) => isJsonObject(parsed) && parsed.quiz_title && Array.isArray(parsed.multiple_choice) && parsed.multiple_choice.length > 0
+  },
+  presentation: {
+    rootKey: "presentation",
+    validate: (parsed) => isJsonObject(parsed) && isJsonObject(parsed.presentation) && Array.isArray(parsed.presentation.slides)
+  },
+  decision_tree: {
+    rootKey: "decision_tree",
+    validate: (parsed) => isJsonObject(parsed) && isJsonObject(parsed.decision_tree) && parsed.decision_tree.title && parsed.decision_tree.root
+  },
+  comparison_table: {
+    rootKey: "comparison",
+    validate: (parsed) => isJsonObject(parsed) && isJsonObject(parsed.comparison) && parsed.comparison.title && Array.isArray(parsed.comparison.items) && Array.isArray(parsed.comparison.criteria)
+  },
+  diagram: {
+    rootKey: "diagram",
+    validate: (parsed) => isJsonObject(parsed) && isJsonObject(parsed.diagram) && parsed.diagram.title && Array.isArray(parsed.diagram.nodes)
+  },
+  math_problem: {
+    rootKey: "math_problem",
+    validate: (parsed) => isJsonObject(parsed) && parsed.math_problem && typeof parsed.math_problem === "object"
+  },
+  // A clickable reference to a platform entity (agent, note, task, file, …).
+  // Deliberately forgiving: any object under the key with a string `type`
+  // qualifies — the renderer handles unknown types via a neutral fallback.
+  item_presentation: {
+    rootKey: "item_presentation",
+    validate: (parsed) => isJsonObject(parsed) && isJsonObject(parsed.item_presentation) && typeof parsed.item_presentation.type === "string"
+  },
+  // An output-schema proposal — what the "JSON Schema Generator" agent emits:
+  // `{ name: string, schema: object, strict?: boolean }`. Recognized so the FE
+  // can offer "Apply to an agent" (writes agent.definition.output_schema). The validate
+  // is deliberately strict (string `name` AND object `schema`) so ordinary JSON
+  // that merely begins with a "name" key never misfires into this block.
+  schema_proposal: {
+    rootKey: "name",
+    validate: (parsed) => isJsonObject(parsed) && typeof parsed.name === "string" && parsed.schema !== null && typeof parsed.schema === "object" && !Array.isArray(parsed.schema)
+  }
+};
+function extractFirstJsonKey(content) {
+  const match = content.trimStart().match(/^\{\s*"([^"]+)"/);
+  return match ? match[1] : null;
+}
+function detectJsonBlockType(content) {
+  const trimmed = content.trim();
+  if (trimmed.startsWith("{")) {
+    try {
+      const parsed = JSON.parse(trimmed);
+      if (tryDecodeDirective(parsed)) return "matrx";
+    } catch {
+    }
+  }
+  if (looksLikeDirectiveHead(content)) return "matrx";
+  const firstKey = extractFirstJsonKey(content);
+  if (!firstKey) return null;
+  if (firstKey === "matrx_version") return "matrx";
+  for (const [type, pattern] of Object.entries(JSON_BLOCK_PATTERNS)) {
+    if (pattern.rootKey === firstKey) {
+      return type;
+    }
+  }
+  return null;
+}
+function containsPlaceholderText(content) {
+  return /\[\s*(array|object|string|number|boolean|description|example|etc|list|item)[^\]]*\]/i.test(
+    content
+  ) || /:\s*"?\[?(array|list) of /i.test(content) || /:\s*"?object with /i.test(content) || /:\s*"?<[a-z_]+>/i.test(content) || /:\s*"?\.\.\."?/.test(content);
+}
+function validateJsonBlock(content, type) {
+  if (type === "matrx") {
+    let trimmed2 = content.trim();
+    trimmed2 = trimmed2.replace(/```+\s*$/, "").trim();
+    try {
+      const parsed = JSON.parse(trimmed2);
+      if (tryDecodeDirective(parsed)) {
+        return { isComplete: true, shouldShow: true };
+      }
+    } catch {
+    }
+    return {
+      isComplete: false,
+      shouldShow: looksLikeDirectiveHead(trimmed2) || extractFirstJsonKey(trimmed2) === "matrx_version"
+    };
+  }
+  let trimmed = content.trim();
+  trimmed = trimmed.replace(/```+\s*$/, "").trim();
+  if (containsPlaceholderText(trimmed)) {
+    return { isComplete: false, shouldShow: false };
+  }
+  try {
+    const parsed = JSON.parse(trimmed);
+    const pattern = JSON_BLOCK_PATTERNS[type];
+    const isValid = pattern.validate(parsed);
+    if (isValid) {
+      return {
+        isComplete: true,
+        shouldShow: true,
+        metadata: { isComplete: true }
+      };
+    }
+    return {
+      isComplete: true,
+      shouldShow: false,
+      metadata: { isComplete: true }
+    };
+  } catch (error) {
+  }
+  const { opens: openBraces, closes: closeBraces } = countStructuralBraces(trimmed);
+  if (openBraces > closeBraces) {
+    return { isComplete: false, shouldShow: false };
+  }
+  if (trimmed.endsWith("}") && openBraces === closeBraces) {
+    return {
+      isComplete: true,
+      shouldShow: false,
+      metadata: { isComplete: true }
+    };
+  }
+  if (closeBraces > openBraces) {
+    return {
+      isComplete: true,
+      shouldShow: false,
+      metadata: { isComplete: true }
+    };
+  }
+  return { isComplete: false, shouldShow: false };
+}
+const questionnaireCache = /* @__PURE__ */ new Map();
+const flashcardCache = /* @__PURE__ */ new Map();
+const recipeCache = /* @__PURE__ */ new Map();
+const tableCache = /* @__PURE__ */ new Map();
+const XML_TAG_BLOCKS = {
+  thinking: ["<thinking>", "<think>"],
+  reasoning: ["<reasoning>"],
+  info: ["<info>"],
+  task: ["<task>"],
+  database: ["<database>"],
+  private: ["<private>"],
+  plan: ["<plan>"],
+  event: ["<event>"],
+  tool: ["<tool>"],
+  questionnaire: ["<questionnaire>"],
+  flashcards: ["<flashcards>"],
+  cooking_recipe: ["<cooking_recipe>"],
+  timeline: ["<timeline>"],
+  progress_tracker: ["<progress_tracker>"],
+  troubleshooting: ["<troubleshooting>"],
+  resources: ["<resources>"],
+  research: ["<research>"]
+};
+const ATTRIBUTE_XML_BLOCKS = [
+  "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.
+  "editor_error",
+  "editor_code_snippet",
+  // Audio citation — an agent reference to a moment in a scribe session's audio.
+  // `start`/`end` are session-relative seconds; the body is the cited label.
+  // Emitted mid-sentence (handled by detectMidLineAttributeXml), so a reply can
+  // cite the audio inline like a footnote.
+  "audiocite"
+];
+const KNOWN_XML_TAG_NAMES = /* @__PURE__ */ new Set([
+  ...Object.values(XML_TAG_BLOCKS).flatMap(
+    (tags) => tags.map((tag) => tag.slice(1, -1))
+  ),
+  ...ATTRIBUTE_XML_BLOCKS
+]);
+function parseXmlAttributes(openingTag) {
+  const attrs = {};
+  const attrRegex = /(\w+)\s*=\s*"([^"]*)"/g;
+  let match;
+  while ((match = attrRegex.exec(openingTag)) !== null) {
+    attrs[match[1]] = match[2];
+  }
+  return attrs;
+}
+function detectAttributeXmlBlock(line) {
+  const trimmed = line.trim();
+  for (const type of ATTRIBUTE_XML_BLOCKS) {
+    const prefix = `<${type}`;
+    if (trimmed.startsWith(prefix) && (trimmed[prefix.length] === " " || trimmed[prefix.length] === ">")) {
+      const closeBracket = trimmed.indexOf(">");
+      if (closeBracket === -1) return null;
+      const fullOpeningTag = trimmed.slice(0, closeBracket + 1);
+      const attributes = parseXmlAttributes(fullOpeningTag);
+      return { type, fullOpeningTag, attributes };
+    }
+  }
+  return null;
+}
+function detectMidLineAttributeXml(line) {
+  for (const type of ATTRIBUTE_XML_BLOCKS) {
+    const prefix = `<${type}`;
+    const idx = indexOutsideInlineCode(line, prefix);
+    if (idx === -1) continue;
+    if (line.trimStart().startsWith(prefix)) continue;
+    const afterPrefix = line[idx + prefix.length];
+    if (afterPrefix !== " " && afterPrefix !== ">") continue;
+    const closeBracket = line.indexOf(">", idx);
+    if (closeBracket === -1) continue;
+    const fullOpeningTag = line.slice(idx, closeBracket + 1);
+    const attributes = parseXmlAttributes(fullOpeningTag);
+    return { tagStart: idx, type, fullOpeningTag, attributes };
+  }
+  return null;
+}
+function extractAttributeXmlBlock(detection, startIndex, lines, rawXmlOverride) {
+  const closingTag = `</${detection.type}>`;
+  const rawLines = [];
+  const consumedLines = [];
+  let i = startIndex;
+  let foundClosingTag = false;
+  const firstLine = normalizeLine(lines[i]).trim();
+  consumedLines.push(lines[i]);
+  const afterOpening = firstLine.slice(firstLine.indexOf(">") + 1);
+  if (afterOpening.includes(closingTag)) {
+    const closingIdx = afterOpening.indexOf(closingTag);
+    const inner = afterOpening.slice(0, closingIdx).trim();
+    if (inner) rawLines.push(inner);
+    const remainderAfterClose = afterOpening.slice(closingIdx + closingTag.length).trim();
+    foundClosingTag = true;
+    i++;
+    if (remainderAfterClose) {
+      lines.splice(i, 0, remainderAfterClose);
+    }
+  } else {
+    if (afterOpening.trim()) rawLines.push(afterOpening.trim());
+    i++;
+    while (i < lines.length) {
+      const current = normalizeLine(lines[i]).trim();
+      const closingIdx = current.indexOf(closingTag);
+      if (closingIdx !== -1) {
+        const before = current.slice(0, closingIdx).trim();
+        if (before) rawLines.push(before);
+        const originalLine = lines[i];
+        const originalClosingIdx = originalLine.indexOf(closingTag);
+        consumedLines.push(
+          originalClosingIdx !== -1 ? originalLine.slice(0, originalClosingIdx + closingTag.length) : originalLine
+        );
+        const remainderAfterClose = current.slice(closingIdx + closingTag.length).trim();
+        foundClosingTag = true;
+        i++;
+        if (remainderAfterClose) {
+          lines.splice(i, 0, remainderAfterClose);
+        }
+        break;
+      }
+      if (current === closingTag) {
+        consumedLines.push(lines[i]);
+        foundClosingTag = true;
+        i++;
+        break;
+      }
+      consumedLines.push(lines[i]);
+      rawLines.push(lines[i]);
+      i++;
+    }
+  }
+  const innerContent = rawLines.join("\n");
+  const fullXml = rawXmlOverride ?? consumedLines.join("\n");
+  if (detection.type === "editor_error" || detection.type === "editor_code_snippet" || detection.type === "audiocite") {
+    return {
+      content: innerContent,
+      nextIndex: i,
+      metadata: {
+        isComplete: foundClosingTag,
+        ...detection.attributes,
+        rawXml: fullXml
+      }
+    };
+  }
+  if (detection.type === "artifact") {
+    const artifactId = detection.attributes.id || `artifact-${startIndex}`;
+    const artifactIndex = artifactId.includes("_") ? parseInt(artifactId.split("_").pop() || "0", 10) : startIndex;
+    const parsedVersion = detection.attributes.version ? parseInt(detection.attributes.version, 10) : void 0;
+    return {
+      content: innerContent,
+      nextIndex: i,
+      metadata: {
+        isComplete: foundClosingTag,
+        artifactId,
+        artifactIndex,
+        artifactType: detection.attributes.type || "text",
+        artifactTitle: detection.attributes.title || "",
+        ...typeof parsedVersion === "number" && Number.isFinite(parsedVersion) ? { version: parsedVersion } : {},
+        rawXml: fullXml
+      }
+    };
+  }
+  const options = parseDecisionOptionsFromBody(innerContent).map(
+    (o) => ({ id: o.id, label: o.label, text: o.text })
+  );
+  const prompt = detection.attributes.prompt || "Make a selection";
+  const decision = {
+    id: `decision-${startIndex}`,
+    prompt,
+    options
+  };
+  return {
+    content: innerContent,
+    nextIndex: i,
+    metadata: {
+      isComplete: foundClosingTag,
+      decision,
+      rawXml: fullXml
+    }
+  };
+}
+function detectXmlBlockType(line) {
+  const trimmed = line.trim();
+  for (const [type, tags] of Object.entries(XML_TAG_BLOCKS)) {
+    const matchedTag = tags.find(
+      (tag) => trimmed === tag || trimmed.startsWith(tag)
+    );
+    if (matchedTag) {
+      return { type, matchedTag };
+    }
+    const bare = tags[0].slice(0, -1);
+    if (trimmed.startsWith(`${bare} `)) {
+      const close = trimmed.indexOf(">");
+      if (close !== -1) {
+        return {
+          type,
+          matchedTag: trimmed.slice(0, close + 1)
+        };
+      }
+    }
+  }
+  return null;
+}
+function xmlTagNameOf(matchedTag) {
+  return /^<([\w-]+)/.exec(matchedTag)?.[1] ?? matchedTag.slice(1, -1);
+}
+function isHtmlOrKnownTag(name) {
+  return KNOWN_XML_TAG_NAMES.has(name) || ALLOWED_RAW_HTML_TAGS.has(name.toLowerCase());
+}
+function leadingTagName(line) {
+  return /^<([A-Za-z_][\w.:-]*)/.exec(line.trimStart())?.[1] ?? null;
+}
+function isUnclosedGenericXmlOpening(source) {
+  if (isPageBreakLine(source)) return false;
+  const text = source.trimStart();
+  const prefix = /^<([A-Za-z_][\w.:-]*)(?=\s|\/|$)/.exec(text);
+  if (!prefix || isHtmlOrKnownTag(prefix[1])) return false;
+  let quote = null;
+  for (let i = prefix[0].length; i < text.length; i++) {
+    if (quote) {
+      if (text[i] === quote) quote = null;
+    } else if (text[i] === "'" || text[i] === '"') quote = text[i];
+    else if (text[i] === ">") return false;
+  }
+  return true;
+}
+function startUnrecognizedXmlContainer(line) {
+  if (isPageBreakLine(line)) return null;
+  const firstTrimmed = line.trimStart();
+  if (!firstTrimmed.startsWith("<")) return null;
+  const openingTag = readXmlTag(firstTrimmed, 0);
+  if (!openingTag || openingTag.isClosing) return null;
+  const rootTag = openingTag.tagName;
+  if (isHtmlOrKnownTag(rootTag)) return null;
+  return {
+    tracker: new XmlContainerTracker(rootTag),
+    rootStart: line.length - firstTrimmed.length
+  };
+}
+function extractUnrecognizedXmlBlock(startIndex, lines) {
+  const firstLine = normalizeLine(lines[startIndex]);
+  const start = startUnrecognizedXmlContainer(firstLine);
+  if (!start) return null;
+  const { tracker, rootStart } = start;
+  for (let lineIndex = startIndex; lineIndex < lines.length; lineIndex++) {
+    const currentLine = normalizeLine(lines[lineIndex]);
+    const rootEnd = tracker.consumeLine(
+      currentLine,
+      lineIndex === startIndex ? rootStart : 0
+    );
+    if (rootEnd === null) continue;
+    const contentLines = lineIndex === startIndex ? [currentLine.slice(rootStart, rootEnd)] : [
+      firstLine.slice(rootStart),
+      ...lines.slice(startIndex + 1, lineIndex).map(normalizeLine),
+      currentLine.slice(0, rootEnd)
+    ];
+    const remainder = currentLine.slice(rootEnd).trim();
+    if (remainder) lines.splice(lineIndex + 1, 0, remainder);
+    return {
+      content: contentLines.join("\n").trim(),
+      nextIndex: lineIndex + 1,
+      metadata: { isComplete: true, genericXmlContainer: true }
+    };
+  }
+  return null;
+}
+function isCompleteUnrecognizedXmlContainer(source) {
+  const lines = source.split(/\r?\n/);
+  const extraction = extractUnrecognizedXmlBlock(0, [...lines]);
+  return extraction !== null && extraction.nextIndex >= lines.length;
+}
+const THINKING_OPENERS = {
+  thinking: ["<thinking>", "<think>"],
+  reasoning: ["<reasoning>"]
+};
+function detectOrphanThinkingClose(trimmedLine) {
+  const CLOSERS = [
+    ["thinking", "</thinking>"],
+    ["thinking", "</think>"],
+    ["reasoning", "</reasoning>"]
+  ];
+  for (const [type, closer] of CLOSERS) {
+    const idx = indexOutsideInlineCode(trimmedLine, closer);
+    if (idx === -1) continue;
+    return {
+      type,
+      before: trimmedLine.slice(0, idx).trim(),
+      remainder: trimmedLine.slice(idx + closer.length).trim()
+    };
+  }
+  return null;
+}
+function extractXmlBlock(type, matchedTag, startIndex, lines, trackFences = true) {
+  const content = [];
+  let i = startIndex;
+  let foundClosingTag = false;
+  const balance = initialXmlBalance();
+  let remainderAfterClose = "";
+  const tagName = xmlTagNameOf(matchedTag);
+  const closingTag = `</${tagName}>`;
+  const firstLine = lines[i];
+  const processedFirst = normalizeLine(firstLine).trim();
+  if (processedFirst.startsWith(matchedTag)) {
+    const afterTag = processedFirst.slice(matchedTag.length);
+    const closingIdx = afterTag.indexOf(closingTag);
+    if (closingIdx !== -1) {
+      const beforeClosing = afterTag.slice(0, closingIdx).trim();
+      if (beforeClosing) content.push(beforeClosing);
+      remainderAfterClose = afterTag.slice(closingIdx + closingTag.length).trim();
+      foundClosingTag = true;
+      i++;
+      if (remainderAfterClose) {
+        lines.splice(i, 0, remainderAfterClose);
+      }
+      const fullContent2 = content.join("\n");
+      const result2 = validateStreamingXmlBlock(
+        type,
+        fullContent2,
+        foundClosingTag
+      );
+      return {
+        content: result2.content || fullContent2,
+        nextIndex: i,
+        metadata: result2.metadata
+      };
+    }
+    const afterTagTrimmed = afterTag.trim();
+    if (afterTagTrimmed) content.push(afterTagTrimmed);
+    i++;
+  }
+  while (i < lines.length) {
+    const currentTrimmed = normalizeLine(lines[i]).trim();
+    const closingIdx = findBalancedXmlClose(currentTrimmed, tagName, balance, {
+      trackFences
+    });
+    if (closingIdx !== -1) {
+      const beforeClosing = currentTrimmed.slice(0, closingIdx).trim();
+      if (beforeClosing) content.push(beforeClosing);
+      remainderAfterClose = currentTrimmed.slice(closingIdx + closingTag.length).trim();
+      foundClosingTag = true;
+      i++;
+      if (remainderAfterClose) {
+        lines.splice(i, 0, remainderAfterClose);
+      }
+      break;
+    }
+    if (type === "thinking" && currentTrimmed.startsWith("### I have everything")) {
+      content.push(lines[i]);
+      i++;
+      break;
+    }
+    content.push(lines[i]);
+    i++;
+  }
+  if (!foundClosingTag && trackFences && balance.fence !== null) {
+    return extractXmlBlock(type, matchedTag, startIndex, lines, false);
+  }
+  const fullContent = content.join("\n");
+  const result = validateStreamingXmlBlock(type, fullContent, foundClosingTag);
+  return {
+    content: result.content || fullContent,
+    nextIndex: i,
+    metadata: result.metadata
+  };
+}
+function validateStreamingXmlBlock(type, content, foundClosingTag) {
+  if (!["questionnaire", "flashcards", "cooking_recipe"].includes(type)) {
+    return {
+      content,
+      metadata: { isComplete: foundClosingTag }
+    };
+  }
+  if (type === "questionnaire") {
+    return validateQuestionnaireStreaming(content, foundClosingTag);
+  }
+  if (type === "flashcards") {
+    return validateFlashcardStreaming(content, foundClosingTag);
+  }
+  if (type === "cooking_recipe") {
+    return validateRecipeStreaming(content, foundClosingTag);
+  }
+  return {
+    content,
+    metadata: { isComplete: foundClosingTag }
+  };
+}
+function validateQuestionnaireStreaming(content, foundClosingTag) {
+  const lines = content.split("\n");
+  const completeQuestions = [];
+  let currentQuestion = [];
+  let totalQuestions = 0;
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i].trim();
+    if (line.match(/^###\s+\*\*Q\d+:/) || line.match(/^###\s+Q\d+:/) || line.match(/^\*\*Q\d+:/)) {
+      totalQuestions++;
+      if (currentQuestion.length > 0) {
+        completeQuestions.push(currentQuestion.join("\n"));
+      }
+      currentQuestion = [lines[i]];
+    } else if (line === "---") {
+      currentQuestion.push(lines[i]);
+      if (currentQuestion.length > 1) {
+        completeQuestions.push(currentQuestion.join("\n"));
+      }
+      currentQuestion = [];
+    } else if (currentQuestion.length > 0 || line.length > 0) {
+      currentQuestion.push(lines[i]);
+    }
+  }
+  if (foundClosingTag && currentQuestion.length > 0) {
+    completeQuestions.push(currentQuestion.join("\n"));
+  }
+  const contentHash = `${completeQuestions.length}-${foundClosingTag}`;
+  const cacheKey = `questionnaire-${contentHash}`;
+  let contentToRelease = foundClosingTag ? content : completeQuestions.join("\n\n---\n\n");
+  const cached = questionnaireCache.get(cacheKey);
+  if (cached && cached.content === contentToRelease) {
+    return cached;
+  }
+  const result = {
+    content: contentToRelease,
+    metadata: {
+      isComplete: foundClosingTag,
+      completeQuestionCount: completeQuestions.length,
+      totalQuestions,
+      hasPartialContent: !foundClosingTag && currentQuestion.length > 0
+    }
+  };
+  questionnaireCache.set(cacheKey, {
+    content: contentToRelease,
+    hash: contentHash,
+    metadata: result.metadata
+  });
+  return result;
+}
+function validateFlashcardStreaming(content, foundClosingTag) {
+  const lines = content.split("\n");
+  const completeCards = [];
+  let currentCard = [];
+  let totalCards = 0;
+  let hasFront = false;
+  let hasBack = false;
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i].trim();
+    if (line.match(/^(?:Front|Question):/i)) {
+      if (currentCard.length > 0 && hasFront && hasBack) {
+        completeCards.push(currentCard.join("\n"));
+      }
+      currentCard = [lines[i]];
+      hasFront = true;
+      hasBack = false;
+      totalCards++;
+    } else if (line.match(/^(?:Back|Answer):/i)) {
+      currentCard.push(lines[i]);
+      hasBack = true;
+    } else if (line === "---") {
+      if (currentCard.length > 0 && hasFront && hasBack) {
+        completeCards.push(currentCard.join("\n"));
+      }
+      currentCard = [];
+      hasFront = false;
+      hasBack = false;
+    } else if (currentCard.length > 0) {
+      currentCard.push(lines[i]);
+    }
+  }
+  if (foundClosingTag && currentCard.length > 0 && hasFront && hasBack) {
+    completeCards.push(currentCard.join("\n"));
+  }
+  const contentHash = `${completeCards.length}-${foundClosingTag}`;
+  const cacheKey = `flashcards-${contentHash}`;
+  let contentToRelease = foundClosingTag ? content : completeCards.join("\n\n---\n\n");
+  const cached = flashcardCache.get(cacheKey);
+  if (cached && cached.content === contentToRelease) {
+    return cached;
+  }
+  const result = {
+    content: contentToRelease,
+    metadata: {
+      isComplete: foundClosingTag,
+      completeCardCount: completeCards.length,
+      totalCards,
+      hasPartialContent: !foundClosingTag && currentCard.length > 0
+    }
+  };
+  flashcardCache.set(cacheKey, {
+    content: contentToRelease,
+    hash: contentHash,
+    metadata: result.metadata
+  });
+  return result;
+}
+function validateRecipeStreaming(content, foundClosingTag) {
+  const hasTitle = /^###\s+.+$/m.test(content);
+  const hasIngredients = /####\s*Ingredients?:/i.test(content);
+  const hasInstructions = /####\s*Instructions?:/i.test(content);
+  const contentLength = content.length;
+  const contentHash = `${contentLength}-${foundClosingTag}-${hasTitle}-${hasIngredients}-${hasInstructions}`;
+  const cacheKey = `cooking_recipe-${contentHash}`;
+  let contentToRelease = "";
+  if (foundClosingTag) {
+    contentToRelease = content;
+  } else if (hasTitle && (hasIngredients || hasInstructions)) {
+    contentToRelease = content;
+  }
+  const cached = recipeCache.get(cacheKey);
+  if (cached && cached.content === contentToRelease) {
+    return cached;
+  }
+  const result = {
+    content: contentToRelease,
+    metadata: {
+      isComplete: foundClosingTag,
+      hasTitle,
+      hasIngredients,
+      hasInstructions,
+      hasPartialContent: !foundClosingTag && contentLength > 0
+    }
+  };
+  recipeCache.set(cacheKey, {
+    content: contentToRelease,
+    hash: contentHash,
+    metadata: result.metadata
+  });
+  return result;
+}
+function detectCodeBlock(line) {
+  const opener = fenceOpenerOf(line);
+  if (!opener) {
+    return { isCodeBlock: false };
+  }
+  const trimmed = line.trim();
+  const ticks = opener.ticks;
+  const { language, meta } = splitFenceInfo(trimmed.slice(ticks));
+  return { isCodeBlock: true, language, meta, ticks, char: opener.char };
+}
+function jsonLineForFenceReader(line) {
+  if (line.includes("```")) return line;
+  let inString = false;
+  let escaped = false;
+  for (let i = 0; i < line.length; i++) {
+    const ch = line[i];
+    if (escaped) escaped = false;
+    else if (ch === "\\" && inString) escaped = true;
+    else if (ch === '"') inString = !inString;
+  }
+  if (!inString) return line;
+  return escaped ? `${line}x"` : `${line}"`;
+}
+function extractCodeBlock(language, openTicks, startIndex, lines, fenceChar = "`") {
+  const jsonBody = fenceChar === "`" && (language ?? "") === "json";
+  const end = closeFence(
+    { count: lines.length, line: (k) => jsonBody ? jsonLineForFenceReader(lines[k] ?? "") : lines[k] ?? "" },
+    startIndex - 1,
+    { char: fenceChar, ticks: openTicks, lang: language ?? "" }
+  );
+  if (!end.closed) {
+    return {
+      content: lines.slice(startIndex).join("\n"),
+      nextIndex: lines.length + 1,
+      metadata: { language },
+      closedCleanly: false
+    };
+  }
+  const closer = lines[end.line] ?? "";
+  const bare = fenceOpenerOf(closer)?.char === fenceChar;
+  const before = bare ? "" : closer.slice(0, closer.indexOf("`".repeat(3)));
+  const body = lines.slice(startIndex, end.line);
+  if (before.trim()) body.push(before);
+  return {
+    content: body.join("\n"),
+    nextIndex: end.line + 1,
+    metadata: { language },
+    closedCleanly: bare
+  };
+}
+function isTableSeparator(line) {
+  return isGfmDelimiterRow(normalizeLine(line).trim());
+}
+function detectTableStart(lines, index) {
+  return opensTable(lines, index);
+}
+function extractTable(startIndex, lines) {
+  const tableLines = [lines[startIndex]];
+  let i = startIndex + 1;
+  const container = tableContainerIndent(lines, startIndex);
+  while (i < lines.length && (continuesTable(normalizeLine(lines[i]), container) || i === startIndex + 1 && isTableSeparator(lines[i]))) {
+    tableLines.push(lines[i]);
+    i++;
+  }
+  const stillArriving = startIndex + 2 >= lines.length && tableLines.length >= 2 && isTableSeparator(tableLines[1]);
+  if (tableLines.length < 2 || !(tableStartsAt(lines, startIndex) || stillArriving)) {
+    return {
+      content: "",
+      nextIndex: startIndex + 1,
+      metadata: { isValid: false }
+    };
+  }
+  const tableHasEnded = i < lines.length;
+  const result = analyzeTableCompletionWithCache(tableLines, tableHasEnded);
+  return {
+    content: result.content,
+    nextIndex: i,
+    metadata: result.metadata
+  };
+}
+function analyzeTableCompletionWithCache(tableLines, tableHasEnded) {
+  if (tableLines.length < 2) {
+    return {
+      content: "",
+      metadata: { isComplete: false, completeRowCount: 0 }
+    };
+  }
+  const headerHash = tableLines.slice(0, 2).join("|").replace(/\s+/g, "");
+  const rowCount = tableLines.length;
+  const cacheKey = `table-${headerHash}-${rowCount}-${tableHasEnded}`;
+  const state = analyzeTableCompletion(tableLines, tableHasEnded);
+  const contentToRelease = tableLines.join("\n");
+  const cached = tableCache.get(cacheKey);
+  if (cached && cached.content === contentToRelease) {
+    return cached;
+  }
+  const result = {
+    content: contentToRelease,
+    metadata: {
+      cacheKey,
+      isComplete: state.isComplete,
+      completeRowCount: state.completeRowCount,
+      totalRows: state.totalRows,
+      hasPartialContent: state.bufferRow.length > 0
+    }
+  };
+  tableCache.set(cacheKey, {
+    content: contentToRelease,
+    hash: `${state.completeRowCount}-${state.isComplete}-${rowCount}`,
+    metadata: result.metadata
+  });
+  return result;
+}
+function analyzeTableCompletion(tableLines, tableHasEnded) {
+  if (tableLines.length < 3) {
+    return {
+      isComplete: false,
+      completeRowCount: 0,
+      totalRows: 0,
+      bufferRow: ""
+    };
+  }
+  const dataLines = tableLines.slice(2);
+  const completeRows = [];
+  let bufferRow = "";
+  for (let i = 0; i < dataLines.length; i++) {
+    const line = dataLines[i];
+    const trimmedLine = normalizeLine(line).trim();
+    if (continuesTable(trimmedLine)) {
+      const isCompleteRow = tableHasEnded || i < dataLines.length - 1;
+      if (isCompleteRow) {
+        completeRows.push(line);
+      } else {
+        bufferRow = line;
+      }
+    }
+  }
+  return {
+    isComplete: tableHasEnded || bufferRow.length === 0,
+    completeRowCount: completeRows.length,
+    totalRows: dataLines.length,
+    bufferRow
+  };
+}
+function detectImageMarkdown(line) {
+  const trimmed = line.trim();
+  const standardMatch = trimmed.match(
+    /^!\[(.*?)\]\((https?:\/\/[^\s)]+)(?:\s+(?:"[^"]*"|'[^']*'))?\)/
+  );
+  const customMatch = trimmed.match(/\[Image URL: (https?:\/\/[^\s\]]+)\]/);
+  if (standardMatch) {
+    return { isImage: true, alt: standardMatch[1], src: standardMatch[2] };
+  }
+  if (customMatch) {
+    return { isImage: true, alt: "Image", src: customMatch[1] };
+  }
+  return { isImage: false };
+}
+function countInlineImages(line) {
+  const re = /!\[(.*?)\]\((https?:\/\/[^\s)]+)(?:\s+(?:"[^"]*"|'[^']*'))?\)/g;
+  let count = 0;
+  while (re.exec(line) !== null) count++;
+  return count;
+}
+function detectVideoMarkdown(line) {
+  const trimmed = line.trim();
+  const customMatch = trimmed.match(/\[Video URL: (https?:\/\/[^\s\]]+)\]/);
+  if (customMatch) {
+    return { isVideo: true, alt: "Video", src: customMatch[1] };
+  }
+  return { isVideo: false };
+}
+const AUDIO_URL_EXT = /\.(mp3|wav|m4a|aac|ogg|oga|opus|flac|weba|webm)(\?[^\s)]*)?$/i;
+function extractAudioLink(line) {
+  const trimmed = line.trim();
+  const customMatch = trimmed.match(/\[Audio URL:\s*(https?:\/\/[^\s\]]+)\]/);
+  if (customMatch) {
+    return { src: customMatch[1], alt: "Audio" };
+  }
+  const linkMatch = trimmed.match(/^!?\[(.*?)\]\((https?:\/\/[^\s)]+)\)$/);
+  if (linkMatch && AUDIO_URL_EXT.test(linkMatch[2])) {
+    return { src: linkMatch[2], alt: linkMatch[1] || "Audio" };
+  }
+  if (/^https?:\/\/[^\s)]+$/.test(trimmed) && AUDIO_URL_EXT.test(trimmed)) {
+    return { src: trimmed, alt: "Audio" };
+  }
+  return null;
+}
+function detectAudioMarkdown(line) {
+  const audio = extractAudioLink(line);
+  if (audio) {
+    return { isAudio: true, src: audio.src, alt: audio.alt };
+  }
+  return { isAudio: false };
+}
+function trimEmphasisEnd(text) {
+  return text.replace(/(?:\*\*|\*|_){1,2}\s*$/, "");
+}
+function trimEmphasisStart(text) {
+  return text.replace(/^\s*(?:\*\*|\*|_){1,2}/, "");
+}
+function detectMatrxFileMarkdown(line) {
+  if (!mightBeOurFileUrl(line)) return { isMatrxFile: false };
+  const linkRe = /!?\[([^\]]*)\]\((https?:\/\/[^\s)]+)\)/g;
+  let m;
+  while ((m = linkRe.exec(line)) !== null) {
+    const url = m[2];
+    if (recognizeOurFileUrl(url)) {
+      const start = m.index;
+      const end = m.index + m[0].length;
+      return {
+        isMatrxFile: true,
+        url,
+        label: m[1] || "",
+        pre: trimEmphasisEnd(line.slice(0, start)),
+        post: trimEmphasisStart(line.slice(end))
+      };
+    }
+  }
+  const bareRe = /(https?:\/\/[^\s)]+)/g;
+  while ((m = bareRe.exec(line)) !== null) {
+    const url = m[1].replace(/[).,;]+$/, "");
+    if (recognizeOurFileUrl(url)) {
+      const start = m.index;
+      const end = m.index + url.length;
+      return {
+        isMatrxFile: true,
+        url,
+        label: "",
+        pre: trimEmphasisEnd(line.slice(0, start)),
+        post: trimEmphasisStart(line.slice(end))
+      };
+    }
+  }
+  return { isMatrxFile: false };
+}
+function detectYoutubeMarkdown(line) {
+  const trimmed = line.trim();
+  const linkedThumb = trimmed.match(
+    /^\[!\[(.*?)\]\((https?:\/\/[^\s)]+?)\)\]\((https?:\/\/[^\s)]+?)\)$/
+  );
+  if (linkedThumb) {
+    const parsed = parseYouTubeUrl(linkedThumb[3]);
+    if (parsed) {
+      return {
+        isYoutube: true,
+        videoId: parsed.videoId,
+        start: parsed.start,
+        title: linkedThumb[1] || void 0,
+        poster: isYouTubeThumbnailUrl(linkedThumb[2]) ? linkedThumb[2] : void 0,
+        watchUrl: youTubeWatchUrl(parsed.videoId, parsed.start)
+      };
+    }
+  }
+  const plainLink = trimmed.match(/^\[([^\]]*)\]\((https?:\/\/[^\s)]+?)\)$/);
+  if (plainLink) {
+    const parsed = parseYouTubeUrl(plainLink[2]);
+    if (parsed) {
+      return {
+        isYoutube: true,
+        videoId: parsed.videoId,
+        start: parsed.start,
+        title: plainLink[1] || void 0,
+        watchUrl: youTubeWatchUrl(parsed.videoId, parsed.start)
+      };
+    }
+  }
+  if (/^https?:\/\/\S+$/.test(trimmed)) {
+    const parsed = parseYouTubeUrl(trimmed);
+    if (parsed) {
+      return {
+        isYoutube: true,
+        videoId: parsed.videoId,
+        start: parsed.start,
+        watchUrl: youTubeWatchUrl(parsed.videoId, parsed.start)
+      };
+    }
+  }
+  return { isYoutube: false };
+}
+const TREE_CHARS = /[├└│┌┐┘┬┴┤┼─]/;
+const ASCII_TREE_PATTERNS = /^[\s│|]*(?:[├└]|[+|][─-])/;
+function isTreeLine(line) {
+  if (!line) return false;
+  if (TREE_CHARS.test(line)) return true;
+  return ASCII_TREE_PATTERNS.test(line) && !isGfmDelimiterRow(line);
+}
+function isMarkdownHeadingLine(line) {
+  return /^#{1,6}\s/.test(line.trim());
+}
+function findTreeBlockStart(lines, firstTreeIndex) {
+  let start = firstTreeIndex;
+  for (let j = firstTreeIndex - 1; j >= 0; j--) {
+    const trimmed = normalizeLine(lines[j]).trim();
+    if (!trimmed) break;
+    if (isTreeLine(trimmed)) break;
+    if (isMarkdownHeadingLine(trimmed)) break;
+    start = j;
+  }
+  return start;
+}
+function stripAccumulatedLinesFromText(text, rawLines, fromIndex, toIndex) {
+  let result = text;
+  for (let j = fromIndex; j < toIndex; j++) {
+    const processed = normalizeLine(rawLines[j]);
+    if (result.endsWith(processed + "\n")) {
+      result = result.slice(0, -(processed.length + 1));
+    } else if (result.endsWith(processed)) {
+      result = result.slice(0, -processed.length);
+    }
+  }
+  return result;
+}
+function normalizeLine(text) {
+  return text.trim() === "" ? "" : text;
+}
+function frontMatterLineCount(lines) {
+  const opener = lines[0]?.replace(/^\uFEFF/, "");
+  if (lines.length < 2 || opener !== "---" && opener !== "+++") return 0;
+  for (let k = 1; k < lines.length; k++) {
+    if (lines[k] === opener || opener === "---" && lines[k] === "...") return k + 1;
+  }
+  return 0;
+}
+const splitContentIntoBlocksWith = (mdContent, envelopes) => {
+  const blocks = [];
+  const lines = liftQuotedKindRegions(
+    unwrapKindImageAlt(unescapeMarkdownKindJson(decodeDoubleEncodedKindText(mdContent)))
+  ).split(/\r?\n/);
+  let currentText = "";
+  let i = 0;
+  const pendingRawXmlOverrides = /* @__PURE__ */ new Map();
+  const frontMatterLines = frontMatterLineCount(lines);
+  if (frontMatterLines > 0) {
+    currentText = lines.slice(0, frontMatterLines).map(normalizeLine).join("\n") + (frontMatterLines < lines.length ? "\n" : "");
+    i = frontMatterLines;
+  }
+  while (i < lines.length) {
+    const line = lines[i];
+    const processedLine = normalizeLine(line);
+    const trimmedLine = processedLine.trim();
+    if (/^\*\s*\*\s*\*\s*$/.test(trimmedLine)) {
+      if (currentText.trim()) {
+        blocks.push({ type: "text", content: currentText.trimEnd() });
+        currentText = "";
+      }
+      blocks.push({ type: "accent-divider", content: trimmedLine });
+      i++;
+      continue;
+    }
+    if (/^#\s*={3,}\s*$/.test(trimmedLine)) {
+      if (currentText.trim()) {
+        blocks.push({ type: "text", content: currentText.trimEnd() });
+        currentText = "";
+      }
+      blocks.push({ type: "heavy-divider", content: trimmedLine });
+      i++;
+      continue;
+    }
+    if (DIRECTIVE_CONTAINER_OPEN.test(processedLine)) {
+      const tracker = new DirectiveContainerTracker(processedLine);
+      let j = i;
+      while (j < lines.length) {
+        const containerLine = normalizeLine(lines[j]);
+        currentText += containerLine + (j < lines.length - 1 ? "\n" : "");
+        j++;
+        if (j - 1 > i && tracker.consume(containerLine)) break;
+      }
+      i = j;
+      continue;
+    }
+    const codeCheck = detectCodeBlock(processedLine);
+    if (codeCheck.isCodeBlock) {
+      if (currentText.trim()) {
+        blocks.push({ type: "text", content: currentText.trimEnd() });
+        currentText = "";
+      }
+      const extraction = extractCodeBlock(
+        codeCheck.language,
+        codeCheck.ticks ?? 3,
+        i + 1,
+        lines,
+        codeCheck.char
+      );
+      const normalizedLanguage = normalizeCodeLanguage(codeCheck.language);
+      if (normalizedLanguage && SPECIAL_CODE_LANGUAGES.includes(normalizedLanguage)) {
+        const closedCleanly = extraction.closedCleanly;
+        let fenceMetadata;
+        if (closedCleanly) {
+          const fenceEnvelope = envelopes.fenceRegion(
+            normalizedLanguage,
+            extraction.content
+          );
+          if (fenceEnvelope) {
+            fenceMetadata = { [IR_ENVELOPE_KEY]: fenceEnvelope };
+          }
+        }
+        blocks.push({
+          type: normalizedLanguage,
+          content: extraction.content,
+          language: codeCheck.language,
+          ...fenceMetadata ? { metadata: fenceMetadata } : {}
+        });
+      } else if (codeCheck.language?.toLowerCase() === "json") {
+        const jsonType = detectJsonBlockType(extraction.content);
+        if (jsonType) {
+          const streamingState = validateJsonBlock(
+            extraction.content,
+            jsonType
+          );
+          blocks.push({
+            type: jsonType,
+            content: extraction.content,
+            language: "json",
+            // content-ir: complete JSON regions carry the canonical envelope
+            // (memoized one-shot parse — identical to the streaming path's).
+            // EXCEPT a directive: its __kind is a reserved-namespace slug that
+            // is BY DESIGN never in kind_definition, so an __ir envelope here
+            // fires a doomed registry fetch per message and lets the kind
+            // route re-type the block away from MatrxEnvelopeBlock the moment
+            // a directive-class registry row exists (adversarial finding A-8;
+            // recoverEmbeddedKindJsonBlocks already does exactly this).
+            metadata: jsonType === "matrx" ? streamingState.metadata : envelopes.withIrEnvelope(extraction.content, streamingState.metadata)
+          });
+        } else {
+          blocks.push({
+            type: "code",
+            content: extraction.content,
+            language: codeCheck.language,
+            metadata: envelopes.withIrEnvelope(
+              extraction.content,
+              codeCheck.meta ? { [FENCE_META_KEY]: codeCheck.meta } : void 0
+            )
+          });
+        }
+      } else {
+        blocks.push({
+          type: "code",
+          content: extraction.content,
+          language: codeCheck.language,
+          ...codeCheck.meta ? { metadata: { [FENCE_META_KEY]: codeCheck.meta } } : {}
+        });
+      }
+      i = extraction.nextIndex;
+      continue;
+    }
+    const attrXmlMatch = detectAttributeXmlBlock(processedLine);
+    if (attrXmlMatch) {
+      if (currentText.trim()) {
+        blocks.push({ type: "text", content: currentText.trimEnd() });
+        currentText = "";
+      }
+      const rawXmlOverride = pendingRawXmlOverrides.get(trimmedLine);
+      if (rawXmlOverride !== void 0) {
+        pendingRawXmlOverrides.delete(trimmedLine);
+      }
+      const extraction = extractAttributeXmlBlock(
+        attrXmlMatch,
+        i,
+        lines,
+        rawXmlOverride
+      );
+      blocks.push({
+        type: attrXmlMatch.type,
+        content: extraction.content,
+        metadata: extraction.metadata
+      });
+      i = extraction.nextIndex;
+      continue;
+    }
+    const xmlMatch = detectXmlBlockType(processedLine);
+    if (xmlMatch) {
+      if (currentText.trim()) {
+        blocks.push({ type: "text", content: currentText.trimEnd() });
+        currentText = "";
+      }
+      const extraction = extractXmlBlock(
+        xmlMatch.type,
+        xmlMatch.matchedTag,
+        i,
+        lines
+      );
+      let xmlMetadata = extraction.metadata;
+      if (xmlMetadata?.isComplete === true) {
+        const xmlTag = xmlTagNameOf(xmlMatch.matchedTag);
+        const attributed = xmlMatch.matchedTag !== `<${xmlTag}>`;
+        const xmlEnvelope = envelopes.xmlRegion(
+          xmlTag,
+          // Attributes (e.g. a questionnaire `title`) live on the opener:
+          // hand the strategy the same literal framing the accumulator does.
+          attributed ? `${xmlMatch.matchedTag}
+${extraction.content}
+</${xmlTag}>` : extraction.content
+        );
+        if (xmlEnvelope) {
+          xmlMetadata = { ...xmlMetadata, [IR_ENVELOPE_KEY]: xmlEnvelope };
+        }
+      }
+      blocks.push({
+        type: xmlMatch.type,
+        content: extraction.content,
+        metadata: xmlMetadata
+      });
+      i = extraction.nextIndex;
+      continue;
+    }
+    const unrecognizedXml = extractUnrecognizedXmlBlock(i, lines);
+    if (unrecognizedXml) {
+      if (currentText.trim()) {
+        blocks.push({ type: "text", content: currentText.trimEnd() });
+        currentText = "";
+      }
+      blocks.push({
+        type: "code",
+        content: unrecognizedXml.content,
+        language: "xml",
+        metadata: unrecognizedXml.metadata
+      });
+      i = unrecognizedXml.nextIndex;
+      continue;
+    }
+    const incompleteUnrecognizedXml = !isHtmlBlockTagName(leadingTagName(processedLine) ?? "") && (startUnrecognizedXmlContainer(processedLine) || isUnclosedGenericXmlOpening(processedLine));
+    if (incompleteUnrecognizedXml) {
+      if (currentText.trim()) {
+        blocks.push({ type: "text", content: currentText.trimEnd() });
+        currentText = "";
+      }
+      blocks.push({
+        type: "code",
+        content: lines.slice(i).map(normalizeLine).join("\n").trim(),
+        language: "xml",
+        metadata: { isComplete: false, genericXmlContainer: true }
+      });
+      i = lines.length;
+      continue;
+    }
+    const orphanClose = detectOrphanThinkingClose(trimmedLine);
+    if (orphanClose) {
+      const openers = orphanClose.type === "thinking" ? ["<thinking>", "<think>"] : ["<reasoning>"];
+      let sameLineOpener = -1;
+      let sameLineLen = 0;
+      for (const opener of THINKING_OPENERS[orphanClose.type]) {
+        const idx = orphanClose.before.lastIndexOf(opener);
+        if (idx > sameLineOpener) {
+          sameLineOpener = idx;
+          sameLineLen = opener.length;
+        }
+      }
+      if (sameLineOpener >= 0 && orphanClose.before.slice(0, sameLineOpener).trim()) {
+        currentText += processedLine + (i < lines.length - 1 ? "\n" : "");
+        i++;
+        continue;
+      }
+      if (sameLineOpener >= 0) {
+        const proseBefore = `${currentText}${orphanClose.before.slice(0, sameLineOpener)}`;
+        if (proseBefore.trim()) {
+          blocks.push({ type: "text", content: proseBefore.trimEnd() });
+        }
+        currentText = "";
+        const span = orphanClose.before.slice(sameLineOpener + sameLineLen).trim();
+        if (span) {
+          blocks.push({
+            type: orphanClose.type,
+            content: span,
+            metadata: { isComplete: true }
+          });
+        }
+        if (orphanClose.remainder) {
+          lines.splice(i + 1, 0, orphanClose.remainder);
+        }
+        i++;
+        continue;
+      }
+      let openerIdx = -1;
+      let openerLen = 0;
+      for (const opener of openers) {
+        const idx = currentText.lastIndexOf(opener);
+        if (idx > openerIdx) {
+          openerIdx = idx;
+          openerLen = opener.length;
+        }
+      }
+      if (openerIdx >= 0 && /<\/(?:thinking|think|reasoning)>/.test(currentText.slice(openerIdx + openerLen))) {
+        openerIdx = -1;
+      }
+      let regionText = currentText;
+      if (openerIdx >= 0) {
+        const proseBefore = currentText.slice(0, openerIdx);
+        regionText = currentText.slice(openerIdx + openerLen);
+        if (proseBefore.trim()) {
+          blocks.push({ type: "text", content: proseBefore.trimEnd() });
+        }
+      }
+      currentText = "";
+      const body = [regionText.trim(), orphanClose.before].filter(Boolean).join("\n");
+      if (body) {
+        blocks.push({
+          type: orphanClose.type,
+          content: body,
+          metadata: { isComplete: true, continuation: true }
+        });
+      }
+      if (orphanClose.remainder) {
+        lines.splice(i + 1, 0, orphanClose.remainder);
+      }
+      i++;
+      continue;
+    }
+    const youtubeCheck = detectYoutubeMarkdown(line);
+    if (youtubeCheck.isYoutube && youtubeCheck.videoId) {
+      if (currentText.trim()) {
+        blocks.push({ type: "text", content: currentText.trimEnd() });
+        currentText = "";
+      }
+      blocks.push({
+        type: "youtube",
+        // Keep the original line as content so the DB round-trip
+        // (reconstructBlockMarkdown default → content) re-detects it on reload.
+        content: trimmedLine,
+        src: youtubeCheck.watchUrl,
+        metadata: {
+          videoId: youtubeCheck.videoId,
+          start: youtubeCheck.start,
+          title: youtubeCheck.title,
+          poster: youtubeCheck.poster
+        }
+      });
+      i++;
+      continue;
+    }
+    const imageCheck = detectImageMarkdown(line);
+    if (imageCheck.isImage && countInlineImages(line) < 2 && !TITLED_IMAGE_LINE.test(line)) {
+      if (currentText.trim()) {
+        blocks.push({ type: "text", content: currentText.trimEnd() });
+        currentText = "";
+      }
+      blocks.push({
+        type: "image",
+        content: trimmedLine,
+        src: imageCheck.src,
+        alt: imageCheck.alt
+      });
+      i++;
+      continue;
+    }
+    const videoCheck = detectVideoMarkdown(line);
+    if (videoCheck.isVideo) {
+      if (currentText.trim()) {
+        blocks.push({ type: "text", content: currentText.trimEnd() });
+        currentText = "";
+      }
+      blocks.push({
+        type: "video",
+        content: trimmedLine,
+        src: videoCheck.src,
+        alt: videoCheck.alt
+      });
+      i++;
+      continue;
+    }
+    const audioCheck = detectAudioMarkdown(line);
+    if (audioCheck.isAudio) {
+      if (currentText.trim()) {
+        blocks.push({ type: "text", content: currentText.trimEnd() });
+        currentText = "";
+      }
+      blocks.push({
+        type: "audio",
+        content: trimmedLine,
+        src: audioCheck.src,
+        alt: audioCheck.alt
+      });
+      i++;
+      continue;
+    }
+    const matrxFileCheck = detectMatrxFileMarkdown(line);
+    if (matrxFileCheck.isMatrxFile) {
+      if (currentText.trim()) {
+        blocks.push({ type: "text", content: currentText.trimEnd() });
+        currentText = "";
+      }
+      blocks.push({
+        type: "matrx_file",
+        // Keep the original line on content so the DB round-trip re-emits it
+        // (reconstructBlockMarkdown default → content) and reload re-detects.
+        content: trimmedLine,
+        src: matrxFileCheck.url,
+        alt: matrxFileCheck.label,
+        metadata: {
+          pre: matrxFileCheck.pre,
+          post: matrxFileCheck.post,
+          label: matrxFileCheck.label
+        }
+      });
+      i++;
+      continue;
+    }
+    if (detectTableStart(lines, i)) {
+      if (currentText.trim()) {
+        blocks.push({ type: "text", content: currentText.trimEnd() });
+        currentText = "";
+      }
+      const extraction = extractTable(i, lines);
+      if (extraction.metadata?.isValid !== false) {
+        blocks.push({
+          type: "table",
+          content: extraction.content,
+          metadata: extraction.metadata
+        });
+        i = extraction.nextIndex;
+      } else {
+        currentText += processedLine + "\n";
+        i++;
+      }
+      continue;
+    }
+    if (/^\[\s*(?:\{|$)/.test(trimmedLine)) {
+      const arrayLines = [processedLine];
+      const first = countStructuralBraces(trimmedLine, "[", "]");
+      let opens = first.opens;
+      let closes = first.closes;
+      let j = i + 1;
+      while (j < lines.length && opens > closes) {
+        const nextLine = normalizeLine(lines[j]);
+        arrayLines.push(nextLine);
+        const counts = countStructuralBraces(nextLine, "[", "]");
+        opens += counts.opens;
+        closes += counts.closes;
+        j++;
+      }
+      const arrayContent = arrayLines.join("\n").trim();
+      let isKindArray = false;
+      if (opens === closes && jsonKindSignal(arrayContent) === "kind") {
+        try {
+          isKindArray = Array.isArray(JSON.parse(arrayContent));
+        } catch {
+          isKindArray = false;
+        }
+      }
+      if (isKindArray) {
+        if (currentText.trim()) {
+          blocks.push({ type: "text", content: currentText.trimEnd() });
+          currentText = "";
+        }
+        blocks.push({ type: "code", content: arrayContent, language: "json" });
+        i = j;
+        continue;
+      }
+    }
+    if (trimmedLine.startsWith("{")) {
+      const jsonLines = [processedLine];
+      const first = countStructuralBraces(trimmedLine);
+      let openCount = first.opens;
+      let closeCount = first.closes;
+      let j = i + 1;
+      while (j < lines.length && openCount > closeCount) {
+        const nextLine = normalizeLine(lines[j]);
+        jsonLines.push(nextLine);
+        const counts = countStructuralBraces(nextLine);
+        openCount += counts.opens;
+        closeCount += counts.closes;
+        j++;
+      }
+      if (openCount === closeCount && openCount > 0) {
+        const jsonContent = jsonLines.join("\n").trim();
+        let parsedOk = false;
+        try {
+          const parsed = JSON.parse(jsonContent);
+          parsedOk = parsed !== null && typeof parsed === "object";
+        } catch {
+        }
+        if (parsedOk) {
+          if (currentText.trim()) {
+            blocks.push({ type: "text", content: currentText.trimEnd() });
+            currentText = "";
+          }
+          const jsonType = detectJsonBlockType(jsonContent);
+          if (jsonType) {
+            const streamingState = validateJsonBlock(jsonContent, jsonType);
+            blocks.push({
+              type: jsonType,
+              content: jsonContent,
+              language: "json",
+              // A directive block never carries __ir — see the fenced-JSON
+              // site above (adversarial finding A-8).
+              metadata: jsonType === "matrx" ? streamingState.metadata : envelopes.withIrEnvelope(jsonContent, streamingState.metadata)
+            });
+          } else {
+            blocks.push({
+              type: "code",
+              content: jsonContent,
+              language: "json",
+              metadata: envelopes.withIrEnvelope(jsonContent, void 0)
+            });
+          }
+          i = j;
+          continue;
+        }
+      } else if (openCount > closeCount && // Round 11 (H1): a region whose own grammar already broke into prose
+      // (`{\"__kind\":…}`, `{ some code`) was never JSON — the live
+      // accumulator draws it as text (same check), so reload does too. Its
+      // brace count never balancing must not carry the region to the end
+      // of the message, where a LATER real kind made it "a kind region".
+      !bareRegionBreaksIntoProse(jsonLines.join("\n"), { firstBudget: true })) {
+        const partialJson = jsonLines.join("\n").trim();
+        const jsonType = detectJsonBlockType(partialJson);
+        if (jsonType) {
+          if (currentText.trim()) {
+            blocks.push({ type: "text", content: currentText.trimEnd() });
+            currentText = "";
+          }
+          blocks.push({
+            type: jsonType,
+            content: partialJson,
+            language: "json",
+            metadata: { isComplete: false }
+          });
+          i = j;
+          continue;
+        }
+        const signal = jsonKindSignal(partialJson);
+        if (signal === "kind" || signal === "undecided" && /^\{\s*(?:"[^"]*)?$/.test(partialJson)) {
+          if (currentText.trim()) {
+            blocks.push({ type: "text", content: currentText.trimEnd() });
+            currentText = "";
+          }
+          blocks.push({
+            type: "code",
+            content: partialJson,
+            language: "json",
+            metadata: { isComplete: false }
+          });
+          i = j;
+          continue;
+        }
+      }
+    }
+    const midLineAttrXml = detectMidLineAttributeXml(processedLine);
+    if (midLineAttrXml) {
+      if (currentText.trim()) {
+        blocks.push({ type: "text", content: currentText.trimEnd() });
+        currentText = "";
+      }
+      const textBefore = processedLine.slice(0, midLineAttrXml.tagStart).trimEnd();
+      const tagAndRest = processedLine.slice(midLineAttrXml.tagStart);
+      const closingTag = `</${midLineAttrXml.type}>`;
+      const rawXmlParts = [tagAndRest];
+      let foundClose = tagAndRest.includes(closingTag);
+      if (!foundClose) {
+        for (let j = i + 1; j < lines.length; j++) {
+          const jLine = lines[j];
+          const jIdx = jLine.indexOf(closingTag);
+          if (jIdx !== -1) {
+            rawXmlParts.push(jLine.slice(0, jIdx + closingTag.length));
+            foundClose = true;
+            break;
+          }
+          rawXmlParts.push(jLine);
+        }
+      }
+      const rawXmlOverride = rawXmlParts.join("\n");
+      const replacements = [];
+      if (textBefore) replacements.push(textBefore);
+      replacements.push(tagAndRest);
+      pendingRawXmlOverrides.set(tagAndRest.trim(), rawXmlOverride);
+      lines.splice(i, 1, ...replacements);
+      continue;
+    }
+    if (isTreeLine(trimmedLine)) {
+      let treeEnd = i + 1;
+      while (treeEnd < lines.length) {
+        const nextTrimmed = normalizeLine(lines[treeEnd]).trim();
+        if (!nextTrimmed) {
+          treeEnd++;
+          continue;
+        }
+        if (isTreeLine(nextTrimmed)) {
+          treeEnd++;
+          continue;
+        }
+        break;
+      }
+      const treeLinesCount = lines.slice(i, treeEnd).filter((l) => isTreeLine(normalizeLine(l).trim())).length;
+      if (treeLinesCount >= 3) {
+        const treeStart = findTreeBlockStart(lines, i);
+        if (treeStart < i) {
+          currentText = stripAccumulatedLinesFromText(
+            currentText,
+            lines,
+            treeStart,
+            i
+          );
+        }
+        if (currentText.trim()) {
+          blocks.push({ type: "text", content: currentText.trimEnd() });
+          currentText = "";
+        }
+        const treeContent = lines.slice(treeStart, treeEnd).map((l) => normalizeLine(l)).join("\n");
+        blocks.push({ type: "tree", content: treeContent.trim() });
+        i = treeEnd;
+        continue;
+      }
+    }
+    currentText += processedLine + (i < lines.length - 1 ? "\n" : "");
+    i++;
+  }
+  if (currentText.trim()) {
+    blocks.push({ type: "text", content: currentText.trimEnd() });
+  }
+  return recoverEmbeddedKindJsonBlocksWith(blocks, envelopes);
+};
+export {
+  AUDIO_URL_EXT,
+  CODE_LANGUAGE_ALIASES,
+  NO_SPLITTER_ENVELOPES,
+  SPECIAL_CODE_LANGUAGES,
+  countInlineImages,
+  detectImageMarkdown,
+  detectJsonBlockType,
+  detectMatrxFileMarkdown,
+  detectVideoMarkdown,
+  extractAudioLink,
+  isCompleteUnrecognizedXmlContainer,
+  isUnclosedGenericXmlOpening,
+  normalizeCodeLanguage,
+  parseXmlAttributes,
+  recoverEmbeddedKindJsonBlocksWith,
+  splitContentIntoBlocksWith,
+  startUnrecognizedXmlContainer
+};