@ai-matrx/content-ir 0.22.6 → 0.23.0

package/dist/source.d.cts

@@ -643,6 +643,143 @@ declare function pendingDisplayMathOpener(text: string): number;
 /** Map of `$$` opener offset → closer offset for every pair the renderer shows as math. */
 declare function pairDisplayMath(text: string): Map<number, number>;
 
+/**
+ * @ai-matrx/kit/delimiter-guard — stops ONE stray markdown delimiter from
+ * swallowing a whole section of a streamed answer.
+ *
+ * THE FAILURE CLASS
+ * -----------------
+ * Markdown delimiters pair greedily and blindly. A single stray opener emitted
+ * by a model (the common shape is a mangled citation:
+ * `…/a-quicker-way-to-heal-prp-and-prf$$ .`) pairs with the next matching
+ * delimiter anywhere later in the message, and everything in between —
+ * headings, bold, links, whole sections — collapses into one node.
+ *
+ * Two delimiters cause this in a remark-math + CommonMark pipeline:
+ *
+ * 1. `$$` (remark-math). The swallowed prose becomes a math node, KaTeX fails
+ *    to parse it, and `rehype-katex` falls back to its built-in error
+ *    rendering: the raw source re-emitted inside `<span class="katex-error"
+ *    style="color:#cc0000">`. The symptom is a huge block of BRIGHT RED
+ *    unrendered markdown mid-answer. That red is KaTeX reporting a parse error
+ *    on text that was never math — not a style of yours.
+ * 2. `[` (CommonMark link label). The swallowed prose becomes the label of one
+ *    enormous hyperlink — the same bug wearing blue instead of red.
+ *
+ * WHAT THIS DOES
+ * --------------
+ * Before the markdown pipeline runs, each candidate span is checked for
+ * plausibility. A `$$…$$` span carrying markdown structure (links, URLs, bold,
+ * headings, list markers) or reading as prose is not math; a link label that is
+ * hundreds of characters long or contains block structure is not a label. The
+ * offending OPENER is neutralized (`&#36;&#36;`, `&#91;`) and scanning resumes at the next
+ * delimiter, so genuine math and genuine links later in the same message still
+ * render. Real content is never touched.
+ *
+ * LOUD RECOVERY: every firing is a real upstream defect (a model emitting
+ * malformed delimiters, or a producer mangling a citation). Callers report the
+ * returned violations — see `reportDelimiterViolations`.
+ *
+ * Ported verbatim from matrx-frontend `lib/markdown/delimiter-guard.ts`, with
+ * ONE coupling inversion: the app's `captureError` store import became the
+ * injected `capture` sink on `reportDelimiterViolations`' context (payload
+ * shape preserved exactly). No sink means console-only loud recovery.
+ */
+type DelimiterViolationReason = 
+/** A `$$…$$` pair whose contents are prose/markdown, not math. */
+"prose-span"
+/** A `$$` with no closing partner in the content. */
+ | "unpaired"
+/** A `[…](…)` link whose label swallowed prose/structure. */
+ | "runaway-link";
+interface DelimiterViolation {
+    reason: DelimiterViolationReason;
+    /** Character offset of the offending delimiter in the input string. */
+    index: number;
+    /** Length of the span between the delimiters (0 for `unpaired`). */
+    spanLength: number;
+    /** Short excerpt of what would have been swallowed. */
+    preview: string;
+}
+interface DelimiterGuardResult {
+    /** Input with runaway openers escaped. */
+    text: string;
+    violations: DelimiterViolation[];
+}
+/**
+ * Escapes `$$` delimiters that would make remark-math swallow non-math text.
+ * Pure — safe to call on every render / stream chunk.
+ */
+declare function guardMathDelimiters(text: string): DelimiterGuardResult;
+/**
+ * Escapes the `[` of a markdown link whose label ran away — the link twin of
+ * the stray-`$$` bug. An unclosed citation bracket pairs with a `]` hundreds of
+ * characters later and turns an entire section into one hyperlink.
+ *
+ * Pure. Runs after the math guard so both share one escaping pass conceptually,
+ * but each is independently usable.
+ */
+declare function guardRunawayLinks(text: string): DelimiterGuardResult;
+/**
+ * The front door: run every delimiter guard in order. Offsets in the returned
+ * violations refer to each guard's own input, so they are for diagnostics only.
+ */
+declare function guardMarkdownDelimiters(text: string): DelimiterGuardResult;
+/**
+ * The payload handed to the injected capture sink — exactly the shape the
+ * original passed to the Matrx `captureError` store. A Matrx host passes
+ * `captureError` straight through; any host can log/report it its own way.
+ */
+interface DelimiterCaptureInput {
+    source: "markdown-delimiters";
+    message: string;
+    relation: string;
+    details: string;
+    conversationId?: string | undefined;
+    callSite: "guardMarkdownDelimiters";
+    raw: {
+        messageId?: string | undefined;
+        violations: DelimiterViolation[];
+    };
+}
+interface DelimiterReportContext {
+    renderPath: string;
+    messageId?: string | undefined;
+    conversationId?: string | undefined;
+    /**
+     * Optional error-capture sink (a Matrx host passes its `captureError`).
+     * Absent, the loud recovery is console-only. Must never be relied on to
+     * throw — failures inside it are swallowed so capture can never break
+     * rendering.
+     */
+    capture?: ((input: DelimiterCaptureInput) => void) | undefined;
+}
+/**
+ * Loud recovery. A firing means malformed math delimiters reached the renderer
+ * — the guard kept the message readable, but the producer is still emitting
+ * broken content and must be found.
+ */
+declare function reportDelimiterViolations(violations: DelimiterViolation[], context: DelimiterReportContext): void;
+
+declare function stripThinking(input: string): string;
+declare function hasThinkingTags(input: string): boolean;
+/**
+ * Streaming-aware variant: handles partial `<thinking>` / `<reasoning>` blocks
+ * whose closing tag hasn't arrived yet. Returns:
+ *   - `visible`: text with all *closed* thinking/reasoning blocks removed AND
+ *     any currently-open thinking block truncated (so the partial chain-of-
+ *     thought never reaches the textarea or the clipboard).
+ *   - `isThinking`: true when the stream is currently inside an unclosed
+ *     `<thinking>` or `<reasoning>` tag — callers can render a "thinking..."
+ *     animation while waiting for the close tag.
+ * Tags inside code — including a fence or inline span still arriving — are
+ * content, never an open block.
+ */
+declare function stripThinkingStreaming(input: string): {
+    visible: string;
+    isThinking: boolean;
+};
+
 /**
  * THE GFM table rule — one splitter, one cell-pipe rule, one "where does a
  * table start and run" — for every surface that reads a markdown table: the
@@ -883,4 +1020,4 @@ declare function findWholeTableStart(lines: readonly string[], from?: number): n
  */
 declare function trailingTableStart(lines: readonly string[], end?: number): number;
 
