libp2r2p 0.11.23 → 0.11.25

package/README.md

@@ -633,9 +633,13 @@ tasks cannot deliver into a new channel generation. Mandatory persistence still
 owns its storage pause; incomplete history remains a pending recovery interval.
 Subscription setup is bounded separately from presence, so a slow announcement
 does not hold the other channels' readers. Sessions prioritize user persistence
-and publication before the next background presence signer call. Signing an outer
-envelope can overlap recovery-seed persistence, but no envelope is yielded for
-publication unless both succeed; only one outer is prepared at a time.
+and publication before the next background presence signer call. `onPreparedSeed`
+receives its existing router/jsonl fields plus `publication`, containing all
+signed fragments, recipient/channel identities and recovery rows for that logical
+event. The callback commits durable recovery before publication: a direct
+messenger uses its seed store; the session uses its encrypted outbox journal and
+archives indexed personal copies independently. No alternative legacy publisher
+is retained. Only one logical event/chunk is prepared per session entry at a time.
 
 `private-channel.fetch` reports incomplete reads as an `AggregateError` with
 stable `code: 'PRIVATE_CHANNEL_FETCH_INCOMPLETE'`. Its message names relays,
@@ -1241,5 +1245,9 @@ Private messenger/session constructors accept optional `fallbackDelayMs` (`null`
 by default). Automatic NIP-65 sends can start configured fallback relays after
 the chosen delay while primary publications retain their deadlines. Explicit
 routes keep sequential fallback; every encrypted recipient must be covered.
