diff --git a/src/routes/Dashboard/DashboardComponentsV2View.test.tsx b/src/routes/Dashboard/DashboardComponentsV2View.test.tsx
index b9fed3f39..31266c84b 100644
--- a/src/routes/Dashboard/DashboardComponentsV2View.test.tsx
+++ b/src/routes/Dashboard/DashboardComponentsV2View.test.tsx
@@ -12,6 +12,23 @@ interface DashboardComponentsV2Search {
 }
 
 const routeMocks = vi.hoisted(() => {
+  const standardSource = {
+    kind: "standard",
+    label: "Standard",
+    id: "standard",
+  } as const;
+  const registeredSource = {
+    kind: "registered",
+    label: "GitHub library",
+    id: "github-lib",
+  } as const;
+  const publishedSource = {
+    kind: "published",
+    label: "Published",
+    id: "published",
+  } as const;
+  const userSource = { kind: "user", label: "User", id: "user" } as const;
+
   const makeComponent = (digest: string, name: string): ComponentReference => ({
     digest,
     name,
@@ -32,8 +49,40 @@ const routeMocks = vi.hoisted(() => {
   const search: DashboardComponentsV2Search = {};
   const descriptionErrorState: { current: Error | null } = { current: null };
 
+  const toIndexEntry = (
+    reference: ComponentReference,
+    source:
+      | typeof standardSource
+      | typeof registeredSource
+      | typeof publishedSource
+      | typeof userSource,
+  ): IndexEntry => ({
+    reference,
+    digest: reference.digest!,
+    name: reference.name!,
+    source,
+    searchable: {
+      name: reference.name!.toLowerCase(),
+      description: reference.spec?.description?.toLowerCase() ?? "",
+      io: [
+        ...(reference.spec?.inputs ?? []),
+        ...(reference.spec?.outputs ?? []),
+      ]
+        .map((io) => io.name)
+        .join(" ")
+        .toLowerCase(),
+      implementation: "",
+      metadata: "",
+    },
+  });
+
   return {
     standard: makeComponent("standard-digest", "Standard component"),
+    standardSource,
+    registeredSource,
+    publishedSource,
+    userSource,
+    toIndexEntry,
     registered: makeComponent("registered-digest", "Registered component"),
     published: {
       ...makeComponent("published-digest", "Published component"),
@@ -108,14 +157,29 @@ vi.mock("@tanstack/react-query", () => ({
     }
 
     if (key === "component-search-v2" && queryKey[1] === "hydrate-library") {
+      const standardSourced = [
+        routeMocks.standard,
+        ...routeMocks.extraStandardComponents,
+      ].map((reference) => ({
+        reference,
+        source: routeMocks.standardSource,
+      }));
+      const sourcedHydrated = [
+        ...standardSourced,
+        {
+          reference: routeMocks.registered,
+          source: routeMocks.registeredSource,
+        },
+        { reference: routeMocks.published, source: routeMocks.publishedSource },
+        { reference: routeMocks.user, source: routeMocks.userSource },
+      ];
       return {
-        data: [
-          routeMocks.standard,
-          routeMocks.registered,
-          routeMocks.published,
-          routeMocks.user,
-          ...routeMocks.extraStandardComponents,
-        ],
+        data: {
+          sourcedHydrated,
+          index: sourcedHydrated.map((item) =>
+            routeMocks.toIndexEntry(item.reference, item.source),
+          ),
+        },
         isLoading: false,
       };
     }
diff --git a/src/routes/Dashboard/DashboardComponentsV2View.tsx b/src/routes/Dashboard/DashboardComponentsV2View.tsx
index ef7184589..c42903777 100644
--- a/src/routes/Dashboard/DashboardComponentsV2View.tsx
+++ b/src/routes/Dashboard/DashboardComponentsV2View.tsx
@@ -77,10 +77,7 @@ import {
   type RerankedMatch,
 } from "@/services/naturalLanguageComponentSearchService";
 import type { ComponentFolder } from "@/types/componentLibrary";
-import type {
-  ComponentReference,
-  HydratedComponentReference,
-} from "@/utils/componentSpec";
+import type { ComponentReference } from "@/utils/componentSpec";
 import { componentMetadata } from "@/utils/componentTracking";
 import { HOURS, TOP_NAV_HEIGHT } from "@/utils/constants";
 import { getComponentName } from "@/utils/getComponentName";
@@ -201,6 +198,11 @@ export function createRegisteredLibrariesFingerprint(
 type ComponentLibraryFolder = Parameters<typeof flattenFolders>[0];
 type UserFolder = { components?: ComponentReference[] };
 
+interface HydratedComponentSearchData {
+  sourcedHydrated: SourcedReference[];
+  index: IndexEntry[];
+}
+
 interface ComponentCollectionMatch {
   id: string;
   label: string;
@@ -714,10 +716,12 @@ function DebouncedComponentSearchInput({
   onCommit,
   disabled,
   initialValue,
+  onLocalChange,
 }: {
   onCommit: (value: string) => void;
   disabled: boolean;
   initialValue: string;
+  onLocalChange?: (value: string) => void;
 }) {
   const inputRef = useRef<HTMLInputElement>(null);
   const [localValue, setLocalValue] = useDebouncedSearchValue(
@@ -733,7 +737,10 @@ function DebouncedComponentSearchInput({
       type="search"
       placeholder="e.g. train_test_split, pandas, clean up my data"
       value={localValue}
-      onChange={(event) => setLocalValue(event.target.value)}
+      onChange={(event) => {
+        setLocalValue(event.target.value);
+        onLocalChange?.(event.target.value);
+      }}
       aria-label="Search components"
       disabled={disabled}
       className="flex-1"
@@ -796,8 +803,9 @@ export const DashboardComponentsV2View = () => {
   const disabledSourceKeysFromUrl = readDisabledSourceKeys(dashboardSearch);
   const disabledSourceKeysParam = disabledSourceKeysFromUrl.join(",");
   const [query, setQuery] = useState(queryFromUrl);
+  const [isSearching, setIsSearching] = useState(false);
   const deferredQuery = useDeferredValue(query);
-  const [, startSearchTransition] = useTransition();
+  const [isSearchPending, startSearchTransition] = useTransition();
   const [disabledSourceKeys, setDisabledSourceKeys] = useState<string[]>(
     disabledSourceKeysFromUrl,
   );
@@ -984,17 +992,23 @@ export const DashboardComponentsV2View = () => {
   // Fingerprint of which refs are in play. Changes when the library set
   // changes, so the hydration cache invalidates appropriately.
   const referencesFingerprint = allSourced
-    .map((s) => s.reference.digest ?? s.reference.url ?? "")
+    .map(
+      (s) =>
+        `${s.source.kind}:${s.source.id}:${s.source.label}:${s.reference.digest ?? s.reference.url ?? ""}`,
+    )
     .sort()
     .join("|");
 
   // Use `isLoading` (first fetch only), not `isFetching` (any fetch). A
-  // background refetch shouldn't flip the page back to a skeleton state.
-  const { data: hydratedReferences, isLoading: hydrating } = useQuery({
+  // background refetch shouldn't flip the page back to a skeleton state. Build
+  // the pure search index inside the query as well so expensive hydration/index
+  // derivation is cached by the component fingerprint instead of repeated on
+  // every search render.
+  const { data: searchData, isLoading: hydrating } = useQuery({
     queryKey: ["component-search-v2", "hydrate-library", referencesFingerprint],
     enabled: allSourced.length > 0,
     staleTime: HOURS,
-    queryFn: async () => {
+    queryFn: async (): Promise<HydratedComponentSearchData> => {
       const results = await Promise.all(
         allSourced.map((sourced) =>
           // Reuse the same cache key as useHydrateComponentReference so
@@ -1009,30 +1023,29 @@ export const DashboardComponentsV2View = () => {
               staleTime: HOURS,
               queryFn: () => hydrateComponentReference(sourced.reference),
             })
+            .then((reference) => ({ reference, source: sourced.source }))
             .catch(() => null),
         ),
       );
-      return results.filter((r): r is HydratedComponentReference => r !== null);
+
+      const sourcedHydrated: SourcedReference[] = [];
+      for (const item of results) {
+        if (!item?.reference) continue;
+        sourcedHydrated.push({
+          reference: item.reference,
+          source: item.source,
+        });
+      }
+
+      return {
+        sourcedHydrated,
+        index: buildSearchIndex(sourcedHydrated),
+      };
     },
   });
 
-  // Pair hydrated refs back with their source by digest. Hydration preserves
-  // digests, so this is a straightforward join.
-  const sourceByDigest = new Map<string, ComponentSearchSource>();
-  for (const sourced of allSourced) {
-    if (sourced.reference.digest) {
-      sourceByDigest.set(sourced.reference.digest, sourced.source);
-    }
-  }
-  const sourcedHydrated: SourcedReference[] = [];
-  for (const reference of hydratedReferences ?? []) {
-    const source = sourceByDigest.get(reference.digest);
-    if (!source) continue;
-    sourcedHydrated.push({ reference, source });
-  }
-
-  // The search index is a pure derivation. React Compiler will memoize this.
-  const index: IndexEntry[] = buildSearchIndex(sourcedHydrated);
+  const sourcedHydrated = searchData?.sourcedHydrated ?? [];
+  const index = searchData?.index ?? [];
   const sourceFilterOptions = createSourceFilterOptions(index);
   const filteredIndex = filterIndexByDisabledSourceKeys(
     index,
@@ -1040,18 +1053,22 @@ export const DashboardComponentsV2View = () => {
   );
   const total = filteredIndex.length;
   const totalAcrossSources = index.length;
+  const isSearchUiPending = isSearching || isSearchPending;
+  const activeQuery = isSearchUiPending ? "" : deferredQuery;
 
   // Alphabetical order for the browse-all view. Predictable scrolling beats
-  // "whatever order the library happened to load in."
-  const sortedIndex = [...filteredIndex].sort((a, b) =>
-    a.name.localeCompare(b.name),
-  );
+  // "whatever order the library happened to load in." Skip it while search is
+  // pending because the skeleton is showing and sorting the full index can steal
+  // the keystroke that should reveal the skeleton.
+  const sortedIndex = isSearchUiPending
+    ? []
+    : [...filteredIndex].sort((a, b) => a.name.localeCompare(b.name));
 
   useEffect(() => {
     setBrowseResultLimit(BROWSE_RESULT_INITIAL_LIMIT);
   }, [deferredQuery, disabledSourceKeysParam, total]);
 
-  const trimmedQuery = deferredQuery.trim();
+  const trimmedQuery = activeQuery.trim();
 
   // One lexical pass at the wider AI-candidate limit; the display list is the
   // top slice of that same scored result, so we never score and sort the index
@@ -1060,7 +1077,7 @@ export const DashboardComponentsV2View = () => {
   const broadLexicalMatches: LexicalMatch[] =
     trimmedQuery.length === 0
       ? []
-      : lexicalSearch(filteredIndex, deferredQuery, {
+      : lexicalSearch(filteredIndex, activeQuery, {
           limit: AI_CANDIDATE_LIMIT,
         });
 
@@ -1070,12 +1087,8 @@ export const DashboardComponentsV2View = () => {
   );
   const collectionMatches = buildComponentCollectionMatches(
     filteredIndex,
-    deferredQuery,
+    activeQuery,
   );
-  const searchSuggestions = buildComponentSearchSuggestions(filteredIndex, {
-    query: trimmedQuery,
-  });
-
   const aiCandidateMatches: LexicalMatch[] = (() => {
     if (trimmedQuery.length === 0) return [];
     return broadLexicalMatches;
@@ -1110,6 +1123,7 @@ export const DashboardComponentsV2View = () => {
   const handleQueryCommit = (value: string) => {
     startSearchTransition(() => {
       setQuery(value);
+      setIsSearching(false);
       if (rerankedFor !== null) {
         clearRerank();
       }
@@ -1119,12 +1133,17 @@ export const DashboardComponentsV2View = () => {
   const handleSuggestedSearch = (value: string) => {
     startSearchTransition(() => {
       setQuery(value);
+      setIsSearching(false);
       if (rerankedFor !== null) {
         clearRerank();
       }
     });
   };
 
+  const handleLocalQueryChange = (value: string) => {
+    setIsSearching(value.trim() !== query.trim());
+  };
+
   const buildEmbeddingMatches = async (
     trimmed: string,
     limit: number,
@@ -1268,6 +1287,15 @@ export const DashboardComponentsV2View = () => {
         rerankScore: undefined,
       }));
 
+  const searchSuggestions =
+    lexicalMatches.length === 0 &&
+    collectionMatches.length === 0 &&
+    !rerankActive
+      ? buildComponentSearchSuggestions(filteredIndex, {
+          query: trimmedQuery,
+        })
+      : [];
+
   const trackedSearchResultCount =
     displayedResults.length + collectionMatches.length;
 
@@ -1387,7 +1415,7 @@ export const DashboardComponentsV2View = () => {
   // Render helpers — keeps the JSX below tidy. These read the closed-over
   // state from the surrounding component; React Compiler memoises them.
   const renderResults = () => {
-    if (isLoadingLibrary) {
+    if (isLoadingLibrary || isSearchUiPending) {
       return (
         <BlockStack gap="2">
           <Skeleton className="h-20 w-full" />
@@ -1572,6 +1600,7 @@ export const DashboardComponentsV2View = () => {
               onCommit={handleQueryCommit}
               disabled={isLoadingLibrary || noLibraryData}
               initialValue={query}
+              onLocalChange={handleLocalQueryChange}
             />
             <Button
               variant="secondary"
diff --git a/src/routes/v2/pages/Editor/components/ComponentSearchV2Content.tsx b/src/routes/v2/pages/Editor/components/ComponentSearchV2Content.tsx
index a6e7725a5..7c74261cc 100644
--- a/src/routes/v2/pages/Editor/components/ComponentSearchV2Content.tsx
+++ b/src/routes/v2/pages/Editor/components/ComponentSearchV2Content.tsx
@@ -84,9 +84,9 @@ function DebouncedComponentSearchInput({
 export function ComponentSearchV2Content() {
   const { track } = useAnalytics();
   const [query, setQuery] = useState("");
-  const [localQuery, setLocalQuery] = useState("");
+  const [isSearching, setIsSearching] = useState(false);
   const deferredQuery = useDeferredValue(query);
-  const [, startSearchTransition] = useTransition();
+  const [isSearchPending, startSearchTransition] = useTransition();
   const {
     results,
     browseFolders,
@@ -101,22 +101,34 @@ export function ComponentSearchV2Content() {
     disabledSourceKeys,
     toggleSourceFilter,
     enableAllSources,
-  } = useComponentSearchV2State(deferredQuery);
+  } = useComponentSearchV2State(deferredQuery, {
+    pauseSearch: isSearching,
+  });
 
   const handleQueryCommit = (value: string) => {
-    startSearchTransition(() => setQuery(value));
+    startSearchTransition(() => {
+      setQuery(value);
+      setIsSearching(false);
+    });
   };
 
   const handleSuggestedSearch = (value: string) => {
-    setLocalQuery(value);
-    startSearchTransition(() => setQuery(value));
+    startSearchTransition(() => {
+      setQuery(value);
+      setIsSearching(false);
+    });
+  };
+
+  const handleLocalQueryChange = (value: string) => {
+    setIsSearching(value.trim() !== query.trim());
   };
 
   const trimmedDeferredQuery = deferredQuery.trim();
-  const isSearching = localQuery.trim() !== trimmedDeferredQuery;
+  const isSearchUiPending = isSearching || isSearchPending;
 
   useEffect(() => {
-    if (isLoading || trimmedDeferredQuery.length === 0) return;
+    if (isLoading || isSearchUiPending || trimmedDeferredQuery.length === 0)
+      return;
 
     const timeout = window.setTimeout(() => {
       track("component_library.search.completed", {
@@ -131,7 +143,14 @@ export function ComponentSearchV2Content() {
     }, 400);
 
     return () => window.clearTimeout(timeout);
-  }, [isLoading, isRerankActive, results.length, track, trimmedDeferredQuery]);
+  }, [
+    isLoading,
+    isSearchUiPending,
+    isRerankActive,
+    results.length,
+    track,
+    trimmedDeferredQuery,
+  ]);
 
   return (
     <BlockStack className="h-full min-h-0 overflow-hidden [&_.text-sm]:text-xs!">
@@ -166,7 +185,7 @@ export function ComponentSearchV2Content() {
             <DebouncedComponentSearchInput
               initialValue={query}
               onCommit={handleQueryCommit}
-              onLocalChange={setLocalQuery}
+              onLocalChange={handleLocalQueryChange}
             />
           </div>
           <Button
@@ -202,7 +221,7 @@ export function ComponentSearchV2Content() {
         browseFolders={browseFolders}
         searchSuggestions={searchSuggestions}
         isLoading={isLoading}
-        isSearching={isSearching}
+        isSearching={isSearchUiPending}
         isRerankActive={isRerankActive}
         onClearRerank={clearRerank}
         onSuggestedSearch={handleSuggestedSearch}
diff --git a/src/routes/v2/pages/Editor/hooks/useComponentSearchV2State.ts b/src/routes/v2/pages/Editor/hooks/useComponentSearchV2State.ts
index c18aec362..b2f00f063 100644
--- a/src/routes/v2/pages/Editor/hooks/useComponentSearchV2State.ts
+++ b/src/routes/v2/pages/Editor/hooks/useComponentSearchV2State.ts
@@ -27,7 +27,6 @@ import {
   buildRerankMatchByDigest,
   buildResultFolders,
   buildResults,
-  buildSourcedHydratedReferences,
   collectAllSourcedReferences,
   type ComponentSearchV2State,
   LEXICAL_RESULT_LIMIT,
@@ -49,10 +48,7 @@ import {
 } from "@/services/componentService";
 import { componentReferenceToCandidate } from "@/services/naturalLanguageComponentSearchService";
 import type { ComponentFolder } from "@/types/componentLibrary";
-import type {
-  ComponentReference,
-  HydratedComponentReference,
-} from "@/utils/componentSpec";
+import type { ComponentReference } from "@/utils/componentSpec";
 import { HOURS } from "@/utils/constants";
 
 function mergeUniqueMatches(
@@ -74,6 +70,7 @@ function mergeUniqueMatches(
 
 export function useComponentSearchV2State(
   query: string,
+  { pauseSearch = false }: { pauseSearch?: boolean } = {},
 ): ComponentSearchV2State {
   const queryClient = useQueryClient();
   const { backendUrl, configured, available } = useBackend();
@@ -160,15 +157,18 @@ export function useComponentSearchV2State(
   });
 
   const referencesFingerprint = sourcedReferences
-    .map((item) => item.reference.digest ?? item.reference.url ?? "")
+    .map(
+      (item) =>
+        `${item.source.kind}:${item.source.id}:${item.source.label}:${item.reference.digest ?? item.reference.url ?? ""}`,
+    )
     .sort()
     .join("|");
 
-  const { data: hydratedReferences = [], isLoading: isHydrating } = useQuery({
-    queryKey: ["component-search-v2", "hydrate-library", referencesFingerprint],
+  const { data: index = [], isLoading: isHydrating } = useQuery({
+    queryKey: ["component-search-v2", "search-index", referencesFingerprint],
     enabled: sourcedReferences.length > 0,
     staleTime: HOURS,
-    queryFn: async (): Promise<HydratedComponentReference[]> => {
+    queryFn: async (): Promise<IndexEntry[]> => {
       const results = await Promise.all(
         sourcedReferences.map((item) =>
           queryClient
@@ -181,24 +181,24 @@ export function useComponentSearchV2State(
               staleTime: HOURS,
               queryFn: () => hydrateComponentReference(item.reference),
             })
+            .then((reference) => ({ reference, source: item.source }))
             .catch(() => null),
         ),
       );
 
-      return results.filter(
-        (reference): reference is HydratedComponentReference =>
-          reference !== null,
-      );
+      const hydratedSourced: SourcedReference[] = [];
+      for (const item of results) {
+        if (!item?.reference) continue;
+        hydratedSourced.push({
+          reference: item.reference,
+          source: item.source,
+        });
+      }
+
+      return buildSearchIndex(hydratedSourced);
     },
   });
 
-  const index = buildSearchIndex(
-    buildSourcedHydratedReferences({
-      sourcedReferences,
-      hydratedReferences,
-    }),
-  );
-
   const [disabledSourceKeys, setDisabledSourceKeys] = useState<string[]>([]);
   const sourceFilterOptions = createSourceFilterOptions(index);
   const filteredIndex = filterIndexByDisabledSourceKeys(
@@ -208,11 +208,10 @@ export function useComponentSearchV2State(
 
   const canUseEmbeddingSearch = aiConfig.apiBase.trim().length > 0;
   const trimmedQuery = query.trim();
-  const lexicalMatches = buildLexicalMatches(filteredIndex, trimmedQuery);
-  const aiCandidateMatches = buildAiCandidateMatches(
-    filteredIndex,
-    trimmedQuery,
-  );
+  const searchableQuery = pauseSearch ? "" : trimmedQuery;
+  const lexicalMatches = pauseSearch
+    ? []
+    : buildLexicalMatches(filteredIndex, searchableQuery);
   const {
     mutate,
     reset: resetRerank,
@@ -246,7 +245,7 @@ export function useComponentSearchV2State(
   }, []);
 
   const isRerankActive =
-    rerankedFor === trimmedQuery &&
+    rerankedFor === searchableQuery &&
     rerankBaseMatches.length > 0 &&
     !isReranking &&
     !isEmbeddingSearchPending &&
@@ -273,7 +272,7 @@ export function useComponentSearchV2State(
     try {
       return await rankComponentMatchesByEmbeddings(
         sourceIndex,
-        trimmedQuery,
+        searchableQuery,
         {
           apiBase: aiConfig.apiBase,
           apiKey: aiConfig.apiKey,
@@ -303,7 +302,7 @@ export function useComponentSearchV2State(
       limit: number;
     },
   ) => {
-    if (!trimmedQuery || !isConfigured) return;
+    if (!searchableQuery || !isConfigured) return;
 
     const canUseEmbeddings = useEmbeddings && canUseEmbeddingSearch;
     if (matches.length === 0 && !canUseEmbeddings) return;
@@ -337,11 +336,15 @@ export function useComponentSearchV2State(
 
     resetRerank();
     setRerankBaseMatches(rerankMatches);
-    setRerankedFor(trimmedQuery);
-    mutate({ query: trimmedQuery, candidates, scoreAllCandidates });
+    setRerankedFor(searchableQuery);
+    mutate({ query: searchableQuery, candidates, scoreAllCandidates });
   };
 
   const rerank = () => {
+    const aiCandidateMatches = buildAiCandidateMatches(
+      filteredIndex,
+      searchableQuery,
+    );
     void startRerank(aiCandidateMatches, {
       scoreAllCandidates: true,
       useEmbeddings: true,
@@ -371,16 +374,21 @@ export function useComponentSearchV2State(
 
   return {
     results,
-    browseFolders: buildResultFolders({
-      results,
-      standardLibrary: disabledSourceKeys.includes("standard")
-        ? undefined
-        : standardLibrary,
-    }),
-    searchSuggestions: buildComponentSearchSuggestions(filteredIndex, {
-      includeSources: false,
-      query: trimmedQuery,
-    }),
+    browseFolders: pauseSearch
+      ? []
+      : buildResultFolders({
+          results,
+          standardLibrary: disabledSourceKeys.includes("standard")
+            ? undefined
+            : standardLibrary,
+        }),
+    searchSuggestions:
+      !pauseSearch && results.length === 0
+        ? buildComponentSearchSuggestions(filteredIndex, {
+            includeSources: false,
+            query: searchableQuery,
+          })
+        : [],
     sourceFilterOptions,
     disabledSourceKeys,
     isLoading:
@@ -391,8 +399,9 @@ export function useComponentSearchV2State(
       isLoadingRegistered ||
       isHydrating,
     canRerank:
-      trimmedQuery.length > 0 &&
-      (aiCandidateMatches.length > 0 || canUseEmbeddingSearch) &&
+      !pauseSearch &&
+      searchableQuery.length > 0 &&
+      (lexicalMatches.length > 0 || canUseEmbeddingSearch) &&
       isConfigured,
     isReranking: isReranking || isEmbeddingSearchPending,
     isRerankActive,
diff --git a/src/services/componentSearchIndex.ts b/src/services/componentSearchIndex.ts
index 1a5512465..e7af11218 100644
--- a/src/services/componentSearchIndex.ts
+++ b/src/services/componentSearchIndex.ts
@@ -58,6 +58,10 @@ export interface IndexEntry {
   source: ComponentSearchSource;
   /** Normalized searchable text, one per logical field. */
   searchable: Record<MatchField, string>;
+  /** Pre-split searchable text, built once with the index to avoid per-keystroke tokenization. */
+  searchableTokens?: Record<MatchField, string[]>;
+  /** Phrase-normalized searchable text, built once with the index to avoid per-keystroke regex work. */
+  searchablePhrases?: Record<MatchField, string>;
 }
 
 export interface LexicalMatch {
@@ -319,23 +323,25 @@ export function buildSearchIndex(sourced: SourcedReference[]): IndexEntry[] {
     const metadata = extractComponentMetadata(reference);
     if (!metadata) continue;
 
+    const searchable: Record<MatchField, string> = {
+      name: normalizeSearchText(metadata.name),
+      description: normalizeSearchText(metadata.description),
+      io: normalizeSearchText(metadata.ioText),
+      implementation: normalizeSearchText(extractImplementationText(reference)),
+      metadata: normalizeSearchText(metadata.metadataText).slice(
+        0,
+        MAX_ANNOTATION_TOTAL_TEXT_LENGTH,
+      ),
+    };
+
     entries.push({
       reference,
       digest: metadata.digest,
       name: metadata.name,
       source,
-      searchable: {
-        name: normalizeSearchText(metadata.name),
-        description: normalizeSearchText(metadata.description),
-        io: normalizeSearchText(metadata.ioText),
-        implementation: normalizeSearchText(
-          extractImplementationText(reference),
-        ),
-        metadata: normalizeSearchText(metadata.metadataText).slice(
-          0,
-          MAX_ANNOTATION_TOTAL_TEXT_LENGTH,
-        ),
-      },
+      searchable,
+      searchableTokens: buildSearchableTokenCache(searchable),
+      searchablePhrases: buildSearchablePhraseCache(searchable),
     });
   }
 
@@ -521,6 +527,42 @@ function searchableTokens(text: string): string[] {
   return text.split(/[^a-z0-9]+/).filter(isNonEmptyString);
 }
 
+function normalizePhraseSearchText(text: string): string {
+  return text.replace(/[^a-z0-9]+/g, " ");
+}
+
+function buildSearchableTokenCache(
+  searchable: Record<MatchField, string>,
+): Record<MatchField, string[]> {
+  return Object.fromEntries(
+    SEARCH_FIELDS.map((field) => [field, searchableTokens(searchable[field])]),
+  ) as Record<MatchField, string[]>;
+}
+
+function buildSearchablePhraseCache(
+  searchable: Record<MatchField, string>,
+): Record<MatchField, string> {
+  return Object.fromEntries(
+    SEARCH_FIELDS.map((field) => [
+      field,
+      normalizePhraseSearchText(searchable[field]),
+    ]),
+  ) as Record<MatchField, string>;
+}
+
+function fieldTokensFor(entry: IndexEntry, field: MatchField): string[] {
+  return (
+    entry.searchableTokens?.[field] ?? searchableTokens(entry.searchable[field])
+  );
+}
+
+function phraseTextFor(entry: IndexEntry, field: MatchField): string {
+  return (
+    entry.searchablePhrases?.[field] ??
+    normalizePhraseSearchText(entry.searchable[field])
+  );
+}
+
 function maxTypoDistance(field: MatchField, token: string): number {
   // Require length >= 5 before allowing any edits: 4-char tokens are too short
   // for distance-1 fuzziness without false positives on generic IO names
@@ -632,25 +674,13 @@ function scoreEntry(
   const matched = new Set<MatchField>();
   let score = 0;
 
-  // A field's tokenization depends only on the field, not the query token, so
-  // split it once per entry (cached) rather than re-splitting inside the
-  // per-query-token loop — that re-split is hot on every keystroke.
-  const fieldTokenCache = new Map<MatchField, string[]>();
-  const fieldTokensFor = (field: MatchField): string[] => {
-    const cached = fieldTokenCache.get(field);
-    if (cached) return cached;
-    const fieldTokens = searchableTokens(entry.searchable[field]);
-    fieldTokenCache.set(field, fieldTokens);
-    return fieldTokens;
-  };
-
   // Hard exclusion uses a whole-token match (not substring): a zero-score
   // filter removes the entire component, so a short negated token must not
   // knock one out by incidentally appearing inside an unrelated word.
   if (
     negativeTokens.some((token) =>
       NEGATIVE_SEARCH_FIELDS.some((field) =>
-        fieldTokensFor(field).includes(token),
+        fieldTokensFor(entry, field).includes(token),
       ),
     )
   ) {
@@ -673,7 +703,7 @@ function scoreEntry(
         matched.add(field);
 
         const hasPrefixMatch = matchingTokens.some((token) =>
-          fieldTokensFor(field).some((fieldToken) =>
+          fieldTokensFor(entry, field).some((fieldToken) =>
             fieldToken.startsWith(token),
           ),
         );
@@ -688,7 +718,7 @@ function scoreEntry(
       const literalToken = concept[0];
       const fuzzyTokens = hasFuzzyTokenMatch(
         field,
-        fieldTokensFor(field),
+        fieldTokensFor(entry, field),
         literalToken,
       )
         ? [literalToken]
@@ -705,10 +735,7 @@ function scoreEntry(
 
   if (phraseTokenSequences.length > 0) {
     for (const field of SEARCH_FIELDS) {
-      const normalizedField = entry.searchable[field].replace(
-        /[^a-z0-9]+/g,
-        " ",
-      );
+      const normalizedField = phraseTextFor(entry, field);
       if (
         !phraseTokenSequences.some((sequence) =>
           normalizedField.includes(sequence.join(" ")),