diff --git a/bun.lock b/bun.lock
index 1f286be4..dbddb68c 100644
--- a/bun.lock
+++ b/bun.lock
@@ -1,5 +1,6 @@
 {
   "lockfileVersion": 1,
+  "configVersion": 0,
   "workspaces": {
     "": {
       "name": "@tscircuit/schematic-viewer",
@@ -8,6 +9,7 @@
         "circuit-json": "^0.0.454",
         "circuit-to-svg": "^0.0.393",
         "debug": "^4.4.0",
+        "lucide-react": "^1.21.0",
         "performance-now": "^2.1.0",
         "use-mouse-matrix-transform": "^1.2.2",
       },
diff --git a/examples/example32-schematic-search.fixture.tsx b/examples/example32-schematic-search.fixture.tsx
new file mode 100644
index 00000000..c57ad81e
--- /dev/null
+++ b/examples/example32-schematic-search.fixture.tsx
@@ -0,0 +1,64 @@
+import type { SubcircuitProps } from "@tscircuit/props"
+import { SchematicViewer } from "lib/components/SchematicViewer"
+import { renderToCircuitJson } from "lib/dev/render-to-circuit-json"
+
+const SensorSheet = (props: SubcircuitProps) => (
+  <subcircuit {...props}>
+    <chip
+      name="U_SENSOR"
+      footprint="soic4"
+      manufacturerPartNumber="SHT40"
+      pinLabels={{ pin1: "VCC", pin2: "SDA", pin3: "SCL", pin4: "GND" }}
+      connections={{
+        VCC: "net.VCC",
+        SDA: "net.I2C_SDA",
+        SCL: "net.I2C_SCL",
+        GND: "net.GND",
+      }}
+    />
+    <capacitor
+      name="C_SENSOR"
+      capacitance="100nF"
+      footprint="0402"
+      connections={{ pin1: "net.VCC", pin2: "net.GND" }}
+    />
+  </subcircuit>
+)
+
+const PowerSheet = (props: SubcircuitProps) => (
+  <subcircuit {...props}>
+    <chip
+      name="U_REG"
+      footprint="sot23"
+      manufacturerPartNumber="AP2112K"
+      pinLabels={{ pin1: "VIN", pin2: "GND", pin3: "VOUT" }}
+      connections={{
+        VIN: "net.VBUS",
+        GND: "net.GND",
+        VOUT: "net.VCC",
+      }}
+    />
+    <capacitor
+      name="C_OUT"
+      capacitance="1uF"
+      footprint="0402"
+      connections={{ pin1: "net.VCC", pin2: "net.GND" }}
+    />
+  </subcircuit>
+)
+
+const circuitJson = renderToCircuitJson(
+  <board routingDisabled>
+    <schematicsheet name="Sensors" displayName="Sensors" sheetIndex={0} />
+    <schematicsheet name="Power" displayName="Power" sheetIndex={1} />
+    <SensorSheet name="SENSORS" schSheetName="Sensors" />
+    <PowerSheet name="POWER" schSheetName="Power" />
+  </board>,
+)
+
+export default () => (
+  <SchematicViewer
+    circuitJson={circuitJson}
+    containerStyle={{ width: "100vw", height: "100vh" }}
+  />
+)
diff --git a/examples/example33-single-sheet-schematic-search.fixture.tsx b/examples/example33-single-sheet-schematic-search.fixture.tsx
new file mode 100644
index 00000000..e35492cd
--- /dev/null
+++ b/examples/example33-single-sheet-schematic-search.fixture.tsx
@@ -0,0 +1,32 @@
+import { SchematicViewer } from "lib/components/SchematicViewer"
+import { renderToCircuitJson } from "lib/dev/render-to-circuit-json"
+
+const circuitJson = renderToCircuitJson(
+  <board routingDisabled>
+    <chip
+      name="U_SENSOR"
+      footprint="soic4"
+      manufacturerPartNumber="SHT40"
+      pinLabels={{ pin1: "VCC", pin2: "SDA", pin3: "SCL", pin4: "GND" }}
+      connections={{
+        VCC: "net.VCC",
+        SDA: "net.I2C_SDA",
+        SCL: "net.I2C_SCL",
+        GND: "net.GND",
+      }}
+    />
+    <capacitor
+      name="C_SENSOR"
+      capacitance="100nF"
+      footprint="0402"
+      connections={{ pin1: "net.VCC", pin2: "net.GND" }}
+    />
+  </board>,
+)
+
+export default () => (
+  <SchematicViewer
+    circuitJson={circuitJson}
+    containerStyle={{ width: "100vw", height: "100vh" }}
+  />
+)
diff --git a/lib/components/SchematicSearch.tsx b/lib/components/SchematicSearch.tsx
new file mode 100644
index 00000000..769b2345
--- /dev/null
+++ b/lib/components/SchematicSearch.tsx
@@ -0,0 +1,531 @@
+import { CornerDownLeft, Cpu, GitBranch, Search, X } from "lucide-react"
+import { useEffect, useRef, useState, type RefObject } from "react"
+import type { SchematicSearchResult } from "../utils/get-schematic-search-results"
+import { zIndexMap } from "../utils/z-index-map"
+
+const HighlightedSearchText = ({
+  text,
+  query,
+}: {
+  text: string
+  query: string
+}) => {
+  const normalizedQuery = query.trim().toLocaleLowerCase()
+  if (!normalizedQuery) return text
+
+  const normalizedText = text.toLocaleLowerCase()
+  const parts: React.ReactNode[] = []
+  let cursor = 0
+  let matchIndex = normalizedText.indexOf(normalizedQuery)
+
+  while (matchIndex !== -1) {
+    if (matchIndex > cursor) {
+      parts.push(text.slice(cursor, matchIndex))
+    }
+    parts.push(
+      <strong key={`${matchIndex}-${cursor}`} style={{ fontWeight: 700 }}>
+        {text.slice(matchIndex, matchIndex + normalizedQuery.length)}
+      </strong>,
+    )
+    cursor = matchIndex + normalizedQuery.length
+    matchIndex = normalizedText.indexOf(normalizedQuery, cursor)
+  }
+
+  if (cursor < text.length) parts.push(text.slice(cursor))
+  if (parts.length > 0) return parts
+  return text
+}
+
+const getShortcutLabel = () => {
+  if (typeof navigator === "undefined") return "Ctrl F"
+  if (/mac/i.test(navigator.platform)) return "⌘ F"
+  return "Ctrl F"
+}
+
+export const SchematicSearch = ({
+  query,
+  onQueryChange,
+  onCancel,
+  results,
+  onSelect,
+  viewerContainerRef,
+}: {
+  query: string
+  onQueryChange: (query: string) => void
+  onCancel: () => void
+  results: SchematicSearchResult[]
+  onSelect: (result: SchematicSearchResult) => void
+  viewerContainerRef: RefObject<HTMLElement | null>
+}) => {
+  const [isOpen, setIsOpen] = useState(false)
+  const [activeResultId, setActiveResultId] = useState<string | null>(null)
+  const [hoveredResultId, setHoveredResultId] = useState<string | null>(null)
+  const inputRef = useRef<HTMLInputElement>(null)
+  const resultsListRef = useRef<HTMLDivElement>(null)
+  const shortcutLabel = getShortcutLabel()
+
+  useEffect(() => {
+    setActiveResultId((currentId) => {
+      if (results.some((result) => result.target.id === currentId)) {
+        return currentId
+      }
+      return (
+        results.find((result) => result.kind === "component")?.target.id ??
+        results[0]?.target.id ??
+        null
+      )
+    })
+  }, [results])
+
+  useEffect(() => {
+    if (!activeResultId) return
+    resultsListRef.current
+      ?.querySelector(`[data-search-result-id="${activeResultId}"]`)
+      ?.scrollIntoView({ behavior: "smooth", block: "nearest" })
+  }, [activeResultId])
+
+  useEffect(() => {
+    const handleSearchShortcut = (event: KeyboardEvent) => {
+      if (event.key === "Escape" && isOpen) {
+        event.preventDefault()
+        event.stopPropagation()
+        event.stopImmediatePropagation()
+        onCancel()
+        setIsOpen(false)
+        inputRef.current?.blur()
+        return
+      }
+      if (event.code !== "KeyF" && event.key.toLocaleLowerCase() !== "f") {
+        return
+      }
+      if (!event.metaKey && !event.ctrlKey) {
+        return
+      }
+      if (!viewerContainerRef.current?.matches(":hover")) return
+
+      event.preventDefault()
+      event.stopPropagation()
+      event.stopImmediatePropagation()
+      setIsOpen(true)
+      requestAnimationFrame(() => {
+        inputRef.current?.focus()
+        inputRef.current?.select()
+      })
+    }
+
+    const shortcutWindows: Window[] = [window]
+    try {
+      if (window.parent !== window && window.parent.document) {
+        shortcutWindows.push(window.parent)
+      }
+    } catch {
+      // Cross-origin parents cannot be accessed; the local listener still works.
+    }
+
+    shortcutWindows.forEach((targetWindow) =>
+      targetWindow.addEventListener("keydown", handleSearchShortcut, {
+        capture: true,
+      }),
+    )
+    return () => {
+      shortcutWindows.forEach((targetWindow) =>
+        targetWindow.removeEventListener("keydown", handleSearchShortcut, {
+          capture: true,
+        }),
+      )
+    }
+  }, [isOpen, onCancel, viewerContainerRef])
+
+  const cancelSearch = () => {
+    onCancel()
+    setIsOpen(false)
+    inputRef.current?.blur()
+  }
+
+  const openSearch = (focusInput: boolean) => {
+    setIsOpen(true)
+    if (focusInput) {
+      requestAnimationFrame(() => inputRef.current?.focus())
+    }
+  }
+
+  const componentResults = results.filter(
+    (result) => result.kind === "component",
+  )
+  const netResults = results.filter((result) => result.kind === "net")
+  const orderedResults = [...componentResults, ...netResults]
+  const activeResult =
+    orderedResults.find((result) => result.target.id === activeResultId) ??
+    orderedResults[0]
+  const resultCountLabel =
+    results.length === 1 ? "1 result" : `${results.length} results`
+  let searchHeaderBorder = "none"
+  if (query) searchHeaderBorder = "1px solid #e8e8e8"
+
+  const handleSearchKeyDown = (event: React.KeyboardEvent) => {
+    if (
+      event.key === "Enter" &&
+      event.target instanceof Element &&
+      event.target.closest('[aria-label="Clear search"]')
+    ) {
+      return
+    }
+    if (event.key === "Escape") {
+      event.preventDefault()
+      cancelSearch()
+      return
+    }
+    if (
+      orderedResults.length > 0 &&
+      (event.key === "ArrowDown" || event.key === "ArrowUp")
+    ) {
+      event.preventDefault()
+      let direction = -1
+      if (event.key === "ArrowDown") direction = 1
+      setActiveResultId((currentId) => {
+        const currentIndex = orderedResults.findIndex(
+          (result) => result.target.id === currentId,
+        )
+        let startIndex = currentIndex
+        if (currentIndex === -1) {
+          startIndex = 0
+          if (direction === 1) startIndex = -1
+        }
+        const nextIndex =
+          (startIndex + direction + orderedResults.length) %
+          orderedResults.length
+        return orderedResults[nextIndex]?.target.id ?? null
+      })
+      return
+    }
+    if (event.key === "Enter" && activeResult) {
+      event.preventDefault()
+      onSelect(activeResult)
+    }
+  }
+
+  const renderResultSection = (
+    title: string,
+    sectionResults: SchematicSearchResult[],
+  ) => {
+    if (sectionResults.length === 0) return null
+    return (
+      <section>
+        <div
+          style={{
+            padding: "6px 12px 3px",
+            backgroundColor: "#f7f7f8",
+            color: "#777777",
+            fontSize: "11px",
+            fontWeight: 600,
+            letterSpacing: "0.02em",
+            textTransform: "lowercase",
+          }}
+        >
+          {title}
+        </div>
+        {sectionResults.map((result) => {
+          const active = result.target.id === activeResult?.target.id
+          const hovering = result.target.id === hoveredResultId
+          let resultBackground = "#ffffff"
+          if (hovering || active) resultBackground = "#f1f3f5"
+
+          let resultIcon = (
+            <GitBranch size={15} strokeWidth={1.8} aria-hidden="true" />
+          )
+          if (result.kind === "component") {
+            resultIcon = <Cpu size={15} strokeWidth={1.8} aria-hidden="true" />
+          }
+          const selectResult = () => {
+            inputRef.current?.blur()
+            setActiveResultId(result.target.id)
+            onSelect(result)
+          }
+          return (
+            <button
+              type="button"
+              key={result.target.id}
+              data-search-result-id={result.target.id}
+              onPointerUp={(event) => {
+                if (event.button === 0) selectResult()
+              }}
+              onClick={(event) => {
+                if (event.detail === 0) selectResult()
+              }}
+              onMouseEnter={() => setHoveredResultId(result.target.id)}
+              onMouseLeave={() => setHoveredResultId(null)}
+              style={{
+                width: "100%",
+                display: "flex",
+                alignItems: "center",
+                gap: "9px",
+                padding: "7px 12px",
+                border: "none",
+                background: resultBackground,
+                color: "#222222",
+                cursor: "pointer",
+                textAlign: "left",
+              }}
+            >
+              <span
+                style={{
+                  width: "26px",
+                  height: "26px",
+                  flexShrink: 0,
+                  display: "grid",
+                  placeItems: "center",
+                  border: "1px solid #e5e5e5",
+                  borderRadius: "6px",
+                  backgroundColor: "#f7f7f7",
+                  color: "#666666",
+                }}
+              >
+                {resultIcon}
+              </span>
+              <span style={{ minWidth: 0, flex: 1 }}>
+                <span
+                  style={{
+                    display: "block",
+                    overflow: "hidden",
+                    fontSize: "13px",
+                    fontWeight: 400,
+                    lineHeight: 1.25,
+                    textOverflow: "ellipsis",
+                    whiteSpace: "nowrap",
+                  }}
+                >
+                  <HighlightedSearchText text={result.label} query={query} />
+                </span>
+                {result.detail && (
+                  <span
+                    style={{
+                      display: "block",
+                      overflow: "hidden",
+                      marginTop: "2px",
+                      color: "#777777",
+                      fontSize: "11px",
+                      lineHeight: 1.2,
+                      textOverflow: "ellipsis",
+                      whiteSpace: "nowrap",
+                    }}
+                  >
+                    {result.detail}
+                  </span>
+                )}
+                {result.schematicSheetName && (
+                  <span
+                    style={{
+                      display: "block",
+                      overflow: "hidden",
+                      marginTop: "2px",
+                      color: "#777777",
+                      fontSize: "11px",
+                      lineHeight: 1.2,
+                      textOverflow: "ellipsis",
+                      whiteSpace: "nowrap",
+                    }}
+                  >
+                    Sheet: {result.schematicSheetName}
+                  </span>
+                )}
+              </span>
+              {active && (
+                <span
+                  title="Press Enter to open"
+                  style={{
+                    flexShrink: 0,
+                    color: "#666666",
+                    fontSize: "17px",
+                    lineHeight: 1,
+                  }}
+                >
+                  <CornerDownLeft size={14} strokeWidth={1.8} />
+                </span>
+              )}
+            </button>
+          )
+        })}
+      </section>
+    )
+  }
+
+  return (
+    <div
+      data-schematic-search
+      onPointerDown={(event) => event.stopPropagation()}
+      onMouseDown={(event) => event.stopPropagation()}
+      onTouchStart={(event) => event.stopPropagation()}
+      onTouchEnd={(event) => event.stopPropagation()}
+      style={{
+        position: "relative",
+        zIndex: zIndexMap.schematicSearch,
+        fontFamily: '-apple-system, BlinkMacSystemFont, "Segoe UI", sans-serif',
+      }}
+    >
+      {!isOpen ? (
+        <button
+          type="button"
+          title="Search schematic"
+          aria-label="Search schematic"
+          onPointerDown={(event) => {
+            event.stopPropagation()
+            if (event.pointerType !== "mouse") openSearch(false)
+          }}
+          onPointerUp={(event) => {
+            if (event.pointerType === "mouse" && event.button === 0) {
+              openSearch(true)
+            }
+          }}
+          onClick={(event) => {
+            if (event.detail === 0) openSearch(true)
+          }}
+          style={{
+            width: "32px",
+            height: "32px",
+            display: "grid",
+            placeItems: "center",
+            padding: 0,
+            border: "none",
+            borderRadius: "4px",
+            backgroundColor: "#ffffff",
+            color: "#000000",
+            cursor: "pointer",
+            boxShadow: "0 2px 4px rgba(0,0,0,0.1)",
+          }}
+        >
+          <Search size={16} strokeWidth={2} aria-hidden="true" />
+        </button>
+      ) : (
+        <div
+          onKeyDown={handleSearchKeyDown}
+          style={{
+            width: "min(280px, calc(100vw - 32px))",
+            overflow: "hidden",
+            border: "none",
+            borderRadius: "4px",
+            backgroundColor: "#ffffff",
+            boxShadow: "0 2px 4px rgba(0,0,0,0.1)",
+          }}
+        >
+          <div
+            style={{
+              display: "flex",
+              alignItems: "center",
+              gap: "8px",
+              height: "32px",
+              boxSizing: "border-box",
+              padding: "0 12px",
+              borderBottom: searchHeaderBorder,
+            }}
+          >
+            <Search size={15} strokeWidth={2} aria-hidden="true" />
+            <input
+              ref={inputRef}
+              value={query}
+              aria-label="Search components and nets"
+              placeholder="Search..."
+              onPointerUp={(event) => event.currentTarget.focus()}
+              onChange={(event) => onQueryChange(event.target.value)}
+              style={{
+                minWidth: 0,
+                flex: 1,
+                border: "none",
+                outline: "none",
+                fontSize: "13px",
+                color: "#222222",
+                background: "transparent",
+              }}
+            />
+            {query && results.length > 0 ? (
+              <span
+                style={{
+                  flexShrink: 0,
+                  color: "#888888",
+                  fontSize: "12px",
+                  whiteSpace: "nowrap",
+                }}
+              >
+                {resultCountLabel}
+              </span>
+            ) : (
+              <kbd
+                style={{
+                  flexShrink: 0,
+                  padding: "2px 5px",
+                  border: "1px solid #dddddd",
+                  borderRadius: "4px",
+                  backgroundColor: "#f7f7f7",
+                  color: "#777777",
+                  fontFamily: "inherit",
+                  fontSize: "10px",
+                  lineHeight: 1.2,
+                }}
+              >
+                {shortcutLabel}
+              </kbd>
+            )}
+            {isOpen && (
+              <button
+                type="button"
+                aria-label="Clear search"
+                onPointerUp={(event) => {
+                  if (event.button === 0) cancelSearch()
+                }}
+                onClick={(event) => {
+                  if (event.detail === 0) cancelSearch()
+                }}
+                style={{
+                  border: "none",
+                  background: "transparent",
+                  color: "#777777",
+                  cursor: "pointer",
+                  width: "20px",
+                  height: "20px",
+                  display: "grid",
+                  placeItems: "center",
+                  padding: 0,
+                  lineHeight: 1,
+                }}
+              >
+                <X size={16} strokeWidth={2} aria-hidden="true" />
+              </button>
+            )}
+          </div>
+          {query && (
+            <div
+              ref={resultsListRef}
+              style={{
+                maxHeight: "240px",
+                overflowX: "hidden",
+                overflowY: "auto",
+                overscrollBehavior: "contain",
+                scrollBehavior: "smooth",
+                touchAction: "pan-y",
+                WebkitOverflowScrolling: "touch",
+              }}
+              onWheel={(event) => event.stopPropagation()}
+              onTouchMove={(event) => event.stopPropagation()}
+            >
+              {results.length === 0 ? (
+                <div
+                  style={{
+                    padding: "12px",
+                    color: "#777777",
+                    fontSize: "13px",
+                  }}
+                >
+                  No matching components or nets
+                </div>
+              ) : (
+                <>
+                  {renderResultSection("components", componentResults)}
+                  {renderResultSection("nets", netResults)}
+                </>
+              )}
+            </div>
+          )}
+        </div>
+      )}
+    </div>
+  )
+}
diff --git a/lib/components/SchematicSheetSelector.tsx b/lib/components/SchematicSheetSelector.tsx
index 0216654c..48af4c80 100644
--- a/lib/components/SchematicSheetSelector.tsx
+++ b/lib/components/SchematicSheetSelector.tsx
@@ -127,9 +127,6 @@ export const SchematicSheetSelector = ({
             title={selectedLabel}
             onPointerDown={(e) => e.stopPropagation()}
             style={{
-              position: "absolute",
-              top: "16px",
-              left: "16px",
               display: "flex",
               alignItems: "center",
               gap: "6px",
@@ -144,7 +141,6 @@ export const SchematicSheetSelector = ({
               boxShadow: "0 2px 4px rgba(0,0,0,0.1)",
               fontSize: "13px",
               fontFamily: FONT_FAMILY,
-              zIndex: zIndexMap.viewMenuIcon,
             }}
           >
             <span style={{ color: "#888888", flexShrink: 0 }}>Sheet:</span>
diff --git a/lib/components/SchematicViewer.tsx b/lib/components/SchematicViewer.tsx
index 798222c5..d37e2201 100644
--- a/lib/components/SchematicViewer.tsx
+++ b/lib/components/SchematicViewer.tsx
@@ -7,6 +7,7 @@ import { useChangeSchematicComponentLocationsInSvg } from "lib/hooks/useChangeSc
 import { useChangeSchematicTracesForMovedComponents } from "lib/hooks/useChangeSchematicTracesForMovedComponents"
 import { useSchematicGroupsOverlay } from "lib/hooks/useSchematicGroupsOverlay"
 import { useSchematicNetHover } from "lib/hooks/useSchematicNetHover"
+import { useSchematicSearch } from "lib/hooks/useSchematicSearch"
 import { enableDebug } from "lib/utils/debug"
 import { useCallback, useEffect, useMemo, useRef, useState } from "react"
 import {
@@ -34,6 +35,7 @@ import { MouseTracker } from "./MouseTracker"
 import { SchematicComponentMouseTarget } from "./SchematicComponentMouseTarget"
 import { SchematicPortMouseTarget } from "./SchematicPortMouseTarget"
 import { SchematicSheetSelector } from "./SchematicSheetSelector"
+import { SchematicSearch } from "./SchematicSearch"
 
 interface Props {
   circuitJson: CircuitJson
@@ -62,6 +64,8 @@ interface Props {
   }) => void
   /** Called when the active schematic sheet changes (multi-sheet circuits). */
   onSchematicSheetChange?: (schematicSheetId: string) => void
+  /** Show component and net-label search. Default true. */
+  searchEnabled?: boolean
 }
 
 export const SchematicViewer = ({
@@ -81,6 +85,7 @@ export const SchematicViewer = ({
   showSchematicPorts = false,
   onSchematicPortClicked,
   onSchematicSheetChange,
+  searchEnabled = true,
   css,
   className,
 }: Props) => {
@@ -283,15 +288,27 @@ export const SchematicViewer = ({
     }
   }, [circuitJson])
 
+  const shouldHandleViewerGesture = useCallback(
+    (event: MouseEvent | TouchEvent | WheelEvent) => {
+      const target = event.target
+      return !(
+        target instanceof Element && target.closest("[data-schematic-search]")
+      )
+    },
+    [],
+  )
+
   const {
     ref: containerRef,
     cancelDrag,
     transform: svgToScreenProjection,
+    setTransform: setSvgToScreenProjection,
   } = useMouseMatrixTransform({
     onSetTransform(transform) {
       if (!svgDivRef.current) return
       svgDivRef.current.style.transform = transformToString(transform)
     },
+    shouldDrag: shouldHandleViewerGesture,
     // @ts-ignore disabled is a valid prop but not typed
     enabled: isInteractionEnabled,
   })
@@ -345,6 +362,26 @@ export const SchematicViewer = ({
     }
   }, [svgString])
 
+  const {
+    searchQuery,
+    setSearchQuery,
+    searchResults,
+    handleSearchResultSelect,
+    handleCancelSearch,
+  } = useSchematicSearch({
+    circuitJson,
+    circuitJsonKey,
+    svgDivRef,
+    containerRef,
+    activeSheetId,
+    hasMultipleSheets,
+    handleSelectSheet,
+    svgString,
+    svgToScreenProjection,
+    setSvgToScreenProjection,
+    setIsInteractionEnabled,
+  })
+
   const handleEditEvent = (event: ManualEditEvent) => {
     setInternalEditEvents((prev) => [...prev, event])
     if (onEditEvent) {
@@ -448,6 +485,26 @@ export const SchematicViewer = ({
             svg :is(g.trace, g.trace-overlays, g[data-schematic-component-id], [data-schematic-net-label-id]) { transition: opacity 0.12s ease-in-out; }`}
         </style>
       )}
+      {searchEnabled && (
+        <style>
+          {`.schematic-search-match text,
+            text.schematic-search-match {
+              fill: #ff00d4 !important;
+            }
+            .schematic-search-match [stroke]:not(text):not([stroke="none"]),
+            [stroke]:not(text):not([stroke="none"]).schematic-search-match {
+              stroke: #ff00d4 !important;
+            }
+            .schematic-viewer-toolbar {
+              flex-direction: row;
+            }
+            @media (max-width: 640px) {
+              .schematic-viewer-toolbar {
+                flex-direction: column;
+              }
+            }`}
+        </style>
+      )}
       {onSchematicComponentClicked && (
         <style>
           {`.schematic-component-clickable [data-schematic-component-id]:hover { cursor: pointer !important; }`}
@@ -485,6 +542,12 @@ export const SchematicViewer = ({
           handleMouseDown(e)
         }}
         onMouseDownCapture={(e) => {
+          if (
+            e.target instanceof Element &&
+            e.target.closest("[data-schematic-search]")
+          ) {
+            return
+          }
           if (clickToInteractEnabled && !isInteractionEnabled) {
             e.preventDefault()
             e.stopPropagation()
@@ -558,11 +621,36 @@ export const SchematicViewer = ({
           showGrid={showGrid}
           onToggleGrid={setShowGridInternal}
         />
-        <SchematicSheetSelector
-          sheets={schematicSheets}
-          selectedSheetId={activeSheetId}
-          onSelectSheet={handleSelectSheet}
-        />
+        <div
+          className="schematic-viewer-toolbar"
+          onTouchStart={(event) => event.stopPropagation()}
+          onTouchEnd={(event) => event.stopPropagation()}
+          style={{
+            position: "absolute",
+            top: "16px",
+            left: "16px",
+            display: "flex",
+            alignItems: "flex-start",
+            gap: "8px",
+            zIndex: zIndexMap.schematicSearch,
+          }}
+        >
+          <SchematicSheetSelector
+            sheets={schematicSheets}
+            selectedSheetId={activeSheetId}
+            onSelectSheet={handleSelectSheet}
+          />
+          {searchEnabled && (
+            <SchematicSearch
+              query={searchQuery}
+              onQueryChange={setSearchQuery}
+              onCancel={handleCancelSearch}
+              results={searchResults}
+              onSelect={handleSearchResultSelect}
+              viewerContainerRef={containerRef}
+            />
+          )}
+        </div>
         {onSchematicComponentClicked &&
           schematicComponentIds.map((componentId) => (
             <SchematicComponentMouseTarget
diff --git a/lib/hooks/useSchematicSearch.ts b/lib/hooks/useSchematicSearch.ts
new file mode 100644
index 00000000..62cdc77f
--- /dev/null
+++ b/lib/hooks/useSchematicSearch.ts
@@ -0,0 +1,189 @@
+import type { CircuitJson } from "circuit-json"
+import type { RefObject } from "react"
+import { useCallback, useEffect, useMemo, useRef, useState } from "react"
+import { fromString, type Matrix } from "transformation-matrix"
+import {
+  getSchematicSearchResults,
+  type SchematicSearchResult,
+} from "../utils/get-schematic-search-results"
+import { getSearchResultTransform } from "../utils/get-search-result-transform"
+
+const MIN_SEARCH_RESULT_ZOOM = 1.8
+const SEARCH_FOCUS_ANIMATION_MS = 350
+
+export const useSchematicSearch = ({
+  circuitJson,
+  circuitJsonKey,
+  svgDivRef,
+  containerRef,
+  activeSheetId,
+  hasMultipleSheets,
+  handleSelectSheet,
+  svgString,
+  svgToScreenProjection,
+  setSvgToScreenProjection,
+  setIsInteractionEnabled,
+}: {
+  circuitJson: CircuitJson
+  circuitJsonKey: string
+  svgDivRef: RefObject<HTMLDivElement | null>
+  containerRef: RefObject<HTMLElement | null>
+  activeSheetId?: string
+  hasMultipleSheets: boolean
+  handleSelectSheet: (schematicSheetId: string) => void
+  svgString: string
+  svgToScreenProjection: Matrix
+  setSvgToScreenProjection: (transform: Matrix) => void
+  setIsInteractionEnabled: (enabled: boolean) => void
+}) => {
+  const [searchQuery, setSearchQuery] = useState("")
+  const [pendingSearchResult, setPendingSearchResult] =
+    useState<SchematicSearchResult | null>(null)
+  const searchAnimationTimerRef = useRef<ReturnType<typeof setTimeout> | null>(
+    null,
+  )
+
+  const searchResults = useMemo(
+    () => getSchematicSearchResults(circuitJson, searchQuery),
+    [circuitJson, circuitJsonKey, searchQuery],
+  )
+
+  const focusSearchResult = useCallback(
+    (result: SchematicSearchResult) => {
+      const svgRoot = svgDivRef.current
+      const container = containerRef.current
+      if (!svgRoot || !container) return false
+
+      let attribute = "data-schematic-net-label-id"
+      if (result.target.type === "schematic_component") {
+        attribute = "data-schematic-component-id"
+      }
+      const target = Array.from(
+        svgRoot.querySelectorAll<SVGGraphicsElement>(`[${attribute}]`),
+      ).find((element) => element.getAttribute(attribute) === result.target.id)
+      if (!target) return false
+
+      const targetRect = target.getBoundingClientRect()
+      const containerRect = container.getBoundingClientRect()
+      if (!targetRect.width && !targetRect.height) return false
+
+      if (searchAnimationTimerRef.current) {
+        clearTimeout(searchAnimationTimerRef.current)
+      }
+
+      let visibleProjection = svgToScreenProjection
+      const visibleTransform = getComputedStyle(svgRoot).transform
+      if (visibleTransform && visibleTransform !== "none") {
+        try {
+          visibleProjection = fromString(visibleTransform)
+          svgRoot.style.transition = "none"
+          svgRoot.style.transform = visibleTransform
+          void svgRoot.offsetWidth
+        } catch {
+          // The transform tracked by the viewer is the safe fallback.
+        }
+      }
+
+      svgRoot.style.transition = `transform ${SEARCH_FOCUS_ANIMATION_MS}ms ease-in-out`
+      void svgRoot.offsetWidth
+      setSvgToScreenProjection(
+        getSearchResultTransform({
+          containerRect,
+          targetRect,
+          visibleProjection,
+          minimumScale: MIN_SEARCH_RESULT_ZOOM,
+        }),
+      )
+      searchAnimationTimerRef.current = setTimeout(() => {
+        svgRoot.style.transition = ""
+      }, SEARCH_FOCUS_ANIMATION_MS)
+
+      svgRoot
+        .querySelectorAll(".schematic-search-match")
+        .forEach((element) =>
+          element.classList.remove("schematic-search-match"),
+        )
+      svgRoot.querySelectorAll(`[${attribute}]`).forEach((element) => {
+        if (element.getAttribute(attribute) === result.target.id) {
+          element.classList.add("schematic-search-match")
+        }
+      })
+      return true
+    },
+    [containerRef, setSvgToScreenProjection, svgDivRef, svgToScreenProjection],
+  )
+
+  const handleSearchResultSelect = useCallback(
+    (result: SchematicSearchResult) => {
+      setIsInteractionEnabled(true)
+      if (
+        result.schematicSheetId &&
+        result.schematicSheetId !== activeSheetId &&
+        hasMultipleSheets
+      ) {
+        handleSelectSheet(result.schematicSheetId)
+        setPendingSearchResult(result)
+        return
+      }
+      focusSearchResult(result)
+    },
+    [
+      activeSheetId,
+      focusSearchResult,
+      handleSelectSheet,
+      hasMultipleSheets,
+      setIsInteractionEnabled,
+    ],
+  )
+
+  const handleCancelSearch = useCallback(() => {
+    setSearchQuery("")
+    setPendingSearchResult(null)
+    if (searchAnimationTimerRef.current) {
+      clearTimeout(searchAnimationTimerRef.current)
+      searchAnimationTimerRef.current = null
+    }
+    if (svgDivRef.current) {
+      svgDivRef.current.style.transition = ""
+      svgDivRef.current
+        .querySelectorAll(".schematic-search-match")
+        .forEach((element) =>
+          element.classList.remove("schematic-search-match"),
+        )
+    }
+  }, [svgDivRef])
+
+  useEffect(() => {
+    if (!pendingSearchResult || !svgString) return
+    const frame = requestAnimationFrame(() => {
+      if (focusSearchResult(pendingSearchResult)) {
+        setPendingSearchResult(null)
+      }
+    })
+    return () => cancelAnimationFrame(frame)
+  }, [focusSearchResult, pendingSearchResult, svgString])
+
+  useEffect(() => {
+    if (searchQuery) return
+    svgDivRef.current
+      ?.querySelectorAll(".schematic-search-match")
+      .forEach((element) => element.classList.remove("schematic-search-match"))
+  }, [searchQuery, svgDivRef])
+
+  useEffect(
+    () => () => {
+      if (searchAnimationTimerRef.current) {
+        clearTimeout(searchAnimationTimerRef.current)
+      }
+    },
+    [],
+  )
+
+  return {
+    searchQuery,
+    setSearchQuery,
+    searchResults,
+    handleSearchResultSelect,
+    handleCancelSearch,
+  }
+}
diff --git a/lib/utils/get-schematic-search-results.ts b/lib/utils/get-schematic-search-results.ts
new file mode 100644
index 00000000..a16ca40b
--- /dev/null
+++ b/lib/utils/get-schematic-search-results.ts
@@ -0,0 +1,250 @@
+import type {
+  CircuitJson,
+  SchematicComponent,
+  SchematicNetLabel,
+  SchematicPort,
+  SourceComponentBase,
+  SourcePort,
+  SourceTrace,
+  SchematicSheet,
+} from "circuit-json"
+
+type SearchableSourceComponent = SourceComponentBase & {
+  display_resistance?: string
+  display_capacitance?: string
+  display_inductance?: string
+  display_frequency?: string
+  symbol_display_value?: string
+}
+
+export type SchematicSearchResult = {
+  label: string
+  detail?: string
+  kind: "component" | "net"
+  schematicSheetId?: string
+  schematicSheetName?: string
+  target:
+    | { type: "schematic_component"; id: string }
+    | { type: "schematic_net_label"; id: string }
+}
+
+const normalize = (value: unknown) => String(value ?? "").toLocaleLowerCase()
+
+const getTextMatchScore = (text: unknown, query: string) => {
+  const normalizedText = normalize(text)
+  if (normalizedText === query) return 0
+  if (normalizedText.startsWith(query)) return 1
+  if (normalizedText.includes(query)) return 2
+  return Number.POSITIVE_INFINITY
+}
+
+const humanizeComponentType = (ftype: unknown) => {
+  if (!ftype) return undefined
+  return String(ftype)
+    .replace(/^simple_/, "")
+    .replaceAll("_", " ")
+    .replace(/\b\w/g, (character) => character.toLocaleUpperCase())
+}
+
+const getComponentDetail = (
+  sourceComponent: SearchableSourceComponent | undefined,
+  schematicComponent: SchematicComponent,
+  primaryLabel: string,
+) => {
+  const componentType = humanizeComponentType(sourceComponent?.ftype)
+  let displayName: string | undefined
+  if (sourceComponent?.display_name !== primaryLabel) {
+    displayName = sourceComponent?.display_name
+  }
+
+  let componentValue = sourceComponent?.display_value
+  if (!componentValue && sourceComponent) {
+    for (const displayField of [
+      "display_resistance",
+      "display_capacitance",
+      "display_inductance",
+      "display_frequency",
+      "symbol_display_value",
+    ] as const) {
+      if (displayField in sourceComponent) {
+        const displayedMeasurement = sourceComponent[displayField]
+        if (typeof displayedMeasurement === "string") {
+          componentValue = displayedMeasurement
+          break
+        }
+      }
+    }
+  }
+  componentValue ??= schematicComponent.symbol_display_value
+
+  if (componentType && componentValue) {
+    return `${componentType} · ${componentValue}`
+  }
+  return (
+    componentValue ??
+    displayName ??
+    sourceComponent?.manufacturer_part_number ??
+    componentType
+  )
+}
+
+const isSourceComponent = (
+  element: CircuitJson[number],
+): element is CircuitJson[number] & SearchableSourceComponent =>
+  element.type === "source_component" && "source_component_id" in element
+
+const isSourcePort = (element: CircuitJson[number]): element is SourcePort =>
+  element.type === "source_port"
+
+const isSourceTrace = (element: CircuitJson[number]): element is SourceTrace =>
+  element.type === "source_trace"
+
+const isSchematicComponent = (
+  element: CircuitJson[number],
+): element is SchematicComponent => element.type === "schematic_component"
+
+const isSchematicPort = (
+  element: CircuitJson[number],
+): element is SchematicPort => element.type === "schematic_port"
+
+const isSchematicNetLabel = (
+  element: CircuitJson[number],
+): element is SchematicNetLabel => element.type === "schematic_net_label"
+
+const isSchematicSheet = (
+  element: CircuitJson[number],
+): element is SchematicSheet => element.type === "schematic_sheet"
+
+const getSchematicSheetName = ({
+  schematicSheets,
+  schematicSheetId,
+}: {
+  schematicSheets: SchematicSheet[]
+  schematicSheetId?: string
+}) => {
+  if (schematicSheets.length <= 1 || !schematicSheetId) return undefined
+  return schematicSheets.find(
+    (sheet) => sheet.schematic_sheet_id === schematicSheetId,
+  )?.name
+}
+
+export const getSchematicSearchResults = (
+  circuitJson: CircuitJson,
+  query: string,
+): SchematicSearchResult[] => {
+  const normalizedQuery = normalize(query).trim()
+  if (!normalizedQuery) return []
+
+  const sourceComponents = new Map(
+    circuitJson
+      .filter(isSourceComponent)
+      .map((element) => [element.source_component_id, element]),
+  )
+  const sourcePorts = new Map(
+    circuitJson
+      .filter(isSourcePort)
+      .map((element) => [element.source_port_id, element]),
+  )
+  const schematicPorts = circuitJson.filter(isSchematicPort)
+  const sourceTraces = circuitJson.filter(isSourceTrace)
+  const schematicSheets = circuitJson.filter(isSchematicSheet)
+  const results: SchematicSearchResult[] = []
+  const resultScores = new Map<SchematicSearchResult, number>()
+
+  for (const component of circuitJson.filter(isSchematicComponent)) {
+    const sourceComponent = component.source_component_id
+      ? sourceComponents.get(component.source_component_id)
+      : undefined
+    const primaryLabel =
+      sourceComponent?.name ?? sourceComponent?.display_name ?? "Component"
+    const componentScore = getTextMatchScore(primaryLabel, normalizedQuery)
+
+    if (Number.isFinite(componentScore)) {
+      const result: SchematicSearchResult = {
+        label: primaryLabel,
+        detail: getComponentDetail(sourceComponent, component, primaryLabel),
+        kind: "component",
+        schematicSheetId: component.schematic_sheet_id,
+        schematicSheetName: getSchematicSheetName({
+          schematicSheets,
+          schematicSheetId: component.schematic_sheet_id,
+        }),
+        target: {
+          type: "schematic_component",
+          id: component.schematic_component_id,
+        },
+      }
+      results.push(result)
+      resultScores.set(result, componentScore)
+    }
+  }
+
+  for (const netLabel of circuitJson.filter(isSchematicNetLabel)) {
+    if (!normalize(netLabel.text).includes(normalizedQuery)) continue
+    const connectedPortIds = new Set<string>()
+    for (const trace of sourceTraces.filter((sourceTrace) =>
+      sourceTrace.connected_source_net_ids.includes(netLabel.source_net_id),
+    )) {
+      for (const portId of trace.connected_source_port_ids) {
+        connectedPortIds.add(portId)
+      }
+    }
+    const anchorPosition = netLabel.anchor_position ?? netLabel.center
+    const nearestConnectedPort = schematicPorts
+      .filter(
+        (port) =>
+          connectedPortIds.has(port.source_port_id) &&
+          (!netLabel.schematic_sheet_id ||
+            !port.schematic_sheet_id ||
+            port.schematic_sheet_id === netLabel.schematic_sheet_id),
+      )
+      .map((port) => ({
+        port,
+        distance: Math.hypot(
+          port.center.x - anchorPosition.x,
+          port.center.y - anchorPosition.y,
+        ),
+      }))
+      .filter(({ distance }) => distance <= 1)
+      .sort((a, b) => a.distance - b.distance)[0]?.port
+    const sourcePort = nearestConnectedPort
+      ? sourcePorts.get(nearestConnectedPort.source_port_id)
+      : undefined
+    const connectedComponent = sourcePort?.source_component_id
+      ? sourceComponents.get(sourcePort.source_component_id)
+      : undefined
+    const connectedPinName =
+      sourcePort?.name ??
+      (sourcePort?.pin_number !== undefined
+        ? `pin${sourcePort.pin_number}`
+        : nearestConnectedPort?.display_pin_label)
+    const connectionLabel =
+      connectedComponent?.name && connectedPinName
+        ? `Connected to ${connectedComponent.name}.${connectedPinName}`
+        : undefined
+    const result: SchematicSearchResult = {
+      label: netLabel.text,
+      detail: connectionLabel,
+      kind: "net",
+      schematicSheetId: netLabel.schematic_sheet_id,
+      schematicSheetName: getSchematicSheetName({
+        schematicSheets,
+        schematicSheetId: netLabel.schematic_sheet_id,
+      }),
+      target: {
+        type: "schematic_net_label",
+        id: netLabel.schematic_net_label_id,
+      },
+    }
+    results.push(result)
+    resultScores.set(result, getTextMatchScore(netLabel.text, normalizedQuery))
+  }
+
+  return results.sort((a, b) => {
+    return (
+      (resultScores.get(a) ?? Number.POSITIVE_INFINITY) -
+        (resultScores.get(b) ?? Number.POSITIVE_INFINITY) ||
+      a.label.localeCompare(b.label)
+    )
+  })
+}
diff --git a/lib/utils/get-search-result-transform.ts b/lib/utils/get-search-result-transform.ts
new file mode 100644
index 00000000..136f9dc0
--- /dev/null
+++ b/lib/utils/get-search-result-transform.ts
@@ -0,0 +1,37 @@
+import type { Matrix } from "transformation-matrix"
+
+export const getSearchResultTransform = ({
+  containerRect,
+  targetRect,
+  visibleProjection,
+  minimumScale,
+}: {
+  containerRect: Pick<DOMRect, "left" | "top" | "width" | "height">
+  targetRect: Pick<DOMRect, "left" | "top" | "width" | "height">
+  visibleProjection: Matrix
+  minimumScale: number
+}): Matrix => {
+  const currentScale = visibleProjection.a || 1
+  const targetCenterInContainer = {
+    x: targetRect.left + targetRect.width / 2 - containerRect.left,
+    y: targetRect.top + targetRect.height / 2 - containerRect.top,
+  }
+  const targetCenterBeforeViewerTransform = {
+    x: (targetCenterInContainer.x - visibleProjection.e) / currentScale,
+    y: (targetCenterInContainer.y - visibleProjection.f) / currentScale,
+  }
+  const targetScale = Math.max(currentScale, minimumScale)
+
+  return {
+    a: targetScale,
+    b: 0,
+    c: 0,
+    d: targetScale,
+    e:
+      containerRect.width / 2 -
+      targetCenterBeforeViewerTransform.x * targetScale,
+    f:
+      containerRect.height / 2 -
+      targetCenterBeforeViewerTransform.y * targetScale,
+  }
+}
diff --git a/lib/utils/z-index-map.ts b/lib/utils/z-index-map.ts
index cf32e180..1c4de98c 100644
--- a/lib/utils/z-index-map.ts
+++ b/lib/utils/z-index-map.ts
@@ -7,4 +7,5 @@ export const zIndexMap = {
   clickToInteractOverlay: 100,
   schematicComponentHoverOutline: 47,
   schematicPortHoverOutline: 48,
+  schematicSearch: 101,
 }
diff --git a/package.json b/package.json
index 386afd39..466f10c4 100644
--- a/package.json
+++ b/package.json
@@ -40,6 +40,7 @@
     "circuit-json": "^0.0.454",
     "circuit-to-svg": "^0.0.393",
     "debug": "^4.4.0",
+    "lucide-react": "^1.21.0",
     "performance-now": "^2.1.0",
     "use-mouse-matrix-transform": "^1.2.2"
   }
diff --git a/tests/schematic-search.test.ts b/tests/schematic-search.test.ts
new file mode 100644
index 00000000..4fb32ef8
--- /dev/null
+++ b/tests/schematic-search.test.ts
@@ -0,0 +1,224 @@
+import { expect, test } from "bun:test"
+import type { CircuitJson } from "circuit-json"
+import { getSearchResultTransform } from "../lib/utils/get-search-result-transform"
+import { getSchematicSearchResults } from "../lib/utils/get-schematic-search-results"
+
+const circuitJson = [
+  {
+    type: "source_component",
+    source_component_id: "source_component_1",
+    name: "U1",
+    display_value: "USB Controller",
+  },
+  {
+    type: "schematic_component",
+    schematic_component_id: "schematic_component_1",
+    source_component_id: "source_component_1",
+    schematic_sheet_id: "sheet_1",
+    port_labels: { pin1: "VBUS", pin2: "D-", pin3: "D+" },
+  },
+  {
+    type: "schematic_net_label",
+    schematic_net_label_id: "schematic_net_label_1",
+    schematic_sheet_id: "sheet_1",
+    text: "GND",
+  },
+] as CircuitJson
+
+test("finds components by reference designator", () => {
+  const results = getSchematicSearchResults(circuitJson, "u1")
+
+  expect(results).toHaveLength(1)
+  expect(results[0]?.target).toEqual({
+    type: "schematic_component",
+    id: "schematic_component_1",
+  })
+  expect(results[0]?.schematicSheetId).toBe("sheet_1")
+})
+
+test("finds net labels case-insensitively", () => {
+  const results = getSchematicSearchResults(circuitJson, "gnd")
+
+  expect(results.map((result) => result.label)).toEqual(["GND"])
+  expect(results[0]?.target.type).toBe("schematic_net_label")
+})
+
+test("identifies matching net labels on different schematic sheets", () => {
+  const circuitWithMatchingNetsAcrossSheets = [
+    {
+      type: "schematic_sheet",
+      schematic_sheet_id: "sheet_power",
+      name: "Power",
+      sheet_index: 0,
+    },
+    {
+      type: "schematic_sheet",
+      schematic_sheet_id: "sheet_sensors",
+      name: "Sensors",
+      sheet_index: 1,
+    },
+    {
+      type: "schematic_net_label",
+      schematic_net_label_id: "vcc_power",
+      schematic_sheet_id: "sheet_power",
+      source_net_id: "source_net_vcc",
+      text: "VCC",
+      center: { x: 0, y: 0 },
+    },
+    {
+      type: "schematic_net_label",
+      schematic_net_label_id: "vcc_sensors",
+      schematic_sheet_id: "sheet_sensors",
+      source_net_id: "source_net_vcc",
+      text: "VCC",
+      center: { x: 0, y: 0 },
+    },
+  ] as CircuitJson
+
+  const results = getSchematicSearchResults(
+    circuitWithMatchingNetsAcrossSheets,
+    "VCC",
+  )
+
+  expect(results).toHaveLength(2)
+  expect(results.map((result) => result.schematicSheetName)).toEqual([
+    "Power",
+    "Sensors",
+  ])
+})
+
+test("does not include component pin labels", () => {
+  const results = getSchematicSearchResults(circuitJson, "D-")
+
+  expect(results).toEqual([])
+})
+
+test("puts exact matches before partial matches", () => {
+  const jsonWithPartialMatch = [
+    ...circuitJson,
+    {
+      type: "schematic_net_label",
+      schematic_net_label_id: "schematic_net_label_2",
+      text: "GND_SENSE",
+    },
+  ] as CircuitJson
+
+  expect(
+    getSchematicSearchResults(jsonWithPartialMatch, "GND").map(
+      (result) => result.label,
+    ),
+  ).toEqual(["GND", "GND_SENSE"])
+})
+
+test("does not match hidden component values", () => {
+  const circuitWithCapacitor = [
+    ...circuitJson,
+    {
+      type: "source_component",
+      source_component_id: "source_component_2",
+      name: "C1",
+      display_value: "1uF",
+    },
+    {
+      type: "schematic_component",
+      schematic_component_id: "schematic_component_2",
+      source_component_id: "source_component_2",
+    },
+  ] as CircuitJson
+
+  expect(
+    getSchematicSearchResults(circuitWithCapacitor, "u").map(
+      (result) => result.label,
+    ),
+  ).toEqual(["U1"])
+})
+
+test("shows the component pin attached to a net label", () => {
+  const circuitWithConnectedNet = [
+    ...circuitJson,
+    {
+      type: "source_component",
+      source_component_id: "source_component_r1",
+      name: "R1",
+    },
+    {
+      type: "source_port",
+      source_port_id: "source_port_r1_pin1",
+      source_component_id: "source_component_r1",
+      name: "pin1",
+      pin_number: 1,
+    },
+    {
+      type: "schematic_port",
+      schematic_port_id: "schematic_port_r1_pin1",
+      source_port_id: "source_port_r1_pin1",
+      center: { x: 2, y: 3.2 },
+    },
+    {
+      type: "source_trace",
+      source_trace_id: "source_trace_1",
+      connected_source_net_ids: ["source_net_gnd"],
+      connected_source_port_ids: ["source_port_r1_pin1"],
+    },
+  ].map((element) =>
+    element.type === "schematic_net_label"
+      ? {
+          ...element,
+          source_net_id: "source_net_gnd",
+          anchor_position: { x: 2, y: 3 },
+        }
+      : element,
+  ) as CircuitJson
+
+  expect(
+    getSchematicSearchResults(circuitWithConnectedNet, "GND")[0]?.detail,
+  ).toBe("Connected to R1.pin1")
+})
+
+test("formats component type and value as useful context", () => {
+  const circuitWithResistor = [
+    {
+      type: "source_component",
+      source_component_id: "source_component_r1",
+      name: "R1",
+      ftype: "simple_resistor",
+      display_resistance: "10Ω",
+    },
+    {
+      type: "schematic_component",
+      schematic_component_id: "schematic_component_r1",
+      source_component_id: "source_component_r1",
+    },
+  ] as CircuitJson
+
+  expect(getSchematicSearchResults(circuitWithResistor, "R1")[0]?.detail).toBe(
+    "Resistor · 10Ω",
+  )
+})
+
+test("centers a search result and preserves an existing closer zoom", () => {
+  const transform = getSearchResultTransform({
+    containerRect: { left: 100, top: 50, width: 800, height: 600 },
+    targetRect: { left: 450, top: 300, width: 100, height: 60 },
+    visibleProjection: { a: 2, b: 0, c: 0, d: 2, e: 100, f: -20 },
+    minimumScale: 1.8,
+  })
+
+  expect(transform.a).toBe(2)
+  expect(transform.d).toBe(2)
+  expect(transform.e).toBe(100)
+  expect(transform.f).toBe(0)
+})
+
+test("zooms in to the minimum search scale", () => {
+  const transform = getSearchResultTransform({
+    containerRect: { left: 0, top: 0, width: 1000, height: 800 },
+    targetRect: { left: 700, top: 500, width: 40, height: 20 },
+    visibleProjection: { a: 1, b: 0, c: 0, d: 1, e: 0, f: 0 },
+    minimumScale: 1.8,
+  })
+
+  expect(transform.a).toBe(1.8)
+  expect(transform.e).toBe(-796)
+  expect(transform.f).toBe(-518)
+})