import {
  FAST_READ_RELAY_URLS,
  ExtendedKind,
  FAST_WRITE_RELAY_URLS,
  DOCUMENT_RELAY_URLS,
  FIRST_RELAY_RESULT_GRACE_MS,
  HTTP_TIMELINE_POLL_INTERVAL_MS,
  HTTP_TIMELINE_POLL_SINCE_OVERLAP_SEC,
  isDocumentRelayKind,
  isSocialKindBlockedKind,
  relayFilterIncludesDocumentRelayKind,
  relayFilterIncludesSocialKindBlockedKind,
  relaysAfterSocialKindBlockedStrip,
  SOCIAL_KIND_BLOCKED_RELAY_URLS,
  MAX_PUBLISH_RELAYS,
  PUBLISH_RELAY_LIST_RESOLUTION_TIMEOUT_MS,
  RELAY_POOL_CONNECTION_TIMEOUT_MS,
  RELAY_READ_ONLY_POOL_CONNECT_TIMEOUT_MS,
  TIMELINE_SHARD_SUBSCRIBE_CONCURRENCY,
  OUTBOX_PUBLISH_RETRY_DELAY_MS,
  NIP66_DISCOVERY_RELAY_URLS,
  PROFILE_FETCH_RELAY_URLS,
  READ_ONLY_RELAY_URLS,
  NIP42_POOL_AUTOMATIC_AUTH_RELAY_URLS,
  SEARCHABLE_RELAY_URLS
} from '@/constants'

/** NIP-01 filter keys only; NIP-50 adds `search` which non-searchable relays reject. */
function filterForRelay(f: Filter, relaySupportsSearch: boolean): Filter {
  if (relaySupportsSearch) return f
  const { search: _search, ...rest } = f
  return rest as Filter
}

const HEX_EVENT_ID_RE = /^[0-9a-f]{64}$/i

function decodeEventRefForETagFilter(raw: string): string | null {
  const trimmed = raw.trim()
  if (!trimmed) return null
  const withoutPrefix = trimmed.toLowerCase().startsWith('nostr:') ? trimmed.slice(6).trim() : trimmed
  if (HEX_EVENT_ID_RE.test(withoutPrefix)) return withoutPrefix.toLowerCase()
  try {
    const decoded = nip19.decode(withoutPrefix)
    if (decoded.type === 'note') return decoded.data
    if (decoded.type === 'nevent') return decoded.data.id
  } catch {
    // ignore malformed refs
  }
  return null
}

function sanitizeETagFilterForSubscribe(filter: Filter): Filter | null {
  const f = { ...filter } as Filter & { '#e'?: string[]; '#E'?: string[] }
  const rawLower = Array.isArray(f['#e']) ? f['#e'] : []
  const rawUpper = Array.isArray(f['#E']) ? f['#E'] : []
  if (rawLower.length === 0 && rawUpper.length === 0) return f
  const rawAll = [...rawLower, ...rawUpper]
  const decoded = [
    ...new Set(
      rawAll
        .map((v) => decodeEventRefForETagFilter(String(v)))
        .filter((v): v is string => !!v)
    )
  ]
  if (decoded.length === 0) return null
  f['#e'] = decoded
  delete f['#E']
  return f
}

function sanitizeSubscribeFiltersBeforeReq(filter: Filter | Filter[]): Filter[] {
  const asArray = Array.isArray(filter) ? filter : [filter]
  return asArray.map(sanitizeETagFilterForSubscribe).filter((f): f is Filter => !!f)
}

function withDocumentRelayUrlsForFilters(relays: string[], filters: Filter[]): string[] {
  if (!filters.some((f) => relayFilterIncludesDocumentRelayKind(f))) return relays
  return dedupeNormalizeRelayUrlsOrdered([...relays, ...DOCUMENT_RELAY_URLS])
}

/** Single key for `pool.seenOn` / query seen-on maps (hex ids are case-insensitive). */
function canonicalSeenOnEventId(eventId: string): string {
  const t = eventId.trim()
  return /^[0-9a-f]{64}$/i.test(t) ? t.toLowerCase() : t
}
import { shouldDropEventOnIngest } from '@/lib/event-ingest-filter'
import { getHttpRelayListFromEvent, getProfileFromEvent, getRelayListFromEvent } from '@/lib/event-metadata'
import logger from '@/lib/logger'
import { patchPoolRelayAuthRaceAndFeedback } from '@/lib/nostr-relay-auth-patch'
import { queueRelayAuthSign } from '@/lib/relay-auth-sign-queue'
import {
  authenticateNip42Relay,
  isRelayAuthRequiredCloseReason,
  isRelayAuthRequiredErrorMessage,
  isRelaySubscriptionClosedByCaller
} from '@/lib/relay-nip42-auth'
import { applyRelayNip42AckTimeout } from '@/lib/relay-nip42-tuning'
import { buildDeletionRelayUrls, dispatchTombstonesUpdated } from '@/lib/tombstone-events'
import { hexPubkeysEqual, isValidPubkey, pubkeyToNpub, userIdToPubkey } from '@/lib/pubkey'
import { getPubkeysFromPTags, tagNameEquals } from '@/lib/tag'
import {
  buildPrioritizedWriteRelayUrls,
  dedupeNormalizeRelayUrlsOrdered,
  mergeRelayPriorityLayers,
  relayUrlsLocalsFirst
} from '@/lib/relay-url-priority'
import {
  IndexRelayTransportError,
  isIndexRelayTransportFailure,
  publishEventToHttpRelay
} from '@/lib/index-relay-http'
import {
  relayFiltersUseCapitalLetterTagKeys,
  relayUrlsStripExtendedTagReqBlocked
} from '@/lib/relay-extended-tag-req-blocks'
import { stripLocalNetworkRelaysFromRelayList } from '@/lib/relay-list-sanitize'
import { isHttpRelayUrl, isLocalNetworkUrl, normalizeAnyRelayUrl, normalizeHttpRelayUrl, normalizeUrl, simplifyUrl } from '@/lib/url'
import { isSafari } from '@/lib/utils'
import {
  ISigner,
  TProfile,
  TPublishEventExtras,
  TPublishOptions,
  TRelayList,
  TMailboxRelay,
  TSignerType,
  TSubRequestFilter
} from '@/types'
import { sha256 } from '@noble/hashes/sha2'
import dayjs from 'dayjs'
import FlexSearch from 'flexsearch'
import {
  EventTemplate,
  Filter,
  kinds,
  matchFilters,
  nip19,
  Event as NEvent,
  Relay,
  SimplePool,
  VerifiedEvent,
  verifyEvent
} from 'nostr-tools'
import { AbstractRelay } from 'nostr-tools/abstract-relay'
import indexedDb from './indexed-db.service'
import { invalidateArchiveFootprintCache } from './event-archive.service'
import { notifyLiveActivitiesPrewarmComplete } from './live-activities-prewarm-bridge'
import nip66Service from './nip66.service'
import { patchRelayNoticeForFetchFailures } from '@/services/relay-notice-strike'
import {
  compactFilterForRelayLog,
  RelayOpTerminalRow,
  RelayPublishOpBatch,
  RelaySubscribeOpBatch
} from '@/services/relay-operation-log.service'
import { QueryService } from './client-query.service'
import { EventService } from './client-events.service'
import { ReplaceableEventService } from './client-replaceable-events.service'
import { MacroService, createBookstrService } from './client-macro.service'

/** Fired on `window` when session relay strike counts change (subscribe in single-relay UI). */
export const JUMBLE_SESSION_RELAY_STRIKES_CHANGED = 'jumble:session-relay-strikes-changed' as const

/** Live timeline REQ: EOSE caps “connected but silent” relays. */
const SUBSCRIBE_RELAY_EOSE_TIMEOUT_MS = 4800

/**
 * After initial timeline EOSE (incl. grace), events with `created_at` older than this many seconds
 * (relative to wall clock at EOSE) are treated as backlog stragglers and merged into the feed;
 * fresher timestamps go to `onNew` (live / “new notes” UX).
 */
const TIMELINE_STRAGGLER_MAX_AGE_SEC = 600

function summarizeFiltersForRelayLog(filters: Filter[]): Record<string, unknown> {
  const f = filters[0]
  if (!f) return {}
  const out: Record<string, unknown> = {}
  if (f.kinds != null) out.kinds = f.kinds
  if (f.limit != null) out.limit = f.limit
  if (f.authors?.length) out.authorCount = f.authors.length
  if (f.ids?.length) out.idCount = f.ids.length
  if (f.search) out.search = true
  if (f['#p']?.length) out.pTagCount = f['#p'].length
  if (f['#e']?.length) out.eTagCount = f['#e'].length
  if (f['#t']?.length) out.tTagCount = f['#t'].length
  return out
}

const READ_ONLY_RELAY_CONNECT_BOOST_URLS = new Set(
  [...READ_ONLY_RELAY_URLS, ...NIP42_POOL_AUTOMATIC_AUTH_RELAY_URLS].map(
    (u) => normalizeUrl(u) || u
  )
)

/** Hostname (+ path when not "/") for readable publish / retry console lines. */
function relayHostForUserLog(url: string): string {
  const n = normalizeUrl(url) || url
  try {
    const u = new URL(n.replace(/^wss:/i, 'https:').replace(/^ws:/i, 'http:'))
    const path = u.pathname && u.pathname !== '/' ? u.pathname.replace(/\/$/, '') : ''
    return path ? `${u.host}${path}` : u.host
  } catch {
    return n
  }
}

type TTimelineRef = [string, number]

/** Run async work on each item with at most `concurrency` tasks in flight; results match `items` order. */
async function mapPoolWithConcurrency<T, R>(
  items: readonly T[],
  concurrency: number,
  fn: (item: T, index: number) => Promise<R>
): Promise<R[]> {
  if (items.length === 0) return []
  const c = Math.max(1, Math.min(concurrency, items.length))
  const results = new Array<R>(items.length)
  let next = 0
  const worker = async () => {
    while (true) {
      const i = next++
      if (i >= items.length) break
      results[i] = await fn(items[i]!, i)
    }
  }
  await Promise.all(Array.from({ length: c }, () => worker()))
  return results
}

/** Many features call `fetchRelayLists` in parallel; each timeout used to emit an identical WARN. */
let fetchRelayListBudgetWarnLastMs = 0
const FETCH_RELAY_LIST_BUDGET_WARN_MIN_INTERVAL_MS = 60_000

class ClientService extends EventTarget {
  static instance: ClientService

  signer?: ISigner
  /** Set with signer from NostrProvider; used to skip relay AUTH when read-only (e.g. npub). */
  signerType?: TSignerType
  pubkey?: string
  private pool: SimplePool

  // Sub-services (public for direct access)
  public readonly queryService: QueryService
  public readonly eventService: EventService
  public readonly replaceableEventService: ReplaceableEventService
  public readonly bookstrService: MacroService

  private timelines: Record<
    string,
    | {
        refs: TTimelineRef[]
        filter: TSubRequestFilter
        urls: string[]
      }
    | string[]
    | undefined
  > = {}
  private timelinePersistTimers = new Map<string, ReturnType<typeof setTimeout>>()
  /** In-flight {@link fetchRelayList} dedupe: key = viewer pubkey + target pubkey (sanitization depends on viewer). */
  private relayListRequestCache = new Map<string, Promise<TRelayList>>()
  private userIndex = new FlexSearch.Index({
    tokenize: 'forward'
  })


  /**
   * Session-only: connection/publish failures per normalized relay URL. After
   * {@link ClientService.SESSION_RELAY_FAILURE_STRIKE_THRESHOLD} strikes we skip that relay for reads and publishes until reload.
   */
  private publishStrikeCount = new Map<string, number>()
  public static readonly SESSION_RELAY_FAILURE_STRIKE_THRESHOLD = 2

  /** Session-only: relay URL -> { successCount, sumLatencyMs } for preferring faster, proven relays when picking "random" relays. */
  private sessionRelayPublishStats = new Map<string, { successCount: number; sumLatencyMs: number }>()

  /**
   * IndexedDB profile index + NIP-66 relay discovery run once per page session; followings prewarm (metadata + kind 10002) runs when logged in.
   * @see {@link runSessionPrewarm}
   */
  private sessionPrewarmBaseCompleted = false

  constructor() {
    super()
    this.pool = new SimplePool()
    this.pool.trackRelays = true
    const rawEnsureRelay = this.pool.ensureRelay.bind(this.pool)
    this.pool.ensureRelay = async (
      url: string,
      params?: { connectionTimeout?: number; abort?: AbortSignal }
    ) => {
      // While offline, skip any relay that isn't on the local network.
      // This prevents a flood of failed WebSocket/HTTP connection attempts across
      // every part of the app (feeds, profile lookups, relay-list fetches, etc.).
      if (!navigator.onLine && !isLocalNetworkUrl(url)) {
        throw new Error(`[offline] skipping non-local relay ${url}`)
      }
      const n = normalizeUrl(url) || url
      const base = params?.connectionTimeout ?? RELAY_POOL_CONNECTION_TIMEOUT_MS
      const connectionTimeout = READ_ONLY_RELAY_CONNECT_BOOST_URLS.has(n)
        ? Math.max(base, RELAY_READ_ONLY_POOL_CONNECT_TIMEOUT_MS)
        : base
      const relay = await rawEnsureRelay(url, {
        ...params,
        connectionTimeout
      })
      patchPoolRelayAuthRaceAndFeedback(relay)
      applyRelayNip42AckTimeout(relay)
      return relay
    }

    // Initialize sub-services
    this.queryService = new QueryService(this.pool, {
      shouldSkipRelayForSession: (url) => {
        const key = normalizeAnyRelayUrl(url) || url
        return (
          (this.publishStrikeCount.get(key) ?? 0) >=
          ClientService.SESSION_RELAY_FAILURE_STRIKE_THRESHOLD
        )
      },
      onRelayConnectionFailure: (url) => this.recordSessionRelayFailure(url),
      onRelayNoticeStrike: (normalizedUrl, noticeMessage) =>
        this.recordRelayNoticeFetchFailure(normalizedUrl, noticeMessage)
    })
    this.eventService = new EventService(this.queryService)
    this.replaceableEventService = new ReplaceableEventService(
      this.queryService,
      (profileEvent) => this.addUsernameToIndex(profileEvent)
    )
    this.queryService.setQueryResultIngest((events) => {
      for (const e of events) {
        this.eventService.addEventToCache(e)
      }
    })
    this.bookstrService = createBookstrService(this.queryService)
  }

  public static getInstance(): ClientService {
    if (!ClientService.instance) {
      ClientService.instance = new ClientService()
    }
    return ClientService.instance
  }

  private async prewarmProfileSearchIndexFromIdb(): Promise<void> {
    const t0 = typeof performance !== 'undefined' ? performance.now() : 0
    let profileRows = 0
    await indexedDb.iterateProfileEvents(async (profileEvent) => {
      this.addUsernameToIndex(profileEvent)
      profileRows += 1
    })
    logger.info('[client] Prewarm: profile @-mention index from IndexedDB done', {
      profileRows,
      ms: typeof performance !== 'undefined' ? Math.round(performance.now() - t0) : undefined
    })
  }

  /**
   * One-shot batch: local profile search index + NIP-66 relay discovery (once per session) + optional following-profile fetch (parallel).
   * Call after Nostr session is ready so it does not compete with the first relay-list REQ.
   */
  async runSessionPrewarm(options: { pubkey: string | null; signal?: AbortSignal }): Promise<void> {
    const signal = options.signal ?? new AbortController().signal
    const t0 = typeof performance !== 'undefined' ? performance.now() : 0
    const tasks: Promise<unknown>[] = []

    if (!this.sessionPrewarmBaseCompleted) {
      this.sessionPrewarmBaseCompleted = true
      tasks.push(this.prewarmProfileSearchIndexFromIdb(), this.fetchNip66RelayDiscovery())
    }
    if (options.pubkey) {
      tasks.push(this.initUserIndexFromFollowings(options.pubkey, signal))
    }

    if (tasks.length === 0) {
      notifyLiveActivitiesPrewarmComplete()
      return
    }

    logger.info('[client] Session prewarm batch started (parallel)', {
      hasPubkey: !!options.pubkey,
      taskCount: tasks.length
    })
    const results = await Promise.allSettled(tasks)
    logger.info('[client] Session prewarm batch finished', {
      ms: typeof performance !== 'undefined' ? Math.round(performance.now() - t0) : undefined,
      results: results.map((r) => r.status)
    })
    notifyLiveActivitiesPrewarmComplete()
  }

  // Update signer in query service when it changes
  setSigner(signer: ISigner | undefined, signerType: TSignerType | undefined) {
    this.signer = signer
    this.signerType = signerType
    this.queryService.setSigner(signer, signerType)
    /**
     * NIP-42: proactive `AUTH` for relays that need it before the first REQ (read-only aggregators +
     * {@link NIP42_POOL_AUTOMATIC_AUTH_RELAY_URLS}). Without this, a REQ can EOSE empty while the extension
     * is still signing; the batch then finishes and never refetches. Other relays stay on reactive
     * `relay.auth()` after `auth-required` to avoid double-sign races with the wider pool.
     */
    if (signer && signerType !== 'npub') {
      this.pool.automaticallyAuth = (relayURL: string) => {
        const n = normalizeUrl(relayURL) || relayURL
        if (!READ_ONLY_RELAY_CONNECT_BOOST_URLS.has(n)) return null
        return async (event: EventTemplate) => {
          const evt = await queueRelayAuthSign(() => signer.signEvent(event))
          return evt as VerifiedEvent
        }
      }
    } else {
      this.pool.automaticallyAuth = undefined
    }
  }

  /** NIP-66: fetch relay discovery events (30166) in background to supplement search/NIP support. */
  private async fetchNip66RelayDiscovery(): Promise<void> {
    try {
      const discoveryRelays = Array.from(new Set([...FAST_READ_RELAY_URLS, ...NIP66_DISCOVERY_RELAY_URLS]))
      const events = await this.queryService.query(
        discoveryRelays,
        { kinds: [ExtendedKind.RELAY_DISCOVERY], limit: 2000 },
        undefined,
        { eoseTimeout: 4000, globalTimeout: 8000 }
      )
      if (events.length > 0) {
        const capped = events.length > 2000 ? events.slice(0, 2000) : events
        nip66Service.loadFromEvents(capped)
        logger.info('[client] Prewarm: NIP-66 relay discovery list updated', { count: capped.length })
      }
    } catch (err) {
      logger.warn('[client] Prewarm: NIP-66 relay discovery fetch failed', { err })
    }
  }

