perf(mothership): restore static markdown parse for settled chat messages

Settled/reloaded chat messages rendered through Streamdown's streaming
parser (remend + incomplete-markdown repair + per-block re-parse, running
the rehype raw/sanitize/harden chain once per block). Because rows are
virtualized, every up/down scroll remounted the messages crossing the
overscan boundary and re-paid that N-block cost — the scroll lag.

- Render never-streamed mounts (reloaded history, or an in-session message
  scrolled out of the virtualized window and back) with mode='static': one
  whole-document parse instead of streaming's per-block re-parse. In-session
  streaming keeps the streaming parser for its mount life (no drain flash).
- Cache Prism highlight output in a module-level bounded LRU so a code block
  re-highlights at most once across the unmount/remount virtualization does
  on scroll (a component useMemo would not survive the unmount).

Author: waleedlatif1

apps/sim/app/workspace/[workspaceId]/home/components/message-content/components/chat-content/chat-content.tsx

@@ -10,8 +10,9 @@ import 'prismjs/components/prism-typescript'
 import 'prismjs/components/prism-bash'
 import 'prismjs/components/prism-css'
 import 'prismjs/components/prism-markup'
+import type { Grammar } from 'prismjs'
 import '@sim/emcn/components/code/code.css'
-import { Checkbox, CopyCodeButton, cn, highlight, languages } from '@sim/emcn'
+import { Checkbox, CopyCodeButton, cn, languages, highlight as prismHighlight } from '@sim/emcn'
 import { decodeVfsSegmentSafe } from '@/lib/copilot/vfs/path-utils'
 import { extractTextContent } from '@/lib/core/utils/react-node-text'
 import { ContextMentionIcon } from '@/app/workspace/[workspaceId]/home/components/context-mention-icon'
@@ -161,6 +162,37 @@ function fileIconLabel(ref: string, fallback: string): string {
   return fallback
 }
 
+/**
+ * Prism highlighting is a pure function of (grammar, source) but costs several
+ * milliseconds per block. Chat rows are virtualized, so a message re-highlights
+ * every time it scrolls back into the overscan window — and a component-level
+ * `useMemo` would not survive the unmount between those scrolls. This
+ * module-level cache keeps the highlighted HTML across remounts, keyed by
+ * resolved language + source, so scrolling a code-heavy transcript re-highlights
+ * each block at most once. It is bounded by {@link HIGHLIGHT_CACHE_LIMIT} with
+ * LRU eviction so a long session cannot grow it without limit.
+ */
+const HIGHLIGHT_CACHE_LIMIT = 512
+const highlightCache = new Map<string, string>()
+
+function highlight(code: string, grammar: Grammar | undefined, language: string): string {
+  const key = `${language}\n${code}`
+  const cached = highlightCache.get(key)
+  if (cached !== undefined) {
+    // Move the hit to the newest slot so eviction sheds genuinely cold entries.
+    highlightCache.delete(key)
+    highlightCache.set(key, cached)
+    return cached
+  }
+  const html = prismHighlight(code, grammar, language)
+  highlightCache.set(key, html)
+  if (highlightCache.size > HIGHLIGHT_CACHE_LIMIT) {
+    const oldest = highlightCache.keys().next().value
+    if (oldest !== undefined) highlightCache.delete(oldest)
+  }
+  return html
+}
+
 const MARKDOWN_COMPONENTS = {
   table({ children }: { children?: React.ReactNode }) {
     return (
@@ -412,9 +444,9 @@ function ChatContentInner({
    * position (`E`/`qe` in streamdown 2.5), so a re-parse of unchanged content
    * without the animate plugin bails at every unoverridden element (`p`,
    * `strong`, `tr`, headings, …) and leaves the stale per-char span DOM in
-   * place. Every instance renders through the streaming parser (see
-   * `streamingTree` below) so the remount only sheds the spans, never
-   * re-interprets the markdown.
+   * place. The settled instance keeps the streaming parser (`parserTree`
+   * below) so the remount only sheds the spans, never re-interprets the
+   * markdown.
    *
    * The drain is deliberately one-way: a stream that resumes afterwards
    * (reconnect/continuation) reveals paced but unfaded, because re-arming
@@ -459,18 +491,28 @@ function ChatContentInner({
   }, [isRevealing, animationDrained, streamedThisSession])
 
   /**
-   * Every mount renders through the streaming parser (remend +
-   * incomplete-markdown repair + block-split) — `mode='static'` is never used.
-   * The two pipelines parse edge-case markdown differently (unbalanced fences,
-   * list continuation across blocks), so a message you watched stream would
-   * render subtly differently from the same message reloaded from the DB; one
-   * pipeline makes in-session and refreshed renders byte-identical. The rows
-   * are virtualized, so only visible messages pay the block-split mount cost.
-   * `streamingTree` (the remount key and animation props) still drops at
-   * drain, so a settled instance re-renders through the SAME parser minus the
-   * per-word animation spans — identical pixels.
+   * `parserTree` (drives `mode`) stays latched for the mount's life: streaming
+   * mode is the only one that applies remend/incomplete-markdown repair and
+   * block-split parsing, so an in-session message must KEEP the streaming
+   * parser once it has streamed — swapping to `mode='static'` at drain
+   * re-parses the same source through a different pipeline (no remend,
+   * whole-doc parse) and visibly flashes on any reply with unbalanced markdown.
+   * `streamingTree` (drives the remount key and animation props) additionally
+   * drops at drain, so the settled instance re-renders through the SAME parser
+   * minus the per-word animation spans — byte-identical pixels.
+   *
+   * A NEVER-streamed mount — reloaded history, or an in-session message
+   * scrolled out of the virtualized window and back — has `parserTree === false`
+   * for its whole life and renders `mode='static'`: one whole-document parse
+   * instead of streaming's per-block re-parse, which runs the rehype
+   * raw/sanitize/harden chain once PER block. Because chat rows are virtualized,
+   * every up/down scroll remounts the messages crossing the overscan boundary;
+   * paying streaming's N-block cost on those reloads is what made scrolling long
+   * transcripts lag, so the cheap static parse is the correct mode for settled
+   * content (a completed message needs no incomplete-markdown repair).
    */
-  const streamingTree = (isRevealing || streamedThisSession) && !animationDrained
+  const parserTree = isRevealing || streamedThisSession
+  const streamingTree = parserTree && !animationDrained
 
   /**
    * One-way fade cutoff (see {@link FADE_MAX_REVEALED_CHARS}). Latched so a
@@ -573,6 +615,7 @@ function ChatContentInner({
             >
               <Streamdown
                 key={streamingTree ? 'stream' : 'settled'}
+                mode={parserTree ? undefined : 'static'}
                 animated={fadeActive ? STREAM_ANIMATION : false}
                 isAnimating={streamingTree}
                 components={MARKDOWN_COMPONENTS}