@flamingo-stack/openframe-frontend-core 0.0.488 → 0.0.490-1506.3944.1

package/src/components/ui/markdown/simple-markdown-renderer.tsx

@@ -0,0 +1,28 @@
+"use client";
+
+/**
+ * SimpleMarkdownRenderer — the chat/doc composition over the unified
+ * `MarkdownEngine`. This IS the real component (not a compat alias): the
+ * old 966-line standalone implementation was deleted in the unification;
+ * its entire prop surface maps 1:1 onto the engine. Chat consumers keep
+ * layering `additionalRemarkPlugins` (card/mention links) and
+ * `componentOverrides` exactly as before.
+ */
+import React from 'react';
+import { MarkdownEngine, type MarkdownEngineProps } from './engine';
+import type { ResolveLinkResult } from '../../../types/doc-source';
+
+export type { ResolveLinkResult };
+
+export interface SimpleMarkdownRendererProps
+  extends Omit<MarkdownEngineProps, 'extraAllowedHtmlTags'> {}
+
+/**
+ * A type-narrowed ALIAS of the engine, not a wrapper: the composition adds
+ * no behavior (it only hides `extraAllowedHtmlTags` from the prop surface),
+ * and `MarkdownEngine` is already `memo`'d. Wrapping it in a second `memo`
+ * bought nothing and cost an extra shallow-compare pass plus a fiber per
+ * chat segment.
+ */
+export const SimpleMarkdownRenderer =
+  MarkdownEngine as React.NamedExoticComponent<SimpleMarkdownRendererProps>;

package/src/components/ui/markdown/streaming.ts

