libp2r2p 0.11.8 → 0.11.10

package/content-key/services/iykc-proof.js

@@ -2,11 +2,13 @@ import { CONTENT_KEY_KIND, parseContentKeyEvent } from '../event/index.js'
 import { pickRelaysForPubkeys, getRelaysByPubkey, relayPool } from '../../relay/index.js'
 
 const QUERY_CACHE_MS = 40 * 60 * 1000
+const NEGATIVE_CACHE_MS = 5 * 60 * 1000
 const IYKC_CACHE_MAX_ITEMS = 10000
 const HEX_PUBKEY = /^[0-9a-f]{64}$/i
 const contentKeysByPubkey = Object.create(null)
 const iykcCacheTimersByPubkey = Object.create(null)
 const iykcCacheAddedAtByPubkey = Object.create(null)
+const inFlightByPubkey = new Map()
 
 const getEvents = (...args) => relayPool.getEvents(...args)
 
@@ -68,42 +70,30 @@ export function clearContentKeyCache () {
   for (const key of Object.keys(contentKeysByPubkey)) delete contentKeysByPubkey[key]
   for (const key of Object.keys(iykcCacheTimersByPubkey)) delete iykcCacheTimersByPubkey[key]
   for (const key of Object.keys(iykcCacheAddedAtByPubkey)) delete iykcCacheAddedAtByPubkey[key]
+  inFlightByPubkey.clear()
 }
 
