import b4a from 'b4a'
import c from 'compact-encoding'
import {
  PROTOCOL_NAME,
  PROTOCOL_APP_CHANNEL_NAME,
  PROTOCOL_CAP_CHANNEL_NAME,
  PROTOCOL_CHAT_CHANNEL_NAME,
  PROTOCOL_MESHDROP_CHANNEL_NAME
} from 'bare-os-protocol/constants.js'
import { bareOsChatMuxEnabled } from './bare-os-chat-service.js'
import { bareOsMeshdropMuxEnabled } from './bare-os-meshdrop-service.js'
import {
  bareOsHostBooterInfo,
  bareOsHostBooterWarn
} from './bare-os-host-booter-log.js'
import { getKernelCapabilityWords } from 'bare-os-protocol'

/**
 * Host-side booter log for swarm disk (stderr JSON when BARE_OS_BOOT_TRACE=json|ndjson; else stderr or console.warn).
 * @param {'info'|'warn'} level
 * @param {string} message
 * @param {Record<string, unknown> | null} [detail]
 */
function emitSwarmDiskHostLog(level, message, detail = null) {
  const env = globalThis.process?.env
  const trace =
    env &&
    (env.BARE_OS_BOOT_TRACE === 'json' || env.BARE_OS_BOOT_TRACE === 'ndjson')
  const err = globalThis.process?.stderr
  if (trace && err && typeof err.write === 'function') {
    err.write(
      `${JSON.stringify({
        type: 'booterHost',
        bootTraceSchemaVersion: 2,
        component: 'swarm_disk',
        level,
        message,
        detail,
        ts: Date.now()
      })}\n`
    )
  }
  if (level === 'warn') {
    bareOsHostBooterWarn(
      'swarm_disk',
      message,
      detail ? JSON.stringify(detail) : ''
    )
    return
  }
  bareOsHostBooterInfo(
    'swarm_disk',
    message,
    detail ? JSON.stringify(detail) : ''
  )
}

/** Default max wait for block 0 (MBR) before failing boot (override **`BARE_OS_MBR_READ_TIMEOUT_MS`**). */
const MBR_READ_TIMEOUT_MS_DEFAULT = 60_000

/** Cap-channel (`bare-os-cap-v1`) message size bound when **`BARE_OS_PROTOMUX_CAP_CHANNEL`** is enabled. */
export const BARE_OS_PROTOMUX_CAP_CHANNEL_MESSAGE_MAX_BYTES = 65536

/**
 * Max wait (ms) for block 0 / MBR replication before boot failure.
 * Exported for microbench / unit introspection (same rules as booter).
 * @param {SwarmDisk} disk
 */
export function mbrReadTimeoutMsForDisk(disk) {
  const env = globalThis.process?.env
  const raw = String(env?.BARE_OS_MBR_READ_TIMEOUT_MS ?? '').trim()
  if (raw) {
    const n = Math.floor(Number(raw))
    if (Number.isFinite(n) && n >= 3000) return Math.min(n, 600_000)
  }
  const adapt =
    env?.BARE_OS_MBR_READ_TIMEOUT_ADAPTIVE === '1' ||
    env?.BARE_OS_MBR_READ_TIMEOUT_ADAPTIVE === 'true'
  if (adapt && disk && disk.peers && typeof disk.peers.size === 'number') {
    const n = disk.peers.size
    if (n <= 1) return Math.min(120_000, MBR_READ_TIMEOUT_MS_DEFAULT + 30_000)
    if (n >= 4) return Math.max(45_000, MBR_READ_TIMEOUT_MS_DEFAULT - 15_000)
  }
  return MBR_READ_TIMEOUT_MS_DEFAULT
}

/**
 * Interval (ms) to re-send pending block read requests to all peers while waiting for MBR / block data.
 * **`0`** disables periodic rebroadcast (initial + per-connect sends only).
 * Override **`BARE_OS_MBR_READ_REBROADCAST_MS`** (defaults **5000**, clamp **2000**–**60000**).
 * @param {Record<string, string | undefined> | null | undefined} env
 */
