libp2r2p 0.7.0 → 0.9.0

package/private-messenger/index.js

@@ -3,6 +3,8 @@
 //   userSigner,
 //   contentKeySigner, // optional when userSigner handles content keys internally
 //   nymSigner: optionalDefaultNymSigner,
+//   staleChannelSeconds: optionalStaleChannelRetention,
+//   identityStorageRetentionSeconds: optionalIdentityStorageRetention,
 //   channels: [{ signer: privateChannelSigner, relays, mode: 'leecher', seeders: optionalSeederPubkeys, offlineRecoverySeconds: optionalChannelOverride }],
 //   onContentKeyChange: event => reviewContentKeyUse(event),
 //   onError: err => reportPrivateMessengerError(err)
@@ -30,7 +32,7 @@
 // - Re-watching after reload fetches the gap from lastSeenAt to now.
 // - Browser offline/online events add explicit offline ranges with a small skew.
 // - Recovery defaults to 7 days and can be overridden per channel; zero disables durable recovery.
-// - Channel state not watched for 45 days is pruned.
+// - 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.
@@ -39,6 +41,7 @@
 
 import * as privateMessage from '../private-message/index.js'
 import { bytesToBase64 } from '../base64/index.js'
+import { ValidationError } from '../error/index.js'
 import { getRelaysByPubkey, pickRelaysForPubkeys, subscribeRelayListUpdates } from '../relay/index.js'
 import * as privateChannel from '../private-channel/index.js'
 import { DEFAULT_RECEIVED_CHUNK_TTL_MS } from '../private-channel/services/received-chunks.js'
