refactor(file-viewer): audit fixes — stale docs, DRY settle-lock, language detection

- rich-markdown-editor: rewrite the now-stale single-surface docstring (no PreviewPanel); extract a
  shared lockSettled() helper used by both the mount and stream-settle paths; guard the settle
  re-seed so it only setContent's when the body actually changed (no redundant doc rebuild)
- detect-language: stop misreading generics (List<String>) as HTML markup; detect Go type/struct
- code-block: export LANGUAGE_OPTIONS + add a test asserting every picker language has a registered
  Prism grammar (prevents picker/highlighter drift)

Author: waleedlatif1

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

@@ -17,8 +17,9 @@ import { detectLanguage } from './detect-language'
 
 const PLAIN = 'plain'
 
-/** Languages the Prism highlighter has registered (see {@link CodeBlockHighlight}). */
-const LANGUAGE_OPTIONS = [
+/** Languages the Prism highlighter has registered (see {@link CodeBlockHighlight}). Every non-plain
+ * value MUST have a grammar registered in {@link CodeBlockHighlight} — enforced by a unit test. */
+export const LANGUAGE_OPTIONS = [
   { value: PLAIN, label: 'Plain text' },
   { value: 'bash', label: 'Bash' },
   { value: 'c', label: 'C' },

apps/sim/app/workspace/[workspaceId]/files/components/file-viewer/rich-markdown-editor/code-languages.test.ts

@@ -0,0 +1,21 @@
+/**
+ * @vitest-environment jsdom
+ *
+ * Guards against drift between the code-block language picker and the Prism grammars actually
+ * registered by CodeBlockHighlight: every selectable language must have a registered grammar, or it
+ * would silently fall back to no highlighting.
+ */
+import Prism from 'prismjs'
+import { describe, expect, it } from 'vitest'
+import { LANGUAGE_OPTIONS } from './code-block'
+// Importing the highlighter registers all the prism-* grammars as a side effect.
+import './code-highlight'
+
+describe('code-block languages', () => {
+  it('every selectable language has a registered Prism grammar', () => {
+    for (const { value } of LANGUAGE_OPTIONS) {
+      if (value === 'plain') continue
+      expect(Prism.languages[value], `no Prism grammar registered for "${value}"`).toBeDefined()
+    }
+  })
+})

apps/sim/app/workspace/[workspaceId]/files/components/file-viewer/rich-markdown-editor/detect-language.test.ts

@@ -22,4 +22,17 @@ describe('detectLanguage', () => {
   it('does not misclassify a JS object as JSON', () => {
     expect(detectLanguage('const x = { a: 1 }')).toBe('javascript')
   })
+
+  it('detects Go, Rust, Java', () => {
+    expect(detectLanguage('package main\n\nfunc main() {\n\tfmt.Println("hi")\n}')).toBe('go')
+    expect(detectLanguage('type User struct {\n\tName string\n}')).toBe('go')
+    expect(detectLanguage('fn main() {\n  let mut x = 1;\n  println!("{}", x);\n}')).toBe('rust')
+    expect(detectLanguage('public class Box {\n  private int n;\n}')).toBe('java')
+  })
+
+  it('does not misread generics as HTML markup', () => {
+    expect(detectLanguage('public class Box { private List<String> items; }')).toBe('java')
+    expect(detectLanguage('let v: Vec<String> = Vec::new();\nfn f() {}')).toBe('rust')
+    expect(detectLanguage('func Map[T any](s []T) {}\npackage x')).toBe('go')
+  })
 })

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

@@ -5,7 +5,9 @@
  * {@link CodeBlockHighlight} actually registers with Prism; returns `null` when unsure.
  */
 const DETECTORS: ReadonlyArray<{ language: string; test: RegExp }> = [
-  { language: 'markup', test: /<\/?[a-z][\w-]*(\s[^>]*)?\/?>/i },
+  // Real HTML: a closing tag, an opening tag with an attribute, or a doctype/comment. Deliberately
+  // NOT a bare `<Word>` so generics (`List<String>`, `Vec<T>`) aren't misread as markup.
+  { language: 'markup', test: /<\/[a-z][\w-]*\s*>|<[a-z][\w-]*\s+[\w:-]+=|<!(?:doctype\b|--)/i },
   {
     language: 'sql',
     test: /\b(?:select\s+[\w*]|insert\s+into|update\s+\w+\s+set|delete\s+from|create\s+table)/i,
@@ -17,7 +19,7 @@ const DETECTORS: ReadonlyArray<{ language: string; test: RegExp }> = [
   },
   {
     language: 'go',
-    test: /^\s*package\s+\w+|\bfunc\s+(\(\w[^)]*\)\s+)?\w+\s*\(|\bfmt\.\w|:=/m,
+    test: /^\s*package\s+\w+|\bfunc\s+(\(\w[^)]*\)\s+)?\w+\s*\(|\btype\s+\w+\s+(struct|interface)\b|\bfmt\.\w|:=/m,
   },
   {
     language: 'rust',

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

@@ -43,16 +43,15 @@ interface RichMarkdownEditorProps {
 
 /**
  * Inline WYSIWYG markdown editor (TipTap/ProseMirror) for markdown files — a single editing surface
- * (markdown transformed inline as you type), no raw/preview split. Owns the file lifecycle through a
- * single {@link useEditableFileContent} engine: while agent output streams in (and during the
- * post-stream reconcile) it shows the read-only {@link PreviewPanel} with autosave disabled, so the
- * editor never races the agent's server-side write. Once content is loaded and settled it mounts the
- * actual editor.
+ * (markdown transformed inline as you type), no raw/preview split and no separate streaming preview.
+ * Owns the file lifecycle through a single {@link useEditableFileContent} engine, and the TipTap
+ * editor is the ONLY thing the user ever sees: while agent output streams in it renders that content
+ * read-only (synced per chunk), then the same editor instance becomes editable once the stream
+ * settles — so the stream→edit transition has no renderer swap or flash.
  *
- * The editor is mounted only once content is ready, and is keyed by file id — so the loaded markdown
- * is the editor's *initial* `content` (parsed at create time), not pushed in by a sync effect. That
- * keeps it robust to TipTap's strict-mode/SSR instance lifecycle: there is no content-sync effect to
- * race, so a freshly created (or strict-mode-recreated) editor is always born with the right document.
+ * The editor is keyed by file id (+ streaming context). A file opened outside a stream uses the plain
+ * create-time initial-content model (no sync). See {@link LoadedRichMarkdownEditor} for the
+ * read-only-stream → editable hand-off.
  */
 export const RichMarkdownEditor = memo(function RichMarkdownEditor({
   file,
@@ -126,6 +125,22 @@ interface LoadedRichMarkdownEditorProps {
   onSaveShortcut: () => Promise<void>
 }
 
+interface SettledContent {
+  frontmatter: string
+  verdict: boolean
+}
+
+/**
+ * Lock the round-trip verdict + frontmatter on the content the editor "opens" with — once, at mount
+ * for a settled file or at the moment a stream settles. A round-trip-unsafe document (raw HTML,
+ * footnotes, >128KB, …) opens read-only so an edit can't corrupt it; a safe one stays editable. Never
+ * re-derived: a dirty document is safe by construction (the editor only emits safe markdown), so
+ * flipping editability off mid-edit would only strand edits.
+ */
+function lockSettled(content: string): SettledContent {
+  return { frontmatter: splitFrontmatter(content).frontmatter, verdict: isRoundTripSafe(content) }
+}
+
 /**
  * The single TipTap editor for a markdown file — the only surface the user ever sees. While agent
  * output streams in ({@link streaming}) it renders that content read-only and re-syncs each chunk;
@@ -149,21 +164,16 @@ export function LoadedRichMarkdownEditor({
   // content until the stream settles; otherwise it uses the plain create-time initial-content model.
   const streamingAtMountRef = useRef(streaming)
 
-  // The round-trip verdict + frontmatter, locked once on the content the editor "opens" with — at
-  // mount for a settled file, or at the moment the stream settles for a streamed one. A round-trip-
-  // unsafe document (raw HTML, footnotes, >128KB, …) opens read-only so an edit can't corrupt it; a
-  // safe one is editable. Once locked it is never re-derived: a dirty document is safe by construction
-  // (the editor only emits safe markdown), so flipping editability off mid-edit would strand edits.
-  const settledRef = useRef<{ frontmatter: string; verdict: boolean } | null>(null)
+  // The verdict + frontmatter locked via {@link lockSettled} — at mount for a settled file, or at the
+  // moment a stream settles (in the effect below). Null until then; reads default to read-only.
+  const settledRef = useRef<SettledContent | null>(null)
   if (!streamingAtMountRef.current && settledRef.current === null) {
-    settledRef.current = {
-      frontmatter: splitFrontmatter(content).frontmatter,
-      verdict: isRoundTripSafe(content),
-    }
+    settledRef.current = lockSettled(content)
   }
   const isEditable = canEdit && !streaming && (settledRef.current?.verdict ?? false)
 
-  // The body that seeds the editor at create time — empty when streaming (filled by the sync effect).
+  // The body that seeds the editor at create time. Empty when streaming — the sync effect pushes the
+  // streamed body in via setContent (this ref is never written again).
   const initialBodyRef = useRef(streamingAtMountRef.current ? '' : splitFrontmatter(content).body)
   // The frontmatter re-attached on every change. Empty until the content settles (the editor never
   // displays frontmatter, so a streamed doc simply shows its body).
@@ -280,10 +290,14 @@ export function LoadedRichMarkdownEditor({
       return
     }
     if (settledRef.current === null) {
-      const { frontmatter, body } = splitFrontmatter(content)
-      settledRef.current = { frontmatter, verdict: isRoundTripSafe(content) }
-      lastSyncedBodyRef.current = body
-      editor.commands.setContent(body, { contentType: 'markdown', emitUpdate: false })
+      settledRef.current = lockSettled(content)
+      // Re-seed only if the settled body differs from the last streamed chunk — it usually doesn't,
+      // and an extra setContent would needlessly rebuild the doc and drop selection/scroll.
+      const body = splitFrontmatter(content).body
+      if (body !== lastSyncedBodyRef.current) {
+        lastSyncedBodyRef.current = body
+        editor.commands.setContent(body, { contentType: 'markdown', emitUpdate: false })
+      }
       editor.setEditable(canEdit && settledRef.current.verdict)
       if (autoFocus) editor.commands.focus('end')
       return