diff --git a/src/lib/components/find/AdvancedSearch.svelte b/src/lib/components/find/AdvancedSearch.svelte
new file mode 100644
index 0000000..09462b0
--- /dev/null
+++ b/src/lib/components/find/AdvancedSearch.svelte
@@ -0,0 +1,672 @@
+<script lang="ts">
+  import { nostrClient } from '../../services/nostr/nostr-client.js';
+  import { relayManager } from '../../services/nostr/relay-manager.js';
+  import { nip19 } from 'nostr-tools';
+  import { KIND_LOOKUP } from '../../types/kind-lookup.js';
+  import type { NostrEvent } from '../../types/nostr.js';
+
+  interface Props {
+    onSearchResults?: (results: { events: NostrEvent[]; profiles: string[]; relays?: string[]; eventRelays?: Map<string, string> }) => void;
+  }
+
+  let { onSearchResults }: Props = $props();
+
+  // NIP-01 standard filter controls
+  let filterIds = $state<string>('');
+  let filterAuthors = $state<string>('');
+  let filterKinds = $state<string>('');
+  let filterE = $state<string>('');
+  let filterP = $state<string>('');
+  let filterA = $state<string>('');
+  let filterQ = $state<string>('');
+  let filterT = $state<string>('');
+  let filterC = $state<string>('');
+  let filterD = $state<string>('');
+  let filterSince = $state<string>('');
+  let filterUntil = $state<string>('');
+  let filterLimit = $state<number>(100);
+  let searching = $state(false);
+  let searchResults = $state<{ events: NostrEvent[]; profiles: string[]; relays?: string[] }>({ events: [], profiles: [] });
+  const eventRelayMap = new Map<string, string>();
+
+  // Helper function to decode bech32 to hex
+  async function decodeBech32ToHex(bech32: string, type: 'pubkey' | 'event'): Promise<string | null> {
+    try {
+      if (!/^(npub|nprofile|note|nevent|naddr)1[a-z0-9]+$/i.test(bech32)) {
+        return null;
+      }
+      
+      const decoded = nip19.decode(bech32);
+      
+      if (type === 'pubkey') {
+        if (decoded.type === 'npub') {
+          return String(decoded.data).toLowerCase();
+        } else if (decoded.type === 'nprofile') {
+          if (decoded.data && typeof decoded.data === 'object' && 'pubkey' in decoded.data) {
+            return String(decoded.data.pubkey).toLowerCase();
+          }
+        } else if (decoded.type === 'naddr') {
+          if (decoded.data && typeof decoded.data === 'object' && 'pubkey' in decoded.data) {
+            return String(decoded.data.pubkey).toLowerCase();
+          }
+        }
+      } else if (type === 'event') {
+        if (decoded.type === 'note') {
+          return String(decoded.data).toLowerCase();
+        } else if (decoded.type === 'nevent') {
+          if (decoded.data && typeof decoded.data === 'object' && 'id' in decoded.data) {
+            return String(decoded.data.id).toLowerCase();
+          }
+        }
+      }
+    } catch (error) {
+      console.debug('Error decoding bech32:', error);
+    }
+    return null;
+  }
+
+  // Helper function to parse comma-separated values and validate hex strings
+  async function parseHexList(input: string, type: 'pubkey' | 'event' = 'event'): Promise<string[]> {
+    const results: string[] = [];
+    const parts = input.split(',').map(s => s.trim()).filter(s => s.length > 0);
+    
+    for (const part of parts) {
+      // Check if it's already a hex string
+      if (/^[0-9a-f]{64}$/i.test(part)) {
+        results.push(part.toLowerCase());
+      } else {
+        // Try to decode as bech32
+        const decoded = await decodeBech32ToHex(part, type);
+        if (decoded) {
+          results.push(decoded);
+        }
+      }
+    }
+    
+    return results;
+  }
+  
+  // Helper function to parse comma-separated numbers
+  function parseNumberList(input: string): number[] {
+    return input
+      .split(',')
+      .map(s => parseInt(s.trim(), 10))
+      .filter(n => !isNaN(n) && n >= 0 && n <= 65535);
+  }
+  
+  // Helper function to parse comma-separated addressable event refs
+  async function parseAddressableList(input: string): Promise<string[]> {
+    const results: string[] = [];
+    const parts = input.split(',').map(s => s.trim()).filter(s => s.length > 0);
+    
+    for (const part of parts) {
+      const match = part.match(/^(\d+):([^:]+)(?::(.+))?$/);
+      if (match) {
+        const [, kind, pubkeyPart, dTag] = match;
+        let hexPubkey: string | null = null;
+        
+        if (/^[0-9a-f]{64}$/i.test(pubkeyPart)) {
+          hexPubkey = pubkeyPart.toLowerCase();
+        } else {
+          hexPubkey = await decodeBech32ToHex(pubkeyPart, 'pubkey');
+        }
+        
+        if (hexPubkey) {
+          if (dTag) {
+            results.push(`${kind}:${hexPubkey}:${dTag}`);
+          } else {
+            results.push(`${kind}:${hexPubkey}:`);
+          }
+        }
+      }
+    }
+    
+    return results;
+  }
+  
+  // Helper function to convert date-time string to unix timestamp
+  function dateTimeToUnixTimestamp(dateTimeStr: string): number | null {
+    if (!dateTimeStr.trim()) return null;
+    
+    try {
+      const date = new Date(dateTimeStr.trim());
+      
+      if (isNaN(date.getTime())) {
+        const timestamp = parseInt(dateTimeStr.trim(), 10);
+        if (!isNaN(timestamp) && timestamp > 0) {
+          return timestamp;
+        }
+        return null;
+      }
+      
+      return Math.floor(date.getTime() / 1000);
+    } catch (error) {
+      const timestamp = parseInt(dateTimeStr.trim(), 10);
+      if (!isNaN(timestamp) && timestamp > 0) {
+        return timestamp;
+      }
+      return null;
+    }
+  }
+  
+  // Build NIP-01 filter from form inputs
+  async function buildFilter(): Promise<any> {
+    const filter: any = {};
+    
+    if (filterIds.trim()) {
+      const ids = await parseHexList(filterIds, 'event');
+      if (ids.length > 0) {
+        filter.ids = ids;
+      }
+    }
+    
+    if (filterAuthors.trim()) {
+      const authors = await parseHexList(filterAuthors, 'pubkey');
+      if (authors.length > 0) {
+        filter.authors = authors;
+      }
+    }
+    
+    if (filterKinds.trim()) {
+      const kinds = parseNumberList(filterKinds);
+      if (kinds.length > 0) {
+        filter.kinds = kinds;
+      }
+    }
+    
+    if (filterE.trim()) {
+      const eTags = await parseHexList(filterE, 'event');
+      if (eTags.length > 0) {
+        filter['#e'] = eTags;
+      }
+    }
+    
+    if (filterP.trim()) {
+      const pTags = await parseHexList(filterP, 'pubkey');
+      if (pTags.length > 0) {
+        filter['#p'] = pTags;
+      }
+    }
+    
+    if (filterA.trim()) {
+      const aTags = await parseAddressableList(filterA);
+      if (aTags.length > 0) {
+        filter['#a'] = aTags;
+      }
+    }
+    
+    if (filterQ.trim()) {
+      const qTags = await parseHexList(filterQ, 'event');
+      if (qTags.length > 0) {
+        filter['#q'] = qTags;
+      }
+    }
+    
+    if (filterT.trim()) {
+      const tTags = filterT
+        .split(',')
+        .map(s => s.trim())
+        .filter(s => s.length > 0);
+      if (tTags.length > 0) {
+        filter['#T'] = tTags;
+      }
+    }
+    
+    if (filterC.trim()) {
+      const cTags = filterC
+        .split(',')
+        .map(s => s.trim())
+        .filter(s => s.length > 0);
+      if (cTags.length > 0) {
+        filter['#C'] = cTags;
+      }
+    }
+    
+    if (filterD.trim()) {
+      const dTags = filterD
+        .split(',')
+        .map(s => s.trim())
+        .filter(s => s.length > 0);
+      if (dTags.length > 0) {
+        filter['#d'] = dTags;
+      }
+    }
+    
+    if (filterSince.trim()) {
+      const since = dateTimeToUnixTimestamp(filterSince);
+      if (since !== null && since > 0) {
+        filter.since = since;
+      }
+    }
+    
+    if (filterUntil.trim()) {
+      const until = dateTimeToUnixTimestamp(filterUntil);
+      if (until !== null && until > 0) {
+        filter.until = until;
+      }
+    }
+    
+    if (filterLimit > 0) {
+      filter.limit = filterLimit;
+    } else {
+      filter.limit = 100;
+    }
+    
+    return filter;
+  }
+
+  async function handleSearch() {
+    searching = true;
+    const newEventRelayMap = new Map<string, string>();
+
+    try {
+      await nostrClient.initialize();
+      const relays = relayManager.getAllAvailableRelays();
+      
+      const filter = await buildFilter();
+      
+      // Check if filter has any conditions (not just limit)
+      const hasConditions = Object.keys(filter).some(key => key !== 'limit');
+      
+      if (!hasConditions) {
+        // No filter conditions, show error or return empty
+        searchResults = { events: [], profiles: [], relays };
+        if (onSearchResults) {
+          onSearchResults({ events: [], profiles: [], relays, eventRelays: new Map() });
+        }
+        searching = false;
+        return;
+      }
+      
+      // Fetch events using the filter
+      const events = await nostrClient.fetchEvents(
+        [filter],
+        relays,
+        { useCache: true, cacheResults: true }
+      );
+      
+      // Track which relay each event came from
+      for (const event of events) {
+        if (!newEventRelayMap.has(event.id)) {
+          newEventRelayMap.set(event.id, relays[0] || 'unknown');
+        }
+      }
+      
+      // Sort by created_at (newest first)
+      const sortedEvents = events.sort((a, b) => b.created_at - a.created_at);
+      
+      searchResults = { events: sortedEvents, profiles: [], relays };
+      if (onSearchResults) {
+        onSearchResults({ events: sortedEvents, profiles: [], relays, eventRelays: newEventRelayMap });
+      }
+    } catch (error) {
+      console.error('Advanced search error:', error);
+      searchResults = { events: [], profiles: [], relays: [] };
+      if (onSearchResults) {
+        onSearchResults({ events: [], profiles: [], relays: [], eventRelays: new Map() });
+      }
+    } finally {
+      searching = false;
+    }
+  }
+
+  export function clearSearch() {
+    filterIds = '';
+    filterAuthors = '';
+    filterKinds = '';
+    filterE = '';
+    filterP = '';
+    filterA = '';
+    filterQ = '';
+    filterT = '';
+    filterC = '';
+    filterD = '';
+    filterSince = '';
+    filterUntil = '';
+    filterLimit = 100;
+    searchResults = { events: [], profiles: [] };
+    eventRelayMap.clear();
+    if (onSearchResults) {
+      onSearchResults({ events: [], profiles: [], relays: [], eventRelays: new Map() });
+    }
+  }
+
+  export function getSearchResults() {
+    return searchResults;
+  }
+</script>
+
+<div class="advanced-search">
+  <h2>Advanced Search (NIP-01 Filters)</h2>
+  <p class="section-description">
+    Use NIP-01 standard filters to search for events. All filters are optional - combine them as needed.
+  </p>
+  
+  <div class="search-container">
+    <div class="advanced-filters-grid">
+      <div class="filter-group">
+        <label for="filter-ids" class="filter-label">IDs (comma-separated event IDs):</label>
+        <input
+          id="filter-ids"
+          type="text"
+          bind:value={filterIds}
+          placeholder="64-char hex event IDs or bech32 (note, nevent)"
+          class="filter-input"
+        />
+      </div>
+      
+      <div class="filter-group">
+        <label for="filter-authors" class="filter-label">Authors (comma-separated pubkeys):</label>
+        <input
+          id="filter-authors"
+          type="text"
+          bind:value={filterAuthors}
+          placeholder="64-char hex pubkeys or bech32 (npub, nprofile)"
+          class="filter-input"
+        />
+      </div>
+      
+      <div class="filter-group">
+        <label for="filter-kinds" class="filter-label">Kinds (comma-separated):</label>
+        <input
+          id="filter-kinds"
+          type="text"
+          bind:value={filterKinds}
+          placeholder="e.g., 1, 7, 11"
+          class="filter-input"
+        />
+      </div>
+      
+      <div class="filter-group">
+        <label for="filter-e" class="filter-label">#e tag (comma-separated event IDs):</label>
+        <input
+          id="filter-e"
+          type="text"
+          bind:value={filterE}
+          placeholder="64-char hex event IDs or bech32"
+          class="filter-input"
+        />
+      </div>
+      
+      <div class="filter-group">
+        <label for="filter-p" class="filter-label">#p tag (comma-separated pubkeys):</label>
+        <input
+          id="filter-p"
+          type="text"
+          bind:value={filterP}
+          placeholder="64-char hex pubkeys or bech32"
+          class="filter-input"
+        />
+      </div>
+      
+      <div class="filter-group">
+        <label for="filter-a" class="filter-label">#a tag (comma-separated addressable refs):</label>
+        <input
+          id="filter-a"
+          type="text"
+          bind:value={filterA}
+          placeholder="kind:pubkey:d-tag"
+          class="filter-input"
+        />
+      </div>
+      
+      <div class="filter-group">
+        <label for="filter-q" class="filter-label">#q tag (comma-separated quoted event IDs):</label>
+        <input
+          id="filter-q"
+          type="text"
+          bind:value={filterQ}
+          placeholder="64-char hex event IDs or bech32"
+          class="filter-input"
+        />
+      </div>
+      
+      <div class="filter-group">
+        <label for="filter-t" class="filter-label">#T tag (comma-separated topics):</label>
+        <input
+          id="filter-t"
+          type="text"
+          bind:value={filterT}
+          placeholder="topic1, topic2, topic3"
+          class="filter-input"
+        />
+      </div>
+      
+      <div class="filter-group">
+        <label for="filter-c" class="filter-label">#C tag (comma-separated categories):</label>
+        <input
+          id="filter-c"
+          type="text"
+          bind:value={filterC}
+          placeholder="category1, category2, category3"
+          class="filter-input"
+        />
+      </div>
+      
+      <div class="filter-group">
+        <label for="filter-d" class="filter-label">#d tag (comma-separated d-tag values):</label>
+        <input
+          id="filter-d"
+          type="text"
+          bind:value={filterD}
+          placeholder="d-tag1, d-tag2, d-tag3"
+          class="filter-input"
+        />
+      </div>
+      
+      <div class="filter-group">
+        <label for="filter-since" class="filter-label">Since (date-time or unix timestamp):</label>
+        <input
+          id="filter-since"
+          type="text"
+          bind:value={filterSince}
+          placeholder="2024-01-15T14:30:00Z or unix timestamp"
+          class="filter-input"
+        />
+        <small class="filter-hint">Accepts ISO 8601 format or unix timestamp</small>
+      </div>
+      
+      <div class="filter-group">
+        <label for="filter-until" class="filter-label">Until (date-time or unix timestamp):</label>
+        <input
+          id="filter-until"
+          type="text"
+          bind:value={filterUntil}
+          placeholder="2024-01-15T14:30:00Z or unix timestamp"
+          class="filter-input"
+        />
+        <small class="filter-hint">Accepts ISO 8601 format or unix timestamp</small>
+      </div>
+      
+      <div class="filter-group">
+        <label for="filter-limit" class="filter-label">Limit:</label>
+        <input
+          id="filter-limit"
+          type="number"
+          bind:value={filterLimit}
+          min="1"
+          max="1000"
+          class="filter-input"
+        />
+      </div>
+    </div>
+    
+    <div class="search-button-wrapper">
+      <button 
+        class="search-button"
+        onclick={handleSearch}
+        disabled={searching}
+        aria-label="Search"
+      >
+        {searching ? 'Searching...' : 'Search'}
+      </button>
+    </div>
+  </div>
+</div>
+
+<style>
+  .advanced-search {
+    /* No container styling - parent .find-section handles it */
+  }
+
+  .advanced-search h2 {
+    margin: 0 0 1rem 0;
+    font-size: 1.25em;
+    font-weight: 600;
+    color: var(--fog-text, #475569);
+  }
+
+  @media (min-width: 640px) {
+    .advanced-search h2 {
+      margin: 0 0 1.5rem 0;
+    }
+  }
+
+  :global(.dark) .advanced-search h2 {
+    color: var(--fog-dark-text, #cbd5e1);
+  }
+
+  .section-description {
+    margin: 0 0 1rem 0;
+    color: var(--fog-text-light, #52667a);
+    font-size: 0.875em;
+  }
+
+  @media (min-width: 640px) {
+    .section-description {
+      margin: 0 0 1.5rem 0;
+    }
+  }
+
+  :global(.dark) .section-description {
+    color: var(--fog-dark-text-light, #a8b8d0);
+  }
+
+  .search-container {
+    display: flex;
+    flex-direction: column;
+    gap: 1.5rem;
+  }
+
+  .advanced-filters-grid {
+    display: grid;
+    grid-template-columns: 1fr;
+    gap: 0.75rem;
+    padding: 0.75rem;
+    background: var(--fog-highlight, #f3f4f6);
+    border-radius: 0.375rem;
+    border: 1px solid var(--fog-border, #e5e7eb);
+  }
+
+  @media (min-width: 640px) {
+    .advanced-filters-grid {
+      gap: 1rem;
+      padding: 1rem;
+    }
+  }
+
+  :global(.dark) .advanced-filters-grid {
+    background: var(--fog-dark-highlight, #374151);
+    border-color: var(--fog-dark-border, #475569);
+  }
+
+  @media (min-width: 768px) {
+    .advanced-filters-grid {
+      grid-template-columns: repeat(2, 1fr);
+    }
+  }
+
+  .filter-group {
+    display: flex;
+    flex-direction: column;
+    gap: 0.5rem;
+  }
+
+  .filter-label {
+    font-size: 0.875em;
+    font-weight: 500;
+    color: var(--fog-text, #1f2937);
+  }
+
+  :global(.dark) .filter-label {
+    color: var(--fog-dark-text, #f9fafb);
+  }
+
+  .filter-input {
+    padding: 0.5em;
+    border: 1px solid var(--fog-border, #cbd5e1);
+    border-radius: 0.375rem;
+    background: var(--fog-post, #ffffff);
+    color: var(--fog-text, #1f2937);
+    font-size: 0.875em;
+    font-family: inherit;
+    width: 100%;
+  }
+
+  .filter-input:focus {
+    outline: none;
+    border-color: var(--fog-accent, #64748b);
+    box-shadow: 0 0 0 3px rgba(100, 116, 139, 0.1);
+  }
+
+  :global(.dark) .filter-input {
+    border-color: var(--fog-dark-border, #374151);
+    background: var(--fog-dark-post, #1f2937);
+    color: var(--fog-dark-text, #f9fafb);
+  }
+
+  :global(.dark) .filter-input:focus {
+    border-color: var(--fog-dark-accent, #94a3b8);
+    box-shadow: 0 0 0 3px rgba(148, 163, 184, 0.1);
+  }
+
+  .filter-hint {
+    font-size: 0.75em;
+    color: var(--fog-text-light, #52667a);
+    margin-top: 0.25em;
+    display: block;
+  }
+
+  :global(.dark) .filter-hint {
+    color: var(--fog-dark-text-light, #a8b8d0);
+  }
+
+  .search-button-wrapper {
+    display: flex;
+    justify-content: flex-end;
+  }
+
+  .search-button {
+    padding: 0.75em 1.5em;
+    background: var(--fog-accent, #64748b);
+    color: #ffffff;
+    border: none;
+    border-radius: 0.375rem;
+    cursor: pointer;
+    font-size: 0.875em;
+    font-weight: 500;
+    font-family: inherit;
+    white-space: nowrap;
+    transition: all 0.2s;
+    min-width: 100px;
+  }
+
+  :global(.dark) .search-button {
+    background: var(--fog-dark-accent, #94a3b8);
+    color: #1f2937;
+  }
+
+  .search-button:hover:not(:disabled) {
+    opacity: 0.9;
+    transform: translateY(-1px);
+  }
+
+  .search-button:active:not(:disabled) {
+    transform: translateY(0);
+  }
+
+  .search-button:disabled {
+    opacity: 0.6;
+    cursor: not-allowed;
+  }
+</style>
diff --git a/src/lib/components/find/NormalSearch.svelte b/src/lib/components/find/NormalSearch.svelte
new file mode 100644
index 0000000..4124e01
--- /dev/null
+++ b/src/lib/components/find/NormalSearch.svelte
@@ -0,0 +1,277 @@
+<script lang="ts">
+  import UnifiedSearch from '../layout/UnifiedSearch.svelte';
+  import { KIND_LOOKUP } from '../../types/kind-lookup.js';
+  import type { NostrEvent } from '../../types/nostr.js';
+
+  interface Props {
+    onSearchResults?: (results: { events: NostrEvent[]; profiles: string[]; relays?: string[]; eventRelays?: Map<string, string> }) => void;
+  }
+
+  let { onSearchResults }: Props = $props();
+
+  let unifiedSearchComponent: { triggerSearch: () => void; clearSearch: () => void; getFilterResult: () => { type: 'event' | 'pubkey' | 'text' | null; value: string | null; kind?: number | null } } | null = $state(null);
+  let selectedKind = $state<number | null>(null);
+  let selectedKindString = $state<string>('');
+
+  // Get all kinds for dropdown
+  const allKinds = Object.values(KIND_LOOKUP).sort((a, b) => a.number - b.number);
+
+  // Sync selectedKindString with selectedKind
+  $effect(() => {
+    selectedKindString = selectedKind?.toString() || '';
+  });
+
+  // Sync selectedKind with selectedKindString when it changes
+  $effect(() => {
+    if (selectedKindString === '') {
+      selectedKind = null;
+    } else {
+      const parsed = parseInt(selectedKindString);
+      if (!isNaN(parsed)) {
+        selectedKind = parsed;
+      }
+    }
+  });
+
+  function handleKindChange(e: Event) {
+    const select = e.target as HTMLSelectElement;
+    selectedKindString = select.value;
+  }
+
+  function handleSearch() {
+    if (unifiedSearchComponent) {
+      unifiedSearchComponent.triggerSearch();
+    }
+  }
+
+  export function clearSearch() {
+    if (unifiedSearchComponent) {
+      unifiedSearchComponent.clearSearch();
+    }
+    selectedKind = null;
+    selectedKindString = '';
+    if (onSearchResults) {
+      onSearchResults({ events: [], profiles: [], relays: [], eventRelays: new Map() });
+    }
+  }
+
+  export function getSearchResults() {
+    return { events: [], profiles: [] };
+  }
+</script>
+
+<div class="normal-search">
+  <h2>Normal Search</h2>
+  <p class="section-description">
+    Search for events by ID, pubkey, NIP-05, or content. Use the kind filter to narrow results.
+  </p>
+  
+  <div class="search-container">
+    <div class="search-bar-wrapper">
+      <UnifiedSearch 
+        mode="search" 
+        bind:this={unifiedSearchComponent}
+        selectedKind={selectedKind}
+        hideDropdownResults={true}
+        onSearchResults={onSearchResults}
+        placeholder="Search events, profiles, pubkeys, or enter event ID..." 
+      />
+    </div>
+    
+    <div class="filter-and-button-wrapper">
+      <div class="kind-filter-wrapper">
+        <label for="kind-filter" class="kind-filter-label">Filter by Kind:</label>
+        <select
+          id="kind-filter"
+          bind:value={selectedKindString}
+          onchange={handleKindChange}
+          class="kind-filter-select"
+          aria-label="Filter by kind"
+        >
+          <option value="">All Kinds</option>
+          {#each allKinds as kindInfo}
+            <option value={kindInfo.number}>{kindInfo.number}: {kindInfo.description}</option>
+          {/each}
+        </select>
+      </div>
+      
+      <button 
+        class="search-button"
+        onclick={handleSearch}
+        disabled={!unifiedSearchComponent || !unifiedSearchComponent.getFilterResult().value?.trim()}
+        aria-label="Search"
+      >
+        Search
+      </button>
+    </div>
+  </div>
+</div>
+
+<style>
+  .normal-search {
+    /* No container styling - parent .find-section handles it */
+  }
+
+  .normal-search h2 {
+    margin: 0 0 1rem 0;
+    font-size: 1.25em;
+    font-weight: 600;
+    color: var(--fog-text, #475569);
+  }
+
+  @media (min-width: 640px) {
+    .normal-search h2 {
+      margin: 0 0 1.5rem 0;
+    }
+  }
+
+  :global(.dark) .normal-search h2 {
+    color: var(--fog-dark-text, #cbd5e1);
+  }
+
+  .section-description {
+    margin: 0 0 1rem 0;
+    color: var(--fog-text-light, #52667a);
+    font-size: 0.875em;
+  }
+
+  @media (min-width: 640px) {
+    .section-description {
+      margin: 0 0 1.5rem 0;
+    }
+  }
+
+  :global(.dark) .section-description {
+    color: var(--fog-dark-text-light, #a8b8d0);
+  }
+
+  .search-container {
+    display: flex;
+    flex-direction: column;
+    gap: 1rem;
+  }
+
+  .search-bar-wrapper {
+    width: 100%;
+  }
+
+  .filter-and-button-wrapper {
+    display: flex;
+    flex-direction: column;
+    gap: 1rem;
+  }
+
+  @media (min-width: 640px) {
+    .filter-and-button-wrapper {
+      flex-direction: row;
+      align-items: flex-end;
+    }
+  }
+
+  .kind-filter-wrapper {
+    display: flex;
+    flex-direction: column;
+    gap: 0.5rem;
+    flex: 1;
+  }
+
+  @media (min-width: 640px) {
+    .kind-filter-wrapper {
+      flex-direction: row;
+      align-items: center;
+      flex: 1;
+    }
+  }
+
+  .kind-filter-label {
+    font-size: 0.875em;
+    color: var(--fog-text, #1f2937);
+    font-weight: 500;
+    white-space: nowrap;
+  }
+
+  :global(.dark) .kind-filter-label {
+    color: var(--fog-dark-text, #f9fafb);
+  }
+
+  .kind-filter-select {
+    padding: 0.75em;
+    border: 1px solid var(--fog-border, #e5e7eb);
+    border-radius: 0.375rem;
+    background: var(--fog-post, #ffffff);
+    color: var(--fog-text, #1f2937);
+    font-size: 0.875em;
+    cursor: pointer;
+    width: 100%;
+    font-family: inherit;
+  }
+
+  @media (min-width: 640px) {
+    .kind-filter-select {
+      width: auto;
+      min-width: 200px;
+    }
+  }
+
+  .kind-filter-select:focus {
+    outline: none;
+    border-color: var(--fog-accent, #64748b);
+    box-shadow: 0 0 0 3px rgba(100, 116, 139, 0.1);
+  }
+
+  :global(.dark) .kind-filter-select {
+    border-color: var(--fog-dark-border, #374151);
+    background: var(--fog-dark-post, #1f2937);
+    color: var(--fog-dark-text, #f9fafb);
+  }
+
+  :global(.dark) .kind-filter-select:focus {
+    border-color: var(--fog-dark-accent, #94a3b8);
+    box-shadow: 0 0 0 3px rgba(148, 163, 184, 0.1);
+  }
+
+  .search-bar-wrapper :global(.unified-search-container) {
+    max-width: none;
+    width: 100%;
+  }
+
+  .search-button {
+    padding: 0.75em 1.5em;
+    background: var(--fog-accent, #64748b);
+    color: #ffffff;
+    border: none;
+    border-radius: 0.375rem;
+    cursor: pointer;
+    font-size: 0.875em;
+    font-weight: 500;
+    font-family: inherit;
+    white-space: nowrap;
+    transition: all 0.2s;
+    min-width: 100px;
+  }
+
+  @media (min-width: 640px) {
+    .search-button {
+      min-width: auto;
+    }
+  }
+
+  :global(.dark) .search-button {
+    background: var(--fog-dark-accent, #94a3b8);
+    color: #1f2937;
+  }
+
+  .search-button:hover:not(:disabled) {
+    opacity: 0.9;
+    transform: translateY(-1px);
+  }
+
+  .search-button:active:not(:disabled) {
+    transform: translateY(0);
+  }
+
+  .search-button:disabled {
+    opacity: 0.6;
+    cursor: not-allowed;
+  }
+</style>
diff --git a/src/lib/components/layout/Header.svelte b/src/lib/components/layout/Header.svelte
index 5cb53d7..76e3336 100644
--- a/src/lib/components/layout/Header.svelte
+++ b/src/lib/components/layout/Header.svelte
@@ -58,6 +58,9 @@
         {#if isLoggedIn}
           <a href="/write" class="text-fog-text dark:text-fog-dark-text hover:text-fog-accent dark:hover:text-fog-dark-accent transition-colors whitespace-nowrap">/Write</a>
         {/if}
+        {#if isLoggedIn}
+          <a href="/bookmarks" class="text-fog-text dark:text-fog-dark-text hover:text-fog-accent dark:hover:text-fog-dark-accent transition-colors whitespace-nowrap">/Bookmarks</a>
+        {/if}
         <a href="/find" class="text-fog-text dark:text-fog-dark-text hover:text-fog-accent dark:hover:text-fog-dark-accent transition-colors whitespace-nowrap">/Find</a>
         {#if isLoggedIn}
           <a href="/rss" class="text-fog-text dark:text-fog-dark-text hover:text-fog-accent dark:hover:text-fog-dark-accent transition-colors whitespace-nowrap">/RSS</a>
diff --git a/src/lib/components/layout/UnifiedSearch.svelte b/src/lib/components/layout/UnifiedSearch.svelte
index daf3e77..1ea56d1 100644
--- a/src/lib/components/layout/UnifiedSearch.svelte
+++ b/src/lib/components/layout/UnifiedSearch.svelte
@@ -810,9 +810,11 @@
       }
 
       // 6. Anything else is a full-text search
+      // Try NIP-50 search first (relay-side full-text search), then fallback to client-side filtering
       if (mode === 'search') {
         let allEvents: NostrEvent[] = [];
         const uniqueEventIds = new Set<string>();
+        const queryLower = query.toLowerCase();
         
         // Helper to add event and notify if needed
         const addEvent = (event: NostrEvent, relay?: string) => {
@@ -827,7 +829,6 @@
             
             // If hideDropdownResults, notify incrementally
             if (hideDropdownResults && onSearchResults) {
-              const queryLower = query.toLowerCase();
               const matches = allEvents.filter(event => {
                 const contentMatch = event.content.toLowerCase().includes(queryLower);
                 const titleTag = event.tags.find(t => t[0] === 'title');
@@ -860,11 +861,87 @@
           }
         };
         
+        const relays = relayManager.getAllAvailableRelays();
+        
+        // Try NIP-50 search first (relay-side full-text search)
+        // Split query into words for NIP-50 search
+        const searchTerms = query.trim().split(/\s+/).filter(term => term.length > 0);
+        
+        if (searchTerms.length > 0) {
+          try {
+            // Build NIP-50 filter with search terms
+            const nip50Filter: any = {
+              search: searchTerms,
+              limit: 100
+            };
+            
+            // Add kind filter if specified
+            if (effectiveKinds && effectiveKinds.length > 0) {
+              nip50Filter.kinds = effectiveKinds;
+            }
+            
+            // Try NIP-50 search on relays
+            const nip50Events = await nostrClient.fetchEvents(
+              [nip50Filter],
+              relays,
+              { 
+                useCache: 'cache-first', 
+                cacheResults: true, 
+                timeout: 10000,
+                onUpdateWithRelay: (eventsWithRelay: Array<{ event: NostrEvent; relay: string }>) => {
+                  // Add events as they arrive (NIP-50 relays already filtered them)
+                  for (const { event, relay } of eventsWithRelay) {
+                    addEvent(event, relay);
+                  }
+                }
+              }
+            );
+            
+            // If we got results from NIP-50, use them (relays that support it already filtered)
+            if (nip50Events.length > 0) {
+              for (const event of nip50Events) {
+                addEvent(event, relays[0] || 'unknown');
+              }
+              
+              // Sort and return NIP-50 results
+              const sorted = allEvents.sort((a, b) => {
+                const aExact = a.content.toLowerCase() === queryLower;
+                const bExact = b.content.toLowerCase() === queryLower;
+                if (aExact && !bExact) return -1;
+                if (!aExact && bExact) return 1;
+                return b.created_at - a.created_at;
+              });
+              
+              const limitedResults = Array.from(new Map(sorted.map(e => [e.id, e])).values()).slice(0, 100);
+              
+              if (hideDropdownResults && onSearchResults) {
+                foundEvents = limitedResults;
+                const foundEventRelays = new Map<string, string>();
+                for (const event of foundEvents) {
+                  const relay = eventRelayMap.get(event.id);
+                  if (relay) {
+                    foundEventRelays.set(event.id, relay);
+                  }
+                }
+                onSearchResults({ events: foundEvents, profiles: [], relays: relaysUsed, eventRelays: foundEventRelays });
+              } else {
+                searchResults = limitedResults.map(e => ({ event: e, matchType: 'Content (NIP-50)' }));
+                showResults = true;
+              }
+              
+              searching = false;
+              resolving = false;
+              return;
+            }
+          } catch (error) {
+            // NIP-50 search failed or not supported, fall through to client-side search
+            console.debug('NIP-50 search not available or failed, falling back to client-side search:', error);
+          }
+        }
+        
+        // Fallback to client-side filtering if NIP-50 didn't return results or isn't supported
         // If kinds are specified, search from relays
         if (effectiveKinds && effectiveKinds.length > 0) {
-          const relays = relayManager.getAllAvailableRelays();
-          const queryLower = query.toLowerCase();
-          
           // Search each allowed kind with onUpdate for incremental results
           for (const kind of effectiveKinds) {
             await nostrClient.fetchEvents(
@@ -914,7 +991,6 @@
             }
           }
           
-          const queryLower = query.toLowerCase();
           allEvents = allCached.filter(event => {
             const contentMatch = event.content.toLowerCase().includes(queryLower);
             
@@ -935,7 +1011,6 @@
         
         // Final sort and limit (only if not already handled incrementally)
         if (!(hideDropdownResults && onSearchResults && effectiveKinds && effectiveKinds.length > 0)) {
-          const queryLower = query.toLowerCase();
           const sorted = allEvents.sort((a, b) => {
             const aExact = a.content.toLowerCase() === queryLower;
             const bExact = b.content.toLowerCase() === queryLower;
diff --git a/src/lib/modules/profiles/PaymentAddresses.svelte b/src/lib/modules/profiles/PaymentAddresses.svelte
index 468926e..de63f7c 100644
--- a/src/lib/modules/profiles/PaymentAddresses.svelte
+++ b/src/lib/modules/profiles/PaymentAddresses.svelte
@@ -26,22 +26,21 @@
   async function loadPaymentAddresses() {
     loading = true;
     try {
-      const config = nostrClient.getConfig();
+      const { getRecentCachedEvents } = await import('../../services/cache/event-cache.js');
+      const { relayManager } = await import('../../services/nostr/relay-manager.js');
+      const { config } = await import('../../services/nostr/config.js');
+      
+      // Try cache first (fast - instant display)
+      const cachedEvents = await getRecentCachedEvents([KIND.PAYMENT_ADDRESSES], 60 * 60 * 1000, 100); // 1 hour cache
+      const cachedPaymentEvent = cachedEvents.find(e => e.pubkey === pubkey);
       
-      // Fetch kind 10133 (payment targets)
-      const paymentEvents = await nostrClient.fetchEvents(
-        [{ kinds: [KIND.PAYMENT_ADDRESSES], authors: [pubkey], limit: 1 }],
-        [...config.defaultRelays, ...config.profileRelays],
-        { useCache: true, cacheResults: true }
-      );
-
       const addresses: Array<{ type: string; address: string }> = [];
       const seen = new Set<string>();
 
-      // Extract from kind 10133
-      if (paymentEvents.length > 0) {
-        paymentEvent = paymentEvents[0];
-        for (const tag of paymentEvent.tags) {
+      // Extract from cached event if available
+      if (cachedPaymentEvent) {
+        paymentEvent = cachedPaymentEvent;
+        for (const tag of cachedPaymentEvent.tags) {
           if (tag[0] === 'payto' && tag[1] && tag[2]) {
             const key = `${tag[1]}:${tag[2]}`;
             if (!seen.has(key)) {
@@ -50,9 +49,11 @@
             }
           }
         }
+        paymentAddresses = addresses;
+        loading = false; // Show cached content immediately
       }
 
-      // Also get lud16 from profile (kind 0)
+      // Also get lud16 from profile (kind 0) - this is usually cached
       const profile = await fetchProfile(pubkey);
       if (profile && profile.lud16) {
         for (const lud16 of profile.lud16) {
@@ -62,9 +63,49 @@
             seen.add(key);
           }
         }
+        paymentAddresses = addresses;
       }
 
-      paymentAddresses = addresses;
+      // Fetch from relays in background (progressive enhancement) if not in cache
+      if (!cachedPaymentEvent) {
+        const relays = relayManager.getProfileReadRelays();
+        const paymentEvents = await nostrClient.fetchEvents(
+          [{ kinds: [KIND.PAYMENT_ADDRESSES], authors: [pubkey], limit: 1 }],
+          relays,
+          { useCache: 'cache-first', cacheResults: true, timeout: config.shortTimeout }
+        );
+
+        // Update with fresh data if available
+        if (paymentEvents.length > 0) {
+          paymentEvent = paymentEvents[0];
+          const freshAddresses: Array<{ type: string; address: string }> = [];
+          const freshSeen = new Set<string>();
+
+          // Extract from kind 10133
+          for (const tag of paymentEvents[0].tags) {
+            if (tag[0] === 'payto' && tag[1] && tag[2]) {
+              const key = `${tag[1]}:${tag[2]}`;
+              if (!freshSeen.has(key)) {
+                freshAddresses.push({ type: tag[1], address: tag[2] });
+                freshSeen.add(key);
+              }
+            }
+          }
+
+          // Merge with lud16 from profile
+          if (profile && profile.lud16) {
+            for (const lud16 of profile.lud16) {
+              const key = `lightning:${lud16}`;
+              if (!freshSeen.has(key)) {
+                freshAddresses.push({ type: 'lightning', address: lud16 });
+                freshSeen.add(key);
+              }
+            }
+          }
+
+          paymentAddresses = freshAddresses;
+        }
+      }
     } catch (error) {
       console.error('Error loading payment addresses:', error);
     } finally {
diff --git a/src/lib/services/cache/event-archive.ts b/src/lib/services/cache/event-archive.ts
index 78759e5..d60ee60 100644
--- a/src/lib/services/cache/event-archive.ts
+++ b/src/lib/services/cache/event-archive.ts
@@ -202,8 +202,10 @@ export async function archiveOldEvents(
 ): Promise<number> {
   try {
     const db = await getDB();
-    const now = Date.now();
-    const cutoffTime = now - threshold;
+    // created_at is in seconds (Unix timestamp), threshold is in milliseconds
+    // Convert threshold to seconds for comparison
+    const nowSeconds = Math.floor(Date.now() / 1000);
+    const cutoffTimeSeconds = nowSeconds - Math.floor(threshold / 1000);
     
     // Find old events
     const tx = db.transaction('events', 'readonly');
@@ -211,7 +213,7 @@ export async function archiveOldEvents(
     
     const oldEvents: CachedEvent[] = [];
     for await (const cursor of index.iterate()) {
-      if (cursor.value.created_at < cutoffTime) {
+      if (cursor.value.created_at < cutoffTimeSeconds) {
         oldEvents.push(cursor.value as CachedEvent);
       }
     }
@@ -331,9 +333,13 @@ export async function clearOldArchivedEvents(olderThan: number): Promise<number>
     const tx = db.transaction('eventArchive', 'readwrite');
     const index = tx.store.index('created_at');
     
+    // olderThan is in milliseconds, but created_at is in seconds
+    // Convert to seconds for comparison
+    const olderThanSeconds = Math.floor(olderThan / 1000);
+    
     const idsToDelete: string[] = [];
     for await (const cursor of index.iterate()) {
-      if (cursor.value.created_at < olderThan) {
+      if (cursor.value.created_at < olderThanSeconds) {
         idsToDelete.push(cursor.value.id);
       }
     }
@@ -373,6 +379,7 @@ export async function getArchiveStats(): Promise<{
     for await (const cursor of tx.store.iterate()) {
       totalArchived++;
       totalSize += cursor.value.compressed.length;
+      // created_at is in seconds, keep it as-is for consistency
       if (!oldestArchived || cursor.value.created_at < oldestArchived) {
         oldestArchived = cursor.value.created_at;
       }
@@ -393,3 +400,93 @@ export async function getArchiveStats(): Promise<{
     };
   }
 }
+
+/**
+ * Recover all archived events back to main cache (unarchive all)
+ */
+export async function recoverAllArchivedEvents(): Promise<number> {
+  try {
+    const db = await getDB();
+    const tx = db.transaction(['events', 'eventArchive'], 'readwrite');
+    
+    const archivedEvents: CachedEvent[] = [];
+    
+    // Get all archived events
+    for await (const cursor of tx.objectStore('eventArchive').iterate()) {
+      const archived = cursor.value as ArchivedEvent;
+      // Decompress
+      const decompressed = await decompressJSON(archived.compressed);
+      archivedEvents.push(decompressed as CachedEvent);
+    }
+    
+    await tx.done;
+    
+    if (archivedEvents.length === 0) return 0;
+    
+    // Restore in batches to avoid blocking
+    const BATCH_SIZE = 50;
+    let recovered = 0;
+    
+    for (let i = 0; i < archivedEvents.length; i += BATCH_SIZE) {
+      const batch = archivedEvents.slice(i, i + BATCH_SIZE);
+      
+      // Use a new transaction for each batch
+      const batchTx = db.transaction(['events', 'eventArchive'], 'readwrite');
+      
+      // Restore events to main cache
+      await Promise.all(batch.map(event => batchTx.objectStore('events').put(event)));
+      
+      // Remove from archive
+      await Promise.all(batch.map(event => batchTx.objectStore('eventArchive').delete(event.id)));
+      
+      await batchTx.done;
+      recovered += batch.length;
+      
+      // Yield to browser between batches to avoid blocking
+      await new Promise(resolve => setTimeout(resolve, 0));
+    }
+    
+    return recovered;
+  } catch (error) {
+    // Recovery failed (non-critical)
+    return 0;
+  }
+}
+
+/**
+ * Find and recover an archived event by ID
+ */
+export async function recoverArchivedEventById(id: string): Promise<boolean> {
+  try {
+    const archived = await getArchivedEvent(id);
+    if (!archived) return false;
+    
+    const db = await getDB();
+    const tx = db.transaction(['events', 'eventArchive'], 'readwrite');
+    
+    // Put back in main events store
+    await tx.objectStore('events').put(archived);
+    
+    // Remove from archive
+    await tx.objectStore('eventArchive').delete(id);
+    
+    await tx.done;
+    return true;
+  } catch (error) {
+    // Recovery failed (non-critical)
+    return false;
+  }
+}
+
+/**
+ * Check if an event is archived by ID
+ */
+export async function isEventArchived(id: string): Promise<boolean> {
+  try {
+    const db = await getDB();
+    const archived = await db.get('eventArchive', id);
+    return archived !== undefined;
+  } catch (error) {
+    return false;
+  }
+}
diff --git a/src/lib/services/cache/event-cache.ts b/src/lib/services/cache/event-cache.ts
index 9cdad67..8432e3c 100644
--- a/src/lib/services/cache/event-cache.ts
+++ b/src/lib/services/cache/event-cache.ts
@@ -90,7 +90,7 @@ export async function getEvent(id: string): Promise<CachedEvent | undefined> {
 }
 
 /**
- * Get events by kind
+ * Get events by kind (checks both main cache and archive)
  */
 export async function getEventsByKind(kind: number, limit?: number): Promise<CachedEvent[]> {
   try {
@@ -104,8 +104,28 @@ export async function getEventsByKind(kind: number, limit?: number): Promise<Cac
     
     await tx.done;
 
+    // Also check archive for events of this kind
+    const { getArchivedEventsByKind } = await import('./event-archive.js');
+    const archivedEvents = await getArchivedEventsByKind(kind, limit);
+    
+    // Combine and deduplicate (archive might have events that are also in main cache)
+    const eventMap = new Map<string, CachedEvent>();
+    
+    // Add main cache events first
+    for (const event of events) {
+      eventMap.set(event.id, event as CachedEvent);
+    }
+    
+    // Add archived events (won't overwrite if already in main cache)
+    for (const event of archivedEvents) {
+      if (!eventMap.has(event.id)) {
+        eventMap.set(event.id, event);
+      }
+    }
+    
     // Sort and limit after fetching
-    const sorted = events.sort((a, b) => b.created_at - a.created_at);
+    const allEvents = Array.from(eventMap.values());
+    const sorted = allEvents.sort((a, b) => b.created_at - a.created_at);
     return limit ? sorted.slice(0, limit) : sorted;
   } catch (error) {
     // Cache read failed (non-critical)
@@ -114,7 +134,7 @@ export async function getEventsByKind(kind: number, limit?: number): Promise<Cac
 }
 
 /**
- * Get events by pubkey
+ * Get events by pubkey (checks both main cache and archive)
  */
 export async function getEventsByPubkey(pubkey: string, limit?: number): Promise<CachedEvent[]> {
   try {
@@ -128,8 +148,28 @@ export async function getEventsByPubkey(pubkey: string, limit?: number): Promise
     
     await tx.done;
 
+    // Also check archive for events by this pubkey
+    const { getArchivedEventsByPubkey } = await import('./event-archive.js');
+    const archivedEvents = await getArchivedEventsByPubkey(pubkey, limit);
+    
+    // Combine and deduplicate (archive might have events that are also in main cache)
+    const eventMap = new Map<string, CachedEvent>();
+    
+    // Add main cache events first
+    for (const event of events) {
+      eventMap.set(event.id, event as CachedEvent);
+    }
+    
+    // Add archived events (won't overwrite if already in main cache)
+    for (const event of archivedEvents) {
+      if (!eventMap.has(event.id)) {
+        eventMap.set(event.id, event);
+      }
+    }
+    
     // Sort and limit after fetching
-    const sorted = events.sort((a, b) => b.created_at - a.created_at);
+    const allEvents = Array.from(eventMap.values());
+    const sorted = allEvents.sort((a, b) => b.created_at - a.created_at);
     return limit ? sorted.slice(0, limit) : sorted;
   } catch (error) {
     // Cache read failed (non-critical)
@@ -292,7 +332,7 @@ export async function getCachedReactionsForEvents(eventIds: string[]): Promise<M
     
     for (const reaction of allReactions) {
       // Find the event ID this reaction references (check both 'e' and 'E' tags)
-      const eventIdTag = reaction.tags.find(t => {
+      const eventIdTag = reaction.tags.find((t: string[]) => {
         const tagName = t[0];
         return (tagName === 'e' || tagName === 'E') && t[1] && eventIds.includes(t[1]);
       });
diff --git a/src/lib/types/nostr.ts b/src/lib/types/nostr.ts
index 25d79a2..34bea58 100644
--- a/src/lib/types/nostr.ts
+++ b/src/lib/types/nostr.ts
@@ -22,4 +22,5 @@ export interface NostrFilter {
   since?: number;
   until?: number;
   limit?: number;
+  search?: string[]; // NIP-50: Full-text search terms
 }
diff --git a/src/routes/bookmarks/+page.svelte b/src/routes/bookmarks/+page.svelte
index 0f76095..40ec405 100644
--- a/src/routes/bookmarks/+page.svelte
+++ b/src/routes/bookmarks/+page.svelte
@@ -1,1002 +1,164 @@
 <script lang="ts">
   import Header from '../../lib/components/layout/Header.svelte';
   import FeedPost from '../../lib/modules/feed/FeedPost.svelte';
-  import HighlightCard from '../../lib/modules/feed/HighlightCard.svelte';
-  import UnifiedSearch from '../../lib/components/layout/UnifiedSearch.svelte';
-  import ProfileBadge from '../../lib/components/layout/ProfileBadge.svelte';
+  import { getBookmarkedEvents } from '../../lib/services/user-actions.js';
+  import { getEvent } from '../../lib/services/cache/event-cache.js';
   import { nostrClient } from '../../lib/services/nostr/nostr-client.js';
   import { relayManager } from '../../lib/services/nostr/relay-manager.js';
-  import { config } from '../../lib/services/nostr/config.js';
   import { sessionManager } from '../../lib/services/auth/session-manager.js';
-  import { onMount } from 'svelte';
   import type { NostrEvent } from '../../lib/types/nostr.js';
-  import { KIND } from '../../lib/types/kind-lookup.js';
-  import { nip19 } from 'nostr-tools';
+  import { onMount } from 'svelte';
   import { goto } from '$app/navigation';
   import { page } from '$app/stores';
-  import Icon from '../../lib/components/ui/Icon.svelte';
   import Pagination from '../../lib/components/ui/Pagination.svelte';
   import { getPaginatedItems, getCurrentPage, ITEMS_PER_PAGE } from '../../lib/utils/pagination.js';
 
-  interface BookmarkOrHighlight {
-    event: NostrEvent;
-    type: 'bookmark' | 'highlight';
-    authorPubkey: string; // Who created the bookmark/highlight
-  }
-
-  let allItems = $state<BookmarkOrHighlight[]>([]);
   let loading = $state(true);
+  let events = $state<NostrEvent[]>([]);
   let error = $state<string | null>(null);
-  let currentPage = $state(1);
-  let filterResult = $state<{ type: 'event' | 'pubkey' | 'text' | null; value: string | null }>({ type: null, value: null });
-  let typeFilter = $state<'all' | 'bookmark' | 'highlight'>('all');
-  let searchResults = $state<{ events: NostrEvent[]; profiles: string[] }>({ events: [], profiles: [] });
-  
-  // Pagination for search results
+
+  // Pagination
   let currentPage = $derived(getCurrentPage($page.url.searchParams));
-  let paginatedSearchEvents = $derived(
-    searchResults.events.length > ITEMS_PER_PAGE 
-      ? getPaginatedItems(searchResults.events, currentPage, ITEMS_PER_PAGE)
-      : searchResults.events
+  let paginatedEvents = $derived(
+    events.length > ITEMS_PER_PAGE 
+      ? getPaginatedItems(events, currentPage, ITEMS_PER_PAGE)
+      : events
   );
-  let unifiedSearchComponent: { triggerSearch: () => void } | null = $state(null);
-  let seeMyOwn = $state(true); // Checked by default
-  let hasLoadedOnce = $state(false); // Track if we've loaded at least once
-
-  function handleFilterChange(result: { type: 'event' | 'pubkey' | 'text' | null; value: string | null }) {
-    filterResult = result;
-  }
-
-  function handleSearchResults(results: { events: NostrEvent[]; profiles: string[] }) {
-    searchResults = results;
-  }
-
-  function handleSearch() {
-    if (unifiedSearchComponent) {
-      unifiedSearchComponent.triggerSearch();
-    }
-  }
-  const itemsPerPage = 100;
-  const maxTotalItems = 500;
-
-  // Get logged-in user's pubkey
-  let currentUserPubkey = $derived(sessionManager.getSession()?.pubkey || null);
-
-  // Computed: filtered items based on filter result and type filter
-  let filteredItems = $derived.by(() => {
-    let filtered = allItems;
-    
-    // Filter by "See my own" checkbox
-    if (seeMyOwn && currentUserPubkey) {
-      filtered = filtered.filter(item => item.authorPubkey.toLowerCase() === currentUserPubkey.toLowerCase());
-    }
-    
-    // Filter by type (bookmark/highlight)
-    if (typeFilter === 'bookmark') {
-      filtered = filtered.filter(item => item.type === 'bookmark');
-    } else if (typeFilter === 'highlight') {
-      filtered = filtered.filter(item => item.type === 'highlight');
-    }
-    // typeFilter === 'all' shows everything
-    
-    // Filter by pubkey if provided
-    if (filterResult.value && filterResult.type === 'pubkey') {
-      const normalizedPubkey = filterResult.value.toLowerCase();
-      if (/^[a-f0-9]{64}$/i.test(normalizedPubkey)) {
-        filtered = filtered.filter(item => item.authorPubkey.toLowerCase() === normalizedPubkey.toLowerCase());
-      }
-    }
-    
-    return filtered;
-  });
-
-  // Computed: get events for current page
-  let paginatedItems = $derived.by(() => {
-    const start = (currentPage - 1) * itemsPerPage;
-    const end = start + itemsPerPage;
-    return filteredItems.slice(start, end);
-  });
 
-  // Computed: total pages
-  let totalPages = $derived.by(() => Math.ceil(filteredItems.length / itemsPerPage));
-
-  async function loadBookmarksAndHighlights() {
+  async function loadBookmarks() {
     loading = true;
     error = null;
-    allItems = [];
-    currentPage = 1;
-
+    
     try {
-      const relays = relayManager.getFeedReadRelays();
-      const items: BookmarkOrHighlight[] = [];
-      
-      // Build filters based on "See my own" checkbox
-      const bookmarkListFilter: any = { kinds: [KIND.BOOKMARKS], limit: 400 };
-      const highlightFilter: any = { kinds: [KIND.HIGHLIGHTED_ARTICLE], limit: 100 };
-      
-      if (seeMyOwn && currentUserPubkey) {
-        // Only fetch bookmarks and highlights from the current user
-        bookmarkListFilter.authors = [currentUserPubkey];
-        highlightFilter.authors = [currentUserPubkey];
-      }
-      
-      // 1. Fetch bookmark lists (kind 10003) - limit 400
-      const fetchedBookmarkLists = await nostrClient.fetchEvents(
-        [bookmarkListFilter],
-        relays,
-        {
-          useCache: true,
-          cacheResults: true,
-          timeout: config.standardTimeout
-        }
-      );
-
-      // Extract event IDs from bookmark lists
-      const bookmarkMap = new Map<string, string>(); // eventId -> authorPubkey
-      for (const bookmarkList of fetchedBookmarkLists) {
-        for (const tag of bookmarkList.tags) {
-          if (tag[0] === 'e' && tag[1]) {
-            bookmarkMap.set(tag[1], bookmarkList.pubkey);
-          }
-        }
+      // Check if user is logged in
+      const session = sessionManager.getSession();
+      if (!session) {
+        error = 'You must be logged in to view bookmarks.';
+        loading = false;
+        goto('/login');
+        return;
       }
 
+      await nostrClient.initialize();
 
-      // 2. Fetch highlight events (kind 9802) - limit 100
-      // Use profile read relays for highlights (they might be on different relays)
-      const profileRelays = relayManager.getProfileReadRelays();
-      const allRelaysForHighlights = [...new Set([...relays, ...profileRelays])];
-      
-      // Fetch highlights - filtered by "See my own" if enabled
-      const highlightEvents = await nostrClient.fetchEvents(
-        [highlightFilter],
-        allRelaysForHighlights,
-        {
-          useCache: true,
-          cacheResults: true,
-          timeout: config.standardTimeout
-        }
-      );
-
-
-      // For highlights, we store the highlight event itself, mapped by source event ID
-      // sourceEventId -> highlight event
-      const highlightBySourceEvent = new Map<string, { highlight: NostrEvent; authorPubkey: string }>();
-      const aTagHighlights = new Map<string, { highlight: NostrEvent; pubkey: string }>(); // a-tag -> highlight info
-      const highlightsWithoutRefs: { highlight: NostrEvent; authorPubkey: string }[] = []; // Highlights without e-tag or a-tag
-      
-      let highlightsWithETags = 0;
-      let highlightsWithATags = 0;
-      let highlightsWithNoRefs = 0;
+      // Get bookmarked event IDs
+      const bookmarkedIds = await getBookmarkedEvents();
       
-      // First pass: extract e-tags and collect a-tags
-      for (const highlight of highlightEvents) {
-        let hasRef = false;
-        
-        // Extract e-tag (direct event reference)
-        const eTag = highlight.tags.find(t => t[0] === 'e' && t[1]);
-        if (eTag && eTag[1]) {
-          highlightBySourceEvent.set(eTag[1], { highlight, authorPubkey: highlight.pubkey });
-          highlightsWithETags++;
-          hasRef = true;
-        }
-        
-        // Extract a-tag (addressable event: kind:pubkey:d-tag)
-        const aTag = highlight.tags.find(t => t[0] === 'a' && t[1]);
-        if (aTag && aTag[1]) {
-          aTagHighlights.set(aTag[1], { highlight, pubkey: highlight.pubkey });
-          if (!hasRef) highlightsWithATags++;
-          hasRef = true;
-        }
-        
-        if (!hasRef) {
-          highlightsWithNoRefs++;
-          // Store highlights without refs to display them directly
-          highlightsWithoutRefs.push({ highlight, authorPubkey: highlight.pubkey });
-          // Log a sample of highlights without refs for debugging
-        }
-      }
-      
-      
-      // Second pass: fetch events for a-tags in batches (grouped by kind+pubkey+d-tag)
-      if (aTagHighlights.size > 0) {
-        // Group a-tags by kind+pubkey+d-tag to create efficient filters
-        const aTagGroups = new Map<string, { aTags: string[]; pubkey: string; kind: number; dTag?: string }>();
-        
-        for (const [aTag, info] of aTagHighlights.entries()) {
-          const aTagParts = aTag.split(':');
-          if (aTagParts.length >= 2) {
-            const kind = parseInt(aTagParts[0]);
-            const pubkey = aTagParts[1];
-            const dTag = aTagParts[2] || '';
-            
-            // Create a key for grouping: kind:pubkey:d-tag
-            const groupKey = `${kind}:${pubkey}:${dTag}`;
-            
-            if (!aTagGroups.has(groupKey)) {
-              aTagGroups.set(groupKey, {
-                aTags: [],
-                pubkey: info.pubkey,
-                kind,
-                dTag: dTag || undefined
-              });
-            }
-            aTagGroups.get(groupKey)!.aTags.push(aTag);
-          }
-        }
-        
-        // Create batched filters (one per group)
-        const aTagFilters: any[] = [];
-        const filterToATags = new Map<number, string[]>(); // filter index -> a-tags
-        
-        for (const [groupKey, group] of aTagGroups.entries()) {
-          // Extract pubkey from the first a-tag in the group
-          const firstATag = group.aTags[0];
-          const aTagParts = firstATag.split(':');
-          if (aTagParts.length >= 2) {
-            const pubkey = aTagParts[1];
-            
-            const filter: any = {
-              kinds: [group.kind],
-              authors: [pubkey],
-              limit: 100 // Fetch up to 100 events for this kind+pubkey combination
-            };
-            
-            if (group.dTag) {
-              filter['#d'] = [group.dTag];
-            }
-            
-            const filterIndex = aTagFilters.length;
-            aTagFilters.push(filter);
-            filterToATags.set(filterIndex, group.aTags);
-          }
-        }
-        
-        // Fetch all a-tag events in one batch
-        if (aTagFilters.length > 0) {
-          try {
-            const aTagEvents = await nostrClient.fetchEvents(
-              aTagFilters,
-              allRelaysForHighlights,
-              {
-                useCache: true,
-                cacheResults: true,
-                timeout: config.standardTimeout
-              }
-            );
-            
-            // Match a-tag events back to highlights
-            const eventToATag = new Map<string, string>(); // event id -> a-tag
-            
-            for (let filterIndex = 0; filterIndex < aTagFilters.length; filterIndex++) {
-              const filter = aTagFilters[filterIndex];
-              const aTags = filterToATags.get(filterIndex) || [];
-              const kind = filter.kinds[0];
-              const pubkey = filter.authors[0];
-              const dTag = filter['#d']?.[0];
-              
-              // Find events that match this filter
-              const matchingEvents = aTagEvents.filter(event => 
-                event.kind === kind && 
-                event.pubkey === pubkey &&
-                (!dTag || event.tags.find(t => t[0] === 'd' && t[1] === dTag))
-              );
-              
-              // Match events to a-tags
-              for (const event of matchingEvents) {
-                for (const aTag of aTags) {
-                  const aTagParts = aTag.split(':');
-                  if (aTagParts.length >= 2) {
-                    const aTagKind = parseInt(aTagParts[0]);
-                    const aTagPubkey = aTagParts[1];
-                    const aTagDTag = aTagParts[2] || '';
-                    
-                    if (event.kind === aTagKind && event.pubkey === aTagPubkey) {
-                      if (aTagDTag) {
-                        const eventDTag = event.tags.find(t => t[0] === 'd' && t[1]);
-                        if (eventDTag && eventDTag[1] === aTagDTag) {
-                          eventToATag.set(event.id, aTag);
-                          break;
-                        }
-                      } else {
-                        eventToATag.set(event.id, aTag);
-                        break;
-                      }
-                    }
-                  }
-                }
-              }
-            }
-            
-            // Map events to highlights
-            for (const [eventId, aTag] of eventToATag.entries()) {
-              const info = aTagHighlights.get(aTag);
-              if (info) {
-                highlightBySourceEvent.set(eventId, { highlight: info.highlight, authorPubkey: info.pubkey });
-              }
-            }
-            
-          } catch (err) {
-            // Non-critical: a-tag resolution failed
-          }
-        }
-      }
-      
-      // Get source event IDs for highlights (to fetch them for sorting/display)
-      const highlightSourceEventIds = Array.from(highlightBySourceEvent.keys());
-
-      // Combine all event IDs (bookmarks + highlight source events)
-      const allEventIds = new Set([...bookmarkMap.keys(), ...highlightSourceEventIds]);
-
-      if (allEventIds.size === 0) {
+      if (bookmarkedIds.size === 0) {
+        events = [];
         loading = false;
         return;
       }
 
-      // Limit to maxTotalItems
-      const eventIds = Array.from(allEventIds).slice(0, maxTotalItems);
-      if (allEventIds.size > maxTotalItems) {
+      // Fetch events from cache first
+      const eventIds = Array.from(bookmarkedIds);
+      const cachedEvents: NostrEvent[] = [];
+      const missingIds: string[] = [];
+
+      for (const id of eventIds) {
+        const cached = await getEvent(id);
+        if (cached) {
+          cachedEvents.push(cached as NostrEvent);
+        } else {
+          missingIds.push(id);
+        }
       }
 
-      // Fetch the actual events - batch to avoid relay limits (use smaller batch size to avoid "arr too big" errors)
-      const batchSize = 100; // Reduced from 500 to avoid relay limits
-      const allFetchedEvents: NostrEvent[] = [];
-      
-      for (let i = 0; i < eventIds.length; i += batchSize) {
-        const batch = eventIds.slice(i, i + batchSize);
-        const filters = [{ ids: batch }];
-        
-        const batchEvents = await nostrClient.fetchEvents(
-          filters,
+      // Fetch missing events from relays
+      let relayEvents: NostrEvent[] = [];
+      if (missingIds.length > 0) {
+        const relays = relayManager.getAllAvailableRelays();
+        relayEvents = await nostrClient.fetchEvents(
+          [{ ids: missingIds, limit: missingIds.length }],
           relays,
-          {
-            useCache: true,
-            cacheResults: true,
-            timeout: config.mediumTimeout
-          }
+          { useCache: true, cacheResults: true }
         );
-        
-        allFetchedEvents.push(...batchEvents);
-      }
-
-      // Track which highlights we've already added (to avoid duplicates)
-      const addedHighlightIds = new Set<string>();
-
-      // Create BookmarkOrHighlight items
-      for (const event of allFetchedEvents) {
-        const isBookmark = bookmarkMap.has(event.id);
-        const highlightInfo = highlightBySourceEvent.get(event.id);
-        
-        if (isBookmark) {
-          items.push({
-            event,
-            type: 'bookmark',
-            authorPubkey: bookmarkMap.get(event.id)!
-          });
-        } else if (highlightInfo) {
-          // For highlights, use the highlight event itself, not the source event
-          if (!addedHighlightIds.has(highlightInfo.highlight.id)) {
-            items.push({
-              event: highlightInfo.highlight,
-              type: 'highlight',
-              authorPubkey: highlightInfo.authorPubkey
-            });
-            addedHighlightIds.add(highlightInfo.highlight.id);
-          }
-        }
-      }
-      
-      // Add ALL highlights with e-tag or a-tag references, even if source event wasn't found
-      for (const [sourceEventId, highlightInfo] of highlightBySourceEvent.entries()) {
-        if (!addedHighlightIds.has(highlightInfo.highlight.id)) {
-          items.push({
-            event: highlightInfo.highlight,
-            type: 'highlight',
-            authorPubkey: highlightInfo.authorPubkey
-          });
-          addedHighlightIds.add(highlightInfo.highlight.id);
-        }
-      }
-      
-      // Add highlights without e-tag or a-tag references (URL-only highlights, etc.)
-      for (const highlightInfo of highlightsWithoutRefs) {
-        if (!addedHighlightIds.has(highlightInfo.highlight.id)) {
-          items.push({
-            event: highlightInfo.highlight,
-            type: 'highlight',
-            authorPubkey: highlightInfo.authorPubkey
-          });
-          addedHighlightIds.add(highlightInfo.highlight.id);
-        }
       }
 
-      // Sort by created_at (newest first) and limit to maxTotalItems
-      allItems = items.sort((a, b) => b.event.created_at - a.event.created_at).slice(0, maxTotalItems);
-      
-      // Pre-fetch all profiles for event authors in one batch to avoid individual fetches
-      // This prevents ProfileBadge components from making hundreds of individual requests
-      const uniquePubkeys = new Set<string>();
-      for (const item of allItems) {
-        uniquePubkeys.add(item.event.pubkey);
-        uniquePubkeys.add(item.authorPubkey);
-      }
-      
-      if (uniquePubkeys.size > 0) {
-        const profileRelays = relayManager.getProfileReadRelays();
-        const pubkeyArray = Array.from(uniquePubkeys);
-        
-        // Batch fetch all profiles at once (fire and forget - don't block)
-        nostrClient.fetchEvents(
-          [{ kinds: [KIND.METADATA], authors: pubkeyArray, limit: 1 }],
-          profileRelays,
-          {
-            useCache: true,
-            cacheResults: true,
-            priority: 'low', // Low priority - let events load first
-            timeout: config.standardTimeout
-          }
-        ).catch(err => {
-          // Profile pre-fetch failed (non-critical)
-          // Don't block on profile fetch errors
-        });
-      }
+      // Combine and sort by created_at (newest first)
+      const allEvents = [...cachedEvents, ...relayEvents];
+      events = allEvents.sort((a, b) => b.created_at - a.created_at);
     } catch (err) {
-      // Failed to load bookmarks
-      error = err instanceof Error ? err.message : 'Failed to load bookmarks and highlights';
+      console.error('Error loading bookmarks:', err);
+      error = 'Failed to load bookmarks.';
     } finally {
       loading = false;
-      hasLoadedOnce = true;
     }
   }
 
-  // Reset to page 1 when filter changes
-  $effect(() => {
-    filterResult; // Track filterResult
-    typeFilter; // Track typeFilter
-    seeMyOwn; // Track seeMyOwn
-    currentPage = 1;
-  });
-
-  // Reload when "See my own" checkbox or user changes (but not on initial mount)
-  $effect(() => {
-    seeMyOwn; // Track seeMyOwn
-    currentUserPubkey; // Track currentUserPubkey
-    if (hasLoadedOnce && !loading) {
-      loadBookmarksAndHighlights();
-    }
-  });
-
-  onMount(async () => {
-    await nostrClient.initialize();
-    await loadBookmarksAndHighlights();
+  onMount(() => {
+    loadBookmarks();
   });
 </script>
 
 <Header />
 
 <main class="container mx-auto px-4 py-8">
-  <div class="bookmarks-page">
-    <h1 class="font-bold text-fog-text dark:text-fog-dark-text font-mono mb-6" style="font-size: 1.5em;">/Bookmarks</h1>
-    
+  <div class="bookmarks-content">
+    <div class="bookmarks-header mb-6">
+      <h1 class="font-bold text-fog-text dark:text-fog-dark-text font-mono" style="font-size: 1.5em;">/Bookmarks</h1>
+    </div>
+
     {#if loading}
       <div class="loading-state">
-        <p class="text-fog-text dark:text-fog-dark-text">Loading bookmarks and highlights...</p>
+        <p class="text-fog-text dark:text-fog-dark-text">Loading bookmarks...</p>
       </div>
     {:else if error}
       <div class="error-state">
-        <p class="text-fog-text dark:text-fog-dark-text error-message">{error}</p>
+        <p class="text-fog-text dark:text-fog-dark-text">{error}</p>
       </div>
-    {:else if allItems.length === 0}
+    {:else if events.length === 0}
       <div class="empty-state">
-        <p class="text-fog-text dark:text-fog-dark-text">No bookmarks or highlights found.</p>
+        <p class="text-fog-text dark:text-fog-dark-text">No bookmarks yet. Bookmark events to see them here.</p>
       </div>
     {:else}
-      <div class="filters-section-sticky mb-4">
-        <div class="filters-row">
-          <div class="type-filter-section">
-            <label for="type-filter" class="type-filter-label">Filter:</label>
-            <select
-              id="type-filter"
-              bind:value={typeFilter}
-              class="type-filter-select"
-              aria-label="Filter by type"
-            >
-              <option value="all">Bookmarks and highlights</option>
-              <option value="bookmark">Bookmarks</option>
-              <option value="highlight">Highlights</option>
-            </select>
-          </div>
-          {#if currentUserPubkey}
-            <div class="see-my-own-section">
-              <label for="see-my-own" class="see-my-own-label">
-                <input
-                  type="checkbox"
-                  id="see-my-own"
-                  bind:checked={seeMyOwn}
-                  class="see-my-own-checkbox"
-                  aria-label="See my own"
-                />
-                <span>See my own</span>
-              </label>
-            </div>
-          {/if}
-          <div class="search-filter-section">
-            <UnifiedSearch 
-              mode="search" 
-              bind:this={unifiedSearchComponent}
-              allowedKinds={[KIND.BOOKMARKS, KIND.HIGHLIGHTED_ARTICLE]}
-              hideDropdownResults={true}
-              onSearchResults={handleSearchResults}
-              onFilterChange={handleFilterChange}
-              placeholder="Search bookmarks and highlights by pubkey, event ID, or content..." 
-            />
-          </div>
-        </div>
-        
-        {#if totalPages > 1 && !searchResults.events.length && !searchResults.profiles.length}
-          <div class="pagination pagination-top">
-            <button
-              class="pagination-button"
-              disabled={currentPage === 1}
-              onclick={() => {
-                if (currentPage > 1) currentPage--;
-              }}
-              aria-label="Previous page"
-            >
-              Previous
-            </button>
-            
-            <div class="pagination-info">
-              <span class="text-fog-text dark:text-fog-dark-text">
-                Page {currentPage} of {totalPages}
-              </span>
-            </div>
-            
-            <button
-              class="pagination-button"
-              disabled={currentPage === totalPages}
-              onclick={() => {
-                if (currentPage < totalPages) currentPage++;
-              }}
-              aria-label="Next page"
-            >
-              Next
-            </button>
-          </div>
-        {/if}
-      </div>
-
-      {#if searchResults.events.length > 0 || searchResults.profiles.length > 0}
-        <div class="search-results-section">
-          <h2 class="results-title">Search Results</h2>
-          
-          {#if searchResults.profiles.length > 0}
-            <div class="results-group">
-              <h3>Profiles</h3>
-              <div class="profile-results">
-                {#each searchResults.profiles as pubkey}
-                  <a href="/profile/{pubkey}" class="profile-result-card">
-                    <ProfileBadge pubkey={pubkey} />
-                  </a>
-                {/each}
-              </div>
-            </div>
-          {/if}
-          
-          {#if searchResults.events.length > 0}
-            <div class="results-group">
-              <h3>Events ({searchResults.events.length})</h3>
-              <div class="event-results">
-                {#each paginatedSearchEvents as event}
-                  {#if event.kind === KIND.HIGHLIGHTED_ARTICLE}
-                    <div class="event-result-card">
-                      <HighlightCard highlight={event} onOpenEvent={(e) => goto(`/event/${e.id}`)} />
-                    </div>
-                  {:else}
-                    <a href="/event/{event.id}" class="event-result-card">
-                      <FeedPost post={event} fullView={false} />
-                    </a>
-                  {/if}
-                {/each}
-              </div>
-            </div>
-          {/if}
-        </div>
-      {:else}
-        <div class="bookmarks-info">
-          <p class="text-fog-text dark:text-fog-dark-text text-sm">
-            Showing {paginatedItems.length} of {filteredItems.length} items
-            {#if allItems.length >= maxTotalItems}
-              (limited to {maxTotalItems})
-            {/if}
-            {#if filterResult.value}
-              (filtered)
-            {/if}
-          </p>
-        </div>
-        
-        <div class="bookmarks-posts">
-        {#each paginatedItems as item (item.event.id)}
-          <div class="bookmark-item-wrapper">
-            {#if item.type === 'highlight'}
-              <HighlightCard highlight={item.event} onOpenEvent={(event) => goto(`/event/${event.id}`)} />
-            {:else}
-              <div class="bookmark-indicator-wrapper">
-                <Icon 
-                  name="bookmark" 
-                  size={20}
-                  class={currentUserPubkey?.toLowerCase() !== item.authorPubkey.toLowerCase() ? 'grayscale' : ''}
-                />
-              </div>
-              <FeedPost post={item.event} />
-            {/if}
+      <div class="bookmarks-feed">
+        {#each paginatedEvents as event}
+          <div class="bookmark-card">
+            <FeedPost post={event} fullView={false} />
           </div>
         {/each}
       </div>
-
-      {#if totalPages > 1}
-        <div class="pagination pagination-bottom">
-          <button
-            class="pagination-button"
-            disabled={currentPage === 1}
-            onclick={() => {
-              if (currentPage > 1) currentPage--;
-            }}
-            aria-label="Previous page"
-          >
-            Previous
-          </button>
-          
-          <div class="pagination-info">
-            <span class="text-fog-text dark:text-fog-dark-text">
-              Page {currentPage} of {totalPages}
-            </span>
-          </div>
-          
-          <button
-            class="pagination-button"
-            disabled={currentPage === totalPages}
-            onclick={() => {
-              if (currentPage < totalPages) currentPage++;
-            }}
-            aria-label="Next page"
-          >
-            Next
-          </button>
-        </div>
-      {/if}
+      
+      {#if events.length > ITEMS_PER_PAGE}
+        <Pagination totalItems={events.length} itemsPerPage={ITEMS_PER_PAGE} />
       {/if}
     {/if}
   </div>
 </main>
 
 <style>
-  .bookmarks-page {
-    max-width: 100%;
-  }
-
-  .loading-state,
-  .empty-state,
-  .error-state {
-    padding: 2rem;
-    text-align: center;
-  }
-
-  .error-message {
-    font-weight: 600;
-    color: var(--fog-accent, #64748b);
-  }
-
-  :global(.dark) .error-message {
-    color: var(--fog-dark-accent, #94a3b8);
-  }
-
-  .bookmarks-info {
-    margin-bottom: 1rem;
-    padding: 0.5rem 0;
-  }
-
-  .bookmarks-posts {
-    display: flex;
-    flex-direction: column;
-    gap: 1rem;
-  }
-
-  .pagination {
-    display: flex;
-    align-items: center;
-    justify-content: center;
-    gap: 1rem;
-    margin-top: 2rem;
-    padding: 1rem 0;
-  }
-
-  .pagination-button {
-    padding: 0.5rem 1rem;
-    background-color: var(--fog-bg, #ffffff);
-    color: var(--fog-text, #1e293b);
-    border: 1px solid var(--fog-border, #e2e8f0);
-    border-radius: 0.375rem;
-    cursor: pointer;
-    font-size: 0.875rem;
-    transition: all 0.2s;
-  }
-
-  .pagination-button:hover:not(:disabled) {
-    background-color: var(--fog-accent, #64748b);
-    color: var(--fog-bg, #ffffff);
-    border-color: var(--fog-accent, #64748b);
+  .bookmarks-content {
+    max-width: var(--content-width);
+    margin: 0 auto;
   }
 
-  .pagination-button:disabled {
-    opacity: 0.5;
-    cursor: not-allowed;
+  .bookmarks-header {
+    padding: 0 1rem;
   }
 
-  :global(.dark) .pagination-button {
-    background-color: var(--fog-dark-bg, #0f172a);
-    color: var(--fog-dark-text, #f1f5f9);
-    border-color: var(--fog-dark-border, #334155);
-  }
-
-  :global(.dark) .pagination-button:hover:not(:disabled) {
-    background-color: var(--fog-dark-accent, #94a3b8);
-    color: var(--fog-dark-bg, #0f172a);
-    border-color: var(--fog-dark-accent, #94a3b8);
-  }
-
-  .pagination-info {
-    min-width: 100px;
+  .loading-state,
+  .error-state,
+  .empty-state {
+    padding: 2rem;
     text-align: center;
   }
 
-  .filters-section-sticky {
-    display: flex;
-    flex-direction: column;
-    gap: 1rem;
-    padding: 1rem;
-    background: var(--fog-post, #ffffff);
-    background-color: var(--fog-post, #ffffff);
-    border: 1px solid var(--fog-border, #e5e7eb);
-    border-radius: 0.5rem;
-    position: sticky;
-    top: 0;
-    z-index: 10;
-    margin-bottom: 1rem;
-    backdrop-filter: none;
-    opacity: 1;
-  }
-
-  :global(.dark) .filters-section-sticky {
-    background: var(--fog-dark-post, #1f2937);
-    background-color: var(--fog-dark-post, #1f2937);
-    border-color: var(--fog-dark-border, #374151);
-    opacity: 1;
-  }
-
-  .filters-row {
+  .bookmarks-feed {
     display: flex;
     flex-direction: column;
     gap: 1rem;
   }
 
-  .pagination-top {
-    margin-top: 0.5rem;
-    padding-top: 0.5rem;
-    border-top: 1px solid var(--fog-border, #e5e7eb);
-  }
-
-  :global(.dark) .pagination-top {
-    border-top-color: var(--fog-dark-border, #374151);
-  }
-
-  .type-filter-section {
-    display: flex;
-    align-items: center;
-    gap: 0.5rem;
-  }
-
-  .see-my-own-section {
-    display: flex;
-    align-items: center;
-    gap: 0.5rem;
-  }
-
-  .see-my-own-label {
-    display: flex;
-    align-items: center;
-    gap: 0.5rem;
-    font-size: 0.875rem;
-    color: var(--fog-text, #1f2937);
-    cursor: pointer;
-    user-select: none;
-  }
-
-  :global(.dark) .see-my-own-label {
-    color: var(--fog-dark-text, #f9fafb);
-  }
-
-  .see-my-own-checkbox {
-    width: 1rem;
-    height: 1rem;
-    cursor: pointer;
-    accent-color: var(--fog-accent, #64748b);
-  }
-
-  :global(.dark) .see-my-own-checkbox {
-    accent-color: var(--fog-dark-accent, #94a3b8);
-  }
-
-  .type-filter-label {
-    font-size: 0.875rem;
-    color: var(--fog-text, #1f2937);
-    font-weight: 500;
-  }
-
-  :global(.dark) .type-filter-label {
-    color: var(--fog-dark-text, #f9fafb);
-  }
-
-  .type-filter-select {
-    padding: 0.5rem 0.75rem;
-    border: 1px solid var(--fog-border, #e5e7eb);
-    border-radius: 0.375rem;
-    background: var(--fog-post, #ffffff);
-    color: var(--fog-text, #1f2937);
-    font-size: 0.875rem;
-    cursor: pointer;
-    min-width: 200px;
-    font-family: inherit;
-  }
-
-  .type-filter-select:focus {
-    outline: none;
-    border-color: var(--fog-accent, #64748b);
-    box-shadow: 0 0 0 3px rgba(100, 116, 139, 0.1);
-  }
-
-  :global(.dark) .type-filter-select {
-    border-color: var(--fog-dark-border, #374151);
-    background: var(--fog-dark-post, #1f2937);
-    color: var(--fog-dark-text, #f9fafb);
-  }
-
-  :global(.dark) .type-filter-select:focus {
-    border-color: var(--fog-dark-accent, #94a3b8);
-    box-shadow: 0 0 0 3px rgba(148, 163, 184, 0.1);
-  }
-
-  .search-filter-section {
-    width: 100%;
-  }
-
-  .bookmark-item-wrapper {
-    position: relative;
-  }
-
-  .bookmark-indicator-wrapper {
-    position: absolute;
-    top: 0.5rem;
-    left: 0.5rem;
-    z-index: 10;
-    pointer-events: none;
-  }
-  
-  .bookmark-item-wrapper :global(.Feed-post) {
-    padding-left: 2.5rem; /* Make room for the icon */
-  }
-
-  .bookmark-indicator-wrapper :global(.icon-wrapper) {
-    filter: grayscale(100%);
-    transition: filter 0.2s;
-  }
-
-  .bookmark-indicator-wrapper :global(.icon-wrapper:not(.grayscale)) {
-    filter: grayscale(0%);
-  }
-
-  .search-results-section {
-    margin-top: 2rem;
+  .bookmark-card {
     border: 1px solid var(--fog-border, #e5e7eb);
     border-radius: 0.5rem;
-    padding: 2rem;
-    background: var(--fog-post, #ffffff);
-  }
-
-  :global(.dark) .search-results-section {
-    border-color: var(--fog-dark-border, #374151);
-    background: var(--fog-dark-post, #1f2937);
-  }
-
-  .results-title {
-    margin: 0 0 1.5rem 0;
-    font-size: 1.25rem;
-    font-weight: 600;
-    color: var(--fog-text, #475569);
-  }
-
-  :global(.dark) .results-title {
-    color: var(--fog-dark-text, #cbd5e1);
-  }
-
-  .results-group {
-    margin-bottom: 2rem;
-  }
-
-  .results-group:last-child {
-    margin-bottom: 0;
-  }
-
-  .results-group h3 {
-    margin: 0 0 1rem 0;
-    font-size: 1rem;
-    font-weight: 500;
-    color: var(--fog-text-light, #52667a);
-  }
-
-  :global(.dark) .results-group h3 {
-    color: var(--fog-dark-text-light, #a8b8d0);
-  }
-
-  .profile-results {
-    display: flex;
-    flex-direction: column;
-    gap: 1rem;
-  }
-
-  .profile-result-card {
-    padding: 1rem;
-    border: 1px solid var(--fog-border, #e5e7eb);
-    border-radius: 0.375rem;
-    background: var(--fog-post, #ffffff);
-    text-decoration: none;
-    transition: all 0.2s;
-  }
-
-  :global(.dark) .profile-result-card {
-    border-color: var(--fog-dark-border, #374151);
-    background: var(--fog-dark-post, #1f2937);
-  }
-
-  .profile-result-card:hover {
-    border-color: var(--fog-accent, #64748b);
-    transform: translateY(-1px);
-    box-shadow: 0 2px 4px rgba(0, 0, 0, 0.1);
-  }
-
-  :global(.dark) .profile-result-card:hover {
-    border-color: var(--fog-dark-accent, #94a3b8);
-  }
-
-  .event-results {
-    display: flex;
-    flex-direction: column;
-    gap: 1rem;
-  }
-
-  .event-result-card {
-    display: block;
-    border: 1px solid var(--fog-border, #e5e7eb);
-    border-radius: 0.375rem;
     background: var(--fog-post, #ffffff);
     overflow: hidden;
-    transition: all 0.2s;
-    text-decoration: none;
-    color: inherit;
   }
 
-  :global(.dark) .event-result-card {
+  :global(.dark) .bookmark-card {
     border-color: var(--fog-dark-border, #374151);
     background: var(--fog-dark-post, #1f2937);
   }
-
-  .event-result-card:hover {
-    border-color: var(--fog-accent, #64748b);
-    transform: translateY(-1px);
-    box-shadow: 0 2px 4px rgba(0, 0, 0, 0.1);
-  }
-
-  :global(.dark) .event-result-card:hover {
-    border-color: var(--fog-dark-accent, #94a3b8);
-  }
 </style>
diff --git a/src/routes/cache/+page.svelte b/src/routes/cache/+page.svelte
index 6485b29..2e4aaf2 100644
--- a/src/routes/cache/+page.svelte
+++ b/src/routes/cache/+page.svelte
@@ -14,7 +14,7 @@
   import { getCacheStats, getAllCachedEvents, clearAllCache, clearCacheByKind, clearCacheByKinds, clearCacheByDate, deleteEventById, type CacheStats } from '../../lib/services/cache/cache-manager.js';
   import { cacheEvent } from '../../lib/services/cache/event-cache.js';
   import type { CachedEvent } from '../../lib/services/cache/event-cache.js';
-  import { getArchiveStats, clearOldArchivedEvents } from '../../lib/services/cache/event-archive.js';
+  import { getArchiveStats, clearOldArchivedEvents, recoverAllArchivedEvents, recoverArchivedEventById, isEventArchived } from '../../lib/services/cache/event-archive.js';
   import { triggerArchive } from '../../lib/services/cache/archive-scheduler.js';
   import { KIND, getKindInfo } from '../../lib/types/kind-lookup.js';
   import { nip19 } from 'nostr-tools';
@@ -42,6 +42,9 @@
   let offset = $state(0);
   const PAGE_SIZE = 50;
   let archiving = $state(false);
+  let recovering = $state(false);
+  let eventIdToRecover = $state<string>('');
+  let recoveringEvent = $state(false);
 
   // Filters
   let selectedKind = $state<number | null>(null);
@@ -107,6 +110,64 @@
     }
   }
 
+  async function handleRecoverAllArchived() {
+    if (!confirm('Are you sure you want to recover all archived events? This will restore them to the main cache.')) {
+      return;
+    }
+
+    recovering = true;
+    try {
+      const recovered = await recoverAllArchivedEvents();
+      await loadStats();
+      await loadArchiveStats();
+      await loadEvents(true);
+      alert(`Recovered ${recovered} archived events. They are now back in the main cache.`);
+    } catch (error) {
+      alert('Failed to recover archived events');
+    } finally {
+      recovering = false;
+    }
+  }
+
+  async function handleRecoverEventById() {
+    if (!eventIdToRecover.trim()) {
+      alert('Please enter an event ID');
+      return;
+    }
+
+    // Decode bech32 if needed
+    const hexId = decodeEventIdToHex(eventIdToRecover.trim());
+    if (!hexId) {
+      alert('Invalid event ID format');
+      return;
+    }
+
+    // Check if event is archived
+    const isArchived = await isEventArchived(hexId);
+    if (!isArchived) {
+      alert('Event not found in archive. It may already be in the main cache or may not exist.');
+      return;
+    }
+
+    recoveringEvent = true;
+    try {
+      const recovered = await recoverArchivedEventById(hexId);
+      if (recovered) {
+        await loadStats();
+        await loadArchiveStats();
+        await loadEvents(true);
+        alert('Event recovered successfully. It is now back in the main cache.');
+        eventIdToRecover = '';
+      } else {
+        alert('Failed to recover event');
+      }
+    } catch (error) {
+      alert('Failed to recover event');
+    } finally {
+      recoveringEvent = false;
+    }
+  }
+
   async function loadEvents(reset = false) {
     if (reset) {
       offset = 0;
@@ -621,7 +682,7 @@
             </p>
             {#if archiveStats.oldestArchived}
               <p>
-                <strong>Oldest Archived:</strong> {new Date(archiveStats.oldestArchived).toLocaleDateString()}
+                <strong>Oldest Archived:</strong> {new Date(archiveStats.oldestArchived * 1000).toLocaleDateString()}
               </p>
             {/if}
           </div>
@@ -633,6 +694,13 @@
             >
               {archiving ? 'Archiving...' : 'Archive Events Older Than 30 Days'}
             </button>
+            <button 
+              class="bulk-action-button" 
+              onclick={handleRecoverAllArchived}
+              disabled={recovering}
+            >
+              {recovering ? 'Recovering...' : 'Recover All Archived Events'}
+            </button>
             <button 
               class="bulk-action-button" 
               onclick={() => handleClearOldArchived(365)}
@@ -640,6 +708,28 @@
               Clear Archived Events Older Than 1 Year
             </button>
           </div>
+          <div class="recover-event-section">
+            <h3>Recover Individual Event</h3>
+            <div class="recover-event-input-group">
+              <input
+                type="text"
+                bind:value={eventIdToRecover}
+                placeholder="Enter event ID (hex, nevent, note)..."
+                class="filter-input"
+                onkeydown={(e) => e.key === 'Enter' && handleRecoverEventById()}
+              />
+              <button 
+                class="bulk-action-button" 
+                onclick={handleRecoverEventById}
+                disabled={recoveringEvent || !eventIdToRecover.trim()}
+              >
+                {recoveringEvent ? 'Recovering...' : 'Recover Event'}
+              </button>
+            </div>
+            <p class="archive-note">
+              Enter an event ID to check if it's archived and recover it to the main cache.
+            </p>
+          </div>
           <p class="archive-note">
             Archived events are compressed to save space but remain accessible. 
             They are automatically decompressed when needed.
@@ -873,6 +963,38 @@
     color: var(--fog-dark-text-light, #a8b8d0);
   }
 
+  .recover-event-section {
+    margin-top: 1.5rem;
+    padding-top: 1.5rem;
+    border-top: 1px solid var(--fog-border, #e5e7eb);
+  }
+
+  :global(.dark) .recover-event-section {
+    border-top-color: var(--fog-dark-border, #475569);
+  }
+
+  .recover-event-section h3 {
+    margin: 0 0 1rem 0;
+    font-size: 1.1em;
+    color: var(--fog-text, #1f2937);
+  }
+
+  :global(.dark) .recover-event-section h3 {
+    color: var(--fog-dark-text, #f9fafb);
+  }
+
+  .recover-event-input-group {
+    display: flex;
+    gap: 0.75rem;
+    align-items: flex-start;
+    flex-wrap: wrap;
+  }
+
+  .recover-event-input-group .filter-input {
+    flex: 1;
+    min-width: 250px;
+  }
+
   .bulk-actions-section,
   .events-section {
     margin-bottom: 2rem;
diff --git a/src/routes/find/+page.svelte b/src/routes/find/+page.svelte
index 051e611..d8ac3d2 100644
--- a/src/routes/find/+page.svelte
+++ b/src/routes/find/+page.svelte
@@ -1,25 +1,26 @@
 <script lang="ts">
   import Header from '../../lib/components/layout/Header.svelte';
-  import UnifiedSearch from '../../lib/components/layout/UnifiedSearch.svelte';
+  import NormalSearch from '../../lib/components/find/NormalSearch.svelte';
+  import AdvancedSearch from '../../lib/components/find/AdvancedSearch.svelte';
+  import SearchAddressableEvents from '../../lib/components/find/SearchAddressableEvents.svelte';
   import FeedPost from '../../lib/modules/feed/FeedPost.svelte';
   import ProfileBadge from '../../lib/components/layout/ProfileBadge.svelte';
   import RelayBadge from '../../lib/components/layout/RelayBadge.svelte';
   import CacheBadge from '../../lib/components/layout/CacheBadge.svelte';
-  import { KIND, KIND_LOOKUP } from '../../lib/types/kind-lookup.js';
   import { nostrClient } from '../../lib/services/nostr/nostr-client.js';
-  import { relayManager } from '../../lib/services/nostr/relay-manager.js';
   import type { NostrEvent } from '../../lib/types/nostr.js';
   import { onMount } from 'svelte';
   import { page } from '$app/stores';
-  import { nip19 } from 'nostr-tools';
   import Pagination from '../../lib/components/ui/Pagination.svelte';
   import { getPaginatedItems, getCurrentPage, ITEMS_PER_PAGE } from '../../lib/utils/pagination.js';
 
-  let selectedKind = $state<number | null>(null);
-  let selectedKindString = $state<string>('');
-  let unifiedSearchComponent: { triggerSearch: () => void; getFilterResult: () => { type: 'event' | 'pubkey' | 'text' | null; value: string | null; kind?: number | null }; clearSearch: () => void } | null = $state(null);
+  let normalSearchComponent: { clearSearch: () => void; getSearchResults: () => { events: NostrEvent[]; profiles: string[] } } | null = $state(null);
+  let advancedSearchComponent: { clearSearch: () => void; getSearchResults: () => { events: NostrEvent[]; profiles: string[] } } | null = $state(null);
+  
+  // Combined results from both search types
   let searchResults = $state<{ events: NostrEvent[]; profiles: string[]; relays?: string[] }>({ events: [], profiles: [] });
   let cacheResults = $state<{ events: NostrEvent[]; profiles: string[] }>({ events: [], profiles: [] });
+  
   // Map to track which relay each event came from
   const eventRelayMap = new Map<string, string>();
   
@@ -35,703 +36,53 @@
       ? getPaginatedItems(searchResults.events, currentPage, ITEMS_PER_PAGE)
       : searchResults.events
   );
-  let searching = $state(false);
-  let searchTimeout: ReturnType<typeof setTimeout> | null = $state(null);
-  
-  // NIP-01 standard filter controls
-  let filterIds = $state<string>(''); // Comma-separated event IDs
-  let filterAuthors = $state<string>(''); // Comma-separated pubkeys
-  let filterKinds = $state<string>(''); // Comma-separated kind numbers
-  let filterE = $state<string>(''); // Comma-separated event IDs for #e tag
-  let filterP = $state<string>(''); // Comma-separated pubkeys for #p tag
-  let filterA = $state<string>(''); // Comma-separated addressable event refs for #a tag
-  let filterQ = $state<string>(''); // Comma-separated event IDs for #q tag (quoted events)
-  let filterT = $state<string>(''); // Comma-separated topic values for #T tag
-  let filterC = $state<string>(''); // Comma-separated category values for #C tag
-  let filterD = $state<string>(''); // Comma-separated d-tag values for #d tag
-  let filterSince = $state<string>(''); // Date-time string (will be converted to unix timestamp)
-  let filterUntil = $state<string>(''); // Date-time string (will be converted to unix timestamp)
-  let filterLimit = $state<number>(100); // Limit number
-  let showAdvancedFilters = $state(false); // Toggle for showing advanced filters
   
   // Check if there are any active searches or results
   const hasActiveSearch = $derived.by(() => {
-    if (searching) return true;
     if (searchResults.events.length > 0 || searchResults.profiles.length > 0) return true;
     if (cacheResults.events.length > 0 || cacheResults.profiles.length > 0) return true;
-    const component = unifiedSearchComponent;
-    if (component) {
-      const filterResult = component.getFilterResult();
-      if (filterResult.value !== null) return true;
-    }
     return false;
   });
 
-  // Sync selectedKindString with selectedKind
-  $effect(() => {
-    selectedKindString = selectedKind?.toString() || '';
-  });
-
-  // Sync selectedKind with selectedKindString when it changes
-  $effect(() => {
-    if (selectedKindString === '') {
-      selectedKind = null;
-    } else {
-      const parsed = parseInt(selectedKindString);
-      if (!isNaN(parsed)) {
-        selectedKind = parsed;
-      }
-    }
-  });
-
-  function handleKindChange(e: Event) {
-    const select = e.target as HTMLSelectElement;
-    selectedKindString = select.value;
-  }
-
-  // Helper function to decode bech32 to hex (for pubkeys and event IDs)
-  async function decodeBech32ToHex(bech32: string, type: 'pubkey' | 'event'): Promise<string | null> {
-    try {
-      // Check if it's a bech32 format
-      if (!/^(npub|nprofile|note|nevent|naddr)1[a-z0-9]+$/i.test(bech32)) {
-        return null;
-      }
-      
-      const decoded = nip19.decode(bech32);
-      
-      if (type === 'pubkey') {
-        if (decoded.type === 'npub') {
-          return String(decoded.data).toLowerCase();
-        } else if (decoded.type === 'nprofile') {
-          if (decoded.data && typeof decoded.data === 'object' && 'pubkey' in decoded.data) {
-            return String(decoded.data.pubkey).toLowerCase();
-          }
-        } else if (decoded.type === 'naddr') {
-          if (decoded.data && typeof decoded.data === 'object' && 'pubkey' in decoded.data) {
-            return String(decoded.data.pubkey).toLowerCase();
-          }
-        }
-      } else if (type === 'event') {
-        if (decoded.type === 'note') {
-          return String(decoded.data).toLowerCase();
-        } else if (decoded.type === 'nevent') {
-          if (decoded.data && typeof decoded.data === 'object' && 'id' in decoded.data) {
-            return String(decoded.data.id).toLowerCase();
-          }
-        }
-      }
-    } catch (error) {
-      // Not a valid bech32, return null
-      console.debug('Error decoding bech32:', error);
-    }
-    return null;
-  }
-
-  // Helper function to parse comma-separated values and validate hex strings
-  // Also decodes bech32 formats (npub, nprofile, note, nevent)
-  async function parseHexList(input: string, type: 'pubkey' | 'event' = 'event'): Promise<string[]> {
-    const results: string[] = [];
-    const parts = input.split(',').map(s => s.trim()).filter(s => s.length > 0);
-    
-    for (const part of parts) {
-      // Check if it's already a hex string
-      if (/^[0-9a-f]{64}$/i.test(part)) {
-        results.push(part.toLowerCase());
-      } else {
-        // Try to decode as bech32
-        const decoded = await decodeBech32ToHex(part, type);
-        if (decoded) {
-          results.push(decoded);
-        }
-      }
-    }
-    
-    return results;
-  }
-  
-  // Helper function to parse comma-separated numbers
-  function parseNumberList(input: string): number[] {
-    return input
-      .split(',')
-      .map(s => parseInt(s.trim(), 10))
-      .filter(n => !isNaN(n) && n >= 0 && n <= 65535);
-  }
-  
-  // Helper function to parse comma-separated addressable event refs (kind:pubkey:d-tag)
-  // Also decodes bech32 formats in the pubkey part (npub, nprofile, naddr)
-  async function parseAddressableList(input: string): Promise<string[]> {
-    const results: string[] = [];
-    const parts = input.split(',').map(s => s.trim()).filter(s => s.length > 0);
-    
-    for (const part of parts) {
-      // Check if it matches the addressable format: kind:pubkey:d-tag or kind:pubkey:
-      const match = part.match(/^(\d+):([^:]+)(?::(.+))?$/);
-      if (match) {
-        const [, kind, pubkeyPart, dTag] = match;
-        let hexPubkey: string | null = null;
-        
-        // Check if pubkey part is already hex
-        if (/^[0-9a-f]{64}$/i.test(pubkeyPart)) {
-          hexPubkey = pubkeyPart.toLowerCase();
-        } else {
-          // Try to decode as bech32
-          hexPubkey = await decodeBech32ToHex(pubkeyPart, 'pubkey');
-        }
-        
-        if (hexPubkey) {
-          // Reconstruct the addressable format
-          if (dTag) {
-            results.push(`${kind}:${hexPubkey}:${dTag}`);
-          } else {
-            results.push(`${kind}:${hexPubkey}:`);
-          }
-        }
-      }
-    }
-    
-    return results;
-  }
-  
-  // Helper function to convert date-time string to unix timestamp
-  // Accepts ISO 8601 format (e.g., "2024-01-15T14:30:00Z" or "2024-01-15T14:30:00+05:00")
-  // Also accepts unix timestamp as fallback
-  function dateTimeToUnixTimestamp(dateTimeStr: string): number | null {
-    if (!dateTimeStr.trim()) return null;
-    
-    try {
-      // Try parsing as ISO 8601 date-time string (supports timezone)
-      const date = new Date(dateTimeStr.trim());
-      
-      // Check if date is valid
-      if (isNaN(date.getTime())) {
-        // If ISO parsing fails, try as unix timestamp (backward compatibility)
-        const timestamp = parseInt(dateTimeStr.trim(), 10);
-        if (!isNaN(timestamp) && timestamp > 0) {
-          return timestamp;
-        }
-        return null;
-      }
-      
-      // Convert to unix timestamp (seconds)
-      return Math.floor(date.getTime() / 1000);
-    } catch (error) {
-      // If parsing fails, try as unix timestamp (backward compatibility)
-      const timestamp = parseInt(dateTimeStr.trim(), 10);
-      if (!isNaN(timestamp) && timestamp > 0) {
-        return timestamp;
-      }
-      return null;
-    }
-  }
-  
-  // Build NIP-01 filter from form inputs
-  async function buildFilter(): Promise<any> {
-    const filter: any = {};
-    
-    // ids filter (event IDs)
-    if (filterIds.trim()) {
-      const ids = await parseHexList(filterIds, 'event');
-      if (ids.length > 0) {
-        filter.ids = ids;
-      }
-    }
-    
-    // authors filter (pubkeys)
-    if (filterAuthors.trim()) {
-      const authors = await parseHexList(filterAuthors, 'pubkey');
-      if (authors.length > 0) {
-        filter.authors = authors;
-      }
-    }
-    
-    // kinds filter - prioritize advanced filter, then selectedKind, then all kinds
-    if (filterKinds.trim()) {
-      const kinds = parseNumberList(filterKinds);
-      if (kinds.length > 0) {
-        filter.kinds = kinds;
-      }
-    } else if (selectedKind !== null) {
-      filter.kinds = [selectedKind];
-    }
-    
-    // #e tag filter (event IDs)
-    if (filterE.trim()) {
-      const eTags = await parseHexList(filterE, 'event');
-      if (eTags.length > 0) {
-        filter['#e'] = eTags;
-      }
-    }
-    
-    // #p tag filter (pubkeys)
-    if (filterP.trim()) {
-      const pTags = await parseHexList(filterP, 'pubkey');
-      if (pTags.length > 0) {
-        filter['#p'] = pTags;
-      }
-    }
-    
-    // #a tag filter (addressable events)
-    if (filterA.trim()) {
-      const aTags = await parseAddressableList(filterA);
-      if (aTags.length > 0) {
-        filter['#a'] = aTags;
-      }
-    }
-    
-    // #q tag filter (quoted events - event IDs)
-    if (filterQ.trim()) {
-      const qTags = await parseHexList(filterQ, 'event');
-      if (qTags.length > 0) {
-        filter['#q'] = qTags;
-      }
-    }
-    
-    // #T tag filter (topics)
-    if (filterT.trim()) {
-      const tTags = filterT
-        .split(',')
-        .map(s => s.trim())
-        .filter(s => s.length > 0);
-      if (tTags.length > 0) {
-        filter['#T'] = tTags;
-      }
-    }
-    
-    // #C tag filter (categories)
-    if (filterC.trim()) {
-      const cTags = filterC
-        .split(',')
-        .map(s => s.trim())
-        .filter(s => s.length > 0);
-      if (cTags.length > 0) {
-        filter['#C'] = cTags;
-      }
-    }
-    
-    // #d tag filter (d-tags for addressable events)
-    if (filterD.trim()) {
-      const dTags = filterD
-        .split(',')
-        .map(s => s.trim())
-        .filter(s => s.length > 0);
-      if (dTags.length > 0) {
-        filter['#d'] = dTags;
-      }
-    }
-    
-    // since filter - convert date-time to unix timestamp
-    if (filterSince.trim()) {
-      const since = dateTimeToUnixTimestamp(filterSince);
-      if (since !== null && since > 0) {
-        filter.since = since;
-      }
-    }
-    
-    // until filter - convert date-time to unix timestamp
-    if (filterUntil.trim()) {
-      const until = dateTimeToUnixTimestamp(filterUntil);
-      if (until !== null && until > 0) {
-        filter.until = until;
-      }
-    }
-    
-    // limit filter
-    if (filterLimit > 0) {
-      filter.limit = filterLimit;
-    } else {
-      filter.limit = 100; // Default limit
-    }
-    
-    return filter;
-  }
-
-  // Check if any advanced filters are set (including selectedKind)
-  function hasAdvancedFilters(): boolean {
-    return !!(
-      selectedKind !== null ||
-      filterIds.trim() ||
-      filterAuthors.trim() ||
-      filterKinds.trim() ||
-      filterE.trim() ||
-      filterP.trim() ||
-      filterA.trim() ||
-      filterQ.trim() ||
-      filterT.trim() ||
-      filterC.trim() ||
-      filterD.trim() ||
-      filterSince.trim() ||
-      filterUntil.trim() ||
-      filterLimit !== 100
-    );
-  }
-  
-  // Check if there's any input (search term, kind, or advanced filters)
-  const hasAnyInput = $derived.by(() => {
-    if (!unifiedSearchComponent) return false;
-    const filterResult = unifiedSearchComponent.getFilterResult();
-    const hasSearchTerm = !!(filterResult.value && filterResult.value.trim());
-    return hasSearchTerm || hasAdvancedFilters();
-  });
-
-  async function handleSearch() {
-    if (!unifiedSearchComponent) return;
-    
-    // Clear previous timeout
-    if (searchTimeout) {
-      clearTimeout(searchTimeout);
-      searchTimeout = null;
-    }
-    
-    const filterResult = unifiedSearchComponent.getFilterResult();
-    const searchTerm = filterResult.value?.trim() || '';
-    const hasAdvanced = hasAdvancedFilters();
-    
-    // If no search term, use NIP-01 filters
-    if (!searchTerm) {
-      searching = true;
-      
-      try {
-        await nostrClient.initialize();
-        const relays = relayManager.getAllAvailableRelays();
-        const newEventRelayMap = new Map<string, string>();
-        
-        // Build filter from form inputs
-        const filter = await buildFilter();
-        
-        // If no filter conditions at all, default to all kinds with limit
-        if (Object.keys(filter).length === 1 && filter.limit) {
-          // Only limit specified, get all kinds
-          const allKindNumbers = Object.values(KIND_LOOKUP).map(k => k.number);
-          // Split into chunks to avoid too large filters
-          const chunkSize = 10;
-          const filters: any[] = [];
-          for (let i = 0; i < allKindNumbers.length; i += chunkSize) {
-            const chunk = allKindNumbers.slice(i, i + chunkSize);
-            filters.push({ kinds: chunk, limit: filter.limit });
-          }
-          
-          // Fetch events
-          const allEvents: NostrEvent[] = [];
-          for (const f of filters) {
-            const events = await nostrClient.fetchEvents(
-              [f],
-              relays,
-              { useCache: true, cacheResults: true }
-            );
-            
-            for (const event of events) {
-              if (!newEventRelayMap.has(event.id)) {
-                newEventRelayMap.set(event.id, relays[0] || 'unknown');
-              }
-              allEvents.push(event);
-            }
-          }
-          
-          // Deduplicate and sort
-          const uniqueEvents = Array.from(
-            new Map(allEvents.map(e => [e.id, e])).values()
-          ).sort((a, b) => b.created_at - a.created_at);
-          
-          const limitedEvents = uniqueEvents.slice(0, filter.limit);
-          
-          // Update eventRelayMap
-          eventRelayMap.clear();
-          for (const [eventId, relay] of newEventRelayMap) {
-            eventRelayMap.set(eventId, relay);
-          }
-          
-          // Update results
-          searchResults = {
-            events: limitedEvents,
-            profiles: [],
-            relays: relays
-          };
-        } else {
-          // Use the built filter
-          const events = await nostrClient.fetchEvents(
-            [filter],
-            relays,
-            { useCache: true, cacheResults: true }
-          );
-          
-          // Track which relay each event came from
-          for (const event of events) {
-            if (!newEventRelayMap.has(event.id)) {
-              newEventRelayMap.set(event.id, relays[0] || 'unknown');
-            }
-          }
-          
-          // Update eventRelayMap
-          eventRelayMap.clear();
-          for (const [eventId, relay] of newEventRelayMap) {
-            eventRelayMap.set(eventId, relay);
-          }
-          
-          // Update results
-          searchResults = {
-            events: events,
-            profiles: [],
-            relays: relays
-          };
-        }
-        
-        searching = false;
-      } catch (error) {
-        // Search failed
-        searching = false;
-        searchResults = { events: [], profiles: [], relays: [] };
-      }
-    } else {
-      // Has search term - always combine with filters (kind dropdown + advanced filters)
-      searching = true;
-      
-      try {
-        await nostrClient.initialize();
-        const relays = relayManager.getAllAvailableRelays();
-        const newEventRelayMap = new Map<string, string>();
-        
-        // Build filter from all form inputs (includes selectedKind and advanced filters)
-        const filter = await buildFilter();
-        
-        // Decode bech32 formats in search term and add to filter
-        let decodedPubkey: string | null = null;
-        let decodedEventId: string | null = null;
-        
-        // Check if search term is a bech32 format (npub, nprofile, note, nevent, naddr)
-        if (/^(npub|nprofile|note|nevent|naddr)1[a-z0-9]+$/i.test(searchTerm)) {
-          try {
-            const decoded = nip19.decode(searchTerm);
-            
-            if (decoded.type === 'npub') {
-              decodedPubkey = String(decoded.data).toLowerCase();
-            } else if (decoded.type === 'nprofile') {
-              if (decoded.data && typeof decoded.data === 'object' && 'pubkey' in decoded.data) {
-                decodedPubkey = String(decoded.data.pubkey).toLowerCase();
-              }
-            } else if (decoded.type === 'note') {
-              decodedEventId = String(decoded.data).toLowerCase();
-            } else if (decoded.type === 'nevent') {
-              if (decoded.data && typeof decoded.data === 'object' && 'id' in decoded.data) {
-                decodedEventId = String(decoded.data.id).toLowerCase();
-              }
-            } else if (decoded.type === 'naddr') {
-              // naddr encodes kind + pubkey + d tag, we can extract pubkey
-              if (decoded.data && typeof decoded.data === 'object' && 'pubkey' in decoded.data) {
-                decodedPubkey = String(decoded.data.pubkey).toLowerCase();
-              }
-            }
-          } catch (error) {
-            // Not a valid bech32, continue with text search
-            // Invalid bech32 format
-          }
-        }
-        
-        // Check if search term is a hex string (64 hex chars)
-        // Could be event ID or pubkey
-        if (!decodedPubkey && !decodedEventId && /^[0-9a-f]{64}$/i.test(searchTerm)) {
-          // Try to get event from cache first to determine if it's an event ID
-          const { getEvent } = await import('../../lib/services/cache/event-cache.js');
-          const hexLower = searchTerm.toLowerCase();
-          const cachedEvent = await getEvent(hexLower);
-          
-          if (cachedEvent) {
-            // It's an event ID
-            decodedEventId = hexLower;
-          } else {
-            // Assume it's a pubkey (more common in searches)
-            decodedPubkey = hexLower;
-          }
-        }
-        
-        // Add decoded pubkey to authors filter
-        if (decodedPubkey) {
-          if (filter.authors) {
-            // Add to existing authors if not already present
-            const authors = Array.isArray(filter.authors) ? filter.authors : [filter.authors];
-            if (!authors.includes(decodedPubkey)) {
-              filter.authors = [...authors, decodedPubkey];
-            }
-          } else {
-            filter.authors = [decodedPubkey];
-          }
-        }
-        
-        // Add decoded event ID to ids filter
-        if (decodedEventId) {
-          if (filter.ids) {
-            // Add to existing ids if not already present
-            const ids = Array.isArray(filter.ids) ? filter.ids : [filter.ids];
-            if (!ids.includes(decodedEventId)) {
-              filter.ids = [...ids, decodedEventId];
-            }
-          } else {
-            filter.ids = [decodedEventId];
-          }
-        }
-        
-        // Check if filter has meaningful conditions (not just limit)
-        const hasFilterConditions = Object.keys(filter).length > 1 || 
-                                   (filter.kinds && filter.kinds.length > 0) ||
-                                   filter.ids || filter.authors || filter['#e'] || filter['#p'] || 
-                                   filter['#a'] || filter['#q'] || filter['#T'] || filter['#C'] || 
-                                   filter['#d'] || filter.since || filter.until;
-        
-        let eventsToSearch: NostrEvent[] = [];
-        
-        if (hasFilterConditions) {
-          // Has filter conditions, use them
-          eventsToSearch = await nostrClient.fetchEvents(
-            [filter],
-            relays,
-            { useCache: true, cacheResults: true }
-          );
-        } else {
-          // No filters at all, fall back to UnifiedSearch for better text search
-          unifiedSearchComponent.triggerSearch();
-          searchTimeout = setTimeout(() => {
-            searching = false;
-            searchTimeout = null;
-          }, 10000);
-          return;
-        }
-        
-        // If we decoded a pubkey or event ID, we already filtered by that, so just return those events
-        // Otherwise, filter by text content client-side
-        let filteredEvents: NostrEvent[] = [];
-        
-        if (decodedPubkey || decodedEventId) {
-          // Already filtered by pubkey/event ID, use results as-is
-          filteredEvents = eventsToSearch;
-        } else {
-          // Filter by text content client-side
-          const queryLower = searchTerm.toLowerCase();
-          filteredEvents = eventsToSearch.filter(event => {
-            // Check content
-            if (event.content.toLowerCase().includes(queryLower)) return true;
-            
-            // Check title tag
-            const titleTag = event.tags.find(t => t[0] === 'title');
-            if (titleTag?.[1]?.toLowerCase().includes(queryLower)) return true;
-            
-            // Check summary tag
-            const summaryTag = event.tags.find(t => t[0] === 'summary');
-            if (summaryTag?.[1]?.toLowerCase().includes(queryLower)) return true;
-            
-            // Check if search term matches event ID or pubkey
-            if (event.id.toLowerCase().includes(queryLower)) return true;
-            if (event.pubkey.toLowerCase().includes(queryLower)) return true;
-            
-            return false;
-          });
-        }
-        
-        // Sort by relevance (exact content match first, then by created_at)
-        // Only do text-based sorting if we didn't decode a pubkey/event ID
-        const sortedEvents = decodedPubkey || decodedEventId
-          ? filteredEvents.sort((a, b) => b.created_at - a.created_at)
-          : filteredEvents.sort((a, b) => {
-              const queryLower = searchTerm.toLowerCase();
-              const aExact = a.content.toLowerCase() === queryLower;
-              const bExact = b.content.toLowerCase() === queryLower;
-              if (aExact && !bExact) return -1;
-              if (!aExact && bExact) return 1;
-              return b.created_at - a.created_at;
-            });
-        
-        // Track which relay each event came from
-        for (const event of sortedEvents) {
-          if (!newEventRelayMap.has(event.id)) {
-            newEventRelayMap.set(event.id, relays[0] || 'unknown');
-          }
-        }
-        
-        // Update eventRelayMap
-        eventRelayMap.clear();
-        for (const [eventId, relay] of newEventRelayMap) {
-          eventRelayMap.set(eventId, relay);
-        }
-        
-        // Update results
-        searchResults = {
-          events: sortedEvents,
-          profiles: [],
-          relays: relays
-        };
-        
-        searching = false;
-      } catch (error) {
-        // Search failed
-        searching = false;
-        searchResults = { events: [], profiles: [], relays: [] };
-      }
-    }
-  }
-
-  function handleSearchResults(results: { events: NostrEvent[]; profiles: string[]; relays?: string[]; eventRelays?: Map<string, string> }) {
-    // Check if these are cache-only results (no relays or all events from cache)
+  function handleNormalSearchResults(results: { events: NostrEvent[]; profiles: string[]; relays?: string[]; eventRelays?: Map<string, string> }) {
+    // Check if these are cache-only results
     const isCacheOnly = !results.relays || results.relays.length === 0 || 
                        (results.eventRelays && Array.from(results.eventRelays.values()).every(r => r === 'cache'));
     
     if (isCacheOnly) {
-      // These are cache results
       cacheResults = { events: results.events, profiles: results.profiles };
     } else {
-      // These are relay results (from button click)
       searchResults = results;
       
-      // Update eventRelayMap with relay information from results
       if (results.eventRelays) {
         for (const [eventId, relay] of results.eventRelays) {
           eventRelayMap.set(eventId, relay);
         }
       }
-      
-      // Clear timeout when results arrive (search is complete)
-      if (searchTimeout) {
-        clearTimeout(searchTimeout);
-        searchTimeout = null;
-        searching = false;
-      }
     }
   }
 
-  // Get all kinds for dropdown (sorted by number)
-  const allKinds = Object.values(KIND_LOOKUP).sort((a, b) => a.number - b.number);
+  function handleAdvancedSearchResults(results: { events: NostrEvent[]; profiles: string[]; relays?: string[]; eventRelays?: Map<string, string> }) {
+    searchResults = results;
+    
+    if (results.eventRelays) {
+      for (const [eventId, relay] of results.eventRelays) {
+        eventRelayMap.set(eventId, relay);
+      }
+    }
+  }
 
   function clearAllSearches() {
-    // Clear UnifiedSearch
-    if (unifiedSearchComponent) {
-      unifiedSearchComponent.clearSearch();
+    if (normalSearchComponent) {
+      normalSearchComponent.clearSearch();
+    }
+    if (advancedSearchComponent) {
+      advancedSearchComponent.clearSearch();
     }
     
-    // Clear local state
     searchResults = { events: [], profiles: [] };
     cacheResults = { events: [], profiles: [] };
     eventRelayMap.clear();
-    searching = false;
-    selectedKind = null;
-    selectedKindString = '';
-    
-    // Clear filter inputs
-    filterIds = '';
-    filterAuthors = '';
-    filterKinds = '';
-    filterE = '';
-    filterP = '';
-    filterA = '';
-    filterQ = '';
-    filterT = '';
-    filterC = '';
-    filterD = '';
-    filterSince = '';
-    filterUntil = '';
-    filterLimit = 100;
-    
-    // Clear timeouts
-    if (searchTimeout) {
-      clearTimeout(searchTimeout);
-      searchTimeout = null;
-    }
   }
   
 
@@ -745,8 +96,8 @@
 <main class="container mx-auto px-4 py-8">
   <div class="find-page">
     <div class="page-header">
-      <h1 class="font-bold mb-6 text-fog-text dark:text-fog-dark-text font-mono" style="font-size: 1.5em;">/Find</h1>
-      {#if hasAnyInput}
+      <h1 class="page-title font-bold mb-4 text-fog-text dark:text-fog-dark-text font-mono">/Find</h1>
+      {#if hasActiveSearch}
         <button 
           class="clear-button"
           onclick={clearAllSearches}
@@ -759,209 +110,21 @@
     
     <div class="find-sections">
       <section class="find-section">
-        <h2>Search Events</h2>
-        <p class="section-description">Search for events by ID, pubkey, NIP-05, or content. Use the kind filter to narrow results.</p>
-        
-        <div class="search-container">
-          <div class="search-bar-wrapper">
-            <UnifiedSearch 
-              mode="search" 
-              bind:this={unifiedSearchComponent}
-              selectedKind={selectedKind}
-              hideDropdownResults={true}
-              onSearchResults={handleSearchResults}
-              placeholder="Search events, profiles, pubkeys, or enter event ID..." 
-            />
-          </div>
-          
-          <div class="filter-and-button-wrapper">
-            <div class="kind-filter-wrapper">
-              <label for="kind-filter" class="kind-filter-label">Filter by Kind:</label>
-              <select
-                id="kind-filter"
-                bind:value={selectedKindString}
-                onchange={handleKindChange}
-                class="kind-filter-select"
-                aria-label="Filter by kind"
-              >
-                <option value="">All Kinds</option>
-                {#each allKinds as kindInfo}
-                  <option value={kindInfo.number}>{kindInfo.number}: {kindInfo.description}</option>
-                {/each}
-              </select>
-            </div>
-            
-            <button 
-              class="search-button"
-              onclick={handleSearch}
-              disabled={searching}
-              aria-label="Search"
-            >
-              {searching ? 'Searching...' : 'Search'}
-            </button>
-          </div>
-          
-          <div class="advanced-filters-section">
-            <button
-              type="button"
-              class="toggle-advanced-filters"
-              onclick={() => showAdvancedFilters = !showAdvancedFilters}
-              aria-label="Toggle advanced filters"
-            >
-              {showAdvancedFilters ? '▼' : '▶'} Advanced Filters (NIP-01)
-            </button>
-            
-            {#if showAdvancedFilters}
-              <div class="advanced-filters-grid">
-                <div class="filter-group">
-                  <label for="filter-ids" class="filter-label">IDs (comma-separated event IDs):</label>
-                  <input
-                    id="filter-ids"
-                    type="text"
-                    bind:value={filterIds}
-                    placeholder="64-char hex event IDs"
-                    class="filter-input"
-                  />
-                </div>
-                
-                <div class="filter-group">
-                  <label for="filter-authors" class="filter-label">Authors (comma-separated pubkeys):</label>
-                  <input
-                    id="filter-authors"
-                    type="text"
-                    bind:value={filterAuthors}
-                    placeholder="64-char hex pubkeys"
-                    class="filter-input"
-                  />
-                </div>
-                
-                <div class="filter-group">
-                  <label for="filter-kinds" class="filter-label">Kinds (comma-separated, overrides kind dropdown):</label>
-                  <input
-                    id="filter-kinds"
-                    type="text"
-                    bind:value={filterKinds}
-                    placeholder="e.g., 1, 7, 11"
-                    class="filter-input"
-                  />
-                </div>
-                
-                <div class="filter-group">
-                  <label for="filter-e" class="filter-label">#e tag (comma-separated event IDs):</label>
-                  <input
-                    id="filter-e"
-                    type="text"
-                    bind:value={filterE}
-                    placeholder="64-char hex event IDs"
-                    class="filter-input"
-                  />
-                </div>
-                
-                <div class="filter-group">
-                  <label for="filter-p" class="filter-label">#p tag (comma-separated pubkeys):</label>
-                  <input
-                    id="filter-p"
-                    type="text"
-                    bind:value={filterP}
-                    placeholder="64-char hex pubkeys"
-                    class="filter-input"
-                  />
-                </div>
-                
-                <div class="filter-group">
-                  <label for="filter-a" class="filter-label">#a tag (comma-separated addressable refs):</label>
-                  <input
-                    id="filter-a"
-                    type="text"
-                    bind:value={filterA}
-                    placeholder="kind:pubkey:d-tag"
-                    class="filter-input"
-                  />
-                </div>
-                
-                <div class="filter-group">
-                  <label for="filter-q" class="filter-label">#q tag (comma-separated quoted event IDs):</label>
-                  <input
-                    id="filter-q"
-                    type="text"
-                    bind:value={filterQ}
-                    placeholder="64-char hex event IDs"
-                    class="filter-input"
-                  />
-                </div>
-                
-                <div class="filter-group">
-                  <label for="filter-t" class="filter-label">#T tag (comma-separated topics):</label>
-                  <input
-                    id="filter-t"
-                    type="text"
-                    bind:value={filterT}
-                    placeholder="topic1, topic2, topic3"
-                    class="filter-input"
-                  />
-                </div>
-                
-                <div class="filter-group">
-                  <label for="filter-c" class="filter-label">#C tag (comma-separated categories):</label>
-                  <input
-                    id="filter-c"
-                    type="text"
-                    bind:value={filterC}
-                    placeholder="category1, category2, category3"
-                    class="filter-input"
-                  />
-                </div>
-                
-                <div class="filter-group">
-                  <label for="filter-d" class="filter-label">#d tag (comma-separated d-tag values):</label>
-                  <input
-                    id="filter-d"
-                    type="text"
-                    bind:value={filterD}
-                    placeholder="d-tag1, d-tag2, d-tag3"
-                    class="filter-input"
-                  />
-                </div>
-                
-                <div class="filter-group">
-                  <label for="filter-since" class="filter-label">Since (date-time or unix timestamp):</label>
-                  <input
-                    id="filter-since"
-                    type="text"
-                    bind:value={filterSince}
-                    placeholder="2024-01-15T14:30:00Z or unix timestamp"
-                    class="filter-input"
-                  />
-                  <small class="filter-hint">Accepts ISO 8601 format (e.g., 2024-01-15T14:30:00Z, 2024-01-15T14:30:00+05:00) or unix timestamp</small>
-                </div>
-                
-                <div class="filter-group">
-                  <label for="filter-until" class="filter-label">Until (date-time or unix timestamp):</label>
-                  <input
-                    id="filter-until"
-                    type="text"
-                    bind:value={filterUntil}
-                    placeholder="2024-01-15T14:30:00Z or unix timestamp"
-                    class="filter-input"
-                  />
-                  <small class="filter-hint">Accepts ISO 8601 format (e.g., 2024-01-15T14:30:00Z, 2024-01-15T14:30:00+05:00) or unix timestamp</small>
-                </div>
-                
-                <div class="filter-group">
-                  <label for="filter-limit" class="filter-label">Limit:</label>
-                  <input
-                    id="filter-limit"
-                    type="number"
-                    bind:value={filterLimit}
-                    min="1"
-                    max="1000"
-                    class="filter-input"
-                  />
-                </div>
-              </div>
-            {/if}
-          </div>
-        </div>
+        <NormalSearch 
+          bind:this={normalSearchComponent}
+          onSearchResults={handleNormalSearchResults}
+        />
+      </section>
+      
+      <section class="find-section">
+        <AdvancedSearch 
+          bind:this={advancedSearchComponent}
+          onSearchResults={handleAdvancedSearchResults}
+        />
+      </section>
+      
+      <section class="find-section">
+        <SearchAddressableEvents />
       </section>
       
       {#if cacheResults.events.length > 0 || cacheResults.profiles.length > 0 || searchResults.events.length > 0 || searchResults.profiles.length > 0}
@@ -1047,12 +210,6 @@
             </div>
           {/if}
         </section>
-      {:else if !searching && unifiedSearchComponent && unifiedSearchComponent.getFilterResult().value}
-        <section class="results-section">
-          <div class="no-results">
-            No results found on the relays: {searchResults.relays && searchResults.relays.length > 0 ? searchResults.relays.join(', ') : 'No relays available'}
-          </div>
-        </section>
       {/if}
     </div>
   </div>
@@ -1069,10 +226,20 @@
     display: flex;
     justify-content: space-between;
     align-items: center;
-    margin-bottom: 1.5rem;
+    margin-bottom: 1rem;
     gap: 1rem;
   }
 
+  @media (min-width: 640px) {
+    .page-header {
+      margin-bottom: 1.5rem;
+    }
+  }
+
+  .page-title {
+    font-size: 1.5em;
+  }
+
   .clear-button {
     padding: 0.5rem 1rem;
     background: var(--fog-highlight, #f3f4f6);
@@ -1080,7 +247,7 @@
     border: 1px solid var(--fog-border, #e5e7eb);
     border-radius: 0.375rem;
     cursor: pointer;
-    font-size: 0.875rem;
+    font-size: 0.875em;
     font-weight: 500;
     font-family: inherit;
     transition: all 0.2s;
@@ -1116,179 +283,66 @@
   .find-sections {
     display: flex;
     flex-direction: column;
-    gap: 3rem;
-  }
-
-  .find-section {
-    border: 1px solid var(--fog-border, #e5e7eb);
-    border-radius: 0.5rem;
-    padding: 2rem;
-    background: var(--fog-post, #ffffff);
-  }
-
-  :global(.dark) .find-section {
-    border-color: var(--fog-dark-border, #374151);
-    background: var(--fog-dark-post, #1f2937);
-  }
-
-  .find-section h2 {
-    margin: 0 0 1.5rem 0;
-    font-size: 1.25rem;
-    font-weight: 600;
-    color: var(--fog-text, #475569);
-  }
-
-  :global(.dark) .find-section h2 {
-    color: var(--fog-dark-text, #cbd5e1);
-  }
-
-  .section-description {
-    margin: 0 0 1.5rem 0;
-    color: var(--fog-text-light, #52667a);
-    font-size: 0.875rem;
-  }
-
-  :global(.dark) .section-description {
-    color: var(--fog-dark-text-light, #a8b8d0);
-  }
-
-  .search-container {
-    display: flex;
-    flex-direction: column;
-    gap: 1rem;
-  }
-
-  .search-bar-wrapper {
-    width: 100%;
-  }
-
-  .search-bar-wrapper :global(.unified-search-container) {
-    max-width: none;
-    width: 100%;
-  }
-
-  .filter-and-button-wrapper {
-    display: flex;
-    flex-direction: column;
-    gap: 1rem;
+    gap: 1.5rem;
   }
 
   @media (min-width: 640px) {
-    .filter-and-button-wrapper {
-      flex-direction: row;
-      align-items: flex-end;
+    .find-sections {
+      gap: 2rem;
     }
   }
 
-  .kind-filter-wrapper {
-    display: flex;
-    flex-direction: column;
-    gap: 0.5rem;
-    flex: 1;
-  }
-
-  @media (min-width: 640px) {
-    .kind-filter-wrapper {
-      flex-direction: row;
-      align-items: center;
-      flex: 1;
+  @media (min-width: 1024px) {
+    .find-sections {
+      gap: 3rem;
     }
   }
 
-  .kind-filter-label {
-    font-size: 0.875rem;
-    color: var(--fog-text, #1f2937);
-    font-weight: 500;
-    white-space: nowrap;
-  }
-
-  :global(.dark) .kind-filter-label {
-    color: var(--fog-dark-text, #f9fafb);
-  }
-
-  .kind-filter-select {
-    padding: 0.75rem;
+  .find-section {
     border: 1px solid var(--fog-border, #e5e7eb);
-    border-radius: 0.375rem;
+    border-radius: 0.5rem;
+    padding: 1rem;
     background: var(--fog-post, #ffffff);
-    color: var(--fog-text, #1f2937);
-    font-size: 0.875rem;
-    cursor: pointer;
-    width: 100%;
-    font-family: inherit;
   }
 
   @media (min-width: 640px) {
-    .kind-filter-select {
-      width: auto;
-      min-width: 200px;
+    .find-section {
+      padding: 1.5rem;
     }
   }
 
-  .kind-filter-select:focus {
-    outline: none;
-    border-color: var(--fog-accent, #64748b);
-    box-shadow: 0 0 0 3px rgba(100, 116, 139, 0.1);
+  @media (min-width: 1024px) {
+    .find-section {
+      padding: 2rem;
+    }
   }
 
-  :global(.dark) .kind-filter-select {
+  :global(.dark) .find-section {
     border-color: var(--fog-dark-border, #374151);
     background: var(--fog-dark-post, #1f2937);
-    color: var(--fog-dark-text, #f9fafb);
   }
 
-  :global(.dark) .kind-filter-select:focus {
-    border-color: var(--fog-dark-accent, #94a3b8);
-    box-shadow: 0 0 0 3px rgba(148, 163, 184, 0.1);
-  }
 
-  .search-button {
-    padding: 0.75rem 1.5rem;
-    background: var(--fog-accent, #64748b);
-    color: #ffffff;
-    border: none;
-    border-radius: 0.375rem;
-    cursor: pointer;
-    font-size: 0.875rem;
-    font-weight: 500;
-    font-family: inherit;
-    white-space: nowrap;
-    transition: all 0.2s;
-    min-width: 100px;
+
+  .results-section {
+    margin-top: 1.5rem;
+    border: 1px solid var(--fog-border, #e5e7eb);
+    border-radius: 0.5rem;
+    padding: 1rem;
+    background: var(--fog-post, #ffffff);
   }
 
   @media (min-width: 640px) {
-    .search-button {
-      min-width: auto;
+    .results-section {
+      padding: 1.5rem;
+      margin-top: 2rem;
     }
   }
 
-  :global(.dark) .search-button {
-    background: var(--fog-dark-accent, #94a3b8);
-    color: #1f2937;
-  }
-
-  .search-button:hover:not(:disabled) {
-    opacity: 0.9;
-    transform: translateY(-1px);
-  }
-
-  .search-button:active:not(:disabled) {
-    transform: translateY(0);
-  }
-
-  .search-button:disabled {
-    opacity: 0.6;
-    cursor: not-allowed;
-  }
-
-
-  .results-section {
-    margin-top: 2rem;
-    border: 1px solid var(--fog-border, #e5e7eb);
-    border-radius: 0.5rem;
-    padding: 2rem;
-    background: var(--fog-post, #ffffff);
+  @media (min-width: 1024px) {
+    .results-section {
+      padding: 2rem;
+    }
   }
 
   :global(.dark) .results-section {
@@ -1297,12 +351,18 @@
   }
 
   .results-section h2 {
-    margin: 0 0 1.5rem 0;
-    font-size: 1.25rem;
+    margin: 0 0 1rem 0;
+    font-size: 1.25em;
     font-weight: 600;
     color: var(--fog-text, #475569);
   }
 
+  @media (min-width: 640px) {
+    .results-section h2 {
+      margin: 0 0 1.5rem 0;
+    }
+  }
+
   :global(.dark) .results-section h2 {
     color: var(--fog-dark-text, #cbd5e1);
   }
@@ -1316,12 +376,18 @@
   }
 
   .results-group h3 {
-    margin: 0 0 1rem 0;
-    font-size: 1rem;
+    margin: 0 0 0.75rem 0;
+    font-size: 1em;
     font-weight: 500;
     color: var(--fog-text-light, #52667a);
   }
 
+  @media (min-width: 640px) {
+    .results-group h3 {
+      margin: 0 0 1rem 0;
+    }
+  }
+
   :global(.dark) .results-group h3 {
     color: var(--fog-dark-text-light, #a8b8d0);
   }
@@ -1395,27 +461,11 @@
   }
 
   .event-relay-badge {
-    padding: 0.5rem 1rem;
-    border-top: 1px solid var(--fog-border, #e5e7eb);
-    background: var(--fog-highlight, #f3f4f6);
-  }
-
-  :global(.dark) .event-relay-badge {
-    border-color: var(--fog-dark-border, #374151);
-    background: var(--fog-dark-highlight, #374151);
-  }
-
-  .event-result-link {
-    display: block;
-    text-decoration: none;
-    color: inherit;
-    flex: 1;
-  }
-
-  .event-relay-badge {
-    padding: 0.5rem 1rem;
+    padding: 0.25rem 0.5rem;
     border-top: 1px solid var(--fog-border, #e5e7eb);
     background: var(--fog-highlight, #f3f4f6);
+    display: flex;
+    align-items: center;
   }
 
   :global(.dark) .event-relay-badge {
@@ -1423,126 +473,17 @@
     background: var(--fog-dark-highlight, #374151);
   }
 
-  .no-results {
-    padding: 2rem;
-    text-align: center;
-    color: var(--fog-text-light, #52667a);
-    font-size: 0.875rem;
-  }
-
-  :global(.dark) .no-results {
-    color: var(--fog-dark-text-light, #a8b8d0);
-  }
-
-  .advanced-filters-section {
-    margin-top: 1.5rem;
-    padding-top: 1.5rem;
-    border-top: 1px solid var(--fog-border, #e5e7eb);
-  }
-
-  :global(.dark) .advanced-filters-section {
-    border-top-color: var(--fog-dark-border, #374151);
+  /* Make badges smaller to match feed page - scale down proportionally */
+  .event-relay-badge :global(.cache-badge),
+  .event-relay-badge :global(.relay-badge) {
+    font-size: 0.625em;
+    padding: 0.125rem 0.375rem;
+    gap: 0.125rem;
   }
 
-  .toggle-advanced-filters {
-    background: none;
-    border: none;
-    color: var(--fog-accent, #64748b);
-    cursor: pointer;
-    font-size: 0.875rem;
-    font-weight: 500;
-    padding: 0.5rem 0;
-    text-align: left;
-    width: 100%;
-    transition: color 0.2s;
-  }
-
-  :global(.dark) .toggle-advanced-filters {
-    color: var(--fog-dark-accent, #94a3b8);
+  .event-relay-badge :global(.cache-icon) {
+    width: 0.625rem;
+    height: 0.625rem;
   }
 
-  .toggle-advanced-filters:hover {
-    color: var(--fog-text, #475569);
-  }
-
-  :global(.dark) .toggle-advanced-filters:hover {
-    color: var(--fog-dark-text, #cbd5e1);
-  }
-
-  .advanced-filters-grid {
-    display: grid;
-    grid-template-columns: 1fr;
-    gap: 1rem;
-    margin-top: 1rem;
-    padding: 1rem;
-    background: var(--fog-highlight, #f3f4f6);
-    border-radius: 0.375rem;
-    border: 1px solid var(--fog-border, #e5e7eb);
-  }
-
-  :global(.dark) .advanced-filters-grid {
-    background: var(--fog-dark-highlight, #374151);
-    border-color: var(--fog-dark-border, #475569);
-  }
-
-  @media (min-width: 768px) {
-    .advanced-filters-grid {
-      grid-template-columns: repeat(2, 1fr);
-    }
-  }
-
-  .filter-group {
-    display: flex;
-    flex-direction: column;
-    gap: 0.5rem;
-  }
-
-  .filter-label {
-    font-size: 0.875rem;
-    font-weight: 500;
-    color: var(--fog-text, #1f2937);
-  }
-
-  :global(.dark) .filter-label {
-    color: var(--fog-dark-text, #f9fafb);
-  }
-
-  .filter-input {
-    padding: 0.5rem;
-    border: 1px solid var(--fog-border, #cbd5e1);
-    border-radius: 0.375rem;
-    background: var(--fog-post, #ffffff);
-    color: var(--fog-text, #1f2937);
-    font-size: 0.875rem;
-    font-family: inherit;
-    width: 100%;
-  }
-
-  .filter-input:focus {
-    outline: none;
-    border-color: var(--fog-accent, #64748b);
-    box-shadow: 0 0 0 3px rgba(100, 116, 139, 0.1);
-  }
-
-  :global(.dark) .filter-input {
-    border-color: var(--fog-dark-border, #374151);
-    background: var(--fog-dark-post, #1f2937);
-    color: var(--fog-dark-text, #f9fafb);
-  }
-
-  :global(.dark) .filter-input:focus {
-    border-color: var(--fog-dark-accent, #94a3b8);
-    box-shadow: 0 0 0 3px rgba(148, 163, 184, 0.1);
-  }
-
-  .filter-hint {
-    font-size: 0.75rem;
-    color: var(--fog-text-light, #52667a);
-    margin-top: 0.25rem;
-    display: block;
-  }
-
-  :global(.dark) .filter-hint {
-    color: var(--fog-dark-text-light, #a8b8d0);
-  }
 </style>