libp2r2p 0.10.26 → 0.10.28

package/README.md

@@ -519,6 +519,29 @@ This also covers abrupt termination without `close()` and channels with no
 messages. Applications still supply signers and desired channels on reopening;
 storage is scoped by origin and user pubkey, not the transient session ID.
 Failed ingestion or incomplete relay fetch reports never complete the gap.
+`private-channel.fetch` reports incomplete reads as an `AggregateError` with
+stable `code: 'PRIVATE_CHANNEL_FETCH_INCOMPLETE'`. Its message names relays,
+completion statuses and native failure messages, including status-only failures.
+`relays` retains all `{ relay, status, error? }` outcomes; `relayErrors` preserves
+`{ relay, reason }` attribution and `errors` retains unique native causes from
+both sources. `request` records selected relays, channel pubkeys, receiver pubkey,
+`since`/`until`/`limit` and the 5000ms read timeout. `elapsedMs` measures the read
+including admission wait, excluding decryption/storage; `receivedEventCount`
+counts fetched outer events, not delivered messages. No event bodies or signers
+are attached. These diagnostics reach the messenger's `onError` unchanged.
+A single incomplete relay keeps the interval pending even if another relay
+returned events; received messages may already have been queued. This is a
+history completeness failure, not evidence that an outgoing message failed.
+Existing rewatch/resume and relay-list refresh paths retry pending intervals;
+there is no dedicated periodic retry timer for a failed history fetch.
+Subscription relay errors forwarded to `onError` include `relay` when known
+and `operation: 'private-channel.subscribe'`. A per-notification wrapper retains
+the native message, name, code, category and WebSocket close fields; `cause`
+references the untouched original error, including its stack and causes.
+Aggregate errors keep their nested errors. This also works with frozen/shared
+errors without leaking attribution between subscribers. Missing relay metadata
+is not inferred from the selected relay list. This does not change reconnection,
+delivery or error classification; processing errors keep their existing path.
 `lastSeenAt` tracks messages persisted in the incoming queue, not app commits.
 The default recovery window is seven days; recovery still depends on available
 relay/seeder data, and retention limits cannot guarantee indefinite delivery.

package/package.json

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

package/private-channel/helpers/fetch-error.js

@@ -0,0 +1,26 @@
+const describe = reason => `${reason?.category ? `[${reason.category}] ` : ''}${reason?.message || String(reason)}`
+
+export function incompleteFetchError ({ errors, report, request, receivedEventCount, elapsedMs }) {
+  // Keep only read metadata, never events, decrypted payloads or signers.
+  const relayErrors = errors.map(({ relay, reason }) => ({ relay, reason }))
+  const relays = report.map(({ relay, status, error }) => ({ relay, status, ...(error ? { error } : {}) }))
+  const reasons = [...new Set([...relayErrors.map(entry => entry.reason), ...relays.map(entry => entry.error)].filter(reason => reason !== undefined))]
+  const details = relays.map(({ relay, status, error }) => {
+    const failures = relayErrors.filter(entry => entry.relay === relay).map(entry => entry.reason)
+    if (error && !failures.includes(error)) failures.push(error)
+    return `${relay} [${status}]${failures.length ? `: ${failures.map(describe).join('; ')}` : ''}`
+  })
+  for (const { relay, reason } of relayErrors) {
+    if (!relays.some(entry => entry.relay === relay)) details.push(`${relay || 'unknown relay'}: ${describe(reason)}`)
+  }
+  return Object.assign(new AggregateError(reasons,
+    `PRIVATE_CHANNEL_FETCH_INCOMPLETE: ${details.join(' | ')} (received=${receivedEventCount}, readElapsedMs=${elapsedMs}, timeoutMs=${request.timeoutMs})`), {
+    code: 'PRIVATE_CHANNEL_FETCH_INCOMPLETE',
+    operation: 'private-channel.fetch',
+    request,
+    receivedEventCount,
+    elapsedMs,
+    relays,
+    relayErrors
+  })
+}

package/private-channel/helpers/subscription-error.js

@@ -0,0 +1,14 @@
+// Relay errors can be shared by multiple subscriptions or be frozen. Attach
+// consumer context to a new error and retain the untouched original as cause.
+export function subscriptionError (reason, relay) {
+  const message = reason?.message ?? String(reason)
+  const error = reason instanceof AggregateError
+    ? new AggregateError(reason.errors, message, { cause: reason })
+    : new Error(message, { cause: reason })
+  for (const key of ['name', 'code', 'category', 'closeCode', 'closeReason', 'wasClean']) {
+    if (reason?.[key] !== undefined) error[key] = reason[key]
+  }
+  error.operation = 'private-channel.subscribe'
+  if (typeof relay === 'string') error.relay = relay
+  return error
+}

package/private-channel/index.js

@@ -6,6 +6,8 @@ import { isValidContentKeyProof, isValidIykcProof, makeContentKeyEventForPubkey,
 import { getIykcProofs } from '../content-key/index.js'
 import { ValidationError } from '../error/index.js'
 import { normalizeRumor, deliveryInfo } from './helpers/rumor.js'
+import { incompleteFetchError } from './helpers/fetch-error.js'
+import { subscriptionError } from './helpers/subscription-error.js'
 import * as nip44v3 from '../nip44-v3/index.js'
 import { relayPool } from '../relay/index.js'
 import { JSONL_CHUNK_BYTES, NYM_CARRIER_CHUNK_CHARS } from './helpers/chunk-size.js'
@@ -907,11 +909,14 @@ export async function fetch ({ signal, receiverSigner, iykcSigner, privateChanne
   if (until != null) filter.until = until
   if (limit != null) filter.limit = limit
 
+  const timeoutMs = 5000
+  const startedAt = performance.now()
   const { result, errors = [], relays: report = [] } = await _getEvents(filter, relays, {
-    timeout: 5000,
+    timeout: timeoutMs,
     timeoutAfterFirstEose: null,
     ...(signal ? { signal } : {})
   })
+  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, onError, receivedChunkScope, receivedChunkTtlMs, receivedChunkTtlMsByPubkey, receivedChunkMaxBytes, receivedChunkIndexedDB, ignoredGroupTtlMs, ignoredGroupMaxEntries })
@@ -922,7 +927,10 @@ export async function fetch ({ signal, receiverSigner, iykcSigner, privateChanne
     }
     signal?.throwIfAborted()
     if (errors.length || report.some(entry => !['eose', 'satisfied'].includes(entry.status))) {
-      throw new AggregateError(errors.map(entry => entry.reason), 'PRIVATE_CHANNEL_FETCH_INCOMPLETE')
+      throw incompleteFetchError({
+        errors, report, elapsedMs, receivedEventCount: events.length,
+        request: { relays: [...relays], channelPubkeys: [...authors], receiverPubkey, since, until, limit, timeoutMs }
+      })
     }
     return events
   } finally {
@@ -955,7 +963,7 @@ export function subscribe ({ receiverSigner, iykcSigner, privateChannelSigner =
     try {
       for await (const item of events) {
         if (controller.signal.aborted) continue
-        if (item.type === 'error') onError?.(item.error)
+        if (item.type === 'error') onError?.(subscriptionError(item.error, item.relay))
         else if (item.type === 'event') await processOuterEvent(item.event)
       }
     } catch (error) {