libp2r2p 0.5.0 → 0.7.0

package/private-channel/services/received-chunks.js

@@ -1,34 +1,118 @@
-import { base64ToBytes, bytesToBase64 } from '../../base64/index.js'
-import { JSONL_CHUNK_BYTES } from '../helpers/chunk-size.js'
+import { bytesToBase64 } from '../../base64/index.js'
+import { run } from '../../idb/index.js'
 
 export const DEFAULT_RECEIVED_CHUNK_TTL_MS = 60 * 60 * 1000 // 1 hour
-// For illustration purposes: A 280-character rumor would take approximately
-// 23 chunks (~0.65 MiB) to be sent if encrypted to 1000 participants.
-export const DEFAULT_RECEIVED_CHUNK_MAX_BYTES = Math.min(JSONL_CHUNK_BYTES * 64, 3 * 1024 * 1024 /* 3 MiB cap */)
+export const DEFAULT_RECEIVED_CHUNK_MAX_BYTES = 16 * 1024 * 1024 // 16 MiB
 
 const DEFAULT_PREFIX = 'libp2r2p:private-channel:received'
-const encoder = new TextEncoder()
+const DATABASE_VERSION = 2
+const GROUPS_STORE = 'groups'
+const CHUNKS_STORE = 'chunks'
+const STATE_STORE = 'state'
+const USAGE_KEY = 'usage'
+const DRAIN_LEASE_MS = 30_000
 const decoder = new TextDecoder()
 