  /**
   * NIP-66: fetch 30166 events for a single relay (relay info page). Uses discovery relay set,
   * filter by #d so we get the newest report for this relay and can show monitor (author) info.
   */
  async fetchNip66DiscoveryForRelay(relayUrl: string): Promise<void> {
    const discoveryRelays = Array.from(new Set([...FAST_READ_RELAY_URLS, ...NIP66_DISCOVERY_RELAY_URLS]))
    const dTag = normalizeAnyRelayUrl(relayUrl) || relayUrl
    const shortForm = simplifyUrl(dTag)
    const dValues = dTag !== shortForm ? [dTag, shortForm] : [dTag]
    try {
      const events = await this.queryService.query(
        discoveryRelays,
        { kinds: [ExtendedKind.RELAY_DISCOVERY], '#d': dValues, limit: 20 },
        undefined,
        { eoseTimeout: 4000, globalTimeout: 6000 }
      )
      if (events.length > 0) {
        nip66Service.loadFromEvents(events)
      }
    } catch {
      // ignore per-relay fetch failure
    }
  }

  /** Read-only logins (e.g. npub) cannot sign relay AUTH challenges; avoid calling signEvent. */
  private canSignerAuthenticateRelay(): boolean {
    if (!this.signer) return false
    if (this.signerType === 'npub') return false
    return true
  }

  /**
   * Pubkeys to pull **read** (inbox) relays for: `p`/`P` mentions and `e` tag relay pubkey hint (NIP-10).
   * Excludes the event author.
   */
  private collectReplyAndMentionPubkeys(event: NEvent): string[] {
    const out: string[] = []
    const seen = new Set<string>()
    const add = (pk: string | undefined) => {
      if (!pk || !isValidPubkey(pk) || pk === event.pubkey || seen.has(pk)) return
      seen.add(pk)
      out.push(pk)
    }
    for (const t of event.tags) {
      const name = t[0]
      const v = t[1]
      const hint = t[3]
      if ((name === 'p' || name === 'P') && v) add(v)
      if (name === 'e' && hint) add(hint)
    }
    return out
  }

  /**
   * Write publish order: user outboxes → author inboxes → favorites → FAST_WRITE → FAST_READ → other.
   * Normalize, dedupe, then cap at {@link MAX_PUBLISH_RELAYS}.
   */
  private filterPublishingRelays(relays: string[], event: NEvent): string[] {
    const readOnlySet = new Set(READ_ONLY_RELAY_URLS.map((u) => normalizeAnyRelayUrl(u) || u))
    const socialKindBlockedSet = new Set(SOCIAL_KIND_BLOCKED_RELAY_URLS.map((u) => normalizeUrl(u) || u))
    return dedupeNormalizeRelayUrlsOrdered(
      relays.filter((url) => {
        const n = normalizeAnyRelayUrl(url) || url
        if (readOnlySet.has(n)) return false
        if (isSocialKindBlockedKind(event.kind) && socialKindBlockedSet.has(n)) return false
        return true
      })
    )
  }

  /** NIP-65 `write` URLs for `event.pubkey`, filtered for publish (no read-only / social-kind blocks). */
  private async getUserOutboxRelayUrlsForPublish(event: NEvent): Promise<string[]> {
    try {
      const relayList = await Promise.race([
        this.fetchRelayList(event.pubkey),
        new Promise<null>((resolve) =>
          setTimeout(() => resolve(null), PUBLISH_RELAY_LIST_RESOLUTION_TIMEOUT_MS)
        )
      ])
      if (relayList == null) {
        logger.warn('[PublishEvent] fetchRelayList timed out while resolving outboxes; publishing without NIP-65 prepend', {
          pubkey: event.pubkey.slice(0, 12)
        })
        return []
      }
      const wsOut = (relayList?.write ?? [])
        .map((u) => normalizeUrl(u) || u)
        .filter((u): u is string => !!u)
      const httpOut = (relayList?.httpWrite ?? [])
        .map((u) => normalizeHttpRelayUrl(u) || u)
        .filter((u): u is string => !!u)
      const raw = dedupeNormalizeRelayUrlsOrdered([...httpOut, ...wsOut])
      return this.filterPublishingRelays(raw, event)
    } catch {
      return []
    }
  }

  private async retryFailedOutboxPublishesOnce(
    event: NEvent,
    userOutboxUrls: string[],
    relayStatuses: { url: string; success: boolean; error?: string }[]
  ): Promise<void> {
    const norm = (u: string) => normalizeAnyRelayUrl(u) || u
    const hadSuccess = new Set<string>()
    for (const r of relayStatuses) {
      if (r.success) hadSuccess.add(norm(r.url))
    }
    const failedOutboxes = userOutboxUrls.filter((u) => !hadSuccess.has(norm(u)))
    if (failedOutboxes.length === 0) return

    const statusHint = (url: string): string => {
      const n = norm(url)
      const forUrl = relayStatuses.filter((r) => norm(r.url) === n)
      const failMsgs = forUrl.filter((r) => !r.success).map((r) => r.error).filter(Boolean)
      if (failMsgs.length) return failMsgs[failMsgs.length - 1]!
      return 'No OK from this relay (timeout, connection failed, or still pending when the first wave ended)'
    }

    const okOutboxes = userOutboxUrls.filter((u) => hadSuccess.has(norm(u)))
    const eventHint =
      event.id && /^[0-9a-f]{64}$/i.test(event.id)
        ? `note id ${event.id.slice(0, 12)}… (kind ${event.kind})`
        : `kind ${event.kind} note`

    const failedSummary = failedOutboxes
      .map((u) => `  • ${relayHostForUserLog(u)} — ${statusHint(u)}`)
      .join('\n')
    const okSummary =
      okOutboxes.length > 0
        ? okOutboxes.map((u) => `  • ${relayHostForUserLog(u)}`).join('\n')
        : '  (none)'

    logger.info(
      `[Publish] NIP-65 write relays (your outboxes): ${failedOutboxes.length} did not confirm ${eventHint}. ` +
        `Retrying only those in ${OUTBOX_PUBLISH_RETRY_DELAY_MS / 1000}s (one more try each).\n` +
        `Not OK:\n${failedSummary}\n` +
        `Confirmed on first publish wave:\n${okSummary}`,
      {
        delaySeconds: OUTBOX_PUBLISH_RETRY_DELAY_MS / 1000,
        failed: failedOutboxes.map((url) => ({
          url,
          host: relayHostForUserLog(url),
          reason: statusHint(url)
        })),
        confirmed: okOutboxes.map((url) => ({ url, host: relayHostForUserLog(url) }))
      }
    )

    await new Promise<void>((r) => setTimeout(r, OUTBOX_PUBLISH_RETRY_DELAY_MS))
    await this.publishEvent(failedOutboxes, event, {
      skipOutboxRetry: true,
      publishBatchLabel: 'NIP-65 outbox retry — 2nd attempt (failed write relays only)'
    })
  }

  private async prioritizePublishUrlList(
    relayUrls: string[],
    event: NEvent,
    favoriteRelayUrls: string[] = []
  ): Promise<string[]> {
    let userWriteSet = new Set<string>()
    try {
      const rl = await this.fetchRelayList(event.pubkey)
      userWriteSet = new Set([
        ...(rl?.write ?? []).map((u) => normalizeUrl(u) || u).filter((u): u is string => !!u),
        ...(rl?.httpWrite ?? []).map((u) => normalizeHttpRelayUrl(u) || u).filter((u): u is string => !!u)
      ])
    } catch {
      // ignore
    }

    const ctx = this.collectReplyAndMentionPubkeys(event)
    let authorReadSet = new Set<string>()
    if (ctx.length > 0) {
      const lists = await this.fetchRelayLists(ctx)
      for (const list of lists) {
        for (const u of list?.read ?? []) {
          const n = normalizeUrl(u) || u
          if (n) authorReadSet.add(n)
        }
      }
    }

    const favSet = new Set(
      favoriteRelayUrls.map((f) => normalizeUrl(f) || f).filter((u): u is string => !!u)
    )
    const fastWSet = new Set(
      FAST_WRITE_RELAY_URLS.map((u) => normalizeUrl(u) || u).filter((u): u is string => !!u)
    )
    const fastRSet = new Set(
      FAST_READ_RELAY_URLS.map((u) => normalizeUrl(u) || u).filter((u): u is string => !!u)
    )

    const readOnlySet = new Set(READ_ONLY_RELAY_URLS.map((u) => normalizeUrl(u) || u))
    const socialKindBlockedSet = new Set(SOCIAL_KIND_BLOCKED_RELAY_URLS.map((u) => normalizeUrl(u) || u))

    const t0: string[] = []
    const t1: string[] = []
    const t2: string[] = []
    const t3: string[] = []
    const t4: string[] = []
    const t5: string[] = []
    for (const u of relayUrls) {
      const n = normalizeAnyRelayUrl(u) || u
      if (!n) continue
      if (userWriteSet.has(n)) t0.push(n)
      else if (authorReadSet.has(n)) t1.push(n)
      else if (favSet.has(n)) t2.push(n)
      else if (fastWSet.has(n)) t3.push(n)
      else if (fastRSet.has(n)) t4.push(n)
      else t5.push(n)
    }
    return dedupeNormalizeRelayUrlsOrdered([...t0, ...t1, ...t2, ...t3, ...t4, ...t5])
      .filter((url) => {
        const n = normalizeAnyRelayUrl(url) || url
        if (readOnlySet.has(n)) return false
        if (isSocialKindBlockedKind(event.kind) && socialKindBlockedSet.has(n)) return false
        return true
      })
      .slice(0, MAX_PUBLISH_RELAYS)
  }

  /**
   * Same ordering as {@link prioritizePublishUrlList} but bounded so relay-list / inbox fetches
   * cannot block publishing indefinitely. Used from {@link determineTargetRelays} (before
   * {@link publishEvent}) and from {@link capPublishRelayUrlsForPublish}.
   */
  private async prioritizePublishUrlListWithTimeout(
    relayUrls: string[],
    event: NEvent,
    favoriteRelayUrls: string[] = []
  ): Promise<string[]> {
    const fallbackOrder = (): string[] =>
      this.filterPublishingRelays(dedupeNormalizeRelayUrlsOrdered(relayUrls), event).slice(0, MAX_PUBLISH_RELAYS)

    return await Promise.race([
      this.prioritizePublishUrlList(relayUrls, event, favoriteRelayUrls),
      new Promise<string[]>((resolve) =>
        setTimeout(() => {
          logger.warn('[PublishEvent] prioritizePublishUrlList timed out; using deduped relay order without inbox fetch', {
            kind: event.kind,
            relayCount: relayUrls.length
          })
          resolve(fallbackOrder())
        }, PUBLISH_RELAY_LIST_RESOLUTION_TIMEOUT_MS)
      )
    ])
  }

  private async capPublishRelayUrlsForPublish(
    relayUrls: string[],
    event: NEvent,
    favoriteRelayUrls: string[] = []
  ): Promise<string[]> {
    return this.prioritizePublishUrlListWithTimeout(relayUrls, event, favoriteRelayUrls)
  }

  private emptyRelayListForPublish(): TRelayList {
    return {
      write: [],
      read: [],
      originalRelays: [],
      httpRead: [],
      httpWrite: [],
      httpOriginalRelays: []
    }
  }

  /** Bounded wait so NIP-65 fetch cannot block publishing (reactions, replies without relay picker, etc.). */
  private async fetchRelayListWithPublishTimeout(pubkey: string): Promise<TRelayList> {
    const empty = this.emptyRelayListForPublish()
    try {
      return await Promise.race([
        this.fetchRelayList(pubkey),
        new Promise<TRelayList>((resolve) =>
          setTimeout(() => {
            logger.warn('[DetermineTargetRelays] fetchRelayList timed out; using empty outbox', {
              pubkeySlice: pubkey.slice(0, 12)
            })
            resolve(empty)
          }, PUBLISH_RELAY_LIST_RESOLUTION_TIMEOUT_MS)
        )
      ])
    } catch (err) {
      logger.warn('[DetermineTargetRelays] fetchRelayList failed, using fallback relays', {
        pubkeySlice: pubkey.slice(0, 12),
        error: err instanceof Error ? err.message : String(err)
      })
      return empty
    }
  }

  private async fetchRelayListsWithPublishTimeout(pubkeys: string[]): Promise<TRelayList[]> {
    if (pubkeys.length === 0) return []
    try {
      return await Promise.race([
        this.fetchRelayLists(pubkeys),
        new Promise<TRelayList[]>((resolve) =>
          setTimeout(() => {
            logger.warn('[DetermineTargetRelays] fetchRelayLists timed out; skipping context inbox merge', {
              pubkeyCount: pubkeys.length
            })
            resolve(pubkeys.map(() => this.emptyRelayListForPublish()))
          }, PUBLISH_RELAY_LIST_RESOLUTION_TIMEOUT_MS)
        )
      ])
    } catch (err) {
      logger.warn('[DetermineTargetRelays] fetchRelayLists failed', {
        pubkeyCount: pubkeys.length,
        error: err instanceof Error ? err.message : String(err)
      })
      return pubkeys.map(() => this.emptyRelayListForPublish())
    }
  }

