libp2r2p 0.11.16 → 0.11.18

package/private-messenger/session/index.js

@@ -5,11 +5,13 @@ import { getEventHash, isValidEvent, isSerializableEvent } from '../../event/ind
 import { decodeIrfsChunk, IRFS_CHUNK_BYTES } from '../../irfs/index.js'
 import { getIykcProofs } from '../../content-key/index.js'
 import { onOnline } from '../../network/index.js'
+import { ValidationError } from '../../error/index.js'
 import { decodeFileMetadata } from '../../nip94/index.js'
 import { createChatOutbox } from './helpers/work-storage.js'
 import { messengerSigner } from './helpers/signer.js'
 import { assertMessagePublished } from '../helpers/publication.js'
-import { normalizeFallbackRelays } from '../helpers/send-routing.js'
+import { normalizeFallbackRelays, normalizeFallbackDelay } from '../helpers/send-routing.js'
+import { createPauseRecovery, isRecoverableStorageFailure } from '../helpers/pause-recovery.js'
 
 export function wireEvent (value, owner) {
   const event = { kind: value.kind, created_at: value.created_at, tags: structuredClone(value.tags), content: value.content, pubkey: value.pubkey || owner }
@@ -27,12 +29,21 @@ const SEND_RETRY_MAX_MS = 30000
 const unavailableError = (error, signal) => Object.assign(new Error(error?.message || 'CHAT_UNAVAILABLE'), {
   code: error?.code,
   cause: error,
+  ...(Array.isArray(error?.pauseReasons) ? { pauseReasons: [...error.pauseReasons] } : {}),
   retryWhenAvailable: !signal?.aborted,
   retryWhenOnline: false
 })
 
-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, _setTimeout = setTimeout, _clearTimeout = clearTimeout, _random = Math.random, openDownloads = options => createChatOutbox({ ...options, namespace: 'downloads' }) }) {
+function messengerStatusSnapshot (value) {
+  if (!value || typeof value.closed !== 'boolean' || typeof value.paused !== 'boolean' ||
+      !Array.isArray(value.pauseReasons) || value.pauseReasons.some(reason => typeof reason !== 'string' || !reason.trim()) ||
+      value.paused !== Boolean(value.pauseReasons.length)) throw new ValidationError('INVALID_MESSENGER_STATUS')
+  return { closed: value.closed, paused: value.paused, pauseReasons: [...value.pauseReasons] }
+}
+
+export function createPrivateMessageSession ({ owner, signer, eventStore, messageStorage, chunkStorage, recoveryStorage, fallbackRelays = [], fallbackDelayMs = null, 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, _setTimeout = setTimeout, _clearTimeout = clearTimeout, _random = Math.random, openDownloads = options => createChatOutbox({ ...options, namespace: 'downloads' }) }) {
   fallbackRelays = normalizeFallbackRelays(fallbackRelays)
+  fallbackDelayMs = normalizeFallbackDelay(fallbackDelayMs)
   const reportedErrors = new WeakSet()
   const reportError = error => {
     if (error && (typeof error === 'object' || typeof error === 'function')) {
@@ -51,6 +62,33 @@ export function createPrivateMessageSession ({ owner, signer, eventStore, messag
   const cancelled = new Set()
   const sendControllers = new Map()
   const offlineSends = new Set()
+  const pausedSends = new Set()
+  let messengerStatus
+  let messengerBinding
+  let storageBlocked = false
+  const inboxRecovery = createPauseRecovery({
+    attempt: async signal => { signal.throwIfAborted(); await drain(); if (storageBlocked) throw inboxError },
+    retryable: isRecoverableStorageFailure, onError: reportError,
+    setTimer: _setTimeout, clearTimer: _clearTimeout, random: _random
+  })
+  let inboxError
+  const stateChanged = state => {
+    if (closed) return
+    messengerStatus = messengerStatusSnapshot(state)
+    if (!available || state.closed) return
+    if (state.paused) {
+      for (const entry of entries.values()) {
+        if (entry.peer !== owner && entry.failed && entry.status === 'pending') pausedSends.add(entry.id)
+      }
+      if (![...entries.values()].some(entry => pendingRetryable(entry) && !pausedSends.has(entry.id))) clearSendRetry()
+      return
+    }
+    clearSendRetry()
+    for (const id of pausedSends) { const entry = entries.get(id); if (entry) entry.failed = false }
+    pausedSends.clear()
+    // The callback can run inside construction/resume, before configure settles.
+    queueMicrotask(() => pump())
+  }
   let stopOnline
   let sendRetryTimer
   let sendRetryDelay = SEND_RETRY_MIN_MS
@@ -70,12 +108,15 @@ export function createPrivateMessageSession ({ owner, signer, eventStore, messag
   let storage
   let initialized
   let closed = false
+  let closeWork
   let available = false
   let lifecycle = 0
   let configuring = Promise.resolve()
+  let configurationFailed = false
   let sending
   let repump
   let draining
+  let redrain = false
   const idleWaiters = new Set()
   const settled = () => { if (!sending && !draining) { for (const resolve of idleWaiters) resolve(); idleWaiters.clear() } }
   const emit = () => onOutbox([...entries.values()].filter(entry => !entry.deletion))
@@ -84,6 +125,35 @@ export function createPrivateMessageSession ({ owner, signer, eventStore, messag
     for (const entry of await storage.list()) entries.set(entry.id, entry)
     emit()
   })().catch(async error => { await storage?.close(); storage = null; initialized = null; throw error }))
+  async function createMessenger () {
+    const binding = {}
+    messengerBinding = binding
+    let notified = false
+    let candidate
+    try {
+      candidate = await Messenger({
+        fallbackRelays, fallbackDelayMs, seedStorage: recoveryStorage?.seeds, userSigner, channels: [], useContentKeys,
+        onMessageQueued: () => { if (messengerBinding === binding) return drain() },
+        onStateChanged: state => {
+          if (closed || messengerBinding !== binding) return
+          stateChanged(state)
+          notified = true
+        },
+        onError: reportError
+      })
+      if (closed) { messengerBinding = null; await candidate?.close?.(); return }
+      if (typeof candidate?.readStatus !== 'function' || !notified) throw new ValidationError('MESSENGER_STATE_CONTRACT_REQUIRED')
+      const status = messengerStatusSnapshot(candidate.readStatus())
+      messenger = candidate
+      stateChanged(status)
+    } catch (error) {
+      messengerBinding = null
+      messengerStatus = undefined
+      try { await candidate?.close?.() } catch (cleanupError) { reportError(cleanupError) }
+      throw error
+    }
+  }
+
   async function configure () {
     if (closed || !available) return
     await ready()
@@ -102,7 +172,8 @@ 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, onMessageQueued: () => drain(), onError: reportError })
+    if (!messenger) await createMessenger()
+    if (!messenger) return
     if (closed || !available || version !== lifecycle) { await messenger.pause('signer'); return }
     await messenger.update({ channels: values })
     if (pendingPriorityRanges.size && typeof messenger.prioritizeRange === 'function') {
@@ -116,6 +187,7 @@ export function createPrivateMessageSession ({ owner, signer, eventStore, messag
       }
     }
     await messenger.resume('signer')
+    if (storageBlocked) inboxRecovery.start({ immediate: true })
     if (!fileTransfers) {
       fileTransfers = FileTransfer({
         messenger, onError: reportError,
@@ -153,13 +225,16 @@ export function createPrivateMessageSession ({ owner, signer, eventStore, messag
   function schedule () {
     const work = configuring.catch(() => {}).then(configure)
     configuring = work
-    work.catch(reportError)
+    work.then(() => { if (configuring === work) configurationFailed = false }, error => { if (configuring === work) configurationFailed = true; reportError(error) })
     return work
   }
   async function drain () {
-    if (draining || closed || !available || !messenger) return
+    if (draining) { redrain = true; return }
+    if (closed || !available || !messenger) return
     draining = true
     const deferred = []
+    let persisted = false
+    let passFailed = false
     try {
       while (true) {
         if (closed || !available) break
@@ -181,16 +256,33 @@ export function createPrivateMessageSession ({ owner, signer, eventStore, messag
           if (!available || closed) { await nack(); break }
           const saved = await messageStorage.save(event, { peerPubkey: peer, hearsay: message.provenance === 'hearsay' })
           if (!saved?.result?.ok && !['blocked', 'expired'].includes(saved?.result?.code)) throw Object.assign(new Error('INBOX_STORAGE_FAILED'), { code: saved?.result?.code?.toUpperCase() })
-          await ack()
+          if (!available || closed) { await nack(); break }
+          if (await ack() === false) throw new Error('INBOX_ACK_FAILED')
+          persisted = true
         } catch (error) {
           await nack()
           reportError(error)
           // Retain the failed record and suspend network ingestion until recovery.
-          await messenger.pause('storage')
+          passFailed = true
+          storageBlocked = true
+          inboxError = error
+          await messenger.pause('session-storage')
+          if (isRecoverableStorageFailure(error)) inboxRecovery.start()
           break
         }
       }
-    } finally { await Promise.all(deferred.map(nack => nack())); draining = false; settled() }
+      if (storageBlocked && persisted && !passFailed) {
+        // A retry can save one record and fail the next. Only release after the
+        // whole currently admissible pass completes without another failure.
+        storageBlocked = false; inboxError = null
+        await messenger.resume('session-storage')
+      }
+    } finally {
+      await Promise.all(deferred.map(nack => nack()))
+      draining = false; settled()
+      const again = redrain; redrain = false
+      if (again && !storageBlocked && !closed && available) queueMicrotask(() => drain())
+    }
   }
   async function publish (peer, event, signal) {
     if (deniedPeers.has(peer)) throw new Error('PERMISSION_DENIED')
@@ -229,6 +321,9 @@ export function createPrivateMessageSession ({ owner, signer, eventStore, messag
           await storage.put(entry, { existing: true })
         }
       }
+      if (entry.peer !== owner && messengerStatus?.paused) {
+        throw unavailableError(Object.assign(new Error('PRIVATE_MESSENGER_PAUSED'), { pauseReasons: [...messengerStatus.pauseReasons] }), controller.signal)
+      }
       // Read/publish one chunk at a time. Progress is durable after each
       // accepted chunk; replay after interruption keeps its original identity.
       for (; entry.peer !== owner && entry.fileIndex < entry.files.length; entry.fileIndex++, entry.chunkIndex = 0) {
@@ -273,20 +368,20 @@ export function createPrivateMessageSession ({ owner, signer, eventStore, messag
       if (cancelled.has(entry.id)) { await storage.remove(entry.id); entries.delete(entry.id) } else {
         entry.status = error.retryWhenAvailable ? 'pending' : 'error'; entry.failed = true; entry.retryable = retryable(error)
         await storage.put(entry, { existing: true }).catch(reportError)
+        if (entry.peer !== owner && error.retryWhenAvailable && messenger.readStatus().paused) pausedSends.add(entry.id)
         reportError(error)
         // The failed wire event may be a quote or file chunk. Report the
         // owning outbox item separately, without mutating the native error.
         if (error.retryWhenOnline) offlineSends.add(entry.id)
-        if (error.retryWhenAvailable) scheduleSendRetry()
+        if (error.retryWhenAvailable && !pausedSends.has(entry.id)) scheduleSendRetry()
         if (!closed && !entry.deletion && !cancelled.has(entry.id) && !error.retryWhenAvailable) onSendError(error, { id: entry.id, peer: entry.peer })
       }
       emit()
     } finally { sendControllers.delete(entry.id) }
   }
   function stopOnlineRetry () { stopOnline?.(); stopOnline = undefined }
-  // Entries that failed only because the messenger was paused/unavailable do
-  // not receive a connectivity transition, so they own a bounded backoff timer
-  // instead of waiting for the next account-state change.
+  // Transient availability failures without an active messenger pause retain
+  // bounded retries. Observed pauses wait exclusively for their release.
   function clearSendRetry () {
     if (sendRetryTimer) _clearTimeout(sendRetryTimer)
     sendRetryTimer = undefined
@@ -305,7 +400,7 @@ export function createPrivateMessageSession ({ owner, signer, eventStore, messag
       if (closed || !available) return
       let retried = false
       for (const entry of entries.values()) {
-        if (!pendingRetryable(entry)) continue
+        if (!pendingRetryable(entry) || pausedSends.has(entry.id)) continue
         entry.failed = false
         retried = true
       }
@@ -341,9 +436,10 @@ export function createPrivateMessageSession ({ owner, signer, eventStore, messag
         for (const entry of entries.values()) {
           if (closed || !available) break
           if ((entry.peer !== owner && !peers.has(entry.peer)) || entry.failed || cancelled.has(entry.id)) continue
+          if (entry.peer !== owner && entry.files.length && !fileTransfers) continue
           await sendEntry(entry)
         }
-      } while (repump && !closed && available)
+      } while (repump)
     } finally {
       sending = false
       watchOfflineSends()
@@ -416,21 +512,26 @@ export function createPrivateMessageSession ({ owner, signer, eventStore, messag
       return true
     },
     async setPeers (values) {
-      peers.clear(); for (const peer of values) if (peer !== owner) peers.add(peer)
+      const next = new Set([...values].filter(peer => peer !== owner))
+      if (next.size === peers.size && [...next].every(peer => peers.has(peer))) return configuring
+      peers.clear(); for (const peer of next) peers.add(peer)
       for (const peer of deniedPeers) if (!peers.has(peer)) deniedPeers.delete(peer)
       lifecycle++
       return schedule()
     },
     async setAvailable (value) {
+      const changed = available !== (value === true)
       available = value === true
+      if (!changed && !available) return
       stopOnlineRetry(); offlineSends.clear()
       if (available) resetSendRetry()
       else clearSendRetry()
-      lifecycle++
-      if (!available) { await messenger?.pause('signer'); return }
+      if (changed) lifecycle++
+      if (!available) { inboxRecovery.stop(); await messenger?.pause('signer'); return }
       await ready()
       for (const entry of entries.values()) if (pendingRetryable(entry)) entry.failed = false
-      await messenger?.resume('storage')
+      if (storageBlocked) inboxRecovery.start({ immediate: true })
+      if (!changed && messenger && !configurationFailed) return pump()
       return schedule()
     },
     async enqueue ({ peer, event, context = [], requiredFiles = [], deletion = false }) {
@@ -446,7 +547,8 @@ export function createPrivateMessageSession ({ owner, signer, eventStore, messag
       return id
     },
     async retry (id) {
-      offlineSends.delete(id); watchOfflineSends()
+      offlineSends.delete(id); pausedSends.delete(id); watchOfflineSends()
+      if (storageBlocked) inboxRecovery.start({ immediate: true })
       await ready()
       const entry = entries.get(id)
       if (entry) { entry.failed = false; resetSendRetry(); if (deniedPeers.delete(entry.peer)) await schedule(); return pump() }
@@ -454,24 +556,26 @@ export function createPrivateMessageSession ({ owner, signer, eventStore, messag
     async cancel (id) {
       cancelled.add(id)
       sendControllers.get(id)?.abort()
-      offlineSends.delete(id); watchOfflineSends()
+      offlineSends.delete(id); pausedSends.delete(id); watchOfflineSends()
       await ready()
       entries.delete(id)
       await storage.remove(id)
       emit()
     },
-    async close () {
-      closed = true; available = false; lifecycle++
-      stopOnlineRetry(); offlineSends.clear(); activeDownloads.clear(); pendingPriorityRanges.clear()
-      clearSendRetry()
-      for (const controller of sendControllers.values()) controller.abort()
-      await Promise.allSettled([configuring, initialized])
-      await messenger?.pause('closed')
-      if (sending || draining) await new Promise(resolve => idleWaiters.add(resolve))
-      await messenger?.close()
-      await storage?.close()
-      await downloadWriteTail.catch(reportError)
-      await downloads?.close()
+    close () {
+      return (closeWork ??= (async () => {
+        closed = true; available = false; lifecycle++
+        stopOnlineRetry(); offlineSends.clear(); activeDownloads.clear(); pendingPriorityRanges.clear()
+        clearSendRetry(); inboxRecovery.stop(); pausedSends.clear()
+        for (const controller of sendControllers.values()) controller.abort()
+        await Promise.allSettled([configuring, initialized])
+        await messenger?.pause('closed')
+        if (sending || draining) await new Promise(resolve => idleWaiters.add(resolve))
+        await messenger?.close()
+        await storage?.close()
+        await downloadWriteTail.catch(reportError)
+        await downloads?.close()
+      })())
     }
   }
 }

package/relay/helpers/publish.js

@@ -76,7 +76,11 @@ export function createPublishSettlements (promises, timeout, { onSettled } = {})
     })
   }
 
-  return { promise, timeout: timeoutPending }
+  const cancel = reason => {
+    if (isFinished) return
+    for (let index = 0; index < settlements.length; index++) settle(index, { status: 'rejected', outcome: 'failed', reason })
+  }
+  return { promise, timeout: timeoutPending, cancel }
 }
 
 // Turns ordered relay settlements into a stable, caller-facing report. Failed

package/relay/services/relay-connection.js

@@ -186,23 +186,33 @@ export class RelayConnection {
   }
 
   #sendEventOperation (type, event, map, timeoutCode, signal) {
-    if (signal?.aborted) return Promise.reject(signal.reason || relayTimeoutError(timeoutCode))
-    if (map.has(event.id)) return map.get(event.id).promise
+    if (signal?.aborted) return Promise.reject(signal.reason)
+    let pending = map.get(event.id)
+    const created = !pending
+    if (created) {
+      const timer = maybeUnref(setTimeout(() => this.#settleEvent(map, event.id, relayTimeoutError(timeoutCode, this.#lastTransportError)), this.publishTimeout))
+      pending = { timer, waiters: new Set(), cancelSend: null }
+      map.set(event.id, pending)
+    }
     const deferred = Promise.withResolvers()
-    const timer = maybeUnref(setTimeout(() => this.#settleEvent(map, event.id, relayTimeoutError(timeoutCode, this.#lastTransportError)), this.publishTimeout))
-    const onAbort = () => this.#settleEvent(map, event.id, signal.reason || relayTimeoutError(timeoutCode))
-    const stopAbort = () => signal?.removeEventListener('abort', onAbort)
-    const pending = { ...deferred, timer, promise: deferred.promise, cancelSend: null, stopAbort }
-    map.set(event.id, pending)
+    const onAbort = () => {
+      pending.waiters.delete(waiter)
+      signal.removeEventListener('abort', onAbort)
+      deferred.reject(signal.reason)
+      if (!pending.waiters.size && map.get(event.id) === pending) {
+        map.delete(event.id)
+        pending.cancelSend?.()
+        clearTimeout(pending.timer)
+      }
+    }
+    const waiter = { ...deferred, stopAbort: () => signal?.removeEventListener('abort', onAbort) }
+    pending.waiters.add(waiter)
     signal?.addEventListener('abort', onAbort, { once: true })
-    pending.cancelSend = this.#dispatchWork(() => {
-      // Once transmitted, keep the existing ACK/report semantics. Before that,
-      // an operation-wide deadline must cancel the deferred publication.
-      stopAbort()
-      this.send(JSON.stringify([type, event]))
-    }, error => {
-      this.#settleEvent(map, event.id, error)
-    })
+    if (created) {
+      pending.cancelSend = this.#dispatchWork(() => {
+        this.send(JSON.stringify([type, event]))
+      }, error => this.#settleEvent(map, event.id, error))
+    }
     return deferred.promise
   }
 
@@ -225,10 +235,13 @@ export class RelayConnection {
     if (!pending) return
     map.delete(id)
     pending.cancelSend?.()
-    pending.stopAbort?.()
     clearTimeout(pending.timer)
-    if (reason) pending.reject(errorFrom(reason, 'OPERATION_REJECTED'))
-    else pending.resolve(value)
+    for (const waiter of pending.waiters) {
+      waiter.stopAbort()
+      if (reason) waiter.reject(errorFrom(reason, 'OPERATION_REJECTED'))
+      else waiter.resolve(value)
+    }
+    pending.waiters.clear()
   }
 
   #settleCount (id, payload, reason) {

package/relay/services/relay-pool.js

@@ -1204,8 +1204,10 @@ export class RelayPool {
     timeout = SEND_TIMEOUT_MS,
     timeoutUntilFirstFulfillment = null,
     getAuthEvent,
-    onRelayResult
+    onRelayResult,
+    signal
   } = {}) {
+    if (signal != null && (typeof signal.aborted !== 'boolean' || typeof signal.addEventListener !== 'function' || typeof signal.removeEventListener !== 'function')) throw new ValidationError('INVALID_RELAY_SIGNAL')
     const urls = normalizedRelayUrls(relays)
     if (!urls.length) {
       const promise = Promise.resolve(publishSummary([], urls, {
@@ -1236,7 +1238,11 @@ export class RelayPool {
     // Resolves after every relay settles (or reaches the operation timeout) as
     // { success, total, fulfilled, succeededRelays, errors },
     // where errors contains { relay, reason } entries for failed relays.
+    const cancel = () => settlement.cancel(signal.reason)
+    if (signal?.aborted) cancel()
+    else signal?.addEventListener('abort', cancel, { once: true })
     const promise = settlement.promise
+      .finally(() => signal?.removeEventListener('abort', cancel))
       .then(settlements => publishSummary(settlements, urls, {
         includeSucceededRelays: true
       }))
@@ -1245,10 +1251,11 @@ export class RelayPool {
       const deferred = sendDeferreds[index]
       ;(async () => {
         try {
+          const operationSignal = sendControllers[index].signal
+          if (operationSignal.aborted) throw operationSignal.reason
           const relay = await this.#getRelay(url)
-          const signal = sendControllers[index].signal
-          if (signal.aborted) throw signal.reason
-          return await this.#publishEvent(relay, eventToSend, getAuthEvent, signal)
+          if (operationSignal.aborted) throw operationSignal.reason
+          return await this.#publishEvent(relay, eventToSend, getAuthEvent, operationSignal)
         } catch (err) {
           const reason = err instanceof Error ? err : new Error(String(err))
           if (reason instanceof Nip42AuthenticationError) throw reason