export function mbrReadRebroadcastMsFromEnv(env) {
  const raw = String(env?.BARE_OS_MBR_READ_REBROADCAST_MS ?? '').trim()
  if (raw === '0' || raw.toLowerCase() === 'false') return 0
  const n = Math.floor(Number(raw))
  if (Number.isFinite(n) && n >= 0) {
    if (n === 0) return 0
    return Math.min(60_000, Math.max(2_000, n))
  }
  return 5_000
}

export class SwarmDisk {
  constructor() {
    this.localRAM = new Map()
    this.peers = new Set()
    this.pendingReads = new Map()
    this.pendingSearches = new Map()
    this.pendingRpc = new Map()
    this.searchIdCounter = 0
    this.rpcIdCounter = 0
    this.drive = null
    this.personalDrive = null
    this.os = null
    /** @type {import('hyperdrive').default[]} */
    this.auxiliaryDrives = []
    /** @type {Record<string, unknown> | null} Last `bare_os.capabilities` RPC result (or error object). */
    this.seedCapabilityInfo = null
    /** @type {Record<string, unknown> | null} Last `bare_os.replication_status` RPC result when available. */
    this.seedReplicationStatus = null
    /** @type {Record<string, unknown> | null} */
    this.seedManifestHints = null
    /** @type {Record<string, unknown> | null} */
    this.seedPeerHealth = null
    /** @type {Record<string, unknown> | null} */
    this.seedStagingSlot = null
    /** @type {Record<string, unknown> | null} */
    this.seedReplicationQueue = null
    /** @type {Record<string, unknown> | null} */
    this.seedCapabilityAttestation = null
    /** @type {Record<string, unknown> | null} */
    this.seedMbrLayout = null
    /** @type {Record<string, unknown> | null} */
    this.seedSnapshotHints = null
    /** @type {Record<string, unknown> | null} */
    this.seedPeerFirewallStats = null
    /** @type {Record<string, unknown> | null} */
    this.seedReplicationPlan = null
    /** @type {Record<string, unknown> | null} */
    this.seedDhtBootstrapHint = null
    /** @type {Record<string, unknown> | null} */
    this.seedSnapshotChain = null
    /** @type {Record<string, unknown> | null} */
    this.seedMirrorCompactionHint = null
    /** @type {Record<string, unknown> | null} */
    this.seedUpdaterState = null
    /** @type {Record<string, unknown> | null} */
    this.seedBlindPeerTopologyV2 = null
    /** @type {Record<string, unknown> | null} */
    this.seedCompactPing = null
    /** @type {Record<string, unknown> | null} */
    this.seedCorestoreStats = null
    /** @type {Record<string, unknown> | null} */
    this.seedSnapshotManifestSlice = null
    /** @type {Record<string, unknown> | null} */
    this.seedMirrorDriveHintV2 = null
    /** @type {Record<string, unknown> | null} */
    this.seedHrpcRegistrySummary = null
    /** @type {Record<string, unknown> | null} */
    this.seedProtomuxCapabilityAd = null
    /** Cumulative count of buffers received on optional Protomux app-channel pairs (operator observability). */
    this.protomuxAppChannelRxTotal = 0
    /** Cumulative count of buffers received on optional Protomux cap-channel pairs (`bare-os-cap-v1`). */
    this.protomuxCapChannelRxTotal = 0
    /** Cumulative chat `event` messages received on `bare-os-chat-v1` (when enabled). */
    this.protomuxChatChannelRxTotal = 0
    /** Cumulative meshdrop envelopes received on `bare-os-meshdrop-v1` (when enabled). */
    this.protomuxMeshdropChannelRxTotal = 0
    /** @type {ReturnType<import('./bare-os-chat-service.js').createBareOsChatService> | null} */
    this.bareOsChatService = null
    /** @type {ReturnType<import('./bare-os-meshdrop-service.js').createBareOsMeshdropService> | null} */
    this.bareOsMeshdropService = null
    /** @type {Record<string, unknown> | null} Host-requested Hyperswarm caps (from env); surfaced on disk.os RPC. */
    this.swarmConnectionBudget = null
    /** @type {Record<string, unknown> | null} */
    this.seedDhtAddressBook = null
    /** @type {Record<string, unknown> | null} */
    this.seedReplicationThrottleHint = null
    /** @type {Record<string, unknown> | null} */
    this.seedBundlebeeStage = null
    /** @type {Record<string, unknown> | null} */
    this.seedHttpDhtProxyHint = null
    /** @type {Record<string, unknown> | null} */
    this.seedProtomuxRpcPoolHint = null
    /** @type {Record<string, unknown> | null} */
    this.seedHyperblobStoreHint = null
    /** @type {Record<string, unknown> | null} */
    this.seedSigningRequestQueueHint = null
    /** @type {Record<string, unknown> | null} */
    this.seedCoreStorageLayoutHint = null
    /** @type {Record<string, unknown> | null} */
    this.seedMirrorDriveCompactionV3 = null
    /** @type {Record<string, unknown> | null} */
    this.seedBundlebeeCliStage = null
    /** @type {Record<string, unknown> | null} */
    this.seedReadyGuardV2 = null
    /** @type {Record<string, unknown> | null} */
    this.seedBlindRelayCircuitHint = null
    /** @type {Record<string, unknown> | null} */
    this.seedHttpDhtProxyRoutes = null
    /** @type {string[]} MBR-derived drive key hex list (primary + failovers). */
    this.mbrKeysHex = []
    /**
     * 512-byte MBR block used at boot (copy); enables peer block-0 service when mirrored to {@link SwarmDisk#localRAM}.
     * @type {Uint8Array | null}
     */
    this.bootMbr512 = null
    /** True after peer system seed eligibility passed and MBR was published to `localRAM`. */
    this.peerSystemSeedActive = false
    /**
     * Local Noise wire static key (32 bytes), last seen from `Hyperswarm` socket `publicKey`.
     * Peers validate chat `senderPk` against `socket.remotePublicKey`, which matches **this** — not `swarm.keyPair.publicKey`.
     */
    this.localNoiseWirePk = /** @type {Uint8Array | null} */ (null)
  }

