libp2r2p 0.11.11 → 0.11.13

package/README.md

@@ -541,6 +541,22 @@ and the uncovered subranges plus the pre-oldest left edge are requested from
 seeders. Offline attempts never consume the budget, mark coverage or contact
 seeders; they wait for connectivity. The per-relay tracker is process-local, so a
 restart falls back to the persisted whole interval.
+
+`prioritizeRange(channelPubkey, { since, until, type })` registers an
+application-directed priority window for the next recovery pass. `unread-page`
+requires `since` (a read anchor); `tail` derives a bounded window from the
+newest persisted range using `priorityTailSeconds` (six hours by default).
+Priority subranges are fetched before older history; relays are ordered by
+recent EOSE, consecutive failures and latency; and the first priority page may
+hedge up to `priorityHedgeRelays` (two) relays with `priorityHedgeDelayMs`
+(500 ms), aborting the loser. When relays do not cover the window, seeders with
+recent presence (`announcedAt`/`lastActiveAt` within `seederOnlineSeconds`) are
+asked only for that subrange; a successful ask counts as coverage. Priority
+probes never consume the relay tier budget, and priorities/statistics are
+process-local: they expire after `priorityTtlMs` (ten minutes) or once covered,
+and clear with channel/recovery state. Presence payloads and persisted ranges
+are unchanged.
+
 `private-channel.fetchHistory(options)` (0.11.6) is the complete-interval API
 used by messenger recovery. It accepts the signers, processor/fragment options,
 callbacks and abort signal of `fetch`, plus inclusive `since`/`until` bounds
@@ -975,7 +991,10 @@ messages, history and files while preserving automatic NIP-65 updates. Successfu
 latency, and short-lived channel/recipient preferences avoid recently refused
 relays without changing receive subscriptions. See the
 [session coordinator](private-messenger/session/README.md) for deferred offline
-attempts and final failure notifications.
+attempts and final failure notifications. Sends attempted while the messenger is
+paused or otherwise unavailable now stay pending in the outbox and retry on a
+bounded session backoff (1–30 seconds, 20% jitter) instead of surfacing a
+user-facing send error.
 
 
 ### Relay backpressure and bounded synchronization (0.11.7)
@@ -1014,10 +1033,12 @@ readiness on the replacement. Callbacks and completions are generation-fenced.
 Equal watch settings cannot keep a dead subscription registered as active.
 
 Overflow recovery keeps one timer per relay with exponential 1–30 second
-backoff and 20% jitter, reset after a stable minute. Other relays remain live.
-Removal, pause and close cancel pending work. Fragment storage stays scoped to
-the same session across replacement subscriptions. Permanent refusals remain
-reported and do not trigger this automatic retry loop.
+backoff and 20% jitter, reset after a stable minute. Relay-pool capacity closes
+(1013, "relay pool capacity") use the same relay backoff instead of stopping
+until an explicit rebuild, because the launcher pool bucket budget is transient.
+Other relays remain live. Removal, pause and close cancel pending work. Fragment
+storage stays scoped to the same session across replacement subscriptions.
+Permanent refusals remain reported and do not trigger this automatic retry loop.
 
 PrivateMessenger persists each interrupted interval before reopening, then
 uses paged `fetchHistory` to repair the gap while listening for new messages.

package/helpers/ranges.js

@@ -29,3 +29,19 @@ export function subtractRanges (range, covered = []) {
   if (cursor <= range.end) out.push({ start: cursor, end: range.end })
   return out
 }
+
+export function intersectRanges (left = [], right = []) {
+  const a = mergeRanges(left)
+  const b = mergeRanges(right)
+  const out = []
+  let i = 0
+  let j = 0
+  while (i < a.length && j < b.length) {
+    const start = Math.max(a[i].start, b[j].start)
+    const end = Math.min(a[i].end, b[j].end)
+    if (start <= end) out.push({ start, end })
+    if (a[i].end < b[j].end) i++
+    else j++
+  }
+  return out
+}

package/package.json

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

package/private-channel/helpers/history.js