  /**
   * Determine which relays to publish an event to.
   * Fallbacks (used when user relay list is empty or fetch fails):
   * - General events (reactions, notes, etc.): FAST_WRITE_RELAY_URLS
   * - Relay list / cache relays / contacts: FAST_READ_RELAY_URLS + PROFILE_RELAY_URLS (added to additional)
   * - Favorite relays: FAST_WRITE_RELAY_URLS (added to additional)
   * - Report events: FAST_WRITE_RELAY_URLS when no user/seen relays
   */
  async determineTargetRelays(
    event: NEvent,
    { specifiedRelayUrls, additionalRelayUrls, favoriteRelayUrls, blockedRelayUrls }: TPublishOptions = {}
  ) {
    const writeRelayPubOpts = {
      blockedRelays: blockedRelayUrls,
      applySocialKindBlockedFilter: isSocialKindBlockedKind(event.kind)
    }
    if (event.kind === kinds.RelayList) {
      logger.info('[DetermineTargetRelays] Determining target relays for relay list event', {
        pubkey: event.pubkey,
        hasSpecifiedRelays: !!specifiedRelayUrls?.length,
        specifiedRelayCount: specifiedRelayUrls?.length ?? 0,
        hasAdditionalRelays: !!additionalRelayUrls?.length,
        additionalRelayCount: additionalRelayUrls?.length ?? 0
      })
    }
    // For Report events, always include user's write relays first, then add seen relays if they're write-capable
    if (event.kind === kinds.Report) {
      // Start with user's write relays (outboxes) - these are the primary targets for reports
      const relayList = await this.fetchRelayListWithPublishTimeout(event.pubkey)
      const reportHttpWrites = (relayList?.httpWrite ?? [])
        .map((url) => normalizeHttpRelayUrl(url) || url)
        .filter((u): u is string => !!u)
      const reportWsWrites = (relayList?.write ?? [])
        .map((url) => normalizeUrl(url) || url)
        .filter((u): u is string => !!u)
      const userWriteRelays = dedupeNormalizeRelayUrlsOrdered([...reportHttpWrites, ...reportWsWrites])
      
      // Get seen relays where the reported event was found
      const targetEventId = event.tags.find(tagNameEquals('e'))?.[1]
      const seenRelays: string[] = []
      
      if (targetEventId) {
        const allSeenRelays = this.getSeenEventRelayUrls(targetEventId)
        // Filter seen relays: only include those that are in user's write list
        // This ensures we don't try to publish to read-only relays
        const userWriteRelaySet = new Set(userWriteRelays.map(url => normalizeAnyRelayUrl(url) || url))
        seenRelays.push(...allSeenRelays.filter(url => {
          const normalized = normalizeAnyRelayUrl(url) || url
          return userWriteRelaySet.has(normalized)
        }))
      }
      
      if (userWriteRelays.length === 0 && seenRelays.length === 0) {
        return this.filterPublishingRelays(
          buildPrioritizedWriteRelayUrls({
            userWriteRelays: [...FAST_WRITE_RELAY_URLS],
            favoriteRelays: favoriteRelayUrls ?? [],
            maxRelays: MAX_PUBLISH_RELAYS,
            ...writeRelayPubOpts
          }),
          event
        )
      }
      return this.filterPublishingRelays(
        buildPrioritizedWriteRelayUrls({
          userWriteRelays: userWriteRelays,
          authorReadRelays: [],
          favoriteRelays: favoriteRelayUrls ?? [],
          extraRelays: seenRelays,
          maxRelays: MAX_PUBLISH_RELAYS,
          ...writeRelayPubOpts
        }),
        event
      )
    }

    // Public messages (kind 24) and calendar RSVPs (kind 31925): only author's outboxes + each recipient's
    // inboxes — no user favorites, FAST_WRITE, or FAST_READ padding (see relay-selection getPublicMessageRelays).
    if (
      event.kind === ExtendedKind.PUBLIC_MESSAGE ||
      event.kind === ExtendedKind.CALENDAR_EVENT_RSVP
    ) {
      const recipientPubkeys = Array.from(
        new Set(
          event.tags.filter((t) => t[0] === 'p' && t[1] && isValidPubkey(t[1])).map((t) => t[1] as string)
        )
      ).filter((p) => p !== event.pubkey)
      const recipientListsPromise =
        recipientPubkeys.length > 0
          ? this.fetchRelayListsWithPublishTimeout(recipientPubkeys)
          : Promise.resolve([] as TRelayList[])
      const [authorRelayList, recipientRelayLists] = await Promise.all([
        this.fetchRelayListWithPublishTimeout(event.pubkey),
        recipientListsPromise
      ])
      const authorHttpWrites = (authorRelayList?.httpWrite ?? [])
        .map((url) => normalizeHttpRelayUrl(url))
        .filter((url): url is string => !!url)
      const authorWsWrites = (authorRelayList?.write ?? [])
        .map((url) => normalizeUrl(url))
        .filter((url): url is string => !!url)
      let authorWrite = dedupeNormalizeRelayUrlsOrdered([...authorHttpWrites, ...authorWsWrites])
      if (authorWrite.length === 0) {
        authorWrite = [...FAST_WRITE_RELAY_URLS]
      }
      let recipientRead: string[] = []
      recipientRead = recipientRelayLists.flatMap((rl) => [
        ...(rl?.httpRead ?? []).map((url) => normalizeHttpRelayUrl(url)).filter((u): u is string => !!u && !isLocalNetworkUrl(u)),
        ...(rl?.read ?? []).map((url) => normalizeUrl(url)).filter((u): u is string => !!u && !isLocalNetworkUrl(u))
      ])
      recipientRead = dedupeNormalizeRelayUrlsOrdered(recipientRead)
      let pubRelays = mergeRelayPriorityLayers(
        [relayUrlsLocalsFirst(authorWrite), dedupeNormalizeRelayUrlsOrdered(recipientRead)],
        blockedRelayUrls,
        MAX_PUBLISH_RELAYS,
        { applySocialKindBlockedFilter: false }
      )
      pubRelays = this.filterPublishingRelays(pubRelays, event)
      logger.debug('[DetermineTargetRelays] Public message / calendar RSVP: author outbox + recipient inboxes only', {
        kind: event.kind,
        relayCount: pubRelays.length,
        authorWriteCount: authorWrite.length,
        recipientReadCount: recipientRead.length
      })
      if (pubRelays.length > 0) return pubRelays
      return this.filterPublishingRelays(
        mergeRelayPriorityLayers(
          [relayUrlsLocalsFirst([...FAST_WRITE_RELAY_URLS])],
          blockedRelayUrls,
          MAX_PUBLISH_RELAYS,
          { applySocialKindBlockedFilter: false }
        ),
        event
      )
    }

    let relays: string[]
    if (specifiedRelayUrls?.length) {
      relays = specifiedRelayUrls
      if (isDocumentRelayKind(event.kind)) {
        relays = dedupeNormalizeRelayUrlsOrdered([...relays, ...DOCUMENT_RELAY_URLS])
      }
    } else {
      // Kind 777 spells: merged write list (kind 10002 outbox + kind 10432 CACHE_RELAYS) + fast write.
      if (event.kind === ExtendedKind.SPELL) {
        let spellRelayList: TRelayList | undefined
        try {
          spellRelayList = await this.fetchRelayListWithPublishTimeout(event.pubkey)
        } catch (err) {
          logger.warn('[DetermineTargetRelays] fetchRelayList failed for spell', {
            pubkey: event.pubkey,
            error: err instanceof Error ? err.message : String(err)
          })
          spellRelayList = this.emptyRelayListForPublish()
        }
        const spellHttpWrites = (spellRelayList?.httpWrite ?? [])
          .map((url) => normalizeHttpRelayUrl(url))
          .filter((url): url is string => !!url)
        const spellWsWrites = (spellRelayList?.write ?? [])
          .map((url) => normalizeUrl(url))
          .filter((url): url is string => !!url)
        const normalizedWrite = dedupeNormalizeRelayUrlsOrdered([...spellHttpWrites, ...spellWsWrites])
        const readOnlySet = new Set(READ_ONLY_RELAY_URLS.map((u) => normalizeUrl(u) || u))
        const spellWriteFiltered = normalizedWrite.filter((url) => {
          const n = normalizeAnyRelayUrl(url) || url
          return !readOnlySet.has(n)
        })
        return this.filterPublishingRelays(
          buildPrioritizedWriteRelayUrls({
            userWriteRelays:
              spellWriteFiltered.length > 0
                ? spellWriteFiltered
                : dedupeNormalizeRelayUrlsOrdered(FAST_WRITE_RELAY_URLS),
            favoriteRelays: favoriteRelayUrls ?? [],
            extraRelays: [],
            maxRelays: MAX_PUBLISH_RELAYS,
            ...writeRelayPubOpts
          }),
          event
        )
      }

      const bootstrapExtras: string[] = [...(additionalRelayUrls ?? [])]
      let authorInboxFromContext: string[] = []
      const shouldMergeContextInboxes =
        !specifiedRelayUrls?.length &&
        ![kinds.Contacts, kinds.Mutelist, ExtendedKind.FOLLOW_SET].includes(event.kind)
      const ctxPubkeys = shouldMergeContextInboxes ? this.collectReplyAndMentionPubkeys(event) : []
      const relayListsPromise =
        ctxPubkeys.length > 0
          ? this.fetchRelayListsWithPublishTimeout(ctxPubkeys)
          : Promise.resolve([] as TRelayList[])
      const relayListPromise = this.fetchRelayListWithPublishTimeout(event.pubkey)
      const [relayLists, relayList] = await Promise.all([relayListsPromise, relayListPromise])
      relayLists.forEach((rl) => {
        for (const u of rl.httpRead ?? []) {
          const n = normalizeHttpRelayUrl(u) || u
          if (n) authorInboxFromContext.push(n)
        }
        for (const u of rl.read ?? []) {
          const n = normalizeUrl(u) || u
          if (n) authorInboxFromContext.push(n)
        }
      })
      if (
        [
          kinds.RelayList,
          ExtendedKind.CACHE_RELAYS,
          kinds.Contacts,
          ExtendedKind.FOLLOW_SET,
          ExtendedKind.BLOSSOM_SERVER_LIST,
          ExtendedKind.RELAY_REVIEW
        ].includes(event.kind)
      ) {
        bootstrapExtras.push(...PROFILE_FETCH_RELAY_URLS)
        logger.debug('[DetermineTargetRelays] Relay list event detected, adding PROFILE_FETCH_RELAY_URLS', {
          kind: event.kind,
          profileFetchRelays: PROFILE_FETCH_RELAY_URLS,
          additionalRelayCount: bootstrapExtras.length
        })
      } else if (event.kind === ExtendedKind.FAVORITE_RELAYS || event.kind === kinds.Relaysets) {
        // Use fast write relays for favorite-relays and kind 30002 relay-set replaceables to avoid
        // timeouts and auth-only relays dominating the attempt list.
        bootstrapExtras.push(...FAST_WRITE_RELAY_URLS)
        logger.debug('[DetermineTargetRelays] Favorite relays or relay set event, adding FAST_WRITE_RELAY_URLS', {
          kind: event.kind,
          fastWriteRelays: FAST_WRITE_RELAY_URLS,
          additionalRelayCount: bootstrapExtras.length
        })
      } else if (event.kind === ExtendedKind.RSS_FEED_LIST) {
        bootstrapExtras.push(...FAST_WRITE_RELAY_URLS, ...PROFILE_FETCH_RELAY_URLS)
      }
      if (isDocumentRelayKind(event.kind)) {
        bootstrapExtras.push(...DOCUMENT_RELAY_URLS)
      }

      if (
        event.kind === kinds.RelayList ||
        event.kind === ExtendedKind.FAVORITE_RELAYS ||
        event.kind === kinds.Relaysets
      ) {
        logger.debug('[DetermineTargetRelays] User relay list resolved for publication', {
          pubkey: event.pubkey,
          kind: event.kind,
          hasRelayList: !!relayList,
          writeRelayCount: relayList?.write?.length ?? 0,
          readRelayCount: relayList?.read?.length ?? 0,
          writeRelays: relayList?.write?.slice(0, MAX_PUBLISH_RELAYS) ?? []
        })
      }
      const wsWrites = (relayList?.write ?? [])
        .map((u) => normalizeUrl(u) || u)
        .filter((u): u is string => !!u)
      const httpWrites = (relayList?.httpWrite ?? [])
        .map((u) => normalizeHttpRelayUrl(u) || u)
        .filter((u): u is string => !!u)
      const userWritesOrdered = dedupeNormalizeRelayUrlsOrdered([...httpWrites, ...wsWrites])
      relays = this.filterPublishingRelays(
        buildPrioritizedWriteRelayUrls({
          userWriteRelays: userWritesOrdered,
          authorReadRelays: authorInboxFromContext,
          favoriteRelays: favoriteRelayUrls ?? [],
          extraRelays: bootstrapExtras,
          maxRelays: MAX_PUBLISH_RELAYS,
          ...writeRelayPubOpts
        }),
        event
      )
      if (
        event.kind === kinds.RelayList ||
        event.kind === ExtendedKind.FAVORITE_RELAYS ||
        event.kind === kinds.Relaysets
      ) {
        logger.info('[DetermineTargetRelays] Final relay list for event publication', {
          kind: event.kind,
          totalRelayCount: relays.length,
          userWriteRelays: userWritesOrdered.slice(0, MAX_PUBLISH_RELAYS),
          additionalRelays: dedupeNormalizeRelayUrlsOrdered(bootstrapExtras),
          allRelays: relays
        })
      }
    }

    // Fallback for all publishing when no relays (e.g. after cache clear or fetch failure).
    // Use FAST_WRITE_RELAY_URLS so writes always have known-good write relays.
    if (!relays.length) {
      relays = isDocumentRelayKind(event.kind)
        ? dedupeNormalizeRelayUrlsOrdered([...FAST_WRITE_RELAY_URLS, ...DOCUMENT_RELAY_URLS])
        : [...FAST_WRITE_RELAY_URLS]
      logger.info('[DetermineTargetRelays] Using default write relays (no user/extra relays)', {
        count: relays.length
      })
    }

    relays = this.filterPublishingRelays(relays, event)

    if (specifiedRelayUrls?.length) {
      const checkedCount = specifiedRelayUrls.length
      relays = await this.prioritizePublishUrlListWithTimeout(relays, event, favoriteRelayUrls ?? [])
      if (checkedCount > relays.length) {
        logger.info('[Publish] Relay picker: checked count exceeds per-publish cap (stage 1)', {
          checkedInRelayPicker: checkedCount,
          keptAfterOutboxInboxPriorityCap: relays.length,
          maxPublishRelays: MAX_PUBLISH_RELAYS
        })
      }
    } else {
      relays = dedupeNormalizeRelayUrlsOrdered(relays).slice(0, MAX_PUBLISH_RELAYS)
    }
    return relays
  }

  /** One failed publish or subscribe connection per normalized URL (accumulates until {@link SESSION_RELAY_FAILURE_STRIKE_THRESHOLD}). */
  /** NOTICE "failed to fetch events" (relay DB/backend) — same session strike as a failed connection. */
  private notifySessionRelayStrikesChanged(affectedUrl?: string): void {
    if (typeof window === 'undefined') return
    window.dispatchEvent(
      new CustomEvent(JUMBLE_SESSION_RELAY_STRIKES_CHANGED, {
        detail: { url: affectedUrl }
      })
    )
  }

  /** Strikes accumulated this session for this relay (connection / NOTICE failures). */
  getSessionRelayStrikeCountForUrl(url: string): number {
    const n = normalizeAnyRelayUrl(url) || url
    return this.publishStrikeCount.get(n) ?? 0
  }

  getSessionRelayFailureStrikeThreshold(): number {
    return ClientService.SESSION_RELAY_FAILURE_STRIKE_THRESHOLD
  }

  /** True when this relay is skipped for reads/publishes until strikes are cleared. */
  isSessionRelayStrikedForReads(url: string): boolean {
    return this.getSessionRelayStrikeCountForUrl(url) >= this.getSessionRelayFailureStrikeThreshold()
  }

  private recordRelayNoticeFetchFailure(url: string, noticeMessage: string) {
    const n = normalizeAnyRelayUrl(url) || url
    if (!n) return
    const prev = this.publishStrikeCount.get(n) ?? 0
    if (prev >= ClientService.SESSION_RELAY_FAILURE_STRIKE_THRESHOLD) {
      return
    }
    logger.info('[Relay] NOTICE failed-fetch → session strike', {
      url: n,
      noticeSnippet: noticeMessage.slice(0, 220)
    })
    this.recordSessionRelayFailure(url)
  }

  private recordSessionRelayFailure(url: string) {
    const n = normalizeAnyRelayUrl(url) || url
    if (!n) return
    const prev = this.publishStrikeCount.get(n) ?? 0
    if (prev >= ClientService.SESSION_RELAY_FAILURE_STRIKE_THRESHOLD) {
      return
    }
    const count = prev + 1
    this.publishStrikeCount.set(n, count)
    if (count === ClientService.SESSION_RELAY_FAILURE_STRIKE_THRESHOLD) {
      logger.info('[Relay] Session strike threshold — relay skipped for reads/publishes until reload', {
        url: n,
        strikes: count
      })
    }
    this.notifySessionRelayStrikesChanged(n)
  }

  private filterSessionStrikedRelays(urls: string[]): string[] {
    return urls.filter((u) => {
      const n = normalizeAnyRelayUrl(u) || u
      return (this.publishStrikeCount.get(n) ?? 0) < ClientService.SESSION_RELAY_FAILURE_STRIKE_THRESHOLD
    })
  }

  /**
   * If every URL was session-striked, clear strikes once so reads/publishes can retry (mobile WebSocket churn).
   */
  clearSessionRelayStrikes(): void {
    if (this.publishStrikeCount.size === 0) return
    logger.info('[Relay] Session relay strikes cleared', { relayCount: this.publishStrikeCount.size })
    this.publishStrikeCount.clear()
    this.notifySessionRelayStrikesChanged()
  }

  /**
   * Clear session failure strikes for one normalized relay URL so reads and publishes use it again
   * until new failures accrue (same counter as {@link clearSessionRelayStrikes}).
   */
  clearSessionRelayStrikeForUrl(url: string): boolean {
    const n = normalizeAnyRelayUrl(url) || url
    if (!n) return false
    const had = this.publishStrikeCount.delete(n)
    if (had) {
      logger.info('[Relay] Session strikes cleared for relay (manual)', { url: n })
      this.notifySessionRelayStrikesChanged(n)
    }
    return had
  }

  /**
   * Apply strike filter; if that removes all candidates while some were provided, clear strikes **for those URLs
   * only** and retry once. (A global clear here caused storms: e.g. NIP-65 outbox retry with 2 relays wiped strikes
   * for every relay in the tab session.)
   */
  private relayUrlsAfterStrikesOrRecover(urls: string[]): string[] {
    const unique = Array.from(new Set(urls))
    const filtered = this.filterSessionStrikedRelays(unique)
    if (filtered.length === 0 && unique.length > 0) {
      let cleared = 0
      for (const u of unique) {
        // HTTP index relays (CORS down, wrong origin) do not recover like WebSockets; clearing their strikes
        // here caused retry storms with many parallel fetchEvents hitting the same dead endpoint.
        if (isHttpRelayUrl(u)) continue
        const n = normalizeAnyRelayUrl(u) || u
        if (n && this.publishStrikeCount.delete(n)) cleared += 1
      }
      if (cleared === 0) return filtered
      logger.info('[Relay] Batch was all session-striked — cleared strikes for this batch only', {
        batchUrlCount: unique.length,
        strikeEntriesCleared: cleared
      })
      this.notifySessionRelayStrikesChanged()
      return this.filterSessionStrikedRelays(unique)
    }
    return filtered
  }

  /** Record a successful publish and its latency for session-based preference when selecting random relays. */
  recordPublishSuccess(url: string, latencyMs: number) {
    const n = normalizeAnyRelayUrl(url) || url
    const cur = this.sessionRelayPublishStats.get(n)
    if (cur) {
      cur.successCount += 1
      cur.sumLatencyMs += latencyMs
    } else {
      this.sessionRelayPublishStats.set(n, { successCount: 1, sumLatencyMs: latencyMs })
    }
  }

  /**
   * Relays that returned OK on at least one publish this session — merged ahead of NIP-66 lively list
   * so they stay in the random-relay pool even if not currently in monitoring data.
   */
  getSessionSuccessfulPublishRelayUrlsForRandomPool(): string[] {
    const readOnlySet = new Set(READ_ONLY_RELAY_URLS.map((u) => normalizeUrl(u) || u))
    const out: string[] = []
    for (const [url, stats] of this.sessionRelayPublishStats.entries()) {
      if (stats.successCount < 1) continue
      const n = normalizeAnyRelayUrl(url) || url
      if (!n || readOnlySet.has(n)) continue
      if ((this.publishStrikeCount.get(n) ?? 0) >= ClientService.SESSION_RELAY_FAILURE_STRIKE_THRESHOLD) continue
      out.push(n)
    }
    out.sort((a, b) => {
      const sa = this.sessionRelayPublishStats.get(a)!
      const sb = this.sessionRelayPublishStats.get(b)!
      if (sb.successCount !== sa.successCount) return sb.successCount - sa.successCount
      return sa.sumLatencyMs / sa.successCount - sb.sumLatencyMs / sb.successCount
    })
    return out
  }

  /**
   * Session-only debug info for the Session Relays settings tab: working/striked preset relays and scored random relays.
   * Strikes accrue from failed publishes and failed subscribe/query connections (same counter).
   */
  getSessionRelayDebug(): {
    strikedUrls: string[]
    scoredRelays: { url: string; successCount: number; avgLatencyMs: number }[]
    presetWorking: string[]
    presetStriked: string[]
  } {
    const presetSet = new Set<string>()
    for (const u of [...FAST_WRITE_RELAY_URLS, ...FAST_READ_RELAY_URLS]) {
      const n = normalizeUrl(u) || u
      if (n) presetSet.add(n)
    }
    const preset = Array.from(presetSet)
    const strikedUrls = Array.from(this.publishStrikeCount.entries())
      .filter(([, count]) => count >= ClientService.SESSION_RELAY_FAILURE_STRIKE_THRESHOLD)
      .map(([url]) => url)
    const presetStriked = preset.filter(
      (url) => (this.publishStrikeCount.get(url) ?? 0) >= ClientService.SESSION_RELAY_FAILURE_STRIKE_THRESHOLD
    )
    const presetWorking = preset.filter(
      (url) => (this.publishStrikeCount.get(url) ?? 0) < ClientService.SESSION_RELAY_FAILURE_STRIKE_THRESHOLD
    )
    const scoredRelays = Array.from(this.sessionRelayPublishStats.entries()).map(([url, s]) => ({
      url,
      successCount: s.successCount,
      avgLatencyMs: Math.round(s.sumLatencyMs / s.successCount)
    }))
    scoredRelays.sort((a, b) => a.avgLatencyMs - b.avgLatencyMs)
    return { strikedUrls, scoredRelays, presetWorking, presetStriked }
  }

  /**
   * From a list of candidate relay URLs (e.g. public lively), return up to `count` relays,
   * preferring those that have succeeded and been fast this session. Excludes 3-strike and read-only relays.
   */
  getPreferredRelaysForRandom(candidateUrls: string[], count: number): string[] {
    const readOnlySet = new Set(READ_ONLY_RELAY_URLS.map((u) => normalizeAnyRelayUrl(u) || u))
    const normalizedCandidates = candidateUrls
      .map((u) => normalizeAnyRelayUrl(u) || u)
      .filter((n) => n && !readOnlySet.has(n))
    const unique = Array.from(new Set(normalizedCandidates))
    const notStruckOut = unique.filter(
      (n) => (this.publishStrikeCount.get(n) ?? 0) < ClientService.SESSION_RELAY_FAILURE_STRIKE_THRESHOLD
    )
    const preferred: string[] = []
    const rest: string[] = []
    for (const url of notStruckOut) {
      const stats = this.sessionRelayPublishStats.get(url)
      if (stats && stats.successCount >= 1) preferred.push(url)
      else rest.push(url)
    }
    preferred.sort((a, b) => {
      const sa = this.sessionRelayPublishStats.get(a)!
      const sb = this.sessionRelayPublishStats.get(b)!
      if (sb.successCount !== sa.successCount) return sb.successCount - sa.successCount
      const avgA = sa.sumLatencyMs / sa.successCount
      const avgB = sb.sumLatencyMs / sb.successCount
      return avgA - avgB
    })
    const result: string[] = []
    let pi = 0
    let ri = 0
    // Preserve candidate order (e.g. NIP-66 write-proven relays first); avoid full shuffle so monitoring hints apply.
    const orderedRest = rest.slice()
    while (result.length < count && (pi < preferred.length || ri < orderedRest.length)) {
      if (pi < preferred.length) {
        result.push(preferred[pi++])
      } else if (ri < orderedRest.length) {
        result.push(orderedRest[ri++])
      }
    }
    return result.slice(0, count)
  }