  /**
   * One JSON-RPC-style round-trip to a specific peer.
   * @param {unknown} peer
   * @param {string} module
   * @param {string} method
   * @param {string[]} args
   * @param {number} timeoutMs
   * @returns {Promise<unknown>}
   */
  _rpcOne(peer, module, method, args, timeoutMs) {
    const id = this.rpcIdCounter++
    return new Promise((resolve, reject) => {
      const to = setTimeout(() => {
        this.pendingRpc.delete(id)
        reject(new Error('swarm-disk rpc: timeout'))
      }, timeoutMs)
      this.pendingRpc.set(id, (m) => {
        clearTimeout(to)
        if (m.success) {
          const r = m.result || ''
          try {
            resolve(r ? JSON.parse(r) : null)
          } catch {
            resolve(r)
          }
        } else {
          reject(new Error(m.error || 'swarm-disk rpc failed'))
        }
      })
      const chan =
        /** @type {{ chan: { messages: { send: (m: unknown) => void }[] } }} */ (
          peer
        ).chan
      void chan.fullyOpened().then((opened) => {
        if (!opened) return
        if (!this.pendingRpc.has(id)) return
        try {
          chan.messages[5].send({ id, module, method, args })
        } catch (err) {
          this.pendingRpc.delete(id)
          clearTimeout(to)
          reject(
            err instanceof Error
              ? err
              : new Error((err && err.message) || String(err))
          )
        }
      })
    })
  }

