diff --git a/packages/mobile/fastlane/Fastfile b/packages/mobile/fastlane/Fastfile
index 35f213a7991..2565bda1c20 100755
--- a/packages/mobile/fastlane/Fastfile
+++ b/packages/mobile/fastlane/Fastfile
@@ -115,6 +115,10 @@ platform :ios do
 end
 
 platform :android do
+  def android_package_name(variant)
+    variant == 'dev' ? 'com.standardnotes.dev' : 'com.standardnotes'
+  end
+
   def build_android(variant, versionCode)
     gradle(
       task: 'bundle',
@@ -132,6 +136,7 @@ platform :android do
     sh('yarn run android:bundle')
     build_android(variant, versionCode)
     upload_to_play_store(
+      package_name: android_package_name(variant),
       track: track,
       json_key_data: (ENV['GOOGLE_PLAY_JSON_KEY_DATA']).to_s,
       skip_upload_metadata: true,
diff --git a/packages/snjs/lib/Services/Features/UseCase/GetFeatureStatus.spec.ts b/packages/snjs/lib/Services/Features/UseCase/GetFeatureStatus.spec.ts
index c799fdd5aa4..0a89e24f354 100644
--- a/packages/snjs/lib/Services/Features/UseCase/GetFeatureStatus.spec.ts
+++ b/packages/snjs/lib/Services/Features/UseCase/GetFeatureStatus.spec.ts
@@ -159,7 +159,6 @@ describe('GetFeatureStatusUseCase', () => {
       ).toEqual(FeatureStatus.InCurrentPlanButExpired)
     })
   })