  async publishEvent(relayUrls: string[], event: NEvent, publishExtras?: TPublishEventExtras) {
    const skipOutboxRetry = publishExtras?.skipOutboxRetry === true
    let userOutboxUrls: string[] = []
    let mergedRelayUrls = relayUrls
    if (!skipOutboxRetry) {
      userOutboxUrls = await this.getUserOutboxRelayUrlsForPublish(event)
      mergedRelayUrls =
        userOutboxUrls.length > 0
          ? dedupeNormalizeRelayUrlsOrdered([...userOutboxUrls, ...relayUrls])
          : relayUrls
    }

    const readOnlySet = new Set(READ_ONLY_RELAY_URLS.map((u) => normalizeAnyRelayUrl(u) || u))
    const socialKindBlockedSet = new Set(SOCIAL_KIND_BLOCKED_RELAY_URLS.map((u) => normalizeUrl(u) || u))
    let filtered = mergedRelayUrls.filter((url) => {
      const n = normalizeAnyRelayUrl(url) || url
      if (readOnlySet.has(n)) return false
      if (isSocialKindBlockedKind(event.kind) && socialKindBlockedSet.has(n)) return false
      return true
    })
    filtered = Array.from(new Set(filtered))
    filtered = this.relayUrlsAfterStrikesOrRecover(filtered)
    const countAfterFiltersBeforeCap = filtered.length
    filtered = await this.capPublishRelayUrlsForPublish(
      filtered,
      event,
      publishExtras?.favoriteRelayUrls ?? []
    )

    const uniqueRelayUrls = filtered

    if (relayUrls.length !== uniqueRelayUrls.length || mergedRelayUrls.length !== uniqueRelayUrls.length) {
      logger.info('[PublishEvent] Publish target relays (UI selection vs actually contacted)', {
        eventId: event.id?.substring(0, 12),
        kind: event.kind,
        maxPublishRelays: MAX_PUBLISH_RELAYS,
        fromPickerOrDetermineCount: relayUrls.length,
        afterMergeWithYourOutboxes: mergedRelayUrls.length,
        afterReadonlySocialAndStrikeFilter: countAfterFiltersBeforeCap,
        finalContactedRelayCount: uniqueRelayUrls.length,
        finalRelays: uniqueRelayUrls,
        explain:
          'Your NIP-65 write relays are prepended, then the list is de-duplicated, filtered (read-only / social-kind blocks / session strike skips), and capped at maxPublishRelays in outbox→inbox→favorite→fast-write priority. Unchecked relays in the picker are never contacted; checked relays beyond the cap or filtered out are also skipped.'
      })
    }

    logger.debug('[PublishEvent] Starting publishEvent', {
      eventId: event.id?.substring(0, 8),
      kind: event.kind,
      relayCount: uniqueRelayUrls.length,
      relayUrlsPassedInCount: relayUrls.length
    })
    if (uniqueRelayUrls.length === 0) {
      const emptyBatch = new RelayPublishOpBatch('ClientService.publishEvent', event.id, [])
      emptyBatch.logBegin()
      emptyBatch.logEnd('no_targets')
      return Promise.resolve({
        success: false,
        relayStatuses: [],
        successCount: 0,
        totalCount: 0
      })
    }
    if (
      event.kind === kinds.RelayList ||
      event.kind === ExtendedKind.HTTP_RELAY_LIST ||
      event.kind === ExtendedKind.FAVORITE_RELAYS ||
      event.kind === kinds.Relaysets
    ) {
      logger.info('[PublishEvent] Publishing event to relays', {
        eventId: event.id?.substring(0, 8),
        kind: event.kind,
        totalRelayCount: uniqueRelayUrls.length,
        allRelays: uniqueRelayUrls
      })
    } else {
      logger.debug('[PublishEvent] Unique relays', { count: uniqueRelayUrls.length, relays: uniqueRelayUrls.slice(0, 5) })
    }

    const publishBatchSource = publishExtras?.publishBatchLabel
      ? `publish — ${publishExtras.publishBatchLabel}`
      : 'ClientService.publishEvent'
    if (publishExtras?.publishBatchLabel) {
      const idBit =
        event.id && /^[0-9a-f]{64}$/i.test(event.id) ? `${event.id.slice(0, 12)}…` : '(unsigned or no id)'
      logger.info(`[Publish] ${publishExtras.publishBatchLabel}`, {
        readable: `Kind ${event.kind} note ${idBit} → ${uniqueRelayUrls.length} relay(s): ${uniqueRelayUrls.map(relayHostForUserLog).join(', ')}`,
        targets: uniqueRelayUrls.map((url) => ({ where: relayHostForUserLog(url), url }))
      })
    }

    const relayStatuses: { url: string; success: boolean; error?: string }[] = []
    const publishOpBatch = new RelayPublishOpBatch(publishBatchSource, event.id, uniqueRelayUrls)
    publishOpBatch.logBegin()

    // eslint-disable-next-line @typescript-eslint/no-this-alias
    const client = this
    return new Promise<{ success: boolean; relayStatuses: typeof relayStatuses; successCount: number; totalCount: number }>((resolve) => {
      let successCount = 0
      let finishedCount = 0
      const errors: { url: string; error: any }[] = []
      let publishOpBatchFlushed = false
      const flushPublishOpBatch = (status: string) => {
        if (publishOpBatchFlushed) return
        publishOpBatchFlushed = true
        uniqueRelayUrls.forEach((url, idx) => {
          const rs = [...relayStatuses].reverse().find((r) => r.url === url)
          publishOpBatch.record(idx, url, rs?.success === true, rs?.error)
        })
        publishOpBatch.logEnd(status)
      }

      logger.debug('[PublishEvent] Setting up global timeout (30 seconds)')
      let hasResolved = false

      // Add a global timeout to prevent hanging - use 30 seconds for faster feedback
      const globalTimeout = setTimeout(() => {
        if (hasResolved) {
          logger.debug('[PublishEvent] Already resolved, ignoring timeout')
          return
        }
        
        logger.warn('[PublishEvent] Global timeout reached!', {
          finishedCount,
          totalRelays: uniqueRelayUrls.length,
          successCount,
          relayStatusesCount: relayStatuses.length
        })
        
        // Mark any unfinished relays as failed
        uniqueRelayUrls.forEach(url => {
          const alreadyFinished = relayStatuses.some(rs => rs.url === url)
          if (!alreadyFinished) {
            logger.warn('[PublishEvent] Marking relay as timed out', { url })
            relayStatuses.push({ url, success: false, error: 'Timeout: Operation took too long' })
            client.recordSessionRelayFailure(url)
            finishedCount++
          }
        })
        
        // Ensure we resolve even if not all relays finished
        if (!hasResolved) {
          hasResolved = true
          logger.debug('[PublishEvent] Resolving due to timeout', {
            success: successCount >= uniqueRelayUrls.length / 3,
            successCount,
            totalCount: uniqueRelayUrls.length,
            relayStatuses: relayStatuses.length
          })
          flushPublishOpBatch('global_timeout')
          resolve({
            success: successCount >= uniqueRelayUrls.length / 3,
            relayStatuses,
            successCount,
            totalCount: uniqueRelayUrls.length
          })
        }
      }, 30_000) // 30 seconds global timeout (reduced from 2 minutes)

      logger.debug('[PublishEvent] Starting Promise.allSettled for all relays')
      const relayPublishAllSettled = Promise.allSettled(
        uniqueRelayUrls.map(async (url, index) => {
          const startMs = Date.now()
          logger.debug(`[PublishEvent] Starting relay ${index + 1}/${uniqueRelayUrls.length}`, { url })
          // eslint-disable-next-line @typescript-eslint/no-this-alias
          const that = this
          const isLocal = isLocalNetworkUrl(url)
          const connectionTimeout = isLocal ? 5_000 : 8_000 // 5s for local, 8s for remote
          const publishTimeout = isLocal ? 5_000 : 8_000 // 5s for local, 8s for remote
          
          // Set up a per-relay timeout to ensure we always reach the finally block
          const relayTimeout = setTimeout(() => {
            logger.warn(`[PublishEvent] Per-relay timeout for ${url}`, { connectionTimeout, publishTimeout })
            // This will be caught in the catch block if the promise is still pending
          }, connectionTimeout + publishTimeout + 2_000) // Add 2s buffer
          
          try {
            if (isHttpRelayUrl(url)) {
              const base = normalizeHttpRelayUrl(url) || url
              logger.debug(`[PublishEvent] Publishing to HTTP index relay`, { url: base })
              await Promise.race([
                publishEventToHttpRelay(base, event),
                new Promise<never>((_, reject) =>
                  setTimeout(() => reject(new Error(`HTTP publish timeout after ${publishTimeout}ms`)), publishTimeout)
                )
              ])
              that.recordPublishSuccess(url, Date.now() - startMs)
              that.queryService.trackEventSeenOnByUrl(event.id, base)
              successCount++
              relayStatuses.push({ url, success: true })
              return
            }

            // For local relays, add a connection timeout
            let relay: Relay
            logger.debug(`[PublishEvent] Ensuring relay connection`, { url, isLocal, connectionTimeout })

            const connectionPromise = isLocal
              ? Promise.race([
                  this.pool.ensureRelay(url),
                  new Promise<Relay>((_, reject) =>
                    setTimeout(() => reject(new Error('Local relay connection timeout')), connectionTimeout)
                  )
                ])
              : Promise.race([
                  this.pool.ensureRelay(url),
                  new Promise<Relay>((_, reject) =>
                    setTimeout(() => reject(new Error('Remote relay connection timeout')), connectionTimeout)
                  )
                ])

            relay = await connectionPromise
            logger.debug(`[PublishEvent] Relay connected`, { url })
            const relayKeyPub = normalizeUrl(url) || url
            patchRelayNoticeForFetchFailures(relay as unknown as AbstractRelay, relayKeyPub, (u, m) =>
              that.recordRelayNoticeFetchFailure(u, m)
            )

            relay.publishTimeout = publishTimeout
            
            logger.debug(`[PublishEvent] Publishing to relay`, { url })
            
            // Wrap publish in a timeout promise
            const publishPromise = relay
              .publish(event)
              .then(() => {
                logger.debug(`[PublishEvent] Successfully published to relay`, { url })
                that.recordPublishSuccess(url, Date.now() - startMs)
                this.trackEventSeenOn(event.id, relay)
                successCount++
                relayStatuses.push({ url, success: true })
              })
              .catch((error) => {
                logger.warn(`[PublishEvent] Publish failed, checking if auth required`, { url, error: error.message })
                if (
                  error instanceof Error &&
                  isRelayAuthRequiredErrorMessage(error.message) &&
                  that.canSignerAuthenticateRelay()
                ) {
                  logger.debug(`[PublishEvent] Auth required, attempting authentication`, { url })
                  applyRelayNip42AckTimeout(relay)
                  return authenticateNip42Relay(relay, (authEvt: EventTemplate) =>
                    queueRelayAuthSign(() => that.signer!.signEvent(authEvt))
                  )
                    .then(() => {
                      logger.debug(`[PublishEvent] Auth successful, retrying publish`, { url })
                      return relay.publish(event)
                    })
                    .then(() => {
                      logger.debug(`[PublishEvent] Successfully published after auth`, { url })
                      that.recordPublishSuccess(url, Date.now() - startMs)
                      this.trackEventSeenOn(event.id, relay)
                      successCount++
                      relayStatuses.push({ url, success: true })
                    })
                    .catch((authError) => {
                      logger.error(`[PublishEvent] Auth or publish failed`, { url, error: authError.message })
                      errors.push({ url, error: authError })
                      relayStatuses.push({ url, success: false, error: authError.message })
                      that.recordSessionRelayFailure(url)
                    })
                } else {
                  logger.error(`[PublishEvent] Publish failed`, { url, error: error.message })
                  errors.push({ url, error })
                  relayStatuses.push({ url, success: false, error: error.message })
                  that.recordSessionRelayFailure(url)
                }
              })
            
            // Add a timeout wrapper for the entire publish operation
            await Promise.race([
              publishPromise,
              new Promise<void>((_, reject) =>
                setTimeout(() => reject(new Error(`Publish timeout after ${publishTimeout}ms`)), publishTimeout)
              )
            ])
          } catch (error) {
            const softHttpDown =
              isHttpRelayUrl(url) &&
              (error instanceof IndexRelayTransportError || isIndexRelayTransportFailure(error))
            if (softHttpDown) {
              logger.debug('[PublishEvent] HTTP index relay unreachable', {
                url,
                error: error instanceof Error ? error.message : String(error)
              })
            } else {
              logger.error(`[PublishEvent] Connection or setup failed`, {
                url,
                error: error instanceof Error ? error.message : String(error)
              })
            }
            errors.push({ url, error })
            relayStatuses.push({
              url,
              success: false,
              error: error instanceof Error ? error.message : 'Connection failed'
            })
            that.recordSessionRelayFailure(url)
          } finally {
            clearTimeout(relayTimeout)
            const currentFinished = ++finishedCount
            logger.debug(`[PublishEvent] Relay finished`, { 
              url, 
              finishedCount: currentFinished, 
              totalRelays: uniqueRelayUrls.length,
              successCount 
            })
            
            // If one third of the relays have accepted the event, consider it a success
            const isSuccess = successCount >= uniqueRelayUrls.length / 3
            if (isSuccess) {
              this.emitNewEvent(event)
            }
            if (currentFinished >= uniqueRelayUrls.length && !hasResolved) {
              hasResolved = true
              logger.debug('[PublishEvent] All relays finished, resolving', {
                success: successCount >= uniqueRelayUrls.length / 3,
                successCount,
                totalCount: uniqueRelayUrls.length,
                relayStatusesCount: relayStatuses.length
              })
              clearTimeout(globalTimeout)
              flushPublishOpBatch('all_relays_finished')
              resolve({
                success: successCount >= uniqueRelayUrls.length / 3,
                relayStatuses,
                successCount,
                totalCount: uniqueRelayUrls.length
              })
            }
            
            // Also resolve early if we have enough successes (1/3 of relays)
            // This prevents waiting for slow/failing relays
            if (!hasResolved && successCount >= Math.max(1, Math.ceil(uniqueRelayUrls.length / 3)) && currentFinished >= Math.max(1, Math.ceil(uniqueRelayUrls.length / 3))) {
              // Wait a bit more to see if more relays succeed quickly
              setTimeout(() => {
                if (!hasResolved) {
                  hasResolved = true
                  logger.debug('[PublishEvent] Resolving early with enough successes', {
                    success: true,
                    successCount,
                    totalCount: uniqueRelayUrls.length,
                    finishedCount: currentFinished,
                    relayStatusesCount: relayStatuses.length
                  })
                  clearTimeout(globalTimeout)
                  flushPublishOpBatch('early_success_threshold')
                  resolve({
                    success: true,
                    relayStatuses,
                    successCount,
                    totalCount: uniqueRelayUrls.length
                  })
                }
              }, 2000) // Wait 2 more seconds for quick responses
            }
          }
        })
      )

      if (!skipOutboxRetry && userOutboxUrls.length > 0) {
        void relayPublishAllSettled.then(() => {
          void client
            .retryFailedOutboxPublishesOnce(event, userOutboxUrls, relayStatuses)
            .catch((err) =>
              logger.warn(
                '[Publish] NIP-65 outbox retry (2nd attempt) failed — check the network or relay logs above',
                {
                  error: err instanceof Error ? err.message : String(err),
                  eventKind: event.kind,
                  eventId: event.id && /^[0-9a-f]{64}$/i.test(event.id) ? `${event.id.slice(0, 16)}…` : event.id
                }
              )
            )
        })
      }
    })
  }

  emitNewEvent(event: NEvent) {
    this.dispatchEvent(new CustomEvent('newEvent', { detail: event }))
  }

  async signHttpAuth(url: string, method: string, description = '') {
    if (!this.signer) {
      throw new Error('Please login first to sign the event')
    }
    const event = await this.signer?.signEvent({
      content: description,
      kind: kinds.HTTPAuth,
      created_at: dayjs().unix(),
      tags: [
        ['u', url],
        ['method', method]
      ]
    })
    return 'Nostr ' + btoa(JSON.stringify(event))
  }

  /** =========== Timeline =========== */

  private scheduleTimelinePersist(timelineKey: string): void {
    const prev = this.timelinePersistTimers.get(timelineKey)
    if (prev) clearTimeout(prev)
    const t = setTimeout(() => {
      this.timelinePersistTimers.delete(timelineKey)
      void this.flushTimelinePersist(timelineKey)
    }, 1600)
    this.timelinePersistTimers.set(timelineKey, t)
  }

  private async flushTimelinePersist(timelineKey: string): Promise<void> {
    const tl = this.timelines[timelineKey]
    if (!tl || Array.isArray(tl) || !tl.refs?.length) return
    try {
      await indexedDb.putTimelinePersistedState(timelineKey, {
        refs: [...tl.refs],
        filter: { ...(tl.filter as object) } as Record<string, unknown>,
        urls: [...tl.urls]
      })
    } catch (e) {
      logger.warn('[ClientService] Timeline persist failed', { timelineKey: timelineKey.slice(0, 12), e })
    }
  }

  private generateTimelineKey(urls: string[], filter: Filter) {
    const stableFilter: any = {}
    Object.entries(filter)
      .sort()
      .forEach(([key, value]) => {
        if (Array.isArray(value)) {
          stableFilter[key] = [...value].sort()
        }
        stableFilter[key] = value
      })
    const paramsStr = JSON.stringify({
      urls: [...urls].sort(),
      filter: stableFilter
    })
    const encoder = new TextEncoder()
    const data = encoder.encode(paramsStr)
    const hashBuffer = sha256(data)
    const hashArray = Array.from(new Uint8Array(hashBuffer))
    return hashArray.map((b) => b.toString(16).padStart(2, '0')).join('')
  }

  private generateMultipleTimelinesKey(subRequests: { urls: string[]; filter: Filter }[]) {
    const keys = subRequests.map(({ urls, filter }) => this.generateTimelineKey(urls, filter))
    const encoder = new TextEncoder()
    const data = encoder.encode(JSON.stringify(keys.sort()))
    const hashBuffer = sha256(data)
    const hashArray = Array.from(new Uint8Array(hashBuffer))
    return hashArray.map((b) => b.toString(16).padStart(2, '0')).join('')
  }