  /**
   * JSON-RPC-style call to swarm peers. For **`bare_os`**, tries each peer in turn when
   * **`BARE_OS_SWARM_RPC_TRY_PEERS`** is not **`0`/`false`** (default: try all).
   * **`capabilities`** responses must include **`kernelCapabilityWords`** (wire v2).
   * @param {string} module
   * @param {string} method
   * @param {string[]} [args]
   * @param {number} [timeoutMs]
   * @returns {Promise<unknown>}
   */
  async rpc(module, method, args = [], timeoutMs = 8000) {
    if (!this.peers.size) throw new Error('swarm-disk rpc: no peers')
    const peers = [...this.peers]
    const mod = String(module || '')
    const meth = String(method || '')
    const env = globalThis.process?.env
    const tryAll =
      String(env?.BARE_OS_SWARM_RPC_TRY_PEERS ?? '1').toLowerCase() !== '0' &&
      String(env?.BARE_OS_SWARM_RPC_TRY_PEERS ?? '1').toLowerCase() !==
        'false' &&
      mod === 'bare_os' &&
      peers.length > 1
    const perPeerMs = tryAll
      ? Math.min(
          2500,
          Math.max(800, Math.floor(timeoutMs / Math.min(peers.length, 4)))
        )
      : timeoutMs
    if (tryAll) {
      /** @type {Error | null} */
      let lastErr = null
      for (const peer of peers) {
        try {
          const r = await this._rpcOne(peer, mod, meth, args, perPeerMs)
          if (meth === 'capabilities') {
            const words = getKernelCapabilityWords(r)
            if (!words) {
              lastErr = new Error(
                'swarm-disk rpc: capabilities missing kernelCapabilityWords'
              )
              continue
            }
          }
          return r
        } catch (e) {
          lastErr =
            e instanceof Error ? e : new Error((e && e.message) || String(e))
        }
      }
      throw lastErr || new Error('swarm-disk rpc: all peers failed')
    }
    return this._rpcOne(peers[0], mod, meth, args, timeoutMs)
  }

  /**
   * @param {import('corestore').default} store
   * @param {import('hyperswarm').default} swarm
   * @param {import('hyperdrive').default} Hyperdrive
   */
  async initPersonalDrive(store, swarm, Hyperdrive) {
    const localStore = store.namespace('bare-os-personal-v1', {
      writable: true
    })
    this.personalDrive = new Hyperdrive(localStore)
    await this.personalDrive.ready()
    if (!this.personalDrive.writable) {
      try {
        await this.personalDrive.close()
      } catch (_) {}
      this.personalDrive = new Hyperdrive(localStore)
      await this.personalDrive.ready()
    }
    if (!this.personalDrive.writable) {
      emitSwarmDiskHostLog(
        'warn',
        '[bare-os-booter] Personal Hyperdrive is not writable — identity and $HOME writes will fail. Check Corestore path permissions and that no other process holds the store read-only.',
        {
          writable: false,
          idPrefix: b4a.toString(this.personalDrive.id, 'hex').slice(0, 16)
        }
      )
    }
    emitSwarmDiskHostLog(
      'info',
      'Personal Hyperdrive mounted; joining swarm discovery',
      {
        idPrefix: b4a.toString(this.personalDrive.id, 'hex').slice(0, 16),
        writable: this.personalDrive.writable
      }
    )
    swarm.join(this.personalDrive.discoveryKey)
  }

