libp2r2p 0.12.0 → 0.12.2

package/private-message/index.js

@@ -4,6 +4,7 @@ import { ValidationError } from '../error/index.js'
 import { generateKeypair, keypairFromSeckey } from '../key/index.js'
 import * as privateChannel from '../private-channel/index.js'
 import { normalizeRumor, deliveryInfo } from '../private-channel/helpers/rumor.js'
+import { normalizePreparedPublications } from '../private-channel/helpers/prepared.js'
 
 export const ASK_KIND = 7329
 export const REPLY_KIND = 7330
@@ -41,17 +42,25 @@ function normalizeDeletionPubkey (deletionPubkey) {
   return deletionPubkey.toLowerCase()
 }
 
-function resolveDeletionCapability ({ deletionPubkey, deletionSeckey, autoDeletionCapability = true, preparedPublication }) {
+function resolveDeletionCapability ({ deletionPubkey, deletionSeckey, autoDeletionCapability = true, preparedPublications = [] }) {
   if (deletionSeckey !== undefined) throw new ValidationError('DELETION_SECKEY_NOT_ACCEPTED')
   if (typeof autoDeletionCapability !== 'boolean') throw new ValidationError('AUTO_DELETION_CAPABILITY_BOOLEAN_REQUIRED')
 
   const normalizedDeletionPubkey = normalizeDeletionPubkey(deletionPubkey)
-  if (preparedPublication) {
-    const capability = preparedPublication.deletionCapability
-    if (!capability || (capability.deletionPubkey !== undefined && normalizeDeletionPubkey(capability.deletionPubkey) !== capability.deletionPubkey) ||
-        (normalizedDeletionPubkey && normalizedDeletionPubkey !== capability.deletionPubkey) ||
-        (capability.deletionSeckey !== undefined && keypairFromSeckey(capability.deletionSeckey).pubkey !== capability.deletionPubkey) ||
-        preparedPublication.events?.some(event => event.tags.find(tag => tag[0] === 's')?.[1] !== capability.deletionPubkey)) throw new ValidationError('INVALID_PREPARED_PUBLICATION')
+  if (preparedPublications.length) {
+    const capability = preparedPublications[0].deletionCapability
+    if (!capability) throw new ValidationError('INVALID_PREPARED_PUBLICATION')
+    for (const publication of preparedPublications) {
+      const current = publication.deletionCapability
+      if (!current || (current.deletionPubkey !== capability.deletionPubkey) ||
+          (current.deletionSeckey !== capability.deletionSeckey) ||
+          (current.deletionPubkey !== undefined && normalizeDeletionPubkey(current.deletionPubkey) !== current.deletionPubkey) ||
+          (normalizedDeletionPubkey && normalizedDeletionPubkey !== capability.deletionPubkey) ||
+          (capability.deletionSeckey !== undefined && keypairFromSeckey(capability.deletionSeckey).pubkey !== capability.deletionPubkey) ||
+          publication.events?.some(event => event.tags.find(tag => tag[0] === 's')?.[1] !== capability.deletionPubkey)) {
+        throw new ValidationError('INVALID_PREPARED_PUBLICATION')
+      }
+    }
     return { ...capability }
   }
   if (normalizedDeletionPubkey) return { deletionPubkey: normalizedDeletionPubkey }
@@ -63,9 +72,9 @@ function resolveDeletionCapability ({ deletionPubkey, deletionSeckey, autoDeleti
 
 function preparedSeedHandler (onPreparedSeed, deletion) {
   if (!onPreparedSeed) return undefined
-  return seed => {
+  return (seed, options) => {
     seed.publication.deletionCapability = deletion
-    return onPreparedSeed(seed)
+    return onPreparedSeed(seed, options)
   }
 }
 
@@ -668,11 +677,11 @@ async function sendPrivateMessage ({
   _getIykcProofs,
   fileChunkIndex,
   onPreparedSeed,
-  preparedPublication,
+  preparedPublications,
   _publish = privateChannel.publish
 }) {
   if (!privateChannelSigner?.getPublicKey) throw new ValidationError('PRIVATE_CHANNEL_WRITER_REQUIRED')
-  return _publish({ senderSigner, imkcSigner, privateChannelSigner, privateChannelReaderPubkey, receivers, receiverTag, deletionPubkey, event, relays, relayToReceivers, recoveryRelays, expirationSeconds, temporaryStorageArea, fileChunkIndex, onPreparedSeed, preparedPublication, _getIykcProofs })
+  return _publish({ senderSigner, imkcSigner, privateChannelSigner, privateChannelReaderPubkey, receivers, receiverTag, deletionPubkey, event, relays, relayToReceivers, recoveryRelays, expirationSeconds, temporaryStorageArea, fileChunkIndex, onPreparedSeed, preparedPublications: preparedPublications?.length ? preparedPublications : undefined, _getIykcProofs })
 }
 
 async function sendNymMessage ({
@@ -841,21 +850,29 @@ export async function yell ({
   deletionSeckey,
   autoDeletionCapability = true,
   fileChunkIndex,
+  createdAt,
   onPreparedSeed,
+  preparedPublication,
+  preparedPublications,
   _publish = privateChannel.publish
 }) {
-  const receivers = uniq(receiverPubkeys)
+  const prepared = normalizePreparedPublications({ preparedPublication, preparedPublications })
+  const receivers = uniq(receiverPubkeys?.length
+    ? receiverPubkeys
+    : prepared.flatMap(publication => publication.receiverPubkeys || []))
   if (!receivers.length) throw new ValidationError('NO_RECEIVERS')
+  const rumor = makeMessageRumor({
+    kind: TELL_KIND,
+    tags: [],
+    message: message || { code, payload, error, content }
+  })
+  if (createdAt !== undefined) rumor.created_at = createdAt
   const { event, wireEvent } = await makeOutgoingRumor({
     senderSigner,
-    rumor: makeMessageRumor({
-      kind: TELL_KIND,
-      tags: [],
-      message: message || { code, payload, error, content }
-    })
+    rumor
   })
-  const deletion = resolveDeletionCapability({ deletionPubkey, deletionSeckey, autoDeletionCapability })
-  const reports = await sendPrivateMessage({ senderSigner, imkcSigner, privateChannelSigner, privateChannelReaderPubkey, receivers, receiverTag: '', deletionPubkey: deletion.deletionPubkey, event: wireEvent, relays, relayToReceivers, recoveryRelays, expirationSeconds, temporaryStorageArea, fileChunkIndex, onPreparedSeed, _getIykcProofs, _publish })
+  const deletion = resolveDeletionCapability({ deletionPubkey, deletionSeckey, autoDeletionCapability, preparedPublications: prepared })
+  const reports = await sendPrivateMessage({ senderSigner, imkcSigner, privateChannelSigner, privateChannelReaderPubkey, receivers, receiverTag: '', deletionPubkey: deletion.deletionPubkey, event: wireEvent, relays, relayToReceivers, recoveryRelays, expirationSeconds, temporaryStorageArea, fileChunkIndex, onPreparedSeed: preparedSeedHandler(onPreparedSeed, deletion), preparedPublications: prepared, _getIykcProofs, _publish })
   return withDelivery({ yell: event }, reports, deletion.deletionSeckey)
 }
 
@@ -878,13 +895,15 @@ export async function broadcastRumor ({
   fileChunkIndex,
   onPreparedSeed,
   preparedPublication,
+  preparedPublications,
   _publish = privateChannel.publish
 }) {
   const receivers = uniq(receiverPubkeys)
   if (!receivers.length) throw new ValidationError('NO_RECEIVERS')
+  const prepared = normalizePreparedPublications({ preparedPublication, preparedPublications })
   const { event, wireEvent } = await makeOutgoingRumor({ senderSigner, rumor })
-  const deletion = resolveDeletionCapability({ deletionPubkey, deletionSeckey, autoDeletionCapability, preparedPublication })
-  const reports = await sendPrivateMessage({ senderSigner, imkcSigner, privateChannelSigner, privateChannelReaderPubkey, receivers, receiverTag: '', deletionPubkey: deletion.deletionPubkey, event: wireEvent, relays, relayToReceivers, recoveryRelays, expirationSeconds, temporaryStorageArea, fileChunkIndex, onPreparedSeed: preparedSeedHandler(onPreparedSeed, deletion), preparedPublication, _getIykcProofs, _publish })
+  const deletion = resolveDeletionCapability({ deletionPubkey, deletionSeckey, autoDeletionCapability, preparedPublications: prepared })
+  const reports = await sendPrivateMessage({ senderSigner, imkcSigner, privateChannelSigner, privateChannelReaderPubkey, receivers, receiverTag: '', deletionPubkey: deletion.deletionPubkey, event: wireEvent, relays, relayToReceivers, recoveryRelays, expirationSeconds, temporaryStorageArea, fileChunkIndex, onPreparedSeed: preparedSeedHandler(onPreparedSeed, deletion), preparedPublications: prepared, _getIykcProofs, _publish })
   return withDelivery({ rumor: event }, reports, deletion.deletionSeckey)
 }
 
@@ -907,13 +926,15 @@ export async function broadcastEvent ({
   fileChunkIndex,
   onPreparedSeed,
   preparedPublication,
+  preparedPublications,
   _publish = privateChannel.publish
 }) {
   const receivers = uniq(receiverPubkeys)
   if (!receivers.length) throw new ValidationError('NO_RECEIVERS')
+  const prepared = normalizePreparedPublications({ preparedPublication, preparedPublications })
   const wireEvent = assertValidSignedEvent({ ...event, tags: cloneTags(event?.tags) })
-  const deletion = resolveDeletionCapability({ deletionPubkey, deletionSeckey, autoDeletionCapability, preparedPublication })
-  const reports = await sendPrivateMessage({ senderSigner, imkcSigner, privateChannelSigner, privateChannelReaderPubkey, receivers, receiverTag: '', deletionPubkey: deletion.deletionPubkey, event: wireEvent, relays, relayToReceivers, recoveryRelays, expirationSeconds, temporaryStorageArea, fileChunkIndex, onPreparedSeed: preparedSeedHandler(onPreparedSeed, deletion), preparedPublication, _getIykcProofs, _publish })
+  const deletion = resolveDeletionCapability({ deletionPubkey, deletionSeckey, autoDeletionCapability, preparedPublications: prepared })
+  const reports = await sendPrivateMessage({ senderSigner, imkcSigner, privateChannelSigner, privateChannelReaderPubkey, receivers, receiverTag: '', deletionPubkey: deletion.deletionPubkey, event: wireEvent, relays, relayToReceivers, recoveryRelays, expirationSeconds, temporaryStorageArea, fileChunkIndex, onPreparedSeed: preparedSeedHandler(onPreparedSeed, deletion), preparedPublications: prepared, _getIykcProofs, _publish })
   return withDelivery({ event: wireEvent }, reports, deletion.deletionSeckey)
 }
 

package/private-messenger/file/index.js

@@ -4,6 +4,7 @@ import { createFileCache } from './helpers/cache.js'
 export { createFileCache, DEFAULT_FILE_CACHE_BYTES } from './helpers/cache.js'
 import { createFileCatalog } from './helpers/catalog.js'
 import { assertMessagePublished } from '../helpers/publication.js'
+import { normalizePreparedPublications } from '../../private-channel/helpers/prepared.js'
 import { ValidationError } from '../../error/index.js'
 import { IRFS_CHUNK_BYTES, decodeIrfsChunk } from '../../irfs/index.js'
 import { createQueue } from '../../idb-queue/index.js'
@@ -151,9 +152,10 @@ export function createPrivateFileTransfer ({ messenger, resolveChannel, storage,
   function sendOptions (file, routes) {
     return { senderSigner: messenger.userSigner, imkcSigner: messenger.contentKeySigner, privateChannelSigner: file.signer, ...routes, temporaryStorageArea: messenger.temporaryStorageArea, expirationSeconds: messenger.eventExpirationSecondsFor(file.controlChannelPubkey), _getIykcProofs: messenger.contentKeyLookup() }
   }
-  async function publishChunk (descriptor, event, { signal, attemptStartedAt, onPreparedSeed, preparedPublication, onDebug } = {}) {
+  async function publishChunk (descriptor, event, { signal, attemptStartedAt, onPreparedSeed, preparedPublication, preparedPublications, onDebug } = {}) {
     const file = await register(descriptor)
     usable(file)
+    const prepared = normalizePreparedPublications({ preparedPublication, preparedPublications })
     const decoded = checked(file, event)
     await catalog.ready
     if (ownsStorage) {
@@ -162,7 +164,7 @@ export function createPrivateFileTransfer ({ messenger, resolveChannel, storage,
     }
     let result
     try {
-      const options = { ...sendOptions(file, await routing(file, file.peerPubkey, signal, attemptStartedAt, onDebug)), receiverPubkeys: [file.peerPubkey], fileChunkIndex: decoded.index, preparedPublication, ...(onPreparedSeed ? { onPreparedSeed } : messenger.channels.get(file.controlChannelPubkey)?.mode === 'watchtower' ? { onPreparedSeed: seed => saveSeed(file, seed) } : {}) }
+      const options = { ...sendOptions(file, await routing(file, file.peerPubkey, signal, attemptStartedAt, onDebug)), receiverPubkeys: [file.peerPubkey], fileChunkIndex: decoded.index, preparedPublications: prepared.length ? prepared : undefined, ...(onPreparedSeed ? { onPreparedSeed } : messenger.channels.get(file.controlChannelPubkey)?.mode === 'watchtower' ? { onPreparedSeed: seed => saveSeed(file, seed) } : {}) }
       result = event.sig ? await _messages.broadcastEvent({ ...options, event }) : await _messages.broadcastRumor({ ...options, rumor: event })
       await assertMessagePublished(result, result?.rumor || result?.event || { ...event, pubkey: event.pubkey || messenger.userPubkey })
     } catch (error) { await uploadLeases.get(file.root)?.(); uploadLeases.delete(file.root); throw error }

package/private-messenger/helpers/fallback-race.js

@@ -2,7 +2,7 @@ import { isReplaceableRelayFailure } from '../../relay/helpers/failure.js'
 
 // Each invocation owns one already signed outer event and its encrypted subset.
 // Lanes share coverage and the tried set; only started reports outlive the race.
-export function publishWithEarlyFallback ({ event, receivers, first, mirrors, tried, nextPrimary, nextFallback, sendEvent, isOnline, isCurrent, signal, pauseSignal, remember, rememberSuccess = () => {}, delay, attemptStartedAt, monotonicNow = () => performance.now(), now, setTimer, clearTimer }) {
+export function publishWithEarlyFallback ({ event, receivers, first, mirrors, tried, getRetryEvent, nextPrimary, nextFallback, sendEvent, isOnline, isCurrent, signal, pauseSignal, remember, rememberSuccess = () => {}, delay, attemptStartedAt, monotonicNow = () => performance.now(), now, setTimer, clearTimer }) {
   const pending = new Set(receivers)
   const summaries = []
   const transportSignal = signal && pauseSignal ? AbortSignal.any([signal, pauseSignal]) : signal || pauseSignal
@@ -33,6 +33,13 @@ export function publishWithEarlyFallback ({ event, receivers, first, mirrors, tr
       ...(interruptedWork && !signal?.aborted ? { retryWhenAvailable: true, ...(offline ? { retryWhenOnline: true } : {}) } : {})
     })
   }
+  const fail = error => {
+    if (done) return
+    done = true
+    clearTimer(timer); timer = null
+    transportSignal?.removeEventListener('abort', interrupted)
+    outcome.reject(error)
+  }
   const check = () => {
     if (done) return
     if (!pending.size) finish(true)
@@ -59,7 +66,11 @@ export function publishWithEarlyFallback ({ event, receivers, first, mirrors, tr
     const slot = Promise.withResolvers()
     summaries.push(slot.promise)
     let result
-    try { result = await sendEvent(event, relays, { signal: transportSignal }) } catch (reason) {
+    try { result = await sendEvent(event, relays, { signal: transportSignal, getRetryEvent }) } catch (reason) {
+      if (reason?.code === 'RETRY_EVENT_PREPARATION_FAILED') {
+        fail(reason)
+        return
+      }
       result = { success: false, promise: Promise.resolve({ fulfilled: 0, errors: [{ reason }] }) }
     }
     const settled = Promise.resolve(result.promise).catch(reason => ({ fulfilled: 0, errors: [{ reason }] }))

package/private-messenger/helpers/send-routing.js

@@ -123,6 +123,7 @@ export function createSendRelayRouting ({ peer, peers = [peer], relaysByPubkey,
       }
       const result = await publishWithEarlyFallback({
         event, receivers, first: first.length ? { receivers, relays: first } : null, mirrors, tried,
+        getRetryEvent: context.getRetryEvent,
         nextPrimary: pending => pick(pending, false), nextFallback: pending => pick(pending, true),
         sendEvent, isOnline, isCurrent, signal, pauseSignal, remember, rememberSuccess,
         delay: fallbackDelayMs, attemptStartedAt, monotonicNow, now, setTimer, clearTimer
@@ -158,7 +159,7 @@ export function createSendRelayRouting ({ peer, peers = [peer], relaysByPubkey,
       for (const relay of relays) tried.add(normalized(relay))
       // Every relay in this batch serves the same pending recipient subset.
       // One ACK covers that subset, never unrelated members of the ciphertext.
-      result = await sendEvent(event, relays, { signal: transportSignal })
+      result = await sendEvent(event, relays, { signal: transportSignal, getRetryEvent: context.getRetryEvent })
       const settled = Promise.resolve(result.promise)
       summaries.push(settled)
       settled.then(report => rememberSuccess(report?.succeededRelays || [])).catch(() => {})

package/private-messenger/index.js

@@ -56,6 +56,7 @@ import { recoveryRetryDelay, isPermanentRecoveryError } from './helpers/recovery
 import { assertMessagePublished, publicationFailureDiagnostic, sanitizePublicationError } from './helpers/publication.js'
 import { normalizeRelayUrl } from '../url/index.js'
 import { deliveryInfo } from '../private-channel/helpers/rumor.js'
+import { normalizePreparedPublications } from '../private-channel/helpers/prepared.js'
 import { migrateMessageQueue } from './services/migrate-message-queue.js'
 import { createPendingDecryption, pendingContentKeyGroup, pendingMissingContentKeyGroup } from './services/pending-decryption.js'
 import { createDecryptionScheduler } from './services/decryption-scheduler.js'
@@ -2415,18 +2416,22 @@ export class PrivateMessenger {
     } finally { releaseActivity() }
   }
 
-  async yell ({ channelPubkey = this.defaultChannelPubkey(), receiverPubkeys, relays, relayToReceivers, message, code, payload, error, content, deletionPubkey }) {
+  async yell ({ channelPubkey = this.defaultChannelPubkey(), receiverPubkeys, relays, relayToReceivers, message, code, payload, error, content, deletionPubkey, createdAt, onPreparedSeed, preparedPublication, preparedPublications }) {
     const channel = this.requireWritableChannel(channelPubkey)
     const releaseActivity = this.decryptionScheduler.activity(channelPubkey)
     try {
-      const routing = await this.resolveSendRouting({ channel, receiverPubkeys, relays, relayToReceivers })
-      this.debugSend('yell', channelPubkey, { code, receiverPubkeys })
+      const prepared = normalizePreparedPublications({ preparedPublication, preparedPublications })
+      const receivers = uniq(receiverPubkeys?.length
+        ? receiverPubkeys
+        : prepared.flatMap(publication => publication.receiverPubkeys || []))
+      const routing = await this.resolveSendRouting({ channel, receiverPubkeys: receivers, relays, relayToReceivers })
+      this.debugSend('yell', channelPubkey, { code, receiverPubkeys: receivers })
       return await this._privateMessage.yell({
         senderSigner: this.userSigner,
         imkcSigner: this.contentKeySigner,
         privateChannelSigner: channel.signer,
         privateChannelReaderPubkey: channel.readerPubkey,
-        receiverPubkeys,
+        receiverPubkeys: receivers,
         ...routing,
         expirationSeconds: this.eventExpirationSecondsFor(channel),
         temporaryStorageArea: this.temporaryStorageArea,
@@ -2437,24 +2442,30 @@ export class PrivateMessenger {
         payload,
         error,
         content,
-        onPreparedSeed: this.outgoingSeedHandler(channelPubkey),
+        createdAt,
+        onPreparedSeed: onPreparedSeed || this.outgoingSeedHandler(channelPubkey),
+        preparedPublications: prepared.length ? prepared : undefined,
         _getIykcProofs: this.contentKeyLookup()
       })
     } finally { releaseActivity() }
   }
 
-  async broadcastRumor ({ channelPubkey = this.defaultChannelPubkey(), receiverPubkeys, relays, relayToReceivers, rumor, deletionPubkey, signal, attemptStartedAt, onPreparedSeed, preparedPublication, onDebug }) {
+  async broadcastRumor ({ channelPubkey = this.defaultChannelPubkey(), receiverPubkeys, relays, relayToReceivers, rumor, deletionPubkey, signal, attemptStartedAt, onPreparedSeed, preparedPublication, preparedPublications, onDebug }) {
     const channel = this.requireWritableChannel(channelPubkey)
     const releaseActivity = this.decryptionScheduler.activity(channelPubkey)
     try {
-      const routing = await this.resolveSendRouting({ channel, receiverPubkeys, relays, relayToReceivers, signal, attemptStartedAt, onDebug })
-      this.debugSend('broadcastRumor', channelPubkey, { receiverPubkeys })
+      const prepared = normalizePreparedPublications({ preparedPublication, preparedPublications })
+      const receivers = uniq(receiverPubkeys?.length
+        ? receiverPubkeys
+        : prepared.flatMap(publication => publication.receiverPubkeys || []))
+      const routing = await this.resolveSendRouting({ channel, receiverPubkeys: receivers, relays, relayToReceivers, signal, attemptStartedAt, onDebug })
+      this.debugSend('broadcastRumor', channelPubkey, { receiverPubkeys: receivers })
       return await this._privateMessage.broadcastRumor({
         senderSigner: this.userSigner,
         imkcSigner: this.contentKeySigner,
         privateChannelSigner: channel.signer,
         privateChannelReaderPubkey: channel.readerPubkey,
-        receiverPubkeys,
+        receiverPubkeys: receivers,
         ...routing,
         expirationSeconds: this.eventExpirationSecondsFor(channel),
         temporaryStorageArea: this.temporaryStorageArea,
@@ -2462,24 +2473,28 @@ export class PrivateMessenger {
         autoDeletionCapability: this.autoDeletionCapabilityFor(channel),
         rumor,
         onPreparedSeed: onPreparedSeed || this.outgoingSeedHandler(channelPubkey),
-        preparedPublication,
+        preparedPublications: prepared.length ? prepared : undefined,
         _getIykcProofs: this.contentKeyLookup()
       })
     } finally { releaseActivity() }
   }
 
-  async broadcastEvent ({ channelPubkey = this.defaultChannelPubkey(), receiverPubkeys, relays, relayToReceivers, event, deletionPubkey, signal, attemptStartedAt, onPreparedSeed, preparedPublication, onDebug }) {
+  async broadcastEvent ({ channelPubkey = this.defaultChannelPubkey(), receiverPubkeys, relays, relayToReceivers, event, deletionPubkey, signal, attemptStartedAt, onPreparedSeed, preparedPublication, preparedPublications, onDebug }) {
     const channel = this.requireWritableChannel(channelPubkey)
     const releaseActivity = this.decryptionScheduler.activity(channelPubkey)
     try {
-      const routing = await this.resolveSendRouting({ channel, receiverPubkeys, relays, relayToReceivers, signal, attemptStartedAt, onDebug })
-      this.debugSend('broadcastEvent', channelPubkey, { receiverPubkeys })
+      const prepared = normalizePreparedPublications({ preparedPublication, preparedPublications })
+      const receivers = uniq(receiverPubkeys?.length
+        ? receiverPubkeys
+        : prepared.flatMap(publication => publication.receiverPubkeys || []))
+      const routing = await this.resolveSendRouting({ channel, receiverPubkeys: receivers, relays, relayToReceivers, signal, attemptStartedAt, onDebug })
+      this.debugSend('broadcastEvent', channelPubkey, { receiverPubkeys: receivers })
       return await this._privateMessage.broadcastEvent({
         senderSigner: this.userSigner,
         imkcSigner: this.contentKeySigner,
         privateChannelSigner: channel.signer,
         privateChannelReaderPubkey: channel.readerPubkey,
-        receiverPubkeys,
+        receiverPubkeys: receivers,
         ...routing,
         expirationSeconds: this.eventExpirationSecondsFor(channel),
         temporaryStorageArea: this.temporaryStorageArea,
@@ -2487,7 +2502,7 @@ export class PrivateMessenger {
         autoDeletionCapability: this.autoDeletionCapabilityFor(channel),
         event,
         onPreparedSeed: onPreparedSeed || this.outgoingSeedHandler(channelPubkey),
-        preparedPublication,
+        preparedPublications: prepared.length ? prepared : undefined,
         _getIykcProofs: this.contentKeyLookup()
       })
     } finally { releaseActivity() }

package/private-messenger/services/pending-decryption.js

@@ -48,6 +48,11 @@ function replaceErrorMetadata (item, error) {
   return Object.assign(next, errorMetadata(error))
 }
 
+function createdAtMetadata (item) {
+  const value = item?.packet?.outer?.created_at ?? item?.outer?.created_at
+  return Number.isSafeInteger(value) ? { outerCreatedAt: value } : {}
+}
+
 export function pendingContentKeyGroup (item) {
   const receiver = item?.receiverPubkey
   const own = item?.ownContentPubkey
@@ -92,7 +97,7 @@ export async function createPendingDecryption ({ prefix, indexedDB, maxBytes = P
   const notify = (action, detail) => {
     report({ action, ...detail })
     const key = `${action}:${detail.code || detail.reason || ''}`
-    counts[key] = { count: (counts[key]?.count || 0) + 1, example: detail }
+    counts[key] = { count: (counts[key]?.count || 0) + 1, sample: detail }
     if (!timer) { timer = setTimeout(flush, 1000); timer.unref?.() }
   }
   return {
@@ -129,7 +134,16 @@ export async function createPendingDecryption ({ prefix, indexedDB, maxBytes = P
         if (evictedBytes) notify('discarded', { reason: 'capacity', bytes: evictedBytes })
         const coordinates = Object.fromEntries(['eventId', 'eventKind', 'senderPubkey', 'receiverPubkey', 'ownContentPubkey', 'peerContentPubkey', 'hasOwnContentKey']
           .filter(key => ['string', 'boolean', 'number'].includes(typeof error[key])).map(key => [key, error[key]]))
-        notify('deferred', { ...coordinates, code: error.code, stage: error.stage, id, channelPubkey: item.channelPubkey, capacityBytesBefore: before.usedBytes, capacityBytesAfter: after.usedBytes })
+        notify('deferred', {
+          ...coordinates,
+          ...createdAtMetadata(record),
+          code: error.code,
+          stage: error.stage,
+          id,
+          channelPubkey: item.channelPubkey,
+          capacityBytesBefore: before.usedBytes,
+          capacityBytesAfter: after.usedBytes
+        })
         return true
       })
     },
@@ -148,7 +162,7 @@ export async function createPendingDecryption ({ prefix, indexedDB, maxBytes = P
     recovered (item) {
       return serial(async () => {
         await queue.removeBy('byId', item.id)
-        notify('recovered', { id: item.id, channelPubkey: item.channelPubkey })
+        notify('recovered', { id: item.id, channelPubkey: item.channelPubkey, ...createdAtMetadata(item) })
       })
     },
     failed (item, error) {
@@ -161,7 +175,9 @@ export async function createPendingDecryption ({ prefix, indexedDB, maxBytes = P
           macAttempts: current.macAttempts + (error.code === 'INVALID_MAC' ? 1 : 0)
         }
         await queue.putBy('byId', updated, { existingOnly: true })
-        if (updated.macAttempts >= 3 && item.macAttempts < 3) notify('suspended', { id: item.id, code: error.code, channelPubkey: item.channelPubkey })
+        if (updated.macAttempts >= 3 && item.macAttempts < 3) {
+          notify('suspended', { id: item.id, code: error.code, channelPubkey: item.channelPubkey, ...createdAtMetadata(updated) })
+        }
       })
     },
     clearChannel: channel => serial(() => queue.removeBy('byChannel', channel)),

package/private-messenger/session/README.md

@@ -289,9 +289,17 @@ recipient/channel and inner-event identities, event/chunk position, retention
 and accepted/archived flags. Old entries without it retain `localSaved`, index
 and file/chunk progress and enter the same preparation path; there is no database
 migration or alternate publisher. Replays validate signatures and identity and
-reuse the exact envelopes without repeating cryptography or extending expiry.
-
-The existing `onPreparedSeed` callback now also supplies `publication`. The
+reuse the exact envelopes without repeating cryptography or extending expiry,
+except for one 3560 age-auth refresh. That refresh reuses router/ciphertext and
+seeds but re-signs the whole publication with a new shared `created_at` and
+recomputed `expiration`, writes the replacement generation before retrying, and
+sets `outerRefreshAttempted` so reload cannot repeat it. A relay may report a
+stale wrapper as `invalid:`; that prefix permits this refresh but does not
+attempt NIP-42 authentication.
+
+The existing `onPreparedSeed` callback now also supplies `publication`, plus an
+optional `{ replace: true }` second argument when a refreshed publication must
+replace the same inner-event/receiver group in place. The
 session commits that minimal journal before transmitting; direct messengers
 retain their local seed-store durability. Only after that commit can relay
 publication proceed. One independent serial worker converts recovery seeds into
@@ -321,6 +329,12 @@ relay confirmation separately from `localSaved`. Old entries normalize from
 saved delivery status, never from local progress; their event/file indices and
 prepared envelopes remain unchanged. No database migration is needed.
 
+Prepared envelopes are stored as the `prepared.publications` array. Older
+snapshots containing `prepared.publication` are converted to a one-item array
+and rewritten through the same encrypted outbox queue before publication or
+archive work resumes. The singular key is never written by current versions and
+is not accepted as a public replay argument.
+
 `onOutbox` adds `localPersistence: { state, retryable }`, where state is pending,
 saved or failed. It is a presentation summary with no native error objects.
 A saved remote entry may still have pending/failed local work. Keep it visible

package/private-messenger/session/helpers/prepared-state.js

@@ -0,0 +1,17 @@
+import { ValidationError } from '../../../error/index.js'
+
+export function normalizePreparedState (prepared) {
+  if (!prepared) return { prepared, migrated: false }
+  const legacy = prepared.publication
+  const publications = prepared.publications !== undefined
+    ? prepared.publications
+    : legacy !== undefined
+      ? [legacy]
+      : null
+  if (!Array.isArray(publications) || publications.length === 0) {
+    throw new ValidationError('INVALID_PREPARED_PUBLICATIONS')
+  }
+  prepared.publications = publications
+  delete prepared.publication
+  return { prepared, migrated: legacy !== undefined }
+}

package/private-messenger/session/helpers/publication-journal.js

@@ -24,7 +24,7 @@ export function createPublicationJournal ({ entries, store, archive, changed, on
   function rows (entry) {
     const packet = entry.prepared
     if (!packet?.recover) return []
-    return packet.publication.seeds.flatMap(seed => compactSeedRouterRows(seed).map(row => {
+    return packet.publications.flatMap(publication => publication.seeds.flatMap(seed => compactSeedRouterRows(seed).map(row => {
       const descriptor = packet.target.file
       const value = {
         ...row, channelPubkey: seed.channelPubkey, receivedAt: packet.receivedAt,
@@ -32,15 +32,15 @@ export function createPublicationJournal ({ entries, store, archive, changed, on
         ...(descriptor
           ? {
               root: descriptor.root, controlChannelPubkey: descriptor.controlChannelPubkey,
-              fileChannelPubkey: packet.publication.channelPubkey, peerPubkey: descriptor.peerPubkey,
+              fileChannelPubkey: publication.channelPubkey, peerPubkey: descriptor.peerPubkey,
               chunkIndex: packet.target.chunkIndex,
-              key: `${descriptor.controlChannelPubkey}:${packet.publication.channelPubkey}:${row.receiverPubkey}:${packet.target.chunkIndex}`
+              key: `${descriptor.controlChannelPubkey}:${publication.channelPubkey}:${row.receiverPubkey}:${packet.target.chunkIndex}`
             }
           : {})
       }
       value.recordId = encodeRecord('seed', value).tags[0][1]
       return value
-    }))
+    })))
   }
   function retryLater () {
     if (stopped || !enabled || timer || !failed.size) return
@@ -60,7 +60,7 @@ export function createPublicationJournal ({ entries, store, archive, changed, on
         try {
           if (!durable.has(packet)) { await write(entry); durable.add(packet) }
           if (!packet.archived) {
-            debug(entry, 'recovery-archive-start', queued.get(packet), { publicationId: packet.publication.events[0].id })
+            debug(entry, 'recovery-archive-start', queued.get(packet), { publicationId: packet.publications[0].events[0].id })
             if (packet.recover) await archive(entry, rows(entry))
             packet.archived = true
             debug(entry, 'recovery-archived', started)
@@ -87,15 +87,43 @@ export function createPublicationJournal ({ entries, store, archive, changed, on
     write,
     async flush (entry) { while (writes.has(entry.id)) await writes.get(entry.id) },
     adopt (entry) { if (entry.prepared) { durable.add(entry.prepared); queued.set(entry.prepared, Date.now()) } },
-    async stage (entry, seed, target, retentionSeconds) {
+    async stage (entry, seed, target, retentionSeconds, { replace = false } = {}) {
       const started = Date.now()
-      if (entry.prepared && entry.prepared.publication.events[0].id !== seed.publication.events[0].id) throw new Error('PUBLICATION_ARCHIVE_PENDING')
-      entry.prepared ||= { publication: structuredClone(seed.publication), target, receivedAt: Math.floor(Date.now() / 1000), retentionSeconds, recover: retentionSeconds > 0, accepted: false, archived: retentionSeconds <= 0 }
-      if (durable.has(entry.prepared)) return
+      const publication = structuredClone(seed.publication)
+      const targetKey = JSON.stringify(target)
+      entry.prepared ||= { publications: [], target, receivedAt: Math.floor(Date.now() / 1000), retentionSeconds, recover: retentionSeconds > 0, accepted: false, archived: retentionSeconds <= 0 }
+      if (replace && targetKey !== JSON.stringify(entry.prepared.target)) throw new Error('PUBLICATION_ARCHIVE_TARGET_MISMATCH')
+      if (entry.prepared.publications.some(existing => existing.innerEventId !== publication.innerEventId)) {
+        throw new Error('PUBLICATION_ARCHIVE_PENDING')
+      }
+      const receiverKey = (publication.receiverPubkeys || []).slice().sort().join(',')
+      const eventKey = publication.events.map(event => event.id).join(',')
+      const matchingIndexes = entry.prepared.publications
+        .map((existing, index) => ({ existing, index }))
+        .filter(({ existing }) => existing.innerEventId === publication.innerEventId &&
+          (existing.receiverPubkeys || []).slice().sort().join(',') === receiverKey)
+      const existingIndex = matchingIndexes[0]?.index ?? -1
+      const existing = matchingIndexes[0]?.existing
+      const duplicate = Boolean(existing) &&
+        existing.events.map(event => event.id).join(',') === eventKey
+      const matches = existingIndex >= 0
+      if (replace) {
+        if (!matches) throw new Error('PUBLICATION_ARCHIVE_REPLACE_MISSING')
+        entry.prepared.publications = entry.prepared.publications
+          .filter((_publication, index) => index !== existingIndex)
+          .filter(candidate =>
+            candidate.innerEventId !== publication.innerEventId ||
+            (candidate.receiverPubkeys || []).slice().sort().join(',') !== receiverKey
+          )
+        entry.prepared.publications.splice(existingIndex, 0, publication)
+      } else {
+        if (!duplicate) entry.prepared.publications.push(publication)
+        if (duplicate && durable.has(entry.prepared)) return
+      }
       queued.set(entry.prepared, Date.now())
       await write(entry)
       durable.add(entry.prepared)
-      debug(entry, 'publication-checkpoint', started, { publicationId: seed.publication.events[0].id })
+      debug(entry, replace ? 'publication-refresh' : 'publication-checkpoint', started, { publicationId: seed.publication.events[0].id })
       for (const row of rows(entry)) debug(entry, 'recovery-pending', undefined, { seedRecordId: row.recordId, publicationId: seed.publication.events[0].id })
       wake()
     },

package/private-messenger/session/index.js

@@ -16,6 +16,7 @@ import { assertMessagePublished } from '../helpers/publication.js'
 import { normalizeFallbackRelays, normalizeFallbackDelay } from '../helpers/send-routing.js'
 import { createPublicationJournal, withPendingSeeds } from './helpers/publication-journal.js'
 import { createPauseRecovery, isRecoverableStorageFailure } from '../helpers/pause-recovery.js'
+import { normalizePreparedState } from './helpers/prepared-state.js'
 
 export function wireEvent (value, owner) {
   const event = { kind: value.kind, created_at: value.created_at, tags: structuredClone(value.tags), content: value.content, pubkey: value.pubkey || owner }
@@ -164,6 +165,7 @@ export function createPrivateMessageSession ({ owner, signer, eventStore, messag
   const idleWaiters = new Set()
   const settled = () => { if (!sending && !localSaving && !enqueuing && !draining && !cleanups.size) { for (const resolve of idleWaiters) resolve(); idleWaiters.clear() } }
   const localComplete = entry => entry.localSaved.every(Boolean)
+  const preparedPublicationId = entry => entry.prepared?.publications?.[0]?.events?.[0]?.id
   const completed = entry => !unadmitted.has(entry) && localComplete(entry) && (entry.peer === owner || entry.deliveryConfirmed)
   const emit = () => onOutbox([...entries.values()].filter(entry => !unadmitted.has(entry) && !entry.deletion && !entry.cancelled).map(entry => ({
     ...entry,
@@ -188,7 +190,7 @@ export function createPrivateMessageSession ({ owner, signer, eventStore, messag
       const onDiagnostic = details => {
         diagnosticReported = true
         debug(entry, 'recovery-archive-result', archiveStartedAt, {
-          publicationId: entry.prepared.publication.events[0].id,
+          publicationId: preparedPublicationId(entry),
           ...details
         })
       }
@@ -199,15 +201,19 @@ export function createPrivateMessageSession ({ owner, signer, eventStore, messag
           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)
+        for (const publication of entry.prepared.publications) {
+          for (const seed of 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)
+        for (const publication of entry.prepared.publications) {
+          for (const seed of 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,
+          publicationId: preparedPublicationId(entry),
           rowCount: rows.length,
           uniqueCount: new Set(rows.map(row => row.recordId).filter(Boolean)).size,
           storedCount,
@@ -226,6 +232,9 @@ export function createPrivateMessageSession ({ owner, signer, eventStore, messag
   const ready = () => (initialized ??= (async () => {
     storage = await openOutbox({ owner, signer, onDebug })
     for (const entry of await storage.list()) {
+      if (normalizePreparedState(entry.prepared).migrated) {
+        await storage.put(structuredClone(entry), { existing: true })
+      }
       // Old encrypted entries retain progress and enter this same pipeline.
       const legacyLocalFailure = entry.deliveryConfirmed === undefined && entry.failed && !entry.localSaved.every(Boolean)
       if (legacyLocalFailure) {
@@ -471,10 +480,10 @@ export function createPrivateMessageSession ({ owner, signer, eventStore, messag
     const options = {
       channelPubkey, receiverPubkeys: [peer], signal, attemptStartedAt: attemptStarts.get(entry.id),
       onDebug: onDebug ? value => debug(entry, value.stage, undefined, value) : undefined,
-      preparedPublication: entry.prepared?.publication,
-      onPreparedSeed: async seed => {
+      preparedPublications: entry.prepared?.publications,
+      onPreparedSeed: async (seed, { replace = false } = {}) => {
         debug(entry, 'envelope-prepared', preparationStartedAt, { publicationId: seed.publication.events[0].id })
-        await journal.stage(entry, seed, { index: entry.index }, retention)
+        await journal.stage(entry, seed, { index: entry.index }, retention, { replace })
         signal.throwIfAborted()
       }
     }
@@ -592,8 +601,11 @@ export function createPrivateMessageSession ({ owner, signer, eventStore, messag
           const recover = mode === 'watchtower' ? messenger.offlineRecoverySecondsFor?.(descriptor.controlChannelPubkey) ?? 0 : 0
           const target = { file: descriptor, fileIndex: entry.fileIndex, chunkIndex: entry.chunkIndex }
           await fileTransfers.publishChunk(descriptor, wireEvent(chunk, owner), {
-            signal: controller.signal, attemptStartedAt: chunkStartedAt, onDebug: onDebug ? value => debug(entry, value.stage, undefined, value) : undefined, preparedPublication: entry.prepared?.publication,
-            onPreparedSeed: async seed => { await journal.stage(entry, seed, target, recover); controller.signal.throwIfAborted() }
+            signal: controller.signal, attemptStartedAt: chunkStartedAt, onDebug: onDebug ? value => debug(entry, value.stage, undefined, value) : undefined, preparedPublications: entry.prepared?.publications,
+            onPreparedSeed: async (seed, { replace = false } = {}) => {
+              await journal.stage(entry, seed, target, recover, { replace })
+              controller.signal.throwIfAborted()
+            }
           })
           entry.chunkIndex++
           const completed = entry.files.slice(0, entry.fileIndex).reduce((sum, value) => sum + value.size, 0) + Math.min(file.size, entry.chunkIndex * IRFS_CHUNK_BYTES)