libp2r2p 0.10.25 → 0.10.27

package/README.md

@@ -519,6 +519,21 @@ 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.
 `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.
@@ -854,3 +869,16 @@ A stale token cannot acknowledge a newly reserved or replaced record.
 
 `queue.getCapacity()` returns `{ usedBytes, maxBytes }`; capacity rejections
 also expose `requiredBytes` and `maxBytes`, without retaining the rejected item.
+
+
+### Publication acknowledgement deadlines
+
+`RelayPool.sendEvent` returns immediately when the first relay accepts an event,
+when all relays fail, or when the operation's `timeout` expires (30 seconds by
+default, including connection work). `timeoutUntilFirstFulfillment` now defaults
+to `null`, removing the former 3-second cutoff. Explicit shorter deadlines remain
+supported and still finalize pending reports as timeouts. `promise` provides the
+complete per-relay report without delaying the first-success return. Connection
+establishment retains its separate 3-second deadline. PrivateMessenger inherits
+this publication policy, including seeder/recovery messages. A timeout indicates
+missing acknowledgement and cannot prove that the recipient did not receive it.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "libp2r2p",
-  "version": "0.10.25",
+  "version": "0.10.27",
   "description": "Peer-to-relay-to-peer",
   "keywords": [
     "p2r2p",
@@ -97,7 +97,7 @@
     "@noble/curves": "2.2.0",
     "@noble/hashes": "2.2.0",
     "@scure/base": "2.0.0",
-    "nmmr": "2.0.0"
+    "nmmr": "2.0.1"
   },
   "devDependencies": {
     "eslint": "^9.39.5",

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/index.js

@@ -6,6 +6,7 @@ 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 * 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 +908,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 +926,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 {

package/relay/services/relay-pool.js

@@ -11,7 +11,6 @@ import { RelayConnection } from './relay-connection.js'
 const CONNECTION_TIMEOUT_MS = 3000
 const COUNT_TIMEOUT_MS = 5000
 const COUNT_TIMEOUT_AFTER_FIRST_COUNT_MS = 500
-const SEND_TIMEOUT_UNTIL_FIRST_FULFILLMENT_MS = 3000
 const SEND_TIMEOUT_MS = 30000
 const LIVE_OVERLAP_SECONDS = 600
 const LIVE_PROGRESS_INTERVAL_MS = 60000
@@ -1120,8 +1119,8 @@ export class RelayPool {
     }
   }
 
-  // Returns after the first acknowledgement window. timeout is one deadline for
-  // the whole operation, while timeoutUntilFirstFulfillment controls only this
+  // Returns on the first acknowledgement, all failures, or the 30s deadline.
+  // An optional timeoutUntilFirstFulfillment imposes an earlier deadline on this
   // initial return and closes pending reports when it fails. null disables either
   // timer independently. onRelayResult receives one
   // { relay, success, outcome, reason? } result per relay as it settles; outcome
@@ -1130,7 +1129,7 @@ export class RelayPool {
   // Await `promise` for the complete report, including every relay outcome.
   async sendEvent (event, relays, {
     timeout = SEND_TIMEOUT_MS,
-    timeoutUntilFirstFulfillment = SEND_TIMEOUT_UNTIL_FIRST_FULFILLMENT_MS,
+    timeoutUntilFirstFulfillment = null,
     getAuthEvent,
     onRelayResult
   } = {}) {