perf(file-viewer): cap the round-trip probe at 24KB and coalesce streaming syncs

@tiptap/markdown's parse is superlinear (~O(n2)) in document size — measured ~170ms
at 11KB, ~875ms at 23KB, multiple seconds past ~35KB — and it runs synchronously at
mount inside the round-trip-safety probe (twice) and the editor's own setContent. The
128KB cap allowed multi-second main-thread freezes; lower it to 24KB so the worst-case
mount stays near a second while still covering the vast majority of real markdown files
(larger files open read-only). Separately, coalesce streaming chunk-syncs to one re-parse
per animation frame so a fast-streaming agent doesn't re-parse the whole accumulating
doc per token. Typing latency was measured to be already excellent (sub-ms median, no
change needed); the only hot cost was the mount parse.

Author: waleedlatif1

apps/sim/app/workspace/[workspaceId]/files/components/file-viewer/rich-markdown-editor/rich-markdown-editor.tsx

@@ -278,20 +278,39 @@ export function LoadedRichMarkdownEditor({
   // `previewContextKey` (the chat id) keeps this instance mounted across those edits — so the verdict
   // + frontmatter must be re-derived per stream, not frozen on the first settled snapshot.
   const wasStreamingRef = useRef(streamingAtMountRef.current)
+  // Coalesce streaming chunk-syncs to one re-parse per animation frame. A fast-streaming agent emits
+  // many chunks per frame; without this each one re-parses the whole accumulating markdown
+  // (`@tiptap/markdown`'s parse is superlinear), saturating the main thread. The editor is read-only
+  // while streaming, so only the latest frame's content needs to render.
+  const pendingStreamBodyRef = useRef<string | null>(null)
+  const streamRafRef = useRef<number | null>(null)
   useEffect(() => {
     if (!editor) return
     if (isStreaming) {
       wasStreamingRef.current = true
       const body = splitFrontmatter(content).body
       if (body === lastSyncedBodyRef.current) return
-      lastSyncedBodyRef.current = body
-      const el = containerRef.current
-      const pinnedToBottom = el ? el.scrollHeight - el.scrollTop - el.clientHeight < 80 : false
-      editor.setEditable(false)
-      editor.commands.setContent(body, { contentType: 'markdown', emitUpdate: false })
-      if (!disableStreamingAutoScroll && el && pinnedToBottom) el.scrollTop = el.scrollHeight
+      pendingStreamBodyRef.current = body
+      if (streamRafRef.current !== null) return
+      streamRafRef.current = requestAnimationFrame(() => {
+        streamRafRef.current = null
+        const pending = pendingStreamBodyRef.current
+        if (pending === null || pending === lastSyncedBodyRef.current) return
+        lastSyncedBodyRef.current = pending
+        const el = containerRef.current
+        const pinnedToBottom = el ? el.scrollHeight - el.scrollTop - el.clientHeight < 80 : false
+        editor.setEditable(false)
+        editor.commands.setContent(pending, { contentType: 'markdown', emitUpdate: false })
+        if (!disableStreamingAutoScroll && el && pinnedToBottom) el.scrollTop = el.scrollHeight
+      })
       return
     }
+    // A streamed frame scheduled just before settle must not land afterward and clobber the final
+    // content, so drop it before settling.
+    if (streamRafRef.current !== null) {
+      cancelAnimationFrame(streamRafRef.current)
+      streamRafRef.current = null
+    }
     // Settle: lock the verdict + frontmatter on the freshly-settled content. Re-lock on the initial
     // settle and on every later stream→settle, so a repeat agent edit gates editability + frontmatter
     // on the NEW content rather than a stale pre-stream snapshot. User edits never re-derive (they
@@ -315,6 +334,13 @@ export function LoadedRichMarkdownEditor({
     if (settledRef.current) editor.setEditable(canEdit && settledRef.current.verdict)
   }, [editor, content, isStreaming, canEdit, autoFocus, disableStreamingAutoScroll])
 
+  useEffect(
+    () => () => {
+      if (streamRafRef.current !== null) cancelAnimationFrame(streamRafRef.current)
+    },
+    []
+  )
+
   return (
     <div
       ref={containerRef}

apps/sim/app/workspace/[workspaceId]/files/components/file-viewer/rich-markdown-editor/round-trip-editable-corpus.test.ts

@@ -161,8 +161,8 @@ describe('editability gate — realistic documents stay editable', () => {
   }
 
   it('a large-but-ordinary document (just under the probe limit) stays editable', () => {
-    const big = `# Big Doc\n\n${'A paragraph of perfectly ordinary prose. '.repeat(2000)}`
-    expect(big.length).toBeLessThan(128 * 1024)
+    const big = `# Big Doc\n\n${'A paragraph of perfectly ordinary prose. '.repeat(500)}`
+    expect(big.length).toBeLessThan(24 * 1024)
     expect(isRoundTripSafe(big)).toBe(true)
   })
 

apps/sim/app/workspace/[workspaceId]/files/components/file-viewer/rich-markdown-editor/round-trip-safety.test.ts

@@ -89,7 +89,10 @@ describe('isRoundTripSafe', () => {
     expect(isRoundTripSafe('see <https://sim.ai> for more')).toBe(true)
   })
 
-  it('falls back for very large documents without probing', () => {
-    expect(isRoundTripSafe(`# Title\n\n${'word '.repeat(110_000)}`)).toBe(false)
+  it('probes documents up to the size cap but falls back (read-only) above it', () => {
+    // ~20KB of simple safe prose is under the 24KB cap → probed and editable.
+    expect(isRoundTripSafe(`# Title\n\n${'word '.repeat(4000)}`)).toBe(true)
+    // ~30KB is over the cap → not probed, opens read-only (the synchronous probe is too slow).
+    expect(isRoundTripSafe(`# Title\n\n${'word '.repeat(6000)}`)).toBe(false)
   })
 })

apps/sim/app/workspace/[workspaceId]/files/components/file-viewer/rich-markdown-editor/round-trip-safety.ts

@@ -7,11 +7,15 @@ import {
 } from './markdown-fidelity'
 
 /**
- * Above this size we don't run the (synchronous) round-trip probe — building two editors to
- * serialize a large document blocks the main thread for too long, and a very large markdown file
- * is heavier to edit richly anyway, so it opens read-only.
+ * Above this size we don't run the (synchronous) round-trip probe, and the file opens read-only.
+ * The probe builds throwaway editors and parses the markdown, and `@tiptap/markdown`'s parse is
+ * superlinear (~O(n²)) in document size — measured ~170ms at 11KB, ~875ms at 23KB, multiple seconds
+ * past ~35KB — so a high cap means a multi-second main-thread freeze at mount. 24KB keeps the
+ * worst-case probe near a second while still covering the vast majority of real markdown files; a
+ * very large markdown file is also heavier to edit richly anyway. The editor's own markdown parse
+ * shares this cost, so the cap protects mount render too.
  */
-const PROBE_SIZE_LIMIT = 128 * 1024
+const PROBE_SIZE_LIMIT = 24 * 1024
 
 /**
  * Constructs the editor drops or mangles in a way that survives a second serialization