libp2r2p 0.11.33 → 0.11.34

package/README.md

@@ -1295,3 +1295,9 @@ The 0.11.33 recovery adapter checks immutable wrapper mirrors without decrypting
 snapshots and serializes recovery mutations per event store. Session archives
 wait for foreground quiet for up to five seconds, execute one batch, then
 re-evaluate so pending recovery cannot monopolize local persistence.
+
+The 0.11.34 recovery adapter marks paged event-store reads with the internal
+`recovery: true` hint so a compatible launcher can prioritize foreground writes
+over new background read transactions. `putMany` also accepts an optional
+development diagnostic callback with aggregate existing/inserted/skipped counts;
+it never exposes ciphertext or record payloads.

package/package.json

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

package/private-messenger/event-store/README.md

@@ -30,10 +30,18 @@ without decrypting the archive; the store may also purge expired wrappers itself
   filter and the record coordinates as an OR filter. Existence checks compare the
   immutable wrapper `o` mirrors to the requested record IDs and do not decrypt or
   decode snapshots. Duplicate `putMany` inputs return their supplied immutable row.
+- Recovery pages pass the optional internal `{ recovery: true }` query hint.
+  Launchers may use it to admit the readonly transaction as background without
+  granting an app elevated priority. Stores that do not recognize the hint keep
+  the previous query behavior.
+- `putMany(rows, { onDiagnostic })` accepts an optional development callback. One
+  sanitized report identifies row, unique, existing, inserted, blocked, expired,
+  stored and skipped counts after each batch. It never includes ciphertext,
+  decoded rows, record payloads or signer material.
 - Mutating recovery stores share one operation tail per event store, so seed and
-  grant writes cannot overlap for the same store. Writes pass the internal
-  `recovery: true` scheduling hint to `addPersonalCopy`; row-returning reads keep
-  normal decrypt-and-validate behavior.
+  grant writes cannot overlap for the same store. Writes and paged reads pass the
+  internal `recovery: true` scheduling hint to the corresponding event-store
+  methods; row-returning reads keep normal decrypt-and-validate behavior.
 - `iterate` is an async generator. Queries can name `recordId`, `channelPubkey`,
   `receiverPubkey`, `since`/`until`, or the file tuple `controlChannelPubkey`,
   `fileChannelPubkey`, `receiverPubkey`, and `indices`. `signal` cancels reads.

package/private-messenger/event-store/index.js