@@ -0,0 +1,362 @@
+/**
+ * Streaming helpers for the unified markdown engine (pure, no React).
+ *
+ * Design contract (unification plan §D1 "Streaming rendering performance"):
+ * - Markdown is NOT context-free across blocks. The splitter only cuts at
+ *   boundaries it can PROVE are atomic; when atomicity is unprovable the
+ *   content is left in one unit (unmemoized) — correctness beats cache hits.
+ * - Blocks containing `card://` / `mention://` markers are never memoized:
+ *   their text is identical before/after the entity ref resolves, so a
+ *   text-keyed cache would serve the stale unresolved card mid-stream.
+ * - On stream completion the engine discards all of this and does ONE
+ *   authoritative whole-document parse — streaming can never permanently
+ *   diverge (late reference defs, footnotes, list renumbering self-heal).
+ * - Tail completion auto-closes ONLY unterminated fenced code blocks
+ *   (fence-count based — unambiguous). Inline emphasis/links are NOT
+ *   auto-closed: a stray `*` in "2 * 3" or a non-link `[` would be
+ *   mis-wrapped, which is worse than the brief flicker it prevents.
+ */
+
+import { createFenceTracker, isBlankLine, type FenceTracker } from '../../../utils/markdown-fences'
+
+export interface StreamingBlock {
+  /** Raw markdown source of this unit (including trailing blank lines). */
+  text: string
+  /** Position index — cache key component so identical blocks never alias. */
+  index: number
+  /**
+   * 1-based line of this unit's first line WITHIN the whole document.
+   * Each unit is parsed by its own `ReactMarkdown`, so hast positions are
+   * unit-relative; the engine adds `startLine - 1` back to look ids up in
+   * the document-wide heading-id map (see ./heading-ids.ts).
+   */
+  startLine: number
+  /**
+   * True when this unit may be render-cached: it is complete (not the
+   * trailing unit), atomic, and free of cross-block / late-resolving
+   * constructs (card/mention markers, reference definitions/uses,
+   * footnotes).
+   */
+  memoizable: boolean
+}
+
+/** Constructs that resolve across blocks or after the text settles. */
+const NON_MEMOIZABLE_RE = /card:\/\/|mention:\/\/|^\s*\[[^\]]*\]:\s|\]\[|\[\^/m
+
+/**
+ * Raw HTML block-level containers. A blank line inside an OPEN one of these
+ * is not a block boundary: cutting there hands react-markdown an unbalanced
+ * fragment, so the container's body renders outside the container and the
+ * stray close tag is dropped (`<details>` disclosure bodies escaping the
+ * widget mid-stream — and the wrong render getting cached).
+ */
+const RAW_BLOCK_TAGS = new Set([
+  'details', 'div', 'table', 'section', 'article', 'aside', 'blockquote',
+  'figure', 'form', 'fieldset', 'header', 'footer', 'main', 'nav', 'dl',
+  'ol', 'ul', 'pre', 'video', 'audio', 'picture', 'iframe', 'template',
+  'svg',
+])
+
+/** `<tag …>` / `</tag>` occurrences, used for raw-HTML depth tracking. */
+const HTML_TAG_RE = /<(\/?)([a-zA-Z][a-zA-Z0-9-]*)([^>]*)>/g
+
+/**
+ * A start tag whose `>` has NOT arrived yet on this line
+ * (`<div\n  class="x">`). Only the trailing occurrence matters, and only
+ * for RAW_BLOCK_TAGS — restricting it there keeps prose like `a <b` from
+ * latching the scanner into "inside a tag" forever.
+ */
+const DANGLING_OPEN_TAG_RE = /<([a-zA-Z][a-zA-Z0-9-]*)(?:\s[^>]*)?$/
+
+/**
+ * A line that may START a raw HTML block. CommonMark puts the `<` at column
+ * 0..3, but a raw HTML block nested in a list item is indented to the item's
+ * CONTENT column (`1.  step` → 4, and up to 7 for a wide ordered marker).
+ * The old column-0..3 gate missed exactly those, so an unbalanced raw-HTML
+ * container nested in a list item never shifted the scanner's depth and its
+ * unit was marked memoizable — contradicting the "unbalanced raw-HTML units
+ * are never cached" policy this module documents.
+ */
+const HTML_BLOCK_START_RE = /^\s{0,7}<\/?[a-zA-Z]/
+
+/**
+ * Cap on how long the raw-HTML latch may suppress cutting. An unclosed
+ * `<div>` (or a start tag whose `>` never arrives) would otherwise pin
+ * `htmlDepth > 0` for the ENTIRE remaining message, collapsing it into one
+ * ever-growing non-memoizable unit and disabling the atomic-block
+ * optimization outright.
+ *
+ * THE TRADEOFF, STATED HONESTLY: past the cap the splitter resumes cutting
+ * even though a container is still open, so a genuinely >200-line authored
+ * `<div>` / `<table>` wrapper IS cut mid-container and visibly breaks apart
+ * while streaming (its body renders outside the wrapper, the stray close tag
+ * is dropped). Those units are still marked non-memoizable, so nothing WRONG
+ * is ever cached and the stream-completion whole-document reparse restores
+ * the correct structure — but during the stream the render is wrong, not
+ * merely uncached. (An earlier comment here claimed "never a wrong render";
+ * that was only true below the cap.)
+ *
+ * The cap is kept because the alternative — never cutting while latched —
+ * makes ONE unbounded unit out of every message containing an unclosed tag,
+ * which is the common case (an LLM mid-emission always has one) and costs a
+ * full reparse of the entire message on every token.
+ */
+const HTML_LATCH_LINE_LIMIT = 200
+
+/**
+ * Two properties of the fence tracker, stated so they stop being accidents.
+ * A reviewer confirmed both hold today, but neither was written down, so a
+ * future change could quietly break them.
+ *
+ * 1. EOF ON THE OPENER LINE EMITS AN EMPTY PAIR. When the stream stops exactly
+ *    on a fence opener, `completeStreamingTail` closes it at EOF and the render
+ *    contains a bare ```/``` — a momentarily empty `<pre>`. It is cosmetic and
+ *    self-heals on the next delta. Do NOT "fix" it by suppressing the close:
+ *    that leaks an unterminated fence into the parse instead, which is worse.
+ *
+ * 2. THIS SCANNER AND THE SANITIZER'S MASK CAN DISAGREE ABOUT WHICH FENCE IS
+ *    OPEN, AND BOTH MUST FAIL CLOSED. `scanLine`'s `pendingOpenTag` early
+ *    return skips `fences.push`, so a fence opened on a line consumed by an
+ *    unclosed HTML tag is never recorded here — while `sanitize.ts`'s
+ *    `blankFencedRegions` runs its own tracker over the same text and may see
+ *    it. The divergence is safe ONLY because each consumer degrades toward
+ *    doing less: `completeStreamingTail` closes nothing it did not see open,
+ *    and `blankFencedRegions` blanks nothing it cannot locate, so the output
+ *    degrades to "render as-is" rather than to a corrupted document. Any
+ *    change to the early return, to `fences` bookkeeping, or to either
+ *    consumer must preserve fail-closed behaviour in BOTH directions
+ *    (scanner-ahead and scanner-behind).
+ */
+
+/**
+ * Line-scanner state shared by `splitStreamingBlocks` and
+ * `completeStreamingTail` — ONE implementation of "where are we in the
+ * document", so the splitter and the tail-completer can never disagree
+ * about which fence is open.
+ */
+interface ScanState {
+  /**
+   * Fenced-code state machine. NOT a local copy: `createFenceTracker` lives
+   * in the server-safe `utils/markdown-fences` and is the SAME instance
+   * shape the heading scanner uses, so "is this line inside a fence" has
+   * exactly one definition. The previous duplicate here (a verbatim
+   * `FENCE_RE` plus its own open/close state machine, cross-referenced by a
+   * comment) is precisely the drift that produced the `~~~` bug.
+   */
+  fences: FenceTracker
+  /** Depth of currently open raw HTML block containers. */
+  htmlDepth: number
+  /** Raw-block tag name of a start tag still waiting for its `>`, or null. */
+  pendingOpenTag: string | null
+  /** Consecutive lines spent with the raw-HTML latch engaged. */
+  htmlLatchLines: number
+}
+
+function createScanState(): ScanState {
+  return {
+    fences: createFenceTracker(),
+    htmlDepth: 0,
+    pendingOpenTag: null,
+    htmlLatchLines: 0,
+  }
+}
+
+/** Raw-HTML state is unbalanced (a container or a start tag is still open). */
+function htmlLatched(state: ScanState): boolean {
+  return state.htmlDepth > 0 || state.pendingOpenTag !== null
+}
+
+/** True while raw-HTML state forbids cutting (latch cap not yet reached). */
+function htmlBlocksCut(state: ScanState): boolean {
+  return htmlLatched(state) && state.htmlLatchLines <= HTML_LATCH_LINE_LIMIT
+}
+
+/** Scan `line` from `from` for complete tags, then record any dangling opener. */
+function scanTags(state: ScanState, line: string, from: number): void {
+  HTML_TAG_RE.lastIndex = from
+  let m: RegExpExecArray | null
+  let end = from
+  while ((m = HTML_TAG_RE.exec(line)) !== null) {
+    end = HTML_TAG_RE.lastIndex
+    const tag = m[2].toLowerCase()
+    if (!RAW_BLOCK_TAGS.has(tag)) continue
+    if (m[1] === '/') {
+      if (state.htmlDepth > 0) state.htmlDepth--
+    } else if (!m[3].trimEnd().endsWith('/')) {
+      state.htmlDepth++
+    }
+  }
+  const dangling = DANGLING_OPEN_TAG_RE.exec(line.slice(end))
+  if (dangling && RAW_BLOCK_TAGS.has(dangling[1].toLowerCase())) {
+    state.pendingOpenTag = dangling[1].toLowerCase()
+  }
+}
+
+/** Advance `state` across one raw source line (mutates). */
+function scanLine(state: ScanState, line: string): void {
+  // A start tag spanning lines wins over everything: its continuation lines
+  // are attribute soup, not markdown.
+  if (state.pendingOpenTag !== null) {
+    const gt = line.indexOf('>')
+    if (gt === -1) {
+      state.htmlLatchLines++
+      return
+    }
+    const selfClosing = line.slice(0, gt).trimEnd().endsWith('/')
+    const tag = state.pendingOpenTag
+    state.pendingOpenTag = null
+    if (!selfClosing && RAW_BLOCK_TAGS.has(tag)) state.htmlDepth++
+    scanTags(state, line, gt + 1)
+    state.htmlLatchLines = htmlLatched(state) ? state.htmlLatchLines + 1 : 0
+    return
+  }
+
+  // Fence delimiters and fence content are both opaque to the HTML scanner —
+  // only `text` lines carry markup that can shift raw-HTML depth.
+  if (state.fences.push(line) !== 'text') return
+
+  // Depth > 0 means we are INSIDE a container, where the closing tag may sit
+  // anywhere on a line (`some text </details>`). Scanning only column-0..3
+  // lines there meant such a close never decremented, so the latch stuck.
+  // At depth 0 only a line that can BEGIN a raw HTML block is considered, so
+  // `a < b` prose can't shift depth.
+  if (state.htmlDepth === 0 && !HTML_BLOCK_START_RE.test(line)) return
+  scanTags(state, line, 0)
+  state.htmlLatchLines = htmlLatched(state) ? state.htmlLatchLines + 1 : 0
+}
+
+/**
+ * Split streaming markdown into atomic units at blank lines that are
+ * provably block boundaries. A blank line does NOT split when:
+ *  - inside a fenced code block,
+ *  - the next non-blank line is indented (loose-list / blockquote
+ *    continuation cannot be ruled out),
+ *  - the next non-blank line starts a list item or blockquote AND the
+ *    previous unit ended in a list item or blockquote (loose list /
+ *    multi-paragraph quote continuation).
+ * The FINAL unit is always the live tail (never memoizable).
+ *
+ * BLANK LINES COME FROM `isBlankLine` (utils/markdown-fences), never from
+ * `String.prototype.trim()`. This file is the THIRD consumer of that module
+ * (it already instantiates `createFenceTracker`) and makes exactly the
+ * CommonMark blank-line decision the helper was minted for, yet it kept four
+ * hand-rolled `trim() === ''` tests — so the module's "every blank-line test"
+ * SSOT claim was false here. `trim()` strips the full Unicode White_Space set
+ * (U+00A0 NBSP, U+000B VT, U+000C FF, U+FEFF BOM), none of which CommonMark
+ * treats as blank: `splitStreamingBlocks('foo\n<NBSP>\nbar\n\ntail')` returned
+ * THREE units where the non-blank filler control (`foo\nx\nbar\n\ntail`)
+ * returns TWO — one NBSP line cut a paragraph into two `ReactMarkdown` units on
+ * the STREAMING path, rendering two `<p>` where the non-streaming and SEO twins
+ * render one. Not a security hole (the fence tracker and `htmlBlocksCut` still
+ * gate the cut), but a live divergence. It survived because the swallow sweep
+ * drove only `SimpleMarkdownRenderer`; the sweep now drives this splitter too,
+ * in both the exotic-blank and CRLF spellings.
+ */
+export function splitStreamingBlocks(content: string): StreamingBlock[] {
+  const lines = content.split('\n')
+  const units: string[][] = []
+  const unitTouchedHtml: boolean[] = []
+  let current: string[] = []
+  let currentTouchedHtml = false
+  const state = createScanState()
+
+  const isListOrQuote = (line: string) =>
+    /^\s{0,3}(?:[-+*]\s|\d{1,9}[.)]\s|>)/.test(line)
+
+  const lastNonBlank = (arr: string[]): string | undefined => {
+    for (let i = arr.length - 1; i >= 0; i--) {
+      if (!isBlankLine(arr[i])) return arr[i]
+    }
+    return undefined
+  }
+
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i]
+    const depthBefore = state.htmlDepth
+    const pendingBefore = state.pendingOpenTag
+    scanLine(state, line)
+    if (
+      state.htmlDepth !== depthBefore ||
+      state.pendingOpenTag !== pendingBefore ||
+      htmlLatched(state)
+    )
+      currentTouchedHtml = true
+    current.push(line)
+
+    const isBlank = isBlankLine(line)
+    // Never cut inside an open fence, nor inside an unbalanced raw HTML
+    // block container / a start tag still waiting for its `>`.
+    if (!isBlank || state.fences.openChar() !== null || htmlBlocksCut(state)) continue
+
+    // Candidate boundary at a blank line outside fences. Look ahead to the
+    // next non-blank line to decide whether cutting here is provably safe.
+    let j = i + 1
+    while (j < lines.length && isBlankLine(lines[j])) j++
+    if (j >= lines.length) continue // trailing blanks stay with the tail
+
+    const next = lines[j]
+    if (/^\s/.test(next)) continue // indented continuation — unprovable
+    const prev = lastNonBlank(current)
+    if (isListOrQuote(next) && prev !== undefined && isListOrQuote(prev)) {
+      // Loose list / multi-paragraph blockquote continuation — do not cut.
+      continue
+    }
+
+    // A unit whose entire content is whitespace is not a block — with 2+
+    // blank lines between blocks the loop reaches a cut point with nothing
+    // but blanks accumulated, and emitting it costs a `ReactMarkdown`
+    // instance (and a React key) that renders nothing. Leave `current`
+    // accumulating so the blanks fold into the NEXT unit; line numbering
+    // (and therefore `startLine`) is unaffected either way.
+    if (current.every(isBlankLine)) continue
+
+    units.push(current)
+    unitTouchedHtml.push(currentTouchedHtml)
+    current = []
+    currentTouchedHtml = false
+  }
+  if (current.length) {
+    units.push(current)
+    unitTouchedHtml.push(currentTouchedHtml)
+  }
+
+  let cursorLine = 1
+  return units.map((unitLines, idx) => {
+    const text = unitLines.join('\n')
+    const isTail = idx === units.length - 1
+    const startLine = cursorLine
+    cursorLine += unitLines.length
+    return {
+      text,
+      index: idx,
+      startLine,
+      // Units carrying UNBALANCED raw HTML are never cached: an open
+      // container (or a start tag still awaiting its `>`) is exactly the
+      // case where rehype-raw's reparse makes a stale cached render
+      // structurally wrong rather than merely late. A raw container that
+      // opens AND closes within the unit (`<div>x</div>`) leaves the
+      // scanner's depth unchanged, so it stays memoizable — correctly: its
+      // parse cannot be invalidated by later tokens.
+      memoizable: !isTail && !unitTouchedHtml[idx] && !NON_MEMOIZABLE_RE.test(text),
+    }
+  })
+}
+
+/**
+ * Auto-close an unterminated fenced code block at the streaming tail so the
+ * half-open fence doesn't flip the rest of the message into code while
+ * tokens arrive.
+ *
+ * Uses the SAME scanner as `splitStreamingBlocks` (never a parallel
+ * fence-count heuristic — a naive count treats ``` and ~~~ as
+ * interchangeable and appends a spurious closer to `` ```\n~~~\n``` ``),
+ * and appends the RECORDED opener so a `~~~` block is closed with `~~~`.
+ */
+export function completeStreamingTail(content: string): string {
+  const state = createScanState()
+  for (const line of content.split('\n')) scanLine(state, line)
+  const openChar = state.fences.openChar()
+  if (openChar === null) return content
+  const closer = openChar.repeat(state.fences.openLength())
+  return content.endsWith('\n') ? `${content}${closer}` : `${content}\n${closer}`
+}