-// Receive buffers survive reloads briefly, unlike send-side temporary chunks.
-// Stale cleanup handles peers that never publish the remaining chunks.
+/*
+IndexedDB schema, scoped per received-chunk prefix:
+
+database `${prefix}:idb`, version 2
+
+groups, keyPath "groupKey"
+  groupKey                  `${channelPubkey}:${routerPubkey}`
+  channelPubkey/routerPubkey private-channel coordinates
+  total                     expected chunk count
+  received/receivedCount    sparse received-index map and its count
+  nextIndex/rowIndex/carry  incremental payload decoding state
+  payloadCiphertext         accumulated encrypted payload text
+  receiverPubkeys           deduplicated intended receivers
+  byteSize                  logical bytes charged to this group
+  createdAt/updatedAt        lifecycle timestamps in milliseconds
+  ttlMs/expiresAt            group-specific retention and absolute expiry
+  drainToken/drainUntil      optional drain lease owner and expiry
+
+groups indexes
+  byUpdatedAt  updatedAt
+  byExpiresAt  expiresAt
+
+chunks, keyPath ["groupKey", "index"]
+  groupKey  owning group coordinate
+  index     zero-based chunk position
+  bytes     raw chunk bytes stored as Uint8Array
+
+chunks indexes
+  byGroup  groupKey
+
+state, keyPath "key"
+  key        state record name, currently "usage"
+  usedBytes  total logical bytes held by all groups
+*/
+
+function deferred () {
+  let resolve
+  let reject
+  const promise = new Promise((nextResolve, nextReject) => {
+    resolve = nextResolve
+    reject = nextReject
+  })
+  return { promise, resolve, reject }
+}
+
+function transactionDone (tx) {
+  const p = deferred()
+  tx.oncomplete = () => p.resolve()
+  tx.onabort = () => p.reject(tx.error || new Error('IDB_TRANSACTION_ABORTED'))
+  tx.onerror = () => p.reject(tx.error || new Error('IDB_TRANSACTION_FAILED'))
+  return p.promise
+}
+
+function openDatabase (indexedDB, name) {
+  if (!indexedDB?.open) return Promise.reject(new Error('IDB_UNAVAILABLE'))
+  return new Promise((resolve, reject) => {
+    const request = indexedDB.open(name, DATABASE_VERSION)
+    request.onerror = () => reject(request.error || new Error('IDB_OPEN_FAILED'))
+    request.onblocked = () => reject(new Error('IDB_DATABASE_BLOCKED'))
+    request.onupgradeneeded = () => {
+      const db = request.result
+      const tx = request.transaction
+      let groups
+      if (!db.objectStoreNames.contains(GROUPS_STORE)) {
+        groups = db.createObjectStore(GROUPS_STORE, { keyPath: 'groupKey' })
+      } else {
+        groups = tx.objectStore(GROUPS_STORE)
+      }
+      if (!groups.indexNames.contains('byUpdatedAt')) groups.createIndex('byUpdatedAt', 'updatedAt')
+      if (!groups.indexNames.contains('byExpiresAt')) groups.createIndex('byExpiresAt', 'expiresAt')
+
+      let chunks
+      if (!db.objectStoreNames.contains(CHUNKS_STORE)) {
+        chunks = db.createObjectStore(CHUNKS_STORE, { keyPath: ['groupKey', 'index'] })
+      } else {
+        chunks = tx.objectStore(CHUNKS_STORE)
+      }
+      if (!chunks.indexNames.contains('byGroup')) chunks.createIndex('byGroup', 'groupKey')
 
-function byteLength (value) {
-  return encoder.encode(String(value)).length
+      if (!db.objectStoreNames.contains(STATE_STORE)) db.createObjectStore(STATE_STORE, { keyPath: 'key' })
+    }
+    request.onsuccess = () => {
+      const db = request.result
+      db.onversionchange = () => db.close()
+      resolve(db)
+    }
+  })
 }
 
-function parseJson (raw, fallback) {
-  try { return JSON.parse(raw || '') } catch { return fallback }
+function normalizeBytes (value) {
+  if (value instanceof Uint8Array) return new Uint8Array(value)
+  if (value instanceof ArrayBuffer) return new Uint8Array(value)
+  if (ArrayBuffer.isView(value)) return new Uint8Array(value.buffer, value.byteOffset, value.byteLength)
+  throw new Error('RECEIVED_CHUNK_BYTES_REQUIRED')
 }
 
 function uniq (values) {
   return [...new Set((values || []).filter(Boolean))]
 }
 
-function normalizeGroupKeys (value) {
-  return Array.isArray(value) ? uniq(value.filter(key => typeof key === 'string' && key)) : []
-}
-
 function normalizeReceived (received) {
   if (!received || typeof received !== 'object' || Array.isArray(received)) return {}
   return Object.fromEntries(
@@ -38,14 +122,16 @@ function normalizeReceived (received) {
   )
 }
 
-function normalizeMeta (meta, groupKey) {
+function normalizeMeta (meta, fallbackTtlMs = DEFAULT_RECEIVED_CHUNK_TTL_MS) {
   if (!meta || typeof meta !== 'object') return null
   const total = Number(meta.total)
   const nextIndex = Number(meta.nextIndex)
   const rowIndex = Number(meta.rowIndex)
-  if (!Number.isSafeInteger(total) || total < 1) return null
+  if (!meta.groupKey || !Number.isSafeInteger(total) || total < 1) return null
+  const updatedAt = Number(meta.updatedAt) || Date.now()
+  const ttlMs = Number.isFinite(meta.ttlMs) && meta.ttlMs >= 0 ? meta.ttlMs : fallbackTtlMs
   return {
-    groupKey,
+    groupKey: String(meta.groupKey),
     channelPubkey: String(meta.channelPubkey || ''),
     routerPubkey: String(meta.routerPubkey || ''),
     total,
@@ -55,10 +141,21 @@ function normalizeMeta (meta, groupKey) {
     rowIndex: Number.isSafeInteger(rowIndex) && rowIndex >= 0 ? rowIndex : 0,
     carry: typeof meta.carry === 'string' ? meta.carry : '',
     payloadCiphertext: typeof meta.payloadCiphertext === 'string' ? meta.payloadCiphertext : '',
-    receiverPubkeys: uniq(meta.receiverPubkeys || []),
+    receiverPubkeys: uniq(meta.receiverPubkeys),
     byteSize: Math.max(0, Number(meta.byteSize) || 0),
     createdAt: Number(meta.createdAt) || Date.now(),
-    updatedAt: Number(meta.updatedAt) || Date.now()
+    updatedAt,
+    ttlMs,
+    expiresAt: Number(meta.expiresAt) || updatedAt + ttlMs,
+    drainToken: typeof meta.drainToken === 'string' ? meta.drainToken : '',
+    drainUntil: Math.max(0, Number(meta.drainUntil) || 0)
+  }
+}
+
+function normalizeUsage (value) {
+  return {
+    key: USAGE_KEY,
+    usedBytes: Number.isSafeInteger(value?.usedBytes) && value.usedBytes >= 0 ? value.usedBytes : 0
   }
 }
 
@@ -70,217 +167,228 @@ function isQuotaExceeded (err) {
     /quota/i.test(err?.message || '')
 }
 
-function joinBase64Chunks (parts) {
-  let out = ''
-  let carry = new Uint8Array()
-
-  for (const part of parts) {
-    const bytes = base64ToBytes(part)
-    const joined = new Uint8Array(carry.length + bytes.length)
-    joined.set(carry)
-    joined.set(bytes, carry.length)
-
-    const completeLength = joined.length - (joined.length % 3)
-    if (completeLength) out += bytesToBase64(joined.slice(0, completeLength))
-    carry = joined.slice(completeLength)
-  }
+function randomToken () {
+  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(16)}:${Math.random().toString(16).slice(2)}`
+}
 
-  if (carry.length) out += bytesToBase64(carry)
-  return out
+function wait (ms) {
+  return new Promise(resolve => setTimeout(resolve, ms))
 }
 
 export function createReceivedChunkStore ({
   prefix = DEFAULT_PREFIX,
-  storageArea = globalThis.localStorage,
+  indexedDB = globalThis.indexedDB,
   ttlMs = DEFAULT_RECEIVED_CHUNK_TTL_MS,
   maxBytes = DEFAULT_RECEIVED_CHUNK_MAX_BYTES
 } = {}) {
-  const groupsKey = `${prefix}:groups`
   const configuredTtlMs = Number.isFinite(ttlMs) && ttlMs >= 0 ? ttlMs : DEFAULT_RECEIVED_CHUNK_TTL_MS
   const configuredMaxBytes = Number.isFinite(maxBytes) && maxBytes > 0 ? maxBytes : Infinity
-
-  function storage () {
-    return storageArea
-  }
-
-  function metaKey (groupKey) {
-    return `${prefix}:group:${groupKey}:meta`
+  let dbPromise
+  let readyPromise
+  let closed = false
+
+  function database () {
+    if (closed) return Promise.reject(new Error('RECEIVED_CHUNK_STORE_CLOSED'))
+    dbPromise ||= openDatabase(indexedDB, `${prefix}:idb`)
+    return dbPromise.then(db => {
+      if (closed) {
+        db.close()
+        throw new Error('RECEIVED_CHUNK_STORE_CLOSED')
+      }
+      return db
+    })
   }
 
-  function chunkKey (groupKey, index) {
-    return `${prefix}:group:${groupKey}:chunk:${index}`
+  async function transaction (storeNames, mode, work) {
+    const db = await database()
+    const tx = db.transaction(storeNames, mode)
+    const done = transactionDone(tx)
+    try {
+      // `work` may await only IDB requests issued through `run` with this tx.
+      const result = await work(tx)
+      await done
+      return result
+    } catch (err) {
+      try { tx.abort() } catch {}
+      try { await done } catch {}
+      throw err
+    }
   }
 
   function groupKeyFor (channelPubkey, routerPubkey) {
     return `${channelPubkey}:${routerPubkey}`
   }
 
-  function readGroupKeys () {
-    return normalizeGroupKeys(parseJson(storage().getItem(groupsKey), []))
-  }
-
-  function writeGroupKeys (keys) {
-    const normalized = normalizeGroupKeys(keys)
-    if (normalized.length) storage().setItem(groupsKey, JSON.stringify(normalized))
-    else storage().removeItem(groupsKey)
+  async function readUsage (tx) {
+    return normalizeUsage((await run('get', [USAGE_KEY], STATE_STORE, null, { tx })).result)
   }
 
-  function addGroupKey (groupKey) {
-    const keys = readGroupKeys()
-    if (!keys.includes(groupKey)) writeGroupKeys(keys.concat(groupKey))
+  async function writeUsage (tx, usage) {
+    await run('put', [normalizeUsage(usage)], STATE_STORE, null, { tx })
   }
 
-  function removeGroupKey (groupKey) {
-    writeGroupKeys(readGroupKeys().filter(key => key !== groupKey))
+  async function deleteGroupInTransaction (tx, groupKey, usage, knownMeta) {
+    const meta = knownMeta || normalizeMeta((await run('get', [groupKey], GROUPS_STORE, null, { tx })).result, configuredTtlMs)
+    const keys = (await run('getAllKeys', [globalThis.IDBKeyRange?.only?.(groupKey) ?? groupKey], CHUNKS_STORE, 'byGroup', { tx })).result
+    for (const key of keys) await run('delete', [key], CHUNKS_STORE, null, { tx })
+    await run('delete', [groupKey], GROUPS_STORE, null, { tx })
+    if (usage && meta) usage.usedBytes = Math.max(0, usage.usedBytes - meta.byteSize)
+    return Boolean(meta || keys.length)
   }
 
-  function readMeta (groupKey) {
-    return normalizeMeta(parseJson(storage().getItem(metaKey(groupKey)), null), groupKey)
+  async function oldestGroupsInTransaction (tx, except = '') {
+    const values = (await run('getAll', [], GROUPS_STORE, null, { tx })).result
+    return values
+      .map(value => normalizeMeta(value, configuredTtlMs))
+      .filter(meta => meta && meta.groupKey !== except)
+      .sort((left, right) => left.updatedAt - right.updatedAt || left.groupKey.localeCompare(right.groupKey))
   }
 
-  function writeMeta (meta) {
-    storage().setItem(metaKey(meta.groupKey), JSON.stringify(meta))
-  }
-
-  function removeGroup (groupKey) {
-    const meta = readMeta(groupKey)
-    if (meta) {
-      for (const index of Object.keys(meta.received)) {
-        storage().removeItem(chunkKey(groupKey, index))
+  async function cleanupStaleRaw (nowMs = Date.now()) {
+    return transaction([GROUPS_STORE, CHUNKS_STORE, STATE_STORE], 'readwrite', async tx => {
+      const usage = await readUsage(tx)
+      const groups = await oldestGroupsInTransaction(tx)
+      let removed = 0
+      for (const meta of groups) {
+        if (meta.expiresAt > nowMs && (!Number.isFinite(configuredMaxBytes) || usage.usedBytes <= configuredMaxBytes)) continue
+        await deleteGroupInTransaction(tx, meta.groupKey, usage, meta)
+        removed++
       }
-    }
-    storage().removeItem(metaKey(groupKey))
-    removeGroupKey(groupKey)
-  }
-
-  function allMetas () {
-    const keys = readGroupKeys()
-    const metas = []
-    const liveKeys = []
-    for (const groupKey of keys) {
-      const meta = readMeta(groupKey)
-      if (!meta) continue
-      metas.push(meta)
-      liveKeys.push(groupKey)
-    }
-    if (liveKeys.length !== keys.length) writeGroupKeys(liveKeys)
-    return metas
+      await writeUsage(tx, usage)
+      return removed
+    })
   }
 
-  function totalStoredBytes () {
-    return allMetas().reduce((total, meta) => {
-      return total + meta.byteSize + byteLength(JSON.stringify(meta))
-    }, 0)
+  function ready (nowMs = Date.now()) {
+    readyPromise ||= cleanupStaleRaw(nowMs)
+    return readyPromise
   }
 
-  function oldestGroupKey ({ except } = {}) {
-    return allMetas()
-      .filter(meta => meta.groupKey !== except)
-      .sort((a, b) => a.updatedAt - b.updatedAt)[0]?.groupKey || ''
+  async function cleanupStale (nowMs = Date.now()) {
+    await ready(nowMs)
+    return cleanupStaleRaw(nowMs)
   }
 
-  function evictOldestUntilFits (requiredBytes = 0, { except } = {}) {
-    if (!Number.isFinite(configuredMaxBytes)) return
-    while (totalStoredBytes() + requiredBytes > configuredMaxBytes) {
-      const groupKey = oldestGroupKey({ except })
-      if (!groupKey) break
-      removeGroup(groupKey)
-    }
-  }
+  async function putOnce ({ channelPubkey, routerPubkey, index, total, contentBytes, ttlMs }) {
+    const groupKey = groupKeyFor(channelPubkey, routerPubkey)
+    const bytes = normalizeBytes(contentBytes)
+    const now = Date.now()
+    const groupTtlMs = Number.isFinite(ttlMs) && ttlMs >= 0 ? ttlMs : configuredTtlMs
+
+    return transaction([GROUPS_STORE, CHUNKS_STORE, STATE_STORE], 'readwrite', async tx => {
+      const usage = await readUsage(tx)
+      let meta = normalizeMeta((await run('get', [groupKey], GROUPS_STORE, null, { tx })).result, configuredTtlMs)
+      if (meta && meta.expiresAt <= now) {
+        await deleteGroupInTransaction(tx, groupKey, usage, meta)
+        meta = null
+      }
+      if (meta && meta.total !== total) {
+        await deleteGroupInTransaction(tx, groupKey, usage, meta)
+        meta = null
+      }
+      if (!meta) {
+        meta = normalizeMeta({
+          groupKey,
+          channelPubkey,
+          routerPubkey,
+          total,
+          received: {},
+          receivedCount: 0,
+          nextIndex: 0,
+          rowIndex: 0,
+          carry: '',
+          payloadCiphertext: '',
+          receiverPubkeys: [],
+          byteSize: 0,
+          createdAt: now,
+          updatedAt: now,
+          ttlMs: groupTtlMs,
+          expiresAt: now + groupTtlMs
+        }, configuredTtlMs)
+      }
 
-  function writeChunk (key, value, requiredBytes, except) {
-    evictOldestUntilFits(requiredBytes, { except })
-    try {
-      storage().setItem(key, value)
-      return
-    } catch (err) {
-      if (!isQuotaExceeded(err)) throw err
-    }
+      const existing = (await run('get', [[groupKey, index]], CHUNKS_STORE, null, { tx })).result
+      if (!existing) {
+        if (bytes.byteLength > configuredMaxBytes || meta.byteSize + bytes.byteLength > configuredMaxBytes) {
+          await deleteGroupInTransaction(tx, groupKey, usage, meta)
+          await writeUsage(tx, usage)
+          return { tooLarge: true, meta: null }
+        }
 
-    let groupKey = oldestGroupKey({ except })
-    while (groupKey) {
-      removeGroup(groupKey)
-      try {
-        storage().setItem(key, value)
-        return
-      } catch (err) {
-        if (!isQuotaExceeded(err)) throw err
+        const requiredBytes = bytes.byteLength
+        const candidates = await oldestGroupsInTransaction(tx, groupKey)
+        for (const candidate of candidates) {
+          if (candidate.expiresAt > now) continue
+          await deleteGroupInTransaction(tx, candidate.groupKey, usage, candidate)
+        }
+        for (const candidate of candidates) {
+          if (candidate.expiresAt <= now) continue
+          if (!Number.isFinite(configuredMaxBytes) || usage.usedBytes + requiredBytes <= configuredMaxBytes) break
+          await deleteGroupInTransaction(tx, candidate.groupKey, usage, candidate)
+        }
+        if (Number.isFinite(configuredMaxBytes) && usage.usedBytes + requiredBytes > configuredMaxBytes) {
+          await deleteGroupInTransaction(tx, groupKey, usage, meta)
+          await writeUsage(tx, usage)
+          return { tooLarge: true, meta: null }
+        }
+
+        await run('put', [{ groupKey, index, bytes }], CHUNKS_STORE, null, { tx })
+        meta.received[String(index)] = true
+        meta.receivedCount++
+        meta.byteSize += requiredBytes
+        usage.usedBytes += requiredBytes
       }
-      groupKey = oldestGroupKey({ except })
-    }
 
-    storage().setItem(key, value)
+      meta.total = total
+      meta.updatedAt = now
+      meta.expiresAt = now + meta.ttlMs
+      await run('put', [meta], GROUPS_STORE, null, { tx })
+      await writeUsage(tx, usage)
+      return { tooLarge: false, meta }
+    })
   }
 
-  function cleanupStale (nowMs = Date.now()) {
-    const cutoff = nowMs - configuredTtlMs
-    for (const meta of allMetas()) {
-      if (meta.updatedAt <= cutoff) removeGroup(meta.groupKey)
-    }
-    evictOldestUntilFits(0)
+  async function evictOldestGroup (except = '') {
+    return transaction([GROUPS_STORE, CHUNKS_STORE, STATE_STORE], 'readwrite', async tx => {
+      const usage = await readUsage(tx)
+      const oldest = (await oldestGroupsInTransaction(tx, except))[0]
+      if (!oldest) return false
+      await deleteGroupInTransaction(tx, oldest.groupKey, usage, oldest)
+      await writeUsage(tx, usage)
+      return true
+    })
   }
 
-  function put ({ channelPubkey, routerPubkey, index, total, content }) {
+  async function put ({ channelPubkey, routerPubkey, index, total, contentBytes, ttlMs }) {
     if (!channelPubkey || !routerPubkey) throw new Error('RECEIVED_CHUNK_GROUP_REQUIRED')
     if (!Number.isSafeInteger(index) || !Number.isSafeInteger(total) || index < 0 || total < 1 || index >= total) {
       throw new Error('INVALID_RECEIVED_CHUNK_INDEX')
     }
-
-    cleanupStale()
-
-    const groupKey = groupKeyFor(channelPubkey, routerPubkey)
-    const now = Date.now()
-    const chunk = String(content || '')
-    const nextBytes = byteLength(chunk)
-    let meta = readMeta(groupKey)
-
-    if (meta && meta.total !== total) {
-      removeGroup(groupKey)
-      meta = null
-    }
-
-    if (!meta) {
-      meta = normalizeMeta({
-        channelPubkey,
-        routerPubkey,
-        total,
-        received: {},
-        receivedCount: 0,
-        nextIndex: 0,
-        rowIndex: 0,
-        carry: '',
-        payloadCiphertext: '',
-        receiverPubkeys: [],
-        byteSize: 0,
-        createdAt: now,
-        updatedAt: now
-      }, groupKey)
-      addGroupKey(groupKey)
-      writeMeta(meta)
-    }
-
-    if (!meta.received[String(index)]) {
-      if (meta.byteSize + nextBytes > configuredMaxBytes) {
-        removeGroup(groupKey)
-        throw new Error('RECEIVED_CHUNK_GROUP_TOO_LARGE')
+    const bytes = normalizeBytes(contentBytes)
+    await ready()
+    while (true) {
+      try {
+        const result = await putOnce({ channelPubkey, routerPubkey, index, total, contentBytes: bytes, ttlMs })
+        if (result.tooLarge) throw new Error('RECEIVED_CHUNK_GROUP_TOO_LARGE')
+        return result.meta
+      } catch (err) {
+        if (!isQuotaExceeded(err) || !await evictOldestGroup(groupKeyFor(channelPubkey, routerPubkey))) throw err
       }
-      writeChunk(chunkKey(groupKey, index), chunk, nextBytes, groupKey)
-      meta.received[String(index)] = true
-      meta.receivedCount++
-      meta.byteSize += nextBytes
     }
+  }
 
-    meta.total = total
-    meta.updatedAt = now
-    writeMeta(meta)
-    evictOldestUntilFits(0, { except: groupKey })
-    return meta
+  async function readMeta (groupKey) {
+    await ready()
+    return transaction([GROUPS_STORE], 'readonly', async tx => {
+      return normalizeMeta((await run('get', [groupKey], GROUPS_STORE, null, { tx })).result, configuredTtlMs)
+    })
   }
 
-  function status (metaOrGroupKey) {
-    const meta = typeof metaOrGroupKey === 'string' ? readMeta(metaOrGroupKey) : metaOrGroupKey
+  async function status (metaOrGroupKey) {
+    const meta = typeof metaOrGroupKey === 'string' ? await readMeta(metaOrGroupKey) : normalizeMeta(metaOrGroupKey, configuredTtlMs)
     if (!meta) return { received: 0, missing: [] }
-
     const missing = []
     let received = 0
     for (let index = 0; index < meta.total; index++) {
@@ -291,98 +399,183 @@ export function createReceivedChunkStore ({
   }
 
   function rememberReceiverPubkey (meta, pubkey) {
-    if (!pubkey || meta.receiverPubkeys.includes(pubkey)) return
-    meta.receiverPubkeys.push(pubkey)
+    if (pubkey && !meta.receiverPubkeys.includes(pubkey)) meta.receiverPubkeys.push(pubkey)
   }
 
   function rememberPayloadCiphertext (meta, ciphertext) {
     if (!meta.payloadCiphertext) meta.payloadCiphertext = ciphertext
   }
 
-  async function drainAvailable (groupKey, { onLine } = {}) {
-    const meta = readMeta(groupKey)
-    if (!meta) return { complete: false, stopped: false, meta: null }
+  async function claimDrain (groupKey, token) {
+    while (true) {
+      const now = Date.now()
+      const result = await transaction([GROUPS_STORE], 'readwrite', async tx => {
+        const meta = normalizeMeta((await run('get', [groupKey], GROUPS_STORE, null, { tx })).result, configuredTtlMs)
+        if (!meta) return { meta: null, waitMs: 0 }
+        if (meta.drainToken && meta.drainToken !== token && meta.drainUntil > now) {
+          return { meta: null, waitMs: Math.min(DRAIN_LEASE_MS, meta.drainUntil - now) }
+        }
+        meta.drainToken = token
+        meta.drainUntil = now + DRAIN_LEASE_MS
+        meta.updatedAt = now
+        meta.expiresAt = now + meta.ttlMs
+        await run('put', [meta], GROUPS_STORE, null, { tx })
+        return { meta, waitMs: 0 }
+      })
+      if (!result.waitMs) return result.meta
+      await wait(result.waitMs)
+    }
+  }
+
+  async function readDrainChunk (groupKey, token) {
+    return transaction([GROUPS_STORE, CHUNKS_STORE], 'readonly', async tx => {
+      const meta = normalizeMeta((await run('get', [groupKey], GROUPS_STORE, null, { tx })).result, configuredTtlMs)
+      if (!meta || meta.drainToken !== token) return { meta: null, bytes: null }
+      if (meta.nextIndex >= meta.total) return { meta, bytes: null }
+      const chunk = (await run('get', [[groupKey, meta.nextIndex]], CHUNKS_STORE, null, { tx })).result
+      return { meta, bytes: chunk ? normalizeBytes(chunk.bytes) : null }
+    })
+  }
+
+  async function commitDrainMeta (nextMeta, token) {
+    return transaction([GROUPS_STORE], 'readwrite', async tx => {
+      const current = normalizeMeta((await run('get', [nextMeta.groupKey], GROUPS_STORE, null, { tx })).result, configuredTtlMs)
+      if (!current || current.drainToken !== token) return null
+      current.nextIndex = nextMeta.nextIndex
+      current.rowIndex = nextMeta.rowIndex
+      current.carry = nextMeta.carry
+      current.payloadCiphertext = nextMeta.payloadCiphertext
+      current.receiverPubkeys = uniq(nextMeta.receiverPubkeys)
+      current.updatedAt = nextMeta.updatedAt
+      current.expiresAt = current.updatedAt + current.ttlMs
+      current.drainUntil = Date.now() + DRAIN_LEASE_MS
+      await run('put', [current], GROUPS_STORE, null, { tx })
+      return current
+    })
+  }
 
-    while (meta.nextIndex < meta.total) {
-      const index = meta.nextIndex
-      const raw = storage().getItem(chunkKey(groupKey, index))
-      if (raw == null) break
+  async function releaseDrain (groupKey, token) {
+    return transaction([GROUPS_STORE], 'readwrite', async tx => {
+      const meta = normalizeMeta((await run('get', [groupKey], GROUPS_STORE, null, { tx })).result, configuredTtlMs)
+      if (!meta || meta.drainToken !== token) return false
+      meta.drainToken = ''
+      meta.drainUntil = 0
+      await run('put', [meta], GROUPS_STORE, null, { tx })
+      return true
+    })
+  }
 
-      const text = `${meta.carry}${decoder.decode(base64ToBytes(raw))}`
-      let start = 0
-      let end = text.indexOf('\n', start)
+  async function drainAvailable (groupKey, { onLine } = {}) {
+    await ready()
+    const token = randomToken()
+    let meta = await claimDrain(groupKey, token)
+    if (!meta) return { complete: false, stopped: false, meta: null }
+    try {
+      while (meta.nextIndex < meta.total) {
+        const snapshot = await readDrainChunk(groupKey, token)
+        meta = snapshot.meta
+        if (!meta || !snapshot.bytes) break
+
+        const text = `${meta.carry}${decoder.decode(snapshot.bytes)}`
+        let start = 0
+        let end = text.indexOf('\n', start)
+        while (end !== -1) {
+          const line = text.slice(start, end)
+          start = end + 1
+          if (line) {
+            const result = await onLine?.(line, meta.rowIndex, meta, { rememberPayloadCiphertext, rememberReceiverPubkey })
+            meta.rowIndex++
+            if (result?.stop) {
+              meta.updatedAt = Date.now()
+              meta = await commitDrainMeta(meta, token)
+              return { complete: false, stopped: true, meta }
+            }
+          }
+          end = text.indexOf('\n', start)
+        }
+        meta.carry = text.slice(start)
+        meta.nextIndex++
+        meta.updatedAt = Date.now()
+        meta = await commitDrainMeta(meta, token)
+        if (!meta) break
+      }
 
-      while (end !== -1) {
-        const line = text.slice(start, end)
-        start = end + 1
-        if (line) {
-          const result = await onLine?.(line, meta.rowIndex, meta, { rememberPayloadCiphertext, rememberReceiverPubkey })
+      if (meta && meta.nextIndex >= meta.total) {
+        if (meta.carry) {
+          const result = await onLine?.(meta.carry, meta.rowIndex, meta, { rememberPayloadCiphertext, rememberReceiverPubkey })
           meta.rowIndex++
+          meta.carry = ''
           if (result?.stop) {
             meta.updatedAt = Date.now()
-            writeMeta(meta)
+            meta = await commitDrainMeta(meta, token)
             return { complete: false, stopped: true, meta }
           }
         }
-        end = text.indexOf('\n', start)
+        meta.updatedAt = Date.now()
+        meta = await commitDrainMeta(meta, token)
+        return { complete: Boolean(meta), stopped: false, meta }
       }
-
-      meta.carry = text.slice(start)
-
-      meta.nextIndex++
-      meta.updatedAt = Date.now()
-      writeMeta(meta)
+      return { complete: false, stopped: false, meta }
+    } finally {
+      await releaseDrain(groupKey, token).catch(() => {})
     }
+  }
 
-    if (meta.nextIndex >= meta.total) {
-      if (meta.carry) {
-        const result = await onLine?.(meta.carry, meta.rowIndex, meta, { rememberPayloadCiphertext, rememberReceiverPubkey })
-        meta.rowIndex++
-        meta.carry = ''
-        if (result?.stop) {
-          meta.updatedAt = Date.now()
-          writeMeta(meta)
-          return { complete: false, stopped: true, meta }
-        }
+  async function readChunkBytes (groupKey) {
+    await ready()
+    return transaction([GROUPS_STORE, CHUNKS_STORE], 'readonly', async tx => {
+      const meta = normalizeMeta((await run('get', [groupKey], GROUPS_STORE, null, { tx })).result, configuredTtlMs)
+      if (!meta) return { meta: null, chunks: [] }
+      const chunks = []
+      for (let index = 0; index < meta.total; index++) {
+        const chunk = (await run('get', [[groupKey, index]], CHUNKS_STORE, null, { tx })).result
+        if (!chunk) throw new Error('RECEIVED_CHUNK_MISSING')
+        chunks.push(normalizeBytes(chunk.bytes))
       }
-      meta.updatedAt = Date.now()
-      writeMeta(meta)
-      return { complete: true, stopped: false, meta }
-    }
+      return { meta, chunks }
+    })
+  }
 
-    return { complete: false, stopped: false, meta }
+  async function readChunkContents (groupKey) {
+    return (await readChunkBytes(groupKey)).chunks.map(bytes => decoder.decode(bytes))
   }
 
-  function readEnvelopeBundleContent (groupKey) {
-    const meta = readMeta(groupKey)
-    if (!meta) return ''
-    const parts = []
-    for (let index = 0; index < meta.total; index++) {
-      const chunk = storage().getItem(chunkKey(groupKey, index))
-      if (chunk == null) throw new Error('RECEIVED_CHUNK_MISSING')
-      parts.push(chunk)
+  async function readEnvelopeBundleContent (groupKey) {
+    const { chunks } = await readChunkBytes(groupKey)
+    return bytesToBase64(joinChunks(chunks))
+  }
+
+  function joinChunks (chunks) {
+    let length = 0
+    for (const chunk of chunks) length += chunk.byteLength
+    const joined = new Uint8Array(length)
+    let offset = 0
+    for (const chunk of chunks) {
+      joined.set(chunk, offset)
+      offset += chunk.byteLength
     }
-    return joinBase64Chunks(parts)
+    return joined
   }
 
-  function readEnvelopeBundleText (groupKey) {
-    const content = readEnvelopeBundleContent(groupKey)
-    return decoder.decode(base64ToBytes(content))
+  async function readEnvelopeBundleText (groupKey) {
+    return decoder.decode(joinChunks((await readChunkBytes(groupKey)).chunks))
   }
 
-  function readChunkContents (groupKey) {
-    const meta = readMeta(groupKey)
-    if (!meta) return []
-    const parts = []
-    for (let index = 0; index < meta.total; index++) {
-      const chunk = storage().getItem(chunkKey(groupKey, index))
-      if (chunk == null) throw new Error('RECEIVED_CHUNK_MISSING')
-      parts.push(chunk)
-    }
-    return parts
+  async function removeGroup (groupKey) {
+    await ready()
+    return transaction([GROUPS_STORE, CHUNKS_STORE, STATE_STORE], 'readwrite', async tx => {
+      const usage = await readUsage(tx)
+      const removed = await deleteGroupInTransaction(tx, groupKey, usage)
+      await writeUsage(tx, usage)
+      return removed
+    })
   }
 
-  cleanupStale()
+  function close () {
+    if (closed) return
+    closed = true
+    dbPromise?.then(db => db.close()).catch(() => {})
+  }
 
   return {
     cleanupStale,
@@ -392,7 +585,22 @@ export function createReceivedChunkStore ({
     readChunkContents,
     readEnvelopeBundleContent,
     readEnvelopeBundleText,
+    ready,
     removeGroup,
-    status
+    status,
+    close
+  }
+}
+
+export async function cleanupReceivedChunkStorage ({
+  indexedDB = globalThis.indexedDB,
+  prefix = DEFAULT_PREFIX,
+  now = Date.now()
+} = {}) {
+  const store = createReceivedChunkStore({ prefix, indexedDB })
+  try {
+    return await store.cleanupStale(now)
+  } finally {
+    store.close()
   }
 }