libp2r2p 0.11.22 → 0.11.24

package/README.md

@@ -264,7 +264,36 @@ close. Missing-key retries have no polling timer. MAC failures permit three tota
 attempts, persisted across reloads; exhausted packets remain until FIFO eviction.
 `retryPendingDecryptions({ force: true })` explicitly retries exhausted packets.
 Success enters the normal acknowledged inbox before removing the pending item.
-The session coordinator forwards this API. Private-channel consumers may opt in
+The session coordinator forwards this API.
+
+Pending recovery waits for 250 ms without channel setup, live/history processing
+or publication activity. Session foreground persistence/publication also delays
+it. After at most five seconds of eligible waiting, a busy channel may advance
+one packet, then receives a fresh deadline. Idle channels take batches of up to
+four records, yielding a task between every record. A busy channel does not hold
+up other channels; overdue channels precede the preferred foreground channel.
+Only requested passes run: a missing key never starts a polling loop. Timer
+throttling or an in-flight signer/storage call can extend actual elapsed time.
+
+`pendingDecryptionReady` defaults to `true` on messenger/session construction.
+Apps may pass `false` and call `setPendingDecryptionReady(true)` after their
+initial interface is presented; `false` holds only pending recovery, not live
+reception, publication or channel setup. The idle/deadline windows start after
+release. `setPendingDecryptionPriority(pubkey | null)` selects a channel on the
+messenger or a peer on the session; self-chat/`null` clear the session preference.
+The session retains a peer preference until preparation finishes and clears it
+on peer removal. Keep startup release and account lifecycle fencing in the app.
+
+`retryPendingDecryptions()` resolves after the requested scheduled pass (including
+an aggregated follow-up). `force: true` only overrides the MAC attempt ceiling;
+it does not bypass availability or admission. Requests before the first snapshot
+share that pass; requests during it aggregate into one following pass. Queue
+reads wait for initial release. Each packet is revalidated under the identity
+Web Lock when available; waits hold neither that lock nor the normal inbox/IDB
+queues. Fragment assembly survives scheduling boundaries. Pause/close cancel
+waits; channel removal fences its queued and in-flight results.
+
+Private-channel consumers may opt in
 with `onDecryptionFailure({ error, record })`, returning true only after durable
 handling, and replay records with `replayDeferredDecryptions`. Without the hook,
 standalone readers retain their existing error behavior.

package/package.json

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

package/private-channel/index.js