  async subscribeTimeline(
    subRequests: { urls: string[]; filter: TSubRequestFilter }[],
    {
      onEvents,
      onNew,
      onClose
    }: {
      onEvents: (events: NEvent[], eosed: boolean) => void
      onNew: (evt: NEvent) => void
      onClose?: (url: string, reason: string) => void
    },
    {
      startLogin,
      needSort = true,
      firstRelayResultGraceMs = FIRST_RELAY_RESULT_GRACE_MS,
      onRelaySubscribeWaveComplete
    }: {
      startLogin?: () => void
      needSort?: boolean
      /** Passed to each shard’s {@link ClientService._subscribeTimeline}: 2s after first event completes initial load if EOSE is slower. */
      firstRelayResultGraceMs?: number
      /** After every timeline shard’s REQ wave has ended (per-relay EOSE / close / timeout), merged rows in shard order. */
      onRelaySubscribeWaveComplete?: (rows: RelayOpTerminalRow[]) => void
    } = {}
  ) {
    const timelineBatchId = `tl-${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 9)}`
    const timelineT0 = performance.now()
    logger.debug('[RelayOp] timeline_wave_begin', {
      timelineBatchId,
      shardCount: subRequests.length,
      relayCountsPerShard: subRequests.map((r) => r.urls.length),
      shards: subRequests.map((s, shardIndex) => ({
        shardIndex,
        relayCount: s.urls.length,
        relaysSample: [...new Set(s.urls.map((u) => normalizeUrl(u) || u))].slice(0, 40),
        filter: compactFilterForRelayLog(s.filter as Filter)
      }))
    })
    logger.debug('[relay-req] timeline_batch_start', {
      timelineBatchId,
      subRequestCount: subRequests.length,
      relayCounts: subRequests.map((r) => r.urls.length)
    })

    const newEventIdSet = new Set<string>()
    const requestCount = subRequests.length
    let eventIdSet = new Set<string>()
    let events: NEvent[] = []
    let eosedCount = 0
    /** One merged buffer — slice using the largest child `limit` so a later child with a smaller limit cannot drop other relays’ events. */
    const mergedTimelineLimit = Math.max(
      500,
      ...subRequests.map(({ filter }) =>
        typeof filter.limit === 'number' && filter.limit > 0 ? filter.limit : 0
      )
    )

    let firstPaintLogged = false
    const deliverTimelineToConsumer = (snapshot: NEvent[], allEosed: boolean) => {
      if (!firstPaintLogged && snapshot.length > 0) {
        firstPaintLogged = true
        logger.debug('[relay-req] first_paint', {
          timelineBatchId,
          phase: 'data_to_feed',
          rowCount: snapshot.length,
          allEosed,
          ms: Math.round(performance.now() - timelineT0)
        })
      }
      onEvents(snapshot, allEosed)
    }

    let outerFlushQueued = false
    let outerFlushBump = 0
    const scheduleOuterFlush = (immediate = false) => {
      const run = () => {
        outerFlushQueued = false
        const snapshot = events.length ? [...events] : []
        const allEosed = eosedCount >= requestCount
        deliverTimelineToConsumer(snapshot, allEosed)
      }
      if (immediate || eosedCount >= requestCount || events.length <= 1) {
        outerFlushBump++
        outerFlushQueued = false
        run()
        return
      }
      if (!outerFlushQueued) {
        outerFlushQueued = true
        const b = outerFlushBump
        queueMicrotask(() => {
          if (b !== outerFlushBump) return
          run()
        })
      }
    }

    let subscribeWaveShardsRemaining = subRequests.length
    const subscribeWaveAcc: RelayOpTerminalRow[] = []
    const onShardSubscribeBatchEnd =
      onRelaySubscribeWaveComplete != null
        ? (rows: RelayOpTerminalRow[]) => {
            subscribeWaveAcc.push(...rows)
            subscribeWaveShardsRemaining--
            if (subscribeWaveShardsRemaining === 0) {
              onRelaySubscribeWaveComplete(subscribeWaveAcc.slice())
            }
          }
        : undefined

    const subs = await mapPoolWithConcurrency(
      subRequests,
      TIMELINE_SHARD_SUBSCRIBE_CONCURRENCY,
      ({ urls, filter }, shardIndex) =>
        this._subscribeTimeline(
          urls,
          filter,
          {
            onEvents: (_events, _eosed) => {
              if (_eosed) {
                eosedCount++
              }

              _events.forEach((evt) => {
                if (eventIdSet.has(evt.id)) return
                eventIdSet.add(evt.id)
                events.push(evt)
              })
              events = needSort
                ? events.sort((a, b) => b.created_at - a.created_at).slice(0, mergedTimelineLimit)
                : events.slice(0, mergedTimelineLimit)
              eventIdSet = new Set(events.map((evt) => evt.id))

              scheduleOuterFlush(!!_eosed)
            },
            onNew: (evt) => {
              if (newEventIdSet.has(evt.id)) return
              newEventIdSet.add(evt.id)
              onNew(evt)
            },
            onClose
          },
          {
            startLogin,
            needSort,
            firstRelayResultGraceMs,
            relayReqLog: {
              groupId: `${timelineBatchId}:shard${shardIndex}`,
              ...(onShardSubscribeBatchEnd
                ? { onBatchEnd: onShardSubscribeBatchEnd }
                : {})
            }
          }
        )
    )

    const key = this.generateMultipleTimelinesKey(subRequests)
    this.timelines[key] = subs.map((sub) => sub.timelineKey)

    return {
      closer: () => {
        onEvents = () => {}
        onNew = () => {}
        subs.forEach((sub) => {
          sub.closer()
        })
      },
      timelineKey: key
    }
  }

  /**
   * Append another {@link subscribeTimeline} composite’s leaf keys onto `primaryCompositeKey` so
   * {@link loadMoreTimeline} fans out to both waves. Removes `secondaryCompositeKey` from the map after merge.
   * Returns the leaf keys that were appended (for removal when the delta wave closes).
   */
  appendTimelinesToComposite(primaryCompositeKey: string, secondaryCompositeKey: string): string[] {
    const primary = this.timelines[primaryCompositeKey]
    const secondary = this.timelines[secondaryCompositeKey]
    if (!Array.isArray(primary) || !Array.isArray(secondary)) return []
    const added = secondary.slice()
    this.timelines[primaryCompositeKey] = [...primary, ...added]
    delete this.timelines[secondaryCompositeKey]
    return added
  }

  /** Undo part of {@link appendTimelinesToComposite} when a delta subscription is torn down. */
  removeTimelineLeavesFromComposite(compositeKey: string, leafKeys: string[]): void {
    if (leafKeys.length === 0) return
    const t = this.timelines[compositeKey]
    if (!Array.isArray(t)) return
    const drop = new Set(leafKeys)
    this.timelines[compositeKey] = t.filter((k) => !drop.has(k))
  }

  /**
   * Check if a timeline has more events available (either cached or from network)
   */
  hasMoreTimelineEvents(key: string, until: number): boolean {
    const timeline = this.timelines[key]
    if (!timeline) return false

    if (Array.isArray(timeline)) {
      // For multiple timelines, check if any has more events
      return timeline.some((subKey) => {
        const subTimeline = this.timelines[subKey]
        if (!subTimeline || Array.isArray(subTimeline)) return false
        const { refs } = subTimeline
        // Check if there are refs with created_at <= until that we haven't loaded
        return refs.some(([, createdAt]) => createdAt <= until)
      })
    }

    const { refs } = timeline
    // Check if there are refs with created_at <= until that we haven't loaded
    return refs.some(([, createdAt]) => createdAt <= until)
  }

  async loadMoreTimeline(key: string, until: number, limit: number) {
    const timeline = this.timelines[key]
    if (!timeline) return []

    if (!Array.isArray(timeline)) {
      return this._loadMoreTimeline(key, until, limit)
    }
    const timelines = await Promise.all(
      timeline.map((key) => this._loadMoreTimeline(key, until, limit))
    )

    const eventIdSet = new Set<string>()
    const events: NEvent[] = []
    timelines.forEach((timeline) => {
      timeline.forEach((evt) => {
        if (eventIdSet.has(evt.id)) return
        eventIdSet.add(evt.id)
        events.push(evt)
      })
    })
    return events.sort((a, b) => b.created_at - a.created_at).slice(0, limit)
  }

  subscribe(
    urls: string[],
    filter: Filter | Filter[],
    {
      onevent,
      oneose,
      onclose,
      startLogin,
      onAllClose
    }: {
      onevent?: (evt: NEvent) => void
      oneose?: (eosed: boolean) => void
      onclose?: (url: string, reason: string) => void
      startLogin?: () => void
      onAllClose?: (reasons: string[]) => void
    },
    relayReqLog?: { groupId?: string; onBatchEnd?: (rows: RelayOpTerminalRow[]) => void }
  ) {
    const originalDedupedRelays = Array.from(new Set(urls))
    let relays = originalDedupedRelays.filter((url) => !isHttpRelayUrl(url))
    // While offline, silently drop every non-local relay so nothing is added to
    // groupedRequests and no session strike is recorded for a connectivity-induced failure.
    if (!navigator.onLine) {
      relays = relays.filter((url) => isLocalNetworkUrl(url))
    }
    const filters = sanitizeSubscribeFiltersBeforeReq(filter)
    if (filters.length === 0) {
      logger.debug('[relay-req] batch_skip', {
        reason: 'no_filters_after_sanitize',
        filterSummary: summarizeFiltersForRelayLog(Array.isArray(filter) ? filter : [filter])
      })
      queueMicrotask(() => {
        oneose?.(true)
        relayReqLog?.onBatchEnd?.([])
      })
      return {
        close: () => {}
      }
    }

    relays = withDocumentRelayUrlsForFilters(relays, filters)

    const stripSocialBlockedRelays =
      SOCIAL_KIND_BLOCKED_RELAY_URLS.length > 0 &&
      filters.some((f) => relayFilterIncludesSocialKindBlockedKind(f))
    if (stripSocialBlockedRelays) {
      const socialKindBlockedSet = new Set(SOCIAL_KIND_BLOCKED_RELAY_URLS.map((u) => normalizeUrl(u) || u))
      const stripped = relays.filter((url) => !socialKindBlockedSet.has(normalizeUrl(url) || url))
      relays = relaysAfterSocialKindBlockedStrip(originalDedupedRelays, stripped)
    }
    if (relayFiltersUseCapitalLetterTagKeys(filters)) {
      relays = relayUrlsStripExtendedTagReqBlocked(relays)
      if (relays.length === 0) {
        relays = relayUrlsStripExtendedTagReqBlocked([...FAST_READ_RELAY_URLS])
      }
    }
    relays = this.relayUrlsAfterStrikesOrRecover(relays)

    // eslint-disable-next-line @typescript-eslint/no-this-alias
    const that = this
    const _knownIds = new Set<string>()

    // Group by relay (same as pool.subscribeMap) so one REQ per relay with all filters
    const grouped = new Map<string, Filter[]>()
    for (const url of relays) {
      const key = normalizeUrl(url) || url
      if (!grouped.has(key)) grouped.set(key, [])
      grouped.get(key)!.push(...filters)
    }
    const searchableSet = new Set([
      ...SEARCHABLE_RELAY_URLS.map((u) => normalizeUrl(u) || u),
      ...nip66Service.getSearchableRelayUrls().map((u) => normalizeUrl(u) || u)
    ])
    const groupedRequests = Array.from(grouped.entries()).map(([url, f]) => {
      const relaySupportsSearch = searchableSet.has(url) || nip66Service.isRelaySearchable(url)
      const filtersForRelay = f.map((one) => filterForRelay(one, relaySupportsSearch))
      return { url, filters: filtersForRelay }
    })

    // Social-kind queries drop SOCIAL_KIND_BLOCKED_RELAY_URLS; if every URL was removed, no subs run and
    // oneose would never fire — timelines stay loading forever (e.g. favorites feed).
    if (groupedRequests.length === 0) {
      logger.debug('[relay-req] batch_skip', {
        reason: 'no_relays_after_filters',
        filterSummary: summarizeFiltersForRelayLog(filters)
      })
      queueMicrotask(() => {
        oneose?.(true)
        relayReqLog?.onBatchEnd?.([])
      })
      return {
        close: () => {}
      }
    }

    const reqGroupId =
      relayReqLog?.groupId ??
      `sub-${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 10)}`
    const opBatch = new RelaySubscribeOpBatch(reqGroupId, groupedRequests, {
      onBatchEnd: relayReqLog?.onBatchEnd
    })
    opBatch.logBegin()
    const reqT0 = performance.now()
    let firstRelayResponseLogged = false
    /** When the first `first_response` was `eose` (no row yet), log once when the first EVENT arrives. */
    let awaitingFirstEventAfterEoseFirstResponse = false
    const logFirstRelayResponse = (kind: 'event' | 'eose', relayUrl: string) => {
      if (firstRelayResponseLogged) return
      firstRelayResponseLogged = true
      if (kind === 'eose') awaitingFirstEventAfterEoseFirstResponse = true
      logger.debug('[relay-req] first_response', {
        reqGroupId,
        kind,
        relayUrl,
        ms: Math.round(performance.now() - reqT0)
      })
    }
    const logFirstEventIfFirstResponseWasEmpty = (evt: NEvent, relayKey: string) => {
      if (!awaitingFirstEventAfterEoseFirstResponse) return
      awaitingFirstEventAfterEoseFirstResponse = false
      logger.debug('[relay-req] first_event', {
        reqGroupId,
        relayUrl: relayKey,
        eventId: evt.id,
        eventKind: evt.kind,
        ms: Math.round(performance.now() - reqT0),
        note: 'first_relay_response_was_eose_not_event'
      })
    }

    const eosesReceived: boolean[] = []
    const closesReceived: (string | undefined)[] = []
    const handleEose = (i: number) => {
      if (eosesReceived[i]) return
      eosesReceived[i] = true
      opBatch.setTerminal(i, 'eose')
      logFirstRelayResponse('eose', groupedRequests[i]!.url)
      if (eosesReceived.filter(Boolean).length === groupedRequests.length) {
        oneose?.(true)
      }
    }
    const handleClose = (i: number, reason: string) => {
      if (closesReceived[i] !== undefined) return
      handleEose(i)
      closesReceived[i] = reason
      opBatch.setTerminal(i, 'closed', reason)
      const { url } = groupedRequests[i]!
      onclose?.(url, reason)
      if (closesReceived.every((r) => r !== undefined)) {
        onAllClose?.(closesReceived as string[])
      }
    }

    const localAlreadyHaveEvent = (id: string) => {
      const have = _knownIds.has(id)
      if (have) return true
      _knownIds.add(id)
      return false
    }

    const forwardOnevent = onevent
      ? (evt: NEvent) => {
          if (shouldDropEventOnIngest(evt)) return
          onevent(evt)
        }
      : undefined

    const subs: { relayKey: string; close: () => void }[] = []
    /** Ignore a follow-up `closed by caller` while NIP-42 auth + resubscribe is in flight (parent `close()` must not finalize the batch early). */
    const nip42ResubscribePending = new Set<number>()
    const nip42HasAuthedOnce = new Set<number>()
    const allOpened = Promise.all(
      groupedRequests.map(async ({ url, filters: relayFilters }, i) => {
        await that.queryService.acquireGlobalRelayConnectionSlot()
        try {
          const relayKey = normalizeUrl(url) || url
          await that.queryService.acquireSubSlot(relayKey)
          let relay: AbstractRelay
          try {
            relay = await that.pool.ensureRelay(url, { connectionTimeout: RELAY_POOL_CONNECTION_TIMEOUT_MS })
            patchRelayNoticeForFetchFailures(relay, relayKey, (u, m) =>
              that.recordRelayNoticeFetchFailure(u, m)
            )
          } catch (err) {
            that.recordSessionRelayFailure(url)
            that.queryService.releaseSubSlot(relayKey)
            handleClose(i, (err as Error)?.message ?? String(err))
            return
          }

          let slotReleased = false
          const releaseOnce = () => {
            if (!slotReleased) {
              slotReleased = true
              that.queryService.releaseSubSlot(relayKey)
            }
          }

          const sub = relay.subscribe(relayFilters, {
            receivedEvent: (_relay, id) => that.trackEventSeenOn(id, _relay),
            onevent: (evt: NEvent) => {
              logFirstEventIfFirstResponseWasEmpty(evt, relayKey)
              logFirstRelayResponse('event', relayKey)
              forwardOnevent?.(evt)
            },
            oneose: () => handleEose(i),
            onclose: (reason: string) => {
              if (isRelaySubscriptionClosedByCaller(reason) && nip42ResubscribePending.has(i)) {
                return
              }
              releaseOnce()
              if (
                isRelayAuthRequiredCloseReason(reason) &&
                that.canSignerAuthenticateRelay() &&
                !nip42HasAuthedOnce.has(i)
              ) {
                nip42ResubscribePending.add(i)
                applyRelayNip42AckTimeout(relay)
                authenticateNip42Relay(relay, async (authEvt: EventTemplate) => {
                  const evt = await queueRelayAuthSign(() => that.signer!.signEvent(authEvt))
                  if (!evt) throw new Error('sign event failed')
                  return evt as VerifiedEvent
                })
                  .then(async () => {
                    nip42HasAuthedOnce.add(i)
                    await that.queryService.acquireGlobalRelayConnectionSlot()
                    try {
                      await that.queryService.acquireSubSlot(relayKey)
                      // After AUTH the socket may be closed or the relay dropped from the pool;
                      // resubscribe on a fresh connection from ensureRelay (fixes SendingOnClosedConnection).
                      let liveRelay: AbstractRelay
                      try {
                        liveRelay = await that.pool.ensureRelay(url, {
                          connectionTimeout: RELAY_POOL_CONNECTION_TIMEOUT_MS
                        })
                        patchRelayNoticeForFetchFailures(liveRelay, relayKey, (u, m) =>
                          that.recordRelayNoticeFetchFailure(u, m)
                        )
                      } catch (err) {
                        nip42ResubscribePending.delete(i)
                        that.recordSessionRelayFailure(url)
                        that.queryService.releaseSubSlot(relayKey)
                        handleClose(i, (err as Error)?.message ?? String(err))
                        return
                      }
                      let slotReleased2 = false
                      const releaseSlot2 = () => {
                        if (!slotReleased2) {
                          slotReleased2 = true
                          that.queryService.releaseSubSlot(relayKey)
                        }
                      }
                      try {
                        const sub2 = liveRelay.subscribe(relayFilters, {
                          receivedEvent: (_relay, id) => that.trackEventSeenOn(id, _relay),
                          onevent: (evt: NEvent) => {
                            logFirstEventIfFirstResponseWasEmpty(evt, relayKey)
                            logFirstRelayResponse('event', relayKey)
                            forwardOnevent?.(evt)
                          },
                          oneose: () => handleEose(i),
                          onclose: (reason2: string) => {
                            releaseSlot2()
                            handleClose(i, reason2)
                          },
                          alreadyHaveEvent: localAlreadyHaveEvent,
                          eoseTimeout: SUBSCRIBE_RELAY_EOSE_TIMEOUT_MS
                        })
                        logger.debug('[relay-req] req_sent', {
                          reqGroupId,
                          url: relayKey,
                          ms: Math.round(performance.now() - reqT0),
                          note: 'after_auth'
                        })
                        subs.push({
                          relayKey,
                          close: () => {
                            releaseSlot2()
                            sub2.close()
                          }
                        })
                        nip42ResubscribePending.delete(i)
                      } catch (err) {
                        nip42ResubscribePending.delete(i)
                        releaseSlot2()
                        handleClose(i, (err as Error)?.message ?? String(err))
                      }
                    } finally {
                      that.queryService.releaseGlobalRelayConnectionSlot()
                    }
                  })
                  .catch(() => {
                    nip42ResubscribePending.delete(i)
                    handleClose(i, reason)
                  })
                return
              }
              if (isRelayAuthRequiredCloseReason(reason)) {
                startLogin?.()
              }
              handleClose(i, reason)
            },
            alreadyHaveEvent: localAlreadyHaveEvent,
            eoseTimeout: SUBSCRIBE_RELAY_EOSE_TIMEOUT_MS
          })
          logger.debug('[relay-req] req_sent', {
            reqGroupId,
            url: relayKey,
            ms: Math.round(performance.now() - reqT0)
          })
          subs.push({
            relayKey,
            close: () => {
              releaseOnce()
              sub.close()
            }
          })
        } finally {
          that.queryService.releaseGlobalRelayConnectionSlot()
        }
      })
    )

    const handleNewEventFromInternal = (data: Event) => {
      const customEvent = data as CustomEvent<NEvent>
      const evt = customEvent.detail
      if (!matchFilters(filters, evt)) return
      if (shouldDropEventOnIngest(evt)) return

      const id = evt.id
      const have = _knownIds.has(id)
      if (have) return

      _knownIds.add(id)
      forwardOnevent?.(evt)
    }

    this.addEventListener('newEvent', handleNewEventFromInternal)

    return {
      close: () => {
        this.removeEventListener('newEvent', handleNewEventFromInternal)
        void allOpened.then(() => {
          subs.forEach(({ close: subClose }) => subClose())
          setTimeout(() => opBatch.finalize('closed', 'subscription_closed'), 0)
        })
      }
    }
  }