-export { AFTER_WINDOW, BacktickRuns, type BlockIslandType, CALLOUT_NAMES, type CodePointIndex, type CodeRange, DIRECTIVE_CONTAINER_OPEN, DirectiveContainerTracker, type DisturbedIsland, FENCE_META_KEY, FENCE_OPENER_WHITESPACE, FENCE_WHITESPACE, type FenceEnd, type FenceInfo, type FenceLineKind, type FenceLines, type FenceMeta, type FenceOpener, FenceReader, type InlineIslandType, type InnerFenceLine, type IslandMeta, type IslandType, type LinkDefinition, type MapOptions, type MappedPosition, type MappedRange, NESTING_FENCE_LANGUAGES, type ReadXmlTag, type SourceBlock, type SourceBlockKind, type SourceChange, type SourceEdit, type SourceIsland, type SourceSpan, SourceSpliceError, type SourceSpliceErrorCode, type SpliceIntegrity, type SpliceOptions, type SpliceResult, TITLED_IMAGE_LINE, type TokenizeOptions, type XmlBalanceOptions, type XmlBalanceState, XmlContainerTracker, blockAt, blockEdit, blockRangeEdit, buildCodePointIndex, classifyInnerFenceLine, cleanMarkdown, closeFence, codeSpanText, collectLinkDefinitions, continuesTable, fenceLineKinds, fenceNestsInnerFences, fenceOpenerOf, fenceParts, findBalancedXmlClose, findCodeRanges, findInlineCodeSpans, findLinkDefinitionLines, findTableEnd, findTableStart, findWholeTableStart, hasUnclosedBacktickRun, indexOutsideInlineCode, initialXmlBalance, isEscapedBracketMath, isGfmDelimiterRow, isGrowingDelimiterRow, isHtmlBlockTagName, isInsideInlineCode, isMathPlaceholder, isPipeLedRow, isSingleDollarMath, islandEdit, joinSource, lineIndent, listIslands, looksLikeDisplayMath, looksLikeOpenInlineMath, mapCodeRanges, mapInlineCodeSpans, mapPosition, mapRange, markdownToPlainText, mathToReadable, normalizeLinkLabel, opensStrippedHtmlBlock, opensTable, pairDisplayMath, parseFenceMeta, parseFenceOpener, parseLineRanges, pendingCodeSpanStart, pendingDisplayMathOpener, readXmlTag, removeCodeSpans, replaceFences, resolveReferenceLinks, rowCells, singleDollarAfter, singleDollarMathEnd, soleFence, spliceSave, splitFenceInfo, splitRowSegments, splitsSurrogatePair, startsHtmlBlock, startsLikeTableRow, startsPipelessTable, tableContainerIndent, tableStartsAt, toCodePointOffset, toUtf16Offset, tokenizeSource, trailingTableStart, trimFenceLine, unescapeCellPipes, unwrapCodeSpans, unwrapKindEnvelopes };
+export { AFTER_WINDOW, BacktickRuns, type BlockIslandType, CALLOUT_NAMES, type CodePointIndex, type CodeRange, DIRECTIVE_CONTAINER_OPEN, type DelimiterCaptureInput, type DelimiterGuardResult, type DelimiterReportContext, type DelimiterViolation, type DelimiterViolationReason, DirectiveContainerTracker, type DisturbedIsland, FENCE_META_KEY, FENCE_OPENER_WHITESPACE, FENCE_WHITESPACE, type FenceEnd, type FenceInfo, type FenceLineKind, type FenceLines, type FenceMeta, type FenceOpener, FenceReader, type InlineIslandType, type InnerFenceLine, type IslandMeta, type IslandType, type LinkDefinition, type MapOptions, type MappedPosition, type MappedRange, NESTING_FENCE_LANGUAGES, type ReadXmlTag, type SourceBlock, type SourceBlockKind, type SourceChange, type SourceEdit, type SourceIsland, type SourceSpan, SourceSpliceError, type SourceSpliceErrorCode, type SpliceIntegrity, type SpliceOptions, type SpliceResult, TITLED_IMAGE_LINE, type TokenizeOptions, type XmlBalanceOptions, type XmlBalanceState, XmlContainerTracker, blockAt, blockEdit, blockRangeEdit, buildCodePointIndex, classifyInnerFenceLine, cleanMarkdown, closeFence, codeSpanText, collectLinkDefinitions, continuesTable, fenceLineKinds, fenceNestsInnerFences, fenceOpenerOf, fenceParts, findBalancedXmlClose, findCodeRanges, findInlineCodeSpans, findLinkDefinitionLines, findTableEnd, findTableStart, findWholeTableStart, guardMarkdownDelimiters, guardMathDelimiters, guardRunawayLinks, hasThinkingTags, hasUnclosedBacktickRun, indexOutsideInlineCode, initialXmlBalance, isEscapedBracketMath, isGfmDelimiterRow, isGrowingDelimiterRow, isHtmlBlockTagName, isInsideInlineCode, isMathPlaceholder, isPipeLedRow, isSingleDollarMath, islandEdit, joinSource, lineIndent, listIslands, looksLikeDisplayMath, looksLikeOpenInlineMath, mapCodeRanges, mapInlineCodeSpans, mapPosition, mapRange, markdownToPlainText, mathToReadable, normalizeLinkLabel, opensStrippedHtmlBlock, opensTable, pairDisplayMath, parseFenceMeta, parseFenceOpener, parseLineRanges, pendingCodeSpanStart, pendingDisplayMathOpener, readXmlTag, removeCodeSpans, replaceFences, reportDelimiterViolations, resolveReferenceLinks, rowCells, singleDollarAfter, singleDollarMathEnd, soleFence, spliceSave, splitFenceInfo, splitRowSegments, splitsSurrogatePair, startsHtmlBlock, startsLikeTableRow, startsPipelessTable, stripThinking, stripThinkingStreaming, tableContainerIndent, tableStartsAt, toCodePointOffset, toUtf16Offset, tokenizeSource, trailingTableStart, trimFenceLine, unescapeCellPipes, unwrapCodeSpans, unwrapKindEnvelopes };