@@ -717,7 +717,7 @@ function createProcessor ({
   onNymEvent,
   onSeedEvent,
   onContentKeyUsage,
-  onDecryptionFailure, isDecryptionPending,
+  onDecryptionFailure, isDecryptionPending, _onProcessing,
   onError,
   receivedChunkScope = '',
   receivedChunkTtlMs = DEFAULT_RECEIVED_CHUNK_TTL_MS,
@@ -741,7 +741,14 @@ function createProcessor ({
   storeReady.catch(() => {})
 
   async function processOuterEvent (outer) {
-    await storeReady
+    const release = _onProcessing?.(outer.pubkey)
+    try {
+      await storeReady
+      return await processReadyOuterEvent(outer)
+    } finally { release?.() }
+  }
+
+  async function processReadyOuterEvent (outer) {
     let groupKey = ''
     let routerDecrypted = false
     try {
@@ -982,7 +989,7 @@ function shouldIgnoreGroupError (err) {
 
 // Replay ciphertext only. Keep one fragment processor for the entire batch;
 // incomplete outer groups remain pending until a later key/channel transition.
-export async function replayDeferredDecryptions ({ records, onRecovered, onFailure, ...options }) {
+export async function replayDeferredDecryptions ({ records, onRecovered, onFailure, _runRecord = (_record, work) => work(), ...options }) {
   if (!Array.isArray(records) || records.some(record => typeof record?.id !== 'string' ||
       typeof record.channelPubkey !== 'string' || !['outer_v1', 'routerRow_v1'].includes(record.packet?.format))) throw new ValidationError('INVALID_DEFERRED_RECORDS')
   if (typeof onRecovered !== 'function' || typeof onFailure !== 'function') throw new ValidationError('DEFERRED_CALLBACKS_REQUIRED')
@@ -1017,44 +1024,48 @@ export async function replayDeferredDecryptions ({ records, onRecovered, onFailu
   })
   try {
     for (const record of records) {
-      options.signal?.throwIfAborted()
-      current = record
-      chunked = false
-      try {
-        if (record.packet.format === 'outer_v1') {
-          await processor(record.packet.outer)
-          if (!chunked) await onRecovered(record)
-        } else {
-          const event = await unwrapRouterEvent({
-            receiverSigner: options.receiverSigner, receiverPubkey: options.receiverPubkey,
-            channelPubkey: record.channelPubkey, router: record.packet.router
-          })
-          options.signal?.throwIfAborted()
-          if (event) {
-            await options.onEvent?.(event, record.packet.outer, {
-              router: record.packet.router, channelPubkey: record.channelPubkey,
-              ...deliveryInfo(event, readSenderTag(record.packet.router))
+      await _runRecord(record, async () => {
+        options.signal?.throwIfAborted()
+        current = record
+        chunked = false
+        try {
+          if (record.packet.format === 'outer_v1') {
+            await processor(record.packet.outer)
+            if (!chunked) await onRecovered(record)
+          } else {
+            const event = await unwrapRouterEvent({
+              receiverSigner: options.receiverSigner, receiverPubkey: options.receiverPubkey,
+              channelPubkey: record.channelPubkey, router: record.packet.router
             })
+            options.signal?.throwIfAborted()
+            if (event) {
+              await options.onEvent?.(event, record.packet.outer, {
+                router: record.packet.router, channelPubkey: record.channelPubkey,
+                ...deliveryInfo(event, readSenderTag(record.packet.router))
+              })
+            }
+            await onRecovered(record)
           }
-          await onRecovered(record)
+        } catch (error) {
+          options.signal?.throwIfAborted()
+          await onFailure(record, decryptionError(error, { channelPubkey: record.channelPubkey, eventId: record.packet.outer?.id }))
         }
-      } catch (error) {
-        options.signal?.throwIfAborted()
-        await onFailure(record, decryptionError(error, { channelPubkey: record.channelPubkey, eventId: record.packet.outer?.id }))
-      }
+        for (const key of completed) {
+          for (const id of groups.get(key) || []) {
+            const recovered = records.find(record => record.id === id)
+            if (recovered) await onRecovered(recovered)
+          }
+          groups.delete(key)
+        }
+        completed.clear()
+      })
       // Let live ingestion and foreground signer work run between records.
       await new Promise(resolve => setTimeout(resolve, 0))
     }
-    for (const key of completed) {
-      for (const id of groups.get(key) || []) {
-        const record = records.find(record => record.id === id)
-        if (record) await onRecovered(record)
-      }
-    }
   } finally { processor.close() }
 }
 
-export async function fetch ({ signal, receiverSigner, iykcSigner, privateChannelSigner = receiverSigner, privateChannelSignersByPubkey, privateChannelReaderSigner = privateChannelSigner, privateChannelReaderSignersByPubkey, privateChannelReaderPubkey, privateChannelReaderPubkeysByPubkey, privateChannelPubkey, privateChannelPubkeys, receiverPubkey, relays, onChunk, onEvent, onNymEvent, onSeedEvent, onContentKeyUsage, onDecryptionFailure, isDecryptionPending, onError, since, until, limit, mode = 'leecher', modeByPubkey, receivedChunkScope = '', receivedChunkTtlMs = DEFAULT_RECEIVED_CHUNK_TTL_MS, receivedChunkTtlMsByPubkey, receivedChunkMaxBytes = DEFAULT_RECEIVED_CHUNK_MAX_BYTES, receivedChunkIndexedDB = globalThis.indexedDB, ignoredGroupTtlMs = DEFAULT_IGNORED_GROUP_TTL_MS, ignoredGroupMaxEntries = DEFAULT_IGNORED_GROUP_MAX_ENTRIES, _getEvents = getEvents }) {
+export async function fetch ({ signal, receiverSigner, iykcSigner, privateChannelSigner = receiverSigner, privateChannelSignersByPubkey, privateChannelReaderSigner = privateChannelSigner, privateChannelReaderSignersByPubkey, privateChannelReaderPubkey, privateChannelReaderPubkeysByPubkey, privateChannelPubkey, privateChannelPubkeys, receiverPubkey, relays, onChunk, onEvent, onNymEvent, onSeedEvent, onContentKeyUsage, onDecryptionFailure, isDecryptionPending, _onProcessing, onError, since, until, limit, mode = 'leecher', modeByPubkey, receivedChunkScope = '', receivedChunkTtlMs = DEFAULT_RECEIVED_CHUNK_TTL_MS, receivedChunkTtlMsByPubkey, receivedChunkMaxBytes = DEFAULT_RECEIVED_CHUNK_MAX_BYTES, receivedChunkIndexedDB = globalThis.indexedDB, ignoredGroupTtlMs = DEFAULT_IGNORED_GROUP_TTL_MS, ignoredGroupMaxEntries = DEFAULT_IGNORED_GROUP_MAX_ENTRIES, _getEvents = getEvents }) {
   if (!relays?.length) throw new ValidationError('NO_RELAYS')
   const authors = privateChannelPubkeyList({ privateChannelPubkey, privateChannelPubkeys })
   const filter = { kinds: [PRIVATE_BROADCAST_KIND] }
@@ -1073,7 +1084,7 @@ export async function fetch ({ signal, receiverSigner, iykcSigner, privateChanne
   const elapsedMs = Math.round(performance.now() - startedAt)
   const events = result.map(({ event }) => event)
   events.sort((a, b) => a.created_at - b.created_at)
-  const processOuterEvent = createProcessor({ receiverSigner, iykcSigner, privateChannelSigner, privateChannelSignersByPubkey, privateChannelReaderSigner, privateChannelReaderSignersByPubkey, privateChannelReaderPubkey, privateChannelReaderPubkeysByPubkey, receiverPubkey, mode, modeByPubkey, onChunk, onEvent, onNymEvent, onSeedEvent, onContentKeyUsage, onDecryptionFailure, isDecryptionPending, onError, receivedChunkScope, receivedChunkTtlMs, receivedChunkTtlMsByPubkey, receivedChunkMaxBytes, receivedChunkIndexedDB, ignoredGroupTtlMs, ignoredGroupMaxEntries })
+  const processOuterEvent = createProcessor({ receiverSigner, iykcSigner, privateChannelSigner, privateChannelSignersByPubkey, privateChannelReaderSigner, privateChannelReaderSignersByPubkey, privateChannelReaderPubkey, privateChannelReaderPubkeysByPubkey, receiverPubkey, mode, modeByPubkey, onChunk, onEvent, onNymEvent, onSeedEvent, onContentKeyUsage, onDecryptionFailure, isDecryptionPending, _onProcessing, onError, receivedChunkScope, receivedChunkTtlMs, receivedChunkTtlMsByPubkey, receivedChunkMaxBytes, receivedChunkIndexedDB, ignoredGroupTtlMs, ignoredGroupMaxEntries })
   try {
     for (const event of events) {
       signal?.throwIfAborted()
@@ -1103,7 +1114,7 @@ export async function fetchHistory ({ receiverSigner, privateChannelSigner = rec
   } finally { processOuterEvent.close() }
 }
 
-export function subscribe ({ receiverSigner, iykcSigner, privateChannelSigner = receiverSigner, privateChannelSignersByPubkey, privateChannelReaderSigner = privateChannelSigner, privateChannelReaderSignersByPubkey, privateChannelReaderPubkey, privateChannelReaderPubkeysByPubkey, privateChannelPubkey, privateChannelPubkeys, receiverPubkey, relays, onChunk, onEvent, onNymEvent, onSeedEvent, onContentKeyUsage, onDecryptionFailure, isDecryptionPending, onError, since = nowSeconds() - 5, limit, liveOnly = false, mode = 'leecher', modeByPubkey, receivedChunkScope = '', receivedChunkTtlMs = DEFAULT_RECEIVED_CHUNK_TTL_MS, receivedChunkTtlMsByPubkey, receivedChunkMaxBytes = DEFAULT_RECEIVED_CHUNK_MAX_BYTES, receivedChunkIndexedDB = globalThis.indexedDB, ignoredGroupTtlMs = DEFAULT_IGNORED_GROUP_TTL_MS, ignoredGroupMaxEntries = DEFAULT_IGNORED_GROUP_MAX_ENTRIES, _liveEventsGenerator = getLiveEventsGenerator, _eventsFeedGenerator = getEventsFeedGenerator }) {
+export function subscribe ({ receiverSigner, iykcSigner, privateChannelSigner = receiverSigner, privateChannelSignersByPubkey, privateChannelReaderSigner = privateChannelSigner, privateChannelReaderSignersByPubkey, privateChannelReaderPubkey, privateChannelReaderPubkeysByPubkey, privateChannelPubkey, privateChannelPubkeys, receiverPubkey, relays, onChunk, onEvent, onNymEvent, onSeedEvent, onContentKeyUsage, onDecryptionFailure, isDecryptionPending, _onProcessing, onError, since = nowSeconds() - 5, limit, liveOnly = false, mode = 'leecher', modeByPubkey, receivedChunkScope = '', receivedChunkTtlMs = DEFAULT_RECEIVED_CHUNK_TTL_MS, receivedChunkTtlMsByPubkey, receivedChunkMaxBytes = DEFAULT_RECEIVED_CHUNK_MAX_BYTES, receivedChunkIndexedDB = globalThis.indexedDB, ignoredGroupTtlMs = DEFAULT_IGNORED_GROUP_TTL_MS, ignoredGroupMaxEntries = DEFAULT_IGNORED_GROUP_MAX_ENTRIES, _liveEventsGenerator = getLiveEventsGenerator, _eventsFeedGenerator = getEventsFeedGenerator }) {
   if (!relays?.length) throw new ValidationError('NO_RELAYS')
   if (receiverSigner && !receiverSigner?.nip44DecryptDoubleDH && !receiverSigner?.nip44v3Decrypt) throw new ValidationError('RECEIVER_SIGNER_NIP44V3_DECRYPT_UNSUPPORTED')
   if (!privateChannelReaderSigner && !privateChannelReaderSignersByPubkey && !privateChannelSigner && !privateChannelSignersByPubkey) throw new ValidationError('PRIVATE_CHANNEL_READER_REQUIRED')
@@ -1112,7 +1123,7 @@ export function subscribe ({ receiverSigner, iykcSigner, privateChannelSigner =
   const filter = { kinds: [PRIVATE_BROADCAST_KIND], since }
   if (authors.length) filter.authors = authors
   if (limit != null) filter.limit = limit
-  const processOuterEvent = createProcessor({ receiverSigner, iykcSigner, privateChannelSigner, privateChannelSignersByPubkey, privateChannelReaderSigner, privateChannelReaderSignersByPubkey, privateChannelReaderPubkey, privateChannelReaderPubkeysByPubkey, receiverPubkey, mode, modeByPubkey, onChunk, onEvent, onNymEvent, onSeedEvent, onContentKeyUsage, onDecryptionFailure, isDecryptionPending, onError, receivedChunkScope, receivedChunkTtlMs, receivedChunkTtlMsByPubkey, receivedChunkMaxBytes, receivedChunkIndexedDB, ignoredGroupTtlMs, ignoredGroupMaxEntries })
+  const processOuterEvent = createProcessor({ receiverSigner, iykcSigner, privateChannelSigner, privateChannelSignersByPubkey, privateChannelReaderSigner, privateChannelReaderSignersByPubkey, privateChannelReaderPubkey, privateChannelReaderPubkeysByPubkey, receiverPubkey, mode, modeByPubkey, onChunk, onEvent, onNymEvent, onSeedEvent, onContentKeyUsage, onDecryptionFailure, isDecryptionPending, _onProcessing, onError, receivedChunkScope, receivedChunkTtlMs, receivedChunkTtlMsByPubkey, receivedChunkMaxBytes, receivedChunkIndexedDB, ignoredGroupTtlMs, ignoredGroupMaxEntries })
   const controller = new AbortController()
   const events = liveOnly
     ? _liveEventsGenerator(filter, relays, {

package/private-message/index.js

@@ -477,6 +477,7 @@ export function createPrivateMessageSession ({ _setTimeout = setTimeout, _clearT
           return dispatchSeedEvent(seed)
         },
         onContentKeyUsage: dispatchContentKeyUsage,
+        _onProcessing: pubkey => watchCallbacks(pubkey)._onProcessing?.(pubkey),
         isDecryptionPending: record => watchCallbacks(record.channelPubkey).isDecryptionPending?.(record),
         onDecryptionFailure: failure => watchCallbacks(failure.record.channelPubkey).onDecryptionFailure?.(failure),
         onError: err => reportSubscriptionError(channels, err)
@@ -524,7 +525,7 @@ export function createPrivateMessageSession ({ _setTimeout = setTimeout, _clearT
     onSeed,
     onChunk,
     onContentKeyUsage,
-    onDecryptionFailure, isDecryptionPending,
+    onDecryptionFailure, isDecryptionPending, _onProcessing,
     onSubscriptionState,
     onError,
     receivedChunkTtlMs,
@@ -545,7 +546,7 @@ export function createPrivateMessageSession ({ _setTimeout = setTimeout, _clearT
     const ownPubkey = receiverPubkey || await receiverSigner?.getPublicKey?.()
     if (identity !== undefined && identity !== ownPubkey) throw new ValidationError('PRIVATE_MESSAGE_IDENTITY_MISMATCH')
     identity = ownPubkey
-    const callbacks = { onAsk, onReply, onTell, onYell, onNym, onMessage, onSeed, onChunk, onContentKeyUsage, onDecryptionFailure, isDecryptionPending, onSubscriptionState, onError }
+    const callbacks = { onAsk, onReply, onTell, onYell, onNym, onMessage, onSeed, onChunk, onContentKeyUsage, onDecryptionFailure, isDecryptionPending, _onProcessing, onSubscriptionState, onError }
 
     for (const channel of channelList) {
       if (watchRequests.get(channel) !== request) continue