libp2r2p 0.5.0 → 0.7.0

package/private-messenger/index.js

@@ -3,7 +3,7 @@
 //   userSigner,
 //   contentKeySigner, // optional when userSigner handles content keys internally
 //   nymSigner: optionalDefaultNymSigner,
-//   channels: [{ signer: privateChannelSigner, relays, mode: 'leecher', seeders: optionalSeederPubkeys }],
+//   channels: [{ signer: privateChannelSigner, relays, mode: 'leecher', seeders: optionalSeederPubkeys, offlineRecoverySeconds: optionalChannelOverride }],
 //   onContentKeyChange: event => reviewContentKeyUse(event),
 //   onError: err => reportPrivateMessengerError(err)
 // })
@@ -26,10 +26,11 @@
 // await messenger.clearChannel(channelPubkey)
 //
 // Missed-message recovery:
-// - Each watched channel stores lastSeenAt/lastWatchedAt in localStorage.
+// - 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 watched for 45 days 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,9 +41,17 @@ 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,
+  maintainPrivateMessengerStorage,
+  PRIVATE_MESSENGER_STORAGE_HEARTBEAT_MS,
+  PRIVATE_MESSENGER_STORAGE_MAINTENANCE_MS,
+  releasePrivateMessengerStorage
+} from './services/storage-maintenance.js'
 import {
   compactSeedNymCarriers,
   compactSeedRouterRows,
@@ -71,6 +80,7 @@ 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 DEFAULT_OFFLINE_SKEW_SECONDS = 30
 const DEFAULT_RELOAD_GAP_DELAY_MS = 500
 const DEFAULT_SEEDER_PRESENCE_INTERVAL_MS = 10 * 60 * 1000
@@ -108,6 +118,13 @@ 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 uniq (values) {
   return [...new Set((values || []).filter(Boolean))]
 }
@@ -121,17 +138,27 @@ function isPlainObject (value) {
   return value && typeof value === 'object' && !Array.isArray(value)
 }
 
+function parseJson (raw, fallback) {
+  try { return JSON.parse(raw || '') } catch { return fallback }
+}
+
 function storesRecoverySeeds (mode) {
   return mode === 'seeder' || mode === 'watchtower'
 }
 
-function parseJson (raw, fallback) {
-  try { return JSON.parse(raw || '') } catch { return fallback }
+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 ({
@@ -159,9 +186,11 @@ 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)
   } = {}) {
-    this.offlineRecoverySeconds = offlineRecoverySeconds
+    this.offlineRecoverySeconds = normalizeOfflineRecoverySeconds(offlineRecoverySeconds)
     this.staleChannelSeconds = staleChannelSeconds
     this.offlineSkewSeconds = offlineSkewSeconds
     this.reloadGapDelayMs = reloadGapDelayMs
@@ -186,6 +215,8 @@ export class PrivateMessenger {
     this._setTimeout = _setTimeout
     this._setInterval = _setInterval
     this._clearInterval = _clearInterval
+    this._storageSetInterval = _storageSetInterval
+    this._storageClearInterval = _storageClearInterval
 
     this.userSigner = null
     this.contentKeySigner = null
@@ -195,6 +226,9 @@ export class PrivateMessenger {
     this.prefix = ''
     this.queue = null
     this.seedQueue = null
+    this.stateStore = null
+    this.state = { channels: {} }
+    this.stateWriteTail = Promise.resolve()
     this.channels = new Map()
     this.stopByChannel = new Map()
     this.presenceTimers = new Map()
@@ -204,37 +238,170 @@ 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.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',
-      indexedDB: this._indexedDB
+    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}`
+      await activatePrivateMessengerStorage({
+        userPubkey: this.userPubkey,
+        leaseId: this.storageLeaseId,
+        indexedDB: this._indexedDB
+      })
+      this.storageActive = true
+      this.lastStorageTouch = Date.now()
+      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.cleanupStaleChannels()
+      await this.update({ userSigner, contentKeySigner, nymSigner: this.nymSigner, channels, relays, mode })
+      await this.pruneStoredSeeds()
+      this.initialized = true
+      return this
+    } catch (err) {
+      this.stopStorageMaintenance()
+      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')
+  }
+
+  startStorageMaintenance () {
+    if (this.storageHeartbeatTimer || this.storageMaintenanceTimer) return
+    this.storageHeartbeatTimer = this._storageSetInterval(() => (
+      this.touchStorageActivity({ force: true }).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 = Promise.all([
+      PrivateMessenger.maintainStorage({
+        indexedDB: this._indexedDB,
+        temporaryStorageArea: this.temporaryStorageArea
+      }),
+      this.pruneStoredSeeds()
+    ]).catch(err => {
+      try { this.onError?.(err) } catch {}
+    }).finally(() => {
+      if (this.storageMaintenancePromise === maintenance) this.storageMaintenancePromise = null
     })
-    this.seedQueue = await createQueue({
-      prefix: `${this.prefix}:seeds`,
-      indexes: SEED_QUEUE_INDEXES,
-      maxBytes: this.seedQueueMaxBytes,
-      evictionPolicy: 'fifo',
-      indexedDB: this._indexedDB
+    this.storageMaintenancePromise = maintenance
+    return maintenance
+  }
+
+  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,
+      indexedDB: this._indexedDB,
+      now
+    }).then(() => true, err => {
+      this.lastStorageTouch = previousTouch
+      throw err
+    }).finally(() => {
+      if (this.storageTouchPromise === touch) this.storageTouchPromise = null
     })
-    await this.cleanupStaleChannels()
-    await this.update({ userSigner, contentKeySigner, nymSigner: this.nymSigner, channels, relays, mode })
-    return this
+    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 {}
@@ -269,6 +436,7 @@ export class PrivateMessenger {
   }
 
   async update ({ userSigner = this.userSigner, contentKeySigner = this.contentKeySigner, nymSigner = this.nymSigner, channels = [...this.channels.values()], relays = [], mode = 'leecher' } = {}) {
+    this.assertOpen()
     if (userSigner) {
       const userPubkey = await userSigner.getPublicKey?.()
       if (!userPubkey) throw new Error('USER_SIGNER_REQUIRED')
@@ -279,17 +447,19 @@ 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)
+        await this.unwatch(pubkey)
         this.channels.delete(pubkey)
       }
     }
     for (const channel of nextChannels) this.channels.set(channel.pubkey, channel)
 
     await this.cleanupStaleChannels()
+    await this.applyRecoveryPolicies(nextChannels)
     await this.watch()
     await this.reconcilePresencePublishers()
     return this
@@ -314,6 +484,9 @@ export class PrivateMessenger {
       const autoDeletionCapability = channel.autoDeletionCapability === undefined
         ? undefined
         : normalizeAutoDeletionCapability(channel.autoDeletionCapability)
+      const offlineRecoverySeconds = normalizeOfflineRecoverySeconds(
+        channel.offlineRecoverySeconds ?? this.offlineRecoverySeconds
+      )
       out.push({
         pubkey,
         signer,
@@ -325,6 +498,7 @@ export class PrivateMessenger {
         usesNip65WatchRelays: !hasChannelRelays && !hasDefaultRelays,
         mode,
         seeders: uniq(channel.seeders),
+        offlineRecoverySeconds,
         autoDeletionCapability
       })
     }
@@ -346,6 +520,7 @@ export class PrivateMessenger {
   }
 
   async recoveryMirrorRelays (channelPubkey) {
+    if (!this.offlineRecoverySecondsFor(channelPubkey)) return []
     const seeders = this.recoverySeeders(channelPubkey)
     if (!seeders.length) return []
     try {
@@ -372,18 +547,26 @@ export class PrivateMessenger {
     return { relayToReceivers: derived, recoveryRelays }
   }
 
-  stateKey () {
-    return `${this.prefix}:state`
-  }
-
   readState () {
-    const state = parseJson(localStorage.getItem(this.stateKey()), { channels: {} })
-    if (!isPlainObject(state.channels)) state.channels = {}
-    return state
+    return structuredClone(this.state)
   }
 
   writeState (state) {
-    localStorage.setItem(this.stateKey(), JSON.stringify(state))
+    this.touchStorageActivity().catch(err => this.onError?.(err))
+    const next = {
+      channels: isPlainObject(state?.channels) ? structuredClone(state.channels) : {}
+    }
+    this.state = next
+    const snapshot = structuredClone(next.channels)
+    const write = this.stateWriteTail.then(() => this.stateStore.replace(snapshot))
+    this.stateWriteTail = write.catch(err => {
+      try { this.onError?.(err) } catch {}
+    })
+    return write
+  }
+
+  async flushStateWrites () {
+    await this.stateWriteTail
   }
 
   updateChannelState (pubkey, patch) {
@@ -416,6 +599,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)
@@ -430,6 +614,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 || {}
@@ -443,6 +628,7 @@ export class PrivateMessenger {
     current.seederActivity = activity
     state.channels[channelPubkey] = current
     this.writeState(state)
+    return true
   }
 
   trackSeederActivity (channelPubkey, message) {
@@ -528,8 +714,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)
@@ -551,10 +739,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 }]))
@@ -566,11 +761,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,
@@ -588,15 +785,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,
@@ -614,12 +817,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 () {
@@ -745,6 +951,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)
@@ -801,6 +1008,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())
   }
@@ -816,7 +1024,7 @@ export class PrivateMessenger {
       privateChannelReaderPubkey: channel.readerPubkey,
       receiverPubkey,
       ...routing,
-      expirationSeconds: this.offlineRecoverySeconds,
+      expirationSeconds: this.eventExpirationSecondsFor(channel),
       temporaryStorageArea: this.temporaryStorageArea,
       deletionPubkey,
       autoDeletionCapability: this.autoDeletionCapabilityFor(channel),
@@ -842,7 +1050,7 @@ export class PrivateMessenger {
       question,
       receiverPubkey,
       ...routing,
-      expirationSeconds: this.offlineRecoverySeconds,
+      expirationSeconds: this.eventExpirationSecondsFor(channel),
       temporaryStorageArea: this.temporaryStorageArea,
       deletionPubkey,
       autoDeletionCapability: this.autoDeletionCapabilityFor(channel),
@@ -866,7 +1074,7 @@ export class PrivateMessenger {
       privateChannelReaderPubkey: channel.readerPubkey,
       receiverPubkey,
       ...routing,
-      expirationSeconds: this.offlineRecoverySeconds,
+      expirationSeconds: this.eventExpirationSecondsFor(channel),
       temporaryStorageArea: this.temporaryStorageArea,
       deletionPubkey,
       autoDeletionCapability: this.autoDeletionCapabilityFor(channel),
@@ -890,7 +1098,7 @@ export class PrivateMessenger {
       privateChannelReaderPubkey: channel.readerPubkey,
       receiverPubkeys,
       ...routing,
-      expirationSeconds: this.offlineRecoverySeconds,
+      expirationSeconds: this.eventExpirationSecondsFor(channel),
       temporaryStorageArea: this.temporaryStorageArea,
       deletionPubkey,
       autoDeletionCapability: this.autoDeletionCapabilityFor(channel),
@@ -914,7 +1122,7 @@ export class PrivateMessenger {
       privateChannelReaderPubkey: channel.readerPubkey,
       receiverPubkeys,
       ...routing,
-      expirationSeconds: this.offlineRecoverySeconds,
+      expirationSeconds: this.eventExpirationSecondsFor(channel),
       temporaryStorageArea: this.temporaryStorageArea,
       deletionPubkey,
       autoDeletionCapability: this.autoDeletionCapabilityFor(channel),
@@ -934,7 +1142,7 @@ export class PrivateMessenger {
       privateChannelReaderPubkey: channel.readerPubkey,
       receiverPubkeys,
       ...routing,
-      expirationSeconds: this.offlineRecoverySeconds,
+      expirationSeconds: this.eventExpirationSecondsFor(channel),
       temporaryStorageArea: this.temporaryStorageArea,
       deletionPubkey,
       autoDeletionCapability: this.autoDeletionCapabilityFor(channel),
@@ -953,7 +1161,7 @@ export class PrivateMessenger {
       privateChannelSigner: channel.signer,
       privateChannelReaderPubkey: channel.readerPubkey,
       ...routing,
-      expirationSeconds: this.offlineRecoverySeconds,
+      expirationSeconds: this.eventExpirationSecondsFor(channel),
       deletionPubkey,
       autoDeletionCapability: this.autoDeletionCapabilityFor(channel),
       rumor
@@ -970,7 +1178,7 @@ export class PrivateMessenger {
       privateChannelSigner: channel.signer,
       privateChannelReaderPubkey: channel.readerPubkey,
       ...routing,
-      expirationSeconds: this.offlineRecoverySeconds,
+      expirationSeconds: this.eventExpirationSecondsFor(channel),
       deletionPubkey,
       autoDeletionCapability: this.autoDeletionCapabilityFor(channel),
       event
@@ -979,6 +1187,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 })
@@ -989,7 +1198,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,
@@ -999,6 +1208,7 @@ export class PrivateMessenger {
   }
 
   async startPresencePublisher (channelPubkey) {
+    if (!this.offlineRecoverySecondsFor(channelPubkey)) return
     if (this.presenceTimers.has(channelPubkey)) return
     try {
       await this.publishSeederPresence(channelPubkey)
@@ -1023,10 +1233,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)
@@ -1060,6 +1270,53 @@ export class PrivateMessenger {
     return channel.autoDeletionCapability ?? this.autoDeletionCapability
   }
 
+  offlineRecoverySecondsFor (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)
+  }
+
+  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 seconds = channel.offlineRecoverySeconds
+        current.offlineRecoverySeconds = seconds
+        if (!seconds) {
+          delete current.openOfflineStart
+          current.offlineRanges = []
+        } else {
+          const cutoff = now - seconds
+          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')
@@ -1071,6 +1328,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
@@ -1100,6 +1358,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
@@ -1122,6 +1381,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 []
@@ -1158,11 +1418,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()
   }
@@ -1246,12 +1509,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) {
@@ -1271,7 +1536,8 @@ 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) })),
             onSeedEvent: seed => this.queueIncoming(() => this.enqueueSeed(pubkey, seed)),
@@ -1295,10 +1561,11 @@ 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)
       this.ensureRelayListWatcher()
@@ -1321,29 +1588,45 @@ export class PrivateMessenger {
         await this.seedQueue?.removeBy('byChannel', pubkey)
       }
       this.writeState(state)
+      await this.flushStateWrites()
     })
   }
 
   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
+    }
+    const recoverySeconds = this.offlineRecoverySecondsFor(channelPubkey)
+    if (!recoverySeconds) {
+      await this.seedQueue.removeBy('byChannel', channelPubkey)
       return
     }
-    if (!channelPubkey && keyRange?.upperBound) {
-      await this.seedQueue.removeBy('byTime', keyRange.upperBound(cutoff, true))
+    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
@@ -1352,6 +1635,32 @@ export class PrivateMessenger {
     this.stopOnline?.()
     this.stopOffline = null
     this.stopOnline = null
+    this.stopStorageMaintenance()
+
+    this.closePromise = (async () => {
+      let unwatchError
+      try { await unwatchPromise } catch (err) { unwatchError = err }
+      await initSettledPromise
+      await this.queueOperationTail
+      await this.stateWriteTail
+      try { await this.storageTouchPromise } catch {}
+      await this.storageMaintenancePromise
+      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 (unwatchError) throw unwatchError
+    })()
+    return this.closePromise
   }
 }
 
@@ -1432,11 +1741,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
 }