  private async _subscribeTimeline(
    urls: string[],
    filter: TSubRequestFilter, // filter with limit,
    {
      onEvents,
      onNew,
      onClose
    }: {
      onEvents: (events: NEvent[], eosed: boolean) => void
      onNew: (evt: NEvent) => void
      onClose?: (url: string, reason: string) => void
    },
    {
      startLogin,
      needSort = true,
      /**
       * After the **first** stored event arrives from any relay, wait this long then treat the initial
       * backlog as complete (same as aggregate EOSE): enables pagination + live `onNew` without waiting for
       * every slow/hung relay. Real EOSE still clears the timer and completes earlier if all relays finish first.
       */
      firstRelayResultGraceMs = FIRST_RELAY_RESULT_GRACE_MS,
      relayReqLog
    }: {
      startLogin?: () => void
      needSort?: boolean
      firstRelayResultGraceMs?: number
      /** Correlate {@link ClientService.subscribe} logs with a timeline shard */
      relayReqLog?: { groupId: string; onBatchEnd?: (rows: RelayOpTerminalRow[]) => void }
    } = {}
  ) {
    let relays = Array.from(new Set(urls))
    // While offline, strip non-local relays before any further processing so the
    // capital-letter-tag fallback below cannot re-introduce internet relays.
    if (!navigator.onLine) {
      relays = relays.filter((url) => isLocalNetworkUrl(url))
    }
    if (relayFiltersUseCapitalLetterTagKeys(filter as Filter)) {
      relays = relayUrlsStripExtendedTagReqBlocked(relays)
      if (relays.length === 0 && navigator.onLine) {
        relays = relayUrlsStripExtendedTagReqBlocked([...FAST_READ_RELAY_URLS])
      }
    }
    const key = this.generateTimelineKey(relays, filter)
    let timeline = this.timelines[key]

    if (!timeline || Array.isArray(timeline)) {
      this.timelines[key] = {
        refs: [],
        filter,
        urls: relays
      }
      timeline = this.timelines[key]
    }

    // eslint-disable-next-line @typescript-eslint/no-this-alias
    const that = this
    let events: NEvent[] = []
    /** `null` until initial backlog is considered complete; then wall-clock unix at completion (for straggler vs live). */
    let eosedAt: number | null = null
    let eventIds = new Set<string>()

    const httpTimelinePollBases = Array.from(
      new Set(
        relays
          .filter((u) => isHttpRelayUrl(u))
          .map((u) => normalizeHttpRelayUrl(u) || u)
          .filter(Boolean)
      )
    )
    let httpPollIntervalId: ReturnType<typeof setInterval> | null = null
    let httpPollCursorUnix = 0
    const clearHttpTimelinePoll = () => {
      if (httpPollIntervalId != null) {
        clearInterval(httpPollIntervalId)
        httpPollIntervalId = null
      }
    }

    let firstResultGraceTimer: ReturnType<typeof setTimeout> | null = null
    const clearFirstResultGraceTimer = () => {
      if (firstResultGraceTimer != null) {
        clearTimeout(firstResultGraceTimer)
        firstResultGraceTimer = null
      }
    }
    const armFirstResultGraceAfterFirstEvent = () => {
      if (eosedAt != null || firstResultGraceTimer != null) return
      if (events.length === 0) return
      if (firstRelayResultGraceMs <= 0) return
      firstResultGraceTimer = setTimeout(() => {
        firstResultGraceTimer = null
        if (eosedAt == null) {
          handleTimelineEose(true)
        }
      }, firstRelayResultGraceMs)
    }

    /**
     * Stream matching events to the UI immediately. Initial completion is either aggregate `oneose` from all
     * relays, or {@link firstRelayResultGraceMs} after the first event (whichever comes first).
     */
    let streamFlushMicrotask = false
    const flushStreamingSnapshot = () => {
      if (eosedAt) return
      const emit = () => {
        streamFlushMicrotask = false
        if (eosedAt) return
        if (needSort) {
          const sorted = [...events].sort((a, b) => b.created_at - a.created_at).slice(0, filter.limit)
          onEvents(sorted, false)
        } else {
          onEvents([...events], false)
        }
      }
      if (events.length <= 1) {
        streamFlushMicrotask = false
        emit()
        return
      }
      if (!streamFlushMicrotask) {
        streamFlushMicrotask = true
        queueMicrotask(emit)
      }
    }

    try {
      const st = await indexedDb.getTimelinePersistedState(key)
      if (st?.refs?.length) {
        const hexIds = st.refs.map((r) => r[0])
        const list = await indexedDb.getArchivedEventsByIds(hexIds)
        for (const ev of list) {
          if (shouldDropEventOnIngest(ev)) continue
          if (eventIds.has(ev.id)) continue
          eventIds.add(ev.id)
          events.push(ev)
        }
        for (const refId of hexIds) {
          if (eventIds.has(refId)) continue
          const sess = that.eventService.peekSessionCachedEvent(refId)
          if (sess && !shouldDropEventOnIngest(sess)) {
            eventIds.add(refId)
            events.push(sess)
          }
        }
        flushStreamingSnapshot()
      }
    } catch (err) {
      logger.warn('[ClientService] Timeline disk hydrate failed', err)
    }

    const applySubscribedTimelineEvent = (evt: NEvent) => {
      that.addEventToCache(evt)
      if (!eosedAt) {
        if (eventIds.has(evt.id)) return
        eventIds.add(evt.id)
        events.push(evt)
        flushStreamingSnapshot()
        armFirstResultGraceAfterFirstEvent()
        return
      }

      if (eventIds.has(evt.id)) return

      const wallClockAtEose = eosedAt
      const isBacklogStraggler = evt.created_at + TIMELINE_STRAGGLER_MAX_AGE_SEC < wallClockAtEose

      if (isBacklogStraggler) {
        eventIds.add(evt.id)
        events.push(evt)
        if (needSort) {
          events = events.sort((a, b) => b.created_at - a.created_at).slice(0, filter.limit)
        }
        eventIds = new Set(events.map((e) => e.id))
        onEvents([...events], false)

        const timeline = that.timelines[key]
        if (timeline && !Array.isArray(timeline)) {
          timeline.refs = events
            .map((e) => [e.id, e.created_at] as TTimelineRef)
            .sort((a, b) => b[1] - a[1])
          that.scheduleTimelinePersist(key)
        }
        return
      }

      eventIds.add(evt.id)
      onNew(evt)

      const timeline = that.timelines[key]
      if (!timeline || Array.isArray(timeline)) {
        return
      }

      if (timeline.refs.length === 0) {
        timeline.refs = events.map((e) => [e.id, e.created_at] as TTimelineRef).sort((a, b) => b[1] - a[1])
        that.scheduleTimelinePersist(key)
        return
      }

      let idx = 0
      for (const ref of timeline.refs) {
        if (evt.created_at > ref[1] || (evt.created_at === ref[1] && evt.id < ref[0])) {
          break
        }
        if (evt.created_at === ref[1] && evt.id === ref[0]) {
          return
        }
        idx++
      }
      if (idx >= timeline.refs.length) return

      timeline.refs.splice(idx, 0, [evt.id, evt.created_at])
      that.scheduleTimelinePersist(key)
    }

    const runHttpTimelinePollQuery = async (pollFilter: Filter) => {
      if (httpTimelinePollBases.length === 0) return
      try {
        await this.query(
          httpTimelinePollBases,
          pollFilter,
          (evt: NEvent) => {
            applySubscribedTimelineEvent(evt)
          },
          {
            firstRelayResultGraceMs: false,
            globalTimeout: 25_000,
            eoseTimeout: 2500
          }
        )
      } catch (err) {
        logger.debug('[ClientService] HTTP index timeline poll failed', err)
      }
    }

    const armHttpTimelinePollingAfterInitial = () => {
      clearHttpTimelinePoll()
      if (httpTimelinePollBases.length === 0) return
      const newestCreated = events.length > 0 ? Math.max(...events.map((e) => e.created_at)) : 0
      httpPollCursorUnix = Math.max(eosedAt ?? 0, newestCreated)
      httpPollIntervalId = setInterval(() => {
        const base = { ...(filter as Filter) } as Filter & { until?: number }
        delete base.until
        const since = Math.max(0, httpPollCursorUnix - HTTP_TIMELINE_POLL_SINCE_OVERLAP_SEC)
        const pollLimit = Math.min(Math.max(filter.limit ?? 200, 1), 500)
        const pollFilter: Filter = { ...base, since, limit: pollLimit }
        void runHttpTimelinePollQuery(pollFilter).then(() => {
          httpPollCursorUnix = dayjs().unix()
        })
      }, HTTP_TIMELINE_POLL_INTERVAL_MS)
    }

    const handleTimelineEose = (eosed: boolean) => {
      if (!eosed) return
      if (eosedAt != null) return

      clearFirstResultGraceTimer()

      eosedAt = dayjs().unix()

      if (!needSort) {
        armHttpTimelinePollingAfterInitial()
        return onEvents([...events], true)
      }

      events = events.sort((a, b) => b.created_at - a.created_at).slice(0, filter.limit)
      eventIds = new Set(events.map((e) => e.id))

      const tl = that.timelines[key]
      if (!tl || Array.isArray(tl)) {
        that.timelines[key] = {
          refs: events.map((evt) => [evt.id, evt.created_at]),
          filter,
          urls: relays
        }
      } else if (tl.refs.length === 0) {
        tl.refs = events.map((evt) => [evt.id, evt.created_at] as TTimelineRef)
      } else {
        const firstRefCreatedAt = tl.refs[0]![1]
        const newRefs = events
          .filter((evt) => evt.created_at > firstRefCreatedAt)
          .map((evt) => [evt.id, evt.created_at] as TTimelineRef)
        if (events.length >= filter.limit) {
          tl.refs = newRefs
        } else {
          tl.refs = newRefs.concat(tl.refs)
        }
      }
      armHttpTimelinePollingAfterInitial()
      onEvents([...events], true)
      that.scheduleTimelinePersist(key)
    }

    // HTTP index relays are handled via httpTimelinePollBases above — never pass them to the WS subscribe path.
    const wsRelays = relays.filter((u) => !isHttpRelayUrl(u))

    // When there are HTTP relays but NO WS relays, subscribe([]) would fire oneose + onBatchEnd
    // immediately (via microtask) — before the HTTP initial poll returns any events. That causes:
    //   (a) handleTimelineEose to set eosedAt=now with 0 events, so HTTP poll events arrive
    //       post-eose and land in onNew rather than the initial-load onEvents path.
    //   (b) onBatchEnd([]) (empty row array) → feedSubscribeRelayOutcomes stays length 0 →
    //       the "Looking for more events…" banner never clears.
    // Fix: for HTTP-only shards, skip oneose + relayReqLog on the (no-op) WS subscribe and
    // defer both to after the HTTP initial poll completes.
    const httpOnlyShard = httpTimelinePollBases.length > 0 && wsRelays.length === 0

    const subCloser = this.subscribe(wsRelays, filter, {
      startLogin,
      onevent: (evt: NEvent) => {
        applySubscribedTimelineEvent(evt)
      },
      oneose: httpOnlyShard ? undefined : handleTimelineEose,
      onclose: onClose
    },
    httpOnlyShard ? undefined : relayReqLog)

    if (httpTimelinePollBases.length > 0) {
      const backfillFilter = { ...(filter as Filter) } as Filter & { until?: number }
      delete backfillFilter.until
      const httpInitialPoll = runHttpTimelinePollQuery(backfillFilter)
      if (httpOnlyShard) {
        void httpInitialPoll.then(() => {
          // Report HTTP relay outcomes first so feedSubscribeRelayOutcomes is non-empty
          // before feedTimelineEmptyUiReady flips to true (both land in the same React batch).
          if (relayReqLog?.onBatchEnd) {
            const t0 = performance.now()
            const httpRows: RelayOpTerminalRow[] = httpTimelinePollBases.map((url, i) => ({
              cmdIndex: i,
              relayUrl: url,
              outcome: 'eose' as const,
              msFromBatchStart: Math.round(performance.now() - t0)
            }))
            relayReqLog.onBatchEnd(httpRows)
          }
          handleTimelineEose(true)
        })
      }
    }

    return {
      timelineKey: key,
      closer: () => {
        clearFirstResultGraceTimer()
        clearHttpTimelinePoll()
        onEvents = () => {}
        onNew = () => {}
        subCloser.close()
      }
    }
  }

  private async _loadMoreTimeline(key: string, until: number, limit: number) {
    const timeline = this.timelines[key]
    if (!timeline || Array.isArray(timeline)) return []

    const { filter, urls } = timeline

    let events = await this.query(urls, { ...filter, until, limit }, undefined, {
      firstRelayResultGraceMs: false,
      globalTimeout: 25_000,
      eoseTimeout: 2500
    })
    events.forEach((evt) => {
      this.addEventToCache(evt)
    })
    events = events.sort((a, b) => b.created_at - a.created_at).slice(0, limit)

    if (!timeline.refs) {
      timeline.refs = []
    }

    const existingRefIds = new Set(timeline.refs.map(([id]) => id))
    const newRefs: TTimelineRef[] = []
    for (const evt of events) {
      if (!existingRefIds.has(evt.id)) {
        newRefs.push([evt.id, evt.created_at])
        existingRefIds.add(evt.id)
      }
    }
    newRefs.sort((a, b) => b[1] - a[1])

    if (timeline.refs.length > 0) {
      const lastRefCreatedAt = timeline.refs[timeline.refs.length - 1][1]
      const olderRefs = newRefs.filter(([, createdAt]) => createdAt < lastRefCreatedAt)
      timeline.refs.push(...olderRefs)
      timeline.refs.sort((a, b) => b[1] - a[1])
    } else {
      timeline.refs.push(...newRefs)
    }

    this.scheduleTimelinePersist(key)
    return events
  }

  /** =========== Event =========== */

  getSeenEventRelays(eventId: string) {
    const key = canonicalSeenOnEventId(eventId)
    return Array.from(this.pool.seenOn.get(key)?.values() || [])
  }

  /**
   * Relays that delivered this event: {@link SimplePool.seenOn} (live subs) plus
   * {@link QueryService}’s map for `query()` / `fetchEvents` REQs.
   */
  getSeenEventRelayUrls(eventId: string): string[] {
    const key = canonicalSeenOnEventId(eventId)
    const poolUrls = this.getSeenEventRelays(key).map((r) => normalizeAnyRelayUrl(r.url) || r.url)
    const queryUrls = this.queryService.getSeenEventRelayUrls(key).map((u) => normalizeAnyRelayUrl(u) || u)
    return Array.from(new Set([...poolUrls, ...queryUrls].filter(Boolean)))
  }

  getEventHints(eventId: string) {
    return this.getSeenEventRelayUrls(eventId).filter((url) => !isLocalNetworkUrl(url))
  }

  getEventHint(eventId: string) {
    return this.getSeenEventRelayUrls(eventId).find((url) => !isLocalNetworkUrl(url)) ?? ''
  }

  trackEventSeenOn(eventId: string, relay: AbstractRelay) {
    const key = canonicalSeenOnEventId(eventId)
    let set = this.pool.seenOn.get(key)
    if (!set) {
      set = new Set()
      this.pool.seenOn.set(key, set)
    }
    set.add(relay)
  }

  // Delegate to QueryService
  private async query(
    urls: string[], 
    filter: Filter | Filter[], 
    onevent?: (evt: NEvent) => void,
    options?: { 
      eoseTimeout?: number
      globalTimeout?: number
      /** For replaceable events: race strategy - wait 2s after first result, then return best */
      replaceableRace?: boolean
      /** For non-replaceable single events: return immediately on first match */
      immediateReturn?: boolean
      firstRelayResultGraceMs?: number | false
    }
  ) {
    return this.queryService.query(urls, filter, onevent, options)
  }

  // Legacy query implementation removed - now delegated to QueryService

