libp2r2p 0.11.17 → 0.11.19

package/private-messenger/session/helpers/peer-preparation.js

@@ -0,0 +1,111 @@
+import { createPauseRecovery } from '../../helpers/pause-recovery.js'
+
+// One account owns the queue. Background work may occupy only three of the
+// four slots so a newly opened conversation never sits behind the whole list.
+export function createPeerPreparation ({ prepare, onReady, onError, isRetryable, online, onOnline, setTimer, clearTimer, random }) {
+  const entries = new Map()
+  let enabled = false
+  let closed = false
+  let running = 0
+  let background = 0
+  const unavailable = () => new Error('CHAT_UNAVAILABLE')
+  function entryFor (peer) {
+    const deferred = Promise.withResolvers()
+    deferred.promise.catch(() => {})
+    return { peer, ...deferred, controller: new AbortController(), state: 'queued', priority: false, value: null, error: null, recovery: null }
+  }
+  const current = entry => !closed && enabled && entries.get(entry.peer) === entry && !entry.controller.signal.aborted
+  function cancel (entry) {
+    entry.recovery?.stop()
+    entry.controller.abort(unavailable())
+    entry.reject(entry.controller.signal.reason)
+    entry.retryResult?.resolve()
+    entry.retryResult = null
+  }
+  function drain () {
+    if (!enabled || closed) return
+    while (running < 4) {
+      const queued = [...entries.values()].filter(entry => entry.state === 'queued')
+      const entry = queued.find(entry => entry.priority) || (background < 3 && queued[0])
+      if (!entry) break
+      const isBackground = !entry.priority
+      entry.state = 'running'
+      running++
+      if (isBackground) background++
+      Promise.resolve().then(() => {
+        entry.controller.signal.throwIfAborted()
+        return prepare(entry.peer, entry.controller.signal)
+      }).then(value => {
+        if (!current(entry)) return
+        entry.state = 'ready'; entry.value = value
+        entry.resolve(value)
+        onReady(entry.peer, value)
+      }, error => {
+        if (!current(entry)) return
+        entry.error = error
+        onError(error)
+        if (!isRetryable(error)) {
+          entry.state = 'failed'; entry.reject(error)
+          entry.retryResult?.reject(error); entry.retryResult = null
+          onReady(entry.peer)
+          return
+        }
+        entry.state = 'waiting'
+        entry.recovery ||= createPauseRecovery({
+          attempt: async signal => {
+            signal.throwIfAborted()
+            if (!current(entry)) return
+            entry.state = 'queued'; drain()
+            // Recovery waits for the actual preparation; no slot is held
+            // during backoff or a connectivity wait.
+            await new Promise((resolve, reject) => { entry.retryResult = { resolve, reject } })
+          },
+          retryable: isRetryable, onError: () => {}, online, onOnline, setTimer, clearTimer, random
+        })
+        if (entry.retryResult) { entry.retryResult.reject(error); entry.retryResult = null } else entry.recovery.start({ retryAt: error.retryAt })
+      }).finally(() => {
+        if (entry.state === 'ready') { entry.retryResult?.resolve(); entry.retryResult = null }
+        if (!current(entry)) { entry.retryResult?.resolve(); entry.retryResult = null }
+        running--
+        if (isBackground) background--
+        drain()
+      })
+    }
+  }
+  return {
+    get: peer => entries.get(peer)?.value,
+    error: peer => entries.get(peer)?.state === 'failed' ? entries.get(peer).error : null,
+    reconcile (peers) {
+      const wanted = new Set(peers)
+      for (const [peer, entry] of entries) if (!wanted.has(peer)) { entries.delete(peer); cancel(entry) }
+      for (const peer of wanted) if (!entries.has(peer)) entries.set(peer, entryFor(peer))
+      drain()
+    },
+    setAvailable (value) {
+      enabled = value === true
+      if (!enabled) {
+        for (const [peer, entry] of entries) {
+          if (entry.state === 'ready') continue
+          cancel(entry)
+          const replacement = entryFor(peer)
+          replacement.priority = entry.priority
+          entries.set(peer, replacement)
+        }
+      }
+      drain()
+    },
+    request (peer, { retry = false } = {}) {
+      if (closed || !entries.has(peer)) return Promise.reject(unavailable())
+      let entry = entries.get(peer)
+      if (retry && entry.state === 'failed') { cancel(entry); entries.set(peer, (entry = entryFor(peer))) }
+      entry.priority = true
+      drain()
+      return entry.promise
+    },
+    close () {
+      closed = true; enabled = false
+      for (const entry of entries.values()) cancel(entry)
+      entries.clear()
+    }
+  }
+}

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