@@ -46,6 +46,7 @@ export async function readHistory ({ filter, relays, receiverPubkey, signal, get
   }
   for (const relay of urls) {
     const relayStartCount = receivedEventCount
+    let relayElapsedMs = 0
     const intervals = resumeIntervalsFor({ resume, relay, since, until })
       .map(interval => ({ since: interval.start, until: interval.end, limit: PAGE_SIZE }))
     const covered = []
@@ -83,7 +84,11 @@ export async function readHistory ({ filter, relays, receiverPubkey, signal, get
           outcome = { relay, status: 'error', error }
           intervals.push(interval)
           break
-        } finally { elapsedMs += performance.now() - started }
+        } finally {
+          const took = performance.now() - started
+          elapsedMs += took
+          relayElapsedMs += took
+        }
         signal?.throwIfAborted()
         const status = page.relays?.find(item => item.relay === relay)
         if (page.errors?.length || !status || !['eose', 'satisfied'].includes(status.status)) {
@@ -123,7 +128,8 @@ export async function readHistory ({ filter, relays, receiverPubkey, signal, get
         ? {
             covered: mergeRanges(covered),
             pending: mergeRanges(intervals.map(interval => ({ start: interval.since, end: interval.until }))),
-            events: receivedEventCount - relayStartCount
+            events: receivedEventCount - relayStartCount,
+            elapsedMs: Math.round(relayElapsedMs)
           }
         : {})
     })

package/private-message/index.js

@@ -21,6 +21,18 @@ function uniq (values) {
   return [...new Set((values || []).filter(Boolean))]
 }
 
+// The launcher's shared relay pool closes anonymous members with 1013 when its
+// per-relay buckets are all busy. That is a transient pool condition, not a
+// permanent relay rejection, so the shared subscription must keep the normal
+// relay backoff instead of stopping until something else re-opens it.
+function isRelayPoolCapacity (error) {
+  for (let current = error, depth = 0; current && depth < 3; current = current.cause, depth++) {
+    if (current.closeCode === 1013 || current.code === 'RELAY_POOL_CAPACITY') return true
+    if (/relay pool capacity/i.test(current.message || '')) return true
+  }
+  return false
+}
+
 function normalizeDeletionPubkey (deletionPubkey) {
   if (deletionPubkey === undefined) return undefined
   if (typeof deletionPubkey !== 'string' || !HEX_PUBKEY.test(deletionPubkey)) {
@@ -360,8 +372,9 @@ export function createPrivateMessageSession ({ _setTimeout = setTimeout, _clearT
       delay: entry.readyAt !== undefined && _now() - entry.readyAt >= 60000 ? 1000 : (previous?.delay || entry.retryDelay || 1000),
       notified: new Map(), timer: null
     }
-    if (/^(auth-required:|restricted:|blocked:|invalid:|pow:)/.test(error.message || '') || error.name === 'ValidationError' ||
-        (error.code !== 'RELAY_LIVE_BUFFER_FULL' && !previous)) {
+    const permanent = /^(auth-required:|restricted:|blocked:|invalid:|pow:)/.test(error.message || '') || error.name === 'ValidationError'
+    const retryable = error.code === 'RELAY_LIVE_BUFFER_FULL' || isRelayPoolCapacity(error) || Boolean(previous)
+    if (permanent || !retryable) {
       cancelRelayRecovery(relay)
       notifyInterruption(relay, recovery).catch(error => reportSubscriptionError(entry.channels, error))
       return

package/private-messenger/helpers/send-routing.js

@@ -102,6 +102,11 @@ export function createSendRelayRouting ({ peer, peers = [peer], relaysByPubkey,
         errors: reports.flatMap(report => report.errors || [])
       }))
     })
+    // A lifecycle change (signer/pause) during a batch is not a user abort:
+    // every failure summary stays retryable so the session can re-attempt it.
+    const finished = result => current()
+      ? finish(result)
+      : { ...finish(result), retryWhenAvailable: !signal?.aborted, retryWhenOnline: !signal?.aborted }
     let result = { success: false }
     while ((batch ||= next())) {
       signal?.throwIfAborted()
@@ -124,15 +129,15 @@ export function createSendRelayRouting ({ peer, peers = [peer], relaysByPubkey,
         const report = await settled
         const failed = rejected(report)
         errors.push(...(report?.errors || []))
-        if (!failed.length || errors.some(item => !isReplaceableRelayFailure(item.reason))) return finish(result)
-        if (!next()) { exclusions.clear(); return finish(result) }
-        if (!await online()) return { ...finish(result), retryWhenAvailable: !signal?.aborted, retryWhenOnline: current() }
+        if (!failed.length || errors.some(item => !isReplaceableRelayFailure(item.reason))) return finished(result)
+        if (!next()) { exclusions.clear(); return finished(result) }
+        if (!await online()) return { ...finish(result), retryWhenAvailable: !signal?.aborted, retryWhenOnline: !signal?.aborted }
         remember(failed)
       }
-      if (!current()) return { ...finish(result), retryWhenAvailable: !signal?.aborted, retryWhenOnline: false }
+      if (!current()) return finished(result)
       batch = null
     }
-    return finish(result)
+    return finished(result)
   }
 
   return {

package/private-messenger/index.js

@@ -43,7 +43,7 @@
 // - For other event-list replies, use createEventReplyPacker({ messenger, question, code }).update(event).
 
 import { createAbortableSemaphore } from '../helpers/abortable-semaphore.js'
-import { mergeRanges, subtractRanges } from '../helpers/ranges.js'
+import { mergeRanges, subtractRanges, intersectRanges } from '../helpers/ranges.js'
 import * as privateMessage from '../private-message/index.js'
 import { isOnline } from '../network/index.js'
 import { createSendRelayRouting, normalizeFallbackRelays } from './helpers/send-routing.js'
@@ -130,6 +130,10 @@ export const RECOVERY_RELAY_RETRY_LIMITS = Object.freeze({
   allFailed: 10
 })
 const RECOVERY_ONLINE_CACHE_MS = 5000
+const DEFAULT_PRIORITY_TAIL_SECONDS = 6 * 3600
+const DEFAULT_PRIORITY_TTL_MS = 10 * 60 * 1000
+const DEFAULT_PRIORITY_HEDGE_DELAY_MS = 500
+const DEFAULT_PRIORITY_HEDGE_RELAYS = 2
 
 function textToBase64 (text) {
   return bytesToBase64(encoder.encode(text))
@@ -213,6 +217,10 @@ export class PrivateMessenger {
     reloadGapDelayMs = DEFAULT_RELOAD_GAP_DELAY_MS,
     seederPresenceIntervalMs = DEFAULT_SEEDER_PRESENCE_INTERVAL_MS,
     seederOnlineSeconds = DEFAULT_SEEDER_ONLINE_SECONDS,
+    priorityTailSeconds = DEFAULT_PRIORITY_TAIL_SECONDS,
+    priorityTtlMs = DEFAULT_PRIORITY_TTL_MS,
+    priorityHedgeDelayMs = DEFAULT_PRIORITY_HEDGE_DELAY_MS,
+    priorityHedgeRelays = DEFAULT_PRIORITY_HEDGE_RELAYS,
     maxDynamicRecoverySeeders = DEFAULT_MAX_DYNAMIC_RECOVERY_SEEDERS,
     messageQueueMaxBytes = DEFAULT_MESSAGE_QUEUE_MAX_BYTES,
     seedQueueMaxBytes = DEFAULT_SEED_QUEUE_MAX_BYTES,
@@ -247,6 +255,19 @@ export class PrivateMessenger {
     this.reloadGapDelayMs = reloadGapDelayMs
     this.seederPresenceIntervalMs = seederPresenceIntervalMs
     this.seederOnlineSeconds = seederOnlineSeconds
+    this.priorityTailSeconds = Number.isFinite(priorityTailSeconds) && priorityTailSeconds >= 0
+      ? Math.floor(priorityTailSeconds)
+      : DEFAULT_PRIORITY_TAIL_SECONDS
+    this.priorityTtlMs = Number.isFinite(priorityTtlMs) && priorityTtlMs > 0
+      ? Math.floor(priorityTtlMs)
+      : DEFAULT_PRIORITY_TTL_MS
+    this.priorityHedgeDelayMs = Number.isFinite(priorityHedgeDelayMs) && priorityHedgeDelayMs >= 0
+      ? Math.floor(priorityHedgeDelayMs)
+      : DEFAULT_PRIORITY_HEDGE_DELAY_MS
+    const hedgeRelays = Math.floor(Number(priorityHedgeRelays))
+    this.priorityHedgeRelays = Number.isSafeInteger(hedgeRelays) && hedgeRelays >= 1
+      ? Math.min(hedgeRelays, 3)
+      : DEFAULT_PRIORITY_HEDGE_RELAYS
     this.maxDynamicRecoverySeeders = maxDynamicRecoverySeeders
     this.messageQueueMaxBytes = messageQueueMaxBytes
     this.seedQueueMaxBytes = seedQueueMaxBytes
@@ -299,6 +320,7 @@ export class PrivateMessenger {
     this.recoveryAdmission = createAbortableSemaphore(2)
     this.recoveryControllers = new Set()
     this.recoveryRanges = new Map()
+    this.recoveryPriority = new Map()
     this.recoveryOnline = { at: 0, value: true }
     this.resumeWork = null
     this.capacityTimer = null
@@ -675,7 +697,7 @@ export class PrivateMessenger {
 
     if (removedPubkeys.length) {
       await this.stampChannelActivity(removedPubkeys)
-      for (const pubkey of removedPubkeys) this.dropRecoveryRanges(pubkey)
+      for (const pubkey of removedPubkeys) this.dropRecoveryState(pubkey)
     }
 
     const storageSnapshot = await activatePrivateMessengerStorage({
@@ -1214,6 +1236,7 @@ export class PrivateMessenger {
         start: range.start,
         end: range.end,
         covered: [],
+        claimed: [],
         oldestCreatedAt: null,
         relays: new Map(),
         tier: '',
@@ -1241,20 +1264,34 @@ export class PrivateMessenger {
         dead: false,
         eose: false,
         events: 0,
-        error: null
+        error: null,
+        consecutiveFailures: 0,
+        latencyMs: null,
+        lastEoseAt: 0,
+        lastErrorAt: 0
       })
     }
   }
 
+  orderedRecoveryRelays (record) {
+    return [...record.relays.entries()]
+      .filter(([, state]) => !state.dead && !state.eose && state.pending?.length)
+      .sort((a, b) => {
+        const failures = (a[1].consecutiveFailures || 0) - (b[1].consecutiveFailures || 0)
+        if (failures) return failures
+        const latency = (a[1].latencyMs ?? Infinity) - (b[1].latencyMs ?? Infinity)
+        if (latency) return latency
+        return (b[1].lastEoseAt || 0) - (a[1].lastEoseAt || 0)
+      })
+  }
+
   recoveryRelayPlan (record) {
     const plan = {}
-    let hasWork = false
-    for (const [relay, state] of record.relays) {
-      if (state.dead || state.eose || !state.pending?.length) continue
+    const ordered = this.orderedRecoveryRelays(record)
+    for (const [relay, state] of ordered) {
       plan[relay] = state.pending
-      hasWork = true
     }
-    return hasWork ? plan : null
+    return ordered.length ? plan : null
   }
 
   hasActiveRecoveryRelays (channelPubkey) {
@@ -1289,7 +1326,65 @@ export class PrivateMessenger {
     }
   }
 
-  updateRecoveryRecord (record, history) {
+  dropRecoveryState (channelPubkey) {
+    this.dropRecoveryRanges(channelPubkey)
+    this.recoveryPriority.delete(channelPubkey)
+  }
+
+  recoveryPriorities (channelPubkey) {
+    const entries = this.recoveryPriority.get(channelPubkey) || []
+    if (!entries.length) return []
+    const now = Date.now()
+    const active = entries.filter(entry => entry.expiresAt > now)
+    if (active.length !== entries.length) {
+      if (active.length) this.recoveryPriority.set(channelPubkey, active)
+      else this.recoveryPriority.delete(channelPubkey)
+    }
+    return active
+  }
+
+  async prioritizeRange (channelPubkey, { since, until, type = 'unread-page', ttlMs } = {}) {
+    if (typeof channelPubkey !== 'string' || !/^[0-9a-f]{64}$/i.test(channelPubkey)) throw new ValidationError('INVALID_CHANNEL_PUBKEY')
+    if (type !== 'unread-page' && type !== 'tail') throw new ValidationError('INVALID_PRIORITY_TYPE')
+    if (since !== undefined && !Number.isSafeInteger(since)) throw new ValidationError('INVALID_PRIORITY_RANGE')
+    if (until !== undefined && !Number.isSafeInteger(until)) throw new ValidationError('INVALID_PRIORITY_RANGE')
+    if (type === 'unread-page' && since === undefined) throw new ValidationError('PRIORITY_SINCE_REQUIRED')
+
+    const now = nowSeconds()
+    const ranges = (this.readState().channels[channelPubkey]?.offlineRanges || []).slice()
+    if (!ranges.length) return false
+
+    let start = since
+    let end = until
+    if (type === 'unread-page') {
+      const range = ranges.filter(candidate => candidate.end >= start).sort((a, b) => a.start - b.start)[0]
+      if (!range) return false
+      start = Math.max(start, range.start)
+      if (end === undefined) end = Math.min(range.end, now)
+    } else {
+      const range = ranges.sort((a, b) => b.end - a.end)[0]
+      if (end === undefined) end = Math.min(range.end, now)
+      if (start === undefined) start = Math.max(range.start, end - this.priorityTailSeconds)
+    }
+
+    const recoverySeconds = this.offlineRecoverySecondsFor(channelPubkey)
+    if (recoverySeconds) {
+      start = Math.max(start, now - recoverySeconds)
+      end = Math.min(end, now)
+    }
+    if (!Number.isSafeInteger(start) || !Number.isSafeInteger(end) || end < start) return false
+
+    const ttl = Number.isSafeInteger(ttlMs) && ttlMs > 0 ? ttlMs : this.priorityTtlMs
+    const entries = this.recoveryPriority.get(channelPubkey) || []
+    const createdAt = Date.now()
+    if (!entries.some(entry => entry.start === start && entry.end === end && entry.type === type)) {
+      entries.push({ start, end, type, createdAt, expiresAt: createdAt + ttl })
+      this.recoveryPriority.set(channelPubkey, entries)
+    }
+    return true
+  }
+
+  updateRecoveryRecord (record, history, { completeRelays = new Set((history.relays || []).map(entry => entry.relay)) } = {}) {
     record.covered = mergeRanges([
       ...record.covered,
       ...(history.relays || []).flatMap(entry => entry.covered || [])
@@ -1306,13 +1401,30 @@ export class PrivateMessenger {
       const relayErrors = [...(entry.errors || [])]
       if (entry.error) relayErrors.push(entry.error)
       state.error = relayErrors[0] || null
-      const done = entry.status === 'eose' && !(entry.pending?.length)
+      const done = entry.status === 'eose' && !(entry.pending?.length) && completeRelays.has(relay)
       state.covered = mergeRanges([...(state.covered || []), ...(entry.covered || [])])
       state.eose = done
-      state.pending = done ? [] : subtractRanges({ start: record.start, end: record.end }, state.covered)
+      state.pending = done
+        ? []
+        : subtractRanges({ start: record.start, end: record.end }, mergeRanges([...state.covered, ...record.claimed]))
       state.events += entry.events || 0
+      if (Number.isFinite(entry.elapsedMs)) {
+        state.latencyMs = state.latencyMs == null
+          ? entry.elapsedMs
+          : Math.round(state.latencyMs * 0.7 + entry.elapsedMs * 0.3)
+      }
       if (done) {
         state.attempts = 0
+        state.consecutiveFailures = 0
+        state.lastEoseAt = nowSeconds()
+      } else if (entry.status === 'eose') {
+        state.consecutiveFailures = 0
+        state.lastEoseAt = nowSeconds()
+      } else {
+        state.consecutiveFailures = (state.consecutiveFailures || 0) + 1
+        state.lastErrorAt = nowSeconds()
+      }
+      if (entry.status === 'eose') {
         record.everEose = true
         if (state.events > 0) record.everEoseWithEvents = true
       }
@@ -1321,6 +1433,52 @@ export class PrivateMessenger {
     record.lastErrors = (history.relays || []).flatMap(entry => [...(entry.errors || []), ...(entry.error ? [entry.error] : [])])
   }
 
+  applyRecoveryCoverage (record, ranges) {
+    if (!ranges?.length) return
+    record.claimed = mergeRanges([...record.claimed, ...ranges])
+    record.covered = mergeRanges([...record.covered, ...ranges])
+    for (const state of record.relays.values()) {
+      if (state.eose) continue
+      state.pending = subtractRanges({ start: record.start, end: record.end }, mergeRanges([...state.covered, ...record.claimed]))
+    }
+  }
+
+  activeRecoverySeeders (channelPubkey) {
+    if (!this.offlineRecoverySecondsFor(channelPubkey)) return []
+    const channel = this.channels.get(channelPubkey)
+    if (!channel?.signer) return []
+    const activity = this.readState().channels[channelPubkey]?.seederActivity || {}
+    const cutoff = nowSeconds() - this.seederOnlineSeconds
+    const candidates = new Set([...(channel.seeders || []), ...Object.keys(activity)])
+    return [...candidates].filter(seeder => {
+      if (!seeder || seeder === this.userPubkey) return false
+      const entry = activity[seeder]
+      const recent = Math.max(entry?.announcedAt || 0, entry?.lastActiveAt || 0)
+      return recent >= cutoff
+    })
+  }
+
+  prunePriorityEntries (channelPubkey) {
+    const entries = this.recoveryPriorities(channelPubkey)
+    if (!entries.length) return
+    const records = [...this.recoveryRanges.values()].filter(record => record.channelPubkey === channelPubkey)
+    const next = entries.filter(entry => {
+      let intersects = false
+      for (const record of records) {
+        const parts = intersectRanges(
+          [{ start: entry.start, end: entry.end }],
+          [{ start: record.start, end: record.end }]
+        )
+        if (!parts.length) continue
+        intersects = true
+        if (subtractRanges(parts[0], record.covered).length) return true
+      }
+      return !intersects
+    })
+    if (next.length) this.recoveryPriority.set(channelPubkey, next)
+    else this.recoveryPriority.delete(channelPubkey)
+  }
+
   applyRecoveryRetryBudget (record) {
     const limit = RECOVERY_RELAY_RETRY_LIMITS[record.tier] ?? RECOVERY_RELAY_RETRY_LIMITS.allFailed
     for (const state of record.relays.values()) {
@@ -1462,7 +1620,7 @@ export class PrivateMessenger {
     const pubkeys = channels ? uniq(Array.isArray(channels) ? channels : [channels]) : [...this.desiredChannels]
     for (const extension of this.extensions) extension.unwatch?.(pubkeys)
     for (const pubkey of pubkeys) this.desiredChannels.delete(pubkey)
-    for (const pubkey of pubkeys) this.dropRecoveryRanges(pubkey)
+    for (const pubkey of pubkeys) this.dropRecoveryState(pubkey)
     this.recordInterruption(pubkeys)
     for (const controller of this.recoveryControllers) {
       if (pubkeys.includes(controller.channelPubkey)) controller.abort()
@@ -2156,7 +2314,7 @@ export class PrivateMessenger {
       this.writeState(state)
       await this.flushStateWrites()
       for (const channel of channels) {
-        if (!this.offlineRecoverySecondsFor(channel)) this.dropRecoveryRanges(channel.pubkey)
+        if (!this.offlineRecoverySecondsFor(channel)) this.dropRecoveryState(channel.pubkey)
       }
       for (const channel of channels) await this.pruneStoredSeeds(channel.pubkey)
     })
@@ -2231,15 +2389,15 @@ export class PrivateMessenger {
     return asks
   }
 
-  async #askSeedersForMissingRangeAttempt (channelPubkey, since, until) {
+  async #askSeedersForMissingRangeAttempt (channelPubkey, since, until, { seeders } = {}) {
     if (!this.offlineRecoverySecondsFor(channelPubkey)) return { asks: [], failures: [] }
     if (!this.channels.get(channelPubkey)?.signer) return { asks: [], failures: [] }
-    const seeders = this.recoverySeeders(channelPubkey)
-    if (!seeders.length || until < since) return { asks: [], failures: [] }
+    const candidates = seeders ?? this.recoverySeeders(channelPubkey)
+    if (!candidates.length || until < since) return { asks: [], failures: [] }
 
     const asks = []
     const failures = []
-    for (const seeder of seeders) {
+    for (const seeder of candidates) {
       try {
         const ask = await this.ask({
           channelPubkey,
@@ -2385,6 +2543,146 @@ export class PrivateMessenger {
     return failures
   }
 
+  recoveryFetchOptions ({ channelPubkey, channel, relays, since, until, signal, partial = false, resume = null }) {
+    return {
+      _acquirePage: pageSignal => this.recoveryAdmission.acquire(pageSignal),
+      signal,
+      receivedChunkScope: this.storageLeaseId,
+      receiverSigner: this.userSigner,
+      iykcSigner: this.contentKeySigner,
+      privateChannelSigner: channel.signer,
+      privateChannelReaderSigner: channel.readerSigner,
+      privateChannelReaderPubkey: channel.readerPubkey,
+      privateChannelPubkeys: [channelPubkey],
+      receiverPubkey: this.userPubkey,
+      relays,
+      since: Math.max(0, since),
+      until,
+      partial,
+      resume,
+      mode: channel.mode,
+      modeByPubkey: { [channelPubkey]: channel.mode },
+      receivedChunkTtlMs: this.receivedChunkTtlMsFor(channel),
+      receivedChunkIndexedDB: this._indexedDB,
+      onEvent: (event, outer, meta) => this.receive(channelPubkey, () => this.enqueueRumor(eventType(event), channelPubkey, { event, outer, meta, payload: parseEventContent(event) }), { event, outer }),
+      onNymEvent: (event, outer, meta) => this.receive(channelPubkey, () => this.enqueueRumor('nym', channelPubkey, { event, outer, meta, payload: parseEventContent(event) }), { event, outer }),
+      onSeedEvent: seed => this.receive(channelPubkey, () => this.enqueueSeed(channelPubkey, seed), seed),
+      onContentKeyUsage: usage => this.handleContentKeyUsage(channelPubkey, usage),
+      onError: err => { throw err }
+    }
+  }
+
+  async hedgedPriorityFetch ({ channelPubkey, channel, candidates, since, until }) {
+    const launched = []
+    let hedgeTimer = null
+    let secondStarted = false
+    const launch = candidate => {
+      const controller = new AbortController()
+      const promise = this._privateChannel
+        .fetchHistory(this.recoveryFetchOptions({
+          channelPubkey,
+          channel,
+          relays: [candidate.relay],
+          since,
+          until,
+          signal: controller.signal,
+          partial: true,
+          resume: { [candidate.relay]: candidate.pending }
+        }))
+        .then(
+          history => ({ ok: true, relay: candidate.relay, controller, history }),
+          error => ({ ok: false, relay: candidate.relay, controller, error })
+        )
+      promise.catch(() => {})
+      launched.push({ promise, controller })
+      return promise
+    }
+    try {
+      const first = launch(candidates[0])
+      const hedge = candidates.length > 1
+        ? new Promise(resolve => {
+          hedgeTimer = this._setTimeout(() => {
+            secondStarted = true
+            resolve(launch(candidates[1]))
+          }, this.priorityHedgeDelayMs)
+        })
+        : null
+      let settled = hedge ? await Promise.race([first, hedge]) : await first
+      if (!settled.ok) {
+        if (secondStarted && launched.length > 1) settled = await launched[launched.length - 1].promise
+        else if (candidates.length > 1) settled = await launch(candidates[1])
+      }
+      if (!settled.ok) return null
+      for (const entry of launched) {
+        if (entry.controller === settled.controller) continue
+        try { entry.controller.abort() } catch { /* aborted */ }
+      }
+      return settled
+    } finally {
+      if (hedgeTimer) this._clearTimeout(hedgeTimer)
+    }
+  }
+
+  async askPrioritySeeders (channelPubkey, intervals) {
+    if (!intervals.length) return []
+    if (!await this.checkRecoveryOnline()) return []
+    const seeders = this.activeRecoverySeeders(channelPubkey)
+    if (!seeders.length) return []
+    const failures = []
+    const claimed = []
+    for (const interval of mergeRanges(intervals)) {
+      const attempt = await this.#askSeedersForMissingRangeAttempt(channelPubkey, interval.start, interval.end, { seeders })
+      failures.push(...attempt.failures.map(failure => failure.error))
+      if (!attempt.failures.length) claimed.push(interval)
+    }
+    if (claimed.length) {
+      for (const record of this.recoveryRanges.values()) {
+        if (record.channelPubkey !== channelPubkey) continue
+        const applied = intersectRanges(claimed, [{ start: record.start, end: record.end }])
+        if (applied.length) this.applyRecoveryCoverage(record, applied)
+      }
+    }
+    return failures
+  }
+
+  async runPriorityLane (channelPubkey, channel, ranges) {
+    const priorities = this.recoveryPriorities(channelPubkey)
+    if (!priorities.length) return
+    const fetchRelays = await this.resolveWatchRelays(channel)
+    for (const range of ranges) {
+      const record = this.recoveryRangeRecord(channelPubkey, range)
+      this.reconcileRecoveryRelays(record, fetchRelays)
+      const priorityIntervals = intersectRanges(
+        priorities.map(entry => ({ start: entry.start, end: entry.end })),
+        [{ start: range.start, end: range.end }]
+      )
+      if (!priorityIntervals.length) continue
+      const pending = subtractRanges({ start: range.start, end: range.end }, record.covered)
+      const wanted = intersectRanges(priorityIntervals, pending)
+      if (!wanted.length) continue
+      const candidates = this.orderedRecoveryRelays(record)
+        .map(([relay, state]) => ({ relay, pending: intersectRanges(state.pending, wanted) }))
+        .filter(candidate => candidate.pending.length)
+        .slice(0, this.priorityHedgeRelays)
+      if (candidates.length) {
+        const winner = await this.hedgedPriorityFetch({
+          channelPubkey,
+          channel,
+          candidates,
+          since: wanted[0].start,
+          until: wanted[wanted.length - 1].end
+        })
+        if (winner?.history) {
+          if (this.isPartialRecoveryHistory(winner.history)) this.updateRecoveryRecord(record, winner.history, { completeRelays: new Set() })
+          else this.applyRecoveryCoverage(record, wanted)
+        }
+      }
+      const uncovered = intersectRanges(wanted, subtractRanges({ start: range.start, end: range.end }, record.covered))
+      if (uncovered.length) await this.askPrioritySeeders(channelPubkey, uncovered)
+    }
+    this.prunePriorityEntries(channelPubkey)
+  }
+
   async recoverChannelRanges (channels) {
     const failures = []
     const state = this.readState()
@@ -2395,17 +2693,21 @@ export class PrivateMessenger {
       const channel = this.channels.get(pubkey)
       const current = state.channels[pubkey]
       if (!channel || !current?.offlineRanges?.length) {
-        this.dropRecoveryRanges(pubkey)
+        this.dropRecoveryState(pubkey)
         continue
       }
       const recoverySeconds = this.offlineRecoverySecondsFor(channel)
       if (!recoverySeconds) {
-        this.dropRecoveryRanges(pubkey)
+        this.dropRecoveryState(pubkey)
         continue
       }
       const minStart = now - recoverySeconds
       const processedRanges = new Set(current.offlineRanges.map(range => `${range.start}:${range.end}`))
 
+      if (online) {
+        try { await this.runPriorityLane(pubkey, channel, current.offlineRanges) } catch (error) { this.onError?.(error) }
+      }
+
       const remaining = []
       let recoveredThrough = current.recoveredThrough || 0
       for (const range of current.offlineRanges) {
@@ -2423,32 +2725,16 @@ export class PrivateMessenger {
           this.reconcileRecoveryRelays(record, fetchRelays)
           const plan = this.recoveryRelayPlan(record)
           if (plan) {
-            const history = await this._privateChannel.fetchHistory({
-              _acquirePage: signal => this.recoveryAdmission.acquire(signal),
-              signal: controller.signal,
-              receivedChunkScope: this.storageLeaseId,
-              receiverSigner: this.userSigner,
-              iykcSigner: this.contentKeySigner,
-              privateChannelSigner: channel.signer,
-              privateChannelReaderSigner: channel.readerSigner,
-              privateChannelReaderPubkey: channel.readerPubkey,
-              privateChannelPubkeys: [pubkey],
-              receiverPubkey: this.userPubkey,
+            const history = await this._privateChannel.fetchHistory(this.recoveryFetchOptions({
+              channelPubkey: pubkey,
+              channel,
               relays: Object.keys(plan),
-              since: Math.max(0, range.start),
+              since: range.start,
               until: range.end,
+              signal: controller.signal,
               partial: true,
-              resume: plan,
-              mode: channel.mode,
-              modeByPubkey: { [pubkey]: channel.mode },
-              receivedChunkTtlMs: this.receivedChunkTtlMsFor(channel),
-              receivedChunkIndexedDB: this._indexedDB,
-              onEvent: (event, outer, meta) => this.receive(pubkey, () => this.enqueueRumor(eventType(event), pubkey, { event, outer, meta, payload: parseEventContent(event) }), { event, outer }),
-              onNymEvent: (event, outer, meta) => this.receive(pubkey, () => this.enqueueRumor('nym', pubkey, { event, outer, meta, payload: parseEventContent(event) }), { event, outer }),
-              onSeedEvent: seed => this.receive(pubkey, () => this.enqueueSeed(pubkey, seed), seed),
-              onContentKeyUsage: usage => this.handleContentKeyUsage(pubkey, usage),
-              onError: err => { throw err }
-            })
+              resume: plan
+            }))
             controller.signal.throwIfAborted()
             if (this.isPartialRecoveryHistory(history)) {
               this.updateRecoveryRecord(record, history)
@@ -2517,7 +2803,7 @@ export class PrivateMessenger {
   async clearChannel (pubkey) {
     await this.unwatch(pubkey)
     await this._privateMessage.clearChannelState?.(pubkey)
-    this.dropRecoveryRanges(pubkey)
+    this.dropRecoveryState(pubkey)
     return this.runQueueOperation(async () => {
       this.channels.delete(pubkey)
       this.removeChannelState(pubkey)
@@ -2551,7 +2837,7 @@ export class PrivateMessenger {
         await this.queue?.removeBy('byChannel', pubkey)
         await (this.seedStorage ? this.seedStorage.removeLocal({ channelPubkey: pubkey }) : this.seedQueue?.removeBy('byChannel', pubkey))
       }
-      for (const pubkey of stalePubkeys) this.dropRecoveryRanges(pubkey)
+      for (const pubkey of stalePubkeys) this.dropRecoveryState(pubkey)
       this.state = state
       if (stalePubkeys.length) await this.removeChannelStates(stalePubkeys)
     })
@@ -2643,6 +2929,7 @@ export class PrivateMessenger {
         })
       }
       this.recoveryRanges.clear()
+      this.recoveryPriority.clear()
       if (unwatchError) throw unwatchError
     })()
     return this.closePromise

package/private-messenger/session/README.md

@@ -17,9 +17,17 @@ key published after an earlier miss. Set it to `false` when the signer owns that
 `createMessengerSigner` adapts this byte signer to the transport's Base64 API.
 
 Methods: `setPeers`, `setAvailable(boolean)`, `prefetchContentKeys(peers?)`,
-`enqueue`, `retry`, `cancel`, `download`, `cancelDownload`, and `close`.
+`prioritizeRange(peer, options)`, `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.
+`prioritizeRange` registers an in-memory priority window for a conversation:
+`type: 'unread-page'` requires `since` (the read anchor), while `type: 'tail'`
+defaults to the newest persisted range minus `priorityTailSeconds` (6 hours).
+The coordinator resolves the peer's channel and queues the request until the
+channel exists. Priorities expire after `priorityTtlMs` (10 minutes) or once
+covered, and are dropped with recovery state. They are process-local and reset
+on reload.
 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.
@@ -32,6 +40,14 @@ or cancelled/closed sends. Apps own route visibility and user-intent filtering;
 automatic retries may also fail. Callbacks must not throw. Errors are not copied
 into persisted outbox records.
 
+Sends that only failed because the messenger was paused or otherwise
+unavailable (`PRIVATE_MESSENGER_PAUSED`, `CHAT_UNAVAILABLE`) stay pending
+without `onSendError`. The session re-pumps them on a bounded backoff
+(1–30 seconds with 20% jitter) in addition to availability/connectivity
+changes, so a paused messenger recovers without a manual retry. The backoff
+resets on a user `retry`, on `setAvailable(true)`, and once no retryable entry
+remains.
+
 `enqueue({ peer, event, context, requiredFiles, deletion })` preserves prepared
 identities. Local message commits and remote stages have independent checkpoints.
 It sends original/thumbnail chunks before announcements, yields for small messages,

package/private-messenger/session/index.js

@@ -18,8 +18,20 @@ 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 || ''}`)
+const unavailableSend = /PRIVATE_MESSENGER_PAUSED|CHAT_UNAVAILABLE|MESSENGER_UNAVAILABLE/i
+const isUnavailableSend = error => unavailableSend.test(`${error?.code || ''} ${error?.message || ''}`)
+const SEND_RETRY_MIN_MS = 1000
+const SEND_RETRY_MAX_MS = 30000
+// A paused or unavailable messenger must keep the outbox entry retryable
+// instead of surfacing a send failure the user has to retry by hand.
+const unavailableError = (error, signal) => Object.assign(new Error(error?.message || 'CHAT_UNAVAILABLE'), {
+  code: error?.code,
+  cause: error,
+  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, 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, _setTimeout = setTimeout, _clearTimeout = clearTimeout, _random = Math.random, openDownloads = options => createChatOutbox({ ...options, namespace: 'downloads' }) }) {
   fallbackRelays = normalizeFallbackRelays(fallbackRelays)
   const reportedErrors = new WeakSet()
   const reportError = error => {
@@ -40,12 +52,15 @@ export function createPrivateMessageSession ({ owner, signer, eventStore, messag
   const sendControllers = new Map()
   const offlineSends = new Set()
   let stopOnline
+  let sendRetryTimer
+  let sendRetryDelay = SEND_RETRY_MIN_MS
   let messenger
   let fileTransfers
   let downloads
   const downloadIntents = new Map()
   const downloadEpochs = new Map()
   const activeDownloads = new Map()
+  const pendingPriorityRanges = new Map()
   let downloadWriteTail = Promise.resolve()
   const writeDownloadIntent = operation => {
     const work = downloadWriteTail.catch(() => {}).then(operation)
@@ -59,6 +74,7 @@ export function createPrivateMessageSession ({ owner, signer, eventStore, messag
   let lifecycle = 0
   let configuring = Promise.resolve()
   let sending
+  let repump
   let draining
   const idleWaiters = new Set()
   const settled = () => { if (!sending && !draining) { for (const resolve of idleWaiters) resolve(); idleWaiters.clear() } }
@@ -89,6 +105,16 @@ export function createPrivateMessageSession ({ owner, signer, eventStore, messag
     if (!messenger) messenger = await Messenger({ fallbackRelays, seedStorage: recoveryStorage?.seeds, userSigner, channels: [], useContentKeys, onMessageQueued: () => drain(), onError: reportError })
     if (closed || !available || version !== lifecycle) { await messenger.pause('signer'); return }
     await messenger.update({ channels: values })
+    if (pendingPriorityRanges.size && typeof messenger.prioritizeRange === 'function') {
+      for (const [peer, list] of [...pendingPriorityRanges]) {
+        const channel = channels.get(peer)
+        if (!channel) continue
+        for (const request of list) {
+          try { await messenger.prioritizeRange(channel.pubkey, request) } catch (error) { reportError(error) }
+        }
+        pendingPriorityRanges.delete(peer)
+      }
+    }
     await messenger.resume('signer')
     if (!fileTransfers) {
       fileTransfers = FileTransfer({
@@ -168,9 +194,15 @@ export function createPrivateMessageSession ({ owner, signer, eventStore, messag
   }
   async function publish (peer, event, signal) {
     if (deniedPeers.has(peer)) throw new Error('PERMISSION_DENIED')
-    if (!available || !peers.has(peer) || !channels.has(peer)) throw new Error('CHAT_UNAVAILABLE')
+    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 }
-    const report = event.sig ? await messenger.broadcastEvent({ ...options, event }) : await messenger.broadcastRumor({ ...options, rumor: event })
+    let report
+    try {
+      report = event.sig ? await messenger.broadcastEvent({ ...options, event }) : await messenger.broadcastRumor({ ...options, rumor: event })
+    } catch (error) {
+      if (isUnavailableSend(error)) throw unavailableError(error, signal)
+      throw error
+    }
     // Published is relay acceptance, never a peer receipt.
     await assertMessagePublished(report, event)
   }
@@ -234,7 +266,10 @@ export function createPrivateMessageSession ({ owner, signer, eventStore, messag
       await storage.remove(entry.id)
       entries.delete(entry.id)
       emit()
-    } catch (error) {
+    } catch (cause) {
+      // Pauses can surface at any stage (text publication, file authorization
+      // or chunk delivery). Normalize all of them into the retryable path.
+      const error = cause?.retryWhenAvailable ? cause : (isUnavailableSend(cause) ? unavailableError(cause, controller.signal) : cause)
       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)
@@ -242,12 +277,42 @@ export function createPrivateMessageSession ({ owner, signer, eventStore, messag
         // 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 (!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.
+  function clearSendRetry () {
+    if (sendRetryTimer) _clearTimeout(sendRetryTimer)
+    sendRetryTimer = undefined
+  }
+  function resetSendRetry () {
+    clearSendRetry()
+    sendRetryDelay = SEND_RETRY_MIN_MS
+  }
+  const pendingRetryable = entry => Boolean(entry.failed && !cancelled.has(entry.id) && (entry.retryable || entry.status === 'pending'))
+  function scheduleSendRetry () {
+    if (closed || !available || sendRetryTimer) return
+    const delay = Math.min(SEND_RETRY_MAX_MS, sendRetryDelay * (0.8 + _random() * 0.4))
+    sendRetryDelay = Math.min(SEND_RETRY_MAX_MS, sendRetryDelay * 2)
+    sendRetryTimer = _setTimeout(() => {
+      sendRetryTimer = undefined
+      if (closed || !available) return
+      let retried = false
+      for (const entry of entries.values()) {
+        if (!pendingRetryable(entry)) continue
+        entry.failed = false
+        retried = true
+      }
+      if (retried) pump()
+    }, delay)
+    sendRetryTimer.unref?.()
+  }
   function watchOfflineSends () {
     if (closed || !available || !offlineSends.size) { stopOnlineRetry(); return }
     if (stopOnline) return
@@ -265,15 +330,26 @@ export function createPrivateMessageSession ({ owner, signer, eventStore, messag
     })
   }
   async function pump () {
-    if (sending || !available || closed || !messenger || !storage) return
+    if (!available || closed || !messenger || !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 }
     sending = true
     try {
-      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
-        await sendEntry(entry)
-      }
-    } finally { sending = false; watchOfflineSends(); settled() }
+      do {
+        repump = false
+        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
+          await sendEntry(entry)
+        }
+      } while (repump && !closed && available)
+    } finally {
+      sending = false
+      watchOfflineSends()
+      if (![...entries.values()].some(pendingRetryable)) resetSendRetry()
+      settled()
+    }
   }
   const intentId = file => getEventHash({ kind: 0, pubkey: owner, created_at: 0, tags: [], content: `${file.peer}:${file.root}` })
   async function download (file, options = {}) {
@@ -322,6 +398,23 @@ export function createPrivateMessageSession ({ owner, signer, eventStore, messag
         return {}
       }
     },
+    async prioritizeRange (peer, options = {}) {
+      if (!/^[0-9a-f]{64}$/.test(peer || '')) throw new TypeError('INVALID_PRIORITY_PEER')
+      const { since, until, type = 'unread-page' } = options || {}
+      if (type !== 'unread-page' && type !== 'tail') throw new TypeError('INVALID_PRIORITY_TYPE')
+      if (since !== undefined && !Number.isSafeInteger(since)) throw new TypeError('INVALID_PRIORITY_RANGE')
+      if (until !== undefined && !Number.isSafeInteger(until)) throw new TypeError('INVALID_PRIORITY_RANGE')
+      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') {
+        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)
+      return true
+    },
     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)
@@ -331,10 +424,12 @@ export function createPrivateMessageSession ({ owner, signer, eventStore, messag
     async setAvailable (value) {
       available = value === true
       stopOnlineRetry(); offlineSends.clear()
+      if (available) resetSendRetry()
+      else clearSendRetry()
       lifecycle++
       if (!available) { await messenger?.pause('signer'); return }
       await ready()
-      for (const entry of entries.values()) if (entry.retryable) entry.failed = false
+      for (const entry of entries.values()) if (pendingRetryable(entry)) entry.failed = false
       await messenger?.resume('storage')
       return schedule()
     },
@@ -354,7 +449,7 @@ export function createPrivateMessageSession ({ owner, signer, eventStore, messag
       offlineSends.delete(id); watchOfflineSends()
       await ready()
       const entry = entries.get(id)
-      if (entry) { entry.failed = false; if (deniedPeers.delete(entry.peer)) await schedule(); return pump() }
+      if (entry) { entry.failed = false; resetSendRetry(); if (deniedPeers.delete(entry.peer)) await schedule(); return pump() }
     },
     async cancel (id) {
       cancelled.add(id)
@@ -367,7 +462,8 @@ export function createPrivateMessageSession ({ owner, signer, eventStore, messag
     },
     async close () {
       closed = true; available = false; lifecycle++
-      stopOnlineRetry(); offlineSends.clear(); activeDownloads.clear()
+      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')