@@ -7,6 +7,7 @@ export { encodeRecord as encodeRecoveryRecord, decodeRecord as decodeRecoveryRec
 
 const nowSeconds = () => Math.floor(Date.now() / 1000)
 const RECOVERY_BATCH_SIZE = 100
+const RECOVERY_QUERY_OPTIONS = Object.freeze({ recovery: true })
 const mutationTails = new WeakMap()
 const chunks = values => Array.from({ length: Math.ceil(values.length / RECOVERY_BATCH_SIZE) }, (_, index) =>
   values.slice(index * RECOVERY_BATCH_SIZE, (index + 1) * RECOVERY_BATCH_SIZE))
@@ -32,7 +33,10 @@ async function * pages (eventStore, filter, signal) {
   let until = filter.until, excluded = []
   while (true) {
     signal?.throwIfAborted()
-    const { results } = await eventStore.query({ ...filter, ...(until === undefined ? {} : { until }), ...(excluded.length ? { '!ids': excluded } : {}), limit: 128, search: 'sort:desc' })
+    const { results } = await eventStore.query(
+      { ...filter, ...(until === undefined ? {} : { until }), ...(excluded.length ? { '!ids': excluded } : {}), limit: 128, search: 'sort:desc' },
+      RECOVERY_QUERY_OPTIONS
+    )
     if (!results.length) return
     for (const event of results) { signal?.throwIfAborted(); yield event }
     const boundary = results.at(-1).created_at
@@ -131,10 +135,10 @@ export function createPersonalCopyRecoveryStorage ({ eventStore, signer, now = n
     }
   }
   function store (type) {
-    async function putMany (rows) {
-      return serializeMutation(eventStore, () => putManyNow(rows))
+    async function putMany (rows, options = {}) {
+      return serializeMutation(eventStore, () => putManyNow(rows, options))
     }
-    async function putManyNow (rows) {
+    async function putManyNow (rows, { onDiagnostic } = {}) {
       check()
       if (!Array.isArray(rows)) throw new ValidationError('INVALID_RECOVERY_RECORDS')
       const encoded = rows.map(row => {
@@ -150,13 +154,35 @@ export function createPersonalCopyRecoveryStorage ({ eventStore, signer, now = n
           if (record) stored.set(recordId, { ...record.row, recordId })
         }
       }
+      const existingCount = stored.size
+      let insertedCount = 0
+      let blockedCount = 0
       for (const [recordId, record] of unique) {
         if (stored.has(recordId)) continue
         const saved = committed(await eventStore.addPersonalCopy(record.event, { context: '', recovery: true }))
         // A pending kind-5 tombstone can reject the insertion; do not cache it.
-        if (saved.result.stored === false && saved.result.code === 'blocked') stored.set(recordId, undefined)
-        else stored.set(recordId, { ...record.row, recordId })
+        if (saved.result.stored === false && saved.result.code === 'blocked') {
+          stored.set(recordId, undefined)
+          blockedCount++
+        } else {
+          stored.set(recordId, { ...record.row, recordId })
+          insertedCount++
+        }
       }
+      const expiredCount = encoded.filter(record => record === null).length
+      try {
+        onDiagnostic?.({
+          type,
+          rowCount: rows.length,
+          uniqueCount: unique.size,
+          existingCount,
+          insertedCount,
+          blockedCount,
+          expiredCount,
+          storedCount: existingCount + insertedCount,
+          skippedCount: existingCount + blockedCount + expiredCount
+        })
+      } catch {}
       return encoded.map(record => record ? stored.get(record.recordId) : undefined)
     }
     async function hasMany (rows) {

package/private-messenger/session/README.md

@@ -270,6 +270,10 @@ event/peer identifiers and elapsed milliseconds for admission, local processing,
 channel preparation, publication acceptance and cleanup. Callback failures never
 change delivery. Connect only in development; never log events or crypto buffers.
 Custom outbox factories also receive this optional callback for storage timings.
+Recovery archive completion also reports `publicationId`, one aggregate
+`recovery-archive-result` per `putMany`, and sanitized row/unique/existing/
+inserted/blocked/expired/stored/skipped counts. A single-row batch may include
+its opaque `seedRecordId`.
 
 ## Durable prepared publications
 

package/private-messenger/session/index.js

@@ -175,15 +175,40 @@ export function createPrivateMessageSession ({ owner, signer, eventStore, messag
         throw error
       }
       if (closed) return
+      const archiveStartedAt = Date.now()
       debug(entry, 'recovery-archive-window', waitedAt, { foregroundIdle: idle, rowCount: rows.length })
+      let archived
+      let diagnosticReported = false
+      const onDiagnostic = details => {
+        diagnosticReported = true
+        debug(entry, 'recovery-archive-result', archiveStartedAt, {
+          publicationId: entry.prepared.publication.events[0].id,
+          ...details
+        })
+      }
       if (recoveryStorage?.seeds) {
-        if (typeof recoveryStorage.seeds.putMany === 'function') await recoveryStorage.seeds.putMany(rows)
-        else for (const row of rows) await recoveryStorage.seeds.put(row)
+        if (typeof recoveryStorage.seeds.putMany === 'function') archived = await recoveryStorage.seeds.putMany(rows, { onDiagnostic })
+        else {
+          archived = []
+          for (const row of rows) archived.push(await recoveryStorage.seeds.put(row))
+        }
       } else if (entry.prepared.target.file) {
         for (const seed of entry.prepared.publication.seeds) await fileTransfers.archiveSeed(entry.prepared.target.file, seed)
       } else {
         for (const seed of entry.prepared.publication.seeds) await messenger.enqueueSeed(seed.channelPubkey, seed)
       }
+      if (!diagnosticReported) {
+        const results = Array.isArray(archived) ? archived : []
+        const storedCount = results.filter(Boolean).length
+        debug(entry, 'recovery-archive-result', archiveStartedAt, {
+          publicationId: entry.prepared.publication.events[0].id,
+          rowCount: rows.length,
+          uniqueCount: new Set(rows.map(row => row.recordId).filter(Boolean)).size,
+          storedCount,
+          skippedCount: results.length ? results.length - storedCount : undefined,
+          ...(rows.length === 1 && rows[0].recordId ? { seedRecordId: rows[0].recordId } : {})
+        })
+      }
     },
     changed: entry => {
       watchOfflineSends()