@@ -3,8 +3,12 @@ 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) {
+  // The adapter belongs to one account/channel generation. Share both the
+  // lookup in flight and its immutable result; failed permissions are retryable
+  // only when the owning session explicitly asks again.
+  let publicKey
   const adapter = {
-    getPublicKey: () => signer.getPublicKey(),
+    getPublicKey: () => (publicKey ??= Promise.resolve().then(() => signer.getPublicKey()).catch(error => { publicKey = null; throw error })),
     getRelays: () => signer.getRelays(),
     signEvent: event => signer.signEvent(event),
     nip44v3Encrypt: (peer, kind, scope, text) => signer.nip44v3.encrypt(peer, kind, scope, base64ToBytes(text).buffer),

package/private-messenger/session/index.js

@@ -4,13 +4,16 @@ 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 { isOnline, onOnline } from '../../network/index.js'
+import { createPeerPreparation } from './helpers/peer-preparation.js'
+import { createForegroundWork } from './helpers/foreground-work.js'
+import { isRetryableRelayFailure } from '../../relay/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) {
@@ -41,8 +44,9 @@ function messengerStatusSnapshot (value) {
   return { closed: value.closed, paused: value.paused, pauseReasons: [...value.pauseReasons] }
 }
 
-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' }) }) {
+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, _isOnline = isOnline, _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')) {
@@ -52,11 +56,11 @@ export function createPrivateMessageSession ({ owner, signer, eventStore, messag
     onError(error)
   }
   const userSigner = messengerSigner(signer)
+  const foreground = createForegroundWork()
   messageStorage ||= createEventStoreMessageStorage({ eventStore })
   chunkStorage ||= eventStore ? createEventStoreChunkStorage({ eventStore }) : undefined
   const peers = new Set()
   const channels = new Map()
-  const deniedPeers = new Set()
   const entries = new Map()
   const cancelled = new Set()
   const sendControllers = new Map()
@@ -112,6 +116,10 @@ export function createPrivateMessageSession ({ owner, signer, eventStore, messag
   let lifecycle = 0
   let configuring = Promise.resolve()
   let configurationFailed = false
+  let configureQueued = false
+  let configureWork
+  let messengerWork
+  let fileSetupWork
   let sending
   let repump
   let draining
@@ -131,7 +139,7 @@ export function createPrivateMessageSession ({ owner, signer, eventStore, messag
     let candidate
     try {
       candidate = await Messenger({
-        fallbackRelays, seedStorage: recoveryStorage?.seeds, userSigner, channels: [], useContentKeys,
+        fallbackRelays, fallbackDelayMs, seedStorage: recoveryStorage?.seeds, userSigner, channels: [], useContentKeys, _waitForForeground: foreground.wait,
         onMessageQueued: () => { if (messengerBinding === binding) return drain() },
         onStateChanged: state => {
           if (closed || messengerBinding !== binding) return
@@ -153,28 +161,41 @@ export function createPrivateMessageSession ({ owner, signer, eventStore, messag
     }
   }
 
+  const preparation = createPeerPreparation({
+    prepare: async (peer, signal) => {
+      const scoped = messengerSigner(signer.withSharedKey(peer, 'dm'))
+      const pubkey = await scoped.getPublicKey()
+      signal.throwIfAborted()
+      const channel = { signer: scoped, pubkey, readerPubkey: pubkey, mode, seeders: seedersForPeer(peer) }
+      channels.set(peer, channel)
+      await schedule()
+      signal.throwIfAborted()
+      return channel
+    },
+    onReady: () => { drain(); pump() }, onError: reportError,
+    isRetryable: error => ['connection', 'transport', 'timeout'].includes(error?.category) && isRetryableRelayFailure(error),
+    online: _isOnline, onOnline: _onOnline, setTimer: _setTimeout, clearTimer: _clearTimeout, random: _random
+  })
+  async function ensureMessenger () {
+    if (!messenger && !messengerWork) {
+      const work = createMessenger()
+      messengerWork = work
+      work.finally(() => { if (messengerWork === work) messengerWork = null }).catch(() => {})
+    }
+    await messengerWork
+  }
   async function configure () {
     if (closed || !available) return
-    await ready()
     const version = lifecycle
-    const values = []
-    for (const peer of peers) {
-      if (deniedPeers.has(peer)) continue
-      let channel = channels.get(peer)
-      if (!channel) {
-        try {
-          const scoped = messengerSigner(signer.withSharedKey(peer, 'dm'))
-          channel = { signer: scoped, pubkey: await scoped.getPublicKey(), mode, seeders: seedersForPeer(peer) }
-          channels.set(peer, channel)
-        } catch (error) { if (!retryable(error)) deniedPeers.add(peer); reportError(error); continue }
-      }
-      if (closed || !available || version !== lifecycle) return
-      values.push(channel)
-    }
-    if (!messenger) await createMessenger()
+    await ready()
+    if (closed || !available || version !== lifecycle) return
+    await ensureMessenger()
     if (!messenger) return
-    if (closed || !available || version !== lifecycle) { await messenger.pause('signer'); return }
+    if (closed || !available) { await messenger.pause('signer'); return }
+    if (version !== lifecycle) { configureQueued = true; return }
+    const values = [...channels].filter(([peer]) => peers.has(peer)).map(([, channel]) => channel)
     await messenger.update({ channels: values })
+    if (closed || !available || version !== lifecycle) return
     if (pendingPriorityRanges.size && typeof messenger.prioritizeRange === 'function') {
       for (const [peer, list] of [...pendingPriorityRanges]) {
         const channel = channels.get(peer)
@@ -186,7 +207,16 @@ export function createPrivateMessageSession ({ owner, signer, eventStore, messag
       }
     }
     await messenger.resume('signer')
+    if (closed || !available || version !== lifecycle) return
+    preparation.setAvailable(true)
     if (storageBlocked) inboxRecovery.start({ immediate: true })
+    if (!fileSetupWork) {
+      fileSetupWork = setupFiles().catch(error => { fileSetupWork = null; if (!closed) reportError(error) })
+    }
+    fileSetupWork.then(() => { if (!closed && available) restoreDownloads() }).catch(reportError)
+    drain(); pump()
+  }
+  async function setupFiles () {
     if (!fileTransfers) {
       fileTransfers = FileTransfer({
         messenger, onError: reportError,
@@ -205,9 +235,17 @@ export function createPrivateMessageSession ({ owner, signer, eventStore, messag
           }
         }
       })
-      downloads = await openDownloads({ owner, signer })
-      for (const entry of await downloads.list()) downloadIntents.set(entry.id, entry)
     }
+    if (!downloads) {
+      const candidate = await openDownloads({ owner, signer })
+      try {
+        const intents = await candidate.list()
+        downloads = candidate
+        for (const entry of intents) downloadIntents.set(entry.id, entry)
+      } catch (error) { await candidate.close?.(); throw error }
+    }
+  }
+  function restoreDownloads () {
     for (const entry of downloadIntents.values()) {
       if (!peers.has(entry.file.peer) || activeDownloads.has(entry.id)) continue
       const work = download(entry.file, { manual: true })
@@ -219,12 +257,37 @@ export function createPrivateMessageSession ({ owner, signer, eventStore, messag
         .finally(() => { if (activeDownloads.get(entry.id) === work) activeDownloads.delete(entry.id) })
       activeDownloads.set(entry.id, work)
     }
-    drain(); pump()
+    pump()
   }
   function schedule () {
-    const work = configuring.catch(() => {}).then(configure)
-    configuring = work
-    work.then(() => { if (configuring === work) configurationFailed = false }, error => { if (configuring === work) configurationFailed = true; reportError(error) })
+    configureQueued = true
+    if (configureWork) return configureWork
+    const work = Promise.resolve().then(async () => {
+      try {
+        do {
+          configureQueued = false
+          await configure()
+          if (closed || !available) break
+        } while (configureQueued)
+      } finally { if (configureWork === work) configureWork = null }
+    })
+    configureWork = configuring = work
+    work.then(() => {
+      if (configureWork === work) configureWork = null
+      configurationFailed = false
+    }, error => {
+      if (configureWork === work) configureWork = null
+      configurationFailed = true
+      if (!closed) reportError(error)
+    }).catch(() => {})
+    return work
+  }
+  async function preparePeer (peer, { retry = true } = {}) {
+    if (typeof peer !== 'string' || !/^[0-9a-f]{64}$/i.test(peer)) throw new ValidationError('INVALID_PRIVATE_PEER')
+    if (closed || !available || !peers.has(peer)) throw new Error('CHAT_UNAVAILABLE')
+    const work = preparation.request(peer, { retry })
+    work.catch(() => {})
+    if (!messenger || configurationFailed) await schedule()
     return work
   }
   async function drain () {
@@ -284,7 +347,7 @@ export function createPrivateMessageSession ({ owner, signer, eventStore, messag
     }
   }
   async function publish (peer, event, signal) {
-    if (deniedPeers.has(peer)) throw new Error('PERMISSION_DENIED')
+    if (preparation.error(peer)) throw preparation.error(peer)
     if (!available || !peers.has(peer) || !channels.has(peer)) throw unavailableError(new Error('CHAT_UNAVAILABLE'), signal)
     const options = { channelPubkey: channels.get(peer)?.pubkey, receiverPubkeys: [peer], signal }
     let report
@@ -298,6 +361,7 @@ export function createPrivateMessageSession ({ owner, signer, eventStore, messag
     await assertMessagePublished(report, event)
   }
   async function sendEntry (entry) {
+    const releaseForeground = foreground.enter()
     entry.status = 'pending'; emit()
     const controller = new AbortController()
     sendControllers.set(entry.id, controller)
@@ -320,6 +384,11 @@ export function createPrivateMessageSession ({ owner, signer, eventStore, messag
           await storage.put(entry, { existing: true })
         }
       }
+      if (entry.peer !== owner && !preparation.get(entry.peer)) {
+        if (preparation.error(entry.peer)) throw preparation.error(entry.peer)
+        preparation.request(entry.peer).catch(() => {})
+        return
+      }
       if (entry.peer !== owner && messengerStatus?.paused) {
         throw unavailableError(Object.assign(new Error('PRIVATE_MESSENGER_PAUSED'), { pauseReasons: [...messengerStatus.pauseReasons] }), controller.signal)
       }
@@ -355,7 +424,9 @@ export function createPrivateMessageSession ({ owner, signer, eventStore, messag
         const event = entry.events[entry.index]
         if (entry.peer !== owner) await publish(entry.peer, event, controller.signal)
         await active()
-        await storage.put({ ...entry, index: entry.index + 1 }, { existing: true })
+        // The final durable operation is removal. Avoid encrypting a checkpoint
+        // that would immediately be deleted; earlier context stages still checkpoint.
+        if (entry.index + 1 < entry.events.length) await storage.put({ ...entry, index: entry.index + 1 }, { existing: true })
       }
       await storage.remove(entry.id)
       entries.delete(entry.id)
@@ -367,16 +438,22 @@ 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)
+        if (entry.peer !== owner && error.retryWhenAvailable && messenger?.readStatus().paused) pausedSends.add(entry.id)
+        else if (isUnavailableSend(cause) && cause.pauseReasons?.length && available && !closed) {
+          // Release can race persistence of the failed attempt. Do not lose
+          // its notification and spend a retry delay after the pause is gone.
+          entry.failed = false
+          queueMicrotask(() => pump())
+        }
         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 && !pausedSends.has(entry.id)) scheduleSendRetry()
+        if (entry.failed && 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) }
+    } finally { sendControllers.delete(entry.id); releaseForeground() }
   }
   function stopOnlineRetry () { stopOnline?.(); stopOnline = undefined }
   // Transient availability failures without an active messenger pause retain
@@ -424,7 +501,7 @@ export function createPrivateMessageSession ({ owner, signer, eventStore, messag
     })
   }
   async function pump () {
-    if (!available || closed || !messenger || !storage) return
+    if (!available || closed || !storage) return
     // A retry that lands while a pump is already running must not be skipped
     // just because that pass already walked past the entry.
     if (sending) { repump = true; return }
@@ -435,6 +512,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.localSaved.every(Boolean) && !preparation.get(entry.peer) && !preparation.error(entry.peer)) {
+            preparation.request(entry.peer).catch(() => {})
+            continue
+          }
           if (entry.peer !== owner && entry.files.length && !fileTransfers) continue
           await sendEntry(entry)
         }
@@ -449,7 +530,10 @@ export function createPrivateMessageSession ({ owner, signer, eventStore, messag
   const intentId = file => getEventHash({ kind: 0, pubkey: owner, created_at: 0, tags: [], content: `${file.peer}:${file.root}` })
   async function download (file, options = {}) {
     if (file.peer === owner) return file
-    if (!available || closed || !peers.has(file.peer) || !fileTransfers) throw new Error('CHAT_UNAVAILABLE')
+    if (!available || closed || !peers.has(file.peer)) throw new Error('CHAT_UNAVAILABLE')
+    await preparePeer(file.peer)
+    await fileSetupWork
+    if (!fileTransfers || !downloads) throw new Error('CHAT_UNAVAILABLE')
     const id = intentId(file)
     if (options.manual) {
       const epoch = downloadEpochs.get(id) || 0
@@ -474,7 +558,7 @@ export function createPrivateMessageSession ({ owner, signer, eventStore, messag
     await writeDownloadIntent(() => downloads?.remove(id))
   }
   return {
-    download, cancelDownload,
+    download, cancelDownload, preparePeer,
     // 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
@@ -502,20 +586,28 @@ export function createPrivateMessageSession ({ owner, signer, eventStore, messag
       if (type === 'unread-page' && since === undefined) throw new TypeError('PRIORITY_SINCE_REQUIRED')
       const request = { since, until, type }
       const channel = channels.get(peer)
-      if (channel && typeof messenger?.prioritizeRange === 'function') {
+      if (channel && preparation.get(peer) && !pendingPriorityRanges.has(peer) && typeof messenger?.prioritizeRange === 'function') {
         try { return await messenger.prioritizeRange(channel.pubkey, request) } catch (error) { reportError(error); return false }
       }
       const list = pendingPriorityRanges.get(peer) || []
       list.push(request)
       pendingPriorityRanges.set(peer, list)
+      if (channel && available) schedule().catch(() => {})
       return true
     },
     async setPeers (values) {
       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++
+      preparation.reconcile(peers)
+      for (const peer of channels.keys()) {
+        if (!peers.has(peer)) {
+          channels.delete(peer); pendingPriorityRanges.delete(peer)
+          for (const entry of entries.values()) {
+            if (entry.peer === peer) sendControllers.get(entry.id)?.abort()
+          }
+        }
+      }
       return schedule()
     },
     async setAvailable (value) {
@@ -526,31 +618,39 @@ export function createPrivateMessageSession ({ owner, signer, eventStore, messag
       if (available) resetSendRetry()
       else clearSendRetry()
       if (changed) lifecycle++
-      if (!available) { inboxRecovery.stop(); await messenger?.pause('signer'); return }
+      if (!available) {
+        preparation.setAvailable(false)
+        for (const peer of channels.keys()) if (!preparation.get(peer)) channels.delete(peer)
+        inboxRecovery.stop(); await messenger?.pause('signer'); return
+      }
       await ready()
       for (const entry of entries.values()) if (pendingRetryable(entry)) entry.failed = false
       if (storageBlocked) inboxRecovery.start({ immediate: true })
-      if (!changed && messenger && !configurationFailed) return pump()
+      if (!changed && messenger && !configurationFailed) { preparation.setAvailable(true); pump(); return configuring }
       return schedule()
     },
     async enqueue ({ peer, event, context = [], requiredFiles = [], deletion = false }) {
       if (closed || !available || (peer !== owner && !peers.has(peer))) throw new Error('CHAT_UNAVAILABLE')
-      await ready()
-      const main = wireEvent(event, owner)
-      const id = getEventHash(main)
-      const events = [...context.map(value => wireEvent(value, owner)), main]
-      const files = events.filter(value => value.kind === 1063).map(value => ({ ...decodeFileMetadata(value), optional: !requiredFiles.includes(getEventHash(value)) })).filter(file => file.service === 'irfs').flatMap(file => [file, ...(file.thumbnail?.root ? [{ ...file.thumbnail, optional: file.optional }] : [])])
-      const entry = { id, peer, event: { ...main, id }, events, files, index: 0, fileIndex: 0, chunkIndex: 0, localSaved: context.map(() => true).concat(false), status: 'pending', deletion }
-      await storage.put(entry)
-      entries.set(id, entry); emit(); pump()
-      return id
+      const releaseForeground = foreground.enter()
+      try {
+        await ready()
+        const main = wireEvent(event, owner)
+        const id = getEventHash(main)
+        const events = [...context.map(value => wireEvent(value, owner)), main]
+        const files = events.filter(value => value.kind === 1063).map(value => ({ ...decodeFileMetadata(value), optional: !requiredFiles.includes(getEventHash(value)) })).filter(file => file.service === 'irfs').flatMap(file => [file, ...(file.thumbnail?.root ? [{ ...file.thumbnail, optional: file.optional }] : [])])
+        const entry = { id, peer, event: { ...main, id }, events, files, index: 0, fileIndex: 0, chunkIndex: 0, localSaved: context.map(() => true).concat(false), status: 'pending', deletion }
+        await storage.put(entry)
+        entries.set(id, entry); emit(); pump()
+        if (peer !== owner) preparePeer(peer).catch(() => {})
+        return id
+      } finally { releaseForeground() }
     },
     async retry (id) {
       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() }
+      if (entry) { entry.failed = false; resetSendRetry(); if (entry.peer !== owner) preparePeer(entry.peer).catch(() => {}); return pump() }
     },
     async cancel (id) {
       cancelled.add(id)
@@ -565,9 +665,9 @@ export function createPrivateMessageSession ({ owner, signer, eventStore, messag
       return (closeWork ??= (async () => {
         closed = true; available = false; lifecycle++
         stopOnlineRetry(); offlineSends.clear(); activeDownloads.clear(); pendingPriorityRanges.clear()
-        clearSendRetry(); inboxRecovery.stop(); pausedSends.clear()
+        clearSendRetry(); inboxRecovery.stop(); preparation.close(); foreground.close(); pausedSends.clear()
         for (const controller of sendControllers.values()) controller.abort()
-        await Promise.allSettled([configuring, initialized])
+        await Promise.allSettled([configuring, initialized, messengerWork, fileSetupWork])
         await messenger?.pause('closed')
         if (sending || draining) await new Promise(resolve => idleWaiters.add(resolve))
         await messenger?.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