package/dist/source.d.ts

@@ -643,6 +643,143 @@ declare function pendingDisplayMathOpener(text: string): number;
 /** Map of `$$` opener offset → closer offset for every pair the renderer shows as math. */
 declare function pairDisplayMath(text: string): Map<number, number>;
 
+/**
+ * @ai-matrx/kit/delimiter-guard — stops ONE stray markdown delimiter from
+ * swallowing a whole section of a streamed answer.
+ *
+ * THE FAILURE CLASS
+ * -----------------
+ * Markdown delimiters pair greedily and blindly. A single stray opener emitted
+ * by a model (the common shape is a mangled citation:
+ * `…/a-quicker-way-to-heal-prp-and-prf$$ .`) pairs with the next matching
+ * delimiter anywhere later in the message, and everything in between —
+ * headings, bold, links, whole sections — collapses into one node.
+ *
+ * Two delimiters cause this in a remark-math + CommonMark pipeline:
+ *
+ * 1. `$$` (remark-math). The swallowed prose becomes a math node, KaTeX fails
+ *    to parse it, and `rehype-katex` falls back to its built-in error
+ *    rendering: the raw source re-emitted inside `<span class="katex-error"
+ *    style="color:#cc0000">`. The symptom is a huge block of BRIGHT RED
+ *    unrendered markdown mid-answer. That red is KaTeX reporting a parse error
+ *    on text that was never math — not a style of yours.
+ * 2. `[` (CommonMark link label). The swallowed prose becomes the label of one
+ *    enormous hyperlink — the same bug wearing blue instead of red.
+ *
+ * WHAT THIS DOES
+ * --------------
+ * Before the markdown pipeline runs, each candidate span is checked for
+ * plausibility. A `$$…$$` span carrying markdown structure (links, URLs, bold,
+ * headings, list markers) or reading as prose is not math; a link label that is
+ * hundreds of characters long or contains block structure is not a label. The
+ * offending OPENER is neutralized (`&#36;&#36;`, `&#91;`) and scanning resumes at the next
+ * delimiter, so genuine math and genuine links later in the same message still
+ * render. Real content is never touched.
+ *
+ * LOUD RECOVERY: every firing is a real upstream defect (a model emitting
+ * malformed delimiters, or a producer mangling a citation). Callers report the
+ * returned violations — see `reportDelimiterViolations`.
+ *
+ * Ported verbatim from matrx-frontend `lib/markdown/delimiter-guard.ts`, with
+ * ONE coupling inversion: the app's `captureError` store import became the
+ * injected `capture` sink on `reportDelimiterViolations`' context (payload
+ * shape preserved exactly). No sink means console-only loud recovery.
+ */
+type DelimiterViolationReason = 
+/** A `$$…$$` pair whose contents are prose/markdown, not math. */
+"prose-span"
+/** A `$$` with no closing partner in the content. */
+ | "unpaired"
+/** A `[…](…)` link whose label swallowed prose/structure. */
+ | "runaway-link";
+interface DelimiterViolation {
+    reason: DelimiterViolationReason;
+    /** Character offset of the offending delimiter in the input string. */
+    index: number;
+    /** Length of the span between the delimiters (0 for `unpaired`). */
+    spanLength: number;
+    /** Short excerpt of what would have been swallowed. */
+    preview: string;
+}
+interface DelimiterGuardResult {
+    /** Input with runaway openers escaped. */
+    text: string;
+    violations: DelimiterViolation[];
+}
+/**
+ * Escapes `$$` delimiters that would make remark-math swallow non-math text.
+ * Pure — safe to call on every render / stream chunk.
+ */
+declare function guardMathDelimiters(text: string): DelimiterGuardResult;
+/**
+ * Escapes the `[` of a markdown link whose label ran away — the link twin of
+ * the stray-`$$` bug. An unclosed citation bracket pairs with a `]` hundreds of
+ * characters later and turns an entire section into one hyperlink.
+ *
+ * Pure. Runs after the math guard so both share one escaping pass conceptually,
+ * but each is independently usable.
+ */
+declare function guardRunawayLinks(text: string): DelimiterGuardResult;
+/**
+ * The front door: run every delimiter guard in order. Offsets in the returned
+ * violations refer to each guard's own input, so they are for diagnostics only.
+ */
+declare function guardMarkdownDelimiters(text: string): DelimiterGuardResult;
+/**
+ * The payload handed to the injected capture sink — exactly the shape the
+ * original passed to the Matrx `captureError` store. A Matrx host passes
+ * `captureError` straight through; any host can log/report it its own way.
+ */
+interface DelimiterCaptureInput {
+    source: "markdown-delimiters";
+    message: string;
+    relation: string;
+    details: string;
+    conversationId?: string | undefined;
+    callSite: "guardMarkdownDelimiters";
+    raw: {
+        messageId?: string | undefined;
+        violations: DelimiterViolation[];
+    };
+}
+interface DelimiterReportContext {
+    renderPath: string;
+    messageId?: string | undefined;
+    conversationId?: string | undefined;
+    /**
+     * Optional error-capture sink (a Matrx host passes its `captureError`).
+     * Absent, the loud recovery is console-only. Must never be relied on to
+     * throw — failures inside it are swallowed so capture can never break
+     * rendering.
+     */
+    capture?: ((input: DelimiterCaptureInput) => void) | undefined;
+}
+/**
+ * Loud recovery. A firing means malformed math delimiters reached the renderer
+ * — the guard kept the message readable, but the producer is still emitting
+ * broken content and must be found.
+ */
+declare function reportDelimiterViolations(violations: DelimiterViolation[], context: DelimiterReportContext): void;
+
+declare function stripThinking(input: string): string;
+declare function hasThinkingTags(input: string): boolean;
+/**
+ * Streaming-aware variant: handles partial `<thinking>` / `<reasoning>` blocks
+ * whose closing tag hasn't arrived yet. Returns:
+ *   - `visible`: text with all *closed* thinking/reasoning blocks removed AND
+ *     any currently-open thinking block truncated (so the partial chain-of-
+ *     thought never reaches the textarea or the clipboard).
+ *   - `isThinking`: true when the stream is currently inside an unclosed
+ *     `<thinking>` or `<reasoning>` tag — callers can render a "thinking..."
+ *     animation while waiting for the close tag.
+ * Tags inside code — including a fence or inline span still arriving — are
+ * content, never an open block.
+ */
+declare function stripThinkingStreaming(input: string): {
+    visible: string;
+    isThinking: boolean;
+};
+
 /**
  * THE GFM table rule — one splitter, one cell-pipe rule, one "where does a
  * table start and run" — for every surface that reads a markdown table: the
@@ -883,4 +1020,4 @@ declare function findWholeTableStart(lines: readonly string[], from?: number): n
  */
 declare function trailingTableStart(lines: readonly string[], end?: number): number;
 