  addPeer(mux, socket) {
    const disk = this
    /** @type {any} */
    let chan

    const context = {
      onread(index) {
        const data = disk.localRAM.get(index)
        if (data) chan.messages[1].send({ index, data })
      },
      ondata(m) {
        const cb = disk.pendingReads.get(m.index)
        if (cb) {
          disk.pendingReads.delete(m.index)
          cb(m.data)
        }
      },
      ongossip() {},
      async onsearchreq(m) {
        const matches = disk.os ? await disk.os.searchLocal?.(m.query) : []
        chan.messages[4].send({ id: m.id, matches: matches || [] })
      },
      onsearchres(m) {
        const st = disk.pendingSearches.get(m.id)
        if (!st || st.settled) return
        st.results.push(m.matches || [])
        st.remaining--
        if (st.remaining <= 0) st.finish()
      },
      async onrpcreq(m) {
        if (!disk.os) {
          chan.messages[6].send({
            id: m.id,
            success: false,
            result: '',
            error: 'OS not initialized'
          })
          return
        }
        try {
          const result = await disk.os.execRpc?.(m.module, m.method, m.args)
          chan.messages[6].send({
            id: m.id,
            success: true,
            result: String(result ?? ''),
            error: ''
          })
        } catch (err) {
          chan.messages[6].send({
            id: m.id,
            success: false,
            result: '',
            error: err.message
          })
        }
      },
      onrpcres(m) {
        const cb = disk.pendingRpc.get(m.id)
        if (cb) {
          disk.pendingRpc.delete(m.id)
          cb(m)
        }
      }
    }

    chan = mux.createChannel({ protocol: PROTOCOL_NAME, userData: context })

    chan.addMessage({
      encoding: c.uint32,
      onmessage: (index, ch) => ch.userData.onread(index)
    })
    chan.addMessage({
      encoding: {
        preencode(state, m) {
          c.uint32.preencode(state, m.index)
          c.buffer.preencode(state, m.data)
        },
        encode(state, m) {
          c.uint32.encode(state, m.index)
          c.buffer.encode(state, m.data)
        },
        decode(state) {
          return { index: c.uint32.decode(state), data: c.buffer.decode(state) }
        }
      },
      onmessage: (m, ch) => ch.userData.ondata(m)
    })
    chan.addMessage({
      encoding: c.buffer,
      onmessage: (bitfield, ch) => ch.userData.ongossip(bitfield)
    })
    chan.addMessage({
      encoding: {
        preencode(state, m) {
          c.uint32.preencode(state, m.id)
          c.string.preencode(state, m.query)
        },
        encode(state, m) {
          c.uint32.encode(state, m.id)
          c.string.encode(state, m.query)
        },
        decode(state) {
          return { id: c.uint32.decode(state), query: c.string.decode(state) }
        }
      },
      onmessage: (m, ch) => ch.userData.onsearchreq(m)
    })
    chan.addMessage({
      encoding: {
        preencode(state, m) {
          c.uint32.preencode(state, m.id)
          c.array(c.string).preencode(state, m.matches)
        },
        encode(state, m) {
          c.uint32.encode(state, m.id)
          c.array(c.string).encode(state, m.matches)
        },
        decode(state) {
          return {
            id: c.uint32.decode(state),
            matches: c.array(c.string).decode(state)
          }
        }
      },
      onmessage: (m, ch) => ch.userData.onsearchres(m)
    })
    chan.addMessage({
      encoding: {
        preencode(state, m) {
          c.uint32.preencode(state, m.id)
          c.string.preencode(state, m.module)
          c.string.preencode(state, m.method)
          c.array(c.string).preencode(state, m.args)
        },
        encode(state, m) {
          c.uint32.encode(state, m.id)
          c.string.encode(state, m.module)
          c.string.encode(state, m.method)
          c.array(c.string).encode(state, m.args)
        },
        decode(state) {
          return {
            id: c.uint32.decode(state),
            module: c.string.decode(state),
            method: c.string.decode(state),
            args: c.array(c.string).decode(state)
          }
        }
      },
      onmessage: (m, ch) => ch.userData.onrpcreq(m)
    })
    chan.addMessage({
      encoding: {
        preencode(state, m) {
          c.uint32.preencode(state, m.id)
          c.bool.preencode(state, m.success)
          c.string.preencode(state, m.result)
          c.string.preencode(state, m.error)
        },
        encode(state, m) {
          c.uint32.encode(state, m.id)
          c.bool.encode(state, m.success)
          c.string.encode(state, m.result || '')
          c.string.encode(state, m.error || '')
        },
        decode(state) {
          return {
            id: c.uint32.decode(state),
            success: c.bool.decode(state),
            result: c.string.decode(state),
            error: c.string.decode(state)
          }
        }
      },
      onmessage: (m, ch) => ch.userData.onrpcres(m)
    })

    chan.open()

    const appChOn =
      globalThis.process &&
      globalThis.process.env &&
      (globalThis.process.env.BARE_OS_PROTOMUX_APP_CHANNEL === '1' ||
        globalThis.process.env.BARE_OS_PROTOMUX_APP_CHANNEL === 'true')
    if (appChOn) {
      mux.pair({ protocol: PROTOCOL_APP_CHANNEL_NAME }, (achan) => {
        achan.addMessage({
          encoding: c.buffer,
          onmessage: () => {
            try {
              this.protomuxAppChannelRxTotal++
            } catch {
              /* ignore */
            }
          }
        })
        achan.open()
      })
    }

    const capChOn =
      globalThis.process &&
      globalThis.process.env &&
      (globalThis.process.env.BARE_OS_PROTOMUX_CAP_CHANNEL === '1' ||
        globalThis.process.env.BARE_OS_PROTOMUX_CAP_CHANNEL === 'true')
    if (capChOn) {
      mux.pair({ protocol: PROTOCOL_CAP_CHANNEL_NAME }, (cchan) => {
        cchan.addMessage({
          encoding: c.buffer,
          onmessage: (buf) => {
            try {
              const n = buf ? buf.byteLength : 0
              if (n > BARE_OS_PROTOMUX_CAP_CHANNEL_MESSAGE_MAX_BYTES) {
                emitSwarmDiskHostLog('warn', 'protomux_cap_payload_oversized', {
                  byteLength: n,
                  maxBytes: BARE_OS_PROTOMUX_CAP_CHANNEL_MESSAGE_MAX_BYTES
                })
                return
              }
              this.protomuxCapChannelRxTotal++
            } catch {
              /* ignore */
            }
          }
        })
        cchan.open()
      })
    }

    const peer = {
      chan,
      mux,
      socket,
      id: null,
      chatChan: null,
      meshdropChan: null
    }
    if (
      bareOsChatMuxEnabled(globalThis.process?.env) &&
      this.bareOsChatService &&
      mux.stream &&
      !mux.stream.destroyed
    ) {
      try {
        this.bareOsChatService.pairOnMux(this, mux, socket, peer)
      } catch (e) {
        emitSwarmDiskHostLog('warn', 'bare_os_chat_pair_on_connect_failed', {
          message:
            (e && /** @type {{ message?: string }} */ (e).message) || String(e)
        })
      }
    }
    if (
      bareOsMeshdropMuxEnabled(globalThis.process?.env) &&
      this.bareOsMeshdropService &&
      mux.stream &&
      !mux.stream.destroyed
    ) {
      try {
        this.bareOsMeshdropService.pairOnMux(this, mux, socket, peer)
      } catch (e) {
        emitSwarmDiskHostLog(
          'warn',
          'bare_os_meshdrop_pair_on_connect_failed',
          {
            message:
              (e && /** @type {{ message?: string }} */ (e).message) ||
              String(e)
          }
        )
      }
    }

    /** Sync local Noise static key once the secret stream exposes `publicKey` (may follow handshake). */
    const cacheLocalNoiseWirePk = () => {
      if (socket.publicKey && socket.publicKey.byteLength === 32) {
        disk.localNoiseWirePk = b4a.from(socket.publicKey)
      }
    }
    cacheLocalNoiseWirePk()

    this.peers.add(peer)

    const pendingIndices = [...this.pendingReads.keys()]
    for (const idx of pendingIndices) {
      this._sendReadIndexToPeer(peer, idx)
    }

    const collabNd =
      globalThis.process &&
      globalThis.process.env &&
      (globalThis.process.env.BARE_OS_COLLAB_SESSION_NDJSON === '1' ||
        globalThis.process.env.BARE_OS_COLLAB_SESSION_NDJSON === 'true')
    if (collabNd) {
      emitSwarmDiskHostLog('info', 'collab_session_peer', {
        peerCount: this.peers.size,
        capChannelEnabled: capChOn,
        appChannelEnabled: appChOn,
        note: 'Host NDJSON preview; mirror to personal-drive tooling off-guest if policy allows.'
      })
    }

    const setPeerId = () => {
      if (socket.remotePublicKey && !peer.id) {
        peer.id = b4a.toString(socket.remotePublicKey, 'hex')
        return true
      }
      if (socket.handshakeHash && !peer.id) {
        peer.id = b4a.toString(socket.handshakeHash, 'hex')
        return true
      }
      return false
    }

    socket.on('handshake', () => {
      setPeerId()
      cacheLocalNoiseWirePk()
    })
    if (!setPeerId()) {
      let attempts = 0
      const tryAgain = () => {
        attempts++
        if (attempts > 10) {
          if (!peer.id) peer.id = 'peer-' + Date.now().toString(36)
          return
        }
        if (!setPeerId()) setTimeout(tryAgain, attempts * 50)
      }
      setTimeout(tryAgain, 50)
    }

    mux.stream.on('close', () => {
      this.peers.delete(peer)
    })

    if (this.drive)
      this.drive.replicate(mux.stream, { live: true, download: true })
    if (this.personalDrive) this.personalDrive.replicate(mux.stream)
    for (const d of this.auxiliaryDrives || []) {
      try {
        d.replicate(mux.stream, { live: true, download: true })
      } catch (_) {}
    }
  }