  async fetchEvents(
    urls: string[],
    filter: Filter | Filter[],
    {
      onevent,
      cache = false,
      eoseTimeout,
      globalTimeout,
      firstRelayResultGraceMs,
      replaceableRace,
      immediateReturn
    }: {
      onevent?: (evt: NEvent) => void
      cache?: boolean
      eoseTimeout?: number
      globalTimeout?: number
      firstRelayResultGraceMs?: number | false
      replaceableRace?: boolean
      immediateReturn?: boolean
    } = {}
  ) {
    const originalDedupedRelays = Array.from(new Set(urls))
    const httpRelayBases = Array.from(
      new Set(
        originalDedupedRelays
          .filter((u) => isHttpRelayUrl(u))
          .map((u) => normalizeHttpRelayUrl(u) || u)
          .filter(Boolean)
      )
    )
    const wsOriginal = originalDedupedRelays.filter((url) => !isHttpRelayUrl(url))
    let relays = [...wsOriginal]
    if (relays.length === 0 && httpRelayBases.length === 0) {
      relays = [...FAST_READ_RELAY_URLS]
    }
    const filters = Array.isArray(filter) ? filter : [filter]
    relays = withDocumentRelayUrlsForFilters(relays, filters)
    const stripSocialBlockedRelays =
      SOCIAL_KIND_BLOCKED_RELAY_URLS.length > 0 &&
      filters.some((f) => relayFilterIncludesSocialKindBlockedKind(f))
    if (stripSocialBlockedRelays) {
      const socialKindBlockedSet = new Set(SOCIAL_KIND_BLOCKED_RELAY_URLS.map((u) => normalizeUrl(u) || u))
      const stripped = relays.filter((url) => !socialKindBlockedSet.has(normalizeUrl(url) || url))
      relays = relaysAfterSocialKindBlockedStrip(wsOriginal, stripped)
    }
    relays = this.relayUrlsAfterStrikesOrRecover(relays)
    const queryRelays = dedupeNormalizeRelayUrlsOrdered([...relays, ...httpRelayBases])
    const events = await this.queryService.query(queryRelays, filter, onevent, {
      eoseTimeout,
      globalTimeout,
      firstRelayResultGraceMs,
      replaceableRace,
      immediateReturn
    })
    if (cache) {
      events.forEach((evt) => {
        this.addEventToCache(evt)
      })
    }
    return events
  }

  /**
   * Query one relay only (e.g. spell COUNT per-relay). Connection failures return `connectionError` instead of throwing.
   */
  async fetchEventsFromSingleRelay(
    url: string,
    filter: Filter | Filter[],
    options?: { globalTimeout?: number }
  ): Promise<{ events: NEvent[]; connectionError?: string }> {
    const normalized = normalizeAnyRelayUrl(url) || url
    if (!normalized) {
      return { events: [], connectionError: 'Invalid relay URL' }
    }
    if (isHttpRelayUrl(normalized)) {
      // HTTP index relay: use HTTP API instead of WebSocket pool
      try {
        const events = await this.queryService.query([normalized], filter, undefined, {
          globalTimeout: options?.globalTimeout ?? 25_000
        })
        return { events, connectionError: undefined }
      } catch (e) {
        return { events: [], connectionError: e instanceof Error ? e.message : String(e) }
      }
    }
    const usableAfterStrikes = this.relayUrlsAfterStrikesOrRecover([normalized])
    if (usableAfterStrikes.length === 0) {
      return { events: [], connectionError: 'Relay skipped this session (repeated failures)' }
    }
    const relayForConn = usableAfterStrikes[0]!
    try {
      await this.pool.ensureRelay(relayForConn, { connectionTimeout: RELAY_POOL_CONNECTION_TIMEOUT_MS })
    } catch (e) {
      this.recordSessionRelayFailure(relayForConn)
      const msg = e instanceof Error ? e.message : String(e)
      return { events: [], connectionError: msg }
    }
    try {
      const events = await this.queryService.query([relayForConn], filter, undefined, {
        globalTimeout: options?.globalTimeout ?? 25_000
      })
      return { events, connectionError: undefined }
    } catch (e) {
      return {
        events: [],
        connectionError: e instanceof Error ? e.message : String(e)
      }
    }
  }

  /**
   * Fetch a single event by id (hex, note1, nevent1, naddr1).
   * Relay order: (1) session/DataLoader cache (2) buildInitialRelayList (user's FAST_READ + favorite + read) or FAST_READ_RELAY_URLS
   * (3) for nevent/naddr: bech32 relay hints + author's read (inbox) + author's write (outbox) from kind 10002
   * (4) if still missing and filter has authors: author's read+write again in tryHarderToFetchEvent
   * (5) SEARCHABLE_RELAY_URLS as final fallback. Author relays are used so embedded notes load from the author's relays.
   */
  async fetchEvent(id: string): Promise<NEvent | undefined> {
    return this.eventService.fetchEvent(id)
  }

  // Legacy fetchEvent implementation removed - now delegated to EventService

  async fetchEventForceRetry(eventId: string): Promise<NEvent | undefined> {
    return this.eventService.fetchEventForceRetry(eventId)
  }

  /** Batch-prefetch by hex id into session cache (feed embeds). */
  async prefetchHexEventIds(hexIds: readonly string[]): Promise<void> {
    return this.eventService.prefetchHexEventIds(hexIds)
  }

  async fetchEventWithExternalRelays(eventId: string, externalRelays: string[]): Promise<NEvent | undefined> {
    return this.eventService.fetchEventWithExternalRelays(eventId, externalRelays)
  }

  addEventToCache(event: NEvent) {
    this.eventService.addEventToCache(event)
  }

  reapplySessionLruFromSettings(): void {
    this.eventService.reapplySessionLruMax()
  }

  peekSessionCachedEvent(noteId: string): NEvent | undefined {
    return this.eventService.peekSessionCachedEvent(noteId)
  }

  getSessionEventsMatchingSearch(query: string, limit: number, allowedKinds: number[]): NEvent[] {
    return this.eventService.getSessionEventsMatchingSearch(query, limit, allowedKinds)
  }


  async fetchFavoriteRelays(pubkey: string): Promise<string[]> {
    try {
      const favoriteRelaysEvent = await this.replaceableEventService.fetchReplaceableEvent(pubkey, ExtendedKind.FAVORITE_RELAYS)
      if (!favoriteRelaysEvent) return []

      const relays: string[] = []
      favoriteRelaysEvent.tags.forEach(([tagName, tagValue]) => {
        if (tagName === 'relay' && tagValue) {
          const normalized = normalizeUrl(tagValue)
          if (normalized) {
            relays.push(normalized)
          }
        }
      })

      return Array.from(new Set(relays))
    } catch {
      return []
    }
  }


  /** =========== Following favorite relays =========== */
  // Moved to ReplaceableEventService

  /** =========== Followings =========== */
  // Moved to ReplaceableEventService

  /** Part of {@link runSessionPrewarm}; batches followings to limit relay load. */
  private async initUserIndexFromFollowings(pubkey: string, signal: AbortSignal) {
    const followings = await this.replaceableEventService.fetchFollowings(pubkey)
    if (followings.length === 0) {
      logger.info('[client] Prewarm: following profiles skipped (no followings)', {
        pubkeySlice: pubkey.slice(0, 12)
      })
      return
    }
    logger.info('[client] Prewarm: following profile + NIP-65 relay list fetch started', {
      pubkeySlice: pubkey.slice(0, 12),
      followingCount: followings.length
    })
    let relayListResolved = 0
    const chunkSize = 20
    for (let i = 0; i * chunkSize < followings.length; i++) {
      if (signal.aborted) {
        logger.info('[client] Prewarm: following profiles + relay lists aborted', { pubkeySlice: pubkey.slice(0, 12) })
        return
      }
      const chunk = followings.slice(i * chunkSize, (i + 1) * chunkSize)
      const [relayListEvents] = await Promise.all([
        this.replaceableEventService.fetchReplaceableEventsFromProfileFetchRelays(chunk, kinds.RelayList),
        Promise.all(chunk.map((pk) => this.fetchProfileEvent(pk)))
      ])
      relayListResolved += relayListEvents.filter(Boolean).length
      await new Promise((resolve) => setTimeout(resolve, 1000))
    }
    logger.info('[client] Prewarm: following profile + NIP-65 relay list fetch finished', {
      pubkeySlice: pubkey.slice(0, 12),
      followingCount: followings.length,
      relayListEventsResolved: relayListResolved
    })
  }

  /** =========== Profile =========== */

  async searchProfiles(relayUrls: string[], filter: Filter): Promise<TProfile[]> {
    const events = await this.queryService.query(relayUrls, {
      ...filter,
      kinds: [kinds.Metadata]
    }, undefined, {
      replaceableRace: true,
      eoseTimeout: 200,
      globalTimeout: 3000
    })

    const profileEvents = events.sort((a, b) => b.created_at - a.created_at)
    await Promise.allSettled(profileEvents.map((profile) => this.addUsernameToIndex(profile)))
    profileEvents.forEach((profile) => this.updateProfileEventCache(profile))
    return profileEvents.map((profileEvent) => getProfileFromEvent(profileEvent))
  }

  async searchNpubsFromLocal(query: string, limit: number = 100) {
    const seen = new Set<string>()
    const out: string[] = []
    const pushNpub = (npub: string) => {
      if (!npub || seen.has(npub) || out.length >= limit) return
      seen.add(npub)
      out.push(npub)
    }
    for (const pk of this.eventService.searchSessionProfilePubkeys(query, limit)) {
      const npub = pubkeyToNpub(pk)
      if (npub) pushNpub(npub)
    }
    if (out.length >= limit) return out
    const remaining = limit - out.length
    const result = await this.userIndex.searchAsync(query, { limit: remaining * 4 })
    for (const pubkey of result) {
      const npub = pubkeyToNpub(pubkey as string)
      if (npub) pushNpub(npub)
      if (out.length >= limit) break
    }
    return out
  }

  /**
   * Npubs for @-mention dropdown: (1) follow-list profiles matching the query,
   * (2) local index, (3) relay search on SEARCHABLE_RELAY_URLS (same as search page).
   * Returns cached results immediately, then streams relay results via callback.
   */
  /**
   * Record a kind-5 deletion in the local tombstone store (no network).
   * Call after publishing a deletion so cache updates without waiting for a fetch.
   */
  async applyDeletionRequestToLocalCache(deletionEvent: NEvent): Promise<void> {
    await this.addTombstoneEntriesFromDeletionEvent(deletionEvent)
    const removed = await indexedDb.removeTombstonedFromCache()
    if (removed > 0) {
      logger.info('[ClientService] Removed tombstoned events from cache', { count: removed })
    }
    invalidateArchiveFootprintCache()
    dispatchTombstonesUpdated()
  }

  private async addTombstoneEntriesFromDeletionEvent(deletionEvent: NEvent): Promise<void> {
    const eTag = deletionEvent.tags.find((tag) => tag[0] === 'e')
    const aTag = deletionEvent.tags.find((tag) => tag[0] === 'a')
    const kTag = deletionEvent.tags.find((tag) => tag[0] === 'k')

    if (eTag?.[1]) {
      await indexedDb.addTombstone(eTag[1])
    } else if (aTag?.[1]) {
      await indexedDb.addTombstone(aTag[1])
    } else if (kTag?.[1] && deletionEvent.pubkey) {
      const kind = parseInt(kTag[1], 10)
      if (!isNaN(kind)) {
        await indexedDb.addTombstone(`${kind}:${deletionEvent.pubkey}`)
      }
    }
  }

  /**
   * Fetch kind-5 deletion events for an author, merge tombstones, remove matching rows from IndexedDB,
   * and notify the UI. Intended for **manual** refresh (e.g. cache settings); not run on every login.
   */
  async fetchDeletionEvents(relayUrls: string[] = [], authorPubkey?: string): Promise<void> {
    const pk = authorPubkey?.trim().toLowerCase()
    if (!pk || !/^[0-9a-f]{64}$/.test(pk)) return

    const urls = (relayUrls.length > 0 ? relayUrls : [...PROFILE_FETCH_RELAY_URLS])
      .map((u) => normalizeUrl(u) || u)
      .filter(Boolean)
    const capped = Array.from(new Set(urls)).slice(0, 16)
    if (capped.length === 0) return

    try {
      const events = await this.queryService.fetchEvents(
        capped,
        {
          kinds: [kinds.EventDeletion],
          authors: [pk],
          limit: 500
        },
        {
          firstRelayResultGraceMs: false,
          globalTimeout: 22_000,
          eoseTimeout: 2500
        }
      )

      let any = false
      for (const e of events) {
        if (e.kind !== kinds.EventDeletion || e.pubkey.toLowerCase() !== pk) continue
        if (!verifyEvent(e)) continue
        if (shouldDropEventOnIngest(e)) continue
        await this.addTombstoneEntriesFromDeletionEvent(e)
        any = true
      }

      if (any) {
        const removed = await indexedDb.removeTombstonedFromCache()
        if (removed > 0) {
          logger.info('[ClientService] Removed tombstoned events from cache after deletion sync', {
            count: removed
          })
        }
        invalidateArchiveFootprintCache()
        dispatchTombstonesUpdated()
      }
    } catch (e) {
      logger.warn('[ClientService] fetchDeletionEvents failed', { error: e })
    }
  }

  /** Fetch deletions for a profile pubkey using that user’s NIP-65 read stack when possible. */
  async fetchDeletionEventsForPubkey(profilePubkey: string): Promise<void> {
    const pk = profilePubkey.trim().toLowerCase()
    if (!/^[0-9a-f]{64}$/.test(pk)) return
    try {
      const rl = await this.fetchRelayList(pk)
      const urls = buildDeletionRelayUrls(rl)
      await this.fetchDeletionEvents(urls, pk)
    } catch {
      await this.fetchDeletionEvents(buildDeletionRelayUrls(null), pk)
    }
  }

  async searchNpubsForMention(
    query: string,
    limit: number = 100,
    onUpdate?: (npubs: string[]) => void
  ): Promise<string[]> {
    const q = query.trim()
    const qLower = q.toLowerCase()
    const addedNpubs = new Set<string>()
    const out: string[] = []

    const addNpub = (npub: string) => {
      if (addedNpubs.has(npub) || out.length >= limit) return false
      addedNpubs.add(npub)
      out.push(npub)
      return true
    }

    const updateIfNeeded = () => {
      if (onUpdate && out.length > 0) {
        onUpdate([...out])
      }
    }

    const matchProfileText = (p: TProfile) =>
      ((p.username ?? '') + ' ' + (p.original_username ?? '') + ' ' + (p.nip05 ?? '')).toLowerCase()

    // 1. Local index first (FlexSearch + session) — fills the @-mention list immediately.
    //    Previously follow-list ran first and awaited up to 80 fetchProfile() calls, so the dropdown
    //    stayed empty until those finished; @nevent / @naddr stayed instant (sync branch in suggestion.ts).
    const local = await this.searchNpubsFromLocal(q, limit)
    for (const npub of local) {
      if (addNpub(npub)) {
        updateIfNeeded()
      }
      if (out.length >= limit) break
    }

    if (out.length >= limit) {
      out.forEach((npub) => {
        this.replaceableEventService.fetchProfileEvent(npub).catch(() => {})
      })
      return out
    }

    // 2. Follow list — IndexedDB-cached profiles only (no network per follow; relay search still covers gaps)
    if (this.pubkey && qLower.length >= 1) {
      try {
        const followListEvent = await this.replaceableEventService.fetchFollowListEvent(this.pubkey)
        const followPubkeys = followListEvent ? getPubkeysFromPTags(followListEvent.tags) : []
        const toCheck = followPubkeys.slice(0, 80)

        const cachedRows = await Promise.all(
          toCheck.map(async (pubkey) => {
            const npub = pubkeyToNpub(pubkey)
            if (!npub) return null
            const p = await this.replaceableEventService.getProfileFromIndexedDB(npub)
            return p ? { npub, p } : null
          })
        )

        for (const row of cachedRows) {
          if (!row || out.length >= limit) break
          if (!matchProfileText(row.p).includes(qLower)) continue
          if (addNpub(row.npub)) {
            updateIfNeeded()
          }
        }
      } catch {
        // ignore follow-list errors; relay search still runs
      }
    }

    if (out.length >= limit) {
      out.forEach((npub) => {
        this.replaceableEventService.fetchProfileEvent(npub).catch(() => {})
      })
      return out
    }

    // 3. Relay search (slow, but runs in background and updates incrementally)
    if (q.length >= 1) {
      // Start relay search in background - don't await, let it update via callback
      this.searchProfiles(SEARCHABLE_RELAY_URLS, {
        search: q,
        limit: limit - out.length
      })
        .then((relayProfiles) => {
          for (const p of relayProfiles) {
            const npub = pubkeyToNpub(p.pubkey)
            if (!npub) continue
            if (addNpub(npub)) {
              updateIfNeeded()
            }
            if (out.length >= limit) break
          }
          
          // Prime profile cache for relay results
          relayProfiles.forEach((p) => {
            const npub = pubkeyToNpub(p.pubkey)
            if (npub) {
              this.replaceableEventService.fetchProfileEvent(npub).catch(() => {})
            }
          })
        })
        .catch(() => {
          // relay search is best-effort
        })
    }

    // Prime profile cache for cached results
    out.forEach((npub) => {
      this.replaceableEventService.fetchProfileEvent(npub).catch(() => {})
    })
    
    return out
  }

  async searchProfilesFromLocal(query: string, limit: number = 100) {
    const npubs = await this.searchNpubsFromLocal(query, limit)
    const profiles = await Promise.all(npubs.map((npub) => this.replaceableEventService.fetchProfile(npub)))
    return profiles.filter((profile) => !!profile) as TProfile[]
  }

  private async addUsernameToIndex(profileEvent: NEvent) {
    try {
      const profileObj = JSON.parse(profileEvent.content)
      const text = [
        profileObj.display_name?.trim() ?? '',
        profileObj.name?.trim() ?? '',
        profileObj.nip05
          ?.split('@')
          .map((s: string) => s.trim())
          .join(' ') ?? ''
      ].join(' ')
      if (!text) return

      await this.userIndex.addAsync(profileEvent.pubkey, text)
    } catch {
      return
    }
  }

  // Delegate to ReplaceableEventService
  async fetchProfileEvent(id: string, skipCache: boolean = false): Promise<NEvent | undefined> {
    return this.replaceableEventService.fetchProfileEvent(id, skipCache)
  }

  async fetchProfile(id: string, skipCache: boolean = false): Promise<TProfile | undefined> {
    return this.replaceableEventService.fetchProfile(id, skipCache)
  }

  async fetchProfilesForPubkeys(pubkeys: string[]): Promise<TProfile[]> {
    return this.replaceableEventService.fetchProfilesForPubkeys(pubkeys)
  }

  async getProfileFromIndexedDB(id: string): Promise<TProfile | undefined> {
    return this.replaceableEventService.getProfileFromIndexedDB(id)
  }

  async updateProfileEventCache(event: NEvent) {
    await this.replaceableEventService.updateReplaceableEventCache(event)
  }

  /** =========== Relay list =========== */

  async fetchRelayListEvent(pubkey: string) {
    const event = await this.replaceableEventService.fetchReplaceableEvent(pubkey, kinds.RelayList)
    return event ?? null
  }

  clearRelayListCache(targetPubkey: string) {
    const suffix = `\x1e${targetPubkey}`
    for (const k of this.relayListRequestCache.keys()) {
      if (k.endsWith(suffix)) this.relayListRequestCache.delete(k)
    }
  }

  private relayListRequestCacheKey(targetPubkey: string): string {
    return `${this.pubkey ?? ''}\x1e${targetPubkey}`
  }

  /**
   * Clear all in-memory caches. Call this after IndexedDB/cache clear so that
   * subsequent fetches go to the network instead of serving stale in-memory data.
   * Fixes missing profile pics and broken reactions after "Clear cache" on mobile.
   */
  clearInMemoryCaches(): void {
    this.relayListRequestCache.clear()
    this.eventService.clearCaches()
    this.replaceableEventService.clearCaches()
    logger.info('[ClientService] In-memory caches cleared')
  }

