app

Local-first trade for farms and co-ops
git clone https://radroots.dev/git/app.git
Log | Files | Refs | README | LICENSE

commit 4fb0b806b2546c90d7029fdaeb46a372b9a7df68
parent 22c04a3780867bb6e10afa1a69fd659b8aa2b30b
Author: triesap <tyson@radroots.org>
Date:   Thu, 15 Oct 2026 03:23:39 +0000

web: Exclude current admitted inbox probes from receive retention

- Bind exact probe delivery exclusion to current source and native custody.
- Preserve ordinary receive and decrypt costs after source or journal loss.
- Bound inclusive history cursor facts across retained and excluded rows.
- Verify actual original and recovered workflows without production wiring.

Diffstat:
Mweb/src/lib/messaging/history-pagination.ts | 143+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++------------
Mweb/src/lib/messaging/inbox-sync.ts | 4++++
Mweb/src/lib/nostr/inbox-ingress.ts | 4++++
Mweb/src/lib/persistence/inbox-envelope-repository.ts | 49++++++++++++++++++++++++++++++++++++++++++++++---
Mweb/src/lib/persistence/inbox-probes.ts | 163++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++-
Aweb/tests/e2e/harness/inbox-probe-exclusion.ts | 536+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Aweb/tests/e2e/inbox-probe-exclusion.spec.ts | 1267+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Mweb/tests/provenance/output.test.mjs | 10+++++++++-
Aweb/tests/unit/inbox-probe-exclusion.test.ts | 121+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Mweb/tools/check-output.mjs | 32++++++++++++++++++++------------
10 files changed, 2291 insertions(+), 38 deletions(-)