  /**
   * Protomux message 0: request block index (MBR). Only send after channel pairing.
   * @param {unknown} peer
   * @param {number} index
   */
  _sendReadIndexToPeer(peer, index) {
    const chan =
      /** @type {{ chan: { messages: { send: (idx: number) => void }[] } }} */ (
        peer
      ).chan
    void chan.fullyOpened().then((opened) => {
      if (!opened) return
      if (!this.pendingReads.has(index)) return
      try {
        chan.messages[0].send(index)
      } catch {
        /* ignore — channel closed or not ready */
      }
    })
  }

  /**
   * Re-broadcast a pending block read to every connected peer (lossy links, slow pairing).
   * @param {number} index
   */
  _broadcastPendingReadIndex(index) {
    for (const p of this.peers) {
      this._sendReadIndexToPeer(p, index)
    }
  }

  async read(index) {
    if (this.localRAM.has(index)) return this.localRAM.get(index)
    return new Promise((resolve, reject) => {
      const timeoutMs = mbrReadTimeoutMsForDisk(this)
      /** @type {ReturnType<typeof setInterval> | null} */
      let rebroadcastIv = null
      const timeout = setTimeout(() => {
        if (rebroadcastIv) clearInterval(rebroadcastIv)
        this.pendingReads.delete(index)
        reject(new Error('MBR read timeout'))
      }, timeoutMs)
      this.pendingReads.set(index, (data) => {
        if (rebroadcastIv) clearInterval(rebroadcastIv)
        clearTimeout(timeout)
        resolve(data)
      })
      const rbMs = mbrReadRebroadcastMsFromEnv(globalThis.process?.env)
      this._broadcastPendingReadIndex(index)
      if (rbMs > 0) {
        rebroadcastIv = setInterval(() => {
          if (!this.pendingReads.has(index)) {
            if (rebroadcastIv) clearInterval(rebroadcastIv)
            return
          }
          this._broadcastPendingReadIndex(index)
        }, rbMs)
      }
    })
  }