@@ -47,9 +50,11 @@ 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 {
@@ -66,6 +71,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,
@@ -81,6 +87,7 @@ export {
 
 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
@@ -120,7 +127,21 @@ function nowSeconds () {
 
 function normalizeOfflineRecoverySeconds (value) {
   if (!Number.isSafeInteger(value) || value < 0 || value > MAX_OFFLINE_RECOVERY_SECONDS) {
-    throw new Error('INVALID_OFFLINE_RECOVERY_SECONDS')
+    throw new ValidationError('INVALID_OFFLINE_RECOVERY_SECONDS')
+  }
+  return value
+}
+
+function normalizeStaleChannelSeconds (value) {
+  if (!Number.isSafeInteger(value) || value < 0 || value > MAX_OFFLINE_RECOVERY_SECONDS) {
+    throw new ValidationError('INVALID_STALE_CHANNEL_SECONDS')
+  }
+  return value
+}
+
+function normalizeIdentityStorageRetentionSeconds (value) {
+  if (!Number.isSafeInteger(value) || value < 0 || value > MAX_OFFLINE_RECOVERY_SECONDS) {
+    throw new ValidationError('INVALID_IDENTITY_STORAGE_RETENTION_SECONDS')
   }
   return value
 }
@@ -130,7 +151,7 @@ function uniq (values) {
 }
 
 function normalizeAutoDeletionCapability (value) {
-  if (typeof value !== 'boolean') throw new Error('AUTO_DELETION_CAPABILITY_BOOLEAN_REQUIRED')
+  if (typeof value !== 'boolean') throw new ValidationError('AUTO_DELETION_CAPABILITY_BOOLEAN_REQUIRED')
   return value
 }
 
@@ -142,7 +163,11 @@ function parseJson (raw, fallback) {
   try { return JSON.parse(raw || '') } catch { return fallback }
 }
 
-function storesRecoverySeeds (mode) {
+function areStateValuesEqual (left, right) {
+  return JSON.stringify(left) === JSON.stringify(right)
+}
+
+function doesModeStoreRecoverySeeds (mode) {
   return mode === 'seeder' || mode === 'watchtower'
 }
 
@@ -164,6 +189,7 @@ export class PrivateMessenger {
   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,
@@ -188,10 +214,12 @@ export class PrivateMessenger {
     _setInterval = globalThis.setInterval.bind(globalThis),
     _clearInterval = globalThis.clearInterval.bind(globalThis),
     _storageSetInterval = globalThis.setInterval.bind(globalThis),
-    _storageClearInterval = globalThis.clearInterval.bind(globalThis)
+    _storageClearInterval = globalThis.clearInterval.bind(globalThis),
+    _BroadcastChannel = _indexedDB === globalThis.indexedDB ? globalThis.BroadcastChannel : undefined
   } = {}) {
     this.offlineRecoverySeconds = normalizeOfflineRecoverySeconds(offlineRecoverySeconds)
-    this.staleChannelSeconds = staleChannelSeconds
+    this.staleChannelSeconds = normalizeStaleChannelSeconds(staleChannelSeconds)
+    this.identityStorageRetentionSeconds = normalizeIdentityStorageRetentionSeconds(identityStorageRetentionSeconds)
     this.offlineSkewSeconds = offlineSkewSeconds
     this.reloadGapDelayMs = reloadGapDelayMs
     this.seederPresenceIntervalMs = seederPresenceIntervalMs
@@ -217,6 +245,7 @@ export class PrivateMessenger {
     this._clearInterval = _clearInterval
     this._storageSetInterval = _storageSetInterval
     this._storageClearInterval = _storageClearInterval
+    this._BroadcastChannel = _BroadcastChannel
 
     this.userSigner = null
     this.contentKeySigner = null
@@ -245,13 +274,17 @@ export class PrivateMessenger {
     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')
+    if (!userSigner?.getPublicKey) throw new ValidationError('USER_SIGNER_REQUIRED')
     this.assertOpen()
     if (this.initSettledPromise) throw new Error('PRIVATE_MESSENGER_INIT_IN_PROGRESS')
     if (this.initialized) throw new Error('PRIVATE_MESSENGER_ALREADY_INITIALIZED')
@@ -264,13 +297,20 @@ export class PrivateMessenger {
       this.nymSigner = nymSigner || null
       this.userPubkey = await userSigner.getPublicKey()
       this.prefix = `libp2r2p:private-messenger:${this.userPubkey}`
-      await activatePrivateMessengerStorage({
+      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,
@@ -302,13 +342,15 @@ export class PrivateMessenger {
       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
+      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([
@@ -338,10 +380,102 @@ export class PrivateMessenger {
     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.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.storagePolicyRefreshTail = refresh
+    return refresh
+  }
+
   startStorageMaintenance () {
     if (this.storageHeartbeatTimer || this.storageMaintenanceTimer) return
     this.storageHeartbeatTimer = this._storageSetInterval(() => (
-      this.touchStorageActivity({ force: true }).catch(err => {
+      this.runStorageHeartbeat().catch(err => {
         try { this.onError?.(err) } catch {}
       })
     ), PRIVATE_MESSENGER_STORAGE_HEARTBEAT_MS)
@@ -362,13 +496,15 @@ export class PrivateMessenger {
 
   runStorageMaintenance () {
     if (this.storageMaintenancePromise) return this.storageMaintenancePromise
-    const maintenance = Promise.all([
-      PrivateMessenger.maintainStorage({
+    const maintenance = (async () => {
+      await PrivateMessenger.maintainStorage({
         indexedDB: this._indexedDB,
         temporaryStorageArea: this.temporaryStorageArea
-      }),
-      this.pruneStoredSeeds()
-    ]).catch(err => {
+      })
+      await this.refreshAndApplyStoragePolicy()
+      await this.cleanupStaleChannels()
+      await this.pruneStoredSeeds()
+    })().catch(err => {
       try { this.onError?.(err) } catch {}
     }).finally(() => {
       if (this.storageMaintenancePromise === maintenance) this.storageMaintenancePromise = null
@@ -377,6 +513,12 @@ export class PrivateMessenger {
     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
@@ -387,9 +529,13 @@ export class PrivateMessenger {
     const touch = activatePrivateMessengerStorage({
       userPubkey: this.userPubkey,
       leaseId: this.storageLeaseId,
+      activeChannelPubkeys: [...this.channels.keys()],
       indexedDB: this._indexedDB,
       now
-    }).then(() => true, err => {
+    }).then(snapshot => {
+      this.applyStoragePolicySnapshot(snapshot)
+      return true
+    }, err => {
       this.lastStorageTouch = previousTouch
       throw err
     }).finally(() => {
@@ -435,12 +581,28 @@ 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')
-      if (this.userPubkey && userPubkey !== this.userPubkey) throw new Error('USER_SIGNER_MISMATCH')
+      if (!userPubkey) throw new ValidationError('USER_SIGNER_REQUIRED')
+      if (this.userPubkey && userPubkey !== this.userPubkey) throw new ValidationError('USER_SIGNER_MISMATCH')
       this.userSigner = userSigner
     }
     this.contentKeySigner = contentKeySigner || null
@@ -449,19 +611,48 @@ export class PrivateMessenger {
     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)) {
-        await 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
   }
 
@@ -476,10 +667,10 @@ export class PrivateMessenger {
       const hasChannelSendRelays = Boolean(channel.sendRelays?.length)
       const hasDefaultRelays = Boolean(defaults.relays?.length)
       const pubkey = channel.pubkey || await signer?.getPublicKey?.()
-      if (!pubkey) throw new Error('CHANNEL_PUBKEY_REQUIRED')
-      if (!signer && !readerSigner) throw new Error('CHANNEL_SIGNER_REQUIRED')
+      if (!pubkey) throw new ValidationError('CHANNEL_PUBKEY_REQUIRED')
+      if (!signer && !readerSigner) throw new ValidationError('CHANNEL_SIGNER_REQUIRED')
       const mode = channel.mode || defaults.mode || 'leecher'
-      if (!signer && storesRecoverySeeds(mode)) throw new Error('PRIVATE_CHANNEL_WRITER_REQUIRED')
+      if (!signer && doesModeStoreRecoverySeeds(mode)) throw new ValidationError('PRIVATE_CHANNEL_WRITER_REQUIRED')
       const readerPubkey = channel.readerPubkey || channel.privateChannelReaderPubkey || await readerSigner?.getPublicKey?.() || pubkey
       const autoDeletionCapability = channel.autoDeletionCapability === undefined
         ? undefined
@@ -543,7 +734,7 @@ export class PrivateMessenger {
     if (channel.sendRelays.length) return { relays: channel.sendRelays, recoveryRelays }
     if (channel.relays.length) return { relays: channel.relays, recoveryRelays }
     const derived = await this.readRelayToReceivers(receiverPubkeys)
-    if (!relayMapRelays(derived).length) throw new Error('NO_RELAYS')
+    if (!relayMapRelays(derived).length) throw new ValidationError('NO_RELAYS')
     return { relayToReceivers: derived, recoveryRelays }
   }
 
@@ -551,14 +742,19 @@ export class PrivateMessenger {
     return structuredClone(this.state)
   }
 
-  writeState (state) {
-    this.touchStorageActivity().catch(err => this.onError?.(err))
+  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]) => !areStateValuesEqual(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 {}
     })
@@ -569,6 +765,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] || {}
@@ -578,9 +797,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()) {
@@ -765,7 +994,7 @@ export class PrivateMessenger {
     const channelPubkeys = uniq(channels)
     for (const pubkey of channelPubkeys) {
       const channel = this.channels.get(pubkey)
-      if (!channel) throw new Error('UNKNOWN_CHANNEL')
+      if (!channel) throw new ValidationError('UNKNOWN_CHANNEL')
       const watchRelays = await this.resolveWatchRelays(channel)
       this.assertOpen()
       const stop = await this._privateMessage.watch({
@@ -879,7 +1108,7 @@ export class PrivateMessenger {
 
   async handleAsk (channelPubkey, message) {
     this.trackSeederActivity(channelPubkey, message)
-    if (storesRecoverySeeds(this.channels.get(channelPubkey)?.mode) && messageCode(message) === MISSING_MESSAGES_ASK_CODE) {
+    if (doesModeStoreRecoverySeeds(this.channels.get(channelPubkey)?.mode) && messageCode(message) === MISSING_MESSAGES_ASK_CODE) {
       await this.replyWithStoredSeeds(channelPubkey, message)
       return
     }
@@ -1233,10 +1462,10 @@ export class PrivateMessenger {
   async reconcilePresencePublishers () {
     const starts = []
     for (const pubkey of [...this.presenceTimers.keys()]) {
-      if (!storesRecoverySeeds(this.channels.get(pubkey)?.mode) || !this.offlineRecoverySecondsFor(pubkey)) this.stopPresencePublisher(pubkey)
+      if (!doesModeStoreRecoverySeeds(this.channels.get(pubkey)?.mode) || !this.offlineRecoverySecondsFor(pubkey)) this.stopPresencePublisher(pubkey)
     }
     for (const [pubkey, channel] of this.channels) {
-      if (storesRecoverySeeds(channel.mode) && this.offlineRecoverySecondsFor(channel)) starts.push(this.startPresencePublisher(pubkey))
+      if (doesModeStoreRecoverySeeds(channel.mode) && this.offlineRecoverySecondsFor(channel)) starts.push(this.startPresencePublisher(pubkey))
       else this.stopPresencePublisher(pubkey)
     }
     await Promise.all(starts)
@@ -1256,13 +1485,13 @@ export class PrivateMessenger {
 
   requireChannel (pubkey) {
     const channel = this.channels.get(pubkey)
-    if (!channel) throw new Error('UNKNOWN_CHANNEL')
+    if (!channel) throw new ValidationError('UNKNOWN_CHANNEL')
     return channel
   }
 
   requireWritableChannel (pubkey) {
     const channel = this.requireChannel(pubkey)
-    if (!channel.signer) throw new Error('PRIVATE_CHANNEL_WRITER_REQUIRED')
+    if (!channel.signer) throw new ValidationError('PRIVATE_CHANNEL_WRITER_REQUIRED')
     return channel
   }
 
@@ -1270,7 +1499,7 @@ export class PrivateMessenger {
     return channel.autoDeletionCapability ?? this.autoDeletionCapability
   }
 
-  offlineRecoverySecondsFor (channelOrPubkey) {
+  requestedOfflineRecoverySecondsFor (channelOrPubkey) {
     const channel = typeof channelOrPubkey === 'string'
       ? this.channels.get(channelOrPubkey)
       : channelOrPubkey
@@ -1282,6 +1511,18 @@ export class PrivateMessenger {
       : 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
   }
@@ -1297,13 +1538,14 @@ export class PrivateMessenger {
       const now = nowSeconds()
       for (const channel of channels) {
         const current = state.channels[channel.pubkey] || {}
-        const seconds = channel.offlineRecoverySeconds
-        current.offlineRecoverySeconds = seconds
-        if (!seconds) {
+        const requestedSeconds = channel.offlineRecoverySeconds
+        const effectiveSeconds = this.offlineRecoverySecondsFor(channel)
+        current.offlineRecoverySeconds = requestedSeconds
+        if (!effectiveSeconds) {
           delete current.openOfflineStart
           current.offlineRanges = []
         } else {
-          const cutoff = now - seconds
+          const cutoff = now - effectiveSeconds
           current.offlineRanges = mergeRanges((current.offlineRanges || [])
             .filter(range => range.end >= cutoff)
             .map(range => ({ ...range, start: Math.max(range.start, cutoff) })))
@@ -1319,7 +1561,7 @@ export class PrivateMessenger {
 
   requireNymSigner (channel, override) {
     const signer = override || channel?.nymSigner || this.nymSigner
-    if (!signer?.getPublicKey) throw new Error('NYM_SIGNER_REQUIRED')
+    if (!signer?.getPublicKey) throw new ValidationError('NYM_SIGNER_REQUIRED')
     return signer
   }
 
@@ -1463,7 +1705,7 @@ export class PrivateMessenger {
 
     const routerRecord = record?.recordType === ROUTER_SEED_RECORD_TYPE ? record.router : null
     if (!isPrivateChannelRouter(routerRecord)) return null
-    if (!this._privateChannel.unwrapEvent) throw new Error('PRIVATE_CHANNEL_UNWRAP_UNSUPPORTED')
+    if (!this._privateChannel.unwrapEvent) throw new ValidationError('PRIVATE_CHANNEL_UNWRAP_UNSUPPORTED')
 
     const channel = this.requireChannel(channelPubkey)
     const router = {
@@ -1568,6 +1810,7 @@ export class PrivateMessenger {
       await this.flushStateWrites()
       await this.queue.removeBy('byChannel', pubkey)
       await this.seedQueue.removeBy('byChannel', pubkey)
+      await this.touchStorageActivity({ force: true })
       this.ensureRelayListWatcher()
     })
   }
@@ -1576,19 +1819,26 @@ 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)
     })
   }
 
@@ -1636,15 +1886,18 @@ export class PrivateMessenger {
     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?.(),
@@ -1658,6 +1911,12 @@ export class PrivateMessenger {
         })
       }
       this.storageActive = false
+      if (this.identityStorageRetentionSeconds === 0) {
+        await PrivateMessenger.maintainStorage({
+          indexedDB: this._indexedDB,
+          temporaryStorageArea: this.temporaryStorageArea
+        })
+      }
       if (unwatchError) throw unwatchError
     })()
     return this.closePromise