commit 2803f5e293b86e862b982fae573351124097a6a9
parent 4aa071680a994c2e6c66d6d9fa120ef5cc9e90bd
Author: triesap <tyson@radroots.org>
Date: Wed, 14 Oct 2026 02:27:12 +0000
harvestcircle: reuse exact private validation and fence stopped retention
- Cache bounded genuine whole-wire proofs while checking every current owner row and quota.
- Merge received ciphertext in one completed native transaction with exact readback.
- Preserve verified history metadata and fence in-flight and stale Stop ownership.
- Verify actual capacity corruption controls, 35 unit, 94 browser and 28 output tests.
Diffstat:
12 files changed, 1153 insertions(+), 127 deletions(-)
diff --git a/web/src/lib/messaging/history-pagination.ts b/web/src/lib/messaging/history-pagination.ts
@@ -16,6 +16,7 @@ import {
} from '../nostr/private-pool.ts';
import {
admitInboxEnvelope,
+ inboxEnvelopeSnapshot,
retainInboxEnvelope
} from '../persistence/inbox-envelope-repository.ts';
import {
@@ -48,6 +49,7 @@ export function captureOlderInbox(
if (!ownership?.current()) return undefined;
const original: InboxHistoryOwnership = ownership;
const token = Object.freeze({}) as OlderInbox;
+ const cancellation = new AbortController();
let stopped = false,
busy = false,
cleanupRequired = false,
@@ -59,6 +61,7 @@ export function captureOlderInbox(
const current = () => !stopped && original.current();
function stop() {
stopped = true;
+ cancellation.abort();
state = 'stopped';
let failure = false;
try {
@@ -73,7 +76,7 @@ export function captureOlderInbox(
}
cursors = [];
cleanupRequired = failure;
- if (!failure) syncs.delete(sync);
+ if (!failure && syncs.get(sync) === token) syncs.delete(sync);
if (failure) throw Error('private_history_cleanup_required');
}
async function page(
@@ -85,8 +88,8 @@ export function captureOlderInbox(
let queue = Promise.resolve(),
finished = false,
failure: string | undefined;
- let ids = Array.from<string>([]),
- acceptedDeliveries = 0;
+ const ids = new Map<string, true>();
+ let acceptedDeliveries = 0;
function receive(message: PrivatePageMessage) {
if (finished) return;
if (message.type === 'end') {
@@ -99,8 +102,8 @@ export function captureOlderInbox(
acceptedDeliveries < (message.deliveries ?? acceptedDeliveries)
? 'unsupported'
: message.reason),
- deliveries: message.deliveries ?? ids.length,
- ids: ids.slice()
+ deliveries: message.deliveries ?? ids.size,
+ ids: Array.from(ids.keys())
})
);
return;
@@ -128,7 +131,8 @@ export function captureOlderInbox(
const retained = await retainInboxEnvelope(
original.repository,
original.session,
- admitted
+ admitted,
+ cancellation.signal
);
if (!current()) return;
if (
@@ -139,8 +143,12 @@ export function captureOlderInbox(
return;
}
acceptedDeliveries++;
- const parsed = JSON.parse(message.wire) as { id: string };
- if (!ids.includes(parsed.id)) ids = ids.concat(parsed.id);
+ const parsed = inboxEnvelopeSnapshot(admitted);
+ if (!parsed) {
+ failure = 'unsupported';
+ return;
+ }
+ ids.set(parsed.id, true);
})
.catch(() => {
failure = 'unknown_completion';
@@ -264,7 +272,7 @@ export function captureOlderInbox(
? 'partial'
: 'older_available';
}
- return true;
+ return current();
} catch {
if (!stopped) {
state = 'needs_action';
diff --git a/web/src/lib/persistence/history-metadata-repository.ts b/web/src/lib/persistence/history-metadata-repository.ts
@@ -4,16 +4,14 @@ import {
} from '../runtime/private-session.ts';
import {
listPrivateReceivedRecords,
+ privateStorageOwner,
type PrivateStorageRepository
} from './private-storage.ts';
import {
+ privateReceivedOuterMetadata,
privateRecordIdentity,
privateRecordSnapshot
} from './private-records.ts';
-import {
- verifyEnvelope,
- verifiedEnvelopeSnapshot
-} from '../nostr/verified-envelope.ts';
export type RetainedOuterMetadata = Readonly<{
source: string;
outerId: string;
@@ -28,10 +26,12 @@ export async function readRetainedOuterMetadata(
> {
const ownership = privateSessionOwnership(session);
if (!ownership?.current()) return { ok: false, reason: 'stopped' };
+ if (privateStorageOwner(repository) !== ownership.owner)
+ return { ok: false, reason: 'invalid_scope' };
const loaded = await listPrivateReceivedRecords(repository);
if (!ownership.current()) return { ok: false, reason: 'stopped' };
if (!loaded.ok) return loaded;
- let rows = Array.from<RetainedOuterMetadata>([]);
+ const rows = new Map<number, RetainedOuterMetadata>();
for (const token of loaded.value) {
const identity = privateRecordIdentity(token);
if (identity?.owner !== ownership.owner)
@@ -39,18 +39,21 @@ export async function readRetainedOuterMetadata(
const record = privateRecordSnapshot(token, ownership.owner, identity.id);
if (record?.family !== 'received_envelope')
return { ok: false, reason: 'corrupt_record' };
- const verified = verifyEnvelope(record.outer),
- event = verified.ok && verifiedEnvelopeSnapshot(verified.value);
- if (!event || event.kind !== 1059 || event.id !== record.id)
+ const event = privateReceivedOuterMetadata(
+ token,
+ ownership.owner,
+ identity.id
+ );
+ if (!event || event.id !== record.id)
return { ok: false, reason: 'corrupt_record' };
for (const source of record.sources)
- rows = rows.concat({
+ rows.set(rows.size, {
source,
outerId: event.id,
- outerTime: event.created_at
+ outerTime: event.createdAt
});
}
return ownership.current()
- ? { ok: true, rows }
+ ? { ok: true, rows: Array.from(rows.values()) }
: { ok: false, reason: 'stopped' };
}
diff --git a/web/src/lib/persistence/inbox-envelope-repository.ts b/web/src/lib/persistence/inbox-envelope-repository.ts
@@ -1,6 +1,6 @@
import { canonicalPublicKey } from '../contracts/public-key.ts';
import { canonicalRelayOrigin } from '../config/relays.ts';
-import { PRIVATE_TRANSPORT_BUDGETS, RELAY_BUDGETS } from '../config/budgets.ts';
+import { PRIVATE_TRANSPORT_BUDGETS } from '../config/budgets.ts';
import { boundedUtf8 } from '../contracts/food-availability-v1/text.ts';
import { safeUnsignedInteger } from '../nostr/envelope-bounds.ts';
import {
@@ -19,7 +19,7 @@ import {
} from './private-records.ts';
import {
loadPrivateRecord,
- commitPrivateRecord,
+ retainPrivateReceivedRecord,
type PrivateStorageRepository,
type PrivateStorageFailure
} from './private-storage.ts';
@@ -92,7 +92,8 @@ export type InboxRetentionResult = Readonly<{
export async function retainInboxEnvelope(
repository: PrivateStorageRepository,
session: PrivateSession,
- envelope: InboxEnvelope
+ envelope: InboxEnvelope,
+ cancellation?: AbortSignal
): Promise<InboxRetentionResult> {
const admitted = envelopes.get(envelope),
ownership = privateSessionOwnership(session);
@@ -104,70 +105,39 @@ export async function retainInboxEnvelope(
!navigator.locks?.request
)
return { status: 'invalid' };
+ if (cancellation?.aborted) return { status: 'stopped' };
try {
return await navigator.locks.request(
'harvestcircle:owner:' + admitted.owner,
{ mode: 'exclusive', ifAvailable: true },
async (lock) => {
if (!lock) return { status: 'busy' };
- if (!ownership.current()) return { status: 'stopped' };
- const loaded = await loadPrivateRecord(
+ if (!ownership.current() || cancellation?.aborted)
+ return { status: 'stopped' };
+ const committed = await retainPrivateReceivedRecord(
repository,
- 'received_envelopes',
- admitted.id
+ session,
+ admitted.record,
+ cancellation
);
- if (!ownership.current()) return { status: 'stopped' };
- let next = admitted.record,
- base: PrivateRecordHandle | null = null,
- duplicate = false;
- if (loaded.ok) {
- const row = privateRecordSnapshot(
- loaded.value,
- admitted.owner,
- admitted.id
- );
- if (!row || row.family !== 'received_envelope')
- return { status: 'conflict' };
- // Keep the first valid signed outer and first observation. Equal outer
- // IDs are deduplication, not trusted inner-message identity/display.
- duplicate = true;
- base = loaded.value;
- if (row.sources.includes(admitted.source))
- return { status: 'duplicate' };
- if (
- row.sources.length >= RELAY_BUDGETS.inbox ||
- row.revision === Number.MAX_SAFE_INTEGER
- )
- return { status: 'capacity' };
- const decoded = decodePrivateRecord(
- JSON.stringify({
- ...row,
- revision: row.revision + 1,
- sources: [...row.sources, admitted.source]
- }),
- admitted.owner,
- admitted.id
- );
- if (!decoded.ok) return { status: 'invalid' };
- next = decoded.value;
- } else if (loaded.reason !== 'invalid_record')
- return { status: loaded.reason };
- if (!ownership.current()) return { status: 'stopped' };
- const committed = await commitPrivateRecord(repository, next, base);
+ if (!ownership.current() || cancellation?.aborted)
+ return { status: 'stopped' };
if (!committed.ok) return { status: committed.reason };
+ if (!committed.value.changed) return { status: committed.value.status };
const readback = await loadPrivateRecord(
repository,
'received_envelopes',
admitted.id
);
- if (!ownership.current()) return { status: 'stopped' };
+ if (!ownership.current() || cancellation?.aborted)
+ return { status: 'stopped' };
if (!readback.ok) return { status: 'unknown_completion' };
if (
privateRecordWire(readback.value, admitted.owner, admitted.id) !==
- privateRecordWire(next, admitted.owner, admitted.id)
+ privateRecordWire(committed.value.record, admitted.owner, admitted.id)
)
return { status: 'conflict' };
- return { status: duplicate ? 'duplicate' : 'retained' };
+ return { status: committed.value.status };
}
);
} catch {
diff --git a/web/src/lib/persistence/private-records.ts b/web/src/lib/persistence/private-records.ts
@@ -83,7 +83,12 @@ declare const recordBrand: unique symbol;
export type PrivateRecordHandle = Readonly<{ [recordBrand]: true }>;
const records = new WeakMap<
PrivateRecordHandle,
- Readonly<{ owner: string; id: string; wire: string }>
+ Readonly<{
+ owner: string;
+ id: string;
+ wire: string;
+ outerMetadata?: Readonly<{ id: string; createdAt: number }>;
+ }>
>();
export type PrivateRecordFailure =
| 'invalid_scope'
@@ -331,7 +336,7 @@ function outer(
raw: unknown,
destination: string,
received = false
-): string | undefined {
+): Readonly<{ id: string; createdAt: number }> | undefined {
if (
typeof raw !== 'string' ||
!boundedUtf8(raw, PRIVATE_TRANSPORT_BUDGETS.envelopeBytes)
@@ -376,7 +381,7 @@ function outer(
} catch {
return undefined;
}
- return event.id;
+ return { id: event.id, createdAt: event.created_at };
}
function artifact(
value: unknown,
@@ -385,7 +390,7 @@ function artifact(
return (
exactLocalFields(value, ['eventId', 'wire']) &&
hash(value.eventId) &&
- outer(value.wire, destination) === value.eventId
+ outer(value.wire, destination)?.id === value.eventId
);
}
function receipt(
@@ -465,6 +470,7 @@ export function decodePrivateRecord(
if (fields.owner !== owner) return failed('owner_mismatch');
if (fields.id !== id) return failed('id_mismatch');
let record: PrivateRecord;
+ let outerMetadata: Readonly<{ id: string; createdAt: number }> | undefined;
if (fields.family === 'private_send_reservation') {
const reservation = inspectPrivateSendReservation(raw, owner, id);
if (!reservation) return failed('malformed');
@@ -532,6 +538,7 @@ export function decodePrivateRecord(
: { receipts: fields.receipts as PrivateTargetReceipt[] })
};
} else if (fields.family === 'received_envelope') {
+ outerMetadata = outer(fields.outer, owner, true);
if (
!hash(id) ||
!exactLocalFields(fields, [
@@ -546,7 +553,7 @@ export function decodePrivateRecord(
'read'
]) ||
!unsigned(fields.revision) ||
- outer(fields.outer, owner, true) !== id ||
+ outerMetadata?.id !== id ||
!unsigned(fields.observedAtMilliseconds) ||
!Array.isArray(fields.sources) ||
fields.sources.length === 0 ||
@@ -582,7 +589,12 @@ export function decodePrivateRecord(
};
} else return failed('malformed');
const token = Object.freeze({}) as PrivateRecordHandle;
- records.set(token, { owner, id, wire: JSON.stringify(record) });
+ records.set(token, {
+ owner,
+ id,
+ wire: JSON.stringify(record),
+ ...(outerMetadata ? { outerMetadata } : {})
+ });
return { ok: true, value: token };
} catch {
return failed('malformed');
@@ -606,6 +618,21 @@ export function privateRecordSnapshot(
const wire = privateRecordWire(token, owner, id);
return wire === undefined ? undefined : (JSON.parse(wire) as PrivateRecord);
}
+// Strict original codec transport metadata only. A detached record or wrong
+// owner/ID cannot borrow a verified outer; this is never inner/room permission.
+export function privateReceivedOuterMetadata(
+ token: PrivateRecordHandle,
+ owner: unknown,
+ id: unknown
+): Readonly<{ id: string; createdAt: number }> | undefined {
+ const saved = records.get(token);
+ return saved &&
+ saved.owner === owner &&
+ saved.id === id &&
+ saved.outerMetadata
+ ? { ...saved.outerMetadata }
+ : undefined;
+}
// Handle identity contains no private body; callers must still match namespace.
export function privateRecordIdentity(
token: PrivateRecordHandle
diff --git a/web/src/lib/persistence/private-storage.ts b/web/src/lib/persistence/private-storage.ts
@@ -5,7 +5,7 @@ import {
} from '../runtime/private-session.ts';
import { canonicalPublicKey } from '../contracts/public-key.ts';
import { exactLocalFields } from '../contracts/local-records.ts';
-import { LOCAL_PERSISTENCE_BUDGETS } from '../config/budgets.ts';
+import { LOCAL_PERSISTENCE_BUDGETS, RELAY_BUDGETS } from '../config/budgets.ts';
import { privateRecordSettlement } from './local-inventory.ts';
import {
browserDatabaseState,
@@ -39,19 +39,80 @@ type Scope = Readonly<{ database: BrowserDatabase; owner: string }>;
type Row = Readonly<{
store: Store;
record: PrivateRecord;
+ handle: PrivateRecordHandle;
wire: string;
bytes: number;
}>;
const repositories = new WeakMap<PrivateStorageRepository, Scope>();
+type ValidatedWire = Readonly<{
+ wire: string;
+ handle: PrivateRecordHandle;
+ bytes: number;
+}>;
+type ValidationState = Readonly<{
+ entries: Map<string, ValidatedWire>;
+ bytes: number;
+}>;
+// Ephemeral ciphertext proofs belong to the genuine repository scope. Every
+// operation still visits every native owner row and checks all keys/headers and
+// quotas. Neither persisted summaries nor cached count/absence is trusted.
+const validations = new WeakMap<
+ Scope,
+ Readonly<Record<Store, ValidationState>>
+>();
+function remember(
+ scope: Scope,
+ store: Store,
+ id: string,
+ value: ValidatedWire
+): void {
+ const countCap =
+ store === 'private_sends'
+ ? LOCAL_PERSISTENCE_BUDGETS.unfinishedPrivateSends
+ : LOCAL_PERSISTENCE_BUDGETS.receivedEnvelopes,
+ byteCap =
+ store === 'private_sends'
+ ? LOCAL_PERSISTENCE_BUDGETS.privateSendBytes
+ : LOCAL_PERSISTENCE_BUDGETS.receivedCiphertextBytes;
+ if (value.bytes > byteCap) return;
+ const stores = validations.get(scope) ?? {
+ private_sends: { entries: new Map<string, ValidatedWire>(), bytes: 0 },
+ received_envelopes: {
+ entries: new Map<string, ValidatedWire>(),
+ bytes: 0
+ }
+ },
+ state = stores[store],
+ entries = state.entries;
+ let bytes = state.bytes;
+ const old = entries.get(id);
+ if (old) {
+ entries.delete(id);
+ bytes -= old.bytes;
+ }
+ while (entries.size >= countCap || bytes + value.bytes > byteCap) {
+ const first = entries.keys().next().value;
+ if (first === undefined) break;
+ bytes -= entries.get(first)!.bytes;
+ entries.delete(first);
+ }
+ entries.set(id, value);
+ validations.set(scope, {
+ ...stores,
+ [store]: { entries, bytes: bytes + value.bytes }
+ });
+}
+
const failed = (
reason: PrivateStorageFailure
): PrivateStorageResult<never> => ({ ok: false, reason });
function scopeOf(repository: PrivateStorageRepository): Scope | undefined {
const scope = repositories.get(repository);
try {
- return scope && browserDatabaseState(scope.database).state === 'ready'
- ? scope
- : undefined;
+ if (scope && browserDatabaseState(scope.database).state === 'ready')
+ return scope;
+ if (scope) validations.delete(scope);
+ return undefined;
} catch {
return undefined;
}
@@ -72,7 +133,13 @@ export function createPrivateStorageRepository(
return undefined;
}
}
+export function privateStorageOwner(
+ repository: PrivateStorageRepository
+): string | undefined {
+ return scopeOf(repository)?.owner;
+}
function stored(
+ scope: Scope,
value: unknown,
store: Store,
owner: string,
@@ -82,10 +149,15 @@ function stored(
!exactLocalFields(value, ['owner', 'id', 'wire']) ||
value.owner !== owner ||
value.id !== id ||
- typeof value.wire !== 'string'
+ typeof value.wire !== 'string' ||
+ typeof id !== 'string'
)
return undefined;
- const decoded = decodePrivateRecord(value.wire, owner, id);
+ const cached = validations.get(scope)?.[store].entries.get(id);
+ const decoded =
+ cached?.wire === value.wire
+ ? { ok: true as const, value: cached.handle }
+ : decodePrivateRecord(value.wire, owner, id);
if (!decoded.ok) return undefined;
const record = privateRecordSnapshot(decoded.value, owner, id);
if (
@@ -93,12 +165,19 @@ function stored(
(record.family === 'received_envelope') !== (store === 'received_envelopes')
)
return undefined;
- return {
- store,
- record,
- wire: value.wire,
- bytes: new TextEncoder().encode(JSON.stringify(value)).length
- };
+ // Equal original wire plus the three exact validated header fields fixes the
+ // encoded row length; property ordering does not change that length.
+ const bytes =
+ cached?.wire === value.wire
+ ? cached.bytes
+ : new TextEncoder().encode(JSON.stringify(value)).length;
+ if (cached?.wire !== value.wire)
+ remember(scope, store, id, {
+ wire: value.wire,
+ handle: decoded.value,
+ bytes
+ });
+ return { store, record, handle: decoded.value, wire: value.wire, bytes };
}
// Each store has an independent owner-scoped scan/quota. A corrupt received
// namespace cannot reset or consume the outbox, and no uncertain row is evicted.
@@ -130,7 +209,7 @@ function transaction<T>(
return new Promise((resolve) => {
let result: PrivateStorageResult<T> | undefined,
bytes = 0;
- let rows = Array.from<Row>([]);
+ const rows = new Map<number, Row>();
function refuse(reason: PrivateStorageFailure) {
if (result && !result.ok) return;
result = failed(reason);
@@ -171,22 +250,22 @@ function transaction<T>(
try {
const cursor = cursorRequest.result;
if (!cursor) {
- const outcome = finish(rows, tx, refuse);
+ const outcome = finish(Array.from(rows.values()), tx, refuse);
if (outcome) result = outcome;
return;
}
const key = cursor.primaryKey;
const row =
Array.isArray(key) && key.length === 2 && key[0] === scope.owner
- ? stored(cursor.value, store, scope.owner, key[1])
+ ? stored(scope, cursor.value, store, scope.owner, key[1])
: undefined;
if (!row) {
refuse('corrupt_record');
return;
}
- rows = rows.concat(row);
+ rows.set(rows.size, row);
bytes += row.bytes;
- if (rows.length > countCap || bytes > byteCap) {
+ if (rows.size > countCap || bytes > byteCap) {
refuse('capacity');
return;
}
@@ -331,6 +410,140 @@ export function commitPrivateRecord(
};
});
}
+// Combine received lookup/merge/write only. The caller holds the actual owner
+// lock. Complete namespace validation and native completion remain mandatory;
+// changed writes require the caller's later exact readonly verification.
+export function retainPrivateReceivedRecord(
+ repository: PrivateStorageRepository,
+ session: PrivateSession,
+ incoming: PrivateRecordHandle,
+ cancellation?: AbortSignal
+): Promise<
+ PrivateStorageResult<
+ Readonly<{
+ record: PrivateRecordHandle;
+ status: 'retained' | 'duplicate';
+ changed: boolean;
+ }>
+ >
+> {
+ const scope = scopeOf(repository),
+ ownership = privateSessionOwnership(session),
+ identity = privateRecordIdentity(incoming),
+ candidate =
+ scope &&
+ identity &&
+ privateRecordSnapshot(incoming, scope.owner, identity.id);
+ // Pre-admission cancellation is not evidence of a native rollback.
+ if (cancellation?.aborted) return Promise.resolve(failed('invalid_scope'));
+ if (!scope || !ownership?.current() || ownership.owner !== scope.owner)
+ return Promise.resolve(failed('invalid_scope'));
+ if (
+ !identity ||
+ candidate?.family !== 'received_envelope' ||
+ candidate.revision !== 0 ||
+ candidate.read !== null ||
+ candidate.sources.length !== 1
+ )
+ return Promise.resolve(failed('invalid_record'));
+ return transaction<
+ Readonly<{
+ record: PrivateRecordHandle;
+ status: 'retained' | 'duplicate';
+ changed: boolean;
+ }>
+ >(
+ scope,
+ 'received_envelopes',
+ 'readwrite',
+ (rows, tx, refuse) => {
+ if (cancellation?.aborted) {
+ refuse('aborted');
+ return;
+ }
+ if (!ownership.current()) {
+ refuse('invalid_scope');
+ return;
+ }
+ const previous = rows.find((row) => row.record.id === identity.id);
+ let record = incoming,
+ status: 'retained' | 'duplicate' = 'retained';
+ if (previous) {
+ if (previous.record.family !== 'received_envelope') {
+ refuse('conflict');
+ return;
+ }
+ status = 'duplicate';
+ if (previous.record.sources.includes(candidate.sources[0]))
+ return {
+ ok: true,
+ value: { record: previous.handle, status, changed: false }
+ };
+ if (
+ previous.record.sources.length >= RELAY_BUDGETS.inbox ||
+ previous.record.revision === Number.MAX_SAFE_INTEGER
+ ) {
+ refuse('capacity');
+ return;
+ }
+ const decoded = decodePrivateRecord(
+ JSON.stringify({
+ ...previous.record,
+ revision: previous.record.revision + 1,
+ sources: [...previous.record.sources, candidate.sources[0]]
+ }),
+ scope.owner,
+ identity.id
+ );
+ if (!decoded.ok) {
+ refuse('invalid_record');
+ return;
+ }
+ record = decoded.value;
+ }
+ const wire = privateRecordWire(record, scope.owner, identity.id);
+ if (!wire) {
+ refuse('invalid_record');
+ return;
+ }
+ const row = { owner: scope.owner, id: identity.id, wire },
+ bytes = new TextEncoder().encode(JSON.stringify(row)).length;
+ if (
+ (!previous &&
+ rows.length >= LOCAL_PERSISTENCE_BUDGETS.receivedEnvelopes) ||
+ rows.reduce((total, item) => total + item.bytes, bytes) -
+ (previous?.bytes ?? 0) >
+ LOCAL_PERSISTENCE_BUDGETS.receivedCiphertextBytes
+ ) {
+ refuse('capacity');
+ return;
+ }
+ if (cancellation?.aborted) {
+ refuse('aborted');
+ return;
+ }
+ if (!ownership.current()) {
+ refuse('invalid_scope');
+ return;
+ }
+ tx.objectStore('received_envelopes').put(row);
+ return { ok: true, value: { record, status, changed: true } };
+ },
+ (refuse) => {
+ const abort = () => refuse('aborted'),
+ off = subscribePrivateSessionClose(session, () =>
+ refuse('invalid_scope')
+ );
+ cancellation?.addEventListener('abort', abort, { once: true });
+ if (cancellation?.aborted) abort();
+ return () => {
+ off();
+ cancellation?.removeEventListener('abort', abort);
+ };
+ }
+ );
+}
+
export function loadPrivateRecord(
repository: PrivateStorageRepository,
store: Store,
@@ -343,11 +556,10 @@ export function loadPrivateRecord(
typeof id !== 'string'
)
return Promise.resolve(failed('invalid_record'));
- return transaction(scope, store, 'readonly', (rows) => {
+ return transaction<PrivateRecordHandle>(scope, store, 'readonly', (rows) => {
const row = rows.find((row) => row.record.id === id);
if (!row) return failed('invalid_record');
- const decoded = decodePrivateRecord(row.wire, scope.owner, id);
- return decoded.ok ? decoded : failed('corrupt_record');
+ return { ok: true, value: row.handle };
});
}
export function inspectPrivateStorage(
@@ -379,17 +591,7 @@ export function listPrivateReceivedRecords(
'received_envelopes',
'readonly',
(rows) => {
- let handles = Array.from<PrivateRecordHandle>([]);
- for (const row of rows) {
- const decoded = decodePrivateRecord(
- row.wire,
- scope.owner,
- row.record.id
- );
- if (!decoded.ok) return failed('corrupt_record');
- handles = handles.concat(decoded.value);
- }
- return { ok: true, value: handles };
+ return { ok: true, value: rows.map((row) => row.handle) };
}
);
}
@@ -405,17 +607,7 @@ export function listPrivateSendRecords(
'private_sends',
'readonly',
(rows) => {
- let handles = Array.from<PrivateRecordHandle>([]);
- for (const row of rows) {
- const decoded = decodePrivateRecord(
- row.wire,
- scope.owner,
- row.record.id
- );
- if (!decoded.ok) return failed('corrupt_record');
- handles = handles.concat(decoded.value);
- }
- return { ok: true, value: handles };
+ return { ok: true, value: rows.map((row) => row.handle) };
}
);
}
diff --git a/web/tests/e2e/harness/history-pagination.ts b/web/tests/e2e/harness/history-pagination.ts
@@ -18,6 +18,12 @@ import {
import { createInboxResolver } from '../../../src/lib/messaging/resolve-inbox.ts';
import { outerHistoryPlan } from '../../../src/lib/messaging/history-cursor.ts';
import { finalizeEvent } from 'applesauce-core/helpers';
+import {
+ browserDatabaseTransaction,
+ openBrowserDatabase,
+ closeBrowserDatabase
+} from '../../../src/lib/persistence/database.ts';
+import { decodePrivateRecord } from '../../../src/lib/persistence/private-records.ts';
import { nip44 } from 'applesauce-core/helpers/encryption';
import {
captureUnlockedSession,
@@ -45,7 +51,10 @@ import {
inboxSyncSnapshot,
type InboxSync
} from '../../../src/lib/messaging/inbox-sync.ts';
-import { loadPrivateRecord } from '../../../src/lib/persistence/private-storage.ts';
+import {
+ loadPrivateRecord,
+ inspectPrivateStorage
+} from '../../../src/lib/persistence/private-storage.ts';
import { privateRecordSnapshot } from '../../../src/lib/persistence/private-records.ts';
import {
getPublicStore,
@@ -136,6 +145,8 @@ export async function makeFixture(
const self = (await f.row())!.record.self;
let ingress: InboxSync | undefined;
let older: OlderInbox | undefined;
+ let capacityWires: string[] = [],
+ capacityWrites = 0;
let authorized = true;
let restoreFault = () => {};
let releaseKey: (() => void) | undefined;
@@ -216,6 +227,22 @@ export async function makeFixture(
loadOlder(review: unknown = 'reviewed_load_older') {
return older ? loadOlderInbox(older, review) : Promise.resolve(false);
},
+ oldStopAfterSuccessor() {
+ if (!older || !ingress) throw Error('original history controller absent');
+ const old = older;
+ stopOlderInbox(old);
+ const successor = captureOlderInbox(ingress, 'reviewed_load_older');
+ if (!successor) throw Error('genuine successor absent');
+ older = successor;
+ stopOlderInbox(old);
+ const third = captureOlderInbox(ingress, 'reviewed_load_older');
+ if (third) stopOlderInbox(third);
+ return {
+ successor: !!successor,
+ third: !!third,
+ current: olderInboxSnapshot(successor)
+ };
+ },
copiedOlderStart() {
return older
? loadOlderInbox(Object.freeze({ ...older }), 'reviewed_load_older')
@@ -225,6 +252,80 @@ export async function makeFixture(
stopOlder() {
if (older) stopOlderInbox(older);
},
+ // Source-only bulk strict ciphertext, not new inner-message/delivery proof.
+ async seedCapacity(source = 'wss://archive.example.org') {
+ const records = Array.from({ length: 2000 }, (_, index) => {
+ const outer =
+ index === 0
+ ? self.wire
+ : this.oldSignedOuter(Math.floor(Date.now() / 1000) - index),
+ event = JSON.parse(outer) as { id: string };
+ const wire = JSON.stringify({
+ schema: 1,
+ family: 'received_envelope',
+ owner: f.owner,
+ id: event.id,
+ revision: 0,
+ outer,
+ observedAtMilliseconds: Date.now(),
+ sources: [source],
+ read: null
+ });
+ if (!decodePrivateRecord(wire, f.owner, event.id).ok)
+ throw Error('strict capacity outer rejected');
+ return { owner: f.owner, id: event.id, wire };
+ });
+ capacityWires = records.map(
+ (row) => (JSON.parse(row.wire) as { outer: string }).outer
+ );
+ if (new Set(records.map((row) => row.id)).size !== 2000)
+ throw Error('capacity fixture IDs collide');
+ const opened = await openBrowserDatabase();
+ if (opened.state !== 'ready')
+ throw Error('owned capacity connection unavailable');
+ try {
+ const tx = browserDatabaseTransaction(
+ opened.owner,
+ ['received_envelopes'],
+ 'readwrite'
+ );
+ for (const row of records)
+ tx.objectStore('received_envelopes').put(row);
+ await new Promise<void>((resolve, reject) => {
+ tx.addEventListener('complete', () => resolve());
+ tx.addEventListener('abort', () =>
+ reject(Error('capacity seed aborted'))
+ );
+ });
+ } finally {
+ closeBrowserDatabase(opened.owner);
+ }
+ const checked = await inspectPrivateStorage(
+ f.repository,
+ 'received_envelopes'
+ );
+ if (!checked.ok || checked.value.count !== 2000)
+ throw Error('actual committed capacity absent');
+ return checked.value;
+ },
+ capacityOuterWires: () => capacityWires.slice(0, 500),
+ capacityWriteCount: () => capacityWrites,
+ observeCapacityWrites() {
+ const nativePut = Reflect.get<IDBObjectStore, 'put'>(
+ IDBObjectStore.prototype,
+ 'put'
+ ),
+ priorRestore = restoreFault;
+ IDBObjectStore.prototype.put = function (...args) {
+ const request = Reflect.apply(nativePut, this, args);
+ if (this.name === 'received_envelopes') capacityWrites++;
+ return request;
+ };
+ restoreFault = () => {
+ IDBObjectStore.prototype.put = nativePut;
+ priorRestore();
+ };
+ },
async seed(wire: string, origin = 'wss://archive.example.org') {
const envelope = admitInboxEnvelope(wire, f.owner, origin, Date.now());
if (!envelope) throw Error('invalid genuinefixture envelope');
diff --git a/web/tests/e2e/harness/private-validation-cache.ts b/web/tests/e2e/harness/private-validation-cache.ts
@@ -0,0 +1,322 @@
+// CR005_TEST_ONLY: real IDB/validator, no nested/extension/operator/fullQ proof.
+import { finalizeEvent, generateSecretKey } from 'applesauce-core/helpers';
+import { nip44 } from 'applesauce-core/helpers/encryption';
+import { makeFixture as makeSigner } from './approved-signing.ts';
+import {
+ openBrowserDatabase,
+ closeBrowserDatabase,
+ browserDatabaseTransaction
+} from '../../../src/lib/persistence/database.ts';
+import {
+ createPrivateStorageRepository,
+ loadPrivateRecord,
+ listPrivateSendRecords,
+ listPrivateReceivedRecords
+} from '../../../src/lib/persistence/private-storage.ts';
+import {
+ decodePrivateRecord,
+ privateRecordSnapshot
+} from '../../../src/lib/persistence/private-records.ts';
+import { readRetainedOuterMetadata } from '../../../src/lib/persistence/history-metadata-repository.ts';
+import {
+ createIdentitySession,
+ connectIdentity,
+ probeIdentityMessaging,
+ disconnectIdentity
+} from '../../../src/lib/runtime/identity-session.ts';
+import { createPrivateSession } from '../../../src/lib/runtime/private-session.ts';
+declare global {
+ var __cr005VerifyCalls: number | undefined;
+}
+type Store = 'private_sends' | 'received_envelopes';
+type Row = { owner: string; id: string; wire: string };
+export async function createFixture() {
+ const signer = makeSigner(),
+ peer = makeSigner(),
+ prior = Object.getOwnPropertyDescriptor(window, 'nostr'),
+ owner = signer.owner;
+ Object.defineProperty(window, 'nostr', {
+ configurable: true,
+ value: {
+ getPublicKey: () => Promise.resolve(owner),
+ signEvent: (t: Parameters<typeof signer.sign>[0]) =>
+ Promise.resolve(signer.sign(t)),
+ nip44: {
+ encrypt: (p: string, t: string) =>
+ Promise.resolve(signer.encrypt(p, t)),
+ decrypt: (p: string, t: string) => Promise.resolve(signer.decrypt(p, t))
+ }
+ }
+ });
+ const identity = createIdentitySession();
+ await connectIdentity(identity);
+ await probeIdentityMessaging(identity, 'reviewed_self_copy');
+ const session = await createPrivateSession(
+ identity,
+ 'reviewed_private_session'
+ ),
+ opened = await openBrowserDatabase();
+ if (!session || opened.state !== 'ready')
+ throw Error('genuine fixture session/database absent');
+ const database = opened.owner,
+ repository = createPrivateStorageRepository(database, owner),
+ foreign = createPrivateStorageRepository(database, peer.owner);
+ if (!repository || !foreign) throw Error('genuine repositories absent');
+ const repo = repository,
+ foreignRepo = foreign,
+ rows: Row[] = [],
+ sends: Row[] = [],
+ observed = Date.now();
+ for (let index = 0; index < 2000; index++) {
+ const secret = generateSecretKey(),
+ conversation = nip44.v2.utils.getConversationKey(secret, owner);
+ let outer;
+ try {
+ outer = finalizeEvent(
+ {
+ kind: 1059,
+ created_at: Math.floor(observed / 1000) - index,
+ tags: [['p', owner]],
+ content: nip44.v2.encrypt(
+ 'CR005_TEST_ONLY_opaque_transport_seal',
+ conversation
+ )
+ },
+ secret
+ );
+ } finally {
+ secret.fill(0);
+ conversation.fill(0);
+ }
+ const record = {
+ schema: 1,
+ family: 'received_envelope',
+ owner,
+ id: outer.id,
+ revision: 0,
+ outer: JSON.stringify(outer),
+ observedAtMilliseconds: observed,
+ sources: ['wss://archive.example.org'],
+ read: null
+ },
+ wire = JSON.stringify(record);
+ if (!decodePrivateRecord(wire, owner, record.id).ok)
+ throw Error('strict outer rejected');
+ rows.push({ owner, id: record.id, wire });
+ }
+ for (let index = 0; index < 100; index++) {
+ const id = crypto.randomUUID(),
+ wire = JSON.stringify({
+ schema: 1,
+ family: 'private_send_reservation',
+ owner,
+ id,
+ revision: 0,
+ peer: peer.owner,
+ rumorHash: 'a'.repeat(64),
+ createdAt: Math.floor(observed / 1000)
+ });
+ if (!decodePrivateRecord(wire, owner, id).ok)
+ throw Error('strict reservation rejected');
+ sends.push({ owner, id, wire });
+ }
+ rows.sort((a, b) => a.id.localeCompare(b.id));
+ const nativeCursor = Reflect.get<IDBIndex, 'openCursor'>(
+ IDBIndex.prototype,
+ 'openCursor'
+ );
+ let visits = 0;
+ IDBIndex.prototype.openCursor = function (...args) {
+ const request = Reflect.apply(nativeCursor, this, args);
+ request.addEventListener('success', () => {
+ if (request.result) visits++;
+ });
+ return request;
+ };
+ async function put(store: Store, records: readonly unknown[], other = false) {
+ const openedOther = other ? await openBrowserDatabase() : undefined;
+ if (openedOther && openedOther.state !== 'ready')
+ throw Error('second connection absent');
+ const db = openedOther?.state === 'ready' ? openedOther.owner : database;
+ try {
+ const tx = browserDatabaseTransaction(db, [store], 'readwrite');
+ for (const row of records) tx.objectStore(store).put(row);
+ await new Promise<void>((resolve, reject) => {
+ tx.addEventListener('complete', () => resolve());
+ tx.addEventListener('abort', () =>
+ reject(Error('actual fixture write aborted'))
+ );
+ });
+ } finally {
+ if (openedOther?.state === 'ready')
+ closeBrowserDatabase(openedOther.owner);
+ }
+ }
+ await put('received_envelopes', rows);
+ await put('private_sends', sends);
+ function reset() {
+ visits = 0;
+ globalThis.__cr005VerifyCalls = 0;
+ }
+ function measured(start: number) {
+ return {
+ cursorVisits: visits,
+ verificationCalls: globalThis.__cr005VerifyCalls ?? 0,
+ milliseconds: performance.now() - start
+ };
+ }
+ async function sample(store: Store = 'received_envelopes') {
+ reset();
+ const start = performance.now(),
+ row = store === 'private_sends' ? sends[0] : rows[0],
+ result = await loadPrivateRecord(repo, store, row.id);
+ return {
+ ...measured(start),
+ ok: result.ok,
+ reason: result.ok ? null : result.reason,
+ revision: result.ok
+ ? privateRecordSnapshot(result.value, owner, row.id)?.revision
+ : null
+ };
+ }
+ return {
+ owner,
+ sample,
+ async inventory() {
+ reset();
+ const start = performance.now(),
+ result = await listPrivateReceivedRecords(repo);
+ return {
+ ...measured(start),
+ ok: result.ok,
+ count: result.ok ? result.value.length : null
+ };
+ },
+ async metadata(other = false) {
+ reset();
+ const start = performance.now(),
+ result = await readRetainedOuterMetadata(
+ other ? foreignRepo : repo,
+ session
+ );
+ return {
+ ...measured(start),
+ ok: result.ok,
+ count: result.ok ? result.rows.length : null,
+ reason: result.ok ? null : result.reason
+ };
+ },
+ bytes: () => ({
+ received: rows.reduce(
+ (n, row) => n + new TextEncoder().encode(JSON.stringify(row)).length,
+ 0
+ ),
+ sends: sends.reduce(
+ (n, row) => n + new TextEncoder().encode(JSON.stringify(row)).length,
+ 0
+ )
+ }),
+ async changeTail(
+ kind: 'valid' | 'metadata' | 'corrupt' | 'summary' | 'id',
+ other = false
+ ) {
+ const original = rows.at(-1)!;
+ let next: unknown;
+ if (kind === 'summary')
+ next = { ...original, untrustedSummary: { count: 0, bytes: 0 } };
+ else {
+ const record = JSON.parse(original.wire) as Record<string, unknown>;
+ if (kind === 'valid' || kind === 'metadata') record.revision = 1;
+ if (kind === 'metadata') {
+ record.sources = [
+ 'wss://archive.example.org',
+ 'wss://peer.example.org'
+ ];
+ record.read = {
+ rumorHash: 'b'.repeat(64),
+ atMilliseconds: Date.now()
+ };
+ }
+ if (kind === 'corrupt') record.outer = 'corrupt signed tail';
+ if (kind === 'id') record.id = '0'.repeat(64);
+ next = { ...original, wire: JSON.stringify(record) };
+ }
+ await put('received_envelopes', [next], other);
+ },
+ restoreTail: () => put('received_envelopes', [rows.at(-1)!]),
+ async overfillReceived() {
+ const secret = generateSecretKey(),
+ conversation = nip44.v2.utils.getConversationKey(secret, owner);
+ let event;
+ try {
+ event = finalizeEvent(
+ {
+ kind: 1059,
+ created_at: Math.floor(Date.now() / 1000),
+ tags: [['p', owner]],
+ content: nip44.v2.encrypt(
+ 'CR005_TEST_ONLY_EXTRA_2001',
+ conversation
+ )
+ },
+ secret
+ );
+ } finally {
+ secret.fill(0);
+ conversation.fill(0);
+ }
+ const prior = JSON.parse(rows[0].wire) as Record<string, unknown>;
+ const record = {
+ ...prior,
+ id: event.id,
+ outer: JSON.stringify(event)
+ },
+ wire = JSON.stringify(record);
+ if (!decodePrivateRecord(wire, owner, event.id).ok)
+ throw Error('actual2001record invalid');
+ await put('received_envelopes', [{ owner, id: event.id, wire }], true);
+ const result = await listPrivateReceivedRecords(repo);
+ return { ok: result.ok, reason: result.ok ? null : result.reason };
+ },
+ async overfillSends() {
+ const extra = { ...sends[0], id: crypto.randomUUID() },
+ record = JSON.parse(extra.wire) as Record<string, unknown>;
+ record.id = extra.id;
+ extra.wire = JSON.stringify(record);
+ await put('private_sends', [extra], true);
+ const result = await listPrivateSendRecords(repo);
+ return { ok: result.ok, reason: result.ok ? null : result.reason };
+ },
+ async oversizeReceived() {
+ const padded = rows.map((row) => {
+ const record = JSON.parse(row.wire) as Record<string, unknown>;
+ record.outer = String(record.outer) + '\n'.repeat(9000);
+ return { ...row, wire: JSON.stringify(record) };
+ }),
+ bytes = padded.reduce(
+ (n, row) => n + new TextEncoder().encode(JSON.stringify(row)).length,
+ 0
+ );
+ await put('received_envelopes', padded, true);
+ const result = await listPrivateReceivedRecords(repo);
+ return { bytes, ok: result.ok, reason: result.ok ? null : result.reason };
+ },
+ async foreignRead() {
+ const result = await loadPrivateRecord(
+ foreignRepo,
+ 'received_envelopes',
+ rows[0].id
+ );
+ return { ok: result.ok, reason: result.ok ? null : result.reason };
+ },
+ close() {
+ IDBIndex.prototype.openCursor = nativeCursor;
+ disconnectIdentity(identity);
+ closeBrowserDatabase(database);
+ signer.close();
+ peer.close();
+ if (prior) Object.defineProperty(window, 'nostr', prior);
+ else delete window.nostr;
+ }
+ };
+}
diff --git a/web/tests/e2e/history-pagination.spec.ts b/web/tests/e2e/history-pagination.spec.ts
@@ -21,7 +21,8 @@ let requests: { origin: string; frame: unknown[] }[] = [],
let frames: Record<string, unknown>[][] = [[], []],
fault: number | undefined,
hold: number | undefined,
- ignoreLimit = false;
+ ignoreLimit = false,
+ ignoreWindow = false;
test.beforeAll(async () => {
server = await createStaticHarness();
for (let i = 0; i < 2; i++) {
@@ -63,8 +64,9 @@ test.beforeAll(async () => {
const rows = frames[i]
.filter(
(e) =>
- (f.since === undefined || Number(e.created_at) >= f.since) &&
- (f.until === undefined || Number(e.created_at) <= f.until)
+ ignoreWindow ||
+ ((f.since === undefined || Number(e.created_at) >= f.since) &&
+ (f.until === undefined || Number(e.created_at) <= f.until))
)
.sort(
(a, b) =>
@@ -112,6 +114,7 @@ test.beforeEach(async ({ page }) => {
fault = undefined;
hold = undefined;
ignoreLimit = false;
+ ignoreWindow = false;
await page.addInitScript(
({ origins, endpoints }) => {
const Native = window.WebSocket;
@@ -424,3 +427,112 @@ test('budget pause requires a new explicit review and starts a fresh bounded act
historyComplete: false
});
});
+
+test('CR005500 retained-capacity duplicate deliveries keep bounded budget facts', async ({
+ page
+}) => {
+ const capacity = await page.evaluate(() =>
+ window.hcp097Fixture.seedCapacity()
+ );
+ expect(capacity.count).toBe(2000);
+ expect(capacity.bytes).toBeLessThanOrEqual(50331648);
+ const wire = await page.evaluate(() => window.hcp097Fixture.outer);
+ frames[0] = Array.from({ length: 501 }, () => event(wire));
+ ignoreLimit = true;
+ ignoreWindow = true;
+ const started = performance.now();
+ await page.evaluate(async () => {
+ window.hcp097Fixture.captureOlder();
+ await window.hcp097Fixture.loadOlder();
+ });
+ const snapshot = await page.evaluate(() =>
+ window.hcp097Fixture.olderSnapshot()
+ );
+ expect(requests).toHaveLength(1);
+ expect(snapshot).toMatchObject({
+ state: 'needs_action',
+ reason: 'budget',
+ historyComplete: false
+ });
+ console.log(
+ JSON.stringify({
+ fixture: 'CR005_TEST_ONLY_500_DELIVERIES_AT_2000_CAPACITY',
+ capacity,
+ wireDeliveriesSent: 501,
+ logicalActionCap: 500,
+ milliseconds: performance.now() - started,
+ snapshot,
+ qualification:
+ 'Actual source controller/IDB; hostile controlled relay ignores window/limit to charge500 before dedup; no access/operator/fullQ'
+ })
+ );
+});
+test('CR005 stop during capacity-scale queued history fences remaining writes and owns teardown', async ({
+ page
+}) => {
+ await page.evaluate(() =>
+ window.hcp097Fixture.seedCapacity('wss://peer.example.org')
+ );
+ const wires = await page.evaluate(() =>
+ window.hcp097Fixture.capacityOuterWires()
+ );
+ expect(wires).toHaveLength(500);
+ frames[0] = wires.map((wire) => event(wire));
+ await page.evaluate(() => window.hcp097Fixture.observeCapacityWrites());
+ ignoreLimit = true;
+ hold = 0;
+ await page.evaluate(() => {
+ window.hcp097Fixture.captureOlder();
+ window.hcp097Pending = window.hcp097Fixture.loadOlder();
+ });
+ await expect.poll(() => requests.length).toBeGreaterThan(0);
+ await expect
+ .poll(() => page.evaluate(() => window.hcp097Fixture.capacityWriteCount()))
+ .toBeGreaterThan(0);
+ const result = await page.evaluate(async () => {
+ const started = performance.now(),
+ writesBeforeStop = window.hcp097Fixture.capacityWriteCount();
+ window.hcp097Fixture.stopOlder();
+ const immediate = window.hcp097Fixture.olderSnapshot();
+ const completed = await window.hcp097Pending;
+ return {
+ immediate,
+ completed,
+ writesBeforeStop,
+ writesAfterDrain: window.hcp097Fixture.capacityWriteCount(),
+ milliseconds: performance.now() - started
+ };
+ });
+ expect(result.immediate).toMatchObject({
+ state: 'stopped',
+ historyComplete: false
+ });
+ expect(result.completed).toBe(false);
+ expect(result.writesBeforeStop).toBeGreaterThan(0);
+ expect(result.writesBeforeStop).toBeLessThan(500);
+ expect(result.writesAfterDrain).toBe(result.writesBeforeStop);
+ await expect.poll(() => closes.length).toBeGreaterThan(0);
+ console.log(
+ JSON.stringify({
+ fixture: 'CR005_TEST_ONLY_CAPACITY_STOP',
+ deliveriesSent: 500,
+ ...result,
+ qualification:
+ 'Stop/owned controller teardown only, no rolled-back in-flight write or operator/fullQ claim'
+ })
+ );
+});
+
+test('CR005 retained old Stop cannot retire the genuine successor history registry owner', async ({
+ page
+}) => {
+ const result = await page.evaluate(() => {
+ window.hcp097Fixture.captureOlder();
+ return window.hcp097Fixture.oldStopAfterSuccessor();
+ });
+ expect(result).toMatchObject({
+ successor: true,
+ third: false,
+ current: { state: 'ready', historyComplete: false }
+ });
+});
diff --git a/web/tests/e2e/private-validation-cache.spec.ts b/web/tests/e2e/private-validation-cache.spec.ts
@@ -0,0 +1,211 @@
+import { expect, test } from '@playwright/test';
+import { build } from 'vite';
+import { fileURLToPath } from 'node:url';
+import { createHash } from 'node:crypto';
+import { createStaticHarness } from '../integration/harness/static.ts';
+import type * as Fixture from './harness/private-validation-cache.ts';
+declare global {
+ interface Window {
+ cr005: typeof Fixture;
+ cr005Fixture: Awaited<ReturnType<typeof Fixture.createFixture>>;
+ }
+}
+let server: Awaited<ReturnType<typeof createStaticHarness>>, bundle: string;
+const baseline = process.env.HCP_CR005_PHASE === 'baseline';
+test.beforeAll(async () => {
+ server = await createStaticHarness();
+ const entry = fileURLToPath(
+ new URL('./harness/private-validation-cache.ts', import.meta.url)
+ ),
+ result = await build({
+ configFile: false,
+ logLevel: 'silent',
+ plugins: [
+ {
+ name: 'cr005-count-real-validator',
+ enforce: 'pre',
+ transform(code, id) {
+ if (!id.endsWith('/src/lib/nostr/verified-envelope.ts')) return;
+ const marker = ' if (\n typeof raw';
+ expect(code.split(marker)).toHaveLength(2);
+ return {
+ code: code.replace(
+ marker,
+ ' globalThis.__cr005VerifyCalls = (globalThis.__cr005VerifyCalls ?? 0) + 1;\n' +
+ marker
+ ),
+ map: null
+ };
+ }
+ }
+ ],
+ build: {
+ write: false,
+ minify: false,
+ lib: { entry, name: 'cr005', formats: ['iife'] }
+ }
+ });
+ const output = Array.isArray(result) ? result[0] : result;
+ if (!('output' in output)) throw Error('fixture bundle absent');
+ const chunks = output.output.filter((row) => row.type === 'chunk');
+ expect(chunks).toHaveLength(1);
+ bundle = chunks[0].code;
+ console.log(
+ JSON.stringify({
+ fixture: 'CR005_TEST_ONLY_ACTUAL_IDB_REAL_VALIDATOR_COUNT',
+ phase: baseline ? 'baseline' : 'candidate',
+ bundleSha256: createHash('sha256').update(bundle).digest('hex'),
+ moduleIds: Object.keys(chunks[0].modules),
+ qualification:
+ 'Counter before unchanged real validator, no fabricated proofs/operator/fullQ'
+ })
+ );
+});
+test.afterAll(async () => server?.close());
+test.beforeEach(async ({ page }) => {
+ await page.goto(server.url + '/about');
+ await page.addScriptTag({ content: bundle });
+ await page.evaluate(async () => {
+ window.cr005Fixture = await window.cr005.createFixture();
+ });
+});
+test.afterEach(async ({ page }) => {
+ if (!page.isClosed()) await page.evaluate(() => window.cr005Fixture?.close());
+});
+test('CR005 actual capacity sample retains complete cursor checks while reusing unchanged validation', async ({
+ page
+}) => {
+ const result = await page.evaluate(async () => {
+ const f = window.cr005Fixture;
+ return {
+ first: await f.sample(),
+ second: await f.sample(),
+ inventory: await f.inventory(),
+ metadata: await f.metadata(),
+ outboxFirst: await f.sample('private_sends'),
+ outboxSecond: await f.sample('private_sends'),
+ bytes: f.bytes()
+ };
+ });
+ console.log(
+ JSON.stringify({
+ fixture: 'CR005_ACTUAL_CAPACITY_COUNTS',
+ phase: baseline ? 'baseline' : 'candidate',
+ ...result
+ })
+ );
+ for (const row of [
+ result.first,
+ result.second,
+ result.inventory,
+ result.metadata
+ ])
+ expect(row).toMatchObject({ ok: true, cursorVisits: 2000 });
+ expect(result.inventory.count).toBe(2000);
+ expect(result.metadata.count).toBe(2000);
+ expect(result.outboxFirst).toMatchObject({ ok: true, cursorVisits: 100 });
+ expect(result.outboxSecond).toMatchObject({ ok: true, cursorVisits: 100 });
+ expect(result.bytes.received).toBeLessThanOrEqual(50331648);
+ expect(result.bytes.sends).toBeLessThanOrEqual(8388608);
+ if (baseline) {
+ expect(result.first.verificationCalls).toBe(2001);
+ expect(result.second.verificationCalls).toBe(2001);
+ expect(result.inventory.verificationCalls).toBe(4000);
+ expect(result.metadata.verificationCalls).toBe(6000);
+ } else {
+ expect(result.first.verificationCalls).toBe(2000);
+ expect(result.second.verificationCalls).toBe(0);
+ expect(result.inventory.verificationCalls).toBe(0);
+ expect(result.metadata.verificationCalls).toBe(0);
+ }
+});
+for (const change of ['valid', 'corrupt', 'summary', 'id'] as const)
+ test(
+ 'CR005 warm complete namespace rejects or revalidates changed ' +
+ change +
+ ' tail through a second connection',
+ async ({ page }) => {
+ const result = await page.evaluate(async (change) => {
+ const f = window.cr005Fixture;
+ await f.sample();
+ await f.changeTail(change, true);
+ return await f.sample();
+ }, change);
+ if (change === 'valid')
+ expect(result).toMatchObject({
+ ok: true,
+ cursorVisits: 2000,
+ verificationCalls: 1
+ });
+ else
+ expect(result).toMatchObject({
+ ok: false,
+ reason: 'corrupt_record',
+ cursorVisits: 2000
+ });
+ }
+ );
+test('CR005 wrong namespace cannot borrow warm validation or claim empty owner history', async ({
+ page
+}) => {
+ const result = await page.evaluate(async () => {
+ const f = window.cr005Fixture;
+ await f.sample();
+ return { read: await f.foreignRead(), metadata: await f.metadata(true) };
+ });
+ expect(result.read).toMatchObject({ ok: false });
+ expect(result.metadata).toMatchObject({ ok: false, reason: 'invalid_scope' });
+});
+test('CR005 warm outbox still rejects actual101rows without eviction', async ({
+ page
+}) => {
+ const result = await page.evaluate(async () => {
+ const f = window.cr005Fixture;
+ await f.sample('private_sends');
+ return await f.overfillSends();
+ });
+ expect(result).toMatchObject({ ok: false, reason: 'capacity' });
+});
+test('CR005 encoded byte accounting rejects changed oversized received namespace', async ({
+ page
+}) => {
+ const result = await page.evaluate(async () => {
+ const f = window.cr005Fixture;
+ await f.sample();
+ return await f.oversizeReceived();
+ });
+ expect(result.bytes).toBeGreaterThan(50331648);
+ expect(result).toMatchObject({ ok: false, reason: 'capacity' });
+});
+
+test('CR005 warm received namespace rejects actual2001rows without eviction', async ({
+ page
+}) => {
+ const result = await page.evaluate(async () => {
+ const f = window.cr005Fixture;
+ await f.sample();
+ return await f.overfillReceived();
+ });
+ expect(result).toMatchObject({ ok: false, reason: 'capacity' });
+});
+test('CR005 changed current read/source metadata is revalidated and reflected in original history', async ({
+ page
+}) => {
+ const result = await page.evaluate(async () => {
+ const f = window.cr005Fixture;
+ await f.sample();
+ await f.changeTail('metadata', true);
+ return { read: await f.sample(), metadata: await f.metadata() };
+ });
+ expect(result.read).toMatchObject({
+ ok: true,
+ cursorVisits: 2000,
+ verificationCalls: 1
+ });
+ expect(result.metadata).toMatchObject({
+ ok: true,
+ cursorVisits: 2000,
+ verificationCalls: 0,
+ count: 2001
+ });
+});
diff --git a/web/tests/provenance/output.test.mjs b/web/tests/provenance/output.test.mjs
@@ -1958,6 +1958,10 @@ import { auditOutput } from '../../tools/check-output.mjs';
'src/lib/persistence/local-inventory.ts',
'src/lib/persistence/private-storage.ts',
'src/lib/persistence/private-outbox-cleanup.ts',
+ 'src/lib/persistence/private-records.ts',
+ 'src/lib/persistence/inbox-envelope-repository.ts',
+ 'src/lib/persistence/history-metadata-repository.ts',
+ 'src/lib/messaging/history-pagination.ts',
'src/lib/runtime/private-session.ts',
'src/lib/components/LocalDataReview.svelte'
]) {
diff --git a/web/tests/unit/private-records.test.ts b/web/tests/unit/private-records.test.ts
@@ -7,6 +7,8 @@ import {
import { nip44 } from 'applesauce-core/helpers/encryption';
import {
decodePrivateRecord,
+ privateReceivedOuterMetadata,
+ type PrivateRecordHandle,
privateRecordSnapshot,
privateRecordWire,
inspectPrivateSendReservation
@@ -92,6 +94,68 @@ function fixture(extended = false) {
}
}
describe('ciphertext-only private local codecs, not nested authenticity or effect authority', () => {
+ it('CR005 transport metadata belongs only to the genuine received handle and exact owner/id', () => {
+ const f = fixture(true),
+ decoded = decodePrivateRecord(
+ JSON.stringify(f.received),
+ f.owner,
+ f.received.id
+ );
+ expect(decoded.ok).toBe(true);
+ if (!decoded.ok) throw Error('strict fixture rejected');
+ expect(
+ privateReceivedOuterMetadata(decoded.value, f.owner, f.received.id)
+ ).toEqual({ id: f.received.id, createdAt: 1700000000 });
+ expect(
+ privateReceivedOuterMetadata(decoded.value, f.peer, f.received.id)
+ ).toBeUndefined();
+ expect(
+ privateReceivedOuterMetadata(decoded.value, f.owner, command)
+ ).toBeUndefined();
+ expect(
+ privateReceivedOuterMetadata(
+ Object.freeze({ ...decoded.value }) as PrivateRecordHandle,
+ f.owner,
+ f.received.id
+ )
+ ).toBeUndefined();
+ expect(
+ privateReceivedOuterMetadata(
+ Object.freeze({}) as PrivateRecordHandle,
+ undefined,
+ undefined
+ )
+ ).toBeUndefined();
+ const copy = privateReceivedOuterMetadata(
+ decoded.value,
+ f.owner,
+ f.received.id
+ )!;
+ Object.assign(copy, { createdAt: 0 });
+ const detached = privateRecordSnapshot(
+ decoded.value,
+ f.owner,
+ f.received.id
+ )!;
+ Object.assign(detached, { outer: 'untrusted changed snapshot' });
+ expect(
+ privateReceivedOuterMetadata(decoded.value, f.owner, f.received.id)
+ ).toEqual({ id: f.received.id, createdAt: 1700000000 });
+ const sender = fixture();
+ for (const record of [sender.operation, sender.reservation]) {
+ const other = decodePrivateRecord(
+ JSON.stringify(record),
+ sender.owner,
+ record.id
+ );
+ expect(other.ok).toBe(true);
+ if (!other.ok) throw Error('strict sender fixture rejected');
+ expect(
+ privateReceivedOuterMetadata(other.value, sender.owner, record.id)
+ ).toBeUndefined();
+ }
+ });
+
it('retains original receive hints/inert tags but keeps stored outgoing artifacts strict', () => {
const f = fixture(true),
decoded = decodePrivateRecord(
diff --git a/web/tools/check-output.mjs b/web/tools/check-output.mjs
@@ -366,6 +366,12 @@ async function operationalFlagsAdmission(web) {
'8bcc73be03321e60a6fbbe7ba58de14eb8fb34db5d5cdce0adee31b5467d7bb9',
'src/lib/persistence/local-data-review.ts':
'90379b183d0a1d8885076fbfc593d7c9ac1e351b16ce7800890107014e5cb0e4',
+ 'src/lib/persistence/inbox-envelope-repository.ts':
+ 'd3613a098c93c8881d53de12f91ffb689827926217cabcba66894885d49cb095',
+ 'src/lib/persistence/history-metadata-repository.ts':
+ 'afe4656e59bd6b365444fbda64fe6572ffa4c5323c474ee862e3cf19252b6f6d',
+ 'src/lib/messaging/history-pagination.ts':
+ '79b22b312a126b55c80a3c6ca22724bd2c5f3ad766f8600f3647028a2624c255',
'src/lib/persistence/private-outbox-cleanup.ts':
'13f4e7d771b3a8d4ec7703f2026a1c8ff71582a2d2a810b9d402d58684b2e2b6',
'src/lib/persistence/local-inventory.ts':
@@ -375,9 +381,9 @@ async function operationalFlagsAdmission(web) {
'src/lib/persistence/local-public-hides.ts':
'4f0e64ed0fabbe9f86014a0512e7dbd3c81711f28ca2c626e2dafa5cda349f83',
'src/lib/persistence/private-records.ts':
- '3389fe2fc5b9b84b292b4340fe1edda16a2eb365c1b0fb00d965827dd9b02ce6',
+ 'a9a7c450808ea363594f2cce5d50c48b8a614197dd0b9690c4860d8387419dcf',
'src/lib/persistence/private-storage.ts':
- 'a5587d3d1e8af689355e170e19d3b8572eba35b0698dab15f0b97294a0ad6e1e',
+ '49b9ef328e569e93c2e88f4c0e8e3e927985fb9ac53daa6814b7471451b81104',
'src/lib/persistence/public-publications.ts':
'be99c4114fb32880e0a9b48ab3593645532853fb4166fb506f398416db41a194',
'src/lib/persistence/public-receipts.ts':
@@ -610,6 +616,12 @@ async function privacyDataAdmission(web) {
'8bcc73be03321e60a6fbbe7ba58de14eb8fb34db5d5cdce0adee31b5467d7bb9',
'src/lib/persistence/local-data-review.ts':
'90379b183d0a1d8885076fbfc593d7c9ac1e351b16ce7800890107014e5cb0e4',
+ 'src/lib/persistence/inbox-envelope-repository.ts':
+ 'd3613a098c93c8881d53de12f91ffb689827926217cabcba66894885d49cb095',
+ 'src/lib/persistence/history-metadata-repository.ts':
+ 'afe4656e59bd6b365444fbda64fe6572ffa4c5323c474ee862e3cf19252b6f6d',
+ 'src/lib/messaging/history-pagination.ts':
+ '79b22b312a126b55c80a3c6ca22724bd2c5f3ad766f8600f3647028a2624c255',
'src/lib/persistence/private-outbox-cleanup.ts':
'13f4e7d771b3a8d4ec7703f2026a1c8ff71582a2d2a810b9d402d58684b2e2b6',
'src/lib/persistence/local-inventory.ts':
@@ -619,9 +631,9 @@ async function privacyDataAdmission(web) {
'src/lib/persistence/local-public-hides.ts':
'4f0e64ed0fabbe9f86014a0512e7dbd3c81711f28ca2c626e2dafa5cda349f83',
'src/lib/persistence/private-records.ts':
- '3389fe2fc5b9b84b292b4340fe1edda16a2eb365c1b0fb00d965827dd9b02ce6',
+ 'a9a7c450808ea363594f2cce5d50c48b8a614197dd0b9690c4860d8387419dcf',
'src/lib/persistence/private-storage.ts':
- 'a5587d3d1e8af689355e170e19d3b8572eba35b0698dab15f0b97294a0ad6e1e',
+ '49b9ef328e569e93c2e88f4c0e8e3e927985fb9ac53daa6814b7471451b81104',
'src/lib/persistence/public-publications.ts':
'be99c4114fb32880e0a9b48ab3593645532853fb4166fb506f398416db41a194',
'src/lib/persistence/public-receipts.ts':
@@ -824,7 +836,7 @@ async function supportReportingAdmission(web) {
'src/lib/persistence/local-public-hides.ts':
'4f0e64ed0fabbe9f86014a0512e7dbd3c81711f28ca2c626e2dafa5cda349f83',
'src/lib/persistence/private-storage.ts':
- 'a5587d3d1e8af689355e170e19d3b8572eba35b0698dab15f0b97294a0ad6e1e',
+ '49b9ef328e569e93c2e88f4c0e8e3e927985fb9ac53daa6814b7471451b81104',
'src/lib/persistence/public-publications.ts':
'be99c4114fb32880e0a9b48ab3593645532853fb4166fb506f398416db41a194',
'src/lib/persistence/public-receipts.ts':
@@ -1011,7 +1023,7 @@ async function privateBlockingAdmission(web) {
'src/lib/persistence/local-public-hides.ts':
'4f0e64ed0fabbe9f86014a0512e7dbd3c81711f28ca2c626e2dafa5cda349f83',
'src/lib/persistence/private-storage.ts':
- 'a5587d3d1e8af689355e170e19d3b8572eba35b0698dab15f0b97294a0ad6e1e',
+ '49b9ef328e569e93c2e88f4c0e8e3e927985fb9ac53daa6814b7471451b81104',
'src/lib/persistence/public-publications.ts':
'be99c4114fb32880e0a9b48ab3593645532853fb4166fb506f398416db41a194',
'src/lib/persistence/public-receipts.ts':
@@ -2134,7 +2146,7 @@ async function inboxPresentationAdmission(web) {
'src/lib/messaging/conversation-thread.ts':
'7367f0e6d96a9f249514f66c2459274e856eb83462523e37264d4cd97d2e36d1',
'src/lib/persistence/private-storage.ts':
- 'a5587d3d1e8af689355e170e19d3b8572eba35b0698dab15f0b97294a0ad6e1e',
+ '49b9ef328e569e93c2e88f4c0e8e3e927985fb9ac53daa6814b7471451b81104',
'src/routes/messages/[conversationId=local_id]/+page.svelte':
'b06c6189adee80b68bc6657fa0e8504551fe9a8b1655a6d81807ebee9930a5e7',
'src/lib/components/MessageComposer.svelte':