package/src/components/ui/markdown/text-size.ts

@@ -0,0 +1,106 @@
+/**
+ * Text-size presets for the unified markdown engine.
+ *
+ * `default` / `compact` / `large` are carried over verbatim from the old
+ * `SimpleMarkdownRenderer`. `article` is NEW — it reproduces the exact
+ * typography the old `RichMarkdownRenderer` hardcoded per element, so
+ * content surfaces (blog, case studies, releases, legal, docs) keep
+ * byte-identical classes through the unification.
+ *
+ * ODS-TOKENS FLAG (ODS_TOKEN_RULES §Typography / §General): the `article`
+ * preset carries raw px classes (`text-[32px] md:text-[40px] …`) because
+ * ODS currently has NO composite tokens for long-form prose — `text-h1`/
+ * `text-h2` are Azeret Mono UI-label scale and `text-h5` is uppercase,
+ * so mapping prose headings onto them would visibly regress articles.
+ * The `code` entry of EVERY preset (`text-[13px]` / `text-[14px]` /
+ * `text-[16px]`), not just `article`'s, is raw px for the same reason: ODS
+ * has no code/mono type scale. `base-components.tsx` carries the matching
+ * flag for inline code's `text-[0.9em]` (the mono FAMILY is no longer an
+ * exemption — both code surfaces now use `font-mono`).
+ * Per the unification plan, the missing prose- and code-typography tokens
+ * are FLAGGED here for addition to ODS; the raw-px carry-over is the
+ * documented, review-gated exemption recorded in the unification PR.
+ * Do NOT copy these px classes anywhere else.
+ */
+
+export type TextSizeElement =
+  | 'h1' | 'h2' | 'h3' | 'h4' | 'h5' | 'h6'
+  | 'p' | 'li' | 'blockquote' | 'code' | 'th' | 'td';
+
+export type TextSizeClassMap = Partial<Record<TextSizeElement, string>>;
+export type TextSizePreset = 'default' | 'compact' | 'large' | 'article';
+export type TextSizeConfig =
+  | TextSizePreset
+  | TextSizeClassMap
+  | { preset: TextSizePreset; overrides: TextSizeClassMap };
+
+export const TEXT_SIZE_PRESETS: Record<TextSizePreset, Record<TextSizeElement, string>> = {
+  default: {
+    h1: 'text-heading-1',
+    h2: 'text-heading-2',
+    h3: 'text-2xl md:text-3xl',
+    h4: 'text-xl',
+    h5: 'text-lg md:text-xl',
+    h6: 'text-base md:text-lg',
+    p: 'md:text-h4 lg:text-h4',
+    li: 'text-base md:text-lg',
+    blockquote: 'text-lg',
+    code: 'text-[14px]',
+    th: 'text-xs md:text-sm',
+    td: 'text-xs md:text-sm',
+  },
+  compact: {
+    h1: 'text-heading-2',
+    h2: 'text-heading-3',
+    h3: 'text-xl md:text-2xl',
+    h4: 'text-lg md:text-xl',
+    h5: 'text-base md:text-lg',
+    h6: 'text-sm md:text-base',
+    p: 'text-base md:text-lg',
+    li: 'text-base md:text-lg',
+    blockquote: 'text-base md:text-lg',
+    code: 'text-[13px]',
+    th: 'text-xs md:text-sm',
+    td: 'text-xs md:text-sm',
+  },
+  large: {
+    h1: 'text-heading-1',
+    h2: 'text-heading-1',
+    h3: 'text-heading-2',
+    h4: 'text-2xl md:text-3xl',
+    h5: 'text-xl md:text-2xl',
+    h6: 'text-lg md:text-xl',
+    p: 'text-h3',
+    li: 'text-lg md:text-xl',
+    blockquote: 'text-xl md:text-2xl',
+    code: 'text-[16px]',
+    th: 'text-sm md:text-base',
+    td: 'text-sm md:text-base',
+  },
+  // Old RichMarkdownRenderer typography, byte-for-byte (see header note).
+  article: {
+    h1: 'text-[32px] md:text-[40px] lg:text-[48px] leading-[1.25]',
+    h2: 'text-[28px] md:text-[32px]',
+    h3: 'text-[24px] md:text-[28px]',
+    h4: 'text-[20px] md:text-[22px]',
+    h5: 'text-[18px] md:text-[20px]',
+    h6: 'text-[16px] md:text-[18px]',
+    // Full class string incl. spacing/leading — `cn` (tailwind-merge)
+    // resolves these OVER the base map's `leading-relaxed mb-4`, keeping
+    // Rich's article rhythm (`my-4`, `leading-[1.6]`, `font-sans`).
+    p: 'font-sans text-[16px] md:text-[18px] lg:text-[20px] leading-[1.6] my-4',
+    li: 'text-[16px] md:text-[18px]',
+    blockquote: 'text-[1.125em]',
+    code: 'text-[14px]',
+    th: 'text-xs md:text-sm',
+    td: 'text-xs md:text-sm',
+  },
+};
+
+export function resolveTextSizeConfig(config?: TextSizeConfig): Record<TextSizeElement, string> {
+  const defaultSizes = TEXT_SIZE_PRESETS.default;
+  if (!config) return defaultSizes;
+  if (typeof config === 'string') return TEXT_SIZE_PRESETS[config];
+  if ('preset' in config) return { ...TEXT_SIZE_PRESETS[config.preset], ...config.overrides };
+  return { ...defaultSizes, ...config };
+}

