libp2r2p 0.6.0 → 0.8.0

package/private-messenger/index.js

@@ -3,7 +3,9 @@
 //   userSigner,
 //   contentKeySigner, // optional when userSigner handles content keys internally
 //   nymSigner: optionalDefaultNymSigner,
-//   channels: [{ signer: privateChannelSigner, relays, mode: 'leecher', seeders: optionalSeederPubkeys }],
+//   staleChannelSeconds: optionalStaleChannelRetention,
+//   identityStorageRetentionSeconds: optionalIdentityStorageRetention,
+//   channels: [{ signer: privateChannelSigner, relays, mode: 'leecher', seeders: optionalSeederPubkeys, offlineRecoverySeconds: optionalChannelOverride }],
 //   onContentKeyChange: event => reviewContentKeyUse(event),
 //   onError: err => reportPrivateMessengerError(err)
 // })
@@ -29,7 +31,8 @@
 // - Each watched channel stores lastSeenAt/lastWatchedAt in IndexedDB.
 // - Re-watching after reload fetches the gap from lastSeenAt to now.
 // - Browser offline/online events add explicit offline ranges with a small skew.
-// - Ranges older than 7 days are ignored; channel state not watched for 45 days is pruned.
+// - Recovery defaults to 7 days and can be overridden per channel; zero disables durable recovery.
+// - Channel state not actively leased or watched within the configured stale window is pruned.
 // - Seeders announce presence every 10min and are used for the relay-uncovered left edge of a missed range.
 // - Configured seeders are all asked; auto-discovered seeders are capped to the 8 most recently active.
 // - Seeder/watchtower channels store reconstructed router events in a separate IndexedDB queue and auto-reply to recovery asks.
@@ -40,10 +43,19 @@ import * as privateMessage from '../private-message/index.js'
 import { bytesToBase64 } from '../base64/index.js'
 import { getRelaysByPubkey, pickRelaysForPubkeys, subscribeRelayListUpdates } from '../relay/index.js'
 import * as privateChannel from '../private-channel/index.js'
-import { cleanupTemporaryStorage as cleanupTemporaryChannelStorage } from '../temporary-storage/index.js'
+import { DEFAULT_RECEIVED_CHUNK_TTL_MS } from '../private-channel/services/received-chunks.js'
 import { createQueue } from '../idb-queue/index.js'
 import { createChannelStateStore } from './services/channel-state.js'
 import { DEFAULT_STALE_CHANNEL_SECONDS } from './constants/index.js'