  async search(query) {
    const id = this.searchIdCounter++
    const peerList = [...this.peers]
    const n = peerList.length
    if (!n) return []
    const self = this
    return new Promise((resolve) => {
      /** @type {unknown[][]} */
      const results = []
      const state = {
        remaining: n,
        results,
        settled: false,
        timeout: /** @type {ReturnType<typeof setTimeout> | null} */ (null),
        finish() {
          if (state.settled) return
          state.settled = true
          if (state.timeout) clearTimeout(state.timeout)
          self.pendingSearches.delete(id)
          resolve(results.flat())
        }
      }
      state.timeout = setTimeout(() => state.finish(), 3000)
      self.pendingSearches.set(id, state)
      for (const peer of peerList) {
        void peer.chan.fullyOpened().then((opened) => {
          if (!opened) return
          if (state.settled) return
          try {
            peer.chan.messages[3].send({ id, query })
          } catch {
            /* ignore */
          }
        })
      }
    })
  }

  /**
   * (Re)pair `bare-os-chat-v1` on every live mux — used after `ensureDiskBareOsChatTransport` replaces
   * the service (guest → user, logout → guest) so `peer.chatChan` and handlers match the active instance.
   */
  async pairBareOsChatExistingPeers() {
    if (!bareOsChatMuxEnabled(globalThis.process?.env)) return
    const svc = this.bareOsChatService
    if (!svc || typeof svc.pairOnMux !== 'function') return
    for (const peer of [...this.peers]) {
      const st = peer.mux && peer.mux.stream
      if (!st || st.destroyed) continue
      try {
        const mux = peer.mux
        const wired = peer.chatChan
        /** @type {Promise<unknown>[]} */
        const closing = []
        if (wired && typeof wired.close === 'function') {
          try {
            wired.close()
            if (typeof wired.fullyClosed === 'function')
              closing.push(wired.fullyClosed())
          } catch {
            /* ignore */
          }
        }
        peer.chatChan = null
        const prevCh =
          mux &&
          typeof mux.getLastChannel === 'function' &&
          mux.getLastChannel({ protocol: PROTOCOL_CHAT_CHANNEL_NAME })
        if (prevCh && typeof prevCh.close === 'function' && prevCh !== wired) {
          try {
            prevCh.close()
            if (typeof prevCh.fullyClosed === 'function')
              closing.push(prevCh.fullyClosed())
          } catch {
            /* ignore */
          }
        }
        if (closing.length) await Promise.all(closing)
      } catch {
        /* ignore */
      }
      try {
        if (typeof peer.mux.unpair === 'function') {
          try {
            peer.mux.unpair({ protocol: PROTOCOL_CHAT_CHANNEL_NAME })
          } catch {
            /* ignore */
          }
        }
        svc.pairOnMux(this, peer.mux, peer.socket, peer)
      } catch (e) {
        emitSwarmDiskHostLog('warn', 'bare_os_chat_late_pair_failed', {
          message:
            (e && /** @type {{ message?: string }} */ (e).message) || String(e)
        })
      }
    }
  }