-export { AFTER_WINDOW, BacktickRuns, type BlockIslandType, CALLOUT_NAMES, type CodePointIndex, type CodeRange, DIRECTIVE_CONTAINER_OPEN, DirectiveContainerTracker, type DisturbedIsland, FENCE_META_KEY, FENCE_OPENER_WHITESPACE, FENCE_WHITESPACE, type FenceEnd, type FenceInfo, type FenceLineKind, type FenceLines, type FenceMeta, type FenceOpener, FenceReader, type InlineIslandType, type InnerFenceLine, type IslandMeta, type IslandType, type LinkDefinition, type MapOptions, type MappedPosition, type MappedRange, NESTING_FENCE_LANGUAGES, type ReadXmlTag, type SourceBlock, type SourceBlockKind, type SourceChange, type SourceEdit, type SourceIsland, type SourceSpan, SourceSpliceError, type SourceSpliceErrorCode, type SpliceIntegrity, type SpliceOptions, type SpliceResult, TITLED_IMAGE_LINE, type TokenizeOptions, type XmlBalanceOptions, type XmlBalanceState, XmlContainerTracker, blockAt, blockEdit, blockRangeEdit, buildCodePointIndex, classifyInnerFenceLine, cleanMarkdown, closeFence, codeSpanText, collectLinkDefinitions, continuesTable, fenceLineKinds, fenceNestsInnerFences, fenceOpenerOf, fenceParts, findBalancedXmlClose, findCodeRanges, findInlineCodeSpans, findLinkDefinitionLines, findTableEnd, findTableStart, findWholeTableStart, hasUnclosedBacktickRun, indexOutsideInlineCode, initialXmlBalance, isEscapedBracketMath, isGfmDelimiterRow, isGrowingDelimiterRow, isHtmlBlockTagName, isInsideInlineCode, isMathPlaceholder, isPipeLedRow, isSingleDollarMath, islandEdit, joinSource, lineIndent, listIslands, looksLikeDisplayMath, looksLikeOpenInlineMath, mapCodeRanges, mapInlineCodeSpans, mapPosition, mapRange, markdownToPlainText, mathToReadable, normalizeLinkLabel, opensStrippedHtmlBlock, opensTable, pairDisplayMath, parseFenceMeta, parseFenceOpener, parseLineRanges, pendingCodeSpanStart, pendingDisplayMathOpener, readXmlTag, removeCodeSpans, replaceFences, resolveReferenceLinks, rowCells, singleDollarAfter, singleDollarMathEnd, soleFence, spliceSave, splitFenceInfo, splitRowSegments, splitsSurrogatePair, startsHtmlBlock, startsLikeTableRow, startsPipelessTable, tableContainerIndent, tableStartsAt, toCodePointOffset, toUtf16Offset, tokenizeSource, trailingTableStart, trimFenceLine, unescapeCellPipes, unwrapCodeSpans, unwrapKindEnvelopes };
+export { AFTER_WINDOW, BacktickRuns, type BlockIslandType, CALLOUT_NAMES, type CodePointIndex, type CodeRange, DIRECTIVE_CONTAINER_OPEN, type DelimiterCaptureInput, type DelimiterGuardResult, type DelimiterReportContext, type DelimiterViolation, type DelimiterViolationReason, DirectiveContainerTracker, type DisturbedIsland, FENCE_META_KEY, FENCE_OPENER_WHITESPACE, FENCE_WHITESPACE, type FenceEnd, type FenceInfo, type FenceLineKind, type FenceLines, type FenceMeta, type FenceOpener, FenceReader, type InlineIslandType, type InnerFenceLine, type IslandMeta, type IslandType, type LinkDefinition, type MapOptions, type MappedPosition, type MappedRange, NESTING_FENCE_LANGUAGES, type ReadXmlTag, type SourceBlock, type SourceBlockKind, type SourceChange, type SourceEdit, type SourceIsland, type SourceSpan, SourceSpliceError, type SourceSpliceErrorCode, type SpliceIntegrity, type SpliceOptions, type SpliceResult, TITLED_IMAGE_LINE, type TokenizeOptions, type XmlBalanceOptions, type XmlBalanceState, XmlContainerTracker, blockAt, blockEdit, blockRangeEdit, buildCodePointIndex, classifyInnerFenceLine, cleanMarkdown, closeFence, codeSpanText, collectLinkDefinitions, continuesTable, fenceLineKinds, fenceNestsInnerFences, fenceOpenerOf, fenceParts, findBalancedXmlClose, findCodeRanges, findInlineCodeSpans, findLinkDefinitionLines, findTableEnd, findTableStart, findWholeTableStart, guardMarkdownDelimiters, guardMathDelimiters, guardRunawayLinks, hasThinkingTags, hasUnclosedBacktickRun, indexOutsideInlineCode, initialXmlBalance, isEscapedBracketMath, isGfmDelimiterRow, isGrowingDelimiterRow, isHtmlBlockTagName, isInsideInlineCode, isMathPlaceholder, isPipeLedRow, isSingleDollarMath, islandEdit, joinSource, lineIndent, listIslands, looksLikeDisplayMath, looksLikeOpenInlineMath, mapCodeRanges, mapInlineCodeSpans, mapPosition, mapRange, markdownToPlainText, mathToReadable, normalizeLinkLabel, opensStrippedHtmlBlock, opensTable, pairDisplayMath, parseFenceMeta, parseFenceOpener, parseLineRanges, pendingCodeSpanStart, pendingDisplayMathOpener, readXmlTag, removeCodeSpans, replaceFences, reportDelimiterViolations, resolveReferenceLinks, rowCells, singleDollarAfter, singleDollarMathEnd, soleFence, spliceSave, splitFenceInfo, splitRowSegments, splitsSurrogatePair, startsHtmlBlock, startsLikeTableRow, startsPipelessTable, stripThinking, stripThinkingStreaming, tableContainerIndent, tableStartsAt, toCodePointOffset, toUtf16Offset, tokenizeSource, trailingTableStart, trimFenceLine, unescapeCellPipes, unwrapCodeSpans, unwrapKindEnvelopes };

