fix(rich-editor): raw-fallback paste hook + bound the filtered mention list

- RawMarkdownField now honors onPasteText (e.g. skill SKILL.md destructuring), so a full-document
  paste is intercepted in the raw fallback too, not only the WYSIWYG path.
- Bound the @-mention list while filtering (MAX_WHEN_FILTERED) so lifting the per-group cap for search
  can't render thousands of rows in the non-virtualized menu on a broad query; search still reaches
  deep matches well before the bound. Adds a test.
- Tighten an extensions.ts doc comment (the headless path omits the registry + node-view construction,
  not React itself).

Author: waleedlatif1

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

@@ -58,9 +58,9 @@ const PipeSafeTable = Table.extend({
 
 /**
  * Node-view variants the live editor injects in place of the headless defaults — the code-block
- * language picker, the resizable image, and the mention chip. They pull React (and, for the mention
- * chip, the block registry for brand icons), so the headless round-trip path omits them: passing
- * nothing keeps {@link createMarkdownContentExtensions} free of React and the registry.
+ * language picker, the resizable image, and the mention chip. The mention chip pulls the block registry
+ * (for brand icons), so the headless round-trip path omits it: passing nothing keeps
+ * {@link createMarkdownContentExtensions} free of the registry and constructs no React node views.
  */
 export interface ContentNodeViews {
   codeBlock?: Node

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

@@ -98,6 +98,29 @@ describe('MentionList keyboard nav', () => {
     expect(container.querySelectorAll('[role="option"]').length).toBe(12)
   })
 
+  it('bounds the filtered list so a broad query cannot flood the menu', () => {
+    const ref = createRef<MentionListHandle>()
+    const command = vi.fn()
+    const store = createMentionStore()
+    // 200 matches — far beyond any reasonable render; the list must cap the total.
+    const flood: MentionItem[] = Array.from({ length: 200 }, (_, i) => ({
+      kind: 'file',
+      id: `f${i}`,
+      label: `alpha-${i}`,
+      group: 'Files',
+      icon: File,
+    }))
+
+    act(() => {
+      root.render(
+        <MentionList ref={ref} query='alpha' command={command} store={store} editor={editor} />
+      )
+    })
+    act(() => store.set(flood))
+
+    expect(container.querySelectorAll('[role="option"]').length).toBe(50)
+  })
+
   it('accepts the active item on Tab, like Enter', () => {
     const ref = createRef<MentionListHandle>()
     const command = vi.fn()

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

@@ -25,6 +25,11 @@ interface MentionListProps {
  * search reaches every match, not just the first eight in a category. */
 const MAX_PER_GROUP = 8
 
+/** Total cap while filtering: lifts the per-group limit so search reaches deep matches, but still bounds
+ * the (non-virtualized) list so a broad single-char query on a huge workspace can't render thousands of
+ * rows. Generous enough that a real search is never truncated before the user narrows further. */
+const MAX_WHEN_FILTERED = 50
+
 /** Category heading order in the menu. */
 const GROUP_ORDER = [
   'Files',
@@ -51,17 +56,22 @@ export const MentionList = forwardRef<MentionListHandle, MentionListProps>(funct
   /**
    * Filtered, flattened in category order; `index` is the flat position for nav. A single pass over the
    * full set filters by label and buckets by group, then reads the buckets in category order — avoiding
-   * a separate filter pass per group. The per-group cap applies only to the unfiltered menu; once a
-   * query is active every match is shown so search can reach items past the eighth in a category.
+   * a separate filter pass per group. Without a query each group is capped ({@link MAX_PER_GROUP}); with
+   * a query the per-group cap is lifted (so search reaches deep matches) but the total is bounded
+   * ({@link MAX_WHEN_FILTERED}) so a broad query can't flood the non-virtualized list.
    */
   const { flat, groups } = useMemo(() => {
     const q = query.trim().toLowerCase()
     const byGroup = new Map<string, MentionItem[]>()
+    let shown = 0
     for (const item of rawItems) {
       if (q && !item.label.toLowerCase().includes(q)) continue
+      if (q && shown >= MAX_WHEN_FILTERED) break
       const bucket = byGroup.get(item.group)
-      if (!bucket) byGroup.set(item.group, [item])
-      else if (q || bucket.length < MAX_PER_GROUP) bucket.push(item)
+      if (!q && bucket && bucket.length >= MAX_PER_GROUP) continue
+      if (bucket) bucket.push(item)
+      else byGroup.set(item.group, [item])
+      shown++
     }
 
     const ordered: { group: string; items: { item: MentionItem; index: number }[] }[] = []

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

@@ -192,7 +192,9 @@ function LoadedRichMarkdownField({
 
 /**
  * Raw-text fallback for content the rich editor can't round-trip losslessly — editing the markdown
- * source directly so an edit can't silently drop footnotes, raw HTML, or comments.
+ * source directly so an edit can't silently drop footnotes, raw HTML, or comments. Honors the same
+ * `onPasteText` hook as the WYSIWYG path (e.g. skill `SKILL.md` destructuring) so a full-document paste
+ * is intercepted here too.
  */
 function RawMarkdownField({
   value,
@@ -203,11 +205,16 @@ function RawMarkdownField({
   minHeight = 140,
   maxHeight = 360,
   error = false,
+  onPasteText,
 }: RichMarkdownFieldProps) {
   return (
     <ChipTextarea
       value={value}
       onChange={(event) => onChange(event.target.value)}
+      onPaste={(event) => {
+        const text = event.clipboardData.getData('text/plain')
+        if (text && onPasteText?.(text)) event.preventDefault()
+      }}
       placeholder={placeholder}
       error={error}
       readOnly={disabled || isStreaming}