  /**
   * (Re)pair `bare-os-meshdrop-v1` on every live mux — used after meshdrop service env/user transitions.
   */
  pairBareOsMeshdropExistingPeers() {
    if (!bareOsMeshdropMuxEnabled(globalThis.process?.env)) return
    const svc = this.bareOsMeshdropService
    if (!svc || typeof svc.pairOnMux !== 'function') return
    for (const peer of [...this.peers]) {
      const st = peer.mux && peer.mux.stream
      if (!st || st.destroyed) continue
      try {
        const mux = peer.mux
        const wired = peer.meshdropChan
        if (wired && typeof wired.close === 'function') {
          try {
            wired.close()
          } catch {
            /* ignore */
          }
        }
        peer.meshdropChan = null
        const prevCh =
          mux &&
          typeof mux.getLastChannel === 'function' &&
          mux.getLastChannel({ protocol: PROTOCOL_MESHDROP_CHANNEL_NAME })
        if (prevCh && typeof prevCh.close === 'function' && prevCh !== wired) {
          try {
            prevCh.close()
          } catch {
            /* ignore */
          }
        }
      } catch {
        /* ignore */
      }
      try {
        svc.pairOnMux(this, peer.mux, peer.socket, peer)
        if (typeof peer.mux.unpair === 'function') {
          try {
            peer.mux.unpair({ protocol: PROTOCOL_MESHDROP_CHANNEL_NAME })
          } catch {
            /* ignore */
          }
        }
      } catch (e) {
        emitSwarmDiskHostLog('warn', 'bare_os_meshdrop_late_pair_failed', {
          message:
            (e && /** @type {{ message?: string }} */ (e).message) || String(e)
        })
      }
    }
  }
}