fix(files): close three find edge cases from review

- Keep context-sensitive lowercasing in the length-preserving case fold. A
  word-final sigma lowercases differently in a string than on its own, so
  folding character by character let one unrelated expanding code point change
  how every sigma in the string matched. The fallback now reads each
  character's replacement out of the whole-string result.
- Decline Cmd/Ctrl+F while a collaborative document is still seeding. The text
  on screen then belongs to the read-only placeholder's editor, not the empty
  hidden one find is attached to, so the bar answered "No results" for visible
  text. The browser's native find reads the placeholder correctly in that
  window; the shortcut becomes ours once the seed lands.
- Re-apply a pending term when the editor instance arrives, so a query typed
  before TipTap mounts is searched instead of sitting at zero matches until the
  next keystroke.

Author: waleedlatif1

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

@@ -96,6 +96,15 @@ describe('RichMarkdownFind', () => {
     expect(paintedMatches(instance)).toEqual(['[x]'])
   })
 
+  it('searches a term applied before any other transaction', () => {
+    // The hook re-applies a pending term the moment the editor exists; setting a query as the very
+    // first thing that happens to a fresh editor must land, not wait for a later transaction.
+    const instance = mountEditor('alpha beta')
+    setFindQuery(instance, 'beta')
+    expect(getFindTally(instance.state).matches).toHaveLength(1)
+    expect(paintedMatches(instance)).toEqual(['[beta]'])
+  })
+
   it('clears every highlight when the term is emptied', () => {
     const instance = mountEditor('alpha')
     setFindQuery(instance, 'alpha')

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

@@ -105,6 +105,18 @@ export function useMarkdownFind({
     }
   }, [editor, isOpen, syncTally])
 
+  /**
+   * Re-applies the live term to a newly arrived editor. `useEditor` returns null on the first render,
+   * so a term typed into the bar before the editor mounts would be held in React and never searched,
+   * leaving the bar at "No results" until the next keystroke pushed it through.
+   */
+  const queryRef = useRef(query)
+  queryRef.current = query
+  useEffect(() => {
+    if (!editor || queryRef.current.length === 0) return
+    setFindQuery(editor, queryRef.current)
+  }, [editor])
+
   const setQuery = useCallback(
     (next: string) => {
       setQueryState(next)

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

@@ -1215,14 +1215,20 @@ export function LoadedRichMarkdownEditor({
 
   useSelectionCopyBridge(containerRef, buildSelectionContext)
 
-  const find = useMarkdownFind({ editor, enabled: enableFind })
-
   // Show the read-only placeholder (the already-fetched markdown) whenever a collaborative doc has not yet
   // seeded — including during an agent stream that begins before the seed lands. Streamed diffs are held
   // until `collabReady` (see the streaming effect), so before then the editor is empty; the placeholder
   // shows the base content until the seed swaps it in, avoiding both a blank frame and a garbled merge.
   const showPlaceholder = collaborationEnabled && !collabReady
 
+  /**
+   * Find is off while the placeholder is up. The text on screen then belongs to the placeholder's own
+   * editor, not to `editor` — which is still empty and hidden — so searching `editor` would answer
+   * "No results" for text the user can see. Declining the shortcut hands it back to the browser, whose
+   * native find reads the rendered placeholder correctly; it becomes ours once the seed lands.
+   */
+  const find = useMarkdownFind({ editor, enabled: enableFind && !showPlaceholder })
+
   return (
     // The find bar is a sibling of the scroller, not a child: pinned inside `containerRef` it would
     // scroll away with the document the moment stepping moved the view.

packages/utils/src/string.test.ts

@@ -233,6 +233,13 @@ describe('forEachSearchOccurrence', () => {
     expect(spans('abc', '')).toEqual([])
   })
 
+  it('keeps context-sensitive lowercasing in the length-preserving fallback', () => {
+    // '\u0130' expands, so the whole-string fast path is unavailable. Folding the rest character by
+    // character would lowercase the word-final '\u03a3' to '\u03c3' instead of '\u03c2', making one
+    // unrelated code point change how every sigma in the string matches.
+    expect(spans('\u0130\u03a3', '\u0130\u03c2')).toEqual(['\u0130\u03a3'])
+  })
+
   it('reports bounds into the caller\u2019s own string after a length-changing lowercase', () => {
     // '\u0130'.toLowerCase() is TWO characters. A plain lowercase would slide every later index by
     // one, so the caller would slice the wrong span out of the string it passed in.

packages/utils/src/string.ts

@@ -217,14 +217,26 @@ export function foldSearchWhitespace(value: string): string {
  * case-sensitively. The whole-string form is tried first because it is a single
  * intrinsic and is length-preserving for every input that contains no such code
  * point, i.e. essentially all of them.
+ *
+ * The fallback still reads each character's replacement out of the whole-string
+ * result rather than lowercasing it in isolation, because some lowercasing is
+ * context-sensitive: a word-final `\u03a3` lowercases to `\u03c2` in the string
+ * but to `\u03c3` on its own. Folding character by character would make one
+ * expanding code point elsewhere in the string silently change how every sigma
+ * in it matches.
  */
 function lowerPreservingLength(value: string): string {
   const lowered = value.toLowerCase()
   if (lowered.length === value.length) return lowered
   let result = ''
+  let loweredOffset = 0
   for (const char of value) {
     const loweredChar = char.toLowerCase()
-    result += loweredChar.length === char.length ? loweredChar : char
+    result +=
+      loweredChar.length === char.length
+        ? lowered.slice(loweredOffset, loweredOffset + loweredChar.length)
+        : char
+    loweredOffset += loweredChar.length
   }
   return result
 }