  async fetchRelayList(pubkey: string): Promise<TRelayList> {
    // Deduplicate concurrent requests for the same pubkey's relay list
    const cacheKey = this.relayListRequestCacheKey(pubkey)
    const existingRequest = this.relayListRequestCache.get(cacheKey)
    if (existingRequest) {
      logger.debug('[FetchRelayList] Using cached in-flight request', { pubkey })
      return existingRequest
    }
    
    logger.debug('[FetchRelayList] Starting fetch', { pubkey })
    const requestPromise = (async () => {
      try {
        const startTime = Date.now()
        const [relayList] = await this.fetchRelayLists([pubkey])
        const duration = Date.now() - startTime
        logger.debug('[FetchRelayList] Fetch completed', {
          pubkey,
          duration: `${duration}ms`,
          hasRelayList: !!relayList,
          writeCount: relayList?.write?.length ?? 0,
          readCount: relayList?.read?.length ?? 0
        })
        return relayList
      } catch (error) {
        logger.error('[FetchRelayList] Fetch failed', {
          pubkey,
          error: error instanceof Error ? error.message : String(error)
        })
        throw error
      } finally {
        this.relayListRequestCache.delete(cacheKey)
      }
    })()
    
    this.relayListRequestCache.set(cacheKey, requestPromise)
    return requestPromise
  }

  /**
   * Merge NIP-65 (10002), HTTP relay list (10243), and cache relays (10432) from network and/or IndexedDB.
   * Network arrays may be sparse/undefined per index; stored* always filled from IDB reads.
   */
  private mergeRelayListsBundle(
    pubkeys: string[],
    relayEvents: (NEvent | null | undefined)[],
    httpRelayEvents: (NEvent | null | undefined)[],
    cacheRelayEvents: (NEvent | null | undefined)[],
    storedRelayEvents: (NEvent | null | undefined)[],
    storedHttpRelayEvents: (NEvent | null | undefined)[],
    storedCacheRelayEvents: (NEvent | null | undefined)[]
  ): TRelayList[] {
    return pubkeys.map((targetPubkey, index) => {
      const isOwnRelayList =
        this.pubkey != null && hexPubkeysEqual(this.pubkey, userIdToPubkey(targetPubkey))

      const storedCacheEvent = storedCacheRelayEvents[index]
      const cacheEvent = cacheRelayEvents[index] || storedCacheEvent

      const httpRelayEvent = httpRelayEvents[index] || storedHttpRelayEvents[index]

      const storedRelayEvent = storedRelayEvents[index]
      const relayEvent = relayEvents[index] || storedRelayEvent

      const emptyHttp = { httpRead: [] as string[], httpWrite: [] as string[], httpOriginalRelays: [] as TMailboxRelay[] }

      const mergeKind10243 = (list: TRelayList): TRelayList => {
        if (!httpRelayEvent) {
          return {
            ...list,
            httpRead: list.httpRead ?? [],
            httpWrite: list.httpWrite ?? [],
            httpOriginalRelays: list.httpOriginalRelays ?? []
          }
        }
        const h = getHttpRelayListFromEvent(httpRelayEvent)
        return { ...list, httpRead: h.httpRead, httpWrite: h.httpWrite, httpOriginalRelays: h.httpOriginalRelays }
      }

      const relayList = relayEvent ? getRelayListFromEvent(relayEvent) : {
        write: [],
        read: [],
        originalRelays: [],
        ...emptyHttp
      }

      if (isOwnRelayList && cacheEvent) {
        const cacheRelayList = getRelayListFromEvent(cacheEvent)

        const mergedRead = [...cacheRelayList.read, ...relayList.read]
        const mergedWrite = [...cacheRelayList.write, ...relayList.write]
        const mergedOriginalRelays = new Map<string, TMailboxRelay>()

        cacheRelayList.originalRelays.forEach((relay) => {
          mergedOriginalRelays.set(relay.url, relay)
        })
        relayList.originalRelays.forEach((relay) => {
          if (!mergedOriginalRelays.has(relay.url)) {
            mergedOriginalRelays.set(relay.url, relay)
          }
        })

        return mergeKind10243({
          write: Array.from(new Set(mergedWrite)),
          read: Array.from(new Set(mergedRead)),
          originalRelays: Array.from(mergedOriginalRelays.values()),
          ...emptyHttp
        })
      }

      if (!relayEvent) {
        if (isOwnRelayList && storedCacheEvent) {
          const cacheRelayList = getRelayListFromEvent(storedCacheEvent)
          return mergeKind10243({
            write: cacheRelayList.write.length > 0 ? cacheRelayList.write : PROFILE_FETCH_RELAY_URLS,
            read: cacheRelayList.read.length > 0 ? cacheRelayList.read : PROFILE_FETCH_RELAY_URLS,
            originalRelays: cacheRelayList.originalRelays,
            ...emptyHttp
          })
        }
        return mergeKind10243({
          write: PROFILE_FETCH_RELAY_URLS,
          read: PROFILE_FETCH_RELAY_URLS,
          originalRelays: [],
          ...emptyHttp
        })
      }

      if (!isOwnRelayList) {
        return mergeKind10243(stripLocalNetworkRelaysFromRelayList(relayList))
      }

      return mergeKind10243(relayList)
    })
  }

  /** Background refresh so UI/publish can use IDB immediately while relays catch up. */
  private refreshRelayListsFromNetwork(
    pubkeys: string[],
    storedKind10002: (NEvent | null | undefined)[]
  ): void {
    void (async () => {
      try {
        const relayEvents = await this.replaceableEventService.fetchReplaceableEventsFromProfileFetchRelays(
          pubkeys,
          kinds.RelayList
        )
        await this.replaceableEventService.fetchReplaceableEventsFromProfileFetchRelays(
          pubkeys,
          ExtendedKind.HTTP_RELAY_LIST
        )
        await this.fetchCacheRelayEventsFromMultipleSources(pubkeys, relayEvents, storedKind10002)
      } catch {
        /* best-effort */
      }
    })()
  }

  async fetchRelayLists(pubkeys: string[]): Promise<TRelayList[]> {
    if (pubkeys.length === 0) return []

    const storedRelayEvents = await Promise.all(
      pubkeys.map((pubkey) => indexedDb.getReplaceableEvent(pubkey, kinds.RelayList))
    )
    const storedCacheRelayEvents = await Promise.all(
      pubkeys.map((pubkey) => indexedDb.getReplaceableEvent(pubkey, ExtendedKind.CACHE_RELAYS))
    )
    const storedHttpRelayEvents = await Promise.all(
      pubkeys.map((pubkey) => indexedDb.getReplaceableEvent(pubkey, ExtendedKind.HTTP_RELAY_LIST))
    )

    const budgetMs = PUBLISH_RELAY_LIST_RESOLUTION_TIMEOUT_MS
    const allHaveKind10002 = pubkeys.every((_, i) => storedRelayEvents[i] != null)

    const networkBundle = async (): Promise<{
      relayEvents: (NEvent | null | undefined)[]
      httpRelayEvents: (NEvent | null | undefined)[]
      cacheRelayEvents: (NEvent | null | undefined)[]
    }> => {
      const relayEvents = await this.replaceableEventService.fetchReplaceableEventsFromProfileFetchRelays(
        pubkeys,
        kinds.RelayList
      )
      const httpRelayEvents = await this.replaceableEventService.fetchReplaceableEventsFromProfileFetchRelays(
        pubkeys,
        ExtendedKind.HTTP_RELAY_LIST
      )
      const cacheRelayEvents = await this.fetchCacheRelayEventsFromMultipleSources(
        pubkeys,
        relayEvents,
        storedRelayEvents
      )
      return { relayEvents, httpRelayEvents, cacheRelayEvents }
    }

    if (allHaveKind10002) {
      this.refreshRelayListsFromNetwork(pubkeys, storedRelayEvents)
      logger.debug(
        '[FetchRelayLists] Kind 10002 present in IndexedDB for all pubkeys; merging locally, network refresh in background',
        { count: pubkeys.length }
      )
      const cacheRelayEvents = await Promise.race([
        this.fetchCacheRelayEventsFromMultipleSources(pubkeys, storedRelayEvents, storedRelayEvents),
        new Promise<(NEvent | null | undefined)[]>((resolve) =>
          setTimeout(() => resolve(storedCacheRelayEvents.map((e) => e ?? undefined)), budgetMs)
        )
      ])
      return this.mergeRelayListsBundle(
        pubkeys,
        storedRelayEvents.map((e) => e ?? undefined),
        storedHttpRelayEvents.map((e) => e ?? undefined),
        cacheRelayEvents,
        storedRelayEvents,
        storedHttpRelayEvents,
        storedCacheRelayEvents
      )
    }

    const raced = await Promise.race([
      networkBundle(),
      new Promise<null>((resolve) => setTimeout(() => resolve(null), budgetMs))
    ])
    if (raced != null) {
      return this.mergeRelayListsBundle(
        pubkeys,
        raced.relayEvents,
        raced.httpRelayEvents,
        raced.cacheRelayEvents,
        storedRelayEvents,
        storedHttpRelayEvents,
        storedCacheRelayEvents
      )
    }

    const now = Date.now()
    if (now - fetchRelayListBudgetWarnLastMs >= FETCH_RELAY_LIST_BUDGET_WARN_MIN_INTERVAL_MS) {
      fetchRelayListBudgetWarnLastMs = now
      logger.warn(
        '[FetchRelayLists] Network relay-list fetch exceeded budget; using IndexedDB / empty network layer only',
        { pubkeyCount: pubkeys.length }
      )
    }
    const cacheRelayEvents = storedCacheRelayEvents.map((e) => e ?? undefined)
    return this.mergeRelayListsBundle(
      pubkeys,
      pubkeys.map(() => undefined),
      pubkeys.map(() => undefined),
      cacheRelayEvents,
      storedRelayEvents,
      storedHttpRelayEvents,
      storedCacheRelayEvents
    )
  }

  async forceUpdateRelayListEvent(pubkey: string) {
    await this.replaceableEventService.fetchReplaceableEvent(pubkey, kinds.RelayList)
  }

  /**
   * Fetch cache relay events (kind 10432) from multiple sources:
   * - PROFILE_FETCH_RELAY_URLS
   * - User's inboxes (read relays from kind 10002)
   * - User's outboxes (write relays from kind 10002)
   */
  private async fetchCacheRelayEventsFromMultipleSources(
    pubkeys: string[],
    _relayEvents: (NEvent | null | undefined)[],
    _storedRelayEvents: (NEvent | null | undefined)[]
  ): Promise<(NEvent | null | undefined)[]> {
    // Start with events from IndexedDB
    const storedCacheRelayEvents = await Promise.all(
      pubkeys.map(pubkey => indexedDb.getReplaceableEvent(pubkey, ExtendedKind.CACHE_RELAYS))
    )
    
    // Check which pubkeys need fetching (don't have stored cache relay events)
    const pubkeysToFetch = pubkeys.filter((_pubkey, index) => !storedCacheRelayEvents[index])
    
    if (pubkeysToFetch.length === 0) {
      return storedCacheRelayEvents
    }

    const cacheRelayEvents = await Promise.race([
      this.replaceableEventService.fetchReplaceableEventsFromProfileFetchRelays(
        pubkeysToFetch,
        ExtendedKind.CACHE_RELAYS
      ),
      new Promise<(NEvent | undefined)[]>((resolve) =>
        setTimeout(
          () => resolve(pubkeysToFetch.map(() => undefined)),
          PUBLISH_RELAY_LIST_RESOLUTION_TIMEOUT_MS
        )
      )
    ])

    // Map results back to original pubkey order
    return pubkeys.map((pubkey, index) => {
      const storedCacheEvent = storedCacheRelayEvents[index]
      if (storedCacheEvent) return storedCacheEvent

      const fetchIndex = pubkeysToFetch.indexOf(pubkey)
      return fetchIndex >= 0 ? cacheRelayEvents[fetchIndex] : null
    })
  }

  async updateRelayListCache(event: NEvent) {
    await this.replaceableEventService.updateReplaceableEventCache(event)
  }


  /** =========== Replaceable event =========== */

  // Delegate to ReplaceableEventService. Pass relayUrls for fallback (user write + search relays).
  async fetchFollowListEvent(pubkey: string, relayUrls?: string[]) {
    return this.replaceableEventService.fetchFollowListEvent(pubkey, relayUrls)
  }

  async fetchFollowings(pubkey: string): Promise<string[]> {
    return this.replaceableEventService.fetchFollowings(pubkey)
  }

  async updateFollowListCache(evt: NEvent) {
    await this.replaceableEventService.updateReplaceableEventCache(evt)
  }

  async fetchMuteListEvent(pubkey: string) {
    return this.replaceableEventService.fetchMuteListEvent(pubkey)
  }

  async fetchBookmarkListEvent(pubkey: string) {
    return this.replaceableEventService.fetchBookmarkListEvent(pubkey)
  }

  async fetchBlossomServerListEvent(pubkey: string) {
    return this.replaceableEventService.fetchBlossomServerListEvent(pubkey)
  }

  async fetchBlossomServerList(pubkey: string): Promise<string[]> {
    return this.replaceableEventService.fetchBlossomServerList(pubkey)
  }

  async updateBlossomServerListEventCache(evt: NEvent) {
    await this.replaceableEventService.updateReplaceableEventCache(evt)
  }

  async fetchInterestListEvent(pubkey: string) {
    return this.replaceableEventService.fetchInterestListEvent(pubkey)
  }

  async fetchPinListEvent(pubkey: string) {
    return this.replaceableEventService.fetchPinListEvent(pubkey)
  }

  async fetchPaymentInfoEvent(pubkey: string) {
    return this.replaceableEventService.fetchPaymentInfoEvent(pubkey)
  }

  async updatePaymentInfoCache(evt: NEvent) {
    await this.replaceableEventService.updateReplaceableEventCache(evt)
  }

  async forceRefreshProfileAndPaymentInfoCache(pubkey: string): Promise<void> {
    return this.replaceableEventService.forceRefreshProfileAndPaymentInfoCache(pubkey)
  }

  /**
   * Resolve `a` tags (kind:pubkey:d) pointing at kind 30030 emoji packs into events.
   */
  async fetchEmojiSetEvents(pointers: string[]): Promise<NEvent[]> {
    if (!pointers?.length) return []
    const out: NEvent[] = []
    for (const coord of pointers) {
      const parts = coord.split(':')
      if (parts.length < 3) continue
      const kind = parseInt(parts[0]!, 10)
      const authorPk = parts[1]?.trim().toLowerCase()
      if (!authorPk || Number.isNaN(kind)) continue
      const d = parts.slice(2).join(':')
      try {
        const ev = await this.replaceableEventService.fetchReplaceableEvent(authorPk, kind, d)
        if (ev) out.push(ev)
      } catch {
        /* ignore per-pointer failures */
      }
    }
    return out
  }

  /**
   * Kind 10030 (user emoji list) + 30030 (emoji packs) for an author — used to populate the custom emoji picker.
   */
  async fetchAuthorEmojiInventory(pubkey: string): Promise<NEvent[]> {
    const pk = pubkey.trim().toLowerCase()
    if (!/^[0-9a-f]{64}$/.test(pk)) return []
    const relayList = await this.fetchRelayList(pk)
    const urls = dedupeNormalizeRelayUrlsOrdered([
      ...relayList.write.map((u) => normalizeUrl(u) || u),
      ...relayList.read.map((u) => normalizeUrl(u) || u),
      ...FAST_READ_RELAY_URLS.map((u) => normalizeUrl(u) || u),
      ...PROFILE_FETCH_RELAY_URLS.map((u) => normalizeUrl(u) || u)
    ]).filter(Boolean)
    const capped = urls.slice(0, 20)
    if (capped.length === 0) return []
    return this.queryService.fetchEvents(capped, {
      kinds: [kinds.UserEmojiList, kinds.Emojisets],
      authors: [pk],
      limit: 80
    })
  }

  /** =========== Following favorite relays =========== */


  // Delegate to ReplaceableEventService
  async fetchFollowingFavoriteRelays(pubkey: string): Promise<[string, string[]][]> {
    return this.replaceableEventService.fetchFollowingFavoriteRelays(pubkey)
  }

  /** =========== Macro Events (Delegated to MacroService) =========== */

  // Delegate to MacroService
  async fetchBookstrEvents(filters: {
    type?: string
    book?: string
    chapter?: number
    verse?: string
    version?: string
  }): Promise<NEvent[]> {
    return this.bookstrService.fetchMacroEvents(filters)
  }

  // Delegate to MacroService
  async getCachedBookstrEvents(filters: {
    type?: string
    book?: string
    chapter?: number
    verse?: string
    version?: string
  }): Promise<NEvent[]> {
    return this.bookstrService.getCachedMacroEvents(filters)
  }

  // Legacy implementations removed - now delegated to MacroService


  // ================= Utils =================

  async generateSubRequestsForPubkeys(pubkeys: string[], myPubkey?: string | null) {
    // If many websocket connections are initiated simultaneously, it will be
    // very slow on Safari (for unknown reason)
    if (isSafari()) {
      let urls = FAST_READ_RELAY_URLS
      if (myPubkey) {
        const relayList = await this.fetchRelayList(myPubkey)
        urls = relayList.read.concat(FAST_READ_RELAY_URLS).slice(0, 5)
      }
      return [{ urls, filter: { authors: pubkeys } }]
    }

    const relayLists = await this.fetchRelayLists(pubkeys)
    const group: Record<string, Set<string>> = {}
    relayLists.forEach((relayList, index) => {
      relayList.write.slice(0, 4).forEach((url) => {
        if (!group[url]) {
          group[url] = new Set()
        }
        group[url].add(pubkeys[index])
      })
    })

    const relayCount = Object.keys(group).length
    const coveredCount = new Map<string, number>()
    Object.entries(group)
      .sort(([, a], [, b]) => b.size - a.size)
      .forEach(([url, pubkeys]) => {
        if (
          relayCount > 10 &&
          pubkeys.size < 10 &&
          Array.from(pubkeys).every((pubkey) => (coveredCount.get(pubkey) ?? 0) >= 2)
        ) {
          delete group[url]
        } else {
          pubkeys.forEach((pubkey) => {
            coveredCount.set(pubkey, (coveredCount.get(pubkey) ?? 0) + 1)
          })
        }
      })

    return Object.entries(group).map(([url, authors]) => ({
      urls: [url],
      filter: { authors: Array.from(authors) }
    }))
  }

  // Legacy Bookstr implementations removed - now in MacroService

}
const instance = ClientService.getInstance()
export default instance

// Export sub-services for direct access
export const queryService = instance.queryService
export const eventService = instance.eventService
export const replaceableEventService = instance.replaceableEventService
export const macroService = instance.bookstrService