-
   describe('third party features', () => {
     it('should return Entitled for third-party features', () => {
       const mockComponent = {
diff --git a/packages/ui-services/src/Keyboard/KeyboardCommands.ts b/packages/ui-services/src/Keyboard/KeyboardCommands.ts
index b23a447c36a..d0ce1c7aa0f 100644
--- a/packages/ui-services/src/Keyboard/KeyboardCommands.ts
+++ b/packages/ui-services/src/Keyboard/KeyboardCommands.ts
@@ -32,6 +32,12 @@ export const SUPER_SEARCH_TOGGLE_CASE_SENSITIVE = createKeyboardCommand('SUPER_S
 export const SUPER_SEARCH_TOGGLE_REPLACE_MODE = createKeyboardCommand('SUPER_SEARCH_TOGGLE_REPLACE_MODE')
 export const SUPER_SEARCH_NEXT_RESULT = createKeyboardCommand('SUPER_SEARCH_NEXT_RESULT')
 export const SUPER_SEARCH_PREVIOUS_RESULT = createKeyboardCommand('SUPER_SEARCH_PREVIOUS_RESULT')
+
+export const UNIVERSAL_TOGGLE_SEARCH = createKeyboardCommand('UNIVERSAL_TOGGLE_SEARCH')
+export const UNIVERSAL_SEARCH_TOGGLE_CASE_SENSITIVE = createKeyboardCommand('UNIVERSAL_SEARCH_TOGGLE_CASE_SENSITIVE')
+export const UNIVERSAL_SEARCH_TOGGLE_REPLACE_MODE = createKeyboardCommand('UNIVERSAL_SEARCH_TOGGLE_REPLACE_MODE')
+export const UNIVERSAL_SEARCH_NEXT_RESULT = createKeyboardCommand('UNIVERSAL_SEARCH_NEXT_RESULT')
+export const UNIVERSAL_SEARCH_PREVIOUS_RESULT = createKeyboardCommand('UNIVERSAL_SEARCH_PREVIOUS_RESULT')
 export const SUPER_SHOW_MARKDOWN_PREVIEW = createKeyboardCommand('SUPER_SHOW_MARKDOWN_PREVIEW')
 
 export const SUPER_EXPORT_JSON = createKeyboardCommand('SUPER_EXPORT_JSON')
diff --git a/packages/ui-services/src/Keyboard/KeyboardShortcut.ts b/packages/ui-services/src/Keyboard/KeyboardShortcut.ts
index 085d59003ea..27d3f4931ff 100644
--- a/packages/ui-services/src/Keyboard/KeyboardShortcut.ts
+++ b/packages/ui-services/src/Keyboard/KeyboardShortcut.ts
@@ -19,7 +19,13 @@ export type PlatformedKeyboardShortcut = KeyboardShortcut & {
   platform: Platform
 }
 
-export type KeyboardShortcutCategory = 'General' | 'Notes list' | 'Current note' | 'Super notes' | 'Formatting'
+export type KeyboardShortcutCategory =
+  | 'General'
+  | 'Notes list'
+  | 'Current note'
+  | 'Super notes'
+  | 'Formatting'
+  | 'Search'
 
 export interface KeyboardShortcutHelpItem extends Omit<PlatformedKeyboardShortcut, 'command'> {
   command?: KeyboardCommand
diff --git a/packages/ui-services/src/Keyboard/getKeyboardShortcuts.ts b/packages/ui-services/src/Keyboard/getKeyboardShortcuts.ts
index 1f4f4eaca01..daaff3cf97b 100644
--- a/packages/ui-services/src/Keyboard/getKeyboardShortcuts.ts
+++ b/packages/ui-services/src/Keyboard/getKeyboardShortcuts.ts
@@ -28,6 +28,11 @@ import {
   SUPER_SEARCH_NEXT_RESULT,
   SUPER_SEARCH_PREVIOUS_RESULT,
   SUPER_SEARCH_TOGGLE_REPLACE_MODE,
+  UNIVERSAL_TOGGLE_SEARCH,
+  UNIVERSAL_SEARCH_TOGGLE_CASE_SENSITIVE,
+  UNIVERSAL_SEARCH_NEXT_RESULT,
+  UNIVERSAL_SEARCH_PREVIOUS_RESULT,
+  UNIVERSAL_SEARCH_TOGGLE_REPLACE_MODE,
   CHANGE_EDITOR_WIDTH_COMMAND,
   SUPER_TOGGLE_TOOLBAR,
   TOGGLE_KEYBOARD_SHORTCUTS_MODAL,
@@ -178,6 +183,31 @@ export function getKeyboardShortcuts(platform: Platform, _environment: Environme
       key: 'F3',
       modifiers: [KeyboardModifier.Shift],
     },
+    {
+      command: UNIVERSAL_TOGGLE_SEARCH,
+      key: 'f',
+      modifiers: [primaryModifier],
+    },
+    {
+      command: UNIVERSAL_SEARCH_TOGGLE_REPLACE_MODE,
+      key: isMacPlatform(platform) ? undefined : 'h',
+      code: isMacPlatform(platform) ? 'KeyF' : undefined,
+      modifiers: isMacPlatform(platform) ? [KeyboardModifier.Alt, primaryModifier] : [primaryModifier],
+    },
+    {
+      command: UNIVERSAL_SEARCH_TOGGLE_CASE_SENSITIVE,
+      key: 'c',
+      modifiers: [KeyboardModifier.Alt],
+    },
+    {
+      command: UNIVERSAL_SEARCH_NEXT_RESULT,
+      key: 'F3',
+    },
+    {
+      command: UNIVERSAL_SEARCH_PREVIOUS_RESULT,
+      key: 'F3',
+      modifiers: [KeyboardModifier.Shift],
+    },
     {
       command: SUPER_SHOW_MARKDOWN_PREVIEW,
       key: 'm',
diff --git a/packages/web/src/javascripts/Components/NoteView/NoteView.tsx b/packages/web/src/javascripts/Components/NoteView/NoteView.tsx
index 37ebb8db3dc..c164b665864 100644
--- a/packages/web/src/javascripts/Components/NoteView/NoteView.tsx
+++ b/packages/web/src/javascripts/Components/NoteView/NoteView.tsx
@@ -47,7 +47,8 @@ import {
 } from './TransactionFunctions'
 import { SuperEditorContentId } from '../SuperEditor/Constants'
 import { NoteViewController } from './Controller/NoteViewController'
-import { PlainEditor, PlainEditorInterface } from './PlainEditor/PlainEditor'
+import { PlainEditorInterface } from './PlainEditor/PlainEditor'
+import { PlainEditorSearchContainer } from './PlainEditor/search/PlainEditorSearchContainer'
 import NoteStatusIndicator, { NoteStatus } from './NoteStatusIndicator'
 import CollaborationInfoHUD from './CollaborationInfoHUD'
 import Button from '../Button/Button'
@@ -977,7 +978,7 @@ class NoteView extends AbstractComponent<NoteViewProps, State> {
           )}
 
           {editorMode === 'plain' && (
-            <PlainEditor
+            <PlainEditorSearchContainer
               application={this.application}
               spellcheck={this.state.spellcheck}
               ref={this.setPlainEditorRef}
diff --git a/packages/web/src/javascripts/Components/NoteView/PlainEditor/PlainEditor.tsx b/packages/web/src/javascripts/Components/NoteView/PlainEditor/PlainEditor.tsx
index cf814923563..fb0b574541e 100644
--- a/packages/web/src/javascripts/Components/NoteView/PlainEditor/PlainEditor.tsx
+++ b/packages/web/src/javascripts/Components/NoteView/PlainEditor/PlainEditor.tsx
@@ -22,11 +22,26 @@ import {
   useCallback,
   useEffect,
   useImperativeHandle,
+  useMemo,
   useRef,
   useState,
   FocusEvent,
 } from 'react'
 import { NoteViewController } from '../Controller/NoteViewController'
+import { findStringMatches } from '../UniversalSearch/findStringMatches'
+import { PlainEditorSearchBackdrop } from './search/PlainEditorSearchBackdrop'
+import { buildPlainSearchHighlightHtml } from './search/buildPlainSearchHighlightHtml'
+import { replaceAllTextRangesWithUndoSupport, replaceTextRangeWithUndoSupport } from './replacePlainTextWithUndoSupport'
+import { scrollPlainTextareaToOffset } from './search/scrollPlainTextareaToOffset'
+import { TextRange } from '../UniversalSearch/types'
+
+export type PlainEditorSearchHighlightState = {
+  isOpen: boolean
+  query: string
+  isCaseSensitive: boolean
+  shouldHighlightAll: boolean
+  activeMatch?: TextRange
+}
 
 type Props = {
   application: WebApplication
@@ -35,14 +50,27 @@ type Props = {
   locked: boolean
   onFocus: () => void
   onBlur: (event: FocusEvent) => void
+  onTextChange?: () => void
+  isSearchMode?: boolean
+  search?: PlainEditorSearchHighlightState
 }
 
 export type PlainEditorInterface = {
   focus: () => void
+  getText: () => string
+  getTextarea: () => HTMLTextAreaElement | null
+  setSelection: (
+    start: number,
+    end: number,
+    options?: { focus?: boolean; scrollIntoView?: boolean; selectInEditor?: boolean },
+  ) => void
+  replaceRange: (start: number, end: number, replacement: string) => Promise<void>
+  replaceAllRanges: (ranges: TextRange[], replacement: string) => Promise<void>
+  onTextChange: (callback: () => void) => Disposer
 }
 
 export const PlainEditor = forwardRef<PlainEditorInterface, Props>(
-  ({ application, spellcheck, controller, locked, onFocus, onBlur }, ref) => {
+  ({ application, spellcheck, controller, locked, onFocus, onBlur, onTextChange, isSearchMode, search }, ref) => {
     const [editorText, setEditorText] = useState<string | undefined>()
     const [textareaUnloading, setTextareaUnloading] = useState(false)
     const [lineHeight, setLineHeight] = useState<EditorLineHeight | undefined>()
@@ -59,12 +87,120 @@ export const PlainEditor = forwardRef<PlainEditorInterface, Props>(
 
     const tabObserverDisposer = useRef<Disposer>()
     const mutationObserver = useRef<MutationObserver | null>(null)
-
-    useImperativeHandle(ref, () => ({
-      focus() {
-        focusEditor()
+    const textareaRef = useRef<HTMLTextAreaElement | null>(null)
+    const textChangeObservers = useRef(new Set<() => void>())
+
+    const notifyTextChange = useCallback(() => {
+      onTextChange?.()
+      textChangeObservers.current.forEach((observer) => observer())
+    }, [onTextChange])
+
+    const persistText = useCallback(
+      (text: string, options?: { bypassDebouncer?: boolean }) => {
+        setEditorText(text)
+        setIsPendingLocalPropagation(true)
+
+        return controller
+          .saveAndAwaitLocalPropagation({
+            text,
+            isUserModified: true,
+            bypassDebouncer: options?.bypassDebouncer,
+          })
+          .then(() => {
+            setIsPendingLocalPropagation(false)
+          })
       },
-    }))
+      [controller],
+    )
+
+    const focusEditor = useCallback(() => {
+      const element = document.getElementById(ElementIds.NoteTextEditor)
+      if (element) {
+        lastEditorFocusEventSource.current = EditorEventSource.Script
+        element.focus()
+      }
+    }, [])
+
+    useImperativeHandle(
+      ref,
+      () => ({
+        focus() {
+          focusEditor()
+        },
+        getText() {
+          return textareaRef.current?.value ?? editorText ?? ''
+        },
+        getTextarea() {
+          return textareaRef.current
+        },
+        setSelection(start, end, options) {
+          const textarea = textareaRef.current
+          if (!textarea) {
+            return
+          }
+
+          const scrollTopBefore = textarea.scrollTop
+          const shouldSelectInEditor = options?.selectInEditor ?? !search?.isOpen
+
+          if (!shouldSelectInEditor) {
+            if (options?.scrollIntoView !== false) {
+              scrollPlainTextareaToOffset(textarea, start, end)
+            } else {
+              textarea.scrollTop = scrollTopBefore
+            }
+            return
+          }
+
+          textarea.setSelectionRange(start, end)
+
+          if (options?.scrollIntoView !== false) {
+            scrollPlainTextareaToOffset(textarea, start, end)
+          } else {
+            textarea.scrollTop = scrollTopBefore
+          }
+
+          if (options?.focus) {
+            lastEditorFocusEventSource.current = EditorEventSource.Script
+            textarea.focus()
+          }
+        },
+        async replaceRange(start, end, replacement) {
+          const textarea = textareaRef.current
+          if (!textarea || locked) {
+            return
+          }
+
+          const nextText = replaceTextRangeWithUndoSupport(textarea, start, end, replacement)
+
+          void persistText(nextText, { bypassDebouncer: true })
+
+          if (!search?.isOpen) {
+            notifyTextChange()
+          }
+        },
+        async replaceAllRanges(ranges, replacement) {
+          const textarea = textareaRef.current
+          if (!textarea || locked || ranges.length < 1) {
+            return
+          }
+
+          const nextText = replaceAllTextRangesWithUndoSupport(textarea, ranges, replacement)
+
+          void persistText(nextText, { bypassDebouncer: true })
+
+          if (!search?.isOpen) {
+            notifyTextChange()
+          }
+        },
+        onTextChange(callback) {
+          textChangeObservers.current.add(callback)
+          return () => {
+            textChangeObservers.current.delete(callback)
+          }
+        },
+      }),
+      [editorText, focusEditor, locked, notifyTextChange, persistText, search?.isOpen],
+    )
 
     useEffect(() => {
       return () => {
@@ -89,6 +225,7 @@ export const PlainEditor = forwardRef<PlainEditorInterface, Props>(
             updatedNote.noteType !== note.current.noteType
           ) {
             setEditorText(updatedNote.text)
+            notifyTextChange()
           }
         }
 
@@ -103,17 +240,14 @@ export const PlainEditor = forwardRef<PlainEditorInterface, Props>(
       controller.item.editorIdentifier,
       controller.item.noteType,
       isPendingLocalPropagation,
+      notifyTextChange,
     ])
 
     const onTextAreaChange: ChangeEventHandler<HTMLTextAreaElement> = ({ currentTarget }) => {
       const text = currentTarget.value
 
-      setEditorText(text)
-
-      setIsPendingLocalPropagation(true)
-
-      void controller.saveAndAwaitLocalPropagation({ text: text, isUserModified: true }).then(() => {
-        setIsPendingLocalPropagation(false)
+      void persistText(text).then(() => {
+        notifyTextChange()
       })
     }
 
@@ -157,14 +291,6 @@ export const PlainEditor = forwardRef<PlainEditorInterface, Props>(
       return disposer
     }, [application, scrollMobileCursorIntoViewAfterWebviewResize])
 
-    const focusEditor = useCallback(() => {
-      const element = document.getElementById(ElementIds.NoteTextEditor)
-      if (element) {
-        lastEditorFocusEventSource.current = EditorEventSource.Script
-        element.focus()
-      }
-    }, [])
-
     useEffect(() => {
       const shouldFocus = controller.isTemplateNote && controller.templateNoteOptions?.autofocusBehavior === 'editor'
 
@@ -212,8 +338,10 @@ export const PlainEditor = forwardRef<PlainEditorInterface, Props>(
     }, [spellcheck, previousSpellcheck])
 
     const onRef = useCallback(
-      (ref: HTMLTextAreaElement | null) => {
-        if (tabObserverDisposer.current || !ref) {
+      (element: HTMLTextAreaElement | null) => {
+        textareaRef.current = element
+
+        if (tabObserverDisposer.current || !element) {
           return
         }
 
@@ -251,18 +379,9 @@ export const PlainEditor = forwardRef<PlainEditorInterface, Props>(
               editor.selectionStart = editor.selectionEnd = start + 4
             }
 
-            setEditorText(editor.value)
-
-            setIsPendingLocalPropagation(true)
-
-            void controller
-              .saveAndAwaitLocalPropagation({
-                text: editor.value,
-                isUserModified: true,
-              })
-              .then(() => {
-                setIsPendingLocalPropagation(false)
-              })
+            void persistText(editor.value).then(() => {
+              notifyTextChange()
+            })
           },
         })
 
@@ -282,14 +401,54 @@ export const PlainEditor = forwardRef<PlainEditorInterface, Props>(
 
         mutationObserver.current = observer
       },
-      [application.keyboardService, controller],
+      [application.keyboardService, notifyTextChange, persistText],
     )
 
+    const {
+      isOpen: searchIsOpen = false,
+      query: searchQuery = '',
+      isCaseSensitive: searchIsCaseSensitive = false,
+      shouldHighlightAll: searchShouldHighlightAll = false,
+      activeMatch: searchActiveMatch,
+    } = search ?? {}
+
+    const searchHighlightHtml = useMemo(() => {
+      if (!searchIsOpen || !searchQuery) {
+        return null
+      }
+
+      const text = editorText ?? ''
+      const matches = findStringMatches(text, searchQuery, searchIsCaseSensitive)
+
+      return buildPlainSearchHighlightHtml(
+        {
+          isOpen: true,
+          query: searchQuery,
+          results: matches.map((range) => ({ id: `plain-${range.start}`, payload: range })),
+          currentResult: searchActiveMatch ? { id: 'active', payload: searchActiveMatch } : undefined,
+          shouldHighlightAll: searchShouldHighlightAll,
+        },
+        () => text,
+      )
+    }, [editorText, searchIsOpen, searchQuery, searchIsCaseSensitive, searchShouldHighlightAll, searchActiveMatch])
+
     if (textareaUnloading) {
       return null
     }
 
-    return (
+    const editorTypographyClassName = classNames(
+      lineHeight && `leading-${lineHeight.toLowerCase()}`,
+      responsiveFontSize,
+    )
+
+    const textareaClassName = classNames(
+      'editable font-editor flex-grow',
+      editorTypographyClassName,
+      searchHighlightHtml != null && 'plain-editor-with-search-highlights',
+      isIOS() && '!pb-12',
+    )
+
+    const textareaElement = (
       <textarea
         autoComplete="off"
         dir="auto"
@@ -301,15 +460,26 @@ export const PlainEditor = forwardRef<PlainEditorInterface, Props>(
         ref={onRef}
         spellCheck={spellcheck}
         value={editorText}
-        className={classNames(
-          'editable font-editor flex-grow',
-          lineHeight && `leading-${lineHeight.toLowerCase()}`,
-          responsiveFontSize,
-          // Extra bottom padding is added on iOS so that text
-          // doesn't get hidden by the floating "Close keyboard" button
-          isIOS() && '!pb-12',
-        )}
+        className={textareaClassName}
       ></textarea>
     )
+
+    if (!isSearchMode) {
+      return textareaElement
+    }
+
+    return (
+      <div className="plain-editor-search-container relative flex min-h-0 flex-grow flex-col">
+        {searchHighlightHtml != null && (
+          <PlainEditorSearchBackdrop
+            html={searchHighlightHtml}
+            textareaRef={textareaRef}
+            typographyClassName={editorTypographyClassName}
+            syncDependency={editorText}
+          />
+        )}
+        {textareaElement}
+      </div>
+    )
   },
 )
diff --git a/packages/web/src/javascripts/Components/NoteView/PlainEditor/replacePlainTextWithUndoSupport.spec.ts b/packages/web/src/javascripts/Components/NoteView/PlainEditor/replacePlainTextWithUndoSupport.spec.ts
new file mode 100644
index 00000000000..29574589f66
--- /dev/null
+++ b/packages/web/src/javascripts/Components/NoteView/PlainEditor/replacePlainTextWithUndoSupport.spec.ts
@@ -0,0 +1,159 @@
+/**
+ * @jest-environment jsdom
+ */
+
+import {
+  replaceAllTextRangesWithUndoSupport,
+  replaceTextRangeWithUndoSupport,
+} from './replacePlainTextWithUndoSupport'
+
+describe('replacePlainTextWithUndoSupport', () => {
+  beforeEach(() => {
+    document.queryCommandSupported = jest.fn(() => true)
+    document.execCommand = jest.fn(() => true)
+    jest.spyOn(window, 'requestAnimationFrame').mockImplementation((callback: FrameRequestCallback) => {
+      callback(0)
+      return 0
+    })
+  })
+
+  afterEach(() => {
+    jest.restoreAllMocks()
+  })
+
+  it('replaces text and keeps focus on the replace input', () => {
+    const textarea = document.createElement('textarea')
+    textarea.value = 'hello world'
+    const replaceInput = document.createElement('input')
+    document.body.appendChild(textarea)
+    document.body.appendChild(replaceInput)
+    replaceInput.focus()
+
+    document.execCommand = jest.fn((_command, _showUi, text: string) => {
+      const start = textarea.selectionStart ?? 0
+      const end = textarea.selectionEnd ?? 0
+      textarea.value = textarea.value.slice(0, start) + text + textarea.value.slice(end)
+      return true
+    })
+
+    replaceTextRangeWithUndoSupport(textarea, 6, 11, 'earth')
+
+    expect(textarea.value).toBe('hello earth')
+    expect(textarea.selectionStart).toBe(0)
+    expect(textarea.selectionEnd).toBe(0)
+    expect(document.activeElement).toBe(replaceInput)
+  })
+
+  it('replaces all matches in one insertText operation', () => {
+    const textarea = document.createElement('textarea')
+    textarea.value = 'hello hello'
+    const replaceInput = document.createElement('input')
+    document.body.appendChild(textarea)
+    document.body.appendChild(replaceInput)
+    replaceInput.focus()
+
+    document.execCommand = jest.fn((_command, _showUi, text: string) => {
+      textarea.value = text
+      return true
+    })
+
+    const result = replaceAllTextRangesWithUndoSupport(
+      textarea,
+      [
+        { start: 0, end: 5 },
+        { start: 6, end: 11 },
+      ],
+      'bye',
+    )
+
+    expect(result).toBe('bye bye')
+    expect(document.execCommand).toHaveBeenCalledWith('insertText', false, 'bye bye')
+    expect(document.activeElement).toBe(replaceInput)
+  })
+
+  it('clears editor selection and restores replace input focus after undo', () => {
+    const textarea = document.createElement('textarea')
+    textarea.value = 'hello hello'
+    const replaceInput = document.createElement('input')
+    document.body.appendChild(textarea)
+    document.body.appendChild(replaceInput)
+    replaceInput.focus()
+
+    document.execCommand = jest.fn((_command, _showUi, text: string) => {
+      textarea.value = text
+      return true
+    })
+
+    replaceAllTextRangesWithUndoSupport(
+      textarea,
+      [
+        { start: 0, end: 5 },
+        { start: 6, end: 11 },
+      ],
+      'bye',
+    )
+
+    textarea.focus()
+    textarea.value = 'hello hello'
+    textarea.setSelectionRange(0, textarea.value.length)
+    textarea.dispatchEvent(new InputEvent('input', { inputType: 'historyUndo', bubbles: true }))
+
+    expect(textarea.selectionStart).toBe(0)
+    expect(textarea.selectionEnd).toBe(0)
+    expect(document.activeElement).toBe(replaceInput)
+  })
+
+  it('clears editor selection and restores replace input focus after undoing a single replace', () => {
+    const textarea = document.createElement('textarea')
+    textarea.value = 'hello world'
+    const replaceInput = document.createElement('input')
+    document.body.appendChild(textarea)
+    document.body.appendChild(replaceInput)
+    replaceInput.focus()
+
+    document.execCommand = jest.fn((_command, _showUi, text: string) => {
+      const start = textarea.selectionStart ?? 0
+      const end = textarea.selectionEnd ?? 0
+      textarea.value = textarea.value.slice(0, start) + text + textarea.value.slice(end)
+      return true
+    })
+
+    replaceTextRangeWithUndoSupport(textarea, 6, 11, 'earth')
+
+    textarea.focus()
+    textarea.value = 'hello world'
+    textarea.setSelectionRange(6, 11)
+    textarea.dispatchEvent(new InputEvent('input', { inputType: 'historyUndo', bubbles: true }))
+
+    expect(textarea.selectionStart).toBe(0)
+    expect(textarea.selectionEnd).toBe(0)
+    expect(document.activeElement).toBe(replaceInput)
+  })
+
+  it('falls back to manual replacement when execCommand fails', () => {
+    const textarea = document.createElement('textarea')
+    textarea.value = 'hello world'
+    const replaceInput = document.createElement('input')
+    document.body.appendChild(textarea)
+    document.body.appendChild(replaceInput)
+    replaceInput.focus()
+
+    document.execCommand = jest.fn(() => false)
+
+    replaceTextRangeWithUndoSupport(textarea, 6, 11, 'earth')
+
+    expect(textarea.value).toBe('hello earth')
+    expect(textarea.selectionStart).toBe(0)
+    expect(textarea.selectionEnd).toBe(0)
+    expect(document.activeElement).toBe(replaceInput)
+
+    textarea.focus()
+    textarea.value = 'hello world'
+    textarea.setSelectionRange(6, 11)
+    textarea.dispatchEvent(new InputEvent('input', { inputType: 'historyUndo', bubbles: true }))
+
+    expect(textarea.selectionStart).toBe(6)
+    expect(textarea.selectionEnd).toBe(11)
+    expect(document.activeElement).toBe(textarea)
+  })
+})
diff --git a/packages/web/src/javascripts/Components/NoteView/PlainEditor/replacePlainTextWithUndoSupport.ts b/packages/web/src/javascripts/Components/NoteView/PlainEditor/replacePlainTextWithUndoSupport.ts
new file mode 100644
index 00000000000..1d5ab227481
--- /dev/null
+++ b/packages/web/src/javascripts/Components/NoteView/PlainEditor/replacePlainTextWithUndoSupport.ts
@@ -0,0 +1,100 @@
+import { applyTextReplacements } from '../UniversalSearch/applyTextReplacements'
+import { TextRange } from '../UniversalSearch/types'
+
+type PendingUndo = {
+  previousFocus: HTMLElement
+  isUndoSelection: (textarea: HTMLTextAreaElement) => boolean
+}
+
+const pendingUndo = new WeakMap<HTMLTextAreaElement, PendingUndo>()
+
+function moveFocusOutOfEditor(textarea: HTMLTextAreaElement, previousFocus: HTMLElement) {
+  textarea.setSelectionRange(0, 0)
+  previousFocus.focus()
+}
+
+function handleUndoInput(event: Event) {
+  const textarea = event.currentTarget as HTMLTextAreaElement
+  const pending = pendingUndo.get(textarea)
+
+  if (!pending || !(event instanceof InputEvent) || event.inputType !== 'historyUndo') {
+    return
+  }
+
+  if (!pending.isUndoSelection(textarea) || !pending.previousFocus.isConnected) {
+    return
+  }
+
+  pendingUndo.delete(textarea)
+
+  // The browser restores the undone selection after this event, so it can only be cleared next frame.
+  requestAnimationFrame(() => moveFocusOutOfEditor(textarea, pending.previousFocus))
+}
+
+function replaceSelection(
+  textarea: HTMLTextAreaElement,
+  start: number,
+  end: number,
+  text: string,
+  isUndoSelection: PendingUndo['isUndoSelection'],
+): string {
+  const previousFocus = document.activeElement
+
+  // Re-registering the same listener reference is a no-op, so no bookkeeping is needed.
+  textarea.addEventListener('input', handleUndoInput)
+
+  textarea.focus()
+  textarea.setSelectionRange(start, end)
+
+  const hasNativeUndoEntry = document.execCommand('insertText', false, text)
+  if (!hasNativeUndoEntry) {
+    textarea.value = textarea.value.slice(0, start) + text + textarea.value.slice(end)
+  }
+
+  if (!(previousFocus instanceof HTMLElement) || previousFocus === textarea || !previousFocus.isConnected) {
+    return textarea.value
+  }
+
+  if (hasNativeUndoEntry) {
+    pendingUndo.set(textarea, { previousFocus, isUndoSelection })
+  }
+
+  moveFocusOutOfEditor(textarea, previousFocus)
+
+  return textarea.value
+}
+
+export function replaceTextRangeWithUndoSupport(
+  textarea: HTMLTextAreaElement,
+  start: number,
+  end: number,
+  replacement: string,
+): string {
+  return replaceSelection(
+    textarea,
+    start,
+    end,
+    replacement,
+    (target) => target.selectionStart === start && target.selectionEnd === end,
+  )
+}
+
+export function replaceAllTextRangesWithUndoSupport(
+  textarea: HTMLTextAreaElement,
+  ranges: TextRange[],
+  replacement: string,
+): string {
+  if (ranges.length < 1) {
+    return textarea.value
+  }
+
+  const nextText = applyTextReplacements(textarea.value, ranges, replacement)
+
+  return replaceSelection(
+    textarea,
+    0,
+    textarea.value.length,
+    nextText,
+    (target) => target.selectionStart === 0 && target.selectionEnd === target.value.length && target.value.length > 0,
+  )
+}
diff --git a/packages/web/src/javascripts/Components/NoteView/PlainEditor/search/PlainEditorSearchBackdrop.tsx b/packages/web/src/javascripts/Components/NoteView/PlainEditor/search/PlainEditorSearchBackdrop.tsx
new file mode 100644
index 00000000000..305b62c1d53
--- /dev/null
+++ b/packages/web/src/javascripts/Components/NoteView/PlainEditor/search/PlainEditorSearchBackdrop.tsx
@@ -0,0 +1,50 @@
+import { classNames } from '@standardnotes/utils'
+import { isIOS } from '@standardnotes/ui-services'
+import { RefObject, useEffect, useRef } from 'react'
+
+type Props = {
+  html: string
+  textareaRef: RefObject<HTMLTextAreaElement | null>
+  typographyClassName: string
+  syncDependency?: string
+}
+
+export function PlainEditorSearchBackdrop({ html, textareaRef, typographyClassName, syncDependency }: Props) {
+  const backdropScrollRef = useRef<HTMLDivElement | null>(null)
+
+  useEffect(() => {
+    const textarea = textareaRef.current
+    const backdrop = backdropScrollRef.current
+    if (!textarea || !backdrop) {
+      return
+    }
+
+    const syncScroll = () => {
+      backdrop.scrollTop = textarea.scrollTop
+      backdrop.scrollLeft = textarea.scrollLeft
+    }
+
+    syncScroll()
+    textarea.addEventListener('scroll', syncScroll)
+
+    return () => {
+      textarea.removeEventListener('scroll', syncScroll)
+    }
+  }, [textareaRef, syncDependency])
+
+  const backdropClassName = classNames(
+    'plain-editor-search-backdrop font-editor whitespace-pre-wrap break-words',
+    typographyClassName,
+    isIOS() && '!pb-12',
+  )
+
+  return (
+    <div
+      ref={backdropScrollRef}
+      className="plain-editor-search-backdrop-scroll pointer-events-none absolute inset-0"
+      aria-hidden
+    >
+      <div className={backdropClassName} dir="auto" dangerouslySetInnerHTML={{ __html: html }} />
+    </div>
+  )
+}
diff --git a/packages/web/src/javascripts/Components/NoteView/PlainEditor/search/PlainEditorSearchContainer.tsx b/packages/web/src/javascripts/Components/NoteView/PlainEditor/search/PlainEditorSearchContainer.tsx
new file mode 100644
index 00000000000..3cac3696501
--- /dev/null
+++ b/packages/web/src/javascripts/Components/NoteView/PlainEditor/search/PlainEditorSearchContainer.tsx
@@ -0,0 +1,135 @@
+import { ComponentProps, forwardRef, useCallback, useEffect, useImperativeHandle, useMemo, useRef } from 'react'
+import { observer } from 'mobx-react-lite'
+import { useApplication } from '@/Components/ApplicationProvider'
+import { useKeyboardService } from '@/Components/KeyboardServiceProvider'
+import {
+  keyboardStringForShortcut,
+  UNIVERSAL_SEARCH_TOGGLE_CASE_SENSITIVE,
+  UNIVERSAL_SEARCH_TOGGLE_REPLACE_MODE,
+  UNIVERSAL_TOGGLE_SEARCH,
+} from '@standardnotes/ui-services'
+import { UniversalSearchController } from '../../UniversalSearch/UniversalSearchController'
+import { registerUniversalSearchKeyboardHandlers } from '../../UniversalSearch/registerUniversalSearchKeyboardHandlers'
+import { createPlainEditorUniversalSearchProvider } from '../../UniversalSearch/providers/PlainEditorUniversalSearchProvider'
+import { UniversalSearchShell } from '../../UniversalSearch/UniversalSearchShell'
+import { PlainEditor, PlainEditorInterface } from '../PlainEditor'
+
+type PlainEditorProps = ComponentProps<typeof PlainEditor>
+
+export const PlainEditorSearchContainer = observer(
+  forwardRef<PlainEditorInterface, PlainEditorProps>(function PlainEditorSearchContainer(props, ref) {
+    const application = useApplication()
+    const keyboardService = useKeyboardService()
+    const plainEditorRef = useRef<PlainEditorInterface | null>(null)
+    const isUniversalSearchEnabled = application.featuresController.isUniversalSearchEnabled()
+
+    const noteUuid = props.controller.item.uuid
+
+    const controller = useMemo(() => {
+      if (!isUniversalSearchEnabled) {
+        return undefined
+      }
+
+      const provider = createPlainEditorUniversalSearchProvider({
+        getEditor: () => plainEditorRef.current ?? undefined,
+      })
+
+      return new UniversalSearchController(provider)
+    }, [isUniversalSearchEnabled])
+
+    useEffect(() => {
+      controller?.resetContext()
+    }, [noteUuid, controller])
+
+    useImperativeHandle(
+      ref,
+      () => ({
+        focus: () => plainEditorRef.current?.focus(),
+        getText: () => plainEditorRef.current?.getText() ?? '',
+        getTextarea: () => plainEditorRef.current?.getTextarea() ?? null,
+        setSelection: (start, end, options) => plainEditorRef.current?.setSelection(start, end, options),
+        replaceRange: async (start, end, replacement) => {
+          await plainEditorRef.current?.replaceRange(start, end, replacement)
+        },
+        replaceAllRanges: async (ranges, replacement) => {
+          await plainEditorRef.current?.replaceAllRanges(ranges, replacement)
+        },
+        onTextChange: (callback) => plainEditorRef.current?.onTextChange(callback) ?? (() => undefined),
+      }),
+      [],
+    )
+
+    useEffect(() => {
+      return () => {
+        controller?.deinit()
+      }
+    }, [controller])
+
+    const wasSearchOpenRef = useRef(false)
+
+    useEffect(() => {
+      if (wasSearchOpenRef.current && !controller?.isOpen) {
+        plainEditorRef.current?.focus()
+      }
+
+      wasSearchOpenRef.current = controller?.isOpen ?? false
+    }, [controller?.isOpen])
+
+    const handleTextChange = useCallback(() => {
+      if (!controller?.isOpen) {
+        return
+      }
+
+      controller.refreshSearch()
+    }, [controller])
+
+    useEffect(() => {
+      if (!controller || !isUniversalSearchEnabled) {
+        return
+      }
+
+      return registerUniversalSearchKeyboardHandlers(keyboardService, controller)
+    }, [controller, isUniversalSearchEnabled, keyboardService])
+
+    const setPlainEditorRef = useCallback((editor: PlainEditorInterface | null) => {
+      plainEditorRef.current = editor
+    }, [])
+
+    const search = controller
+      ? {
+          isOpen: controller.isOpen,
+          query: controller.query,
+          isCaseSensitive: controller.isCaseSensitive,
+          shouldHighlightAll: controller.shouldHighlightAll,
+          activeMatch: controller.currentResult?.payload,
+        }
+      : undefined
+
+    const searchToggleShortcut = keyboardStringForShortcut(
+      keyboardService.keyboardShortcutForCommand(UNIVERSAL_TOGGLE_SEARCH),
+    )
+    const toggleReplaceShortcut = keyboardStringForShortcut(
+      keyboardService.keyboardShortcutForCommand(UNIVERSAL_SEARCH_TOGGLE_REPLACE_MODE),
+    )
+    const caseSensitivityShortcut = keyboardStringForShortcut(
+      keyboardService.keyboardShortcutForCommand(UNIVERSAL_SEARCH_TOGGLE_CASE_SENSITIVE),
+    )
+
+    if (!isUniversalSearchEnabled || !controller) {
+      return <PlainEditor {...props} ref={setPlainEditorRef} />
+    }
+
+    return (
+      <div className="relative flex flex-grow flex-col">
+        <UniversalSearchShell
+          controller={controller}
+          locked={props.locked}
+          closeShortcut={searchToggleShortcut}
+          replaceShortcut={toggleReplaceShortcut}
+          caseSensitivityShortcut={caseSensitivityShortcut}
+        />
+        <PlainEditor {...props} ref={setPlainEditorRef} isSearchMode onTextChange={handleTextChange} search={search} />
+      </div>
+    )
+  }),
+)
diff --git a/packages/web/src/javascripts/Components/NoteView/PlainEditor/search/buildPlainSearchHighlightHtml.spec.ts b/packages/web/src/javascripts/Components/NoteView/PlainEditor/search/buildPlainSearchHighlightHtml.spec.ts
new file mode 100644
index 00000000000..b347294d867
--- /dev/null
+++ b/packages/web/src/javascripts/Components/NoteView/PlainEditor/search/buildPlainSearchHighlightHtml.spec.ts
@@ -0,0 +1,68 @@
+import { buildPlainSearchHighlightHtml } from './buildPlainSearchHighlightHtml'
+
+describe('buildPlainSearchHighlightHtml', () => {
+  it('returns null when search is closed', () => {
+    expect(
+      buildPlainSearchHighlightHtml(
+        {
+          isOpen: false,
+          query: 'hello',
+          results: [],
+          shouldHighlightAll: true,
+        },
+        () => 'hello world',
+      ),
+    ).toBeNull()
+  })
+
+  it('escapes html in note text', () => {
+    const html = buildPlainSearchHighlightHtml(
+      {
+        isOpen: true,
+        query: 'x',
+        results: [],
+        shouldHighlightAll: true,
+      },
+      () => '<script>',
+    )
+
+    expect(html).toBe('&lt;script&gt;')
+  })
+
+  it('highlights all matches when enabled', () => {
+    const html = buildPlainSearchHighlightHtml(
+      {
+        isOpen: true,
+        query: 'hello',
+        results: [
+          { id: '1', payload: { start: 0, end: 5 } },
+          { id: '2', payload: { start: 6, end: 11 } },
+        ],
+        currentResult: { id: '1', payload: { start: 0, end: 5 } },
+        shouldHighlightAll: true,
+      },
+      () => 'hello hello',
+    )
+
+    expect(html).toContain('<mark class="plain-search-highlight-active">hello</mark>')
+    expect(html).toContain('<mark class="plain-search-highlight">hello</mark>')
+  })
+
+  it('highlights only the active match when highlight all is disabled', () => {
+    const html = buildPlainSearchHighlightHtml(
+      {
+        isOpen: true,
+        query: 'hello',
+        results: [
+          { id: '1', payload: { start: 0, end: 5 } },
+          { id: '2', payload: { start: 6, end: 11 } },
+        ],
+        currentResult: { id: '2', payload: { start: 6, end: 11 } },
+        shouldHighlightAll: false,
+      },
+      () => 'hello hello',
+    )
+
+    expect(html).toBe('hello <mark class="plain-search-highlight-active">hello</mark>')
+  })
+})
diff --git a/packages/web/src/javascripts/Components/NoteView/PlainEditor/search/buildPlainSearchHighlightHtml.ts b/packages/web/src/javascripts/Components/NoteView/PlainEditor/search/buildPlainSearchHighlightHtml.ts
new file mode 100644
index 00000000000..713af46502b
--- /dev/null
+++ b/packages/web/src/javascripts/Components/NoteView/PlainEditor/search/buildPlainSearchHighlightHtml.ts
@@ -0,0 +1,59 @@
+import { TextRange, UniversalSearchResult } from '../../UniversalSearch/types'
+
+export type PlainSearchHighlightState = {
+  isOpen: boolean
+  query: string
+  results: UniversalSearchResult<TextRange>[]
+  currentResult?: UniversalSearchResult<TextRange>
+  shouldHighlightAll: boolean
+}
+
+function escapeHtml(text: string): string {
+  return text.replace(/&/g, '&amp;').replace(/</g, '&lt;').replace(/>/g, '&gt;')
+}
+
+export function buildPlainSearchHighlightHtml(state: PlainSearchHighlightState, getText: () => string): string | null {
+  if (!state.isOpen || !state.query) {
+    return null
+  }
+
+  const text = getText()
+  const matches = state.results
+    .map((result) => result.payload)
+    .filter((payload): payload is TextRange => payload != undefined)
+  const activeMatch = state.currentResult?.payload
+
+  if (!matches.length) {
+    return escapeHtml(text)
+  }
+
+  const sortedMatches = [...matches].sort((a, b) => a.start - b.start)
+  let html = ''
+  let lastEnd = 0
+
+  for (const match of sortedMatches) {
+    if (match.start < lastEnd) {
+      continue
+    }
+
+    html += escapeHtml(text.slice(lastEnd, match.start))
+
+    const matchText = escapeHtml(text.slice(match.start, match.end))
+    const isActive = activeMatch != undefined && match.start === activeMatch.start && match.end === activeMatch.end
+    const shouldShow = state.shouldHighlightAll || isActive
+
+    if (shouldShow) {
+      html += `<mark class="${
+        isActive ? 'plain-search-highlight-active' : 'plain-search-highlight'
+      }">${matchText}</mark>`
+    } else {
+      html += matchText
+    }
+
+    lastEnd = match.end
+  }
+
+  html += escapeHtml(text.slice(lastEnd))
+
+  return html
+}
diff --git a/packages/web/src/javascripts/Components/NoteView/PlainEditor/search/scrollPlainTextareaToOffset.spec.ts b/packages/web/src/javascripts/Components/NoteView/PlainEditor/search/scrollPlainTextareaToOffset.spec.ts
new file mode 100644
index 00000000000..2139f5e06a5
--- /dev/null
+++ b/packages/web/src/javascripts/Components/NoteView/PlainEditor/search/scrollPlainTextareaToOffset.spec.ts
@@ -0,0 +1,39 @@
+/**
+ * @jest-environment jsdom
+ */
+
+import { getTargetScrollTopForMatch, scrollPlainTextareaToOffset } from './scrollPlainTextareaToOffset'
+
+describe('scrollPlainTextareaToOffset', () => {
+  it('centers the match in the textarea viewport', () => {
+    const textarea = document.createElement('textarea')
+    const lines = Array.from({ length: 20 }, (_, index) => `line ${index}`).join('\n')
+    textarea.value = lines
+    textarea.style.width = '200px'
+    textarea.style.height = '80px'
+    textarea.style.lineHeight = '20px'
+    textarea.style.padding = '0'
+    textarea.style.whiteSpace = 'pre-wrap'
+    document.body.appendChild(textarea)
+
+    const matchStart = lines.indexOf('line 15')
+    const matchEnd = matchStart + 'line 15'.length
+    const targetScrollTop = getTargetScrollTopForMatch(textarea, matchStart, matchEnd)
+
+    scrollPlainTextareaToOffset(textarea, matchStart, matchEnd)
+
+    expect(textarea.scrollTop).toBe(targetScrollTop)
+
+    document.body.removeChild(textarea)
+  })
+
+  it('clamps offsets to the textarea value length', () => {
+    const textarea = document.createElement('textarea')
+    textarea.value = 'hello'
+    document.body.appendChild(textarea)
+
+    expect(() => scrollPlainTextareaToOffset(textarea, 0, 100)).not.toThrow()
+
+    document.body.removeChild(textarea)
+  })
+})
diff --git a/packages/web/src/javascripts/Components/NoteView/PlainEditor/search/scrollPlainTextareaToOffset.ts b/packages/web/src/javascripts/Components/NoteView/PlainEditor/search/scrollPlainTextareaToOffset.ts
new file mode 100644
index 00000000000..08b2cace1d5
--- /dev/null
+++ b/packages/web/src/javascripts/Components/NoteView/PlainEditor/search/scrollPlainTextareaToOffset.ts
@@ -0,0 +1,83 @@
+const mirrorStyleProperties = [
+  'borderBottomWidth',
+  'borderLeftWidth',
+  'borderRightWidth',
+  'borderTopWidth',
+  'boxSizing',
+  'fontFamily',
+  'fontSize',
+  'fontStyle',
+  'fontWeight',
+  'letterSpacing',
+  'lineHeight',
+  'paddingBottom',
+  'paddingLeft',
+  'paddingRight',
+  'paddingTop',
+  'tabSize',
+  'textIndent',
+  'textTransform',
+  'whiteSpace',
+  'wordSpacing',
+] as const
+
+type MatchPosition = {
+  top: number
+  bottom: number
+}
+
+function measureMatchPosition(textarea: HTMLTextAreaElement, start: number, end: number): MatchPosition {
+  const boundedStart = Math.max(0, Math.min(start, textarea.value.length))
+  const boundedEnd = Math.max(boundedStart, Math.min(end, textarea.value.length))
+  const style = window.getComputedStyle(textarea)
+  const mirror = document.createElement('div')
+  mirror.setAttribute('aria-hidden', 'true')
+  mirror.style.position = 'absolute'
+  mirror.style.top = '0'
+  mirror.style.left = '-9999px'
+  mirror.style.visibility = 'hidden'
+  mirror.style.width = `${textarea.clientWidth}px`
+  mirror.style.overflowWrap = 'break-word'
+  mirror.style.wordWrap = 'break-word'
+
+  for (const property of mirrorStyleProperties) {
+    mirror.style[property] = style[property]
+  }
+
+  const textBefore = textarea.value.slice(0, boundedStart)
+  const matchText = textarea.value.slice(boundedStart, boundedEnd) || '\u200b'
+  const textAfter = textarea.value.slice(boundedEnd)
+
+  mirror.textContent = textBefore
+
+  const matchSpan = document.createElement('span')
+  matchSpan.textContent = matchText
+  mirror.appendChild(matchSpan)
+
+  if (textAfter) {
+    mirror.appendChild(document.createTextNode(textAfter))
+  }
+
+  document.body.appendChild(mirror)
+
+  const lineHeight = parseFloat(style.lineHeight) || matchSpan.offsetHeight || 0
+  const top = matchSpan.offsetTop
+  const bottom = top + (matchSpan.offsetHeight || lineHeight)
+
+  document.body.removeChild(mirror)
+
+  return { top, bottom }
+}
+
+export function getTargetScrollTopForMatch(textarea: HTMLTextAreaElement, start: number, end: number = start): number {
+  const { top: matchTop, bottom: matchBottom } = measureMatchPosition(textarea, start, end)
+  const maxScrollTop = Math.max(0, textarea.scrollHeight - textarea.clientHeight)
+  const matchHeight = matchBottom - matchTop
+  const targetTop = matchTop - textarea.clientHeight / 2 + matchHeight / 2
+
+  return Math.max(0, Math.min(targetTop, maxScrollTop))
+}
+
+export function scrollPlainTextareaToOffset(textarea: HTMLTextAreaElement, start: number, end: number = start): void {
+  textarea.scrollTop = getTargetScrollTopForMatch(textarea, start, end)
+}
diff --git a/packages/web/src/javascripts/Components/NoteView/UniversalSearch/UniversalSearchController.spec.ts b/packages/web/src/javascripts/Components/NoteView/UniversalSearch/UniversalSearchController.spec.ts
new file mode 100644
index 00000000000..ed7a16cef37
--- /dev/null
+++ b/packages/web/src/javascripts/Components/NoteView/UniversalSearch/UniversalSearchController.spec.ts
@@ -0,0 +1,328 @@
+import { createMockUniversalSearchProvider } from './providers/createMockUniversalSearchProvider'
+import {
+  getNextUniversalSearchResultIndex,
+  getPreviousUniversalSearchResultIndex,
+  UniversalSearchController,
+} from './UniversalSearchController'
+import { UniversalSearchProvider } from './types'
+
+const immediateSearchOptions = { searchDebounceMs: 0, contentSearchDebounceMs: 0 }
+
+describe('UniversalSearchController', () => {
+  async function flushSearch() {
+    await Promise.resolve()
+  }
+
+  it('calculates predictable wraparound indexes', () => {
+    expect(getNextUniversalSearchResultIndex(-1, 0)).toBe(-1)
+    expect(getNextUniversalSearchResultIndex(-1, 3)).toBe(0)
+    expect(getNextUniversalSearchResultIndex(2, 3)).toBe(0)
+    expect(getPreviousUniversalSearchResultIndex(-1, 0)).toBe(-1)
+    expect(getPreviousUniversalSearchResultIndex(0, 3)).toBe(2)
+  })
+
+  it('opens, searches, selects, navigates, and closes with reset state', async () => {
+    const onSelectResult = jest.fn()
+    const provider = createMockUniversalSearchProvider({
+      documents: [{ id: 'one', text: 'hello hello' }],
+      onSelectResult,
+    })
+    const controller = new UniversalSearchController(provider, immediateSearchOptions)
+
+    controller.open()
+    controller.setQuery('hello')
+    await flushSearch()
+
+    expect(controller.isOpen).toBe(true)
+    expect(controller.status).toBe('ready')
+    expect(controller.results).toHaveLength(2)
+    expect(controller.currentResultIndex).toBe(0)
+    expect(onSelectResult).toHaveBeenCalledWith(expect.objectContaining({ id: 'one-0' }))
+
+    controller.goToNextResult()
+    await flushSearch()
+
+    expect(controller.currentResultIndex).toBe(1)
+    expect(onSelectResult).toHaveBeenLastCalledWith(expect.objectContaining({ id: 'one-6' }))
+
+    controller.goToNextResult()
+    await flushSearch()
+
+    expect(controller.currentResultIndex).toBe(0)
+
+    controller.close()
+
+    expect(controller.isOpen).toBe(false)
+    expect(controller.query).toBe('')
+    expect(controller.results).toEqual([])
+    expect(controller.currentResultIndex).toBe(-1)
+  })
+
+  it('debounces query changes before searching', async () => {
+    jest.useFakeTimers()
+    const search = jest.fn(() => [])
+    const provider: UniversalSearchProvider = {
+      id: 'debounced',
+      capabilities: {
+        supportsReplace: false,
+        supportsHighlightAll: false,
+      },
+      search,
+      selectResult: jest.fn(),
+      clear: jest.fn(),
+    }
+    const controller = new UniversalSearchController(provider, { searchDebounceMs: 30, contentSearchDebounceMs: 250 })
+
+    controller.open()
+    controller.setQuery('h')
+    controller.setQuery('he')
+    controller.setQuery('hel')
+
+    expect(search).not.toHaveBeenCalled()
+
+    jest.advanceTimersByTime(30)
+    await flushSearch()
+
+    expect(search).toHaveBeenCalledTimes(1)
+    expect(search).toHaveBeenCalledWith({ query: 'hel', isCaseSensitive: false })
+
+    jest.useRealTimers()
+  })
+
+  it('handles provider errors', async () => {
+    const provider: UniversalSearchProvider = {
+      id: 'failing',
+      capabilities: {
+        supportsReplace: false,
+        supportsHighlightAll: false,
+      },
+      search: () => {
+        throw new Error('Provider failed')
+      },
+      selectResult: jest.fn(),
+      clear: jest.fn(),
+    }
+    const controller = new UniversalSearchController(provider, immediateSearchOptions)
+
+    controller.open()
+    controller.setQuery('hello')
+    await flushSearch()
+
+    expect(controller.status).toBe('error')
+    expect(controller.error).toBe('Provider failed')
+    expect(controller.results).toEqual([])
+  })
+
+  it('delegates replacement through provider contracts', async () => {
+    const provider = createMockUniversalSearchProvider({
+      documents: [{ id: 'one', text: 'hello hello' }],
+    })
+    const controller = new UniversalSearchController(provider, immediateSearchOptions)
+
+    controller.open()
+    controller.setQuery('hello')
+    controller.setReplaceQuery('goodbye')
+    await flushSearch()
+
+    await controller.replaceCurrentResult()
+
+    expect(provider.getDocuments()[0].text).toBe('goodbye hello')
+    expect(controller.results).toHaveLength(1)
+
+    await controller.replaceAllResults()
+
+    expect(provider.getDocuments()[0].text).toBe('goodbye goodbye')
+    expect(controller.results).toHaveLength(0)
+  })
+
+  it('preserves the current result index after replacing a single match', async () => {
+    const provider = createMockUniversalSearchProvider({
+      documents: [{ id: 'one', text: 'hello hello hello' }],
+    })
+    const controller = new UniversalSearchController(provider, immediateSearchOptions)
+
+    controller.open()
+    controller.setQuery('hello')
+    controller.setReplaceQuery('bye')
+    await flushSearch()
+
+    controller.goToNextResult()
+    await flushSearch()
+    expect(controller.currentResultIndex).toBe(1)
+
+    await controller.replaceCurrentResult()
+
+    expect(provider.getDocuments()[0].text).toBe('hello bye hello')
+    expect(controller.results).toHaveLength(2)
+    expect(controller.currentResultIndex).toBe(1)
+    expect(controller.currentResult?.id).toBe('one-10')
+  })
+
+  it('resetContext clears search state without selecting a stale result', async () => {
+    const onSelectResult = jest.fn()
+    const provider = createMockUniversalSearchProvider({
+      documents: [{ id: 'one', text: 'hello hello' }],
+      onSelectResult,
+    })
+    const controller = new UniversalSearchController(provider, immediateSearchOptions)
+
+    controller.open()
+    controller.setQuery('hello')
+    controller.setReplaceQuery('bye')
+    controller.toggleReplaceMode()
+    await flushSearch()
+
+    expect(controller.isOpen).toBe(true)
+    expect(controller.results).toHaveLength(2)
+    expect(onSelectResult).toHaveBeenCalledTimes(1)
+
+    controller.resetContext()
+
+    expect(controller.isOpen).toBe(false)
+    expect(controller.query).toBe('')
+    expect(controller.replaceQuery).toBe('')
+    expect(controller.results).toEqual([])
+    expect(controller.isReplaceMode).toBe(false)
+    expect(onSelectResult).toHaveBeenCalledTimes(1)
+  })
+
+  it('does not toggle case sensitivity when search is closed', async () => {
+    const search = jest.fn(() => [])
+    const provider: UniversalSearchProvider = {
+      id: 'case-sensitive',
+      capabilities: {
+        supportsReplace: false,
+        supportsHighlightAll: false,
+      },
+      search,
+      selectResult: jest.fn(),
+      clear: jest.fn(),
+    }
+    const controller = new UniversalSearchController(provider, immediateSearchOptions)
+
+    controller.toggleCaseSensitivity()
+
+    expect(controller.isCaseSensitive).toBe(false)
+    expect(search).not.toHaveBeenCalled()
+  })
+
+  it('does not enable replace mode when replace is unsupported', () => {
+    const provider: UniversalSearchProvider = {
+      id: 'no-replace',
+      capabilities: {
+        supportsReplace: false,
+        supportsHighlightAll: true,
+      },
+      search: jest.fn(() => []),
+      selectResult: jest.fn(),
+      clear: jest.fn(),
+    }
+    const controller = new UniversalSearchController(provider, immediateSearchOptions)
+
+    controller.open()
+    controller.toggleReplaceMode()
+
+    expect(controller.isReplaceMode).toBe(false)
+  })
+
+  it('closes replace mode when locked', () => {
+    const provider: UniversalSearchProvider = {
+      id: 'dynamic-replace',
+      capabilities: {
+        supportsReplace: true,
+        supportsHighlightAll: true,
+      },
+      search: jest.fn(() => []),
+      selectResult: jest.fn(),
+      clear: jest.fn(),
+    }
+    const controller = new UniversalSearchController(provider, immediateSearchOptions)
+
+    controller.open()
+    controller.toggleReplaceMode()
+
+    expect(controller.isReplaceMode).toBe(true)
+
+    controller.setLocked(true)
+
+    expect(controller.canReplace).toBe(false)
+    expect(controller.isReplaceMode).toBe(false)
+  })
+
+  it('closes replace mode', () => {
+    const provider: UniversalSearchProvider = {
+      id: 'dynamic-replace',
+      capabilities: {
+        supportsReplace: true,
+        supportsHighlightAll: true,
+      },
+      search: jest.fn(() => []),
+      selectResult: jest.fn(),
+      clear: jest.fn(),
+    }
+    const controller = new UniversalSearchController(provider, immediateSearchOptions)
+
+    controller.open()
+    controller.toggleReplaceMode()
+
+    expect(controller.isReplaceMode).toBe(true)
+
+    controller.closeReplaceMode()
+
+    expect(controller.isReplaceMode).toBe(false)
+  })
+
+  it('does not enable replace mode when the note is locked', () => {
+    const provider: UniversalSearchProvider = {
+      id: 'read-only',
+      capabilities: {
+        supportsReplace: true,
+        supportsHighlightAll: true,
+      },
+      search: jest.fn(() => []),
+      selectResult: jest.fn(),
+      clear: jest.fn(),
+    }
+    const controller = new UniversalSearchController(provider, {
+      ...immediateSearchOptions,
+    })
+    controller.setLocked(true)
+
+    controller.open()
+    controller.toggleReplaceMode()
+
+    expect(controller.canReplace).toBe(false)
+    expect(controller.isReplaceMode).toBe(false)
+  })
+
+  it('does not replace text when locked', async () => {
+    const replaceCurrentResult = jest.fn()
+    const provider: UniversalSearchProvider = {
+      id: 'read-only-replace',
+      capabilities: {
+        supportsReplace: true,
+        supportsHighlightAll: true,
+      },
+      search: jest.fn(() => [{ id: 'one-0' }]),
+      selectResult: jest.fn(),
+      clear: jest.fn(),
+      replaceCurrentResult,
+      replaceAllResults: jest.fn(),
+    }
+    const controller = new UniversalSearchController(provider, {
+      ...immediateSearchOptions,
+    })
+
+    controller.open()
+    controller.setQuery('hello')
+    await flushSearch()
+    controller.setReplaceQuery('bye')
+    controller.toggleReplaceMode()
+
+    controller.setLocked(true)
+    await controller.replaceCurrentResult()
+    await controller.replaceAllResults()
+
+    expect(replaceCurrentResult).not.toHaveBeenCalled()
+  })
+})
diff --git a/packages/web/src/javascripts/Components/NoteView/UniversalSearch/UniversalSearchController.ts b/packages/web/src/javascripts/Components/NoteView/UniversalSearch/UniversalSearchController.ts
new file mode 100644
index 00000000000..bdd69f04b87
--- /dev/null
+++ b/packages/web/src/javascripts/Components/NoteView/UniversalSearch/UniversalSearchController.ts
@@ -0,0 +1,396 @@
+import { action, computed, makeObservable, observable, runInAction } from 'mobx'
+import {
+  UniversalSearchProvider,
+  UniversalSearchResult,
+  UniversalSearchResultPayload,
+  UniversalSearchStatus,
+} from './types'
+
+const DEFAULT_QUERY_DEBOUNCE_MS = 30
+const DEFAULT_CONTENT_REFRESH_DEBOUNCE_MS = 250
+
+export function getNextUniversalSearchResultIndex(currentResultIndex: number, resultCount: number): number {
+  if (resultCount < 1) {
+    return -1
+  }
+
+  const next = currentResultIndex + 1
+  return next >= resultCount ? 0 : next
+}
+
+export function getPreviousUniversalSearchResultIndex(currentResultIndex: number, resultCount: number): number {
+  if (resultCount < 1) {
+    return -1
+  }
+
+  const previous = currentResultIndex - 1
+  return previous < 0 ? resultCount - 1 : previous
+}
+
+function errorMessage(error: unknown): string {
+  if (error instanceof Error) {
+    return error.message
+  }
+
+  return 'Search failed'
+}
+
+type SetSearchResultsOptions = {
+  preferredIndex?: number
+  selectResult?: boolean
+  scrollIntoView?: boolean
+}
+
+interface UniversalSearchControllerOptions<TPayload = UniversalSearchResultPayload> {
+  provider: UniversalSearchProvider<TPayload>
+  /** Overridable mainly so tests can run searches synchronously; production uses the defaults below. */
+  searchDebounceMs?: number
+  contentSearchDebounceMs?: number
+}
+
+export class UniversalSearchController<TPayload = UniversalSearchResultPayload> {
+  isOpen = false
+  query = ''
+  replaceQuery = ''
+  results: UniversalSearchResult<TPayload>[] = []
+  currentResultIndex = -1
+  status: UniversalSearchStatus = 'idle'
+  error: string | undefined = undefined
+  isCaseSensitive = false
+  isReplaceMode = false
+  shouldHighlightAll: boolean
+  locked = false
+
+  private searchId = 0
+  private searchDebounceMs: number
+  private contentSearchDebounceMs: number
+  private searchDebounceTimeout: ReturnType<typeof setTimeout> | undefined
+
+  constructor(
+    public readonly provider: UniversalSearchProvider<TPayload>,
+    options: Omit<UniversalSearchControllerOptions<TPayload>, 'provider'> = {},
+  ) {
+    this.searchDebounceMs = options.searchDebounceMs ?? DEFAULT_QUERY_DEBOUNCE_MS
+    this.contentSearchDebounceMs = options.contentSearchDebounceMs ?? DEFAULT_CONTENT_REFRESH_DEBOUNCE_MS
+    this.shouldHighlightAll = provider.capabilities.supportsHighlightAll ? true : false
+
+    makeObservable<this, 'setSearchResults' | 'setSearchError' | 'clearResults'>(this, {
+      isOpen: observable,
+      query: observable,
+      replaceQuery: observable,
+      results: observable,
+      currentResultIndex: observable,
+      status: observable,
+      error: observable,
+      isCaseSensitive: observable,
+      isReplaceMode: observable,
+      shouldHighlightAll: observable,
+      locked: observable,
+
+      canReplace: computed,
+      currentResult: computed,
+
+      open: action,
+      close: action,
+      resetContext: action,
+      setQuery: action,
+      setReplaceQuery: action,
+      toggleCaseSensitivity: action,
+      toggleReplaceMode: action,
+      closeReplaceMode: action,
+      setLocked: action,
+      setShouldHighlightAll: action,
+      goToNextResult: action,
+      goToPreviousResult: action,
+      setSearchResults: action,
+      setSearchError: action,
+      clearResults: action,
+    })
+  }
+
+  get canReplace(): boolean {
+    return this.provider.capabilities.supportsReplace && !this.locked
+  }
+
+  get currentResult(): UniversalSearchResult<TPayload> | undefined {
+    return this.results[this.currentResultIndex]
+  }
+
+  deinit(): void {
+    this.cancelScheduledSearch()
+    this.searchId++
+    void this.provider.clear()
+    this.results = []
+  }
+
+  open = (): void => {
+    this.isOpen = true
+    void this.executeSearch()
+  }
+
+  close = (): void => {
+    void this.selectCurrentResult({ selectInEditor: true })
+    this.clearSessionState()
+  }
+
+  resetContext = (): void => {
+    this.clearSessionState()
+  }
+
+  setQuery = (query: string): void => {
+    this.query = query
+
+    if (!query) {
+      this.cancelScheduledSearch()
+      void this.executeSearch()
+      return
+    }
+
+    this.scheduleSearch(this.searchDebounceMs)
+  }
+
+  refreshSearch = (): void => {
+    if (!this.isOpen || !this.query) {
+      return
+    }
+
+    this.scheduleSearch(this.contentSearchDebounceMs)
+  }
+
+  setReplaceQuery = (replaceQuery: string): void => {
+    this.replaceQuery = replaceQuery
+  }
+
+  toggleCaseSensitivity = (): void => {
+    if (!this.isOpen) {
+      return
+    }
+
+    this.isCaseSensitive = !this.isCaseSensitive
+    this.scheduleSearch(this.searchDebounceMs)
+  }
+
+  toggleReplaceMode = (): void => {
+    if (!this.canReplace) {
+      this.closeReplaceMode()
+      return
+    }
+
+    this.isReplaceMode = !this.isReplaceMode
+  }
+
+  closeReplaceMode = (): void => {
+    this.isReplaceMode = false
+  }
+
+  setLocked = (locked: boolean): void => {
+    this.locked = locked
+    if (locked) {
+      this.closeReplaceMode()
+    }
+  }
+
+  setShouldHighlightAll = (shouldHighlightAll: boolean): void => {
+    this.shouldHighlightAll = this.provider.capabilities.supportsHighlightAll && shouldHighlightAll
+  }
+
+  goToNextResult = (): void => {
+    this.currentResultIndex = getNextUniversalSearchResultIndex(this.currentResultIndex, this.results.length)
+    void this.selectCurrentResult({ scrollIntoView: true })
+  }
+
+  goToPreviousResult = (): void => {
+    this.currentResultIndex = getPreviousUniversalSearchResultIndex(this.currentResultIndex, this.results.length)
+    void this.selectCurrentResult({ scrollIntoView: true })
+  }
+
+  selectCurrentResult = async (options?: { scrollIntoView?: boolean; selectInEditor?: boolean }): Promise<void> => {
+    const result = this.currentResult
+    if (!result) {
+      return
+    }
+
+    await this.provider.selectResult(result, {
+      scrollIntoView: options?.scrollIntoView ?? false,
+      selectInEditor: options?.selectInEditor ?? false,
+    })
+  }
+
+  replaceCurrentResult = async (): Promise<void> => {
+    if (!this.canReplace || !this.provider.replaceCurrentResult) {
+      return
+    }
+
+    const result = this.currentResult
+    if (!result || !this.replaceQuery) {
+      return
+    }
+
+    const indexBeforeReplace = this.currentResultIndex
+    const nextResults = await this.provider.replaceCurrentResult(result, {
+      query: this.query,
+      isCaseSensitive: this.isCaseSensitive,
+      replaceQuery: this.replaceQuery,
+    })
+
+    await this.handleReplaceResult(nextResults, { preferredIndex: indexBeforeReplace })
+  }
+
+  replaceAllResults = async (): Promise<void> => {
+    if (!this.canReplace || !this.provider.replaceAllResults) {
+      return
+    }
+
+    if (this.results.length < 1 || !this.replaceQuery) {
+      return
+    }
+
+    const nextResults = await this.provider.replaceAllResults(this.results, {
+      query: this.query,
+      isCaseSensitive: this.isCaseSensitive,
+      replaceQuery: this.replaceQuery,
+    })
+
+    await this.handleReplaceResult(nextResults)
+  }
+
+  private clearSessionState = (): void => {
+    this.cancelScheduledSearch()
+    this.searchId++
+    void this.provider.clear()
+    this.isOpen = false
+    this.query = ''
+    this.replaceQuery = ''
+    this.results = []
+    this.currentResultIndex = -1
+    this.status = 'idle'
+    this.error = undefined
+    this.isCaseSensitive = false
+    this.isReplaceMode = false
+    this.shouldHighlightAll = this.provider.capabilities.supportsHighlightAll ? true : false
+  }
+
+  private cancelScheduledSearch = (): void => {
+    if (this.searchDebounceTimeout) {
+      clearTimeout(this.searchDebounceTimeout)
+      this.searchDebounceTimeout = undefined
+    }
+  }
+
+  private scheduleSearch = (debounceMs: number): void => {
+    this.cancelScheduledSearch()
+
+    if (debounceMs <= 0) {
+      void this.executeSearch()
+      return
+    }
+
+    this.searchDebounceTimeout = setTimeout(() => {
+      this.searchDebounceTimeout = undefined
+      void this.executeSearch()
+    }, debounceMs)
+  }
+
+  private executeSearch = async (): Promise<void> => {
+    if (!this.isOpen) {
+      return
+    }
+
+    const searchId = this.searchId + 1
+    this.searchId = searchId
+
+    if (!this.query) {
+      void this.provider.clear()
+      this.clearResults('idle')
+      return
+    }
+
+    this.status = 'loading'
+    this.error = undefined
+
+    try {
+      const results = await this.provider.search({
+        query: this.query,
+        isCaseSensitive: this.isCaseSensitive,
+      })
+
+      if (searchId !== this.searchId) {
+        return
+      }
+
+      runInAction(() => {
+        this.setSearchResults(results, { selectResult: true, scrollIntoView: false })
+      })
+    } catch (error) {
+      if (searchId !== this.searchId) {
+        return
+      }
+
+      runInAction(() => {
+        this.setSearchError(errorMessage(error))
+      })
+    }
+  }
+
+  private handleReplaceResult = async (
+    nextResults: UniversalSearchResult<TPayload>[] | void,
+    options?: Pick<SetSearchResultsOptions, 'preferredIndex'>,
+  ): Promise<void> => {
+    if (Array.isArray(nextResults)) {
+      runInAction(() => {
+        this.setSearchResults(nextResults, {
+          preferredIndex: options?.preferredIndex,
+          selectResult: true,
+          scrollIntoView: true,
+        })
+      })
+      return
+    }
+
+    const results = await this.provider.search({
+      query: this.query,
+      isCaseSensitive: this.isCaseSensitive,
+    })
+
+    runInAction(() => {
+      this.setSearchResults(results, {
+        preferredIndex: options?.preferredIndex,
+        selectResult: true,
+        scrollIntoView: true,
+      })
+    })
+  }
+
+  private setSearchResults(results: UniversalSearchResult<TPayload>[], options?: SetSearchResultsOptions): void {
+    this.results = results
+
+    if (results.length < 1) {
+      this.currentResultIndex = -1
+    } else if (options?.preferredIndex !== undefined) {
+      this.currentResultIndex = Math.min(Math.max(0, options.preferredIndex), results.length - 1)
+    } else {
+      this.currentResultIndex = 0
+    }
+
+    this.status = 'ready'
+    this.error = undefined
+
+    if (options?.selectResult && this.currentResultIndex >= 0) {
+      void this.selectCurrentResult({ scrollIntoView: options.scrollIntoView ?? false })
+    }
+  }
+
+  private setSearchError(error: string): void {
+    this.results = []
+    this.currentResultIndex = -1
+    this.status = 'error'
+    this.error = error
+  }
+
+  private clearResults(status: UniversalSearchStatus): void {
+    this.results = []
+    this.currentResultIndex = -1
+    this.status = status
+    this.error = undefined
+  }
+}
diff --git a/packages/web/src/javascripts/Components/NoteView/UniversalSearch/UniversalSearchShell.tsx b/packages/web/src/javascripts/Components/NoteView/UniversalSearch/UniversalSearchShell.tsx
new file mode 100644
index 00000000000..33540773b46
--- /dev/null
+++ b/packages/web/src/javascripts/Components/NoteView/UniversalSearch/UniversalSearchShell.tsx
@@ -0,0 +1,274 @@
+import { ArrowDownIcon, ArrowRightIcon, ArrowUpIcon, CloseIcon } from '@standardnotes/icons'
+import { classNames } from '@standardnotes/utils'
+import { observer } from 'mobx-react-lite'
+import { KeyboardEvent, useEffect, useRef } from 'react'
+import Button from '../../Button/Button'
+import Icon from '../../Icon/Icon'
+import DecoratedInput from '../../Input/DecoratedInput'
+import StyledTooltip from '../../StyledTooltip/StyledTooltip'
+import { UniversalSearchController } from './UniversalSearchController'
+import { UniversalSearchResultPayload } from './types'
+
+interface UniversalSearchShellProps<TPayload = UniversalSearchResultPayload> {
+  controller: UniversalSearchController<TPayload>
+  locked: boolean
+  className?: string
+  position?: 'absolute' | 'inline'
+  topMarginClassName?: string
+  closeShortcut?: string
+  replaceShortcut?: string
+  caseSensitivityShortcut?: string
+}
+
+function statusLabel<TPayload = UniversalSearchResultPayload>(controller: UniversalSearchController<TPayload>): string {
+  if (controller.status === 'loading') {
+    return 'Loading'
+  }
+
+  if (controller.status === 'error') {
+    return controller.error || 'Error'
+  }
+
+  if (!controller.query) {
+    return ''
+  }
+
+  if (controller.results.length < 1) {
+    return '0'
+  }
+
+  return `${controller.currentResultIndex + 1} / ${controller.results.length}`
+}
+
+export const UniversalSearchShell = observer(function UniversalSearchShell<TPayload = UniversalSearchResultPayload>({
+  controller,
+  locked,
+  className,
+  position = 'absolute',
+  topMarginClassName,
+  closeShortcut,
+  replaceShortcut,
+  caseSensitivityShortcut,
+}: UniversalSearchShellProps<TPayload>) {
+  const searchInputRef = useRef<HTMLInputElement | null>(null)
+  const replaceInputRef = useRef<HTMLInputElement | null>(null)
+  const wasOpenRef = useRef(false)
+  const wasReplaceModeRef = useRef(false)
+
+  useEffect(() => {
+    controller.setLocked(locked)
+  }, [controller, locked])
+
+  useEffect(() => {
+    if (controller.isOpen && !wasOpenRef.current) {
+      searchInputRef.current?.focus()
+    }
+
+    wasOpenRef.current = controller.isOpen
+  }, [controller.isOpen])
+
+  useEffect(() => {
+    if (controller.isOpen && controller.isReplaceMode && !wasReplaceModeRef.current) {
+      replaceInputRef.current?.focus()
+    }
+
+    wasReplaceModeRef.current = controller.isReplaceMode
+  }, [controller.isOpen, controller.isReplaceMode])
+
+  const canReplace = controller.canReplace
+  const canHighlightAll = controller.provider.capabilities.supportsHighlightAll
+  const hasResults = controller.results.length > 0
+  const hasReplaceQuery = controller.replaceQuery.length > 0
+
+  const handleSearchKeyDown = (event: KeyboardEvent<HTMLInputElement>) => {
+    if (event.key !== 'Enter' || !hasResults) {
+      return
+    }
+
+    if (event.shiftKey) {
+      controller.goToPreviousResult()
+      event.preventDefault()
+      return
+    }
+
+    controller.goToNextResult()
+    event.preventDefault()
+  }
+
+  const handleReplaceKeyDown = (event: KeyboardEvent<HTMLInputElement>) => {
+    if (event.key !== 'Enter' || !hasResults || !hasReplaceQuery || !canReplace) {
+      return
+    }
+
+    if (event.ctrlKey && event.altKey) {
+      void controller.replaceAllResults()
+      event.preventDefault()
+      return
+    }
+
+    void controller.replaceCurrentResult()
+    event.preventDefault()
+  }
+
+  if (!controller.isOpen) {
+    return null
+  }
+
+  const defaultTopMarginClassName = position === 'absolute' ? 'top-2 md:top-3' : 'mt-2 md:mt-3'
+
+  return (
+    <div
+      className={classNames(
+        'z-10 flex select-none rounded border border-border bg-default font-sans',
+        position === 'absolute' ? 'absolute left-2 right-6 md:left-auto' : 'relative mx-2 mb-2 w-fit',
+        topMarginClassName ?? defaultTopMarginClassName,
+        className,
+      )}
+    >
+      {canReplace && (
+        <button
+          className="focus:ring-none border-r border-border px-1 hover:bg-contrast focus:shadow-inner focus:shadow-info"
+          onClick={controller.toggleReplaceMode}
+          title={replaceShortcut ? `Toggle Replace Mode (${replaceShortcut})` : 'Toggle Replace Mode'}
+          aria-label="Toggle replace mode"
+        >
+          {controller.isReplaceMode ? (
+            <ArrowDownIcon className="h-4 w-4 fill-text" />
+          ) : (
+            <ArrowRightIcon className="h-4 w-4 fill-text" />
+          )}
+        </button>
+      )}
+      <div
+        className="flex flex-col gap-2 px-2 py-2"
+        onKeyDown={(event) => {
+          if (event.key === 'Escape') {
+            controller.close()
+          }
+        }}
+      >
+        <div className="flex items-center gap-2">
+          <DecoratedInput
+            placeholder="Search"
+            className={{
+              container: classNames('flex-grow !text-[length:inherit]', !controller.query.length && '!py-1'),
+              right: '!py-1',
+            }}
+            value={controller.query}
+            onChange={controller.setQuery}
+            onKeyDown={handleSearchKeyDown}
+            ref={searchInputRef}
+            right={[
+              <div
+                className="min-w-[7ch] max-w-[7ch] flex-shrink-0 whitespace-nowrap text-right"
+                aria-live="polite"
+                aria-label="Search status"
+              >
+                {statusLabel(controller)}
+              </div>,
+            ]}
+          />
+          <label
+            className={classNames(
+              'relative flex items-center rounded border px-1.5 py-1 focus-within:ring-2 focus-within:ring-info focus-within:ring-offset-2 focus-within:ring-offset-default',
+              controller.isCaseSensitive ? 'border-info bg-info text-info-contrast' : 'border-border hover:bg-contrast',
+            )}
+            title={caseSensitivityShortcut ? `Case sensitive (${caseSensitivityShortcut})` : 'Case sensitive'}
+          >
+            <input
+              type="checkbox"
+              className="absolute left-0 top-0 z-[1] m-0 h-full w-full cursor-pointer border border-transparent p-0 opacity-0 shadow-none outline-none"
+              checked={controller.isCaseSensitive}
+              onChange={controller.toggleCaseSensitivity}
+              aria-label="Case sensitive"
+            />
+            <span aria-hidden>Aa</span>
+          </label>
+          <button
+            className="flex items-center rounded border border-border p-1.5 hover:bg-contrast disabled:cursor-not-allowed"
+            onClick={controller.goToPreviousResult}
+            disabled={!hasResults}
+            title="Previous result (Shift + Enter)"
+            aria-label="Previous result"
+          >
+            <ArrowUpIcon className="h-4 w-4 fill-current text-text" />
+          </button>
+          <button
+            className="flex items-center rounded border border-border p-1.5 hover:bg-contrast disabled:cursor-not-allowed"
+            onClick={controller.goToNextResult}
+            disabled={!hasResults}
+            title="Next result (Enter)"
+            aria-label="Next result"
+          >
+            <ArrowDownIcon className="h-4 w-4 fill-current text-text" />
+          </button>
+          <button
+            className="flex items-center rounded border border-border p-1.5 hover:bg-contrast"
+            onClick={controller.close}
+            title={closeShortcut ? `Close (${closeShortcut})` : 'Close'}
+            aria-label="Close search"
+          >
+            <CloseIcon className="h-4 w-4 fill-current text-text" />
+          </button>
+        </div>
+        {controller.isReplaceMode && canReplace && (
+          <div className="flex flex-wrap items-center gap-2 md:flex-nowrap">
+            <input
+              type="text"
+              placeholder="Replace"
+              value={controller.replaceQuery}
+              onChange={(event) => {
+                controller.setReplaceQuery(event.target.value)
+              }}
+              onKeyDown={handleReplaceKeyDown}
+              className="rounded border border-border bg-default p-1 px-2"
+              ref={replaceInputRef}
+              disabled={!canReplace}
+              aria-label="Replace"
+            />
+            <Button
+              small
+              onClick={() => void controller.replaceCurrentResult()}
+              disabled={!canReplace || !hasResults || !hasReplaceQuery}
+              title="Replace (Enter)"
+            >
+              Replace
+            </Button>
+            <Button
+              small
+              onClick={() => void controller.replaceAllResults()}
+              disabled={!canReplace || !hasResults || !hasReplaceQuery}
+              title="Replace all (Ctrl + Alt + Enter)"
+            >
+              Replace all
+            </Button>
+          </div>
+        )}
+        <div className="flex items-center gap-2">
+          <label className="inline-flex items-center gap-2">
+            <input
+              className="h-4 w-4 rounded accent-info"
+              type="checkbox"
+              checked={controller.shouldHighlightAll}
+              onChange={(event) => controller.setShouldHighlightAll(event.target.checked)}
+              disabled={!canHighlightAll}
+              aria-label="Highlight all results"
+            />
+            <div>Highlight all results</div>
+          </label>
+          {!canHighlightAll && (
+            <StyledTooltip
+              label="This editor does not support search result highlighting yet."
+              className="!z-modal"
+              showOnMobile
+            >
+              <button className="cursor-default" aria-label="Highlight all unavailable">
+                <Icon type="info" size="medium" />
+              </button>
+            </StyledTooltip>
+          )}
+        </div>
+      </div>
+    </div>
+  )
+})
diff --git a/packages/web/src/javascripts/Components/NoteView/UniversalSearch/applyTextReplacements.spec.ts b/packages/web/src/javascripts/Components/NoteView/UniversalSearch/applyTextReplacements.spec.ts
new file mode 100644
index 00000000000..c07cc921f74
--- /dev/null
+++ b/packages/web/src/javascripts/Components/NoteView/UniversalSearch/applyTextReplacements.spec.ts
@@ -0,0 +1,33 @@
+import { applyTextReplacements } from './applyTextReplacements'
+
+describe('applyTextReplacements', () => {
+  it('returns the original text when there are no ranges', () => {
+    expect(applyTextReplacements('hello world', [], 'bye')).toBe('hello world')
+  })
+
+  it('replaces multiple matches in one pass', () => {
+    const result = applyTextReplacements(
+      'hello hello',
+      [
+        { start: 0, end: 5 },
+        { start: 6, end: 11 },
+      ],
+      'bye',
+    )
+
+    expect(result).toBe('bye bye')
+  })
+
+  it('handles replacements with different lengths', () => {
+    const result = applyTextReplacements(
+      'aa aa',
+      [
+        { start: 0, end: 2 },
+        { start: 3, end: 5 },
+      ],
+      'b',
+    )
+
+    expect(result).toBe('b b')
+  })
+})
diff --git a/packages/web/src/javascripts/Components/NoteView/UniversalSearch/applyTextReplacements.ts b/packages/web/src/javascripts/Components/NoteView/UniversalSearch/applyTextReplacements.ts
new file mode 100644
index 00000000000..9873f356877
--- /dev/null
+++ b/packages/web/src/javascripts/Components/NoteView/UniversalSearch/applyTextReplacements.ts
@@ -0,0 +1,16 @@
+import { TextRange } from './types'
+
+export function applyTextReplacements(text: string, ranges: TextRange[], replacement: string): string {
+  if (!ranges.length) {
+    return text
+  }
+
+  const sortedRanges = [...ranges].sort((a, b) => b.start - a.start)
+  let result = text
+
+  for (const { start, end } of sortedRanges) {
+    result = result.slice(0, start) + replacement + result.slice(end)
+  }
+
+  return result
+}
diff --git a/packages/web/src/javascripts/Components/NoteView/UniversalSearch/findStringMatches.spec.ts b/packages/web/src/javascripts/Components/NoteView/UniversalSearch/findStringMatches.spec.ts
new file mode 100644
index 00000000000..81aea17556c
--- /dev/null
+++ b/packages/web/src/javascripts/Components/NoteView/UniversalSearch/findStringMatches.spec.ts
@@ -0,0 +1,23 @@
+import { findStringMatches } from './findStringMatches'
+
+describe('findStringMatches', () => {
+  it('returns non-overlapping matches', () => {
+    expect(findStringMatches('aaaa', 'aa', false)).toEqual([
+      { start: 0, end: 2 },
+      { start: 2, end: 4 },
+    ])
+    expect(findStringMatches('aaa', 'aa', false)).toEqual([{ start: 0, end: 2 }])
+  })
+
+  it('finds multiple matches with optional case sensitivity', () => {
+    expect(findStringMatches('Hello hello', 'hello', true)).toEqual([{ start: 6, end: 11 }])
+    expect(findStringMatches('Hello hello', 'hello', false)).toEqual([
+      { start: 0, end: 5 },
+      { start: 6, end: 11 },
+    ])
+  })
+
+  it('returns an empty array for an empty query', () => {
+    expect(findStringMatches('hello', '', false)).toEqual([])
+  })
+})
diff --git a/packages/web/src/javascripts/Components/NoteView/UniversalSearch/findStringMatches.ts b/packages/web/src/javascripts/Components/NoteView/UniversalSearch/findStringMatches.ts
new file mode 100644
index 00000000000..30f670a0e33
--- /dev/null
+++ b/packages/web/src/javascripts/Components/NoteView/UniversalSearch/findStringMatches.ts
@@ -0,0 +1,24 @@
+import { TextRange } from './types'
+
+export function findStringMatches(text: string, query: string, isCaseSensitive: boolean): TextRange[] {
+  if (!query) {
+    return []
+  }
+
+  const haystack = isCaseSensitive ? text : text.toLowerCase()
+  const needle = isCaseSensitive ? query : query.toLowerCase()
+  const matches: TextRange[] = []
+  let startIndex = 0
+
+  while (startIndex <= haystack.length - needle.length) {
+    const index = haystack.indexOf(needle, startIndex)
+    if (index === -1) {
+      break
+    }
+
+    matches.push({ start: index, end: index + needle.length })
+    startIndex = index + needle.length
+  }
+
+  return matches
+}
diff --git a/packages/web/src/javascripts/Components/NoteView/UniversalSearch/providers/PlainEditorUniversalSearchProvider.spec.ts b/packages/web/src/javascripts/Components/NoteView/UniversalSearch/providers/PlainEditorUniversalSearchProvider.spec.ts
new file mode 100644
index 00000000000..08050f6f2b9
--- /dev/null
+++ b/packages/web/src/javascripts/Components/NoteView/UniversalSearch/providers/PlainEditorUniversalSearchProvider.spec.ts
@@ -0,0 +1,119 @@
+/**
+ * @jest-environment jsdom
+ */
+
+import { PlainEditorInterface } from '../../PlainEditor/PlainEditor'
+import { createPlainEditorUniversalSearchProvider } from './PlainEditorUniversalSearchProvider'
+
+function createMockPlainEditor(text: string): PlainEditorInterface {
+  let currentText = text
+  const textarea = document.createElement('textarea')
+  textarea.value = text
+  textarea.setSelectionRange(0, 0)
+
+  return {
+    focus: jest.fn(),
+    getText: () => currentText,
+    getTextarea: () => textarea,
+    setSelection: jest.fn((start, end, options) => {
+      if (options?.selectInEditor) {
+        textarea.setSelectionRange(start, end)
+      }
+    }),
+    replaceRange: jest.fn(async (start, end, replacement) => {
+      currentText = currentText.slice(0, start) + replacement + currentText.slice(end)
+      textarea.value = currentText
+    }),
+    replaceAllRanges: jest.fn(async (ranges, replacement) => {
+      const sortedRanges = [...ranges].sort((a, b) => b.start - a.start)
+      for (const { start, end } of sortedRanges) {
+        currentText = currentText.slice(0, start) + replacement + currentText.slice(end)
+      }
+      textarea.value = currentText
+    }),
+    onTextChange: () => {
+      return () => {
+        return
+      }
+    },
+  }
+}
+
+describe('PlainEditorUniversalSearchProvider', () => {
+  it('finds matches with optional case sensitivity', async () => {
+    const provider = createPlainEditorUniversalSearchProvider({
+      getEditor: () => createMockPlainEditor('Hello hello'),
+    })
+
+    expect(await provider.search({ query: 'hello', isCaseSensitive: true })).toHaveLength(1)
+    expect(await provider.search({ query: 'hello', isCaseSensitive: false })).toHaveLength(2)
+  })
+
+  it('supports replace and highlight all capabilities', () => {
+    const provider = createPlainEditorUniversalSearchProvider({
+      getEditor: () => createMockPlainEditor('hello'),
+    })
+
+    expect(provider.capabilities.supportsReplace).toBe(true)
+    expect(provider.capabilities.supportsHighlightAll).toBe(true)
+  })
+
+  it('scrolls to a result without selecting it during search navigation', async () => {
+    const editor = createMockPlainEditor('hello world')
+    const provider = createPlainEditorUniversalSearchProvider({
+      getEditor: () => editor,
+    })
+    const [result] = await provider.search({ query: 'world', isCaseSensitive: false })
+
+    provider.selectResult(result, { scrollIntoView: true })
+
+    expect(editor.setSelection).toHaveBeenCalledWith(6, 11, {
+      focus: false,
+      scrollIntoView: true,
+      selectInEditor: false,
+    })
+    expect(editor.getTextarea()?.selectionStart).toBe(0)
+    expect(editor.getTextarea()?.selectionEnd).toBe(0)
+  })
+
+  it('selects a result in the editor when requested', async () => {
+    const editor = createMockPlainEditor('hello world')
+    const provider = createPlainEditorUniversalSearchProvider({
+      getEditor: () => editor,
+    })
+    const [result] = await provider.search({ query: 'world', isCaseSensitive: false })
+
+    provider.selectResult(result, { selectInEditor: true })
+
+    expect(editor.getTextarea()?.selectionStart).toBe(6)
+    expect(editor.getTextarea()?.selectionEnd).toBe(11)
+  })
+
+  it('replaces the current and all results', async () => {
+    const editor = createMockPlainEditor('hello hello')
+    const provider = createPlainEditorUniversalSearchProvider({
+      getEditor: () => editor,
+    })
+    const results = await provider.search({ query: 'hello', isCaseSensitive: false })
+
+    await provider.replaceCurrentResult?.(results[0], {
+      query: 'hello',
+      isCaseSensitive: false,
+      replaceQuery: 'goodbye',
+    })
+
+    expect(editor.getText()).toBe('goodbye hello')
+    expect(editor.replaceRange).toHaveBeenCalledTimes(1)
+
+    const remainingResults = await provider.search({ query: 'hello', isCaseSensitive: false })
+    await provider.replaceAllResults?.(remainingResults, {
+      query: 'hello',
+      isCaseSensitive: false,
+      replaceQuery: 'bye',
+    })
+
+    expect(editor.getText()).toBe('goodbye bye')
+    expect(editor.replaceAllRanges).toHaveBeenCalledTimes(1)
+    expect(editor.replaceRange).toHaveBeenCalledTimes(1)
+  })
+})
diff --git a/packages/web/src/javascripts/Components/NoteView/UniversalSearch/providers/PlainEditorUniversalSearchProvider.ts b/packages/web/src/javascripts/Components/NoteView/UniversalSearch/providers/PlainEditorUniversalSearchProvider.ts
new file mode 100644
index 00000000000..9c26d1b44a6
--- /dev/null
+++ b/packages/web/src/javascripts/Components/NoteView/UniversalSearch/providers/PlainEditorUniversalSearchProvider.ts
@@ -0,0 +1,70 @@
+import { PlainEditorInterface } from '../../PlainEditor/PlainEditor'
+import { findStringMatches } from '../findStringMatches'
+import {
+  TextRange,
+  UniversalSearchProvider,
+  UniversalSearchQuery,
+  UniversalSearchReplaceQuery,
+  UniversalSearchResult,
+} from '../types'
+
+function toSearchResults(matches: TextRange[]): UniversalSearchResult<TextRange>[] {
+  return matches.map((match) => ({
+    id: `plain-${match.start}`,
+    payload: match,
+  }))
+}
+
+type CreatePlainEditorUniversalSearchProviderOptions = {
+  getEditor: () => PlainEditorInterface | undefined
+}
+
+export function createPlainEditorUniversalSearchProvider({
+  getEditor,
+}: CreatePlainEditorUniversalSearchProviderOptions): UniversalSearchProvider<TextRange> {
+  const searchText = (query: UniversalSearchQuery): UniversalSearchResult<TextRange>[] => {
+    const text = getEditor()?.getText() ?? ''
+    return toSearchResults(findStringMatches(text, query.query, query.isCaseSensitive))
+  }
+
+  return {
+    id: 'plain-editor',
+    capabilities: {
+      supportsReplace: true,
+      supportsHighlightAll: true,
+    },
+    search: searchText,
+    selectResult: (result, options) => {
+      const payload = result.payload
+      if (!payload) {
+        return
+      }
+
+      getEditor()?.setSelection(payload.start, payload.end, {
+        focus: false,
+        scrollIntoView: options?.scrollIntoView ?? false,
+        selectInEditor: options?.selectInEditor ?? false,
+      })
+    },
+    clear: () => {
+      return
+    },
+    replaceCurrentResult: async (result, query: UniversalSearchReplaceQuery) => {
+      const payload = result.payload
+      if (!payload) {
+        return searchText(query)
+      }
+
+      await getEditor()?.replaceRange(payload.start, payload.end, query.replaceQuery)
+      return searchText(query)
+    },
+    replaceAllResults: async (results, query: UniversalSearchReplaceQuery) => {
+      const ranges = results
+        .map((result) => result.payload)
+        .filter((payload): payload is TextRange => payload != undefined)
+
+      await getEditor()?.replaceAllRanges(ranges, query.replaceQuery)
+      return searchText(query)
+    },
+  }
+}
diff --git a/packages/web/src/javascripts/Components/NoteView/UniversalSearch/providers/UniversalSearchProvider.spec.ts b/packages/web/src/javascripts/Components/NoteView/UniversalSearch/providers/UniversalSearchProvider.spec.ts
new file mode 100644
index 00000000000..3b3088e4402
--- /dev/null
+++ b/packages/web/src/javascripts/Components/NoteView/UniversalSearch/providers/UniversalSearchProvider.spec.ts
@@ -0,0 +1,53 @@
+/**
+ * @jest-environment jsdom
+ */
+
+import { createMockUniversalSearchProvider } from './createMockUniversalSearchProvider'
+
+describe('UniversalSearchProvider', () => {
+  it('searches documents with a mock provider', async () => {
+    const provider = createMockUniversalSearchProvider({
+      documents: [
+        { id: 'one', text: 'Hello world' },
+        { id: 'two', text: 'hello again' },
+      ],
+    })
+
+    const results = await provider.search({ query: 'hello', isCaseSensitive: false })
+
+    expect(results.map(({ id }) => id)).toEqual(['one-0', 'two-0'])
+  })
+
+  it('honors case sensitivity in the mock provider', async () => {
+    const provider = createMockUniversalSearchProvider({
+      documents: [{ id: 'one', text: 'Hello hello' }],
+    })
+
+    expect(await provider.search({ query: 'hello', isCaseSensitive: true })).toHaveLength(1)
+    expect(await provider.search({ query: 'hello', isCaseSensitive: false })).toHaveLength(2)
+  })
+
+  it('supports current and all replacements in the mock provider', async () => {
+    const provider = createMockUniversalSearchProvider({
+      documents: [{ id: 'one', text: 'hello hello' }],
+    })
+    const [firstResult] = await provider.search({ query: 'hello', isCaseSensitive: false })
+
+    await provider.replaceCurrentResult?.(firstResult, {
+      query: 'hello',
+      isCaseSensitive: false,
+      replaceQuery: 'goodbye',
+    })
+
+    expect(provider.getDocuments()[0].text).toBe('goodbye hello')
+
+    const results = await provider.search({ query: 'hello', isCaseSensitive: false })
+    await provider.replaceAllResults?.(results, {
+      query: 'hello',
+      isCaseSensitive: false,
+      replaceQuery: 'bye',
+    })
+
+    expect(provider.getDocuments()[0].text).toBe('goodbye bye')
+  })
+})
diff --git a/packages/web/src/javascripts/Components/NoteView/UniversalSearch/providers/createMockUniversalSearchProvider.ts b/packages/web/src/javascripts/Components/NoteView/UniversalSearch/providers/createMockUniversalSearchProvider.ts
new file mode 100644
index 00000000000..de36d131438
--- /dev/null
+++ b/packages/web/src/javascripts/Components/NoteView/UniversalSearch/providers/createMockUniversalSearchProvider.ts
@@ -0,0 +1,111 @@
+import { applyTextReplacements } from '../applyTextReplacements'
+import { findStringMatches } from '../findStringMatches'
+import {
+  TextRange,
+  UniversalSearchProvider,
+  UniversalSearchQuery,
+  UniversalSearchReplaceQuery,
+  UniversalSearchResult,
+} from '../types'
+
+export type MockTextMatchPayload = TextRange & {
+  documentId: string
+}
+
+export type MockUniversalSearchDocument = {
+  id: string
+  text: string
+}
+
+type CreateMockUniversalSearchProviderOptions = {
+  documents: MockUniversalSearchDocument[]
+  onSelectResult?: (result: UniversalSearchResult<MockTextMatchPayload>) => void
+}
+
+export function createMockUniversalSearchProvider({
+  documents,
+  onSelectResult,
+}: CreateMockUniversalSearchProviderOptions): UniversalSearchProvider<MockTextMatchPayload> & {
+  getDocuments: () => MockUniversalSearchDocument[]
+} {
+  const docs = documents.map((document) => ({ ...document }))
+
+  const searchDocuments = (query: UniversalSearchQuery): UniversalSearchResult<MockTextMatchPayload>[] => {
+    const results: UniversalSearchResult<MockTextMatchPayload>[] = []
+
+    for (const document of docs) {
+      const matches = findStringMatches(document.text, query.query, query.isCaseSensitive)
+      for (const match of matches) {
+        results.push({
+          id: `${document.id}-${match.start}`,
+          payload: {
+            start: match.start,
+            end: match.end,
+            documentId: document.id,
+          },
+        })
+      }
+    }
+
+    return results
+  }
+
+  const replaceMatch = (documentId: string, start: number, end: number, replaceQuery: string): void => {
+    const document = docs.find((doc) => doc.id === documentId)
+    if (!document) {
+      return
+    }
+
+    document.text = document.text.slice(0, start) + replaceQuery + document.text.slice(end)
+  }
+
+  return {
+    id: 'mock',
+    capabilities: {
+      supportsReplace: true,
+      supportsHighlightAll: false,
+    },
+    search: searchDocuments,
+    selectResult: (result) => {
+      onSelectResult?.(result)
+    },
+    clear: () => {
+      return
+    },
+    replaceCurrentResult: (result, query: UniversalSearchReplaceQuery) => {
+      const payload = result.payload
+      if (!payload) {
+        return searchDocuments(query)
+      }
+
+      replaceMatch(payload.documentId, payload.start, payload.end, query.replaceQuery)
+      return searchDocuments(query)
+    },
+    replaceAllResults: (results, query: UniversalSearchReplaceQuery) => {
+      const matchesByDocument = new Map<string, TextRange[]>()
+
+      for (const result of results) {
+        const payload = result.payload
+        if (!payload) {
+          continue
+        }
+
+        const documentMatches = matchesByDocument.get(payload.documentId) ?? []
+        documentMatches.push({ start: payload.start, end: payload.end })
+        matchesByDocument.set(payload.documentId, documentMatches)
+      }
+
+      for (const [documentId, ranges] of matchesByDocument) {
+        const document = docs.find((doc) => doc.id === documentId)
+        if (!document) {
+          continue
+        }
+
+        document.text = applyTextReplacements(document.text, ranges, query.replaceQuery)
+      }
+
+      return searchDocuments(query)
+    },
+    getDocuments: () => docs,
+  }
+}
diff --git a/packages/web/src/javascripts/Components/NoteView/UniversalSearch/registerUniversalSearchKeyboardHandlers.spec.ts b/packages/web/src/javascripts/Components/NoteView/UniversalSearch/registerUniversalSearchKeyboardHandlers.spec.ts
new file mode 100644
index 00000000000..65b1be16366
--- /dev/null
+++ b/packages/web/src/javascripts/Components/NoteView/UniversalSearch/registerUniversalSearchKeyboardHandlers.spec.ts
@@ -0,0 +1,65 @@
+import { KeyboardService, UNIVERSAL_SEARCH_TOGGLE_REPLACE_MODE } from '@standardnotes/ui-services'
+import { UniversalSearchController } from './UniversalSearchController'
+import { registerUniversalSearchKeyboardHandlers } from './registerUniversalSearchKeyboardHandlers'
+import { createMockUniversalSearchProvider } from './providers/createMockUniversalSearchProvider'
+
+type CapturedKeyboardHandler = {
+  command: unknown
+  onKeyDown?: (event: KeyboardEvent) => void
+}
+
+describe('registerUniversalSearchKeyboardHandlers', () => {
+  function createKeyboardEvent(): KeyboardEvent {
+    return {
+      preventDefault: jest.fn(),
+      stopPropagation: jest.fn(),
+    } as unknown as KeyboardEvent
+  }
+
+  function createCapturingKeyboardService() {
+    const handlers: CapturedKeyboardHandler[] = []
+
+    return {
+      handlers,
+      keyboardService: {
+        addCommandHandlers: (newHandlers: CapturedKeyboardHandler[]) => {
+          handlers.push(...newHandlers)
+          return () => undefined
+        },
+      } as unknown as KeyboardService,
+    }
+  }
+
+  it('opens search in replace mode when the replace shortcut is used while closed', () => {
+    const { keyboardService, handlers } = createCapturingKeyboardService()
+    const controller = new UniversalSearchController(createMockUniversalSearchProvider({ documents: [] }), {
+      searchDebounceMs: 0,
+      contentSearchDebounceMs: 0,
+    })
+
+    registerUniversalSearchKeyboardHandlers(keyboardService, controller)
+
+    const handler = handlers.find((entry) => entry.command === UNIVERSAL_SEARCH_TOGGLE_REPLACE_MODE)
+    handler?.onKeyDown?.(createKeyboardEvent())
+
+    expect(controller.isOpen).toBe(true)
+    expect(controller.isReplaceMode).toBe(true)
+  })
+
+  it('does not open replace mode when replace is unsupported', () => {
+    const { keyboardService, handlers } = createCapturingKeyboardService()
+    const controller = new UniversalSearchController(createMockUniversalSearchProvider({ documents: [] }), {
+      searchDebounceMs: 0,
+      contentSearchDebounceMs: 0,
+    })
+    controller.setLocked(true)
+
+    registerUniversalSearchKeyboardHandlers(keyboardService, controller)
+
+    const handler = handlers.find((entry) => entry.command === UNIVERSAL_SEARCH_TOGGLE_REPLACE_MODE)
+    handler?.onKeyDown?.(createKeyboardEvent())
+
+    expect(controller.isOpen).toBe(false)
+    expect(controller.isReplaceMode).toBe(false)
+  })
+})
diff --git a/packages/web/src/javascripts/Components/NoteView/UniversalSearch/registerUniversalSearchKeyboardHandlers.ts b/packages/web/src/javascripts/Components/NoteView/UniversalSearch/registerUniversalSearchKeyboardHandlers.ts
new file mode 100644
index 00000000000..c3131ef2ced
--- /dev/null
+++ b/packages/web/src/javascripts/Components/NoteView/UniversalSearch/registerUniversalSearchKeyboardHandlers.ts
@@ -0,0 +1,94 @@
+import {
+  KeyboardService,
+  UNIVERSAL_SEARCH_NEXT_RESULT,
+  UNIVERSAL_SEARCH_PREVIOUS_RESULT,
+  UNIVERSAL_SEARCH_TOGGLE_CASE_SENSITIVE,
+  UNIVERSAL_SEARCH_TOGGLE_REPLACE_MODE,
+  UNIVERSAL_TOGGLE_SEARCH,
+} from '@standardnotes/ui-services'
+import { Disposer } from '@/Types/Disposer'
+import { UniversalSearchController } from './UniversalSearchController'
+
+export function registerUniversalSearchKeyboardHandlers<TPayload>(
+  keyboardService: KeyboardService,
+  controller: UniversalSearchController<TPayload>,
+): Disposer {
+  return keyboardService.addCommandHandlers([
+    {
+      command: UNIVERSAL_TOGGLE_SEARCH,
+      category: 'Search',
+      description: 'Search in current note',
+      onKeyDown: (event) => {
+        event.preventDefault()
+        event.stopPropagation()
+
+        if (controller.isOpen) {
+          controller.close()
+        } else {
+          controller.open()
+        }
+      },
+    },
+    {
+      command: UNIVERSAL_SEARCH_TOGGLE_REPLACE_MODE,
+      category: 'Search',
+      description: 'Search and replace in current note',
+      onKeyDown: (event) => {
+        if (!controller.canReplace) {
+          return
+        }
+
+        event.preventDefault()
+        event.stopPropagation()
+
+        if (!controller.isOpen) {
+          controller.open()
+          if (!controller.isReplaceMode) {
+            controller.toggleReplaceMode()
+          }
+          return
+        }
+
+        controller.toggleReplaceMode()
+      },
+    },
+    {
+      command: UNIVERSAL_SEARCH_TOGGLE_CASE_SENSITIVE,
+      onKeyDown: () => {
+        if (!controller.isOpen) {
+          return
+        }
+
+        controller.toggleCaseSensitivity()
+      },
+    },
+    {
+      command: UNIVERSAL_SEARCH_NEXT_RESULT,
+      category: 'Search',
+      description: 'Go to next search result',
+      onKeyDown(event) {
+        if (!controller.isOpen) {
+          return
+        }
+
+        event.preventDefault()
+        event.stopPropagation()
+        controller.goToNextResult()
+      },
+    },
+    {
+      command: UNIVERSAL_SEARCH_PREVIOUS_RESULT,
+      category: 'Search',
+      description: 'Go to previous search result',
+      onKeyDown(event) {
+        if (!controller.isOpen) {
+          return
+        }
+
+        event.preventDefault()
+        event.stopPropagation()
+        controller.goToPreviousResult()
+      },
+    },
+  ])
+}
diff --git a/packages/web/src/javascripts/Components/NoteView/UniversalSearch/types.ts b/packages/web/src/javascripts/Components/NoteView/UniversalSearch/types.ts
new file mode 100644
index 00000000000..65c403c19b8
--- /dev/null
+++ b/packages/web/src/javascripts/Components/NoteView/UniversalSearch/types.ts
@@ -0,0 +1,53 @@
+export type UniversalSearchStatus = 'idle' | 'loading' | 'ready' | 'error'
+
+export type UniversalSearchResultPayload = unknown
+
+export type TextRange = {
+  start: number
+  end: number
+}
+
+export interface UniversalSearchQuery {
+  query: string
+  isCaseSensitive: boolean
+}
+
+export interface UniversalSearchReplaceQuery extends UniversalSearchQuery {
+  replaceQuery: string
+}
+
+export interface UniversalSearchResult<TPayload = UniversalSearchResultPayload> {
+  id: string
+  label?: string
+  context?: string
+  payload?: TPayload
+}
+
+export interface UniversalSearchProviderCapabilities {
+  supportsReplace: boolean
+  supportsHighlightAll: boolean
+}
+
+export interface UniversalSearchSelectResultOptions {
+  scrollIntoView?: boolean
+  selectInEditor?: boolean
+}
+
+export interface UniversalSearchProvider<TPayload = UniversalSearchResultPayload> {
+  id: string
+  capabilities: UniversalSearchProviderCapabilities
+  search(query: UniversalSearchQuery): Promise<UniversalSearchResult<TPayload>[]> | UniversalSearchResult<TPayload>[]
+  selectResult(
+    result: UniversalSearchResult<TPayload>,
+    options?: UniversalSearchSelectResultOptions,
+  ): Promise<void> | void
+  clear(): Promise<void> | void
+  replaceCurrentResult?(
+    result: UniversalSearchResult<TPayload>,
+    query: UniversalSearchReplaceQuery,
+  ): Promise<UniversalSearchResult<TPayload>[]> | UniversalSearchResult<TPayload>[] | Promise<void> | void
+  replaceAllResults?(
+    results: UniversalSearchResult<TPayload>[],
+    query: UniversalSearchReplaceQuery,
+  ): Promise<UniversalSearchResult<TPayload>[]> | UniversalSearchResult<TPayload>[] | Promise<void> | void
+}
diff --git a/packages/web/src/javascripts/Components/NotesOptions/NotesOptions.tsx b/packages/web/src/javascripts/Components/NotesOptions/NotesOptions.tsx
index e82d1fbe594..13fb739eeb3 100644
--- a/packages/web/src/javascripts/Components/NotesOptions/NotesOptions.tsx
+++ b/packages/web/src/javascripts/Components/NotesOptions/NotesOptions.tsx
@@ -1,7 +1,7 @@
 import Icon from '@/Components/Icon/Icon'
 import { observer } from 'mobx-react-lite'
 import { useState, useEffect, useMemo, useCallback } from 'react'
-import { NoteType, Platform } from '@standardnotes/snjs'
+import { isUIFeatureAnIframeFeature, NoteType, Platform } from '@standardnotes/snjs'
 import {
   CHANGE_EDITOR_WIDTH_COMMAND,
   OPEN_NOTE_HISTORY_COMMAND,
@@ -24,6 +24,7 @@ import { SpellcheckOptions } from './SpellcheckOptions'
 import { NoteSizeWarning } from './NoteSizeWarning'
 import { iconClass } from './ClassNames'
 import SuperNoteOptions from './SuperNoteOptions'
+import PlainNoteOptions from './PlainNoteOptions'
 import MenuSwitchButtonItem from '../Menu/MenuSwitchButtonItem'
 import MenuItem from '../Menu/MenuItem'
 import { useApplication } from '../ApplicationProvider'
@@ -374,6 +375,11 @@ const NotesOptions = ({ notes, closeMenu }: NotesOptionsProps) => {
         <>
           {notes[0].noteType === NoteType.Super && <SuperNoteOptions closeMenu={closeMenu} />}
 
+          {notes[0].noteType !== NoteType.Super &&
+            editorForNote &&
+            !isUIFeatureAnIframeFeature(editorForNote) &&
+            application.featuresController.isUniversalSearchEnabled() && <PlainNoteOptions closeMenu={closeMenu} />}
+
           {!areSomeNotesInSharedVault && (
             <MenuSection>
               <ListedActionsOption iconClassName={iconClass} application={application} note={notes[0]} />
diff --git a/packages/web/src/javascripts/Components/NotesOptions/PlainNoteOptions.tsx b/packages/web/src/javascripts/Components/NotesOptions/PlainNoteOptions.tsx
new file mode 100644
index 00000000000..5c52d614c55
--- /dev/null
+++ b/packages/web/src/javascripts/Components/NotesOptions/PlainNoteOptions.tsx
@@ -0,0 +1,38 @@
+import Icon from '../Icon/Icon'
+import { KeyboardShortcutIndicator } from '../KeyboardShortcutIndicator/KeyboardShortcutIndicator'
+import MenuItem from '../Menu/MenuItem'
+import { iconClass } from './ClassNames'
+import MenuSection from '../Menu/MenuSection'
+import { UNIVERSAL_TOGGLE_SEARCH } from '@standardnotes/ui-services'
+import { useMemo, useCallback } from 'react'
+import { useKeyboardService } from '../KeyboardServiceProvider'
+
+type Props = {
+  closeMenu: () => void
+}
+
+const PlainNoteOptions = ({ closeMenu }: Props) => {
+  const keyboardService = useKeyboardService()
+
+  const findShortcut = useMemo(
+    () => keyboardService.keyboardShortcutForCommand(UNIVERSAL_TOGGLE_SEARCH),
+    [keyboardService],
+  )
+
+  const findInNote = useCallback(() => {
+    keyboardService.triggerCommand(UNIVERSAL_TOGGLE_SEARCH)
+    closeMenu()
+  }, [closeMenu, keyboardService])
+
+  return (
+    <MenuSection>
+      <MenuItem onClick={findInNote}>
+        <Icon type="search" className={iconClass} />
+        Find in note
+        {findShortcut && <KeyboardShortcutIndicator className="ml-auto" shortcut={findShortcut} />}
+      </MenuItem>
+    </MenuSection>
+  )
+}
+
+export default PlainNoteOptions
diff --git a/packages/web/src/javascripts/Components/Preferences/Panes/General/Offline/OfflineSubscription.tsx b/packages/web/src/javascripts/Components/Preferences/Panes/General/Offline/OfflineSubscription.tsx
index 741c69eb37f..f53d5fbe3f7 100644
--- a/packages/web/src/javascripts/Components/Preferences/Panes/General/Offline/OfflineSubscription.tsx
+++ b/packages/web/src/javascripts/Components/Preferences/Panes/General/Offline/OfflineSubscription.tsx
@@ -53,7 +53,7 @@ const OfflineSubscription: FunctionComponent<Props> = ({ application, onSuccess
         return
       }
 
-      const parsedOfflineFeaturesCodeResult = application.features.parseOfflineEntitlementsCode(activationCode)
+      const parsedOfflineFeaturesCodeResult = await application.features.parseOfflineEntitlementsCode(activationCode)
       if (parsedOfflineFeaturesCodeResult instanceof ClientDisplayableError) {
         await application.alerts.alert(parsedOfflineFeaturesCodeResult.text)
 
diff --git a/packages/web/src/javascripts/Controllers/FeaturesController.spec.ts b/packages/web/src/javascripts/Controllers/FeaturesController.spec.ts
new file mode 100644
index 00000000000..47708b6a4dd
--- /dev/null
+++ b/packages/web/src/javascripts/Controllers/FeaturesController.spec.ts
@@ -0,0 +1,33 @@
+import { FeaturesClientInterface, FeatureStatus } from '@standardnotes/services'
+import { InternalEventBusInterface } from '@standardnotes/snjs'
+import { FeaturesController } from './FeaturesController'
+
+describe('FeaturesController', () => {
+  describe('isUniversalSearchEnabled', () => {
+    let features: jest.Mocked<Pick<FeaturesClientInterface, 'getFeatureStatus' | 'hasRole'>>
+    let eventBus: jest.Mocked<Pick<InternalEventBusInterface, 'addEventHandler'>>
+    let controller: FeaturesController
+
+    beforeEach(() => {
+      features = {
+        getFeatureStatus: jest.fn().mockReturnValue(FeatureStatus.Entitled),
+        hasRole: jest.fn(),
+      }
+      eventBus = {
+        addEventHandler: jest.fn(),
+      }
+      controller = new FeaturesController(
+        features as unknown as FeaturesClientInterface,
+        eventBus as unknown as InternalEventBusInterface,
+      )
+    })
+
+    afterEach(() => {
+      controller.deinit()
+    })
+
+    it('returns true', () => {
+      expect(controller.isUniversalSearchEnabled()).toBe(true)
+    })
+  })
+})
diff --git a/packages/web/src/javascripts/Controllers/FeaturesController.ts b/packages/web/src/javascripts/Controllers/FeaturesController.ts
index 5878ac25481..2b47c31a1c6 100644
--- a/packages/web/src/javascripts/Controllers/FeaturesController.ts
+++ b/packages/web/src/javascripts/Controllers/FeaturesController.ts
@@ -156,4 +156,8 @@ export class FeaturesController extends AbstractViewController implements Intern
 
     return featureTrunkVaultsEnabled() || isEntitledToFeature
   }
+
+  isUniversalSearchEnabled(): boolean {
+    return true
+  }
 }
diff --git a/packages/web/src/javascripts/Utils/KeyboardShortcutCategoryLabels.ts b/packages/web/src/javascripts/Utils/KeyboardShortcutCategoryLabels.ts
index 2d2fc92b3e7..5b3e8be21f8 100644
--- a/packages/web/src/javascripts/Utils/KeyboardShortcutCategoryLabels.ts
+++ b/packages/web/src/javascripts/Utils/KeyboardShortcutCategoryLabels.ts
@@ -9,6 +9,7 @@ export const KEYBOARD_SHORTCUT_CATEGORY_ORDER: KeyboardShortcutCategory[] = [
   'Super notes',
   'Notes list',
   'General',
+  'Search',
 ]
 
 /** Localized label for a stable keyboard shortcut category id. */
@@ -24,5 +25,7 @@ export function translateKeyboardShortcutCategory(category: KeyboardShortcutCate
       return jtString(c('B2.NavSharedUI.Label').jt`${SuperName} notes`)
     case 'Formatting':
       return c('B2.NavSharedUI.Label').t`Formatting`
+    case 'Search':
+      return c('B2.NavSharedUI.Label').t`Search`
   }
 }
diff --git a/packages/web/src/stylesheets/_editor.scss b/packages/web/src/stylesheets/_editor.scss
index 080fff86f3c..52c4562751f 100644
--- a/packages/web/src/stylesheets/_editor.scss
+++ b/packages/web/src/stylesheets/_editor.scss
@@ -121,6 +121,20 @@ $heading-height: 75px;
   padding: 15px;
   resize: none;
 }
+// Mirror-backdrop search: textarea text must be transparent so highlights show through.
+.editor-content .plain-editor-search-container textarea.editable.plain-editor-with-search-highlights,
+#editor-content .plain-editor-search-container textarea.editable.plain-editor-with-search-highlights {
+  background-color: transparent;
+  color: transparent;
+  -webkit-text-fill-color: transparent;
+  caret-color: var(--editor-pane-editor-foreground-color);
+
+  &::selection {
+    background-color: var(--text-selection-background-color);
+    color: transparent;
+    -webkit-text-fill-color: transparent;
+  }
+}
 
 #editor-pane-component-stack {
   width: 100%;
diff --git a/packages/web/src/stylesheets/_ui.scss b/packages/web/src/stylesheets/_ui.scss
index 1f0130aa09c..40b7dfdb862 100644
--- a/packages/web/src/stylesheets/_ui.scss
+++ b/packages/web/src/stylesheets/_ui.scss
@@ -2,6 +2,46 @@
   font-family: var(--sn-stylekit-editor-font-family);
 }
 
+.plain-editor-search-container {
+  background-color: var(--editor-pane-editor-background-color);
+  flex: 1 1 auto;
+  min-height: 0;
+
+  .plain-editor-search-backdrop-scroll {
+    overflow: hidden;
+  }
+
+  .plain-editor-search-backdrop {
+    width: 100%;
+    box-sizing: border-box;
+    padding: 15px;
+    color: var(--editor-pane-editor-foreground-color);
+    tab-size: 2;
+    min-height: 100%;
+  }
+
+  mark.plain-search-highlight,
+  mark.plain-search-highlight-active {
+    padding: 0;
+    border-radius: 0;
+  }
+
+  .plain-search-highlight {
+    background-color: color-mix(in srgb, var(--sn-stylekit-info-color), transparent 60%);
+    color: var(--text-norm);
+  }
+
+  .plain-search-highlight-active {
+    background-color: var(--sn-stylekit-info-color);
+    color: var(--text-norm);
+  }
+
+  .plain-editor-with-search-highlights {
+    position: relative;
+    z-index: 1;
+  }
+}
+
 .wrap {
   word-wrap: break-word;
   word-break: break-all;
diff --git a/packages/web/tsconfig.json b/packages/web/tsconfig.json
index 6c31b065a43..a6e6e14fd92 100644
--- a/packages/web/tsconfig.json
+++ b/packages/web/tsconfig.json
@@ -1,7 +1,7 @@
 {
   "compilerOptions": {
     "skipLibCheck": true,
-    "lib": ["ES2022"],
+    "lib": ["ES2022", "DOM", "DOM.Iterable"],
     "target": "ES2019",
     "module": "ES2020",
     "moduleResolution": "node",