package/dist/source.js

@@ -2882,6 +2882,198 @@ function resolveReferenceLinks(fragment, defs) {
   return resolved.replace(new RegExp(`${PLACEHOLDER}(\\d+)${PLACEHOLDER}`, "g"), (_m, i) => spans[Number(i)] ?? "");
 }
 
+// source/delimiter-guard.ts
+var ZWSP = "\u200B";
+var ESCAPED_DOLLARS = `${ZWSP}$${ZWSP}$`;
+var ESCAPED_BRACKET = `${ZWSP}[`;
+function protectedRanges(text) {
+  return findCodeRanges(text).map((r) => [r.start, r.end]);
+}
+function isProtected(index, ranges) {
+  return ranges.some(([start, end]) => index >= start && index < end);
+}
+function preview(text, max = 160) {
+  const flat = text.replace(/\s+/g, " ").trim();
+  return flat.length > max ? `${flat.slice(0, max)}\u2026` : flat;
+}
+function guardMathDelimiters(text) {
+  if (!text.includes("$$")) return { text, violations: [] };
+  const ranges = protectedRanges(text);
+  const tokens = [];
+  for (let i = 0; i < text.length - 1; i++) {
+    if (text[i] !== "$" || text[i + 1] !== "$") continue;
+    if (!isProtected(i, ranges)) tokens.push(i);
+    i++;
+  }
+  if (tokens.length === 0) return { text, violations: [] };
+  const violations = [];
+  const escapeAt = [];
+  let j = 0;
+  while (j < tokens.length) {
+    const open = tokens[j];
+    const close = tokens[j + 1];
+    if (close === void 0) {
+      violations.push({
+        reason: "unpaired",
+        index: open,
+        spanLength: 0,
+        // An unpaired `$$` is inert to remark-math (nothing closes it), so it
+        // is reported but NOT escaped — it already renders as literal text.
+        preview: preview(text.slice(open, open + 120))
+      });
+      break;
+    }
+    const inner = text.slice(open + 2, close);
+    if (isMathPlaceholder(inner)) {
+      escapeAt.push(open, close);
+      violations.push({ reason: "prose-span", index: open, spanLength: inner.length, preview: preview(inner) });
+      j += 2;
+      continue;
+    }
+    if (looksLikeDisplayMath(inner, opensFlowBlock(text, open))) {
+      j += 2;
+      continue;
+    }
+    escapeAt.push(open);
+    violations.push({
+      reason: "prose-span",
+      index: open,
+      spanLength: inner.length,
+      preview: preview(inner)
+    });
+    j += 1;
+  }
+  let guarded = text;
+  for (const index of [...escapeAt].sort((a, b) => b - a)) {
+    guarded = `${guarded.slice(0, index)}${ESCAPED_DOLLARS}${guarded.slice(index + 2)}`;
+  }
+  return { text: guarded, violations };
+}
+var MAX_LINK_LABEL = 200;
+var LABEL_BLOCK_STRUCTURE = /\n[ \t]*\n|(?:^|\n)[ \t]*[-*+][ \t]+|#{2,6}[ \t]/;
+function guardRunawayLinks(text) {
+  if (!text.includes("[")) return { text, violations: [] };
+  const ranges = protectedRanges(text);
+  const violations = [];
+  const escapeAt = [];
+  const linkRe = /\[((?:[^[\]\\]|\\.)*)\]\(([^\s)]*)/g;
+  let m;
+  while ((m = linkRe.exec(text)) !== null) {
+    const open = m.index;
+    if (isProtected(open, ranges)) continue;
+    const label = m[1] ?? "";
+    const runaway = label.length > MAX_LINK_LABEL || LABEL_BLOCK_STRUCTURE.test(label);
+    if (!runaway) continue;
+    escapeAt.push(open);
+    violations.push({
+      reason: "runaway-link",
+      index: open,
+      spanLength: label.length,
+      preview: preview(label)
+    });
+  }
+  let guarded = text;
+  for (const index of [...escapeAt].sort((a, b) => b - a)) {
+    guarded = `${guarded.slice(0, index)}${ESCAPED_BRACKET}${guarded.slice(index + 1)}`;
+  }
+  return { text: guarded, violations };
+}
+function guardMarkdownDelimiters(text) {
+  const math = guardMathDelimiters(text);
+  const links = guardRunawayLinks(math.text);
+  return {
+    text: links.text,
+    violations: [...math.violations, ...links.violations]
+  };
+}
+function reportDelimiterViolations(violations, context) {
+  if (violations.length === 0) return;
+  try {
+    const worst = violations.find((v) => v.reason !== "unpaired") ?? violations[0];
+    if (!worst) return;
+    const message = worst.reason === "prose-span" ? `Malformed math delimiters: a stray "$$" would have turned ${worst.spanLength} chars of prose into a math span (KaTeX would render it as red error text). Escaped it.` : worst.reason === "runaway-link" ? `Runaway markdown link: an unclosed "[" would have turned ${worst.spanLength} chars into one link label. Escaped it.` : `Malformed math delimiters: an unpaired "$$" reached the renderer.`;
+    console.warn(`[markdown-delimiter-guard] ${message}`, {
+      renderPath: context.renderPath,
+      violations
+    });
+    context.capture?.({
+      source: "markdown-delimiters",
+      message,
+      relation: `markdown:${context.renderPath}`,
+      details: worst.preview,
+      conversationId: context.conversationId,
+      callSite: "guardMarkdownDelimiters",
+      raw: { messageId: context.messageId, violations }
+    });
+  } catch {
+  }
+}
+
+// source/thinking.ts
+function codeRanges2(text, live) {
+  const ranges = findCodeRanges(text).map((r) => [r.start, r.end]);
+  if (live) {
+    const pending = pendingCodeSpanStart(text);
+    if (pending >= 0 && !inCode(ranges, pending)) ranges.push([pending, text.length]);
+  }
+  return ranges.sort((x, y) => x[0] - y[0]);
+}
+function inCode(ranges, index) {
+  return ranges.some(([a, b]) => index >= a && index < b);
+}
+function collapseGaps(text) {
+  const ranges = codeRanges2(text, false);
+  let out = "";
+  let at = 0;
+  for (const [a, b] of ranges) {
+    out += text.slice(at, a).replace(/\n{3,}/g, "\n\n") + text.slice(a, b);
+    at = b;
+  }
+  return out + text.slice(at).replace(/\n{3,}/g, "\n\n");
+}
+var OPEN_TAG = /<(thinking|reasoning)\b[^>]*>/gi;
+function removeClosedBlocks(input, live) {
+  let text = input;
+  for (; ; ) {
+    const ranges = codeRanges2(text, live);
+    OPEN_TAG.lastIndex = 0;
+    let opener = null;
+    for (let m = OPEN_TAG.exec(text); m; m = OPEN_TAG.exec(text)) {
+      if (!inCode(ranges, m.index)) {
+        opener = m;
+        break;
+      }
+    }
+    if (!opener) return { text, openAt: -1 };
+    const closeTag = new RegExp(`</${opener[1]}\\s*>`, "gi");
+    closeTag.lastIndex = opener.index + opener[0].length;
+    let closer = null;
+    for (let m = closeTag.exec(text); m; m = closeTag.exec(text)) {
+      if (!inCode(ranges, m.index)) {
+        closer = m;
+        break;
+      }
+    }
+    if (!closer) return { text, openAt: opener.index };
+    text = text.slice(0, opener.index) + text.slice(closer.index + closer[0].length);
+  }
+}
+function stripThinking(input) {
+  if (!input) return "";
+  return collapseGaps(removeClosedBlocks(input, false).text).trim();
+}
+function hasThinkingTags(input) {
+  if (!input) return false;
+  return removeClosedBlocks(input, false).text !== input;
+}
+function stripThinkingStreaming(input) {
+  if (!input) return { visible: "", isThinking: false };
+  const { text, openAt } = removeClosedBlocks(input, true);
+  const isThinking = openAt !== -1;
+  const kept = isThinking ? text.slice(0, openAt) : text;
+  return { visible: collapseGaps(kept).replace(/^\s+/, ""), isThinking };
+}
+
 // source/code-range-edits.ts
 function unwrapCodeSpans(text) {
   if (!text.includes("`")) return text;
@@ -3294,6 +3486,6 @@ function trailingTableStart(lines, end = lines.length) {
   return end;
 }
 
-export { AFTER_WINDOW, BacktickRuns, CALLOUT_NAMES, DIRECTIVE_CONTAINER_OPEN, DirectiveContainerTracker, FENCE_META_KEY, FENCE_OPENER_WHITESPACE, FENCE_WHITESPACE, FenceReader, NESTING_FENCE_LANGUAGES, SourceSpliceError, TITLED_IMAGE_LINE, XmlContainerTracker, blockAt, blockEdit, blockRangeEdit, buildCodePointIndex, classifyInnerFenceLine, cleanMarkdown, closeFence, codeSpanText, collectLinkDefinitions, continuesTable, fenceLineKinds, fenceNestsInnerFences, fenceOpenerOf, fenceParts, findBalancedXmlClose, findCodeRanges, findInlineCodeSpans, findLinkDefinitionLines, findTableEnd, findTableStart, findWholeTableStart, hasUnclosedBacktickRun, indexOutsideInlineCode, initialXmlBalance, isEscapedBracketMath, isGfmDelimiterRow, isGrowingDelimiterRow, isHtmlBlockTagName, isInsideInlineCode, isMathPlaceholder, isPipeLedRow, isSingleDollarMath, islandEdit, joinSource, lineIndent, listIslands, looksLikeDisplayMath, looksLikeOpenInlineMath, mapCodeRanges, mapInlineCodeSpans, mapPosition, mapRange, markdownToPlainText, mathToReadable, normalizeLinkLabel, opensStrippedHtmlBlock, opensTable, pairDisplayMath, parseFenceMeta, parseFenceOpener, parseLineRanges, pendingCodeSpanStart, pendingDisplayMathOpener, readXmlTag, removeCodeSpans, replaceFences, resolveReferenceLinks, rowCells, singleDollarAfter, singleDollarMathEnd, soleFence, spliceSave, splitFenceInfo, splitRowSegments, splitsSurrogatePair, startsHtmlBlock, startsLikeTableRow, startsPipelessTable, tableContainerIndent, tableStartsAt, toCodePointOffset, toUtf16Offset, tokenizeSource, trailingTableStart, trimFenceLine, unescapeCellPipes, unwrapCodeSpans, unwrapKindEnvelopes };
+export { AFTER_WINDOW, BacktickRuns, CALLOUT_NAMES, DIRECTIVE_CONTAINER_OPEN, DirectiveContainerTracker, FENCE_META_KEY, FENCE_OPENER_WHITESPACE, FENCE_WHITESPACE, FenceReader, NESTING_FENCE_LANGUAGES, SourceSpliceError, TITLED_IMAGE_LINE, XmlContainerTracker, blockAt, blockEdit, blockRangeEdit, buildCodePointIndex, classifyInnerFenceLine, cleanMarkdown, closeFence, codeSpanText, collectLinkDefinitions, continuesTable, fenceLineKinds, fenceNestsInnerFences, fenceOpenerOf, fenceParts, findBalancedXmlClose, findCodeRanges, findInlineCodeSpans, findLinkDefinitionLines, findTableEnd, findTableStart, findWholeTableStart, guardMarkdownDelimiters, guardMathDelimiters, guardRunawayLinks, hasThinkingTags, hasUnclosedBacktickRun, indexOutsideInlineCode, initialXmlBalance, isEscapedBracketMath, isGfmDelimiterRow, isGrowingDelimiterRow, isHtmlBlockTagName, isInsideInlineCode, isMathPlaceholder, isPipeLedRow, isSingleDollarMath, islandEdit, joinSource, lineIndent, listIslands, looksLikeDisplayMath, looksLikeOpenInlineMath, mapCodeRanges, mapInlineCodeSpans, mapPosition, mapRange, markdownToPlainText, mathToReadable, normalizeLinkLabel, opensStrippedHtmlBlock, opensTable, pairDisplayMath, parseFenceMeta, parseFenceOpener, parseLineRanges, pendingCodeSpanStart, pendingDisplayMathOpener, readXmlTag, removeCodeSpans, replaceFences, reportDelimiterViolations, resolveReferenceLinks, rowCells, singleDollarAfter, singleDollarMathEnd, soleFence, spliceSave, splitFenceInfo, splitRowSegments, splitsSurrogatePair, startsHtmlBlock, startsLikeTableRow, startsPipelessTable, stripThinking, stripThinkingStreaming, tableContainerIndent, tableStartsAt, toCodePointOffset, toUtf16Offset, tokenizeSource, trailingTableStart, trimFenceLine, unescapeCellPipes, unwrapCodeSpans, unwrapKindEnvelopes };
 //# sourceMappingURL=source.js.map
 //# sourceMappingURL=source.js.map