package/src/components/ui/release-changelog-section.tsx

@@ -4,7 +4,7 @@ import React, { useState } from 'react';
 import { Badge } from './badge';
 import { ChevronDown } from 'lucide-react';
 import { FadePreview } from './fade-preview';
-import { RichMarkdownRenderer } from './rich-markdown-renderer';
+import { RichMarkdownRenderer } from './markdown';
 import type { ChangelogEntry } from '../../types/product-release';
 
 interface ReleaseChangelogSectionProps {

package/src/components/ui/ticket-info-section.tsx

@@ -12,7 +12,7 @@ import { TicketDetailSection } from "./ticket-detail-section"
 import { type TicketAttachment, TicketAttachmentsList } from "./ticket-attachments-list"
 import type { TicketNote } from "./ticket-note-card"
 import { TicketNotesSection } from "./ticket-notes-section"
-import { SimpleMarkdownRenderer } from "./simple-markdown-renderer"
+import { SimpleMarkdownRenderer } from "./markdown/simple-markdown-renderer"
 
 export type { TicketAssigneeOption }
 

package/src/contexts/chat-runtime-context.tsx

@@ -57,6 +57,14 @@ export interface ChatRuntime {
     listEngagementsUrl?: string
     /** GET slash-command catalog. Hub: '/api/docs/commands'. */
     commandsUrl: string
+    /** GET server-side conversation history (`?conversationId=<id>`) — the
+     *  chat panel's mount-time hydration read against the server transcript
+     *  store (localStorage keeps only the server-issued conversation id).
+     *  OPTIONAL — defaults to `<chatStreamUrl>/history`, which is correct for
+     *  same-origin hosts AND for reverse-proxy embedders (the proxied chat
+     *  prefix covers it). Set explicitly only when the history route lives
+     *  elsewhere. */
+    chatHistoryUrl?: string
     /** GET RAG-search endpoint behind `<DocSearchBar>` (the in-source search
      *  bar mounted by `<DocViewer>` / `<DocsHubPage>` when `showAIChat` is on).
      *  Hub: '/api/docs/search'. OPTIONAL — falls back to the hub path so

package/src/utils/index.ts

@@ -334,6 +334,7 @@ export * from './humanity-signals'
 export * from './doc-path-utils'
 export * from './doc-tree-nav'
 export * from './tree-builder'
+export * from './markdown-heading-id'
 export * from './markdown-section-extractor'
 export * from './markdown-to-plain'
 export * from './embed-url-converters'

package/src/utils/markdown-fences.ts

@@ -0,0 +1,127 @@
+/**
+ * Fenced-code tracker — THE definition of "am I inside a code fence".
+ * Server-safe: no React, no DOM.
+ *
+ * Lives in its own module because it is a GENERAL CommonMark fence machine
+ * with two unrelated consumers: the heading scanner
+ * (`utils/markdown-heading-id`) and the streaming block splitter
+ * (`components/ui/markdown/streaming`). It used to live inside
+ * `markdown-heading-id`, which meant a streaming renderer imported its fence
+ * state machine from a module named after heading slugs. `markdown-heading-id`
+ * re-exports these names so the public `utils` surface is unchanged.
+ */
+
+/**
+ * CommonMark fenced-code opener/closer. Fence indent is capped at 3 spaces
+ * (4+ is an indented code block, whose backticks are literal content), and the
+ * run length is captured so a closer can be required to be at least as long as
+ * its opener. Matched on the RAW line — `trimStart()` would let a fence inside
+ * 4-space-indented code toggle the state.
+ *
+ * `\r`-TOLERANT BY CONSTRUCTION. The previous spelling ended `(.*)$`, and `.`
+ * excludes `\r` while `$` (no `m` flag) anchors at end of input — so on a CRLF
+ * document, split on `\n`, NO line ever matched and the tracker was completely
+ * fence-blind: `['```js\r','const a = 1\r','```\r','after\r']` classified as
+ * four `text` lines where the LF spelling gives `open/inside/close/text`. The
+ * sanitizer's closer haystack then never blanked the fenced region, so a
+ * `</textarea>` written as a CRLF code sample satisfied `hasLaterCloser` and a
+ * prose `<textarea>` above it stayed LIVE (reproduced in the DOM; the LF twin
+ * of the same fixture escapes correctly). The `\r` is absorbed by `\r?$` rather
+ * than normalized out of the text, because the sanitizer's mask is
+ * LENGTH-PRESERVING and every offset in it is an index into the original
+ * string — stripping `\r` would shift them all.
+ *
+ * THE ONLY COPY. This constant plus its open/close state machine used to be
+ * duplicated verbatim in `components/ui/markdown/streaming.ts`, kept in sync
+ * by a code comment — which is exactly how the `~~~`-blind extractor drifted
+ * in the first place. Both consumers now instantiate `createFenceTracker()`.
+ */
+const FENCE_RE = /^ {0,3}(`{3,}|~{3,})([^\n]*?)\r?$/
+
+/**
+ * CommonMark's BLANK LINE — spaces and tabs only. The single definition, shared
+ * by every consumer of this module (the sanitizer's mask passes, the heading
+ * scanner, the HTML-block range walk).
+ *
+ * NOT `String.prototype.trim()`. JS `trim()` strips the full Unicode
+ * White_Space set — U+00A0 NBSP, U+000B VT, U+000C FF, U+2028/9, U+FEFF BOM —
+ * none of which CommonMark (or remark) treats as blank. Every place that meant
+ * "is this a CommonMark blank line?" and asked `trim() === ''` therefore
+ * TERMINATED a construct one line early while remark kept it open. Verified
+ * end-to-end: `<div>\n \n\`<textarea>\`\n\nrest\n` left a LIVE `<textarea>`
+ * in the DOM (`escapeUnknownHtmlTags` returned the input byte-identical),
+ * because the tracked HTML-block range ended at the NBSP filler line and the
+ * inline-code shelter below it stopped being inside a tracked block. Same for
+ * VT / FF / BOM, for `<pre>` / `<details>` wrappers, and for a live third-party
+ * `<iframe>`.
+ *
+ * `\r` IS accepted: a CRLF document split on `\n` spells its blank lines
+ * `"\r"`, and the mask is length-preserving so stripping `\r` from the source
+ * is not an option (see `FENCE_RE`'s `\r?$`).
+ */
+const BLANK_LINE_RE = /^[ \t\r]*$/
+
+/** True when `line` is a CommonMark blank line (spaces/tabs only, `\r`-tolerant). */
+export function isBlankLine(line: string): boolean {
+  return BLANK_LINE_RE.test(line)
+}
+
+/**
+ * What one source line is, relative to fenced code:
+ *  - `open`  — this line opened a fence
+ *  - `close` — this line closed the open fence
+ *  - `inside`— this line is fence content (including a would-be delimiter that
+ *              does NOT close the open fence: wrong marker char, too short, or
+ *              carrying an info string)
+ *  - `text`  — this line is ordinary markdown outside any fence
+ *
+ * NOTE: no consumer discriminates the three non-`text` roles today — both the
+ * heading scanner and the streaming splitter only test `!== 'text'`, and the
+ * closer-haystack mask below only tests `=== 'open'` / `=== 'close'`. The
+ * four-value union is kept because the state machine already computes the
+ * distinction for free and a future consumer (e.g. fence-aware syntax
+ * post-processing) would otherwise have to re-derive it.
+ */
+export type FenceLineRole = 'open' | 'close' | 'inside' | 'text'
+
+export interface FenceTracker {
+  /** Advance across one raw source line (mutates) and classify it. */
+  push(line: string): FenceLineRole
+  /** Marker CHARACTER of the currently open fence (`` ` `` / `~`), or null. */
+  openChar(): string | null
+  /** Run length of the currently open fence (a closer must be ≥ this). */
+  openLength(): number
+}
+
+/** A fresh fenced-code state machine. Server-safe: no React, no DOM. */
+export function createFenceTracker(): FenceTracker {
+  let fenceChar: string | null = null
+  let fenceLength = 0
+  return {
+    push(line: string): FenceLineRole {
+      const fence = FENCE_RE.exec(line)
+      if (fence) {
+        const run = fence[1]
+        if (fenceChar === null) {
+          fenceChar = run[0]
+          fenceLength = run.length
+          return 'open'
+        }
+        // A closer must use the SAME marker char, be at least as long as the
+        // opener, and (per CommonMark) carry no info string. "No info string"
+        // means spaces/tabs only — `trim()` would accept an NBSP tail and close
+        // a fence CommonMark keeps open, i.e. blank LESS of the haystack
+        // (fail-OPEN). Hence `isBlankLine`, not `trim()`.
+        if (run[0] === fenceChar && run.length >= fenceLength && isBlankLine(fence[2])) {
+          fenceChar = null
+          fenceLength = 0
+          return 'close'
+        }
+        return 'inside'
+      }
+      return fenceChar === null ? 'text' : 'inside'
+    },
+    openChar: () => fenceChar,
+    openLength: () => fenceLength,
+  }
+}