diff --git a/web/src/lib/messaging/history-pagination.ts b/web/src/lib/messaging/history-pagination.ts @@ -8,7 +8,11 @@ import { advanceOuterPage, type OuterCursor } from './inbox-state.ts'; -import { readRetainedOuterMetadata } from '../persistence/history-metadata-repository.ts'; +import { + readRetainedOuterMetadata, + type RetainedOuterMetadata +} from '../persistence/history-metadata-repository.ts'; +import { LOCAL_PERSISTENCE_BUDGETS } from '../config/budgets.ts'; import { createPrivateHistoryRun, subscribePrivateSourcePage, @@ -16,7 +20,7 @@ import { } from '../nostr/private-pool.ts'; import { admitInboxEnvelope, - inboxEnvelopeSnapshot, + inboxEnvelopeOuterMetadata, retainInboxEnvelope } from '../persistence/inbox-envelope-repository.ts'; import { @@ -58,7 +62,43 @@ export function captureOlderInbox( let cursors = Array.from<OuterCursor>([]), release = () => {}, off = () => {}; - const current = () => !stopped && original.current(); + // Genuine excluded deliveries still have signed outer cursor facts. They + // are bounded observed-page memory, never retained rows or exclusion proof. + const excludedOuter = new Map<string, RetainedOuterMetadata>(); + let retainedOuter: readonly RetainedOuterMetadata[] = + Array.from<RetainedOuterMetadata>([]); + function mergedOuter( + retained: readonly RetainedOuterMetadata[], + extra?: RetainedOuterMetadata + ): RetainedOuterMetadata[] | undefined { + const rows = new Map<string, RetainedOuterMetadata>(), + ids = new Map<string, true>(); + for (const row of [ + ...retained, + ...excludedOuter.values(), + ...(extra ? [extra] : []) + ]) { + ids.set(row.outerId, true); + if (ids.size > LOCAL_PERSISTENCE_BUDGETS.receivedEnvelopes) + return undefined; + const key = JSON.stringify([row.source, row.outerId]), + previous = rows.get(key); + if (previous && previous.outerTime !== row.outerTime) return undefined; + if (!previous) rows.set(key, row); + } + return Array.from(rows.values()); + } + const current = () => { + const valid = !stopped && original.current(); + if (!valid) { + // These are only transient cursor facts. Observed generation loss must + // discard them even when the next explicit action is refused at entry. + excludedOuter.clear(); + retainedOuter = []; + cursors = []; + } + return valid; + }; function stop() { stopped = true; cancellation.abort(); @@ -75,6 +115,8 @@ export function captureOlderInbox( failure = true; } cursors = []; + excludedOuter.clear(); + retainedOuter = []; cleanupRequired = failure; if (!failure && syncs.get(sync) === token) syncs.delete(sync); if (failure) throw Error('private_history_cleanup_required'); @@ -89,6 +131,7 @@ export function captureOlderInbox( finished = false, failure: string | undefined; const ids = new Map<string, true>(); + const pageRetained = new Map<string, RetainedOuterMetadata>(); let acceptedDeliveries = 0; function receive(message: PrivatePageMessage) { if (finished) return; @@ -120,6 +163,7 @@ export function captureOlderInbox( queue = queue .then(async () => { if (!current()) return; + if (failure === 'capacity') return; const owner = privateOwner(); const admitted = owner && @@ -135,6 +179,29 @@ export function captureOlderInbox( cancellation.signal ); if (!current()) return; + if (retained.status === 'probe_excluded') { + const signed = inboxEnvelopeOuterMetadata(admitted); + if (!signed) { + failure = 'unsupported'; + return; + } + const fact = { + source, + outerId: signed.id, + outerTime: signed.createdAt + }; + if ( + !mergedOuter([...retainedOuter, ...pageRetained.values()], fact) + ) { + failure = 'capacity'; + return; + } + const key = JSON.stringify([source, signed.id]); + if (!excludedOuter.has(key)) excludedOuter.set(key, fact); + acceptedDeliveries++; + ids.set(signed.id, true); + return; + } if ( retained.status !== 'retained' && retained.status !== 'duplicate' @@ -142,13 +209,25 @@ export function captureOlderInbox( failure = retained.status; return; } - acceptedDeliveries++; - const parsed = inboxEnvelopeSnapshot(admitted); - if (!parsed) { + const signed = inboxEnvelopeOuterMetadata(admitted); + if (!signed) { failure = 'unsupported'; return; } - ids.set(parsed.id, true); + const fact = { + source, + outerId: signed.id, + outerTime: signed.createdAt + }; + if ( + !mergedOuter([...retainedOuter, ...pageRetained.values()], fact) + ) { + failure = 'capacity'; + return; + } + pageRetained.set(signed.id, fact); + acceptedDeliveries++; + ids.set(signed.id, true); }) .catch(() => { failure = 'unknown_completion'; @@ -171,17 +250,20 @@ export function captureOlderInbox( return privateSessionOwnership(original.session)?.owner; } controllers.set(token, { - snapshot: () => ({ - ownerGenerationScoped: true, - state, - reason, - historyComplete: false, - cleanupRequired, - sources: cursors.map((cursor) => ({ - ...cursor, - seen: cursor.seen.slice() - })) - }), + snapshot: () => { + current(); + return { + ownerGenerationScoped: true, + state, + reason, + historyComplete: false, + cleanupRequired, + sources: cursors.map((cursor) => ({ + ...cursor, + seen: cursor.seen.slice() + })) + }; + }, stop, async start(reviewed) { if ( @@ -208,10 +290,17 @@ export function captureOlderInbox( reason = initial.reason; return false; } + const observed = mergedOuter(initial.rows); + if (!observed) { + state = 'needs_action'; + reason = 'capacity'; + return false; + } + retainedOuter = initial.rows; cursors = original.targets.map((source) => { const fresh = initialOuterCursor( source, - initial.rows.filter((row) => row.source === source) + observed.filter((row) => row.source === source) ); const previous = cursors.find((cursor) => cursor.source === source); return previous && previous.until === fresh.until @@ -248,14 +337,26 @@ export function captureOlderInbox( next = next.concat(cursor); break; } - const rows = stored.rows.filter( + const observed = mergedOuter(stored.rows); + if (!observed) { + state = 'needs_action'; + reason = 'capacity'; + next = next.concat(cursor); + break; + } + retainedOuter = stored.rows; + const rows = observed.filter( (row) => row.source === cursor.source && result.ids.includes(row.outerId) ); next = next.concat( advanceOuterPage(cursor, rows, result.deliveries, result.reason) ); - if (result.reason === 'budget' || result.reason === 'elapsed') { + if ( + result.reason === 'budget' || + result.reason === 'elapsed' || + result.reason === 'capacity' + ) { state = 'needs_action'; reason = result.reason; break; diff --git a/web/src/lib/messaging/inbox-sync.ts b/web/src/lib/messaging/inbox-sync.ts @@ -51,6 +51,7 @@ type Snapshot = Readonly<{ bytes: number; retained: number; duplicates: number; + excludedProbes: number; rejected: number; reason: string | null; pending: number; @@ -196,6 +197,7 @@ export function captureInboxSync( bytes = 0, retained = 0, duplicates = 0, + excludedProbes = 0, rejected = 0, pending = 0, reason: string | null = null, @@ -318,6 +320,7 @@ export function captureInboxSync( } if (result.status === 'retained') retained++; else if (result.status === 'duplicate') duplicates++; + else if (result.status === 'probe_excluded') excludedProbes++; else pause(result.status); }) .catch(() => pause('unknown_completion')) @@ -370,6 +373,7 @@ export function captureInboxSync( bytes, retained, duplicates, + excludedProbes, rejected, reason, pending, diff --git a/web/src/lib/nostr/inbox-ingress.ts b/web/src/lib/nostr/inbox-ingress.ts @@ -38,6 +38,7 @@ type Snapshot = Readonly<{ bytes: number; retained: number; duplicates: number; + excludedProbes: number; rejected: number; reason: string | null; pending: number; @@ -145,6 +146,7 @@ export function captureInboxIngress( bytes = 0, retained = 0, duplicates = 0, + excludedProbes = 0, rejected = 0, pending = 0, reason: string | null = null, @@ -190,6 +192,7 @@ export function captureInboxIngress( bytes, retained, duplicates, + excludedProbes, rejected, reason, pending, @@ -272,6 +275,7 @@ export function captureInboxIngress( } if (result.status === 'retained') retained++; else if (result.status === 'duplicate') duplicates++; + else if (result.status === 'probe_excluded') excludedProbes++; else { failed = true; state = 'needs_action'; diff --git a/web/src/lib/persistence/inbox-envelope-repository.ts b/web/src/lib/persistence/inbox-envelope-repository.ts @@ -15,14 +15,20 @@ import { decodePrivateRecord, privateRecordSnapshot, privateRecordWire, + privateReceivedOuterMetadata, type PrivateRecordHandle } from './private-records.ts'; import { loadPrivateRecord, + privateStorageOwner, retainPrivateReceivedRecord, type PrivateStorageRepository, type PrivateStorageFailure } from './private-storage.ts'; +import { + observeInboxProbeDelivery, + consumeInboxProbeDelivery +} from './inbox-probes.ts'; declare const envelopeBrand: unique symbol; export type InboxEnvelope = Readonly<{ [envelopeBrand]: true }>; type Admitted = Readonly<{ @@ -78,10 +84,15 @@ export function inboxEnvelopeSnapshot(token: InboxEnvelope) { const row = envelopes.get(token); return row && privateRecordSnapshot(row.record, row.owner, row.id); } +export function inboxEnvelopeOuterMetadata(token: InboxEnvelope) { + const row = envelopes.get(token); + return row && privateReceivedOuterMetadata(row.record, row.owner, row.id); +} export type InboxRetentionResult = Readonly<{ status: | 'retained' | 'duplicate' + | 'probe_excluded' | 'invalid' | 'stopped' | 'busy' @@ -95,10 +106,11 @@ export async function retainInboxEnvelope( envelope: InboxEnvelope, cancellation?: AbortSignal ): Promise<InboxRetentionResult> { - const admitted = envelopes.get(envelope), - ownership = privateSessionOwnership(session); + const admitted = envelopes.get(envelope); + if (!admitted || privateStorageOwner(repository) !== admitted.owner) + return { status: 'invalid' }; + const ownership = privateSessionOwnership(session); if ( - !admitted || !ownership?.current() || ownership.owner !== admitted.owner || typeof window === 'undefined' || @@ -114,6 +126,37 @@ export async function retainInboxEnvelope( if (!lock) return { status: 'busy' }; if (!ownership.current() || cancellation?.aborted) return { status: 'stopped' }; + const record = privateRecordSnapshot( + admitted.record, + admitted.owner, + admitted.id + ); + if (!record || record.family !== 'received_envelope') + return { status: 'invalid' }; + const probe = await observeInboxProbeDelivery( + repository, + session, + admitted.id, + record.outer, + cancellation + ); + if ( + !ownership.current() || + cancellation?.aborted || + probe === 'stopped' + ) + return { status: 'stopped' }; + if ( + typeof probe !== 'string' && + consumeInboxProbeDelivery( + probe, + repository, + session, + admitted.id, + record.outer + ) + ) + return { status: 'probe_excluded' }; const committed = await retainPrivateReceivedRecord( repository, session, diff --git a/web/src/lib/persistence/inbox-probes.ts b/web/src/lib/persistence/inbox-probes.ts @@ -58,6 +58,7 @@ import { type PrivateAccessProbeReceipt, type PrivateRecordHandle } from './private-records.ts'; +import { LOCAL_PERSISTENCE_BUDGETS } from '../config/budgets.ts'; import { verifyEnvelope, verifiedEnvelopeSnapshot @@ -99,7 +100,7 @@ function createLineage( wire = originalWire, pending = false, retired = false; - return { + const lineage: Lineage = { repository, session, identity, @@ -116,12 +117,14 @@ function createLineage( active: () => !retired, retire() { retired = true; + forgetInboxProbeDelivery(lineage); }, admit(next, nextWire) { record = next; wire = nextWire; } }; + return lineage; } const lineages = new WeakMap<InboxProbeIdentity, Lineage>(); type Saved = Readonly<{ @@ -142,6 +145,162 @@ type Saved = Readonly<{ }> ); const acknowledgements = new WeakMap<InboxProbeAcknowledgement, Saved>(); +// Actual native-admitted source owners only. Decoded journal rows cannot enter +// this bounded, weak repository/session index, including after a realm reload. +const deliveryJournals = new WeakMap< + PrivateStorageRepository, + WeakMap<PrivateSession, Map<string, Saved>> +>(); +declare const deliveryObservationBrand: unique symbol; +export type InboxProbeDeliveryObservation = Readonly<{ + [deliveryObservationBrand]: true; +}>; +const deliveryObservations = new WeakMap< + InboxProbeDeliveryObservation, + Readonly<{ + saved: Saved; + entries: Map<string, Saved>; + id: string; + wire: string; + eventId: string; + outerWire: string; + }> +>(); +function currentDeliveryJournal(saved: Saved) { + try { + return saved.lineage.active() && saved.current(); + } catch { + return false; + } +} +function forgetInboxProbeDelivery(lineage: Lineage) { + const entries = deliveryJournals + .get(lineage.repository) + ?.get(lineage.session); + const id = lineage.record().id; + if (entries?.get(id)?.lineage === lineage) entries.delete(id); +} +function rememberInboxProbeDelivery( + acknowledgement: InboxProbeAcknowledgement +) { + const saved = acknowledgements.get(acknowledgement); + if (!saved || !currentDeliveryJournal(saved)) return; + let sessions = deliveryJournals.get(saved.repository); + if (!sessions) { + sessions = new WeakMap(); + deliveryJournals.set(saved.repository, sessions); + } + let entries = sessions.get(saved.session); + if (!entries) { + entries = new Map(); + sessions.set(saved.session, entries); + } + for (const [id, entry] of entries) + if (!currentDeliveryJournal(entry)) entries.delete(id); + const id = saved.lineage.record().id; + if ( + !entries.has(id) && + entries.size >= LOCAL_PERSISTENCE_BUDGETS.unfinishedPrivateSends + ) + return; + entries.set(id, saved); +} + +// Called by actual admitted-envelope retention under its existing owner lock. +// The result is local receive bookkeeping, never qualification or transport +// authority. Exact source AND fresh whole-owner native custody are required. +export async function observeInboxProbeDelivery( + repository: PrivateStorageRepository, + session: PrivateSession, + eventId: string, + outerWire: string, + cancellation?: AbortSignal +): Promise<InboxProbeDeliveryObservation | 'ordinary' | 'stopped'> { + const entries = deliveryJournals.get(repository)?.get(session); + if (!entries) return 'ordinary'; + for (const [id, saved] of entries) { + if (!currentDeliveryJournal(saved)) { + entries.delete(id); + continue; + } + const lineage = saved.lineage, + record = lineage.record(); + if (record.self?.eventId !== eventId || record.self.wire !== outerWire) + continue; + const ownership = privateSessionOwnership(session), + wire = lineage.wire(); + const drop = () => { + if (entries.get(id) === saved) entries.delete(id); + }; + if (!ownership?.current() || cancellation?.aborted) { + drop(); + return 'stopped'; + } + try { + const observed = await observePrivateRecord( + repository, + 'private_sends', + id + ); + if (!ownership.current() || cancellation?.aborted) { + drop(); + return 'stopped'; + } + if ( + !currentDeliveryJournal(saved) || + entries.get(id) !== saved || + !observed.ok || + lineage.wire() !== wire || + observed.value.wire !== wire || + privateRecordWire(observed.value.handle, ownership.owner, id) !== wire + ) { + drop(); + return 'ordinary'; + } + const proof = Object.freeze({}) as InboxProbeDeliveryObservation; + deliveryObservations.set(proof, { + saved, + entries, + id, + wire, + eventId, + outerWire + }); + return proof; + } catch { + drop(); + return ownership.current() && !cancellation?.aborted + ? 'ordinary' + : 'stopped'; + } + } + return 'ordinary'; +} +// One-use source observation crosses the async native-reader boundary. Its +// exact issuer/index/Lineage is rechecked synchronously at exclusion consumption; +// a copied proof or a newly registered replacement cannot provide authority. +export function consumeInboxProbeDelivery( + proof: InboxProbeDeliveryObservation, + repository: PrivateStorageRepository, + session: PrivateSession, + eventId: string, + outerWire: string +): boolean { + const observed = deliveryObservations.get(proof); + if (!observed) return false; + deliveryObservations.delete(proof); + const { saved, entries, id, wire } = observed; + const current = + saved.repository === repository && + saved.session === session && + observed.eventId === eventId && + observed.outerWire === outerWire && + entries.get(id) === saved && + saved.lineage.wire() === wire && + currentDeliveryJournal(saved); + if (!current && entries.get(id) === saved) entries.delete(id); + return current; +} const actions = new WeakMap< InboxProbeGiftwrap, Readonly<{ @@ -356,6 +515,7 @@ export async function commitInboxProbe( revoked = true; } }); + rememberInboxProbeDelivery(acknowledgement); return { status, acknowledgement }; } ); @@ -616,6 +776,7 @@ export async function adoptRecoveredInboxProbe( revoked = true; } }); + rememberInboxProbeDelivery(acknowledgement); return { status: 'adopted', acknowledgement }; } ); diff --git a/web/tests/e2e/harness/inbox-probe-exclusion.ts b/web/tests/e2e/harness/inbox-probe-exclusion.ts @@ -0,0 +1,536 @@ +import { makeQualificationFixture } from './inbox-access-qualification.ts'; +import type { openRecoveryContext } from './inbox-probe-recovery.ts'; +import { + admitInboxEnvelope, + inboxEnvelopeSnapshot, + retainInboxEnvelope +} from '../../../src/lib/persistence/inbox-envelope-repository.ts'; +import type { PrivateAccessProbe } from '../../../src/lib/persistence/private-records.ts'; +import { observeQualifiedInboxAccess } from '../../../src/lib/messaging/inbox-access-qualification.ts'; +import { + captureInboxIngress, + startInboxIngress, + stopInboxIngress, + inboxIngressSnapshot, + type InboxIngress +} from '../../../src/lib/nostr/inbox-ingress.ts'; +import { + captureInboxSync, + startInboxSync, + stopInboxSync, + inboxSyncSnapshot, + type InboxSync +} from '../../../src/lib/messaging/inbox-sync.ts'; +import { + captureOlderInbox, + loadOlderInbox, + olderInboxSnapshot, + stopOlderInbox, + type OlderInbox +} from '../../../src/lib/messaging/history-pagination.ts'; +import { + captureUnlockedSession, + type UnlockedSession +} from '../../../src/lib/messaging/unlocked-session.ts'; +import { + captureDecryptionQueue, + runDecryptionBatch, + stopDecryptionQueue, + decryptionQueueSnapshot, + decryptionQueueConversations, + type DecryptionQueue +} from '../../../src/lib/messaging/decryption-queue.ts'; +import { + createPublicView, + beginPublicViewRun, + disposePublicView +} from '../../../src/lib/runtime/public-runtime.ts'; +import { + resolveInboxPreference, + settleInboxResolver +} from '../../../src/lib/messaging/resolve-inbox.ts'; +import { + openBrowserDatabase, + browserDatabaseTransaction, + closeBrowserDatabase +} from '../../../src/lib/persistence/database.ts'; +import { inboxProbeRumorWire } from '../../../src/lib/nostr/inbox-access.ts'; +import { recoveredInboxProbeRumorWire } from '../../../src/lib/nostr/self-recovery-reader.ts'; +import { + generateSecretKey, + getPublicKey, + getEventHash, + finalizeEvent +} from 'applesauce-core/helpers'; +import { nip44 } from 'applesauce-core/helpers/encryption'; +export { + observeInboxProbeDelivery, + consumeInboxProbeDelivery +} from '../../../src/lib/persistence/inbox-probes.ts'; +export * from './inbox-access-qualification.ts'; +export { admitInboxEnvelope, retainInboxEnvelope }; +export { openBrowserDatabase, closeBrowserDatabase }; +// Observe real native transactions and mutation calls without changing results. +export function watchExclusionNative() { + const transaction = Object.getOwnPropertyDescriptor( + IDBDatabase.prototype, + 'transaction' + )!.value as IDBDatabase['transaction'], + put = Object.getOwnPropertyDescriptor(IDBObjectStore.prototype, 'put')! + .value as IDBObjectStore['put'], + remove = Object.getOwnPropertyDescriptor( + IDBObjectStore.prototype, + 'delete' + )!.value as IDBObjectStore['delete']; + let readonly = 0, + readwrite = 0, + puts = 0, + deletes = 0; + IDBDatabase.prototype.transaction = function ( + ...args: Parameters<IDBDatabase['transaction']> + ) { + if (args[1] === 'readwrite') readwrite++; + else readonly++; + return transaction.apply(this, args); + }; + IDBObjectStore.prototype.put = function ( + ...args: Parameters<IDBObjectStore['put']> + ) { + puts++; + return put.apply(this, args); + }; + IDBObjectStore.prototype.delete = function ( + ...args: Parameters<IDBObjectStore['delete']> + ) { + deletes++; + return remove.apply(this, args); + }; + return { + counts: () => ({ readonly, readwrite, puts, deletes }), + restore() { + IDBDatabase.prototype.transaction = transaction; + IDBObjectStore.prototype.put = put; + IDBObjectStore.prototype.delete = remove; + } + }; +} +// Delay delivery of the FIRST actual native complete notification. The real +// cursor, result and trusted completion event still run; no success is fabricated. +export function holdExclusionNativeCompletion() { + const transaction = Object.getOwnPropertyDescriptor( + IDBDatabase.prototype, + 'transaction' + )!.value as IDBDatabase['transaction']; + let selected = false, + waiting = false, + released = false; + const deliveries: (() => void)[] = []; + IDBDatabase.prototype.transaction = function ( + ...args: Parameters<IDBDatabase['transaction']> + ) { + const tx = transaction.apply(this, args); + if ( + !selected && + tx.mode === 'readonly' && + tx.objectStoreNames.contains('private_sends') + ) { + selected = true; + const add = tx.addEventListener.bind(tx); + Object.defineProperty(tx, 'addEventListener', { + configurable: true, + value( + type: string, + listener: EventListenerOrEventListenerObject | null, + options?: boolean | AddEventListenerOptions + ) { + if (!listener) return; + if (type !== 'complete') return add(type, listener, options); + add( + type, + (event) => { + const deliver = () => { + if (typeof listener === 'function') listener.call(tx, event); + else listener.handleEvent(event); + }; + if (released) deliver(); + else { + waiting = true; + deliveries.push(deliver); + } + }, + options + ); + } + }); + } + return tx; + }; + return { + waiting: () => waiting, + release() { + released = true; + waiting = false; + IDBDatabase.prototype.transaction = transaction; + for (const deliver of deliveries.splice(0)) deliver(); + } + }; +} +// Real child documents use the surviving extension host while all product +// actors and their private provenance belong to the child's fresh module realm. +export async function retainInRecoveryContext( + context: Awaited<ReturnType<typeof openRecoveryContext>>, + wire: string +) { + const envelope = admitInboxEnvelope( + wire, + context.owner, + 'wss://inbox.example.org', + Date.now() + ); + return envelope + ? (await retainInboxEnvelope(context.repository, context.session, envelope)) + .status + : 'invalid'; +} +export async function decryptInRecoveryContext( + context: Awaited<ReturnType<typeof openRecoveryContext>> +) { + const unlocked = captureUnlockedSession( + context.session, + 'reviewed_messages_unlock' + ); + if (!unlocked) throw Error('actual child explicit unlock'); + const queue = captureDecryptionQueue( + context.repository, + context.session, + context.identity, + unlocked, + 'reviewed_inbox_unlock' + ); + if (!queue) throw Error('actual child decryption queue'); + try { + const result = await runDecryptionBatch( + queue, + 'reviewed_decrypt_batch', + [] + ); + return { + result, + snapshot: decryptionQueueSnapshot(queue), + rooms: decryptionQueueConversations(queue).length + }; + } finally { + stopDecryptionQueue(queue); + } +} +export async function makeExclusionFixture() { + const base = await makeQualificationFixture(); + const views: ReturnType<typeof createPublicView>[] = []; + let finite: InboxIngress | undefined, + sync: InboxSync | undefined, + older: OlderInbox | undefined, + unlocked: UnlockedSession | undefined, + queue: DecryptionQueue | undefined; + async function selfWire() { + const row = (await base.host.stored()).find( + (value) => value.id === base.command() + ); + if (!row) throw Error('actual source-admitted original probe row'); + const record = JSON.parse(row.wire) as PrivateAccessProbe; + if (!record.self) throw Error('actual original self ciphertext'); + return record.self.wire; + } + return { + ...base, + selfWire, + async seedReceived(count = 1999) { + if (!Number.isSafeInteger(count) || count < 0 || count > 2000) + throw Error('bounded native quota fixture'); + const probe = JSON.parse(await selfWire()) as { created_at: number }; + const secret = generateSecretKey(), + key = nip44.v2.utils.getConversationKey(secret, base.host.owner); + const rows: { owner: string; id: string; wire: string }[] = []; + try { + const content = nip44.v2.encrypt( + 'bounded native outer-only quota fixture', + key + ); + for (let n = 0; n < count; n++) { + const event = finalizeEvent( + { + kind: 1059, + created_at: probe.created_at + n + 1, + tags: [['p', base.host.owner]], + content + }, + secret + ); + const envelope = admitInboxEnvelope( + JSON.stringify(event), + base.host.owner, + 'wss://inbox.example.org', + Date.now() + ); + const record = envelope && inboxEnvelopeSnapshot(envelope); + if (!record) + throw Error('actual stock signed outer fixture admission'); + rows.push({ + owner: base.host.owner, + id: event.id, + wire: JSON.stringify(record) + }); + } + } finally { + key.fill(0); + secret.fill(0); + } + const opened = await openBrowserDatabase(); + if (opened.state !== 'ready') + throw Error('actual received quota database'); + try { + const tx = browserDatabaseTransaction( + opened.owner, + ['received_envelopes'], + 'readwrite' + ); + for (const row of rows) tx.objectStore('received_envelopes').put(row); + await new Promise<void>((resolve, reject) => { + tx.addEventListener('complete', () => resolve()); + tx.addEventListener('abort', () => + reject(Error('actual received quota seed abort')) + ); + }); + } finally { + closeBrowserDatabase(opened.owner); + } + return probe.created_at + 1; + }, + async deleteReceived(id: string) { + const opened = await openBrowserDatabase(); + if (opened.state !== 'ready') + throw Error('actual received fixture deletion'); + try { + const tx = browserDatabaseTransaction( + opened.owner, + ['received_envelopes'], + 'readwrite' + ); + tx.objectStore('received_envelopes').delete([base.host.owner, id]); + await new Promise<void>((resolve, reject) => { + tx.addEventListener('complete', () => resolve()); + tx.addEventListener('abort', () => + reject(Error('actual received fixture delete abort')) + ); + }); + } finally { + closeBrowserDatabase(opened.owner); + } + }, + async rowWire() { + const row = (await base.host.stored()).find( + (value) => value.id === base.command() + ); + if (!row) throw Error('actual source journal row'); + return row.wire; + }, + async replaceRow( + wire: string, + id = base.command()!, + owner = base.host.owner + ) { + const opened = await openBrowserDatabase(); + if (opened.state !== 'ready') + throw Error('actual fixture native database'); + try { + const tx = browserDatabaseTransaction( + opened.owner, + ['private_sends'], + 'readwrite' + ); + tx.objectStore('private_sends').put({ owner, id, wire }); + await new Promise<void>((resolve, reject) => { + tx.addEventListener('complete', () => resolve()); + tx.addEventListener('abort', () => + reject(Error('actual fixture native write abort')) + ); + }); + } finally { + closeBrowserDatabase(opened.owner); + } + }, + ordinaryWire(recovered: boolean, time?: number) { + const a = base.actors(), + original = base.originalIdentity(), + proof = base.proof(); + const rumorWire = + recovered && proof + ? recoveredInboxProbeRumorWire( + proof, + base.repository, + a.session, + a.access, + base.host.policy, + base.host.qualification + ) + : original && inboxProbeRumorWire(original, a.session); + if (!rumorWire) throw Error('actual original diagnostic rumor source'); + const diagnostic = JSON.parse(rumorWire) as { + content: string; + created_at: number; + }; + const peer = generateSecretKey(), + outer = generateSecretKey(); + function encrypt(secret: Uint8Array, plain: string) { + const key = nip44.v2.utils.getConversationKey(secret, base.host.owner); + try { + return nip44.v2.encrypt(plain, key); + } finally { + key.fill(0); + } + } + try { + const template = { + pubkey: getPublicKey(peer), + kind: 14, + created_at: diagnostic.created_at, + tags: [['p', base.host.owner]], + content: diagnostic.content + }; + const rumor = { id: getEventHash(template), ...template }; + const seal = finalizeEvent( + { + kind: 13, + created_at: diagnostic.created_at, + tags: [], + content: encrypt(peer, JSON.stringify(rumor)) + }, + peer + ); + return JSON.stringify( + finalizeEvent( + { + kind: 1059, + created_at: time ?? diagnostic.created_at, + tags: [['p', base.host.owner]], + content: encrypt(outer, JSON.stringify(seal)) + }, + outer + ) + ); + } finally { + peer.fill(0); + outer.fill(0); + } + }, + async startReceive(lane: 'finite' | 'sync') { + const qualification = base.qualification(); + if (!qualification) + throw Error('actual genuine access qualification missing'); + const a = base.actors(), + view = createPublicView(base.sharedPublicRuntime()); + views.push(view); + const own = resolveInboxPreference( + view, + beginPublicViewRun(view), + base.host.owner + ); + await settleInboxResolver(own); + const observe = observeQualifiedInboxAccess(qualification); + if (lane === 'finite') { + finite = captureInboxIngress( + base.repository, + a.session, + base.host.policy, + own, + observe, + 'reviewed_private_inbox_receive' + ); + return ( + !!finite && + startInboxIngress(finite, 'reviewed_private_inbox_receive') + ); + } + unlocked = captureUnlockedSession(a.session, 'reviewed_messages_unlock'); + if (!unlocked) throw Error('actual owner unlocked scope'); + sync = captureInboxSync( + base.repository, + a.session, + base.host.policy, + own, + unlocked, + observe, + 'reviewed_foreground_inbox' + ); + return !!sync && startInboxSync(sync, 'reviewed_foreground_inbox'); + }, + receiveSnapshot: () => + finite ? inboxIngressSnapshot(finite) : sync && inboxSyncSnapshot(sync), + async older() { + if (!sync) throw Error('actual foreground sync'); + older ??= captureOlderInbox(sync, 'reviewed_load_older'); + return !!older && loadOlderInbox(older, 'reviewed_load_older'); + }, + olderSnapshot: () => older && olderInboxSnapshot(older), + stopReceive() { + if (older) stopOlderInbox(older); + if (finite) stopInboxIngress(finite); + if (sync) stopInboxSync(sync); + }, + async decryptStored() { + const a = base.actors(); + unlocked ??= captureUnlockedSession( + a.session, + 'reviewed_messages_unlock' + ); + if (!unlocked) throw Error('actual explicit unlock'); + queue ??= captureDecryptionQueue( + base.repository, + a.session, + a.identity, + unlocked, + 'reviewed_inbox_unlock' + ); + if (!queue) throw Error('actual explicit decryption queue'); + const before = base.host.counts(); + const result = await runDecryptionBatch( + queue, + 'reviewed_decrypt_batch', + [] + ); + return { + result, + snapshot: decryptionQueueSnapshot(queue), + rooms: decryptionQueueConversations(queue).length, + before, + after: base.host.counts() + }; + }, + async retain(raw?: string, cancellation?: AbortSignal) { + const a = base.actors(); + const envelope = admitInboxEnvelope( + raw ?? (await selfWire()), + base.host.owner, + 'wss://inbox.example.org', + Date.now() + ); + return envelope + ? ( + await retainInboxEnvelope( + base.repository, + a.session, + envelope, + cancellation + ) + ).status + : 'invalid'; + }, + close() { + if (queue) stopDecryptionQueue(queue); + if (older) stopOlderInbox(older); + if (finite) stopInboxIngress(finite); + if (sync) stopInboxSync(sync); + for (const view of views) disposePublicView(view); + base.close(); + } + }; +} diff --git a/web/tests/e2e/inbox-probe-exclusion.spec.ts b/web/tests/e2e/inbox-probe-exclusion.spec.ts @@ -0,0 +1,1267 @@ +import { test, expect, type Page } from '@playwright/test'; +import { build } from 'vite'; +import { once } from 'node:events'; +import { fileURLToPath } from 'node:url'; +import { WebSocketServer, type WebSocket } from 'ws'; +import { createStaticHarness } from '../integration/harness/static.ts'; +import type * as Fixture from './harness/inbox-probe-exclusion.ts'; +declare global { + interface Window { + qx: typeof Fixture; + qxFixture: Awaited<ReturnType<typeof Fixture.makeExclusionFixture>>; + qxChild: Awaited<ReturnType<typeof Fixture.openRecoveryContext>>; + qxHold: ReturnType<typeof Fixture.holdExclusionNativeCompletion>; + qxPending: Promise<string>; + qxCancellation: AbortController; + } +} +let server: Awaited<ReturnType<typeof createStaticHarness>>, + sockets: WebSocketServer, + endpoint: string, + bundle: string, + head = ''; +const physical = new Set<WebSocket>(), + archived = new Map<string, unknown>(), + physicalOrigins = new WeakMap<WebSocket, string>(), + live = new Map<WebSocket, string>(); +let receiveFrames: { id: string; created_at: number }[] = []; +let receiveLane: 'none' | 'history' | 'live' | 'both' = 'none'; +const requests: { + origin: string; + filter: { kinds?: number[]; ids?: string[]; limit?: number; until?: number }; +}[] = []; +const origins = [ + 'wss://inbox.example.org', + 'wss://peer.example.org', + 'wss://archive.example.org' +]; +test.beforeAll(async () => { + server = await createStaticHarness(); + sockets = new WebSocketServer({ + host: '127.0.0.1', + port: 0, + maxPayload: 65536 + }); + await once(sockets, 'listening'); + const address = sockets.address(); + if (!address || typeof address === 'string') + throw Error('actual loopback endpoint'); + endpoint = 'ws://127.0.0.1:' + address.port; + sockets.on('connection', (socket, request) => { + physical.add(socket); + socket.on('close', () => { + physical.delete(socket); + live.delete(socket); + }); + const origin = new URL(request.url!, 'http://127.0.0.1').searchParams.get( + 'origin' + )!; + physicalOrigins.set(socket, origin); + socket.on('message', (bytes) => { + const raw = Buffer.isBuffer(bytes) + ? bytes + : Array.isArray(bytes) + ? Buffer.concat(bytes) + : Buffer.from(bytes); + const frame = JSON.parse(raw.toString()) as unknown[]; + if (frame[0] === 'REQ') { + const filter = frame[2] as { + kinds?: number[]; + ids?: string[]; + limit?: number; + until?: number; + }; + if (requests.length >= 10000) + throw Error('bounded fixture request log'); + requests.push({ origin, filter }); + if (filter.kinds?.includes(10050) && head) + socket.send(JSON.stringify(['EVENT', frame[1], JSON.parse(head)])); + if (filter.kinds?.includes(1059)) { + if (filter.ids) { + const event = archived.get(JSON.stringify([origin, filter.ids[0]])); + if (event) socket.send(JSON.stringify(['EVENT', frame[1], event])); + } else { + if (filter.limit === 0) live.set(socket, String(frame[1])); + if ( + receiveLane === 'both' || + (receiveLane === 'history' && filter.limit !== 0) || + (receiveLane === 'live' && filter.limit === 0) + ) { + for (const event of receiveFrames) + if ( + filter.until === undefined || + event.created_at <= filter.until + ) + socket.send(JSON.stringify(['EVENT', frame[1], event])); + } + } + } + socket.send(JSON.stringify(['EOSE', frame[1]])); + } else if (frame[0] === 'EVENT') { + const event = frame[1] as { id: string }; + archived.set(JSON.stringify([origin, event.id]), event); + socket.send( + JSON.stringify(['OK', event.id, true, 'controlled named acceptance']) + ); + } + }); + }); + const result = await build({ + configFile: false, + logLevel: 'silent', + build: { + write: false, + minify: false, + lib: { + entry: fileURLToPath( + new URL('./harness/inbox-probe-exclusion.ts', import.meta.url) + ), + name: 'qx', + formats: ['iife'] + } + } + }); + const output = Array.isArray(result) ? result[0] : result; + if (!('output' in output)) throw Error('actual compiled exclusion harness'); + const chunks = output.output.filter((item) => item.type === 'chunk'); + expect(chunks).toHaveLength(1); + bundle = chunks[0].code; +}); +test.afterAll(async () => { + for (const socket of sockets.clients) socket.terminate(); + await new Promise<void>((resolve) => sockets.close(() => resolve())); + await server.close(); +}); +test.beforeEach(async ({ page }) => { + await expect.poll(() => physical.size).toBe(0); + head = ''; + archived.clear(); + live.clear(); + requests.length = 0; + receiveFrames = []; + receiveLane = 'none'; + await page.addInitScript( + ({ endpoint, origins }) => { + const Native = window.WebSocket; + window.WebSocket = class extends Native { + constructor(url: string | URL, protocols?: string | string[]) { + const origin = new URL(String(url)).origin; + if (!['wss://discovery.example.org', ...origins].includes(origin)) + throw Error('unapproved fixture origin'); + super(endpoint + '/?origin=' + encodeURIComponent(origin), protocols); + } + }; + }, + { endpoint, origins } + ); + await page.goto(server.url + '/search'); + await page.addScriptTag({ content: bundle }); + head = await page.evaluate(async (origins) => { + window.qxFixture = await window.qx.makeExclusionFixture(); + return window.qxFixture.host.preferenceWire(origins); + }, origins); + await page.evaluate(async () => { + await window.qxFixture.open(); + if ((await window.qxFixture.prepareOriginal()).status !== 'prepared') + throw Error('actual original S3/R1 preparation'); + }); +}); +test.afterEach(async ({ page }) => { + if (page.isClosed()) return; + const closed = await page.evaluate(() => { + try { + window.qxFixture.close(); + return true; + } catch (error) { + if ( + error instanceof Error && + [ + 'private_inbox_cleanup_required', + 'private_history_cleanup_required', + 'private_auth_cleanup_required' + ].includes(error.message) + ) + return false; + throw error; + } + }); + if (!closed) { + await expect + .poll( + () => + Array.from(physical).filter( + (socket) => + physicalOrigins.get(socket) !== 'wss://discovery.example.org' + ).length + ) + .toBe(0); + await page.evaluate(() => window.qxFixture.close()); + } +}); +test('original actual admitted journal excludes exact self ciphertext before received retention', async ({ + page +}) => { + const result = await page.evaluate(async () => { + const f = window.qxFixture, + before = f.host.counts(); + const status = await f.retain(); + return { + status, + before, + after: f.host.counts(), + received: (await f.receivedRows()).length + }; + }); + expect(result.status).toBe('probe_excluded'); + expect(result.received).toBe(0); + expect(result.after).toEqual(result.before); +}); +test('original actual C7 loss during native observation uses ordinary owner-current retention', async ({ + page +}) => { + const result = await page.evaluate(async () => { + const f = window.qxFixture; + const fault = f.nativeFault('read_loss', () => f.stop()); + try { + const status = await f.retain(); + return { + status, + native: fault.counts(), + received: (await f.receivedRows()).length + }; + } finally { + fault.restore(); + } + }); + expect(result.native.readonly).toBe(1); + expect(result.status).toBe('retained'); + expect(result.received).toBe(1); +}); + +for (const recovered of [false, true]) { + const label = recovered ? 'REC' : 'original'; + test(`${label} actual readonly exclusion performs zero native mutations`, async ({ + page + }) => { + const result = await page.evaluate(async (recovered) => { + const f = window.qxFixture; + if (recovered && (await f.qualify(true)).status !== 'saved') + throw Error('actual REC'); + const wire = await f.selfWire(), + before = f.host.counts(), + watch = window.qx.watchExclusionNative(); + try { + const status = await f.retain(wire); + return { + status, + native: watch.counts(), + before, + after: f.host.counts() + }; + } finally { + watch.restore(); + } + }, recovered); + expect(result.status).toBe('probe_excluded'); + expect(result.native.readonly).toBeGreaterThan(0); + expect(result.native).toMatchObject({ readwrite: 0, puts: 0, deletes: 0 }); + expect(result.after).toEqual(result.before); + }); + test(`${label} held actual owner WebLock refuses before native or provider work`, async ({ + page + }) => { + const result = await page.evaluate(async (recovered) => { + const f = window.qxFixture; + if (recovered && (await f.qualify(true)).status !== 'saved') + throw Error('actual REC'); + const wire = await f.selfWire(), + before = f.host.counts(), + watch = window.qx.watchExclusionNative(); + try { + return await navigator.locks.request( + 'harvestcircle:owner:' + f.host.owner, + async () => ({ + status: await f.retain(wire), + native: watch.counts(), + before, + after: f.host.counts() + }) + ); + } finally { + watch.restore(); + } + }, recovered); + expect(result.status).toBe('busy'); + expect(result.native).toEqual({ + readonly: 0, + readwrite: 0, + puts: 0, + deletes: 0 + }); + expect(result.after).toEqual(result.before); + }); + for (const loss of ['cancel', 'session', 'C7', 'head'] as const) + test(`${label} actual ${loss} loss while native completion is held cannot exclude`, async ({ + page + }) => { + await page.evaluate(async (recovered) => { + const f = window.qxFixture; + if (recovered && (await f.qualify(true)).status !== 'saved') + throw Error('actual REC'); + }, recovered); + await page.evaluate(async () => { + const wire = await window.qxFixture.selfWire(); + window.qxCancellation = new AbortController(); + window.qxHold = window.qx.holdExclusionNativeCompletion(); + window.qxPending = window.qxFixture.retain( + wire, + window.qxCancellation.signal + ); + }); + await expect + .poll(() => page.evaluate(() => window.qxHold.waiting())) + .toBe(true); + const result = await page.evaluate(async (loss) => { + const f = window.qxFixture; + try { + if (loss === 'cancel') window.qxCancellation.abort(); + else if (loss === 'session') + window.qx.closePrivateSession(f.actors().session); + else if (loss === 'head') f.actors().churnHead(); + else if (loss === 'C7') f.stop(); + } finally { + window.qxHold.release(); + } + return { + status: await window.qxPending, + received: (await f.receivedRows()).length + }; + }, loss); + expect(result.status).toBe( + loss === 'C7' || loss === 'head' ? 'retained' : 'stopped' + ); + expect(result.received).toBe(loss === 'C7' || loss === 'head' ? 1 : 0); + }); + test(`${label} copied signed id with changed ciphertext fails ordinary admission`, async ({ + page + }) => { + const result = await page.evaluate(async (recovered) => { + const f = window.qxFixture; + if (recovered && (await f.qualify(true)).status !== 'saved') + throw Error('actual REC'); + const event = JSON.parse(await f.selfWire()) as { content: string }; + event.content = + event.content.slice(0, -1) + (event.content.endsWith('A') ? 'B' : 'A'); + const before = f.host.counts(), + status = await f.retain(JSON.stringify(event)); + return { + status, + before, + after: f.host.counts(), + received: (await f.receivedRows()).length + }; + }, recovered); + expect(result.status).toBe('invalid'); + expect(result.received).toBe(0); + expect(result.after).toEqual(result.before); + }); + test(`${label} copied envelope and different genuine repository session and owner cannot borrow exclusion`, async ({ + page + }) => { + const result = await page.evaluate(async (recovered) => { + const q = window.qx, + f = window.qxFixture; + if (recovered && (await f.qualify(true)).status !== 'saved') + throw Error('actual REC'); + const wire = await f.selfWire(), + a = f.actors(), + opened = await q.openBrowserDatabase(); + if (opened.state !== 'ready') throw Error('actual database'); + const other = q.createPrivateStorageRepository( + opened.owner, + f.host.owner + )!; + const identity = q.createIdentitySession(); + await q.connectIdentity(identity); + await q.probeIdentityMessaging(identity, 'reviewed_self_copy'); + const session = await q.createPrivateSession( + identity, + 'reviewed_private_session' + ); + if (!session || session === a.session || other === f.repository) + throw Error('actual distinct source actors'); + try { + const envelope = q.admitInboxEnvelope( + wire, + f.host.owner, + originsForBrowser(), + Date.now() + )!; + const before = f.host.counts(); + const copied = await q.retainInboxEnvelope(f.repository, a.session, { + ...envelope + }); + const foreign = await q.retainInboxEnvelope( + f.host.foreignRepository(), + a.session, + envelope + ); + const otherRepository = await q.retainInboxEnvelope( + other, + a.session, + envelope + ); + const otherSession = await q.retainInboxEnvelope( + f.repository, + session, + envelope + ); + return { + copied: copied.status, + foreign: foreign.status, + otherRepository: otherRepository.status, + otherSession: otherSession.status, + before, + after: f.host.counts() + }; + } finally { + q.closePrivateSession(session); + q.disconnectIdentity(identity); + q.closeBrowserDatabase(opened.owner); + } + function originsForBrowser() { + return 'wss://inbox.example.org'; + } + }, recovered); + expect(result).toMatchObject({ + copied: 'invalid', + foreign: 'invalid', + otherRepository: 'retained', + otherSession: 'duplicate' + }); + expect(result.after).toEqual(result.before); + }); + test(`${label} only a new genuine source admission restores exclusion after observed absence`, async ({ + page + }) => { + const result = await page.evaluate(async (recovered) => { + const f = window.qxFixture; + if (recovered && (await f.qualify(true)).status !== 'saved') + throw Error('actual REC'); + const wire = await f.selfWire(), + row = await f.rowWire(); + await f.removeFixtureRow(); + const missing = await f.retain(wire); + await f.replaceRow(row); + const restored = await f.retain(wire); + await f.freshSession(); + const recovery = await f.recover(); + if (!recovery || recovery.status !== 'recovered') + throw Error('actual fresh recovery'); + const adopted = await f.adopt(); + if (!('acknowledgement' in adopted)) throw Error('actual fresh adoption'); + return { + missing, + restored, + readmitted: await f.retain(wire), + received: (await f.receivedRows()).length + }; + }, recovered); + expect(result).toEqual({ + missing: 'retained', + restored: 'duplicate', + readmitted: 'probe_excluded', + received: 1 + }); + }); + for (const lane of ['finite', 'sync'] as const) + test(`${label} genuine ${lane} pending queue stays bounded while actual native completion is held`, async ({ + page + }) => { + await qualify(page, recovered); + const wire = await page.evaluate(() => window.qxFixture.selfWire()); + receiveFrames = Array.from( + { length: 501 }, + () => JSON.parse(wire) as (typeof receiveFrames)[number] + ); + receiveLane = lane === 'finite' ? 'history' : 'live'; + await page.evaluate(() => { + window.qxHold = window.qx.holdExclusionNativeCompletion(); + }); + try { + expect( + await page.evaluate( + (lane) => window.qxFixture.startReceive(lane), + lane + ) + ).toBe(true); + await expect + .poll(() => page.evaluate(() => window.qxHold.waiting())) + .toBe(true); + await expect + .poll(() => + page.evaluate(() => window.qxFixture.receiveSnapshot()?.reason) + ) + .toBe('budget'); + const held = await page.evaluate(() => + window.qxFixture.receiveSnapshot() + ); + expect(held!.pending).toBeGreaterThan(0); + expect(held!.pending).toBeLessThanOrEqual(500); + expect(held!.excludedProbes).toBe(0); + } finally { + await page.evaluate(() => window.qxHold.release()); + } + await expect + .poll(() => + page.evaluate(() => window.qxFixture.receiveSnapshot()?.pending) + ) + .toBe(0); + expect( + await page.evaluate( + async () => (await window.qxFixture.receivedRows()).length + ) + ).toBe(0); + }); + test(`${label} repeated full inclusive probe page saturates and actual Stop clears transient cursors`, async ({ + page + }) => { + await qualify(page, recovered); + expect( + await page.evaluate(() => window.qxFixture.startReceive('sync')) + ).toBe(true); + await liveReady(page); + const wire = await page.evaluate(() => window.qxFixture.selfWire()); + receiveFrames = Array.from( + { length: 200 }, + () => JSON.parse(wire) as (typeof receiveFrames)[number] + ); + receiveLane = 'history'; + expect(await page.evaluate(() => window.qxFixture.older())).toBe(true); + expect( + (await page.evaluate(() => window.qxFixture.olderSnapshot()))!.sources[0] + .state + ).toBe('capped'); + expect(await page.evaluate(() => window.qxFixture.older())).toBe(true); + expect( + (await page.evaluate(() => window.qxFixture.olderSnapshot()))!.sources[0] + .state + ).toBe('saturated'); + const count = requests.length; + expect(await page.evaluate(() => window.qxFixture.older())).toBe(true); + // Shared500 cap may leave later sources partial; the saturated FIRST + // source itself cannot be requested a third time. + expect( + requests + .slice(count) + .filter((row) => row.origin === origins[0] && row.filter.limit !== 0) + ).toHaveLength(0); + await page.evaluate(() => { + try { + window.qxFixture.stopReceive(); + } catch (error) { + if ( + !(error instanceof Error) || + ![ + 'private_history_cleanup_required', + 'private_inbox_cleanup_required' + ].includes(error.message) + ) + throw error; + } + }); + expect( + (await page.evaluate(() => window.qxFixture.olderSnapshot()))!.sources + ).toEqual([]); + expect(await page.evaluate(() => window.qxFixture.older())).toBe(false); + expect( + await page.evaluate( + async () => (await window.qxFixture.receivedRows()).length + ) + ).toBe(0); + }); + test(`${label} observed generation loss clears transient excluded cursor metadata`, async ({ + page + }) => { + await qualify(page, recovered); + expect( + await page.evaluate(() => window.qxFixture.startReceive('sync')) + ).toBe(true); + await liveReady(page); + const wire = await page.evaluate(() => window.qxFixture.selfWire()); + receiveFrames = [JSON.parse(wire) as (typeof receiveFrames)[number]]; + receiveLane = 'history'; + expect(await page.evaluate(() => window.qxFixture.older())).toBe(true); + expect( + (await page.evaluate(() => window.qxFixture.olderSnapshot()))!.sources + .length + ).toBeGreaterThan(0); + await page.evaluate(() => window.qxFixture.actors().churnHead()); + expect(await page.evaluate(() => window.qxFixture.older())).toBe(false); + expect( + (await page.evaluate(() => window.qxFixture.olderSnapshot()))!.sources + ).toEqual([]); + }); + test(`${label} same current direct probe remains excluded on repeated delivery`, async ({ + page + }) => { + const result = await page.evaluate(async (recovered) => { + const f = window.qxFixture; + if (recovered && (await f.qualify(true)).status !== 'saved') + throw Error('actual REC source'); + const before = f.host.counts(), + first = await f.retain(), + second = await f.retain(); + return { + first, + second, + before, + after: f.host.counts(), + received: (await f.receivedRows()).length + }; + }, recovered); + expect(result.first).toBe('probe_excluded'); + expect(result.second).toBe('probe_excluded'); + expect(result.received).toBe(0); + expect(result.after).toEqual(result.before); + }); + test(`${label} fresh actual session without adoption receives stored probe through ordinary decrypt`, async ({ + page + }) => { + const result = await page.evaluate(async (recovered) => { + const f = window.qxFixture; + if (recovered && (await f.qualify(true)).status !== 'saved') + throw Error('actual REC source'); + const wire = await f.selfWire(); + await f.freshSession(); + const before = f.host.counts(), + status = await f.retain(wire), + afterRetain = f.host.counts(), + decrypted = await f.decryptStored(); + return { status, before, afterRetain, decrypted }; + }, recovered); + expect(result.status).toBe('retained'); + expect(result.afterRetain).toEqual(result.before); + expect(result.decrypted.snapshot).toMatchObject({ + attempted: 1, + invalid: 1, + admitted: 0 + }); + expect( + result.decrypted.after.decrypts - result.decrypted.before.decrypts + ).toBe(2); + }); + test(`${label} actual browser reload loses suppression admission while keeping native journal`, async ({ + page + }) => { + const setup = await page.evaluate(() => { + const f = window.qxFixture; + return { + owner: f.host.owner, + policyWire: JSON.stringify(window.qx.readRelayPolicy(f.host.policy)), + operatorWire: window.qx.inboxOperatorQualificationWire( + f.host.qualification, + f.host.policy + )! + }; + }); + await page.evaluate((url) => { + const child = document.createElement('iframe'); + child.id = 'exclusion-realm'; + child.src = url; + document.body.append(child); + }, server.url + '/search'); + const frame = await ( + await page.locator('#exclusion-realm').elementHandle() + ).contentFrame(); + if (!frame) throw Error('actual same-origin child'); + await frame.waitForLoadState(); + await frame.addScriptTag({ content: bundle }); + const original = await frame.evaluate( + async ({ setup, recovered }) => { + window.qx.installHostedProvider(); + const policy = window.qx.validateRelayPolicy(setup.policyWire)!, + operator = window.qx.validateInboxOperatorQualification( + setup.operatorWire + )!; + const id = crypto.randomUUID(); + const context = await window.qx.openRecoveryContext( + setup.owner, + policy, + operator, + id + ); + const record = await window.qx.prepareHostedOriginal(context); + if (recovered) { + const result = await context.recover( + context.capture('reviewed_inbox_probe_recovery', record.id) + ); + if (!('proof' in result)) throw Error('actual child recovery'); + const adopted = await window.qx.adoptRecoveredInboxProbe( + context.repository, + context.session, + context.access, + policy, + operator, + result.proof, + 'reviewed_original_inbox_probe_retry' + ); + if (!('acknowledgement' in adopted)) + throw Error('actual child adoption'); + } + const wire = record.self!.wire; + const before = await window.qx.retainInRecoveryContext(context, wire); + context.close(); + return { id: record.id, wire, before }; + }, + { setup, recovered } + ); + expect(original.before).toBe('probe_excluded'); + await frame.goto(server.url + '/search'); + await frame.addScriptTag({ content: bundle }); + const before = await page.evaluate(() => window.qxFixture.host.counts()); + const result = await frame.evaluate( + async ({ setup, original }) => { + window.qx.installHostedProvider(); + window.qxChild = await window.qx.openRecoveryContext( + setup.owner, + window.qx.validateRelayPolicy(setup.policyWire)!, + window.qx.validateInboxOperatorQualification(setup.operatorWire)!, + original.id + ); + const status = await window.qx.retainInRecoveryContext( + window.qxChild, + original.wire + ); + return { status }; + }, + { setup, original } + ); + const afterRetain = await page.evaluate(() => + window.qxFixture.host.counts() + ); + const decrypted = await frame.evaluate(() => + window.qx.decryptInRecoveryContext(window.qxChild) + ); + const after = await page.evaluate(() => window.qxFixture.host.counts()); + await frame.evaluate(() => window.qxChild.close()); + expect( + await page.evaluate( + async () => (await window.qxFixture.host.stored()).length + ) + ).toBe(2); + expect(result.status).toBe('retained'); + // Opening the actual fresh identity performs its existing capability probe. + expect(afterRetain.decrypts - before.decrypts).toBe(1); + expect(afterRetain.signs).toBe(before.signs); + expect(decrypted.snapshot).toMatchObject({ + attempted: 1, + invalid: 1, + admitted: 0 + }); + expect(after.decrypts - afterRetain.decrypts).toBe(2); + }); + for (const lane of ['finite', 'sync'] as const) + test(`${label} genuine ${lane} probe flood exhausts original delivery budget before exclusion`, async ({ + page + }) => { + await qualify(page, recovered); + const wire = await page.evaluate(() => window.qxFixture.selfWire()), + event = JSON.parse(wire) as (typeof receiveFrames)[number]; + receiveFrames = Array.from({ length: 501 }, () => event); + receiveLane = 'history'; + const before = await page.evaluate(() => window.qxFixture.host.counts()); + expect( + await page.evaluate((lane) => window.qxFixture.startReceive(lane), lane) + ).toBe(true); + await expect + .poll(() => + page.evaluate(() => window.qxFixture.receiveSnapshot()?.reason) + ) + .toBe('budget'); + await expect + .poll(() => + page.evaluate(() => window.qxFixture.receiveSnapshot()?.pending) + ) + .toBe(0); + const result = await page.evaluate(async () => ({ + snapshot: window.qxFixture.receiveSnapshot(), + received: (await window.qxFixture.receivedRows()).length, + after: window.qxFixture.host.counts() + })); + expect(result.snapshot!.candidates).toBeGreaterThan(0); + expect(result.snapshot!.candidates).toBeLessThanOrEqual(501); + expect(result.snapshot!.bytes).toBe( + result.snapshot!.candidates * Buffer.byteLength(wire) + ); + expect(result.snapshot!.excludedProbes).toBeLessThanOrEqual( + result.snapshot!.candidates + ); + expect(result.received).toBe(0); + expect(result.after).toEqual({ + ...before, + keys: before.keys + (lane === 'sync' ? 2 : 1) + }); + }); + for (const order of [ + 'ordinary-first', + 'probe-first', + 'between-pages' + ] as const) + test(`${label} mixed 1999-row ${order} preserves bounded cursor facts and honest native retention`, async ({ + page + }) => { + await qualify(page, recovered); + const nativeUntil = await page.evaluate(() => + window.qxFixture.seedReceived() + ); + expect( + await page.evaluate(() => window.qxFixture.startReceive('sync')) + ).toBe(true); + await liveReady(page); + const wire = await page.evaluate(() => window.qxFixture.selfWire()), + probe = JSON.parse(wire) as (typeof receiveFrames)[number]; + const normal = JSON.parse( + await page.evaluate( + ({ recovered, time }) => + window.qxFixture.ordinaryWire(recovered, time), + { recovered, time: probe.created_at - 1 } + ) + ) as (typeof receiveFrames)[number]; + receiveFrames = order === 'ordinary-first' ? [normal, probe] : [probe]; + if (order === 'probe-first') receiveFrames.push(normal); + receiveLane = 'history'; + expect(await page.evaluate(() => window.qxFixture.older())).toBe(true); + if (order === 'between-pages') { + expect( + (await page.evaluate(() => window.qxFixture.olderSnapshot()))!.reason + ).toBeNull(); + expect( + await page.evaluate( + (wire) => window.qxFixture.retain(wire), + JSON.stringify(normal) + ) + ).toBe('retained'); + receiveFrames = []; + expect(await page.evaluate(() => window.qxFixture.older())).toBe(false); + } + expect( + await page.evaluate(() => window.qxFixture.olderSnapshot()) + ).toMatchObject({ + state: 'needs_action', + reason: 'capacity', + historyComplete: false + }); + expect( + await page.evaluate( + async () => (await window.qxFixture.receivedRows()).length + ) + ).toBe(2000); + await page.evaluate( + (id) => window.qxFixture.deleteReceived(id), + normal.id + ); + receiveFrames = []; + expect(await page.evaluate(() => window.qxFixture.older())).toBe(true); + const after = await page.evaluate(() => window.qxFixture.olderSnapshot()); + if (order === 'ordinary-first') { + expect(after!.sources[0].seen).not.toContain(probe.id); + expect(after!.sources[0].until).toBe(nativeUntil); + } else { + expect(after!.sources[0].seen).toContain(probe.id); + expect(after!.sources[0].until).toBe(probe.created_at); + } + expect(after!.historyComplete).toBe(false); + }); +} + +async function qualify(page: Page, recovered: boolean) { + expect( + await page.evaluate( + async (recovered) => (await window.qxFixture.qualify(recovered)).status, + recovered + ) + ).toBe('saved'); + expect( + await page.evaluate( + async () => (await window.qxFixture.qualifyAccess()).status + ) + ).toBe('qualified'); +} +async function liveReady(page: Page) { + await expect + .poll(() => + page.evaluate(() => { + const snapshot = window.qxFixture.receiveSnapshot(); + return snapshot && 'backfill' in snapshot + ? { + state: snapshot.state, + backfill: snapshot.backfill, + pending: snapshot.pending + } + : undefined; + }) + ) + .toEqual({ state: 'live', backfill: 'complete', pending: 0 }); +} +for (const recovered of [false, true]) { + const label = recovered ? 'REC' : 'original'; + for (const variation of ['extra', 'order'] as const) + test(`${label} same signed event with ${variation} wire variation follows ordinary envelope admission`, async ({ + page + }) => { + const result = await page.evaluate( + async ({ recovered, variation }) => { + const f = window.qxFixture; + if (recovered && (await f.qualify(true)).status !== 'saved') + throw Error('actual REC source'); + const event = JSON.parse(await f.selfWire()) as Record< + string, + unknown + >; + const changed = + variation === 'extra' + ? { ...event, diagnostic: 'not source authority' } + : Object.fromEntries(Object.entries(event).reverse()); + const before = f.host.counts(); + const status = await f.retain(JSON.stringify(changed)); + return { + status, + before, + after: f.host.counts(), + received: (await f.receivedRows()).length + }; + }, + { recovered, variation } + ); + expect(result.status).toBe( + variation === 'extra' ? 'invalid' : 'retained' + ); + expect(result.received).toBe(variation === 'extra' ? 0 : 1); + expect(result.after).toEqual(result.before); + }); + test(`${label} observed missing journal then handwritten exact restoration cannot revive exclusion`, async ({ + page + }) => { + const result = await page.evaluate(async (recovered) => { + const f = window.qxFixture; + if (recovered && (await f.qualify(true)).status !== 'saved') + throw Error('actual REC source'); + const wire = await f.selfWire(), + row = await f.rowWire(); + await f.removeFixtureRow(); + const first = await f.retain(wire); + await f.replaceRow(row); + const second = await f.retain(wire); + return { first, second, received: (await f.receivedRows()).length }; + }, recovered); + expect(result).toEqual({ + first: 'retained', + second: 'duplicate', + received: 1 + }); + }); + for (const mode of ['changed', 'alias', 'abort', 'corrupt'] as const) + test(`${label} actual ${mode} native custody cannot exclude`, async ({ + page + }) => { + const result = await page.evaluate( + async ({ recovered, mode }) => { + const f = window.qxFixture; + if (recovered && (await f.qualify(true)).status !== 'saved') + throw Error('actual REC source'); + const wire = await f.selfWire(), + row = await f.rowWire(); + if (mode === 'changed') { + const parsed = JSON.parse(row) as { revision: number }; + parsed.revision++; + await f.replaceRow(JSON.stringify(parsed)); + } else if (mode === 'alias') + await f.replaceRow(row, crypto.randomUUID()); + else if (mode === 'corrupt') + await f.replaceRow('{malformed own journal'); + const fault = + mode === 'abort' ? f.nativeFault('initial_read_abort') : undefined; + try { + const status = await f.retain(wire); + return { + status, + received: (await f.receivedRows()).length, + corruptPreserved: + mode !== 'corrupt' || + (await f.host.stored()).find((row) => row.id === f.command()) + ?.wire === '{malformed own journal', + reads: fault?.counts().readonly + }; + } finally { + fault?.restore(); + } + }, + { recovered, mode } + ); + expect(result.status).toBe('retained'); + expect(result.received).toBe(1); + expect(result.corruptPreserved).toBe(true); + if (mode === 'abort') expect(result.reads).toBe(1); + }); + test(`${label} foreign native namespace is preserved and does not poison genuine exclusion`, async ({ + page + }) => { + const result = await page.evaluate(async (recovered) => { + const f = window.qxFixture; + if (recovered && (await f.qualify(true)).status !== 'saved') + throw Error('actual REC source'); + const owner = + 'c6047f9441ed7d6d3045406e95c07cd85c778e4b8cef3ca7abac09b95c709ee5'; + const id = crypto.randomUUID(), + wire = await f.rowWire(); + await f.replaceRow(wire, id, owner); + const before = (await f.host.stored()).find((row) => row.id === id)!; + const status = await f.retain(); + const after = (await f.host.stored()).find((row) => row.id === id)!; + return { + status, + preserved: JSON.stringify(before) === JSON.stringify(after) + }; + }, recovered); + expect(result).toEqual({ status: 'probe_excluded', preserved: true }); + }); + for (const lane of ['finite', 'history', 'live'] as const) + test(`${label} genuine qualified ${lane} receive charges exact probe deliveries without retention or prompts`, async ({ + page + }) => { + await qualify(page, recovered); + const wire = await page.evaluate(() => window.qxFixture.selfWire()); + receiveFrames = [JSON.parse(wire) as (typeof receiveFrames)[number]]; + receiveLane = lane === 'live' ? 'live' : 'history'; + const before = await page.evaluate(() => window.qxFixture.host.counts()); + expect( + await page.evaluate( + async (lane) => + window.qxFixture.startReceive( + lane === 'finite' ? 'finite' : 'sync' + ), + lane + ) + ).toBe(true); + await expect + .poll(() => + page.evaluate( + () => window.qxFixture.receiveSnapshot()?.excludedProbes + ) + ) + .toBe(lane === 'history' ? 6 : 3); + if (lane !== 'finite') await liveReady(page); + const result = await page.evaluate(async () => ({ + snapshot: window.qxFixture.receiveSnapshot(), + received: (await window.qxFixture.receivedRows()).length, + after: window.qxFixture.host.counts() + })); + expect(result.snapshot).toMatchObject({ + candidates: lane === 'history' ? 6 : 3, + excludedProbes: lane === 'history' ? 6 : 3, + retained: 0, + duplicates: 0, + rejected: 0, + pending: 0 + }); + expect(result.snapshot!.bytes).toBe( + (lane === 'history' ? 6 : 3) * Buffer.byteLength(wire) + ); + expect(result.received).toBe(0); + const settled = await page.evaluate(() => window.qxFixture.host.counts()); + // Existing live admission plus its two bounded history windows each + // recheck the extension owner; no decryption or signing is added. + expect(result.after).toEqual({ + ...before, + keys: before.keys + (lane === 'finite' ? 1 : 3) + }); + expect(settled).toEqual(result.after); + }); + for (const mixed of [false, true]) + test(`${label} real load-older ${mixed ? 'mixed' : 'probe-only'} page preserves signed cursor progress and actual costs`, async ({ + page + }) => { + await qualify(page, recovered); + expect( + await page.evaluate(() => window.qxFixture.startReceive('sync')) + ).toBe(true); + await liveReady(page); + const wire = await page.evaluate(() => window.qxFixture.selfWire()), + probe = JSON.parse(wire) as (typeof receiveFrames)[number]; + let ordinary: (typeof receiveFrames)[number] | undefined; + if (mixed) { + const normal = await page.evaluate( + ({ recovered, time }) => + window.qxFixture.ordinaryWire(recovered, time), + { recovered, time: probe.created_at - 1 } + ); + ordinary = JSON.parse(normal) as (typeof receiveFrames)[number]; + } + receiveFrames = ordinary ? [probe, ordinary, probe] : [probe, probe]; + receiveLane = 'history'; + const before = await page.evaluate(() => window.qxFixture.host.counts()); + expect(await page.evaluate(() => window.qxFixture.older())).toBe(true); + const state = await page.evaluate(async () => ({ + older: window.qxFixture.olderSnapshot(), + received: (await window.qxFixture.receivedRows()).length, + after: window.qxFixture.host.counts() + })); + expect(state.older!.historyComplete).toBe(false); + expect(state.older!.reason).toBeNull(); + for (const cursor of state.older!.sources) { + expect(cursor.until).toBe(ordinary?.created_at ?? probe.created_at); + expect(cursor.seen).toContain(probe.id); + if (ordinary) expect(cursor.seen).toContain(ordinary.id); + // Existing cursor policy preserves duplicate delivery costs: unique + // signed facts are fewer than actual deliveries, so coverage is partial. + expect(cursor.partial).toBe(true); + } + expect(state.received).toBe(mixed ? 1 : 0); + expect(state.after).toEqual({ ...before, keys: before.keys + 3 }); + receiveFrames = []; + expect(await page.evaluate(() => window.qxFixture.older())).toBe(true); + const next = await page.evaluate(() => window.qxFixture.olderSnapshot()); + for (const cursor of next!.sources) { + expect(cursor.until).toBe(ordinary?.created_at ?? probe.created_at); + expect(cursor.seen).toContain(probe.id); + } + expect( + requests.filter( + (row) => + row.filter.kinds?.includes(1059) && + !row.filter.ids && + row.filter.limit !== 0 + ).length + ).toBe(12); + }); + test(`${label} successful reviewed removal returns self ciphertext to normal explicit decrypt cost and self-pair rejection`, async ({ + page + }) => { + await qualify(page, recovered); + const result = await page.evaluate(async () => { + const f = window.qxFixture, + wire = await f.selfWire(); + if (!(await f.select()) || (await f.remove()).status !== 'removed') + throw Error('actual successful reviewed cleanup'); + if (f.qualifyRemoved().status !== 'qualified') + throw Error('actual removed source qualification'); + const before = f.host.counts(), + status = await f.retain(wire), + retained = (await f.receivedRows()).length; + const afterRetain = f.host.counts(), + decrypted = await f.decryptStored(); + return { status, retained, before, afterRetain, decrypted }; + }); + expect(result.status).toBe('retained'); + expect(result.retained).toBe(1); + expect(result.afterRetain).toEqual(result.before); + expect(result.decrypted.snapshot).toMatchObject({ + attempted: 1, + invalid: 1, + admitted: 0 + }); + expect(result.decrypted.rooms).toBe(0); + expect( + result.decrypted.after.decrypts - result.decrypted.before.decrypts + ).toBe(2); + }); + test(`${label} genuine two-party message with identical diagnostic body remains a normal conversation`, async ({ + page + }) => { + const result = await page.evaluate(async (recovered) => { + const f = window.qxFixture; + if (recovered && (await f.qualify(true)).status !== 'saved') + throw Error('actual REC source'); + const wire = f.ordinaryWire(recovered), + status = await f.retain(wire), + decrypted = await f.decryptStored(); + return { status, decrypted }; + }, recovered); + expect(result.status).toBe('retained'); + expect(result.decrypted.snapshot).toMatchObject({ + attempted: 1, + invalid: 0, + admitted: 1 + }); + expect(result.decrypted.rooms).toBe(1); + expect( + result.decrypted.after.decrypts - result.decrypted.before.decrypts + ).toBe(2); + }); + test(`${label} genuine native-observed delivery proof is one-use and cannot survive final source loss`, async ({ + page + }) => { + if (recovered) + expect( + await page.evaluate( + async () => (await window.qxFixture.qualify(true)).status + ) + ).toBe('saved'); + const result = await page.evaluate(async () => { + const f = window.qxFixture, + a = f.actors(), + wire = await f.selfWire(), + event = JSON.parse(wire) as { id: string }; + return await navigator.locks.request( + 'harvestcircle:owner:' + f.host.owner, + { mode: 'exclusive', ifAvailable: true }, + async (lock) => { + if (!lock) throw Error('actual owner WebLock'); + const first = await window.qx.observeInboxProbeDelivery( + f.repository, + a.session, + event.id, + wire + ); + if (typeof first === 'string') + throw Error('actual native-observed source proof'); + const copy = window.qx.consumeInboxProbeDelivery( + { ...first }, + f.repository, + a.session, + event.id, + wire + ); + const current = window.qx.consumeInboxProbeDelivery( + first, + f.repository, + a.session, + event.id, + wire + ); + const repeat = window.qx.consumeInboxProbeDelivery( + first, + f.repository, + a.session, + event.id, + wire + ); + const later = await window.qx.observeInboxProbeDelivery( + f.repository, + a.session, + event.id, + wire + ); + if (typeof later === 'string') + throw Error('actual second native source proof'); + f.stop(); + const lost = window.qx.consumeInboxProbeDelivery( + later, + f.repository, + a.session, + event.id, + wire + ); + return { copy, current, repeat, lost }; + } + ); + }); + expect(result).toEqual({ + copy: false, + current: true, + repeat: false, + lost: false + }); + }); +} diff --git a/web/tests/provenance/output.test.mjs b/web/tests/provenance/output.test.mjs @@ -614,6 +614,10 @@ import { auditOutput } from '../../tools/check-output.mjs'; for (const producer of [ 'src/lib/persistence/private-storage.ts', 'src/lib/persistence/inbox-probes.ts', + 'src/lib/persistence/inbox-envelope-repository.ts', + 'src/lib/nostr/inbox-ingress.ts', + 'src/lib/messaging/inbox-sync.ts', + 'src/lib/messaging/history-pagination.ts', 'src/lib/persistence/inbox-probe-cleanup.ts', 'src/lib/messaging/inbox-access-qualification.ts', 'src/lib/persistence/private-records.ts' @@ -634,7 +638,11 @@ import { auditOutput } from '../../tools/check-output.mjs'; await refresh(f); await assert.rejects( f.audit, - /Invalid owned probe storage source|ENOENT/ + // This shared producer is already guarded by exact inbox + // presentation identity before probe-storage admission. + producer === 'src/lib/messaging/inbox-sync.ts' + ? /Invalid owned (?:probe storage|inbox presentation) source|ENOENT/ + : /Invalid owned probe storage source|ENOENT/ ); } finally { await writeFile(file, original); diff --git a/web/tests/unit/inbox-probe-exclusion.test.ts b/web/tests/unit/inbox-probe-exclusion.test.ts @@ -0,0 +1,121 @@ +import { afterEach, expect, it, vi } from 'vitest'; +import { + generateSecretKey, + getPublicKey, + finalizeEvent +} from 'applesauce-core/helpers'; +import { nip44 } from 'applesauce-core/helpers/encryption'; +afterEach(() => vi.unstubAllGlobals()); +for (const browser of [false, true]) { + it(`cold ${browser ? 'browser-shaped' : 'SSR'} envelope/probe forgeries cannot acquire exclusion or native effects`, async () => { + vi.resetModules(); + let effects = 0; + const trap = () => { + effects++; + throw Error('unadmitted effect'); + }; + if (browser) { + vi.stubGlobal('window', { + get nostr() { + return trap(); + } + }); + vi.stubGlobal('navigator', { + get locks() { + return trap(); + } + }); + vi.stubGlobal('indexedDB', { open: trap }); + vi.stubGlobal('WebSocket', trap); + } + const envelopes = + await import('../../src/lib/persistence/inbox-envelope-repository.ts'); + const probes = await import('../../src/lib/persistence/inbox-probes.ts'); + type Args = Parameters<typeof envelopes.retainInboxEnvelope>; + const repository = {} as Args[0], + session = {} as Args[1]; + for (const value of [ + undefined, + null, + false, + 0, + '', + Symbol(), + {}, + { + family: 'private_access_probe', + status: 'probe_excluded', + id: 'a'.repeat(64), + current: () => true + } + ]) { + const envelope = value as Args[2]; + expect(envelopes.inboxEnvelopeOuterMetadata(envelope)).toBeUndefined(); + expect( + (await envelopes.retainInboxEnvelope(repository, session, envelope)) + .status + ).toBe('invalid'); + expect( + await probes.observeInboxProbeDelivery( + repository, + session, + 'a'.repeat(64), + '{}' + ) + ).toBe('ordinary'); + expect( + probes.consumeInboxProbeDelivery( + value as Parameters<typeof probes.consumeInboxProbeDelivery>[0], + repository, + session, + 'a'.repeat(64), + '{}' + ) + ).toBe(false); + } + expect(effects).toBe(0); + }); +} +it('only the genuine admitted envelope owns detached signed outer cursor metadata', async () => { + const envelopes = + await import('../../src/lib/persistence/inbox-envelope-repository.ts'); + const secret = generateSecretKey(), + ownerSecret = generateSecretKey(); + try { + const owner = getPublicKey(ownerSecret), + key = nip44.v2.utils.getConversationKey(secret, owner); + try { + const event = finalizeEvent( + { + kind: 1059, + created_at: 1700000000, + tags: [['p', owner]], + content: nip44.v2.encrypt('ciphertext fixture only', key) + }, + secret + ); + const token = envelopes.admitInboxEnvelope( + JSON.stringify(event), + owner, + 'wss://inbox.example.org', + 100 + ); + expect(token).toBeDefined(); + const metadata = envelopes.inboxEnvelopeOuterMetadata(token!)! as { + id: string; + createdAt: number; + }; + expect(metadata).toEqual({ id: event.id, createdAt: event.created_at }); + metadata.id = '0'.repeat(64); + expect(envelopes.inboxEnvelopeOuterMetadata(token!)?.id).toBe(event.id); + expect( + envelopes.inboxEnvelopeOuterMetadata({ ...token! }) + ).toBeUndefined(); + } finally { + key.fill(0); + } + } finally { + secret.fill(0); + ownerSecret.fill(0); + } +}); diff --git a/web/tools/check-output.mjs b/web/tools/check-output.mjs @@ -323,9 +323,9 @@ async function operationalFlagsAdmission(web) { 'src/lib/nostr/private-pool.ts': '2ed123596f26bedb8aab5ec7694be6e264616429e00f745f1614c83f52de9825', 'src/lib/nostr/inbox-ingress.ts': - 'f860a094a8ba767585124c795d44b7620064f73a5b3a0170041c581c0fc64ecb', + 'dab2e6be2e10c1194008957a7015d22907f08201f95c5f4824ace4b98c1b89c2', 'src/lib/persistence/inbox-probes.ts': - '7d16f44c6fb8ec1168e6c93b669ca3eb404529e8b1783e29694a182db7649cc7', + '2e623973b9885ef20a85ee10229c634251719931afc20e05b118b5e9748a2ba3', 'src/lib/persistence/inbox-probe-cleanup.ts': 'bfc24be3530471cccd01d387ed2b38a6534eb6493ce850ba9711cc3cfa77e6d9', 'src/lib/messaging/inbox-access-qualification.ts': @@ -343,7 +343,7 @@ async function operationalFlagsAdmission(web) { 'src/lib/messaging/inbox-setup.ts': '7a935d8542ff8f64287d2b441a8a458d299dea4ed88beecda39cb1637dd4a9ac', 'src/lib/messaging/inbox-sync.ts': - '0d91f5895e7eb054b036a5cb80897a3d60a212d470029a82d11124c8536b3d2c', + '1a161fc95756ce2ae8fe7fceb5906d502f84cb1ae32834bb16791c408e1a775a', 'src/lib/messaging/inbox-view.ts': '6871707ae7395d3679856a01e87c7d8f273848e0b9ef0dc7b94f450d8417528c', 'src/lib/messaging/product-request-controller.ts': @@ -391,11 +391,11 @@ async function operationalFlagsAdmission(web) { 'src/lib/persistence/local-data-review.ts': '90379b183d0a1d8885076fbfc593d7c9ac1e351b16ce7800890107014e5cb0e4', 'src/lib/persistence/inbox-envelope-repository.ts': - 'd3613a098c93c8881d53de12f91ffb689827926217cabcba66894885d49cb095', + 'beb7eeef35be8b81ff03c9080e780528e37f1cd5c0be4f7b32575b1e60994bd3', 'src/lib/persistence/history-metadata-repository.ts': 'afe4656e59bd6b365444fbda64fe6572ffa4c5323c474ee862e3cf19252b6f6d', 'src/lib/messaging/history-pagination.ts': - '79b22b312a126b55c80a3c6ca22724bd2c5f3ad766f8600f3647028a2624c255', + '25218db4f7048311156b730634874108c1f224ca1dc80aa7041743fbaf6c3919', 'src/lib/persistence/private-outbox-cleanup.ts': '13f4e7d771b3a8d4ec7703f2026a1c8ff71582a2d2a810b9d402d58684b2e2b6', 'src/lib/persistence/local-inventory.ts': @@ -605,9 +605,9 @@ async function privacyDataAdmission(web) { 'src/lib/nostr/private-pool.ts': '2ed123596f26bedb8aab5ec7694be6e264616429e00f745f1614c83f52de9825', 'src/lib/nostr/inbox-ingress.ts': - 'f860a094a8ba767585124c795d44b7620064f73a5b3a0170041c581c0fc64ecb', + 'dab2e6be2e10c1194008957a7015d22907f08201f95c5f4824ace4b98c1b89c2', 'src/lib/persistence/inbox-probes.ts': - '7d16f44c6fb8ec1168e6c93b669ca3eb404529e8b1783e29694a182db7649cc7', + '2e623973b9885ef20a85ee10229c634251719931afc20e05b118b5e9748a2ba3', 'src/lib/persistence/inbox-probe-cleanup.ts': 'bfc24be3530471cccd01d387ed2b38a6534eb6493ce850ba9711cc3cfa77e6d9', 'src/lib/messaging/inbox-access-qualification.ts': @@ -623,7 +623,7 @@ async function privacyDataAdmission(web) { 'src/lib/messaging/inbox-setup-view.ts': '4ec9025232bb1355fef1ba039b46ce0a2be10e02e348e1b4eaadc3d1f3c2fd84', 'src/lib/messaging/inbox-sync.ts': - '0d91f5895e7eb054b036a5cb80897a3d60a212d470029a82d11124c8536b3d2c', + '1a161fc95756ce2ae8fe7fceb5906d502f84cb1ae32834bb16791c408e1a775a', 'src/lib/messaging/inbox-view.ts': '6871707ae7395d3679856a01e87c7d8f273848e0b9ef0dc7b94f450d8417528c', 'src/lib/messaging/reply-controller.ts': @@ -667,11 +667,11 @@ async function privacyDataAdmission(web) { 'src/lib/persistence/local-data-review.ts': '90379b183d0a1d8885076fbfc593d7c9ac1e351b16ce7800890107014e5cb0e4', 'src/lib/persistence/inbox-envelope-repository.ts': - 'd3613a098c93c8881d53de12f91ffb689827926217cabcba66894885d49cb095', + 'beb7eeef35be8b81ff03c9080e780528e37f1cd5c0be4f7b32575b1e60994bd3', 'src/lib/persistence/history-metadata-repository.ts': 'afe4656e59bd6b365444fbda64fe6572ffa4c5323c474ee862e3cf19252b6f6d', 'src/lib/messaging/history-pagination.ts': - '79b22b312a126b55c80a3c6ca22724bd2c5f3ad766f8600f3647028a2624c255', + '25218db4f7048311156b730634874108c1f224ca1dc80aa7041743fbaf6c3919', 'src/lib/persistence/private-outbox-cleanup.ts': '13f4e7d771b3a8d4ec7703f2026a1c8ff71582a2d2a810b9d402d58684b2e2b6', 'src/lib/persistence/local-inventory.ts': @@ -2174,12 +2174,20 @@ async function inboxSetupAdmission(web) { /** @param {string} web */ async function inboxProbeStorageAdmission(web) { const producers = { + 'src/lib/persistence/inbox-envelope-repository.ts': + 'beb7eeef35be8b81ff03c9080e780528e37f1cd5c0be4f7b32575b1e60994bd3', + 'src/lib/nostr/inbox-ingress.ts': + 'dab2e6be2e10c1194008957a7015d22907f08201f95c5f4824ace4b98c1b89c2', + 'src/lib/messaging/inbox-sync.ts': + '1a161fc95756ce2ae8fe7fceb5906d502f84cb1ae32834bb16791c408e1a775a', + 'src/lib/messaging/history-pagination.ts': + '25218db4f7048311156b730634874108c1f224ca1dc80aa7041743fbaf6c3919', 'src/lib/persistence/private-records.ts': '821ef96740cf644bff4ffe5c7816c6aa097aa419bd16b8b301809b963294dafe', 'src/lib/persistence/private-storage.ts': '9cdac5a1f00678d83bdf4a9b7bfb7c8bd04dc234afb140fc19e0156ad4a064a3', 'src/lib/persistence/inbox-probes.ts': - '7d16f44c6fb8ec1168e6c93b669ca3eb404529e8b1783e29694a182db7649cc7', + '2e623973b9885ef20a85ee10229c634251719931afc20e05b118b5e9748a2ba3', 'src/lib/persistence/inbox-probe-cleanup.ts': 'bfc24be3530471cccd01d387ed2b38a6534eb6493ce850ba9711cc3cfa77e6d9', 'src/lib/messaging/inbox-access-qualification.ts': @@ -2206,7 +2214,7 @@ async function inboxPresentationAdmission(web) { 'src/lib/messaging/inbox-view.ts': 'f725d1e122550232efa52b26139d3047d3bbfd6d3d11b1ef0a110b5e4b4410dc', 'src/lib/messaging/inbox-sync.ts': - '0d91f5895e7eb054b036a5cb80897a3d60a212d470029a82d11124c8536b3d2c', + '1a161fc95756ce2ae8fe7fceb5906d502f84cb1ae32834bb16791c408e1a775a', 'src/lib/messaging/inbox-setup-view.ts': '4ec9025232bb1355fef1ba039b46ce0a2be10e02e348e1b4eaadc3d1f3c2fd84', 'src/lib/messaging/decryption-queue.ts':