+Session `enqueue` accepts optional monotonic `attemptStartedAt`; supplied values
+make preparation consume that delay. Retries/reloads start a fresh attempt and
+uploads budget each chunk independently. Monotonic clocks never enter storage or
+Nostr events. Omitted timestamps keep the publication-local delay.
 `RelayPool.sendEvent` accepts a consumer `signal` without closing shared sockets.
 See [fallback and cancellation](private-messenger/session/README.md#relay-fallback).

package/package.json

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

package/private-channel/index.js

@@ -143,6 +143,7 @@ async function prepareRoutedMessage ({ senderSigner, imkcSigner, privateChannelS
       channelPubkey,
       channelReaderPubkey,
       preparedRows,
+      innerEventId: getEventHash({ ...event, pubkey: event.pubkey || senderPubkey }),
       imkcPubkey,
       imkcProof
     }
@@ -152,69 +153,74 @@ async function prepareRoutedMessage ({ senderSigner, imkcSigner, privateChannelS
   }
 }
 
-async function * wrapPreparedEvents ({ privateChannelSigner, receivers, receiverTag, fileChunkIndex, onPreparedSeed, deletionPubkey, expirationSeconds = EXPIRATION_SECONDS, context }) {
-  const routerSeckey = generateSecretKey()
-  const routerPubkey = getPublicKey(routerSeckey)
-  const receiverPubkeyList = receiverPubkeys(receivers)
-  const routerReceiverTag = receiverTag ?? (receiverPubkeyList.length === 1 ? receiverPubkeyList[0] : '')
-  const rowIndexes = preparedRowIndexesForReceivers(context.preparedRows, receivers)
-  const total = preparedChunkCount(context.preparedRows, rowIndexes)
-  const persistSeeds = async () => {
-    if (!onPreparedSeed) return
-    const router = makeRouterEvent({ pubkey: routerPubkey, senderPubkey: context.senderPubkey, imkcPubkey: context.imkcPubkey, imkcProof: context.imkcProof, receiverPubkey: routerReceiverTag, chunkIndex: 0, chunkTotal: 1, fileChunkIndex, content: '' })
+async function * wrapPreparedEvents ({ privateChannelSigner, senderSigner, event, receivers, receiverTag, fileChunkIndex, onPreparedSeed, deletionPubkey, expirationSeconds = EXPIRATION_SECONDS, context, preparedPublication }) {
+  let publication = preparedPublication
+  if (publication) {
+    const channelPubkey = await privateChannelSigner.getPublicKey()
+    const expected = receiverPubkeys(receivers).sort().join(',')
+    const innerEventId = getEventHash({ ...event, pubkey: event.pubkey || await senderSigner.getPublicKey() })
+    if (publication.innerEventId !== innerEventId || publication.channelPubkey !== channelPubkey || !Array.isArray(publication.receiverPubkeys) || publication.receiverPubkeys.slice().sort().join(',') !== expected ||
+        !Array.isArray(publication.events) || !publication.events.length || !Array.isArray(publication.seeds) ||
+        publication.events.some(event => !isValidEvent(event) || event.pubkey !== channelPubkey || event.kind !== PRIVATE_BROADCAST_KIND)) {
+      throw new ValidationError('INVALID_PREPARED_PUBLICATION')
+    }
+    if (publication.events.some(event => Number(event.tags.find(tag => tag[0] === 'expiration')?.[1]) <= nowSeconds())) throw new ValidationError('PREPARED_PUBLICATION_EXPIRED')
+  } else {
+    const routerSeckey = generateSecretKey()
+    const routerPubkey = getPublicKey(routerSeckey)
+    const receiverPubkeyList = receiverPubkeys(receivers)
+    const routerReceiverTag = receiverTag ?? (receiverPubkeyList.length === 1 ? receiverPubkeyList[0] : '')
+    const rowIndexes = preparedRowIndexesForReceivers(context.preparedRows, receivers)
+    const total = preparedChunkCount(context.preparedRows, rowIndexes)
+    const seedRouter = makeRouterEvent({ pubkey: routerPubkey, senderPubkey: context.senderPubkey, imkcPubkey: context.imkcPubkey, imkcProof: context.imkcProof, receiverPubkey: routerReceiverTag, chunkIndex: 0, chunkTotal: 1, fileChunkIndex, content: '' })
     const payloadRow = readPreparedRow(context.preparedRows, 0)
-    for (const rowIndex of rowIndexes) {
-      await onPreparedSeed({ channelPubkey: context.channelPubkey, router, jsonl: `${payloadRow}\n${readPreparedRow(context.preparedRows, rowIndex)}\n` })
+    const seeds = rowIndexes.map(rowIndex => ({ channelPubkey: context.channelPubkey, router: seedRouter, jsonl: `${payloadRow}\n${readPreparedRow(context.preparedRows, rowIndex)}\n` }))
+    const events = []
+    let index = 0
+    for (const content of preparedChunks(context.preparedRows, rowIndexes)) {
+      const router = finalizeEvent(makeRouterEvent({
+        pubkey: routerPubkey, senderPubkey: context.senderPubkey, imkcPubkey: context.imkcPubkey,
+        imkcProof: context.imkcProof, receiverPubkey: routerReceiverTag, fileChunkIndex,
+        chunkIndex: index++, chunkTotal: total, content
+      }), routerSeckey)
+      const createdAt = nowSeconds()
+      const outer = await privateChannelSigner.signEvent({
+        kind: PRIVATE_BROADCAST_KIND, created_at: createdAt,
+        tags: privateBroadcastTags({ deletionPubkey, createdAt, expirationSeconds }),
+        content: await nip44v3EncryptText(privateChannelSigner, context.channelReaderPubkey, PRIVATE_BROADCAST_KIND, JSON.stringify(router))
+      })
+      if (eventByteLength(outer) > MAX_EVENT_BYTES) throw new ValidationError('EVENT_TOO_LARGE')
+      events.push(outer)
     }
+    publication = { innerEventId: context.innerEventId, channelPubkey: context.channelPubkey, receiverPubkeys: receiverPubkeyList, events, seeds }
   }
-  let index = 0
-  for (const content of preparedChunks(context.preparedRows, rowIndexes)) {
-    const router = finalizeEvent(makeRouterEvent({
-      pubkey: routerPubkey,
-      senderPubkey: context.senderPubkey,
-      imkcPubkey: context.imkcPubkey,
-      imkcProof: context.imkcProof,
-      receiverPubkey: routerReceiverTag,
-      fileChunkIndex,
-      chunkIndex: index++,
-      chunkTotal: total,
-      content
-    }), routerSeckey)
-    const createdAt = nowSeconds()
-    const prepareOuter = async () => privateChannelSigner.signEvent({
-      kind: PRIVATE_BROADCAST_KIND,
-      created_at: createdAt,
-      tags: privateBroadcastTags({ deletionPubkey, createdAt, expirationSeconds }),
-      content: await nip44v3EncryptText(privateChannelSigner, context.channelReaderPubkey, PRIVATE_BROADCAST_KIND, JSON.stringify(router))
-    })
-    // These independent steps may run together, but no envelope is yielded
-    // until every seed is durable. Settle both before releasing prepared rows.
-    const [persistence, prepared] = await Promise.allSettled([index === 1 ? persistSeeds() : undefined, prepareOuter()])
-    if (persistence.status === 'rejected') throw persistence.reason
-    if (prepared.status === 'rejected') throw prepared.reason
-    const outer = prepared.value
-    if (eventByteLength(outer) > MAX_EVENT_BYTES) throw new ValidationError('EVENT_TOO_LARGE')
-    yield outer
+  // The callback commits recovery data before any bytes leave this publisher.
+  // A session commits its encrypted journal; a direct messenger commits seeds.
+  if (onPreparedSeed) {
+    for (const seed of publication.seeds) await onPreparedSeed({ ...seed, publication })
   }
+  yield * publication.events
 }
 
 // Streaming version of wrapEvent
-export async function * wrapEvents ({ senderSigner, imkcSigner, privateChannelSigner = senderSigner, privateChannelReaderPubkey, receivers, receiverTag, fileChunkIndex, onPreparedSeed, deletionPubkey, event, expirationSeconds = EXPIRATION_SECONDS, temporaryStorageArea, _getIykcProofs = getIykcProofs }) {
+export async function * wrapEvents ({ senderSigner, imkcSigner, privateChannelSigner = senderSigner, privateChannelReaderPubkey, receivers, receiverTag, fileChunkIndex, onPreparedSeed, deletionPubkey, event, expirationSeconds = EXPIRATION_SECONDS, temporaryStorageArea, _getIykcProofs = getIykcProofs, preparedPublication }) {
   const normalizedDeletionPubkey = normalizeDeletionPubkey(deletionPubkey)
-  const context = await prepareRoutedMessage({
-    senderSigner,
-    imkcSigner,
-    privateChannelSigner,
-    privateChannelReaderPubkey,
-    receivers,
-    event,
-    temporaryStorageArea,
-    _getIykcProofs
-  })
+  const context = preparedPublication
+    ? null
+    : await prepareRoutedMessage({
+      senderSigner,
+      imkcSigner,
+      privateChannelSigner,
+      privateChannelReaderPubkey,
+      receivers,
+      event,
+      temporaryStorageArea,
+      _getIykcProofs
+    })
   try {
-    yield * wrapPreparedEvents({ privateChannelSigner, receivers, receiverTag, fileChunkIndex, onPreparedSeed, deletionPubkey: normalizedDeletionPubkey, expirationSeconds, context })
+    yield * wrapPreparedEvents({ privateChannelSigner, senderSigner, event, receivers, receiverTag, fileChunkIndex, onPreparedSeed, deletionPubkey: normalizedDeletionPubkey, expirationSeconds, context, preparedPublication })
   } finally {
-    cleanupEnvelopeRows(context.preparedRows)
+    if (context) cleanupEnvelopeRows(context.preparedRows)
   }
 }
 
@@ -552,35 +558,37 @@ function withRecoveryRelays (relays, recoveryRelays) {
   return uniq([...(relays || []), ...(recoveryRelays || [])])
 }
 
-export async function publish ({ senderSigner, imkcSigner, privateChannelSigner = senderSigner, privateChannelReaderPubkey, receivers, receiverTag, fileChunkIndex, onPreparedSeed, deletionPubkey, event, relays, relayToReceivers, recoveryRelays, expirationSeconds, temporaryStorageArea, _getIykcProofs = getIykcProofs, _publish = sendToRelays }) {
+export async function publish ({ senderSigner, imkcSigner, privateChannelSigner = senderSigner, privateChannelReaderPubkey, receivers, receiverTag, fileChunkIndex, onPreparedSeed, deletionPubkey, event, relays, relayToReceivers, recoveryRelays, expirationSeconds, temporaryStorageArea, _getIykcProofs = getIykcProofs, _publish = sendToRelays, preparedPublication }) {
   const normalizedDeletionPubkey = normalizeDeletionPubkey(deletionPubkey)
   const results = []
   // Relays are grouped only when they have the exact same recipient pubkey set
   const groups = groupedRelayReceivers({ relayToReceivers, receivers })
   if (groups) {
-    const context = await prepareRoutedMessage({
-      senderSigner,
-      imkcSigner,
-      privateChannelSigner,
-      privateChannelReaderPubkey,
-      receivers,
-      event,
-      temporaryStorageArea,
-      _getIykcProofs
-    })
+    const context = preparedPublication
+      ? null
+      : await prepareRoutedMessage({
+        senderSigner,
+        imkcSigner,
+        privateChannelSigner,
+        privateChannelReaderPubkey,
+        receivers,
+        event,
+        temporaryStorageArea,
+        _getIykcProofs
+      })
     try {
       for (const group of groups) {
-        for await (const wrappedEvent of wrapPreparedEvents({ privateChannelSigner, receivers: group.receivers, receiverTag, fileChunkIndex, onPreparedSeed, deletionPubkey: normalizedDeletionPubkey, expirationSeconds, context })) {
+        for await (const wrappedEvent of wrapPreparedEvents({ privateChannelSigner, senderSigner, event, receivers: group.receivers, receiverTag, fileChunkIndex, onPreparedSeed, deletionPubkey: normalizedDeletionPubkey, expirationSeconds, context, preparedPublication })) {
           results.push(await _publish(wrappedEvent, withRecoveryRelays(group.relays, recoveryRelays), { receiverPubkeys: receiverPubkeys(group.receivers), primaryRelays: group.relays }))
         }
       }
     } finally {
-      cleanupEnvelopeRows(context.preparedRows)
+      if (context) cleanupEnvelopeRows(context.preparedRows)
     }
     return results
   }
 
-  for await (const wrappedEvent of wrapEvents({ senderSigner, imkcSigner, privateChannelSigner, privateChannelReaderPubkey, receivers, receiverTag, fileChunkIndex, onPreparedSeed, deletionPubkey: normalizedDeletionPubkey, event, expirationSeconds, temporaryStorageArea, _getIykcProofs })) {
+  for await (const wrappedEvent of wrapEvents({ senderSigner, imkcSigner, privateChannelSigner, privateChannelReaderPubkey, receivers, receiverTag, fileChunkIndex, onPreparedSeed, deletionPubkey: normalizedDeletionPubkey, event, expirationSeconds, temporaryStorageArea, _getIykcProofs, preparedPublication })) {
     results.push(await _publish(wrappedEvent, withRecoveryRelays(relays, recoveryRelays), { receiverPubkeys: receiverPubkeys(receivers), primaryRelays: relays }))
   }
   return results

package/private-message/index.js

@@ -1,7 +1,7 @@
 import { normalizeRelayUrl } from '../url/index.js'
 import { isValidEvent } from '../event/index.js'
 import { ValidationError } from '../error/index.js'
-import { generateKeypair } from '../key/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'
 
@@ -41,11 +41,19 @@ function normalizeDeletionPubkey (deletionPubkey) {
   return deletionPubkey.toLowerCase()
 }
 
-function resolveDeletionCapability ({ deletionPubkey, deletionSeckey, autoDeletionCapability = true }) {
+function resolveDeletionCapability ({ deletionPubkey, deletionSeckey, autoDeletionCapability = true, preparedPublication }) {
   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')
+    return { ...capability }
+  }
   if (normalizedDeletionPubkey) return { deletionPubkey: normalizedDeletionPubkey }
   if (!autoDeletionCapability) return {}
 
@@ -53,6 +61,14 @@ function resolveDeletionCapability ({ deletionPubkey, deletionSeckey, autoDeleti
   return { deletionPubkey: pubkey, deletionSeckey: seckey }
 }
 
+function preparedSeedHandler (onPreparedSeed, deletion) {
+  if (!onPreparedSeed) return undefined
+  return seed => {
+    seed.publication.deletionCapability = deletion
+    return onPreparedSeed(seed)
+  }
+}
+
 function withDelivery (result, reports, deletionSeckey) {
   const delivery = { reports }
   if (deletionSeckey !== undefined) delivery.deletionSeckey = deletionSeckey
@@ -652,10 +668,11 @@ async function sendPrivateMessage ({
   _getIykcProofs,
   fileChunkIndex,
   onPreparedSeed,
+  preparedPublication,
   _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, _getIykcProofs })
+  return _publish({ senderSigner, imkcSigner, privateChannelSigner, privateChannelReaderPubkey, receivers, receiverTag, deletionPubkey, event, relays, relayToReceivers, recoveryRelays, expirationSeconds, temporaryStorageArea, fileChunkIndex, onPreparedSeed, preparedPublication, _getIykcProofs })
 }
 
 async function sendNymMessage ({
@@ -860,13 +877,14 @@ export async function broadcastRumor ({
   autoDeletionCapability = true,
   fileChunkIndex,
   onPreparedSeed,
+  preparedPublication,
   _publish = privateChannel.publish
 }) {
   const receivers = uniq(receiverPubkeys)
   if (!receivers.length) throw new ValidationError('NO_RECEIVERS')
   const { event, wireEvent } = await makeOutgoingRumor({ senderSigner, 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, 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 })
   return withDelivery({ rumor: event }, reports, deletion.deletionSeckey)
 }
 
@@ -888,13 +906,14 @@ export async function broadcastEvent ({
   autoDeletionCapability = true,
   fileChunkIndex,
   onPreparedSeed,
+  preparedPublication,
   _publish = privateChannel.publish
 }) {
   const receivers = uniq(receiverPubkeys)
   if (!receivers.length) throw new ValidationError('NO_RECEIVERS')
   const wireEvent = assertValidSignedEvent({ ...event, tags: cloneTags(event?.tags) })
-  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, 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 })
   return withDelivery({ event: wireEvent }, reports, deletion.deletionSeckey)
 }
 

package/private-messenger/file/index.js

@@ -144,14 +144,14 @@ export function createPrivateFileTransfer ({ messenger, resolveChannel, storage,
     if (decoded.root !== file.root || (index !== undefined && decoded.index !== index) || (file.size !== undefined && (decoded.total !== Math.ceil(file.size / IRFS_CHUNK_BYTES) || (decoded.index === decoded.total - 1 && decoded.contentBytes.length !== file.size - decoded.index * IRFS_CHUNK_BYTES)))) throw new ValidationError('FILE_CHUNK_DESCRIPTOR_MISMATCH')
     return decoded
   }
-  async function routing (file, receiverPubkey, signal) {
+  async function routing (file, receiverPubkey, signal, attemptStartedAt, onDebug) {
     const parent = messenger.requireWritableChannel(file.controlChannelPubkey)
-    return messenger.resolveSendRouting({ channel: parent, receiverPubkeys: [receiverPubkey], signal })
+    return messenger.resolveSendRouting({ channel: parent, receiverPubkeys: [receiverPubkey], signal, attemptStartedAt, onDebug })
   }
   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 } = {}) {
+  async function publishChunk (descriptor, event, { signal, attemptStartedAt, onPreparedSeed, preparedPublication, onDebug } = {}) {
     const file = await register(descriptor)
     usable(file)
     const decoded = checked(file, event)
@@ -162,7 +162,7 @@ export function createPrivateFileTransfer ({ messenger, resolveChannel, storage,
     }
     let result
     try {
-      const options = { ...sendOptions(file, await routing(file, file.peerPubkey, signal)), receiverPubkeys: [file.peerPubkey], fileChunkIndex: decoded.index, ...(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, preparedPublication, ...(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 }
@@ -463,5 +463,5 @@ export function createPrivateFileTransfer ({ messenger, resolveChannel, storage,
   const timer = setInterval(() => { prune().catch(onError) }, 60000)
   timer.unref?.()
   messenger.extensions.add(extension)
-  return { register, authorizeSeeding, publishChunk, download, readChunk: (root, index) => storage.read(root, index), stream: (descriptor, options = {}) => storage.stream ? storage.stream(descriptor, options) : chunkStream({ read: storage.read.bind(storage), ...descriptor, ...options }), close: extension.close, cancel (control, root) { const job = jobs.get(keyFor(control, root)); if (job) { job.pauseRequested = false; cancelJob(job) } }, observe (listener) { listeners.add(listener); for (const job of jobs.values()) emit(job); return () => listeners.delete(listener) } }
+  return { register, authorizeSeeding, publishChunk, archiveSeed: async (descriptor, seed) => saveSeed(await register(descriptor), seed), download, readChunk: (root, index) => storage.read(root, index), stream: (descriptor, options = {}) => storage.stream ? storage.stream(descriptor, options) : chunkStream({ read: storage.read.bind(storage), ...descriptor, ...options }), close: extension.close, cancel (control, root) { const job = jobs.get(keyFor(control, root)); if (job) { job.pauseRequested = false; cancelJob(job) } }, observe (listener) { listeners.add(listener); for (const job of jobs.values()) emit(job); return () => listeners.delete(listener) } }
 }

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, delay, now, setTimer, clearTimer }) {
+export function publishWithEarlyFallback ({ event, receivers, first, mirrors, tried, nextPrimary, nextFallback, sendEvent, isOnline, isCurrent, signal, pauseSignal, remember, 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
@@ -120,7 +120,8 @@ export function publishWithEarlyFallback ({ event, receivers, first, mirrors, tr
   }
   if (transportSignal?.aborted || !isCurrent()) { finish(false); return outcome.promise }
   transportSignal?.addEventListener('abort', interrupted, { once: true })
-  const deadline = now() + delay
+  const remaining = attemptStartedAt === undefined ? delay : Math.max(0, delay - Math.max(0, monotonicNow() - attemptStartedAt))
+  const deadline = now() + remaining
   const failed = reason => {
     if (done) return
     done = true; clearTimer(timer); timer = null

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

@@ -32,10 +32,11 @@ function routeGroups (routes) {
   return [...groups.values()]
 }
 
-export function createSendRelayRouting ({ peer, peers = [peer], relaysByPubkey, primaryRelays, primaryRelayToReceivers, fallbackRelays = [], fallbackDelayMs = null, exclusions, pickRelays, recoveryRelays, publish, publishNymEvent, sendEvent, isOnline, isCurrent, signal, pauseSignal, now = Date.now, setTimer = setTimeout, clearTimer = clearTimeout }) {
+export function createSendRelayRouting ({ peer, peers = [peer], relaysByPubkey, primaryRelays, primaryRelayToReceivers, fallbackRelays = [], fallbackDelayMs = null, exclusions, pickRelays, recoveryRelays, publish, publishNymEvent, sendEvent, isOnline, isCurrent, signal, pauseSignal, attemptStartedAt, monotonicNow = () => performance.now(), now = Date.now, setTimer = setTimeout, clearTimer = clearTimeout }) {
   // Keep discovery's defaults when NIP-65 is unavailable. Explicit maps/lists
   // retain their fanout; configured fallbacks are a separate last-resort stage.
   fallbackDelayMs = normalizeFallbackDelay(fallbackDelayMs)
+  if (attemptStartedAt !== undefined && (!Number.isFinite(attemptStartedAt) || attemptStartedAt < 0)) throw new ValidationError('INVALID_ATTEMPT_STARTED_AT')
   const transportSignal = signal && pauseSignal ? AbortSignal.any([signal, pauseSignal]) : signal || pauseSignal
   const explicit = Boolean(primaryRelays || primaryRelayToReceivers)
   const primaryRoutes = primaryRelayToReceivers || (primaryRelays
@@ -98,7 +99,7 @@ export function createSendRelayRouting ({ peer, peers = [peer], relaysByPubkey,
         event, receivers, first: first.length ? { receivers, relays: first } : null, mirrors, tried,
         nextPrimary: pending => pick(pending, false), nextFallback: pending => pick(pending, true),
         sendEvent, isOnline, isCurrent, signal, pauseSignal, remember,
-        delay: fallbackDelayMs, now, setTimer, clearTimer
+        delay: fallbackDelayMs, attemptStartedAt, monotonicNow, now, setTimer, clearTimer
       })
       if (!result.success && current()) exclusions.clear()
       return result

package/private-messenger/index.js

@@ -233,6 +233,7 @@ export class PrivateMessenger {
     messageQueueMaxBytes = DEFAULT_MESSAGE_QUEUE_MAX_BYTES,
     seedQueueMaxBytes = DEFAULT_SEED_QUEUE_MAX_BYTES,
     seedStorage,
+    _pendingSeedRecords = () => [],
     temporaryStorageArea = globalThis.sessionStorage,
     autoDeletionCapability = true,
     _indexedDB = globalThis.indexedDB,
@@ -290,6 +291,7 @@ export class PrivateMessenger {
     this.messageQueueMaxBytes = messageQueueMaxBytes
     this.seedQueueMaxBytes = seedQueueMaxBytes
     this.seedStorage = seedStorage
+    this._pendingSeedRecords = _pendingSeedRecords
     this.temporaryStorageArea = temporaryStorageArea
     this.autoDeletionCapability = normalizeAutoDeletionCapability(autoDeletionCapability)
     this._indexedDB = _indexedDB
@@ -887,7 +889,8 @@ export class PrivateMessenger {
     return uniq([...primary, ...this.fallbackRelays].map(normalizeRelayUrl))
   }
 
-  async resolveSendRouting ({ channel, receiverPubkeys, relays, relayToReceivers, signal }) {
+  async resolveSendRouting ({ channel, receiverPubkeys, relays, relayToReceivers, signal, attemptStartedAt, onDebug }) {
+    if (attemptStartedAt !== undefined && (!Number.isFinite(attemptStartedAt) || attemptStartedAt < 0)) throw new ValidationError('INVALID_ATTEMPT_STARTED_AT')
     const recoveryRelays = await this.recoveryMirrorRelays(channel.pubkey)
     if (relayToReceivers && !this.fallbackRelays.length) return { relayToReceivers, recoveryRelays }
     const fixed = relayToReceivers ? null : relays?.length ? uniq(relays) : channel.sendRelays.length ? channel.sendRelays : channel.relays.length ? channel.relays : null
@@ -903,12 +906,17 @@ export class PrivateMessenger {
       peers: fixed && !recipients.length ? [this.userPubkey] : recipients, relaysByPubkey, recoveryRelays, primaryRelays: fixed?.map(normalizeRelayUrl), primaryRelayToReceivers: relayToReceivers, fallbackRelays: this.fallbackRelays,
       signal: signal ? AbortSignal.any([this.sendRoutingLifetime.signal, signal]) : this.sendRoutingLifetime.signal,
       exclusions: this.sendRelayExclusions.get(key).exclusions,
-      fallbackDelayMs: this.fallbackDelayMs, pauseSignal: this.sendRoutingPause.signal,
+      fallbackDelayMs: this.fallbackDelayMs, attemptStartedAt, pauseSignal: this.sendRoutingPause.signal,
       setTimer: this._setTimeout, clearTimer: this._clearTimeout,
       pickRelays: this._pickRelaysForPubkeys,
       publish: this._privateChannel.publish || privateChannel.publish,
       publishNymEvent: this._privateChannel.publishNymEvent || privateChannel.publishNymEvent,
-      sendEvent: (...args) => relayPool.sendEvent(...args),
+      sendEvent: async (...args) => {
+        const startedAt = onDebug ? performance.now() : 0
+        const result = await relayPool.sendEvent(...args)
+        if (result.success && onDebug) { try { onDebug({ stage: 'first-ack', publicationId: args[0].id, elapsedMs: performance.now() - startedAt }) } catch {} }
+        return result
+      },
       isOnline: this._isOnline,
       isCurrent: () => !this.closePromise && !this.pauseReasons.size && this.channels.has(channel.pubkey)
     })
@@ -2401,11 +2409,11 @@ export class PrivateMessenger {
     } finally { releaseActivity() }
   }
 
-  async broadcastRumor ({ channelPubkey = this.defaultChannelPubkey(), receiverPubkeys, relays, relayToReceivers, rumor, deletionPubkey, signal }) {
+  async broadcastRumor ({ channelPubkey = this.defaultChannelPubkey(), receiverPubkeys, relays, relayToReceivers, rumor, deletionPubkey, signal, attemptStartedAt, onPreparedSeed, preparedPublication, onDebug }) {
     const channel = this.requireWritableChannel(channelPubkey)
     const releaseActivity = this.decryptionScheduler.activity(channelPubkey)
     try {
-      const routing = await this.resolveSendRouting({ channel, receiverPubkeys, relays, relayToReceivers, signal })
+      const routing = await this.resolveSendRouting({ channel, receiverPubkeys, relays, relayToReceivers, signal, attemptStartedAt, onDebug })
       this.debugSend('broadcastRumor', channelPubkey, { receiverPubkeys })
       return await this._privateMessage.broadcastRumor({
         senderSigner: this.userSigner,
@@ -2419,17 +2427,18 @@ export class PrivateMessenger {
         deletionPubkey,
         autoDeletionCapability: this.autoDeletionCapabilityFor(channel),
         rumor,
-        onPreparedSeed: this.outgoingSeedHandler(channelPubkey),
+        onPreparedSeed: onPreparedSeed || this.outgoingSeedHandler(channelPubkey),
+        preparedPublication,
         _getIykcProofs: this.contentKeyLookup()
       })
     } finally { releaseActivity() }
   }
 
-  async broadcastEvent ({ channelPubkey = this.defaultChannelPubkey(), receiverPubkeys, relays, relayToReceivers, event, deletionPubkey, signal }) {
+  async broadcastEvent ({ channelPubkey = this.defaultChannelPubkey(), receiverPubkeys, relays, relayToReceivers, event, deletionPubkey, signal, attemptStartedAt, onPreparedSeed, preparedPublication, onDebug }) {
     const channel = this.requireWritableChannel(channelPubkey)
     const releaseActivity = this.decryptionScheduler.activity(channelPubkey)
     try {
-      const routing = await this.resolveSendRouting({ channel, receiverPubkeys, relays, relayToReceivers, signal })
+      const routing = await this.resolveSendRouting({ channel, receiverPubkeys, relays, relayToReceivers, signal, attemptStartedAt, onDebug })
       this.debugSend('broadcastEvent', channelPubkey, { receiverPubkeys })
       return await this._privateMessage.broadcastEvent({
         senderSigner: this.userSigner,
@@ -2443,7 +2452,8 @@ export class PrivateMessenger {
         deletionPubkey,
         autoDeletionCapability: this.autoDeletionCapabilityFor(channel),
         event,
-        onPreparedSeed: this.outgoingSeedHandler(channelPubkey),
+        onPreparedSeed: onPreparedSeed || this.outgoingSeedHandler(channelPubkey),
+        preparedPublication,
         _getIykcProofs: this.contentKeyLookup()
       })
     } finally { releaseActivity() }
@@ -2782,8 +2792,17 @@ export class PrivateMessenger {
     })
 
     if (this.offlineRecoverySecondsFor(channelPubkey)) {
+      const seen = new Set()
+      const key = seed => seed.router ? routerSeedRowKey(seed) : nymCarrierSeedKey(seed)
+      const pending = this._pendingSeedRecords({ channelPubkey, receiverPubkey: message.event?.pubkey, since, until })
+      for (const seed of pending) {
+        if (seed.channelPubkey !== channelPubkey || (seed.receiverPubkey && seed.receiverPubkey !== message.event?.pubkey) || seed.expiresAt <= nowSeconds()) continue
+        if (since !== undefined && (seed.lastSeenAt || seed.router.created_at) < since) continue
+        if (until !== undefined && (seed.firstSeenAt || seed.router.created_at) > until) continue
+        seen.add(key(seed)); await packer.update(seed)
+      }
       for await (const seed of this.seedStorage ? this.seedStorage.iterate({ channelPubkey, receiverPubkey: message.event?.pubkey, since, until }) : this.seedQueue.storedItemsBy('byChannel', channelPubkey)) {
-        if (seedRecordTime(seed) < nowSeconds() - this.offlineRecoverySecondsFor(channelPubkey)) continue
+        if (seen.has(key(seed)) || seedRecordTime(seed) < nowSeconds() - this.offlineRecoverySecondsFor(channelPubkey)) continue
         if (this.seedStorage && !await this.seedStorage.has(seed)) continue
         await packer.update(seed)
       }

package/private-messenger/session/README.md

@@ -72,7 +72,7 @@ The coordinator resolves the peer's channel and queues the request until the
 channel exists. Priorities expire after `priorityTtlMs` (10 minutes) or once
 covered, and are dropped with recovery state. They are process-local and reset
 on reload.
-Callbacks are `onOutbox`, `onMedia`,
+Callbacks are optional `onDebug`, `onOutbox`, `onMedia`,
 `onError`, and optional `onSendError(error, { id, peer })`. The caller maps its
 account permissions/connectivity/lock state to availability and owns view subscriptions. There are no DOM or UI imports.
 
@@ -170,8 +170,11 @@ Optional `fallbackDelayMs` defaults to `null` (sequential primary exhaustion).
 A nonnegative integer up to 2147483647 opts automatic NIP-65 routing into early
 fallback; explicit relay lists/maps retain the sequential policy. With `3000`,
 start at most two eligible fallback relays after three seconds without complete
-acceptance, or immediately after primary exhaustion. The deadline belongs to
-one signed outer event; later batches do not renew it. Primary operations retain
+acceptance, or immediately after primary exhaustion. Optional `enqueue({ ..., attemptStartedAt })`
+uses `performance.now()` from the caller's realm to include preparation in the
+budget. Without it, the deadline starts at publication. Later batches do not
+renew it; retries/reloads start a new attempt and uploads budget each chunk.
+Primary operations retain
 their deadlines and can still win. Failed fallback operations leave primary
 alternatives available; no relay is tried twice. Multiple recipients require
 accepted coverage of every encrypted recipient subset. No wrapper, ID, recipient
@@ -226,3 +229,57 @@ closing shared sockets or cancelling another subscriber for the same event ID.
 Operations already transmitted cannot be recalled from relays. A messenger pause
 cancels its outstanding publication work and leaves the outbox pending; resume
 creates a fresh publication lifetime, without treating the pause as a user abort.
+
+## Independent local persistence and publication
+
+One encrypted outbox feeds two independent serial processors. Local persistence
+never waits for peer preparation or an in-flight publication. Remote entries
+become publishable only after their local progress checkpoint commits; failed
+checkpoints are retried even if the copies have already committed. Text may
+continue passing uploads between chunks after its local stage is ready.
+
+Self entries emit `status: 'saved'` as soon as local persistence succeeds. They
+do not write a redundant localSaved checkpoint before removal. Remote entries
+emit that status after the first valid relay ACK for every required publication,
+without waiting for redundant relays. Outbox cleanup runs independently; failures
+retain saved status and retry only removal with the session backoff, never
+`onSendError`. Consumers must accept saved entries while removal is pending.
+A crash before removal replays the original event identity into idempotent storage.
+Account shutdown fences late admissions and waits for both processors and cleanup.
+
+`onDebug(record)` is disabled by default. Records carry fixed stage names, public
+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.
+
+## Durable prepared publications
+
+Each remote entry may contain optional `prepared` progress in its existing
+encrypted JSON. It holds the signed envelope fragments, compact recovery seeds,
+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
+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
+their configured archive. Pending durable rows participate in recovery reads
+immediately, including during a blocked archive write. No new seeds are enabled
+for modes which did not previously retain them.
+
+First acceptance of every required envelope emits saved independently of archive
+or cleanup. ACK progress checkpoints serialize with other entry writes. A crash
+between ACK and its checkpoint may replay the same envelope; acknowledged durable
+progress only archives. Archive failure never becomes `onSendError` or changes
+saved status. Removal waits for archival and outstanding entry writes.
+
+At most one unit awaits archival per entry; a stalled upload yields its remote
+slot to other texts rather than accumulating the entire file. Cancel stops wire
+work but retains potentially transmitted seeds until archival finishes. Close
+drains active local operations and leaves durable backoff work for restart.
+Diagnostics add publication/seed IDs, checkpoint time, archive wait/execution and
+first-ACK timing, without message or ciphertext contents.

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

@@ -0,0 +1,137 @@
+import { compactSeedRouterRows } from '../../index.js'
+import { encodeRecord } from '../../event-store/helpers/codec.js'
+import { isRecoverableStorageFailure } from '../../helpers/pause-recovery.js'
+
+export function createPublicationJournal ({ entries, store, archive, changed, onError, debug, setTimer = setTimeout, clearTimer = clearTimeout, random = Math.random }) {
+  const writes = new Map()
+  const failed = new Set()
+  const durable = new WeakSet()
+  const queued = new WeakMap()
+  let working; let stopped = false; let enabled = false; let timer; let delay = 1000
+  function write (entry) {
+    const previous = writes.get(entry.id) || Promise.resolve()
+    const work = previous.catch(() => {}).then(() => store().put(structuredClone(entry), { existing: true }))
+    writes.set(entry.id, work)
+    work.finally(() => { if (writes.get(entry.id) === work) writes.delete(entry.id) }).catch(() => {})
+    return work
+  }
+  function rows (entry) {
+    const packet = entry.prepared
+    if (!packet?.recover) return []
+    return packet.publication.seeds.flatMap(seed => compactSeedRouterRows(seed).map(row => {
+      const descriptor = packet.target.file
+      const value = {
+        ...row, channelPubkey: seed.channelPubkey, receivedAt: packet.receivedAt,
+        expiresAt: row.router.created_at + packet.retentionSeconds,
+        ...(descriptor
+          ? {
+              root: descriptor.root, controlChannelPubkey: descriptor.controlChannelPubkey,
+              fileChannelPubkey: packet.publication.channelPubkey, peerPubkey: descriptor.peerPubkey,
+              chunkIndex: packet.target.chunkIndex,
+              key: `${descriptor.controlChannelPubkey}:${packet.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
+    timer = setTimer(() => { timer = null; failed.clear(); wake() }, Math.min(30000, delay * (0.8 + random() * 0.4)))
+    timer?.unref?.()
+    delay = Math.min(30000, delay * 2)
+  }
+  function wake () {
+    if (stopped || !enabled || working) return working
+    const work = Promise.resolve().then(async () => {
+      for (const entry of entries.values()) {
+        if (stopped || !enabled) break
+        const packet = entry.prepared
+        if (!packet || failed.has(entry.id)) continue
+        if (packet.archived && !packet.accepted && !entry.cancelled) continue
+        const started = Date.now()
+        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 })
+            if (packet.recover) await archive(entry, rows(entry))
+            packet.archived = true
+            debug(entry, 'recovery-archived', started)
+          }
+          if (packet.accepted || entry.cancelled) delete entry.prepared
+          await write(entry)
+          changed(entry)
+        } catch (error) {
+          failed.add(entry.id)
+          onError(error)
+          if (isRecoverableStorageFailure(error)) retryLater()
+        }
+      }
+    }).finally(() => {
+      if (working === work) working = null
+      if (!failed.size) delay = 1000
+      // An ACK can arrive while another entry is being archived.
+      if (!stopped && [...entries.values()].some(entry => entry.prepared && !failed.has(entry.id) && (!entry.prepared.archived || entry.prepared.accepted || entry.cancelled))) wake()
+    })
+    working = work
+    return work
+  }
+  return {
+    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) {
+      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
+      queued.set(entry.prepared, Date.now())
+      await write(entry)
+      durable.add(entry.prepared)
+      debug(entry, '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()
+    },
+    wake,
+    accept (entry) {
+      entry.prepared.accepted = true
+      // An unrelated archive may be blocked. Its worker must not hold this ACK.
+      write(entry).catch(error => { failed.add(entry.id); onError(error); retryLater() }).finally(wake)
+      wake()
+    },
+    setAvailable (value) {
+      enabled = value
+      if (!enabled) { if (timer) clearTimer(timer); timer = null } else { failed.clear(); wake() }
+    },
+    retry () { failed.clear(); if (timer) clearTimer(timer); timer = null; return wake() },
+    pendingRows () { return [...entries.values()].flatMap(rows).filter(row => row.expiresAt > Math.floor(Date.now() / 1000)) },
+    async close () {
+      stopped = true
+      if (timer) clearTimer(timer)
+      await working
+      await Promise.allSettled([...writes.values()])
+    }
+  }
+}
+
+export function pendingSeedMatches (row, query) {
+  for (const key of ['channelPubkey', 'controlChannelPubkey', 'fileChannelPubkey', 'receiverPubkey', 'recordId']) if (query[key] && row[key] !== query[key]) return false
+  if (query.indices && !query.indices.includes(row.chunkIndex)) return false
+  if (query.since !== undefined && (row.lastSeenAt ?? row.router.created_at) < query.since) return false
+  if (query.until !== undefined && (row.firstSeenAt ?? row.router.created_at) > query.until) return false
+  return true
+}
+
+export function withPendingSeeds (storage, pending) {
+  return {
+    ...storage,
+    async * iterate (query = {}) {
+      const seen = new Set()
+      // Pending durable rows are immediately usable, even while store.put waits.
+      for (const row of pending()) if (pendingSeedMatches(row, query)) { seen.add(row.recordId); yield row }
+      for await (const row of storage.iterate(query)) if (!seen.has(row.recordId)) yield row
+    },
+    has: row => pending().some(value => value.recordId === row.recordId) || storage.has(row)
+  }
+}

package/private-messenger/session/index.js

@@ -14,6 +14,7 @@ import { createChatOutbox } from './helpers/work-storage.js'
 import { messengerSigner } from './helpers/signer.js'
 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'
 
 export function wireEvent (value, owner) {
@@ -44,7 +45,7 @@ function messengerStatusSnapshot (value) {
   return { closed: value.closed, paused: value.paused, pauseReasons: [...value.pauseReasons] }
 }
 
-export function createPrivateMessageSession ({ owner, signer, eventStore, messageStorage, chunkStorage, recoveryStorage, fallbackRelays = [], fallbackDelayMs = null, mode = 'seeder', seedersForPeer = peer => [peer], allowedKinds = [5, 9, 1063, 34601], useContentKeys = true, pendingDecryptionReady = true, onMedia = () => {}, onOutbox = () => {}, onError = () => {}, onSendError = () => {}, Messenger = createPrivateMessenger, openOutbox = createChatOutbox, FileTransfer = createPrivateFileTransfer, _onOnline = onOnline, _isOnline = isOnline, _getIykcProofs = getIykcProofs, _setTimeout = setTimeout, _clearTimeout = clearTimeout, _random = Math.random, openDownloads = options => createChatOutbox({ ...options, namespace: 'downloads' }) }) {
+export function createPrivateMessageSession ({ owner, signer, eventStore, messageStorage, chunkStorage, recoveryStorage, fallbackRelays = [], fallbackDelayMs = null, mode = 'seeder', seedersForPeer = peer => [peer], allowedKinds = [5, 9, 1063, 34601], useContentKeys = true, pendingDecryptionReady = true, onMedia = () => {}, onOutbox = () => {}, onError = () => {}, onSendError = () => {}, onDebug, Messenger = createPrivateMessenger, openOutbox = createChatOutbox, FileTransfer = createPrivateFileTransfer, _onOnline = onOnline, _isOnline = isOnline, _getIykcProofs = getIykcProofs, _setTimeout = setTimeout, _clearTimeout = clearTimeout, _random = Math.random, openDownloads = options => createChatOutbox({ ...options, namespace: 'downloads' }) }) {
   fallbackRelays = normalizeFallbackRelays(fallbackRelays)
   fallbackDelayMs = normalizeFallbackDelay(fallbackDelayMs)
   if (typeof pendingDecryptionReady !== 'boolean') throw new ValidationError('INVALID_PENDING_DECRYPTION_READY')
@@ -65,7 +66,16 @@ export function createPrivateMessageSession ({ owner, signer, eventStore, messag
   const channels = new Map()
   const entries = new Map()
   const cancelled = new Set()
+  const attemptStarts = new Map()
   const sendControllers = new Map()
+  const localReady = new Set()
+  const localIdleWaiters = new Set()
+  const cleanups = new Map()
+  const queuedAt = new WeakMap()
+  const debug = (entry, stage, startedAt, coordinates = {}) => {
+    if (!onDebug) return
+    try { onDebug({ stage, eventId: entry.id, peer: entry.peer, at: Date.now(), ...coordinates, ...(startedAt != null ? { elapsedMs: Date.now() - startedAt } : {}) }) } catch {}
+  }
   const offlineSends = new Set()
   const pausedSends = new Set()
   let messengerStatus
@@ -89,7 +99,7 @@ export function createPrivateMessageSession ({ owner, signer, eventStore, messag
       return
     }
     clearSendRetry()
-    for (const id of pausedSends) { const entry = entries.get(id); if (entry) entry.failed = false }
+    for (const id of pausedSends) { const entry = entries.get(id); if (entry) { entry.failed = false; attemptStarts.set(entry.id, performance.now()) } }
     pausedSends.clear()
     // The callback can run inside construction/resume, before configure settles.
     queueMicrotask(() => pump())
@@ -123,15 +133,41 @@ export function createPrivateMessageSession ({ owner, signer, eventStore, messag
   let messengerWork
   let fileSetupWork
   let sending
+  let enqueuing = 0
+  let localSaving = false
+  let relocal = false
   let repump
   let draining
   let redrain = false
   const idleWaiters = new Set()
-  const settled = () => { if (!sending && !draining) { for (const resolve of idleWaiters) resolve(); idleWaiters.clear() } }
-  const emit = () => onOutbox([...entries.values()].filter(entry => !entry.deletion))
+  const settled = () => { if (!sending && !localSaving && !enqueuing && !draining && !cleanups.size) { for (const resolve of idleWaiters) resolve(); idleWaiters.clear() } }
+  const emit = () => onOutbox([...entries.values()].filter(entry => !entry.deletion && !entry.cancelled))
+  const journal = createPublicationJournal({
+    entries, store: () => storage, onError: reportError, debug, setTimer: _setTimeout, clearTimer: _clearTimeout, random: _random,
+    archive: async (entry, rows) => {
+      if (recoveryStorage?.seeds) { for (const row of rows) 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)
+      }
+    },
+    changed: entry => {
+      if (!entry.prepared && (entry.status === 'saved' || entry.cancelled)) cleanupEntry(entry)
+      else if (!closed && available) pumpRemote()
+    }
+  })
+  const seedStorage = recoveryStorage?.seeds ? withPendingSeeds(recoveryStorage.seeds, () => journal.pendingRows()) : undefined
   const ready = () => (initialized ??= (async () => {
-    storage = await openOutbox({ owner, signer })
-    for (const entry of await storage.list()) entries.set(entry.id, entry)
+    storage = await openOutbox({ owner, signer, onDebug })
+    for (const entry of await storage.list()) {
+      // Old encrypted entries retain progress and enter this same pipeline.
+      if (entry.cancelled) cancelled.add(entry.id)
+      entries.set(entry.id, entry)
+      journal.adopt(entry)
+      attemptStarts.set(entry.id, performance.now())
+      if (entry.localSaved.every(Boolean)) localReady.add(entry.id)
+      queuedAt.set(entry, Date.now())
+    }
     emit()
   })().catch(async error => { await storage?.close(); storage = null; initialized = null; throw error }))
   async function createMessenger () {
@@ -141,7 +177,7 @@ export function createPrivateMessageSession ({ owner, signer, eventStore, messag
     let candidate
     try {
       candidate = await Messenger({
-        fallbackRelays, fallbackDelayMs, pendingDecryptionReady, seedStorage: recoveryStorage?.seeds, userSigner, channels: [], useContentKeys, _waitForForeground: foreground.wait, _observeForeground: foreground.observe,
+        fallbackRelays, fallbackDelayMs, pendingDecryptionReady, seedStorage, _pendingSeedRecords: () => journal.pendingRows(), userSigner, channels: [], useContentKeys, _waitForForeground: foreground.wait, _observeForeground: foreground.observe,
         onMessageQueued: () => { if (messengerBinding === binding) return drain() },
         onStateChanged: state => {
           if (closed || messengerBinding !== binding) return
@@ -167,6 +203,7 @@ export function createPrivateMessageSession ({ owner, signer, eventStore, messag
 
   const preparation = createPeerPreparation({
     prepare: async (peer, signal) => {
+      const startedAt = Date.now()
       const scoped = messengerSigner(signer.withSharedKey(peer, 'dm'))
       const pubkey = await scoped.getPublicKey()
       signal.throwIfAborted()
@@ -175,6 +212,7 @@ export function createPrivateMessageSession ({ owner, signer, eventStore, messag
       if (peer === pendingDecryptionPeer) messenger?.setPendingDecryptionPriority?.(channel.pubkey)
       await schedule()
       signal.throwIfAborted()
+      if (onDebug) { try { onDebug({ stage: 'channel-ready', peer, elapsedMs: Date.now() - startedAt }) } catch {} }
       return channel
     },
     onReady: () => { drain(); pump() }, onError: reportError,
@@ -219,7 +257,7 @@ export function createPrivateMessageSession ({ owner, signer, eventStore, messag
       fileSetupWork = setupFiles().catch(error => { fileSetupWork = null; if (!closed) reportError(error) })
     }
     fileSetupWork.then(() => { if (!closed && available) restoreDownloads() }).catch(reportError)
-    drain(); pump()
+    journal.wake(); drain(); pump()
   }
   async function setupFiles () {
     if (!fileTransfers) {
@@ -227,7 +265,7 @@ export function createPrivateMessageSession ({ owner, signer, eventStore, messag
         messenger, onError: reportError,
         resolveChannel: ({ peerPubkey, info }) => messengerSigner(signer.withSharedKey(peerPubkey, info)),
         storage: chunkStorage,
-        seedStorage: recoveryStorage?.seeds,
+        seedStorage,
         authorizationStorage: recoveryStorage?.authorizations
       })
       fileTransfers.observe(state => {
@@ -351,10 +389,24 @@ export function createPrivateMessageSession ({ owner, signer, eventStore, messag
       if (again && !storageBlocked && !closed && available) queueMicrotask(() => drain())
     }
   }
-  async function publish (peer, event, signal) {
+  async function publish (entry, event, signal) {
+    const peer = entry.peer
     if (preparation.error(peer)) throw preparation.error(peer)
     if (!available || !peers.has(peer) || !channels.has(peer)) throw unavailableError(new Error('CHAT_UNAVAILABLE'), signal)
-    const options = { channelPubkey: channels.get(peer)?.pubkey, receiverPubkeys: [peer], signal }
+    const channelPubkey = channels.get(peer)?.pubkey
+    const retention = mode === 'seeder' || mode === 'watchtower' ? messenger.offlineRecoverySecondsFor?.(channelPubkey) ?? 0 : 0
+    const preparationStartedAt = Date.now()
+    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 => {
+        debug(entry, 'envelope-prepared', preparationStartedAt, { publicationId: seed.publication.events[0].id })
+        await journal.stage(entry, seed, { index: entry.index }, retention)
+        signal.throwIfAborted()
+      }
+    }
+    debug(entry, 'envelope-preparation')
     let report
     try {
       report = event.sig ? await messenger.broadcastEvent({ ...options, event }) : await messenger.broadcastRumor({ ...options, rumor: event })
@@ -365,7 +417,25 @@ export function createPrivateMessageSession ({ owner, signer, eventStore, messag
     // Published is relay acceptance, never a peer receipt.
     await assertMessagePublished(report, event)
   }
-  async function sendEntry (entry) {
+  async function cleanupEntry (entry) {
+    if (entry.prepared) { journal.wake(); return }
+    if (cleanups.has(entry.id)) return cleanups.get(entry.id)
+    const startedAt = Date.now()
+    const work = Promise.resolve().then(async () => { await journal.flush(entry); await storage.remove(entry.id) }).then(() => {
+      entries.delete(entry.id); localReady.delete(entry.id); attemptStarts.delete(entry.id)
+      debug(entry, 'outbox-cleanup', startedAt)
+      emit()
+    }).catch(error => {
+      // Delivery has already succeeded. Cleanup must never become a send error.
+      entry.failed = true; entry.retryable = true
+      reportError(error)
+      if (!closed && available) scheduleSendRetry()
+    }).finally(() => { cleanups.delete(entry.id); if (![...entries.values()].some(pendingRetryable) && !cleanups.size) resetSendRetry(); settled() })
+    cleanups.set(entry.id, work)
+    return work
+  }
+  async function sendEntry (entry, localOnly = false) {
+    if (entry.status === 'saved') return
     const releaseForeground = foreground.enter()
     entry.status = 'pending'; emit()
     const controller = new AbortController()
@@ -375,19 +445,32 @@ export function createPrivateMessageSession ({ owner, signer, eventStore, messag
         if (storage.has && !await storage.has(entry.id)) cancelled.add(entry.id)
         if (closed || !available || cancelled.has(entry.id) || (entry.peer !== owner && !peers.has(entry.peer))) throw new Error('CHAT_UNAVAILABLE')
       }
-      // Personal copies must commit even if publishing attachment bytes
-      // fails offline. Remote progress remains independently retryable.
-      for (let index = 0; index < entry.events.length; index++) {
-        await active()
-        const event = entry.events[index]
-        if (!entry.localSaved[index]) {
+      if (localOnly) {
+        debug(entry, 'local-start', queuedAt.get(entry))
+        const startedAt = Date.now()
+        for (let index = 0; index < entry.events.length; index++) {
+          await active()
+          if (entry.localSaved[index]) continue
+          const event = entry.events[index]
           const hearsay = !event.sig && event.pubkey !== owner
           const result = await messageStorage.save(event, { peerPubkey: entry.peer, hearsay })
           if (result?.result?.code === 'blocked') { cancelled.add(entry.id); await active() }
           if (!result?.result?.ok) throw Object.assign(new Error('MESSAGE_STORAGE_FAILED'), { code: result?.result?.code?.toUpperCase() })
           entry.localSaved[index] = true
-          await storage.put(entry, { existing: true })
         }
+        debug(entry, 'local-stored', startedAt)
+        await active()
+        if (entry.peer === owner) {
+          entry.status = 'saved'; emit()
+          cleanupEntry(entry)
+        } else {
+          // Retry this checkpoint even when a preceding attempt saved all copies
+          // but failed to persist progress. Only then admit remote publication.
+          await journal.write(entry)
+          await active()
+          localReady.add(entry.id)
+        }
+        return
       }
       if (entry.peer !== owner && !preparation.get(entry.peer)) {
         if (preparation.error(entry.peer)) throw preparation.error(entry.peer)
@@ -397,52 +480,68 @@ export function createPrivateMessageSession ({ owner, signer, eventStore, messag
       if (entry.peer !== owner && messengerStatus?.paused) {
         throw unavailableError(Object.assign(new Error('PRIVATE_MESSENGER_PAUSED'), { pauseReasons: [...messengerStatus.pauseReasons] }), controller.signal)
       }
-      // Read/publish one chunk at a time. Progress is durable after each
-      // accepted chunk; replay after interruption keeps its original identity.
-      for (; entry.peer !== owner && entry.fileIndex < entry.files.length; entry.fileIndex++, entry.chunkIndex = 0) {
+      if (entry.prepared?.accepted) { journal.wake(); return }
+      // One prepared unit per entry. Archive waits yield this entry, not the pump.
+      for (; entry.fileIndex < entry.files.length; entry.fileIndex++, entry.chunkIndex = 0) {
         const file = entry.files[entry.fileIndex]
+        const descriptor = { controlChannelPubkey: channels.get(entry.peer).pubkey, peerPubkey: entry.peer, root: file.root, size: file.size }
         await active()
-        await fileTransfers.authorizeSeeding({ controlChannelPubkey: channels.get(entry.peer).pubkey, peerPubkey: entry.peer, root: file.root, size: file.size }, { receiverPubkeys: [entry.peer], sharedAt: entry.event.created_at })
-        for (; entry.chunkIndex < Math.ceil(file.size / IRFS_CHUNK_BYTES); entry.chunkIndex++) {
+        await fileTransfers.authorizeSeeding(descriptor, { receiverPubkeys: [entry.peer], sharedAt: entry.event.created_at })
+        while (entry.chunkIndex < Math.ceil(file.size / IRFS_CHUNK_BYTES)) {
+          const chunkStartedAt = performance.now()
           await active()
           const chunk = chunkStorage ? await chunkStorage.read(file.root, entry.chunkIndex, file) : await fileTransfers.readChunk(file.root, entry.chunkIndex)
           if (!chunk || decodeIrfsChunk(chunk).root !== file.root) { if (file.optional) break; throw new Error('FILE_UNAVAILABLE') }
-          if (!fileTransfers) throw new Error('FILE_TRANSFER_UNAVAILABLE')
-          await fileTransfers.publishChunk({ controlChannelPubkey: channels.get(entry.peer).pubkey, peerPubkey: entry.peer, root: file.root, size: file.size }, wireEvent(chunk, owner), { signal: controller.signal })
-          const completed = entry.files.slice(0, entry.fileIndex).reduce((sum, value) => sum + value.size, 0) + Math.min(file.size, (entry.chunkIndex + 1) * IRFS_CHUNK_BYTES)
+          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() }
+          })
+          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)
           entry.uploadProgress = { completed, total: entry.files.reduce((sum, value) => sum + value.size, 0) }
           emit()
           await active()
-          await storage.put({ ...entry, chunkIndex: entry.chunkIndex + 1 }, { existing: true })
-          // Newly queued text and deletion controls can pass an in-flight file.
+          if (entry.prepared) { journal.accept(entry); return }
+          await journal.write(entry)
+          if ([...entries.values()].some(pending => !pending.files.length && pending.peer !== owner && !pending.failed && !localReady.has(pending.id))) {
+            await pumpLocal()
+            if (localSaving) await new Promise(resolve => localIdleWaiters.add(resolve))
+          }
           let admitted = 0
           for (const pending of entries.values()) {
             if (closed || !available || admitted >= 8) break
-            if (pending.files.length || pending.failed || cancelled.has(pending.id) || (pending.peer !== owner && !peers.has(pending.peer))) continue
+            if (!localReady.has(pending.id) || pending.peer === owner || pending.status === 'saved' || pending.files.length || pending.failed || cancelled.has(pending.id) || pending.prepared?.accepted || !peers.has(pending.peer)) continue
             admitted++
             await sendEntry(pending)
           }
         }
       }
-      for (; entry.index < entry.events.length; entry.index++) {
+      while (entry.index < entry.events.length) {
         await active()
         const event = entry.events[entry.index]
-        if (entry.peer !== owner) await publish(entry.peer, event, controller.signal)
+        const startedAt = Date.now()
+        await publish(entry, event, controller.signal)
+        debug(entry, 'publication-accepted', startedAt)
         await active()
-        // The final durable operation is removal. Avoid encrypting a checkpoint
-        // that would immediately be deleted; earlier context stages still checkpoint.
-        if (entry.index + 1 < entry.events.length) await storage.put({ ...entry, index: entry.index + 1 }, { existing: true })
+        entry.index++
+        if (entry.index === entry.events.length) { entry.status = 'saved'; emit() }
+        if (entry.prepared) { journal.accept(entry); return }
+        if (entry.index < entry.events.length) await journal.write(entry)
       }
-      await storage.remove(entry.id)
-      entries.delete(entry.id)
-      emit()
+      entry.status = 'saved'; emit()
+      cleanupEntry(entry)
     } catch (cause) {
       // Pauses can surface at any stage (text publication, file authorization
       // or chunk delivery). Normalize all of them into the retryable path.
       const error = cause?.retryWhenAvailable ? cause : (isUnavailableSend(cause) ? unavailableError(cause, controller.signal) : cause)
-      if (cancelled.has(entry.id)) { await storage.remove(entry.id); entries.delete(entry.id) } else {
+      if (cancelled.has(entry.id)) {
+        entry.cancelled = true
+        if (entry.prepared) { await journal.write(entry); journal.wake() } else { await storage.remove(entry.id); entries.delete(entry.id) }
+      } else {
         entry.status = error.retryWhenAvailable ? 'pending' : 'error'; entry.failed = true; entry.retryable = retryable(error)
-        await storage.put(entry, { existing: true }).catch(reportError)
+        await journal.write(entry).catch(reportError)
         if (entry.peer !== owner && error.retryWhenAvailable && messenger?.readStatus().paused) pausedSends.add(entry.id)
         else if (isUnavailableSend(cause) && cause.pauseReasons?.length && available && !closed) {
           // Release can race persistence of the failed attempt. Do not lose
@@ -483,6 +582,8 @@ export function createPrivateMessageSession ({ owner, signer, eventStore, messag
       for (const entry of entries.values()) {
         if (!pendingRetryable(entry) || pausedSends.has(entry.id)) continue
         entry.failed = false
+        attemptStarts.set(entry.id, performance.now())
+        if (entry.status === 'saved') { cleanupEntry(entry); continue }
         retried = true
       }
       if (retried) pump()
@@ -499,16 +600,32 @@ export function createPrivateMessageSession ({ owner, signer, eventStore, messag
       if (closed || !available) return
       for (const id of offlineSends) {
         const entry = entries.get(id)
-        if (entry?.retryable) entry.failed = false
+        if (entry?.retryable) { entry.failed = false; attemptStarts.set(entry.id, performance.now()) }
       }
       offlineSends.clear()
       return schedule()
     })
   }
-  async function pump () {
+  async function pumpLocal () {
     if (!available || closed || !storage) return
-    // A retry that lands while a pump is already running must not be skipped
-    // just because that pass already walked past the entry.
+    if (localSaving) { relocal = true; return }
+    localSaving = true
+    try {
+      do {
+        relocal = false
+        for (const entry of entries.values()) {
+          if (closed || !available) break
+          if (entry.failed || cancelled.has(entry.id) || (entry.peer !== owner && !peers.has(entry.peer))) continue
+          if (entry.status === 'saved') { cleanupEntry(entry); continue }
+          if (localReady.has(entry.id) && entry.peer !== owner) continue
+          await sendEntry(entry, true)
+          pumpRemote()
+        }
+      } while (relocal)
+    } finally { localSaving = false; for (const resolve of localIdleWaiters) resolve(); localIdleWaiters.clear(); settled() }
+  }
+  async function pumpRemote () {
+    if (!available || closed || !storage || !messenger) return
     if (sending) { repump = true; return }
     sending = true
     try {
@@ -516,22 +633,24 @@ export function createPrivateMessageSession ({ owner, signer, eventStore, messag
         repump = false
         for (const entry of entries.values()) {
           if (closed || !available) break
-          if ((entry.peer !== owner && !peers.has(entry.peer)) || entry.failed || cancelled.has(entry.id)) continue
-          if (entry.peer !== owner && entry.localSaved.every(Boolean) && !preparation.get(entry.peer) && !preparation.error(entry.peer)) {
+          if (entry.prepared?.accepted) { journal.wake(); continue }
+          if (entry.peer === owner || entry.status === 'saved' || !localReady.has(entry.id) || !peers.has(entry.peer) || entry.failed || cancelled.has(entry.id)) continue
+          if (!preparation.get(entry.peer) && !preparation.error(entry.peer)) {
             preparation.request(entry.peer).catch(() => {})
             continue
           }
-          if (entry.peer !== owner && entry.files.length && !fileTransfers) continue
+          if (entry.files.length && !fileTransfers) continue
           await sendEntry(entry)
         }
       } while (repump)
     } finally {
       sending = false
       watchOfflineSends()
-      if (![...entries.values()].some(pendingRetryable)) resetSendRetry()
+      if (![...entries.values()].some(pendingRetryable) && !cleanups.size) resetSendRetry()
       settled()
     }
   }
+  async function pump () { await Promise.all([pumpLocal(), pumpRemote()]) }
   const intentId = file => getEventHash({ kind: 0, pubkey: owner, created_at: 0, tags: [], content: `${file.peer}:${file.root}` })
   async function download (file, options = {}) {
     if (file.peer === owner) return file
@@ -643,19 +762,24 @@ export function createPrivateMessageSession ({ owner, signer, eventStore, messag
       else clearSendRetry()
       if (changed) lifecycle++
       if (!available) {
+        journal.setAvailable(false)
         preparation.setAvailable(false)
         for (const peer of channels.keys()) if (!preparation.get(peer)) channels.delete(peer)
         inboxRecovery.stop(); await messenger?.pause('signer'); return
       }
       await ready()
-      for (const entry of entries.values()) if (pendingRetryable(entry)) entry.failed = false
+      journal.setAvailable(true)
+      pumpLocal()
+      for (const entry of entries.values()) if (pendingRetryable(entry)) { entry.failed = false; attemptStarts.set(entry.id, performance.now()) }
       if (storageBlocked) inboxRecovery.start({ immediate: true })
       if (!changed && messenger && !configurationFailed) { preparation.setAvailable(true); pump(); return configuring }
       return schedule()
     },
-    async enqueue ({ peer, event, context = [], requiredFiles = [], deletion = false }) {
+    async enqueue ({ peer, event, context = [], requiredFiles = [], deletion = false, attemptStartedAt }) {
       if (closed || !available || (peer !== owner && !peers.has(peer))) throw new Error('CHAT_UNAVAILABLE')
+      if (attemptStartedAt !== undefined && (!Number.isFinite(attemptStartedAt) || attemptStartedAt < 0)) throw new ValidationError('INVALID_ATTEMPT_STARTED_AT')
       const releaseForeground = foreground.enter()
+      enqueuing++
       try {
         await ready()
         const main = wireEvent(event, owner)
@@ -663,26 +787,35 @@ export function createPrivateMessageSession ({ owner, signer, eventStore, messag
         const events = [...context.map(value => wireEvent(value, owner)), main]
         const files = events.filter(value => value.kind === 1063).map(value => ({ ...decodeFileMetadata(value), optional: !requiredFiles.includes(getEventHash(value)) })).filter(file => file.service === 'irfs').flatMap(file => [file, ...(file.thumbnail?.root ? [{ ...file.thumbnail, optional: file.optional }] : [])])
         const entry = { id, peer, event: { ...main, id }, events, files, index: 0, fileIndex: 0, chunkIndex: 0, localSaved: context.map(() => true).concat(false), status: 'pending', deletion }
+        const startedAt = Date.now()
+        debug(entry, 'outbox-start')
         await storage.put(entry)
+        debug(entry, 'outbox-stored', startedAt)
+        queuedAt.set(entry, Date.now())
+        if (attemptStartedAt !== undefined) attemptStarts.set(id, attemptStartedAt)
+        if (cancelled.has(id)) { await storage.remove(id); throw new Error('CHAT_UNAVAILABLE') }
+        // An accepted durable intent survives shutdown/locking for replay. Only
+        // explicit cancellation removes it; no late callback or work is admitted.
+        if (closed) return id
         entries.set(id, entry); emit(); pump()
-        if (peer !== owner) preparePeer(peer).catch(() => {})
+        if (available && peer !== owner) preparePeer(peer).catch(() => {})
         return id
-      } finally { releaseForeground() }
+      } finally { releaseForeground(); enqueuing--; settled() }
     },
     async retry (id) {
       offlineSends.delete(id); pausedSends.delete(id); watchOfflineSends()
       if (storageBlocked) inboxRecovery.start({ immediate: true })
       await ready()
       const entry = entries.get(id)
-      if (entry) { entry.failed = false; resetSendRetry(); if (entry.peer !== owner) preparePeer(entry.peer).catch(() => {}); return pump() }
+      if (entry) { attemptStarts.set(id, performance.now()); journal.retry(); entry.failed = false; resetSendRetry(); if (entry.peer !== owner) preparePeer(entry.peer).catch(() => {}); return pump() }
     },
     async cancel (id) {
       cancelled.add(id)
       sendControllers.get(id)?.abort()
       offlineSends.delete(id); pausedSends.delete(id); watchOfflineSends()
       await ready()
-      entries.delete(id)
-      await storage.remove(id)
+      const entry = entries.get(id)
+      if (entry?.prepared) { entry.cancelled = true; await journal.write(entry); journal.wake() } else { entries.delete(id); localReady.delete(id); await storage.remove(id) }
       emit()
     },
     close () {
@@ -693,7 +826,9 @@ export function createPrivateMessageSession ({ owner, signer, eventStore, messag
         for (const controller of sendControllers.values()) controller.abort()
         await Promise.allSettled([configuring, initialized, messengerWork, fileSetupWork])
         await messenger?.pause('closed')
-        if (sending || draining) await new Promise(resolve => idleWaiters.add(resolve))
+        if (sending || localSaving || enqueuing || draining || cleanups.size) await new Promise(resolve => idleWaiters.add(resolve))
+        await journal.close()
+        if (cleanups.size) await new Promise(resolve => idleWaiters.add(resolve))
         await messenger?.close()
         await storage?.close()
         await downloadWriteTail.catch(reportError)