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:
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':