-export async function getIykcProofs (pubkeys, {
-  _getEvents = getEvents,
-  _getRelaysByPubkey = getRelaysByPubkey,
-  cacheMs = QUERY_CACHE_MS
-} = {}) {
-  const pubkeyList = uniquePubkeys(pubkeys, { requireHex: _getEvents === getEvents })
-  if (!pubkeyList.length) return {}
-
-  const out = {}
-  const missingPubkeys = []
-  for (const pubkey of pubkeyList) {
-    if (!hasCachedKey(contentKeysByPubkey, pubkey)) {
-      missingPubkeys.push(pubkey)
-      continue
-    }
-    const cached = cloneContentKey(contentKeysByPubkey[pubkey])
-    if (cached) out[pubkey] = cached
-  }
-  if (!missingPubkeys.length) return out
-
-  const relaysByPubkey = await _getRelaysByPubkey(missingPubkeys, { _getEvents, cacheMs })
-  const relayToAuthors = pickRelaysForPubkeys(missingPubkeys, relaysByPubkey)
+async function queryContentKeyProofs (pubkeyList, { _getEvents, _getRelaysByPubkey, cacheMs, negativeCacheMs }) {
+  const relaysByPubkey = await _getRelaysByPubkey(pubkeyList, { _getEvents, cacheMs })
+  const relayToAuthors = pickRelaysForPubkeys(pubkeyList, relaysByPubkey)
   const eventGroups = await Promise.all(
     [...relayToAuthors.entries()]
       .map(async ([relay, authors]) => {
-        const { result } = await _getEvents({
-          kinds: [CONTENT_KEY_KIND],
-          authors,
-          limit: authors.length
-        }, [relay], {
-          timeout: 5000,
-          timeoutAfterFirstEose: null
-        })
-        return result.map(({ event }) => event)
+        try {
+          const { result } = await _getEvents({
+            kinds: [CONTENT_KEY_KIND],
+            authors,
+            limit: authors.length
+          }, [relay], {
+            timeout: 5000,
+            timeoutAfterFirstEose: null
+          })
+          return result.map(({ event }) => event)
+        } catch {
+          // Discovery is best-effort: a failing relay group must not fail an
+          // otherwise publishable message.
+          return []
+        }
       })
   )
 
@@ -116,14 +106,67 @@ export async function getIykcProofs (pubkeys, {
     }
   }
 
-  for (const pubkey of missingPubkeys) {
+  const out = {}
+  for (const pubkey of pubkeyList) {
     const entry = latestByPubkey[pubkey]
     const proof = entry
       ? { iykcPubkey: entry.iykcPubkey, iykcProof: entry.iykcProof }
       : null
-    setCachedValue(contentKeysByPubkey, iykcCacheTimersByPubkey, iykcCacheAddedAtByPubkey, pubkey, cloneContentKey(proof), cacheMs)
-    if (proof) out[pubkey] = proof
+    if (proof) {
+      setCachedValue(contentKeysByPubkey, iykcCacheTimersByPubkey, iykcCacheAddedAtByPubkey, pubkey, cloneContentKey(proof), cacheMs)
+      out[pubkey] = proof
+    } else if (negativeCacheMs > 0) {
+      // Misses expire quickly so a peer that publishes a key right after a
+      // prefetch is picked up without waiting for the positive cache window.
+      setCachedValue(contentKeysByPubkey, iykcCacheTimersByPubkey, iykcCacheAddedAtByPubkey, pubkey, null, negativeCacheMs)
+    }
   }
   pruneCache(contentKeysByPubkey, iykcCacheTimersByPubkey, iykcCacheAddedAtByPubkey, IYKC_CACHE_MAX_ITEMS)
   return out
 }
+
+export async function getIykcProofs (pubkeys, {
+  _getEvents = getEvents,
+  _getRelaysByPubkey = getRelaysByPubkey,
+  cacheMs = QUERY_CACHE_MS,
+  negativeCacheMs = NEGATIVE_CACHE_MS
+} = {}) {
+  const pubkeyList = uniquePubkeys(pubkeys, { requireHex: _getEvents === getEvents })
+  if (!pubkeyList.length) return {}
+
+  const out = {}
+  const waiting = []
+  const toQuery = []
+  for (const pubkey of pubkeyList) {
+    if (hasCachedKey(contentKeysByPubkey, pubkey)) {
+      const cached = cloneContentKey(contentKeysByPubkey[pubkey])
+      if (cached) out[pubkey] = cached
+      continue
+    }
+    const pending = inFlightByPubkey.get(pubkey)
+    if (pending) waiting.push([pubkey, pending])
+    else toQuery.push(pubkey)
+  }
+
+  if (toQuery.length) {
+    const query = queryContentKeyProofs(toQuery, { _getEvents, _getRelaysByPubkey, cacheMs, negativeCacheMs })
+    for (const pubkey of toQuery) inFlightByPubkey.set(pubkey, query)
+    try {
+      Object.assign(out, await query)
+    } finally {
+      for (const pubkey of toQuery) {
+        if (inFlightByPubkey.get(pubkey) === query) inFlightByPubkey.delete(pubkey)
+      }
+    }
+  }
+
+  for (const [pubkey, pending] of waiting) {
+    const found = await pending.catch(() => null)
+    if (found?.[pubkey]) out[pubkey] = found[pubkey]
+    else {
+      const cached = cloneContentKey(contentKeysByPubkey[pubkey])
+      if (cached) out[pubkey] = cached
+    }
+  }
+  return out
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "libp2r2p",
-  "version": "0.11.8",
+  "version": "0.11.10",
   "description": "Peer-to-relay-to-peer",
   "keywords": [
     "p2r2p",

package/private-channel/helpers/lookup-warning.js

@@ -0,0 +1,29 @@
+export const LOOKUP_WARNING_INTERVAL_MS = 30_000
+
+// Best-effort discovery can fail on every message while a relay or the
+// network is unavailable. Keep the first failure visible, then debounce
+// repeats and report how many were suppressed on the next log.
+export function createLookupWarningLogger ({
+  intervalMs = LOOKUP_WARNING_INTERVAL_MS,
+  label = 'private-messenger content-key lookup failed',
+  warn = (...args) => console.warn(...args),
+  now = Date.now
+} = {}) {
+  let warnedAt = null
+  let suppressed = 0
+  return (error, context = '') => {
+    const current = now()
+    if (warnedAt !== null && current - warnedAt < intervalMs) {
+      suppressed++
+      return false
+    }
+    const count = suppressed
+    warnedAt = current
+    suppressed = 0
+    warn(
+      `${label}${context ? ` (${context})` : ''}${count ? ` [${count} repeated failures suppressed]` : ''}`,
+      error?.message ?? error
+    )
+    return true
+  }
+}

package/private-channel/index.js

@@ -9,6 +9,7 @@ import { normalizeRumor, deliveryInfo } from './helpers/rumor.js'
 import { incompleteFetchError } from './helpers/fetch-error.js'
 import { readHistory } from './helpers/history.js'
 import { subscriptionError } from './helpers/subscription-error.js'
+import { createLookupWarningLogger } from './helpers/lookup-warning.js'
 import * as nip44v3 from '../nip44-v3/index.js'
 import { relayPool } from '../relay/index.js'
 import { JSONL_CHUNK_BYTES, NYM_CARRIER_CHUNK_CHARS } from './helpers/chunk-size.js'
@@ -35,6 +36,7 @@ const HEX_SECKEY = /^[0-9a-f]{64}$/i
 const HEX_PUBKEY = /^[0-9a-f]{64}$/i
 const encoder = new TextEncoder()
 const decoder = new TextDecoder()
+const warnLookupFailure = createLookupWarningLogger()
 const NIP44_V3_SCOPE = ''
 
 const sendToRelays = (event, relays) => relayPool.sendEvent(event, relays)
@@ -110,7 +112,19 @@ async function prepareRoutedMessage ({ senderSigner, imkcSigner, privateChannelS
   const useDoubleDh = typeof senderSigner.nip44EncryptDoubleDH === 'function'
   const channelPubkey = await privateChannelSigner.getPublicKey()
   const channelReaderPubkey = privateChannelReaderPubkey || channelPubkey
-  const receiverContentKeys = useDoubleDh ? await _getIykcProofs(receiverPubkeysWithoutContentKeys(receivers)) : {}
+  let receiverContentKeys = {}
+  if (useDoubleDh) {
+    const receiversWithoutContentKeys = receiverPubkeysWithoutContentKeys(receivers)
+    try {
+      receiverContentKeys = await _getIykcProofs(receiversWithoutContentKeys) || {}
+    } catch (error) {
+      // Content-key discovery is best-effort; without a proof the row still
+      // works in sender-content mode instead of failing the send. Keep
+      // failures visible without logging on every message during an outage.
+      warnLookupFailure(error, `recipients: ${receiversWithoutContentKeys.length}`)
+      receiverContentKeys = {}
+    }
+  }
   const preparedRows = await prepareEnvelopeRows({
     senderSigner,
     imkcSigner: useDoubleDh ? imkcSigner : null,
@@ -390,13 +404,18 @@ async function unwrapRecipientEnvelope ({ payloadCiphertext, envelope, receiverS
     if (envelope.iykcPubkey) {
       assertValidEnvelopeIykcProof(envelope)
     }
+    // In self-encryption the advertised sender content key is also our own.
+    // Rows written without a content-key lookup (useContentKeys: false) carry
+    // no iykc pubkey, so hand imkc to the signer as the receiver's own key.
+    const ownContentPubkey = envelope.iykcPubkey ||
+      (senderPubkey && receiverPubkey && senderPubkey === receiverPubkey ? imkcPubkey : '')
     messageSeckey = base64ToText(await receiverSigner.nip44DecryptDoubleDH(
       senderPubkey,
       ROUTER_KIND,
       rowScope,
       envelope.ciphertext,
       imkcPubkey,
-      envelope.iykcPubkey || ''
+      ownContentPubkey
     ))
   } else {
     if (!receiverSigner?.nip44v3Decrypt) throw new ValidationError('RECEIVER_SIGNER_NIP44V3_DECRYPT_UNSUPPORTED')

package/private-messenger/file/index.js

@@ -243,6 +243,16 @@ export function createPrivateFileTransfer ({ messenger, resolveChannel, storage,
     const requestedSeeders = new Set()
     const validSeeders = new Set([file.peerPubkey, ...messenger.recoverySeeders(file.controlChannelPubkey)])
     let terminalError
+    let lastError = null
+    const reportError = error => {
+      lastError = {
+        name: error?.name || 'Error',
+        message: error?.message ?? String(error),
+        code: error?.code || '',
+        at: Date.now()
+      }
+      onError(error)
+    }
     const fail = error => { terminalError ||= error }
     async function accept (event, index, { save = true } = {}) {
       signal.throwIfAborted()
@@ -297,7 +307,7 @@ export function createPrivateFileTransfer ({ messenger, resolveChannel, storage,
       })
       // Malformed remote records do not poison the ingestion chain. Operational
       // persistence failures stop the job so completion cannot outrun storage.
-      ingest = task.catch(error => { if (error instanceof ValidationError) onError(error); else if (!signal.aborted) fail(error) })
+      ingest = task.catch(error => { if (error instanceof ValidationError) reportError(error); else if (!signal.aborted) fail(error) })
       return ingest
     }
     try {
@@ -312,7 +322,7 @@ export function createPrivateFileTransfer ({ messenger, resolveChannel, storage,
       if (total !== undefined && persisted.size === total) return
       const parent = messenger.requireWritableChannel(file.controlChannelPubkey)
       const relays = await messenger.resolveWatchRelays(parent)
-      const options = { receiverSigner: messenger.userSigner, privateChannelSigner: file.signer, privateChannelPubkey: file.fileChannelPubkey, receiverPubkey: messenger.userPubkey, relays, receivedChunkIndexedDB: messenger._indexedDB, receivedChunkScope: `${messenger.userPubkey}:file:${file.fileChannelPubkey}`, onEvent: consume, onSeedEvent: seed => saveSeed(file, seed), mode: messenger.channels.get(file.controlChannelPubkey)?.mode === 'watchtower' ? 'watchtower' : 'leecher', onError }
+      const options = { receiverSigner: messenger.userSigner, privateChannelSigner: file.signer, privateChannelPubkey: file.fileChannelPubkey, receiverPubkey: messenger.userPubkey, relays, receivedChunkIndexedDB: messenger._indexedDB, receivedChunkScope: `${messenger.userPubkey}:file:${file.fileChannelPubkey}`, onEvent: consume, onSeedEvent: seed => saveSeed(file, seed), mode: messenger.channels.get(file.controlChannelPubkey)?.mode === 'watchtower' ? 'watchtower' : 'leecher', onError: reportError }
       sub = _transport.subscribe({ ...options, liveOnly: true })
       const stop = () => { sub?.close() }
       signal.addEventListener('abort', stop, { once: true })
@@ -323,7 +333,7 @@ export function createPrivateFileTransfer ({ messenger, resolveChannel, storage,
         const history = _transport.fetch({ ...options, signal: AbortSignal.any([signal, historyController.signal]), since: 0 }).catch(error => {
           // Completion aborts the remaining history read in finally. Only its
           // own cancellation is expected; genuine history failures stay visible.
-          if (!signal.aborted && !(historyController.signal.aborted && error === historyController.signal.reason)) onError(error)
+          if (!signal.aborted && !(historyController.signal.aborted && error === historyController.signal.reason)) reportError(error)
         })
         work.add(history); history.finally(() => work.delete(history))
         const seeders = [...validSeeders].sort((a, b) => (successes.get(b) || 0) - (successes.get(a) || 0) || Math.random() - 0.5)
@@ -340,9 +350,33 @@ export function createPrivateFileTransfer ({ messenger, resolveChannel, storage,
             requestedSeeders.add(peer)
             requestRoundAt = Date.now() + _hedgeMs
             // The request is on dm; its compact reply is on the file channel.
-            await messenger.ask({ channelPubkey: file.controlChannelPubkey, receiverPubkey: peer, code: FILE_CHUNKS_REQUEST_CODE, payload: { fileChannelPubkey: file.fileChannelPubkey, missingRanges: rangesFor(missing) } }).catch(onError)
+            await messenger.ask({ channelPubkey: file.controlChannelPubkey, receiverPubkey: peer, code: FILE_CHUNKS_REQUEST_CODE, payload: { fileChannelPubkey: file.fileChannelPubkey, missingRanges: rangesFor(missing) } }).catch(reportError)
+          }
+          if (!remaining.length && Date.now() - Math.max(lastProgress, requestRoundAt - _hedgeMs) >= _idleMs) {
+            const details = {
+              operation: 'file-download-stall',
+              ownerPubkey: messenger.userPubkey,
+              root: file.root,
+              peerPubkey: file.peerPubkey,
+              total,
+              persisted: persisted.size,
+              missingRanges: rangesFor(missing),
+              missingCount: total === undefined ? null : total - persisted.size,
+              seeders: [...validSeeders],
+              requestedSeeders: [...requestedSeeders],
+              lastProgressAt: new Date(lastProgress).toISOString(),
+              lastProgressAgoMs: Date.now() - lastProgress,
+              elapsedMs: Date.now() - Math.max(lastProgress, requestRoundAt - _hedgeMs),
+              lastError
+            }
+            const error = new Error('FILE_DOWNLOAD_STALLED')
+            error.code = 'FILE_DOWNLOAD_STALLED'
+            error.operation = details.operation
+            error.elapsedMs = details.elapsedMs
+            error.details = details
+            console.warn('private-messenger file download stalled', details)
+            throw error
           }
-          if (!remaining.length && Date.now() - Math.max(lastProgress, requestRoundAt - _hedgeMs) >= _idleMs) throw new Error('FILE_DOWNLOAD_STALLED')
           // Start a fresh batch when all positions of the previous batch arrived.
           if (job.batch?.every(index => persisted.has(index))) { requestedSeeders.clear(); requestRoundAt = Date.now(); job.batch = null }
           job.batch ||= missing

package/private-messenger/session/README.md

@@ -9,11 +9,18 @@ Provide `owner`, a byte-based NIP-44 v3 `signer` with `withSharedKey`, and eithe
 Optional `chunkStorage` and `recoveryStorage` (`seeds`, `authorizations`) select
 persistence; absent file storage uses the library cache. `mode` defaults to
 `seeder`, `seedersForPeer(peer)` to `[peer]`, and `allowedKinds` to
-`[5, 9, 1063, 34601]`. The DM context is `dm`; file contexts are `dm:media:<root>`.
+`[5, 9, 1063, 34601]`. `useContentKeys` defaults to `true`: the coordinator looks
+up recipients' published content-key proofs (kind 18716) while sending and falls
+back to sender-content whenever a proof is missing or the lookup fails. Misses
+are cached for 5 minutes (found proofs for 40), so a later prefetch picks up a
+key published after an earlier miss. Set it to `false` when the signer owns that discovery. The DM context is `dm`; file contexts are `dm:media:<root>`.
 `createMessengerSigner` adapts this byte signer to the transport's Base64 API.
 
-Methods: `setPeers`, `setAvailable(boolean)`, `enqueue`, `retry`, `cancel`,
-`download`, `cancelDownload`, and `close`. Callbacks are `onOutbox`, `onMedia`,
+Methods: `setPeers`, `setAvailable(boolean)`, `prefetchContentKeys(peers?)`,
+`enqueue`, `retry`, `cancel`, `download`, `cancelDownload`, and `close`.
+`prefetchContentKeys` warms the content-key lookup cache for the owner and the
+given peers (default: current peers); it is best-effort and never rejects.
+Callbacks are `onOutbox`, `onMedia`,
 `onError`, and optional `onSendError(error, { id, peer })`. The caller maps its
 account permissions/connectivity/lock state to availability and owns view subscriptions. There are no DOM or UI imports.
 

package/private-messenger/session/helpers/signer.js

@@ -3,11 +3,21 @@ import { base64ToBytes, bytesToBase64 } from '../../../base64/index.js'
 // The library transport uses its Base64 signer contract. Conversion stays at
 // this adapter; the injected launcher/vault channel always carries raw bytes.
 export function messengerSigner (signer) {
-  return {
+  const adapter = {
     getPublicKey: () => signer.getPublicKey(),
     getRelays: () => signer.getRelays(),
     signEvent: event => signer.signEvent(event),
     nip44v3Encrypt: (peer, kind, scope, text) => signer.nip44v3.encrypt(peer, kind, scope, base64ToBytes(text).buffer),
     nip44v3Decrypt: async (peer, kind, scope, ciphertext) => bytesToBase64(new Uint8Array(await signer.nip44v3.decrypt(peer, kind, scope, ciphertext)))
   }
+  // Double DH stays opt-in by capability: a signer without both methods keeps
+  // the identity-only fallback that the private channel selects by itself.
+  if (typeof signer?.nip44v3?.encryptDoubleDH === 'function' &&
+      typeof signer?.nip44v3?.decryptDoubleDH === 'function') {
+    adapter.nip44EncryptDoubleDH = (peer, kind, scope, text, peerContentPubkey = '') =>
+      signer.nip44v3.encryptDoubleDH(peer, kind, scope, base64ToBytes(text).buffer, peerContentPubkey)
+    adapter.nip44DecryptDoubleDH = async (peer, kind, scope, ciphertext, peerContentPubkey = '', ownContentPubkey = '') =>
+      bytesToBase64(new Uint8Array(await signer.nip44v3.decryptDoubleDH(peer, kind, scope, ciphertext, peerContentPubkey, ownContentPubkey)))
+  }
+  return adapter
 }

package/private-messenger/session/index.js

@@ -3,6 +3,7 @@ import { createPrivateFileTransfer } from '../file/index.js'
 import { createPrivateMessenger } from '../index.js'
 import { getEventHash, isValidEvent, isSerializableEvent } from '../../event/index.js'
 import { decodeIrfsChunk, IRFS_CHUNK_BYTES } from '../../irfs/index.js'
+import { getIykcProofs } from '../../content-key/index.js'
 import { onOnline } from '../../network/index.js'
 import { decodeFileMetadata } from '../../nip94/index.js'
 import { createChatOutbox } from './helpers/work-storage.js'
@@ -18,7 +19,7 @@ export function wireEvent (value, owner) {
 // Relay rejection text must not be interpreted as a local signer denial.
 const retryable = error => error?.code === 'MESSAGE_NOT_PUBLISHED' || !/DENIED|PERMISSION|REVOKED|READ_ONLY|INVALID|BLOCKED|EXPIRED|NOT_IN_PERSONA/i.test(`${error?.code || ''} ${error?.message || ''}`)
 
-export function createPrivateMessageSession ({ owner, signer, eventStore, messageStorage, chunkStorage, recoveryStorage, fallbackRelays = [], mode = 'seeder', seedersForPeer = peer => [peer], allowedKinds = [5, 9, 1063, 34601], onMedia = () => {}, onOutbox = () => {}, onError = () => {}, onSendError = () => {}, Messenger = createPrivateMessenger, openOutbox = createChatOutbox, FileTransfer = createPrivateFileTransfer, _onOnline = onOnline, openDownloads = options => createChatOutbox({ ...options, namespace: 'downloads' }) }) {
+export function createPrivateMessageSession ({ owner, signer, eventStore, messageStorage, chunkStorage, recoveryStorage, fallbackRelays = [], mode = 'seeder', seedersForPeer = peer => [peer], allowedKinds = [5, 9, 1063, 34601], useContentKeys = true, onMedia = () => {}, onOutbox = () => {}, onError = () => {}, onSendError = () => {}, Messenger = createPrivateMessenger, openOutbox = createChatOutbox, FileTransfer = createPrivateFileTransfer, _onOnline = onOnline, _getIykcProofs = getIykcProofs, openDownloads = options => createChatOutbox({ ...options, namespace: 'downloads' }) }) {
   fallbackRelays = normalizeFallbackRelays(fallbackRelays)
   const userSigner = messengerSigner(signer)
   messageStorage ||= createEventStoreMessageStorage({ eventStore })
@@ -76,7 +77,7 @@ export function createPrivateMessageSession ({ owner, signer, eventStore, messag
       if (closed || !available || version !== lifecycle) return
       values.push(channel)
     }
-    if (!messenger) messenger = await Messenger({ fallbackRelays, seedStorage: recoveryStorage?.seeds, userSigner, channels: [], useContentKeys: false, onMessageQueued: () => drain(), onError })
+    if (!messenger) messenger = await Messenger({ fallbackRelays, seedStorage: recoveryStorage?.seeds, userSigner, channels: [], useContentKeys, onMessageQueued: () => drain(), onError })
     if (closed || !available || version !== lifecycle) { await messenger.pause('signer'); return }
     await messenger.update({ channels: values })
     await messenger.resume('signer')
@@ -284,6 +285,24 @@ export function createPrivateMessageSession ({ owner, signer, eventStore, messag
   }
   return {
     download, cancelDownload,
+    // Peers-based so callers can prefetch as soon as a chat route opens, before
+    // the shared-key channel exists. When group chats get real membership, add
+    // a thin prefetchChannelContentKeys(channelPubkey) wrapper that resolves
+    // the channel's receivers and delegates here.
+    async prefetchContentKeys (values = [...peers]) {
+      if (closed || !useContentKeys) return {}
+      const requested = [...new Set([owner, ...(Array.isArray(values) ? values : [values])])]
+        .filter(value => typeof value === 'string' && value)
+      if (!requested.length) return {}
+      try {
+        return await _getIykcProofs(requested)
+      } catch (error) {
+        // Prefetch only warms the lookup cache; callers must keep working with
+        // sender-content until a proof is available. Keep the failure visible.
+        console.warn('private-messenger content-key prefetch failed', error?.message ?? error)
+        return {}
+      }
+    },
     async setPeers (values) {
       peers.clear(); for (const peer of values) if (peer !== owner) peers.add(peer)
       for (const peer of deniedPeers) if (!peers.has(peer)) deniedPeers.delete(peer)