+import {
+  activatePrivateMessengerStorage,
+  DEFAULT_IDENTITY_STORAGE_RETENTION_SECONDS,
+  maintainPrivateMessengerStorage,
+  PRIVATE_MESSENGER_STORAGE_HEARTBEAT_MS,
+  PRIVATE_MESSENGER_STORAGE_MAINTENANCE_MS,
+  readPrivateMessengerStorage,
+  releasePrivateMessengerStorage
+} from './services/storage-maintenance.js'
 import {
   compactSeedNymCarriers,
   compactSeedRouterRows,
@@ -58,6 +70,7 @@ import {
 } from './recovery/index.js'
 
 export { DEFAULT_STALE_CHANNEL_SECONDS } from './constants/index.js'
+export { DEFAULT_IDENTITY_STORAGE_RETENTION_SECONDS } from './services/storage-maintenance.js'
 export {
   compactSeedNymCarriers,
   compactSeedRouterRows,
@@ -72,6 +85,8 @@ export {
 } from './recovery/index.js'
 
 const DEFAULT_OFFLINE_RECOVERY_SECONDS = 7 * 24 * 60 * 60
+const MAX_OFFLINE_RECOVERY_SECONDS = Math.floor(Number.MAX_SAFE_INTEGER / 1000)
+const STORAGE_POLICY_BROADCAST_CHANNEL = 'libp2r2p:private-messenger:storage-policy'
 const DEFAULT_OFFLINE_SKEW_SECONDS = 30
 const DEFAULT_RELOAD_GAP_DELAY_MS = 500
 const DEFAULT_SEEDER_PRESENCE_INTERVAL_MS = 10 * 60 * 1000
@@ -109,6 +124,27 @@ function nowSeconds () {
   return Math.floor(Date.now() / 1000)
 }
 
+function normalizeOfflineRecoverySeconds (value) {
+  if (!Number.isSafeInteger(value) || value < 0 || value > MAX_OFFLINE_RECOVERY_SECONDS) {
+    throw new Error('INVALID_OFFLINE_RECOVERY_SECONDS')
+  }
+  return value
+}
+
+function normalizeStaleChannelSeconds (value) {
+  if (!Number.isSafeInteger(value) || value < 0 || value > MAX_OFFLINE_RECOVERY_SECONDS) {
+    throw new Error('INVALID_STALE_CHANNEL_SECONDS')
+  }
+  return value
+}
+
+function normalizeIdentityStorageRetentionSeconds (value) {
+  if (!Number.isSafeInteger(value) || value < 0 || value > MAX_OFFLINE_RECOVERY_SECONDS) {
+    throw new Error('INVALID_IDENTITY_STORAGE_RETENTION_SECONDS')
+  }
+  return value
+}
+
 function uniq (values) {
   return [...new Set((values || []).filter(Boolean))]
 }
@@ -126,18 +162,33 @@ function parseJson (raw, fallback) {
   try { return JSON.parse(raw || '') } catch { return fallback }
 }
 
+function sameStateValue (left, right) {
+  return JSON.stringify(left) === JSON.stringify(right)
+}
+
 function storesRecoverySeeds (mode) {
   return mode === 'seeder' || mode === 'watchtower'
 }
 
+function randomStorageLeaseId () {
+  if (globalThis.crypto?.randomUUID) return globalThis.crypto.randomUUID()
+  const bytes = globalThis.crypto?.getRandomValues?.(new Uint8Array(16))
+  if (bytes) return [...bytes].map(value => value.toString(16).padStart(2, '0')).join('')
+  return `${Date.now().toString(36)}:${Math.random().toString(36).slice(2)}`
+}
+
 export class PrivateMessenger {
-  static cleanupTemporaryStorage ({ storageArea = globalThis.sessionStorage } = {}) {
-    cleanupTemporaryChannelStorage({ storageArea })
+  static maintainStorage ({
+    indexedDB = globalThis.indexedDB,
+    temporaryStorageArea = globalThis.sessionStorage
+  } = {}) {
+    return maintainPrivateMessengerStorage({ indexedDB, temporaryStorageArea })
   }
 
   constructor ({
     offlineRecoverySeconds = DEFAULT_OFFLINE_RECOVERY_SECONDS,
     staleChannelSeconds = DEFAULT_STALE_CHANNEL_SECONDS,
+    identityStorageRetentionSeconds = DEFAULT_IDENTITY_STORAGE_RETENTION_SECONDS,
     offlineSkewSeconds = DEFAULT_OFFLINE_SKEW_SECONDS,
     reloadGapDelayMs = DEFAULT_RELOAD_GAP_DELAY_MS,
     seederPresenceIntervalMs = DEFAULT_SEEDER_PRESENCE_INTERVAL_MS,
@@ -160,10 +211,14 @@ export class PrivateMessenger {
     _subscribeRelayListUpdates = subscribeRelayListUpdates,
     _setTimeout = globalThis.setTimeout.bind(globalThis),
     _setInterval = globalThis.setInterval.bind(globalThis),
-    _clearInterval = globalThis.clearInterval.bind(globalThis)
+    _clearInterval = globalThis.clearInterval.bind(globalThis),
+    _storageSetInterval = globalThis.setInterval.bind(globalThis),
+    _storageClearInterval = globalThis.clearInterval.bind(globalThis),
+    _BroadcastChannel = _indexedDB === globalThis.indexedDB ? globalThis.BroadcastChannel : undefined
   } = {}) {
-    this.offlineRecoverySeconds = offlineRecoverySeconds
-    this.staleChannelSeconds = staleChannelSeconds
+    this.offlineRecoverySeconds = normalizeOfflineRecoverySeconds(offlineRecoverySeconds)
+    this.staleChannelSeconds = normalizeStaleChannelSeconds(staleChannelSeconds)
+    this.identityStorageRetentionSeconds = normalizeIdentityStorageRetentionSeconds(identityStorageRetentionSeconds)
     this.offlineSkewSeconds = offlineSkewSeconds
     this.reloadGapDelayMs = reloadGapDelayMs
     this.seederPresenceIntervalMs = seederPresenceIntervalMs
@@ -187,6 +242,9 @@ export class PrivateMessenger {
     this._setTimeout = _setTimeout
     this._setInterval = _setInterval
     this._clearInterval = _clearInterval
+    this._storageSetInterval = _storageSetInterval
+    this._storageClearInterval = _storageClearInterval
+    this._BroadcastChannel = _BroadcastChannel
 
     this.userSigner = null
     this.contentKeySigner = null
@@ -208,42 +266,287 @@ export class PrivateMessenger {
     this.stopOnline = null
     this.stopOffline = null
     this.queueOperationTail = Promise.resolve()
+    this.storageActive = false
+    this.storageLeaseId = randomStorageLeaseId()
+    this.lastStorageTouch = 0
+    this.storageTouchPromise = null
+    this.storageHeartbeatTimer = null
+    this.storageMaintenanceTimer = null
+    this.storageMaintenancePromise = null
+    this.storagePolicyRevision = 0
+    this.storagePolicyNeedsApply = false
+    this.storagePolicyBroadcast = null
+    this.storagePolicyRefreshTail = Promise.resolve()
+    this.closePromise = null
+    this.initSettledPromise = null
+    this.initialized = false
   }
 
   async init ({ userSigner, contentKeySigner, nymSigner, channels = [], relays = [], mode = 'leecher' }) {
     if (!userSigner?.getPublicKey) throw new Error('USER_SIGNER_REQUIRED')
-    PrivateMessenger.cleanupTemporaryStorage({ storageArea: this.temporaryStorageArea })
-    this.userSigner = userSigner
-    this.contentKeySigner = contentKeySigner || null
-    this.nymSigner = nymSigner || null
-    this.userPubkey = await userSigner.getPublicKey()
-    this.contentKeyPubkey = await this.contentKeySigner?.getPublicKey?.() || ''
-    this.prefix = `libp2r2p:private-messenger:${this.userPubkey}`
-    this.queue = await createQueue({
-      prefix: this.prefix,
-      indexes: MESSAGE_QUEUE_INDEXES,
-      maxBytes: this.messageQueueMaxBytes,
-      evictionPolicy: 'fifo',
+    this.assertOpen()
+    if (this.initSettledPromise) throw new Error('PRIVATE_MESSENGER_INIT_IN_PROGRESS')
+    if (this.initialized) throw new Error('PRIVATE_MESSENGER_ALREADY_INITIALIZED')
+    let settleInit
+    const initSettledPromise = new Promise(resolve => { settleInit = resolve })
+    this.initSettledPromise = initSettledPromise
+    try {
+      this.userSigner = userSigner
+      this.contentKeySigner = contentKeySigner || null
+      this.nymSigner = nymSigner || null
+      this.userPubkey = await userSigner.getPublicKey()
+      this.prefix = `libp2r2p:private-messenger:${this.userPubkey}`
+      const storageSnapshot = await activatePrivateMessengerStorage({
+        userPubkey: this.userPubkey,
+        leaseId: this.storageLeaseId,
+        activeChannelPubkeys: [],
+        storagePolicy: {
+          staleChannelSeconds: this.staleChannelSeconds,
+          identityStorageRetentionSeconds: this.identityStorageRetentionSeconds
+        },
+        indexedDB: this._indexedDB
+      })
+      this.applyStoragePolicySnapshot(storageSnapshot)
+      this.storageActive = true
+      this.lastStorageTouch = Date.now()
+      this.startStoragePolicyBroadcast()
+      this.assertOpen()
+      await PrivateMessenger.maintainStorage({
+        indexedDB: this._indexedDB,
+        temporaryStorageArea: this.temporaryStorageArea
+      })
+      this.assertOpen()
+      this.contentKeyPubkey = await this.contentKeySigner?.getPublicKey?.() || ''
+      this.assertOpen()
+      this.queue = await createQueue({
+        prefix: this.prefix,
+        indexes: MESSAGE_QUEUE_INDEXES,
+        maxBytes: this.messageQueueMaxBytes,
+        evictionPolicy: 'fifo',
+        indexedDB: this._indexedDB
+      })
+      this.assertOpen()
+      this.seedQueue = await createQueue({
+        prefix: `${this.prefix}:seeds`,
+        indexes: SEED_QUEUE_INDEXES,
+        maxBytes: this.seedQueueMaxBytes,
+        evictionPolicy: 'fifo',
+        indexedDB: this._indexedDB
+      })
+      this.assertOpen()
+      this.stateStore = await createChannelStateStore({
+        prefix: this.prefix,
+        indexedDB: this._indexedDB
+      })
+      this.assertOpen()
+      this.startStorageMaintenance()
+      this.state = { channels: await this.stateStore.load() }
+      await this.update({ userSigner, contentKeySigner, nymSigner: this.nymSigner, channels, relays, mode })
+      await this.pruneStoredSeeds()
+      this.initialized = true
+      await this.refreshAndApplyStoragePolicy()
+      this.broadcastStoragePolicyChange()
+      return this
+    } catch (err) {
+      this.stopStorageMaintenance()
+      this.stopStoragePolicyBroadcast()
+      try { await this.queueOperationTail } catch {}
+      try { await this.stateWriteTail } catch {}
+      await Promise.allSettled([
+        this.queue?.close?.(),
+        this.seedQueue?.close?.(),
+        this.stateStore?.close?.()
+      ])
+      if (this.storageActive) {
+        try {
+          await releasePrivateMessengerStorage({
+            userPubkey: this.userPubkey,
+            leaseId: this.storageLeaseId,
+            indexedDB: this._indexedDB
+          })
+        } catch {}
+      }
+      this.storageActive = false
+      this.initialized = false
+      throw err
+    } finally {
+      settleInit()
+      if (this.initSettledPromise === initSettledPromise) this.initSettledPromise = null
+    }
+  }
+
+  assertOpen () {
+    if (this.closePromise) throw new Error('PRIVATE_MESSENGER_CLOSED')
+  }
+
+  applyStoragePolicySnapshot (snapshot) {
+    if (!snapshot) return false
+    const staleChannelSeconds = normalizeStaleChannelSeconds(snapshot.staleChannelSeconds)
+    const identityStorageRetentionSeconds = normalizeIdentityStorageRetentionSeconds(
+      snapshot.identityStorageRetentionSeconds
+    )
+    const policyRevision = Math.max(0, Number(snapshot.policyRevision) || 0)
+    const changed = this.staleChannelSeconds !== staleChannelSeconds ||
+      this.identityStorageRetentionSeconds !== identityStorageRetentionSeconds
+    this.staleChannelSeconds = staleChannelSeconds
+    this.identityStorageRetentionSeconds = identityStorageRetentionSeconds
+    this.storagePolicyRevision = policyRevision
+    if (changed && this.initialized) this.storagePolicyNeedsApply = true
+    return changed
+  }
+
+  startStoragePolicyBroadcast () {
+    if (this.storagePolicyBroadcast || typeof this._BroadcastChannel !== 'function') return
+    try {
+      const channel = new this._BroadcastChannel(STORAGE_POLICY_BROADCAST_CHANNEL)
+      channel.unref?.()
+      channel.onmessage = event => {
+        const message = event?.data
+        if (message?.userPubkey !== this.userPubkey) return
+        if (!Number.isSafeInteger(message.policyRevision) || message.policyRevision <= (this.storagePolicyRevision || 0)) return
+        this.refreshAndApplyStoragePolicy().catch(err => {
+          try { this.onError?.(err) } catch {}
+        })
+      }
+      this.storagePolicyBroadcast = channel
+    } catch {}
+  }
+
+  stopStoragePolicyBroadcast () {
+    const channel = this.storagePolicyBroadcast
+    this.storagePolicyBroadcast = null
+    if (!channel) return
+    channel.onmessage = null
+    channel.close?.()
+  }
+
+  broadcastStoragePolicyChange () {
+    try {
+      this.storagePolicyBroadcast?.postMessage({
+        userPubkey: this.userPubkey,
+        policyRevision: this.storagePolicyRevision || 0
+      })
+    } catch (err) {
+      try { this.onError?.(err) } catch {}
+    }
+  }
+
+  async readStoragePolicySnapshot () {
+    if (!this.userPubkey) return null
+    const snapshot = await readPrivateMessengerStorage({
+      userPubkey: this.userPubkey,
       indexedDB: this._indexedDB
     })
-    this.seedQueue = await createQueue({
-      prefix: `${this.prefix}:seeds`,
-      indexes: SEED_QUEUE_INDEXES,
-      maxBytes: this.seedQueueMaxBytes,
-      evictionPolicy: 'fifo',
-      indexedDB: this._indexedDB
+    this.applyStoragePolicySnapshot(snapshot)
+    return snapshot
+  }
+
+  async applyPendingStoragePolicy () {
+    if (!this.storagePolicyNeedsApply || !this.initialized || this.closePromise) return false
+    this.storagePolicyNeedsApply = false
+    try {
+      const channels = [...this.channels.values()]
+      await this.applyRecoveryPolicies(channels)
+      await this.cleanupStaleChannels()
+      const pubkeys = [...this.channels.keys()]
+      if (pubkeys.length) {
+        await this.unwatch(pubkeys)
+        await this.watch(pubkeys)
+      }
+      await this.reconcilePresencePublishers()
+      return true
+    } catch (err) {
+      this.storagePolicyNeedsApply = true
+      throw err
+    }
+  }
+
+  refreshAndApplyStoragePolicy () {
+    const previous = this.storagePolicyRefreshTail || Promise.resolve()
+    const refresh = previous.catch(() => {}).then(async () => {
+      await this.readStoragePolicySnapshot()
+      return this.applyPendingStoragePolicy()
     })
-    this.stateStore = await createChannelStateStore({
-      prefix: this.prefix,
-      indexedDB: this._indexedDB
+    this.storagePolicyRefreshTail = refresh
+    return refresh
+  }
+
+  startStorageMaintenance () {
+    if (this.storageHeartbeatTimer || this.storageMaintenanceTimer) return
+    this.storageHeartbeatTimer = this._storageSetInterval(() => (
+      this.runStorageHeartbeat().catch(err => {
+        try { this.onError?.(err) } catch {}
+      })
+    ), PRIVATE_MESSENGER_STORAGE_HEARTBEAT_MS)
+    this.storageMaintenanceTimer = this._storageSetInterval(
+      () => this.runStorageMaintenance(),
+      PRIVATE_MESSENGER_STORAGE_MAINTENANCE_MS
+    )
+    this.storageHeartbeatTimer?.unref?.()
+    this.storageMaintenanceTimer?.unref?.()
+  }
+
+  stopStorageMaintenance () {
+    if (this.storageHeartbeatTimer) this._storageClearInterval(this.storageHeartbeatTimer)
+    if (this.storageMaintenanceTimer) this._storageClearInterval(this.storageMaintenanceTimer)
+    this.storageHeartbeatTimer = null
+    this.storageMaintenanceTimer = null
+  }
+
+  runStorageMaintenance () {
+    if (this.storageMaintenancePromise) return this.storageMaintenancePromise
+    const maintenance = (async () => {
+      await PrivateMessenger.maintainStorage({
+        indexedDB: this._indexedDB,
+        temporaryStorageArea: this.temporaryStorageArea
+      })
+      await this.refreshAndApplyStoragePolicy()
+      await this.cleanupStaleChannels()
+      await this.pruneStoredSeeds()
+    })().catch(err => {
+      try { this.onError?.(err) } catch {}
+    }).finally(() => {
+      if (this.storageMaintenancePromise === maintenance) this.storageMaintenancePromise = null
     })
-    this.state = { channels: await this.stateStore.load() }
-    await this.cleanupStaleChannels()
-    await this.update({ userSigner, contentKeySigner, nymSigner: this.nymSigner, channels, relays, mode })
-    return this
+    this.storageMaintenancePromise = maintenance
+    return maintenance
+  }
+
+  async runStorageHeartbeat () {
+    await this.stampActiveChannelActivity()
+    await this.touchStorageActivity({ force: true })
+    await this.applyPendingStoragePolicy()
+  }
+
+  async touchStorageActivity ({ force = false } = {}) {
+    if (!this.storageActive || this.closePromise) return false
+    if (this.storageTouchPromise) return this.storageTouchPromise
+    const now = Date.now()
+    if (!force && now - this.lastStorageTouch < PRIVATE_MESSENGER_STORAGE_HEARTBEAT_MS) return false
+    const previousTouch = this.lastStorageTouch
+    this.lastStorageTouch = now
+    const touch = activatePrivateMessengerStorage({
+      userPubkey: this.userPubkey,
+      leaseId: this.storageLeaseId,
+      activeChannelPubkeys: [...this.channels.keys()],
+      indexedDB: this._indexedDB,
+      now
+    }).then(snapshot => {
+      this.applyStoragePolicySnapshot(snapshot)
+      return true
+    }, err => {
+      this.lastStorageTouch = previousTouch
+      throw err
+    }).finally(() => {
+      if (this.storageTouchPromise === touch) this.storageTouchPromise = null
+    })
+    this.storageTouchPromise = touch
+    return touch
   }
 
   runQueueOperation (operation) {
+    if (this.closePromise) return Promise.reject(new Error('PRIVATE_MESSENGER_CLOSED'))
+    this.touchStorageActivity().catch(err => this.onError?.(err))
     const run = this.queueOperationTail.then(operation)
     this.queueOperationTail = run.catch(err => {
       try { this.onError?.(err) } catch {}
@@ -277,7 +580,24 @@ export class PrivateMessenger {
     })
   }
 
-  async update ({ userSigner = this.userSigner, contentKeySigner = this.contentKeySigner, nymSigner = this.nymSigner, channels = [...this.channels.values()], relays = [], mode = 'leecher' } = {}) {
+  async update (options = {}) {
+    this.assertOpen()
+    const {
+      userSigner = this.userSigner,
+      contentKeySigner = this.contentKeySigner,
+      nymSigner = this.nymSigner,
+      channels = [...this.channels.values()],
+      relays = [],
+      mode = 'leecher'
+    } = options
+    const updatesStalePolicy = Object.hasOwn(options, 'staleChannelSeconds')
+    const updatesIdentityPolicy = Object.hasOwn(options, 'identityStorageRetentionSeconds')
+    let nextStaleChannelSeconds = updatesStalePolicy
+      ? normalizeStaleChannelSeconds(options.staleChannelSeconds)
+      : this.staleChannelSeconds
+    let nextIdentityStorageRetentionSeconds = updatesIdentityPolicy
+      ? normalizeIdentityStorageRetentionSeconds(options.identityStorageRetentionSeconds)
+      : this.identityStorageRetentionSeconds
     if (userSigner) {
       const userPubkey = await userSigner.getPublicKey?.()
       if (!userPubkey) throw new Error('USER_SIGNER_REQUIRED')
@@ -288,19 +608,50 @@ export class PrivateMessenger {
     this.nymSigner = nymSigner || null
     this.contentKeyPubkey = await this.contentKeySigner?.getPublicKey?.() || ''
     const nextChannels = await this.normalizeChannels(channels, { relays, mode })
+    this.assertOpen()
     const nextPubkeys = new Set(nextChannels.map(channel => channel.pubkey))
-
-    for (const pubkey of [...this.channels.keys()]) {
-      if (!nextPubkeys.has(pubkey)) {
-        this.unwatch(pubkey)
-        this.channels.delete(pubkey)
+    const removedPubkeys = [...this.channels.keys()].filter(pubkey => !nextPubkeys.has(pubkey))
+    const updatesStoragePolicy = updatesStalePolicy || updatesIdentityPolicy
+
+    if (updatesStoragePolicy) {
+      const currentPolicy = await this.readStoragePolicySnapshot()
+      if (!updatesStalePolicy) nextStaleChannelSeconds = currentPolicy?.staleChannelSeconds ?? this.staleChannelSeconds
+      if (!updatesIdentityPolicy) {
+        nextIdentityStorageRetentionSeconds = currentPolicy?.identityStorageRetentionSeconds ?? this.identityStorageRetentionSeconds
       }
     }
+
+    if (removedPubkeys.length) {
+      await this.stampChannelActivity(removedPubkeys)
+    }
+
+    const storageSnapshot = await activatePrivateMessengerStorage({
+      userPubkey: this.userPubkey,
+      leaseId: this.storageLeaseId,
+      activeChannelPubkeys: [...nextPubkeys],
+      storagePolicy: updatesStoragePolicy
+        ? {
+            staleChannelSeconds: nextStaleChannelSeconds,
+            identityStorageRetentionSeconds: nextIdentityStorageRetentionSeconds
+          }
+        : undefined,
+      indexedDB: this._indexedDB
+    })
+    this.applyStoragePolicySnapshot(storageSnapshot)
+    this.lastStorageTouch = Date.now()
+    if (updatesStoragePolicy) this.broadcastStoragePolicyChange()
+
+    await this.unwatch([...this.channels.keys()])
+    this.channels.clear()
     for (const channel of nextChannels) this.channels.set(channel.pubkey, channel)
 
-    await this.cleanupStaleChannels()
+    await this.cleanupStaleChannels({ storageSnapshot })
+    await this.applyRecoveryPolicies(nextChannels)
     await this.watch()
     await this.reconcilePresencePublishers()
+    if (this.storagePolicyRevision === storageSnapshot.policyRevision) {
+      this.storagePolicyNeedsApply = false
+    }
     return this
   }
 
@@ -323,6 +674,9 @@ export class PrivateMessenger {
       const autoDeletionCapability = channel.autoDeletionCapability === undefined
         ? undefined
         : normalizeAutoDeletionCapability(channel.autoDeletionCapability)
+      const offlineRecoverySeconds = normalizeOfflineRecoverySeconds(
+        channel.offlineRecoverySeconds ?? this.offlineRecoverySeconds
+      )
       out.push({
         pubkey,
         signer,
@@ -334,6 +688,7 @@ export class PrivateMessenger {
         usesNip65WatchRelays: !hasChannelRelays && !hasDefaultRelays,
         mode,
         seeders: uniq(channel.seeders),
+        offlineRecoverySeconds,
         autoDeletionCapability
       })
     }
@@ -355,6 +710,7 @@ export class PrivateMessenger {
   }
 
   async recoveryMirrorRelays (channelPubkey) {
+    if (!this.offlineRecoverySecondsFor(channelPubkey)) return []
     const seeders = this.recoverySeeders(channelPubkey)
     if (!seeders.length) return []
     try {
@@ -385,13 +741,19 @@ export class PrivateMessenger {
     return structuredClone(this.state)
   }
 
-  writeState (state) {
+  writeState (state, { touchStorage = true } = {}) {
+    if (touchStorage) this.touchStorageActivity().catch(err => this.onError?.(err))
+    const previous = this.state?.channels || {}
     const next = {
       channels: isPlainObject(state?.channels) ? structuredClone(state.channels) : {}
     }
+    const changed = Object.fromEntries(Object.entries(next.channels)
+      .filter(([pubkey, value]) => !sameStateValue(previous[pubkey], value)))
+    const removed = Object.keys(previous).filter(pubkey => !Object.hasOwn(next.channels, pubkey))
     this.state = next
-    const snapshot = structuredClone(next.channels)
-    const write = this.stateWriteTail.then(() => this.stateStore.replace(snapshot))
+    if (!Object.keys(changed).length && !removed.length) return this.stateWriteTail
+    const snapshot = structuredClone(changed)
+    const write = this.stateWriteTail.then(() => this.stateStore.update(snapshot, removed))
     this.stateWriteTail = write.catch(err => {
       try { this.onError?.(err) } catch {}
     })
@@ -402,6 +764,29 @@ export class PrivateMessenger {
     await this.stateWriteTail
   }
 
+  async stampChannelActivity (pubkeys) {
+    if (!this.stateStore || !this.state) return false
+    pubkeys = [...new Set(pubkeys || [])].filter(pubkey => this.state.channels[pubkey])
+    if (!pubkeys.length) return false
+    const lastWatchedAt = nowSeconds()
+    for (const pubkey of pubkeys) {
+      this.state.channels[pubkey] = {
+        ...this.state.channels[pubkey],
+        lastWatchedAt
+      }
+    }
+    const write = this.stateWriteTail.then(() => this.stateStore.touch(pubkeys, lastWatchedAt))
+    this.stateWriteTail = write.catch(err => {
+      try { this.onError?.(err) } catch {}
+    })
+    await write
+    return true
+  }
+
+  stampActiveChannelActivity () {
+    return this.stampChannelActivity([...this.channels.keys()])
+  }
+
   updateChannelState (pubkey, patch) {
     const state = this.readState()
     const current = state.channels[pubkey] || {}
@@ -411,9 +796,19 @@ export class PrivateMessenger {
   }
 
   removeChannelState (pubkey) {
-    const state = this.readState()
-    delete state.channels[pubkey]
-    this.writeState(state)
+    this.removeChannelStates([pubkey])
+  }
+
+  removeChannelStates (pubkeys) {
+    pubkeys = [...new Set(pubkeys || [])]
+    for (const pubkey of pubkeys) delete this.state.channels[pubkey]
+    if (!pubkeys.length) return this.stateWriteTail
+    this.touchStorageActivity().catch(err => this.onError?.(err))
+    const write = this.stateWriteTail.then(() => this.stateStore.update({}, pubkeys))
+    this.stateWriteTail = write.catch(err => {
+      try { this.onError?.(err) } catch {}
+    })
+    return write
   }
 
   markSeen (pubkey, createdAt = nowSeconds()) {
@@ -432,6 +827,7 @@ export class PrivateMessenger {
   }
 
   recoverySeeders (pubkey) {
+    if (!this.offlineRecoverySecondsFor(pubkey)) return []
     const channel = this.channels.get(pubkey)
     const configuredSeeders = channel?.seeders || []
     if (configuredSeeders.length) return configuredSeeders.filter(seeder => seeder !== this.userPubkey)
@@ -446,6 +842,7 @@ export class PrivateMessenger {
   }
 
   markSeederActive (channelPubkey, seederPubkey, { announced = false, at = nowSeconds() } = {}) {
+    if (!this.offlineRecoverySecondsFor(channelPubkey)) return false
     const state = this.readState()
     const current = state.channels[channelPubkey] || {}
     const activity = current.seederActivity || {}
@@ -459,6 +856,7 @@ export class PrivateMessenger {
     current.seederActivity = activity
     state.channels[channelPubkey] = current
     this.writeState(state)
+    return true
   }
 
   trackSeederActivity (channelPubkey, message) {
@@ -544,8 +942,10 @@ export class PrivateMessenger {
   }
 
   addOfflineRange (pubkey, start, end) {
+    const recoverySeconds = this.offlineRecoverySecondsFor(pubkey)
+    if (!recoverySeconds) return
     const now = nowSeconds()
-    const minStart = now - this.offlineRecoverySeconds
+    const minStart = now - recoverySeconds
     const normalized = {
       start: Math.max(0, Math.floor(start)),
       end: Math.floor(end)
@@ -567,10 +967,17 @@ export class PrivateMessenger {
   closeOpenOfflineRanges () {
     const state = this.readState()
     const end = nowSeconds()
-    const minStart = end - this.offlineRecoverySeconds
     for (const pubkey of Object.keys(state.channels)) {
       const current = state.channels[pubkey]
       if (!current.openOfflineStart) continue
+      const recoverySeconds = this.offlineRecoverySecondsFor(pubkey)
+      if (!recoverySeconds) {
+        delete current.openOfflineStart
+        current.offlineRanges = []
+        state.channels[pubkey] = current
+        continue
+      }
+      const minStart = end - recoverySeconds
       const start = Math.max(minStart, Math.max(0, current.openOfflineStart))
       if (end > start) {
         current.offlineRanges = mergeRanges((current.offlineRanges || []).concat([{ start, end }]))
@@ -582,11 +989,13 @@ export class PrivateMessenger {
   }
 
   async watch (channels = [...this.channels.keys()], { scheduleReloadGap = true } = {}) {
+    this.assertOpen()
     const channelPubkeys = uniq(channels)
     for (const pubkey of channelPubkeys) {
       const channel = this.channels.get(pubkey)
       if (!channel) throw new Error('UNKNOWN_CHANNEL')
       const watchRelays = await this.resolveWatchRelays(channel)
+      this.assertOpen()
       const stop = await this._privateMessage.watch({
         channels: [pubkey],
         relays: watchRelays,
@@ -604,16 +1013,21 @@ export class PrivateMessenger {
         onMessage: message => this.queueIncoming(() => this.handleMessage(pubkey, message)),
         onSeed: seed => this.queueIncoming(() => this.enqueueSeed(pubkey, seed)),
         onContentKeyUsage: usage => this.handleContentKeyUsage(pubkey, usage),
-        receivedChunkTtlMs: this.offlineRecoverySeconds * 1000,
+        receivedChunkTtlMs: this.receivedChunkTtlMsFor(channel),
         receivedChunkIndexedDB: this._indexedDB,
         onError: err => this.onError?.(err)
       })
+      if (this.closePromise) {
+        await stop?.()
+        this.assertOpen()
+      }
       this.stopByChannel.set(pubkey, stop)
       this.updateChannelState(pubkey, {
         lastWatchedAt: nowSeconds(),
         mode: channel.mode,
         relays: watchRelays,
-        seeders: channel.seeders
+        seeders: channel.seeders,
+        offlineRecoverySeconds: channel.offlineRecoverySeconds
       })
       this.debug('watch', {
         channelPubkey: pubkey,
@@ -631,12 +1045,15 @@ export class PrivateMessenger {
 
   unwatch (channels) {
     const channelPubkeys = channels ? uniq(Array.isArray(channels) ? channels : [channels]) : [...this.stopByChannel.keys()]
+    const closing = []
     for (const pubkey of channelPubkeys) {
-      this.stopByChannel.get(pubkey)?.()
+      const close = this.stopByChannel.get(pubkey)?.()
+      if (close && typeof close.then === 'function') closing.push(close)
       this.stopByChannel.delete(pubkey)
       this.stopPresencePublisher(pubkey)
     }
     this.ensureRelayListWatcher()
+    return Promise.allSettled(closing)
   }
 
   nip65WatchChannelPubkeys () {
@@ -762,6 +1179,7 @@ export class PrivateMessenger {
   }
 
   async enqueueSeed (channelPubkey, seed) {
+    if (!this.offlineRecoverySecondsFor(channelPubkey)) return
     const receivedAt = nowSeconds()
     if (seed.recordType === NYM_CARRIER_SEED_RECORD_TYPE || seed.carriers?.length) {
       const carriers = compactSeedNymCarriers(seed.carriers)
@@ -818,6 +1236,7 @@ export class PrivateMessenger {
 
   async nextMessage () {
     // seedQueue is retained replay material for recovery replies, not an app-message stream.
+    this.touchStorageActivity().catch(err => this.onError?.(err))
     await this.queueOperationTail
     return withoutQueueMetadata(await this.queue.shift())
   }
@@ -833,7 +1252,7 @@ export class PrivateMessenger {
       privateChannelReaderPubkey: channel.readerPubkey,
       receiverPubkey,
       ...routing,
-      expirationSeconds: this.offlineRecoverySeconds,
+      expirationSeconds: this.eventExpirationSecondsFor(channel),
       temporaryStorageArea: this.temporaryStorageArea,
       deletionPubkey,
       autoDeletionCapability: this.autoDeletionCapabilityFor(channel),
@@ -859,7 +1278,7 @@ export class PrivateMessenger {
       question,
       receiverPubkey,
       ...routing,
-      expirationSeconds: this.offlineRecoverySeconds,
+      expirationSeconds: this.eventExpirationSecondsFor(channel),
       temporaryStorageArea: this.temporaryStorageArea,
       deletionPubkey,
       autoDeletionCapability: this.autoDeletionCapabilityFor(channel),
@@ -883,7 +1302,7 @@ export class PrivateMessenger {
       privateChannelReaderPubkey: channel.readerPubkey,
       receiverPubkey,
       ...routing,
-      expirationSeconds: this.offlineRecoverySeconds,
+      expirationSeconds: this.eventExpirationSecondsFor(channel),
       temporaryStorageArea: this.temporaryStorageArea,
       deletionPubkey,
       autoDeletionCapability: this.autoDeletionCapabilityFor(channel),
@@ -907,7 +1326,7 @@ export class PrivateMessenger {
       privateChannelReaderPubkey: channel.readerPubkey,
       receiverPubkeys,
       ...routing,
-      expirationSeconds: this.offlineRecoverySeconds,
+      expirationSeconds: this.eventExpirationSecondsFor(channel),
       temporaryStorageArea: this.temporaryStorageArea,
       deletionPubkey,
       autoDeletionCapability: this.autoDeletionCapabilityFor(channel),
@@ -931,7 +1350,7 @@ export class PrivateMessenger {
       privateChannelReaderPubkey: channel.readerPubkey,
       receiverPubkeys,
       ...routing,
-      expirationSeconds: this.offlineRecoverySeconds,
+      expirationSeconds: this.eventExpirationSecondsFor(channel),
       temporaryStorageArea: this.temporaryStorageArea,
       deletionPubkey,
       autoDeletionCapability: this.autoDeletionCapabilityFor(channel),
@@ -951,7 +1370,7 @@ export class PrivateMessenger {
       privateChannelReaderPubkey: channel.readerPubkey,
       receiverPubkeys,
       ...routing,
-      expirationSeconds: this.offlineRecoverySeconds,
+      expirationSeconds: this.eventExpirationSecondsFor(channel),
       temporaryStorageArea: this.temporaryStorageArea,
       deletionPubkey,
       autoDeletionCapability: this.autoDeletionCapabilityFor(channel),
@@ -970,7 +1389,7 @@ export class PrivateMessenger {
       privateChannelSigner: channel.signer,
       privateChannelReaderPubkey: channel.readerPubkey,
       ...routing,
-      expirationSeconds: this.offlineRecoverySeconds,
+      expirationSeconds: this.eventExpirationSecondsFor(channel),
       deletionPubkey,
       autoDeletionCapability: this.autoDeletionCapabilityFor(channel),
       rumor
@@ -987,7 +1406,7 @@ export class PrivateMessenger {
       privateChannelSigner: channel.signer,
       privateChannelReaderPubkey: channel.readerPubkey,
       ...routing,
-      expirationSeconds: this.offlineRecoverySeconds,
+      expirationSeconds: this.eventExpirationSecondsFor(channel),
       deletionPubkey,
       autoDeletionCapability: this.autoDeletionCapabilityFor(channel),
       event
@@ -996,6 +1415,7 @@ export class PrivateMessenger {
 
   async publishSeederPresence (channelPubkey = this.defaultChannelPubkey()) {
     const channel = this.requireWritableChannel(channelPubkey)
+    if (!this.offlineRecoverySecondsFor(channel)) return null
     const receiverPubkeys = uniq([...this.knownSeeders(channelPubkey), this.userPubkey])
     const routing = await this.resolveSendRouting({ channel, receiverPubkeys })
     this.debugSend('yell', channelPubkey, { code: SEEDER_PRESENCE_CODE, receiverPubkeys })
@@ -1006,7 +1426,7 @@ export class PrivateMessenger {
       privateChannelReaderPubkey: channel.readerPubkey,
       receiverPubkeys,
       ...routing,
-      expirationSeconds: this.offlineRecoverySeconds,
+      expirationSeconds: this.eventExpirationSecondsFor(channel),
       temporaryStorageArea: this.temporaryStorageArea,
       autoDeletionCapability: this.autoDeletionCapabilityFor(channel),
       code: SEEDER_PRESENCE_CODE,
@@ -1016,6 +1436,7 @@ export class PrivateMessenger {
   }
 
   async startPresencePublisher (channelPubkey) {
+    if (!this.offlineRecoverySecondsFor(channelPubkey)) return
     if (this.presenceTimers.has(channelPubkey)) return
     try {
       await this.publishSeederPresence(channelPubkey)
@@ -1040,10 +1461,10 @@ export class PrivateMessenger {
   async reconcilePresencePublishers () {
     const starts = []
     for (const pubkey of [...this.presenceTimers.keys()]) {
-      if (!storesRecoverySeeds(this.channels.get(pubkey)?.mode)) this.stopPresencePublisher(pubkey)
+      if (!storesRecoverySeeds(this.channels.get(pubkey)?.mode) || !this.offlineRecoverySecondsFor(pubkey)) this.stopPresencePublisher(pubkey)
     }
     for (const [pubkey, channel] of this.channels) {
-      if (storesRecoverySeeds(channel.mode)) starts.push(this.startPresencePublisher(pubkey))
+      if (storesRecoverySeeds(channel.mode) && this.offlineRecoverySecondsFor(channel)) starts.push(this.startPresencePublisher(pubkey))
       else this.stopPresencePublisher(pubkey)
     }
     await Promise.all(starts)
@@ -1077,6 +1498,66 @@ export class PrivateMessenger {
     return channel.autoDeletionCapability ?? this.autoDeletionCapability
   }
 
+  requestedOfflineRecoverySecondsFor (channelOrPubkey) {
+    const channel = typeof channelOrPubkey === 'string'
+      ? this.channels.get(channelOrPubkey)
+      : channelOrPubkey
+    if (channel?.offlineRecoverySeconds !== undefined) return channel.offlineRecoverySeconds
+    const pubkey = typeof channelOrPubkey === 'string' ? channelOrPubkey : channelOrPubkey?.pubkey
+    const persisted = pubkey ? this.state.channels[pubkey]?.offlineRecoverySeconds : undefined
+    return persisted === undefined
+      ? this.offlineRecoverySeconds
+      : normalizeOfflineRecoverySeconds(persisted)
+  }
+
+  offlineRecoverySecondsFor (channelOrPubkey) {
+    return Math.min(
+      this.requestedOfflineRecoverySecondsFor(channelOrPubkey),
+      this.staleChannelSeconds,
+      this.identityStorageRetentionSeconds
+    )
+  }
+
+  staleChannelSecondsForCleanup () {
+    return Math.min(this.staleChannelSeconds, this.identityStorageRetentionSeconds)
+  }
+
+  eventExpirationSecondsFor (channel) {
+    return this.offlineRecoverySecondsFor(channel) || privateChannel.EXPIRATION_SECONDS
+  }
+
+  receivedChunkTtlMsFor (channel) {
+    const seconds = this.offlineRecoverySecondsFor(channel)
+    return seconds ? seconds * 1000 : DEFAULT_RECEIVED_CHUNK_TTL_MS
+  }
+
+  async applyRecoveryPolicies (channels) {
+    return this.runQueueOperation(async () => {
+      const state = this.readState()
+      const now = nowSeconds()
+      for (const channel of channels) {
+        const current = state.channels[channel.pubkey] || {}
+        const requestedSeconds = channel.offlineRecoverySeconds
+        const effectiveSeconds = this.offlineRecoverySecondsFor(channel)
+        current.offlineRecoverySeconds = requestedSeconds
+        if (!effectiveSeconds) {
+          delete current.openOfflineStart
+          current.offlineRanges = []
+        } else {
+          const cutoff = now - effectiveSeconds
+          current.offlineRanges = mergeRanges((current.offlineRanges || [])
+            .filter(range => range.end >= cutoff)
+            .map(range => ({ ...range, start: Math.max(range.start, cutoff) })))
+          if (current.openOfflineStart) current.openOfflineStart = Math.max(current.openOfflineStart, cutoff)
+        }
+        state.channels[channel.pubkey] = current
+      }
+      this.writeState(state)
+      await this.flushStateWrites()
+      for (const channel of channels) await this.pruneStoredSeeds(channel.pubkey)
+    })
+  }
+
   requireNymSigner (channel, override) {
     const signer = override || channel?.nymSigner || this.nymSigner
     if (!signer?.getPublicKey) throw new Error('NYM_SIGNER_REQUIRED')
@@ -1088,6 +1569,7 @@ export class PrivateMessenger {
   }
 
   scheduleReloadGap (pubkey) {
+    if (!this.offlineRecoverySecondsFor(pubkey)) return
     const current = this.readState().channels[pubkey]
     const start = current?.openOfflineStart || current?.lastSeenAt
     if (!start) return
@@ -1117,6 +1599,7 @@ export class PrivateMessenger {
         const state = this.readState()
         const start = Math.max(0, nowSeconds() - this.offlineSkewSeconds)
         for (const pubkey of this.channels.keys()) {
+          if (!this.offlineRecoverySecondsFor(pubkey)) continue
           const current = state.channels[pubkey] || {}
           current.openOfflineStart ||= start
           state.channels[pubkey] = current
@@ -1139,6 +1622,7 @@ export class PrivateMessenger {
   }
 
   async askSeedersForMissingRange (channelPubkey, since, until) {
+    if (!this.offlineRecoverySecondsFor(channelPubkey)) return []
     if (!this.channels.get(channelPubkey)?.signer) return []
     const seeders = this.recoverySeeders(channelPubkey)
     if (!seeders.length || until < since) return []
@@ -1175,11 +1659,14 @@ export class PrivateMessenger {
       question: message.event,
       receiverPubkey: message.event?.pubkey,
       since,
-      until
+      until,
+      sendEmptyReply: !this.offlineRecoverySecondsFor(channelPubkey)
     })
 
-    for await (const seed of this.seedQueue.storedItemsBy('byChannel', channelPubkey)) {
-      await packer.update(seed)
+    if (this.offlineRecoverySecondsFor(channelPubkey)) {
+      for await (const seed of this.seedQueue.storedItemsBy('byChannel', channelPubkey)) {
+        await packer.update(seed)
+      }
     }
     await packer.finalize()
   }
@@ -1263,12 +1750,14 @@ export class PrivateMessenger {
   async recoverOfflineRanges (channels = [...this.stopByChannel.keys()]) {
     const state = this.readState()
     const now = nowSeconds()
-    const minStart = now - this.offlineRecoverySeconds
 
     for (const pubkey of uniq(channels)) {
       const channel = this.channels.get(pubkey)
       const current = state.channels[pubkey]
       if (!channel || !current?.offlineRanges?.length) continue
+      const recoverySeconds = this.offlineRecoverySecondsFor(channel)
+      if (!recoverySeconds) continue
+      const minStart = now - recoverySeconds
 
       const remaining = []
       for (const range of current.offlineRanges) {
@@ -1288,7 +1777,7 @@ export class PrivateMessenger {
             until: range.end,
             mode: channel.mode,
             modeByPubkey: { [pubkey]: channel.mode },
-            receivedChunkTtlMs: this.offlineRecoverySeconds * 1000,
+            receivedChunkTtlMs: this.receivedChunkTtlMsFor(channel),
             receivedChunkIndexedDB: this._indexedDB,
             onEvent: (event, outer, meta) => this.queueIncoming(() => this.enqueueRumor(eventType(event), pubkey, { event, outer, meta, payload: parseEventContent(event) })),
             onNymEvent: (event, outer, meta) => this.queueIncoming(() => this.enqueueRumor('nym', pubkey, { event, outer, meta, payload: parseEventContent(event) })),
@@ -1313,13 +1802,14 @@ export class PrivateMessenger {
 
   async clearChannel (pubkey) {
     return this.runQueueOperation(async () => {
-      this.unwatch(pubkey)
-      this._privateMessage.clearChannelState?.(pubkey)
+      await this.unwatch(pubkey)
+      await this._privateMessage.clearChannelState?.(pubkey)
       this.channels.delete(pubkey)
       this.removeChannelState(pubkey)
       await this.flushStateWrites()
       await this.queue.removeBy('byChannel', pubkey)
       await this.seedQueue.removeBy('byChannel', pubkey)
+      await this.touchStorageActivity({ force: true })
       this.ensureRelayListWatcher()
     })
   }
@@ -1328,42 +1818,64 @@ export class PrivateMessenger {
     return this.runQueueOperation(() => this.queue.clear())
   }
 
-  async cleanupStaleChannels () {
+  async cleanupStaleChannels ({ storageSnapshot } = {}) {
     if (!this.prefix) return
+    storageSnapshot ||= await this.readStoragePolicySnapshot()
+    if (!storageSnapshot) return
+    const activeChannelPubkeys = new Set(storageSnapshot.activeChannelPubkeys || [])
     return this.runQueueOperation(async () => {
-      const state = this.readState()
-      const cutoff = nowSeconds() - this.staleChannelSeconds
+      await this.flushStateWrites()
+      const state = { channels: await this.stateStore.load() }
+      const cutoff = nowSeconds() - this.staleChannelSecondsForCleanup()
+      const stalePubkeys = []
       for (const [pubkey, channel] of Object.entries(state.channels)) {
+        if (activeChannelPubkeys.has(pubkey)) continue
         if ((channel.lastWatchedAt || 0) >= cutoff) continue
         delete state.channels[pubkey]
+        stalePubkeys.push(pubkey)
         await this.queue?.removeBy('byChannel', pubkey)
         await this.seedQueue?.removeBy('byChannel', pubkey)
       }
-      this.writeState(state)
-      await this.flushStateWrites()
+      this.state = state
+      if (stalePubkeys.length) await this.removeChannelStates(stalePubkeys)
     })
   }
 
   async pruneStoredSeeds (channelPubkey) {
     if (!this.seedQueue) return
-    const cutoff = nowSeconds() - this.offlineRecoverySeconds
     const keyRange = globalThis.IDBKeyRange
-    if (channelPubkey && keyRange?.bound) {
-      await this.seedQueue.removeBy('byChannelTime', keyRange.bound([channelPubkey, 0], [channelPubkey, cutoff], false, true))
+    if (!channelPubkey) {
+      const pubkeys = new Set([...Object.keys(this.state.channels), ...this.channels.keys()])
+      for (const pubkey of pubkeys) await this.pruneStoredSeeds(pubkey)
+      await this.seedQueue.removeWhere(item => !pubkeys.has(item.channelPubkey))
       return
     }
-    if (!channelPubkey && keyRange?.upperBound) {
-      await this.seedQueue.removeBy('byTime', keyRange.upperBound(cutoff, true))
+    const recoverySeconds = this.offlineRecoverySecondsFor(channelPubkey)
+    if (!recoverySeconds) {
+      await this.seedQueue.removeBy('byChannel', channelPubkey)
+      return
+    }
+    const cutoff = nowSeconds() - recoverySeconds
+    if (cutoff <= 0) return
+    if (keyRange?.bound) {
+      await this.seedQueue.removeBy('byChannelTime', keyRange.bound([channelPubkey, 0], [channelPubkey, cutoff], false, true))
       return
     }
     await this.seedQueue.removeWhere(item => {
-      if (channelPubkey && item.channelPubkey !== channelPubkey) return false
+      if (item.channelPubkey !== channelPubkey) return false
       return (seedRecordTime(item) || item.receivedAt || 0) < cutoff
     })
   }
 
   close () {
-    this.unwatch()
+    if (this.closePromise) return this.closePromise
+    const initSettledPromise = this.initSettledPromise
+    let unwatchPromise
+    try {
+      unwatchPromise = Promise.resolve(this.unwatch())
+    } catch (err) {
+      unwatchPromise = Promise.reject(err)
+    }
     for (const pubkey of [...this.presenceTimers.keys()]) this.stopPresencePublisher(pubkey)
     this.stopRelayListWatcher?.()
     this.stopRelayListWatcher = null
@@ -1372,6 +1884,41 @@ export class PrivateMessenger {
     this.stopOnline?.()
     this.stopOffline = null
     this.stopOnline = null
+    this.stopStorageMaintenance()
+    this.stopStoragePolicyBroadcast()
+
+    this.closePromise = (async () => {
+      let unwatchError
+      try { await unwatchPromise } catch (err) { unwatchError = err }
+      await initSettledPromise
+      await this.stampActiveChannelActivity()
+      await this.queueOperationTail
+      await this.stateWriteTail
+      try { await this.storageTouchPromise } catch {}
+      await this.storageMaintenancePromise
+      try { await this.storagePolicyRefreshTail } catch {}
+      await Promise.all([
+        this.queue?.close?.(),
+        this.seedQueue?.close?.(),
+        this.stateStore?.close?.()
+      ])
+      if (this.storageActive) {
+        await releasePrivateMessengerStorage({
+          userPubkey: this.userPubkey,
+          leaseId: this.storageLeaseId,
+          indexedDB: this._indexedDB
+        })
+      }
+      this.storageActive = false
+      if (this.identityStorageRetentionSeconds === 0) {
+        await PrivateMessenger.maintainStorage({
+          indexedDB: this._indexedDB,
+          temporaryStorageArea: this.temporaryStorageArea
+        })
+      }
+      if (unwatchError) throw unwatchError
+    })()
+    return this.closePromise
   }
 }
 
@@ -1452,11 +1999,9 @@ function nymCarrierSeedKey (record) {
 
 function withoutQueueMetadata (item) {
   if (!item) return null
-  const {
-    [SEED_KEY]: ignoredSeedKey,
-    [SEED_TIME]: ignoredSeedTime,
-    ...value
-  } = item
+  const value = { ...item }
+  delete value[SEED_KEY]
+  delete value[SEED_TIME]
   return value
 }