app

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

commit c0caa4ee1a8b2dca05e0f218f8d67e541a8d7e1d
parent 234c19d6ffe9c5a484d052b3fcdf3f74691e08df
Author: triesap <tyson@radroots.org>
Date:   Wed, 14 Oct 2026 06:34:12 +0000

harvestcircle_web: Add strict isolated private probe journals

- Bind ciphertext-only probe metadata to original inbox and operator configuration.
- Enforce immutable whole-wire CAS and the existing joint outbox quotas.
- Reject probe identities throughout ordinary send and self recovery.
- Verify 58 browser workflows, 47 units and hostile output producer controls.

Diffstat:
Mweb/src/lib/nostr/self-recovery-reader.ts | 7++++++-
Mweb/src/lib/persistence/private-records.ts | 196+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++--
Mweb/src/lib/persistence/private-send-reservations.ts | 28+++++++++++++++++++++++-----
Mweb/src/lib/persistence/private-sends.ts | 9+++++++--
Mweb/src/lib/persistence/private-storage.ts | 19+++++++++++++++++--
Mweb/tests/e2e/harness/private-storage.ts | 56+++++++++++++++++++++++++++++++++++++++++++++++++++++++-
Mweb/tests/e2e/private-storage.spec.ts | 549+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Mweb/tests/provenance/output.test.mjs | 3+++
Aweb/tests/unit/private-access-records.test.ts | 374+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Mweb/tools/check-output.mjs | 36++++++++++++++++++++++++------------
10 files changed, 1251 insertions(+), 26 deletions(-)

diff --git a/web/src/lib/nostr/self-recovery-reader.ts b/web/src/lib/nostr/self-recovery-reader.ts @@ -158,7 +158,12 @@ export function captureSelfRecoveryReader( id ), storedWire = privateRecordWire(loaded.value, ownership.owner, id); - if (!record || !storedWire || record.family === 'received_envelope') + if ( + !record || + !storedWire || + (record.family !== 'private_send_reservation' && + record.family !== 'private_send_operation') + ) return { status: 'invalid_scope' }; if (record.family !== 'private_send_operation') return { status: 'lost_evidence' }; diff --git a/web/src/lib/persistence/private-records.ts b/web/src/lib/persistence/private-records.ts @@ -7,7 +7,15 @@ import { verifyEnvelope, verifiedEnvelopeSnapshot } from '../nostr/verified-envelope.ts'; -import { canonicalRelayOrigin } from '../config/relays.ts'; +import { + canonicalRelayOrigin, + readRelayPolicy, + validateRelayPolicy +} from '../config/relays.ts'; +import { + inboxOperatorQualificationSnapshot, + validateInboxOperatorQualification +} from '../config/inbox-operators.ts'; import { incomingGiftWrapTags } from '../nostr/incoming-wire.ts'; import type { InboxRouteSnapshot } from '../messaging/inbox-routing.ts'; import { @@ -77,8 +85,50 @@ export type ReceivedEnvelopeRecord = Readonly<{ sources: readonly string[]; read: Readonly<{ rumorHash: string; atMilliseconds: number }> | null; }>; +export type PrivateAccessProbeBinding = Readonly<{ + preferenceId: string; + preferenceCreatedAt: number; + readTargets: readonly string[]; + archiveTargets: readonly string[]; + policyWire: string; + operatorWire: string; +}>; +export type PrivateAccessProbeReceipt = Readonly<{ + actionId: string; + origin: string; + role: 'access_archive' | 'access_readback'; + attempt: number; + eventId: string; + status: + | 'accepted' + | 'refused' + | 'timed_out' + | 'unknown' + | 'stopped' + | 'readback' + | 'nonce_verified'; + observedAtMilliseconds: number; + readbackWire: string | null; +}>; +// Ciphertext/status bookkeeping only. Neither this record nor a receipt label +// is a genuine probe issuer, nested proof, effect or suppression capability. +export type PrivateAccessProbe = Readonly<{ + schema: 1; + family: 'private_access_probe'; + owner: string; + id: string; + revision: number; + rumorHash: string; + createdAt: number; + binding: PrivateAccessProbeBinding; + self: PrivateCiphertextArtifact | null; + receipts: readonly PrivateAccessProbeReceipt[]; +}>; export type PrivateRecord = - PrivateSendReservation | PrivateSendOperation | ReceivedEnvelopeRecord; + | PrivateSendReservation + | PrivateSendOperation + | ReceivedEnvelopeRecord + | PrivateAccessProbe; declare const recordBrand: unique symbol; export type PrivateRecordHandle = Readonly<{ [recordBrand]: true }>; const records = new WeakMap< @@ -445,6 +495,96 @@ function receipt( : value.readbackWire === null) ); } +function probeBinding(value: unknown): value is PrivateAccessProbeBinding { + if ( + !exactLocalFields(value, [ + 'preferenceId', + 'preferenceCreatedAt', + 'readTargets', + 'archiveTargets', + 'policyWire', + 'operatorWire' + ]) || + !hash(value.preferenceId) || + !unsigned(value.preferenceCreatedAt) || + typeof value.policyWire !== 'string' || + typeof value.operatorWire !== 'string' + ) + return false; + const policy = validateRelayPolicy(value.policyWire), + qualified = validateInboxOperatorQualification(value.operatorWire), + declaration = qualified && inboxOperatorQualificationSnapshot(qualified); + if ( + !policy || + !declaration || + declaration.authority === 'unconfigured' || + declaration.policyWire !== value.policyWire + ) + return false; + const manifest = readRelayPolicy(policy); + if (JSON.stringify(manifest) !== value.policyWire) return false; + function targets(raw: unknown, role: 'read' | 'write'): boolean { + return ( + Array.isArray(raw) && + raw.length >= 1 && + raw.length <= RELAY_BUDGETS.inbox && + new Set(raw).size === raw.length && + (raw as unknown[]).every( + (origin) => + typeof origin === 'string' && + canonicalRelayOrigin(origin) === origin && + manifest.inbox.some( + (entry) => entry.origin === origin && entry[role] + ) && + declaration!.relays.some((entry) => entry.origin === origin) + ) + ); + } + return ( + targets(value.readTargets, 'read') && targets(value.archiveTargets, 'write') + ); +} +function probeReceipt( + value: unknown, + self: PrivateCiphertextArtifact, + binding: PrivateAccessProbeBinding +): value is PrivateAccessProbeReceipt { + if ( + !exactLocalFields(value, [ + 'actionId', + 'origin', + 'role', + 'attempt', + 'eventId', + 'status', + 'observedAtMilliseconds', + 'readbackWire' + ]) || + !canonicalLocalId(value.actionId) || + typeof value.origin !== 'string' || + canonicalRelayOrigin(value.origin) !== value.origin || + !unsigned(value.attempt) || + value.attempt < 1 || + value.attempt > PRIVATE_PUBLICATION_BUDGETS.attemptsPerTargetAction || + value.eventId !== self.eventId || + !unsigned(value.observedAtMilliseconds) + ) + return false; + if (value.role === 'access_archive') + return ( + binding.archiveTargets.includes(value.origin) && + ['accepted', 'refused', 'timed_out', 'unknown', 'stopped'].includes( + value.status as string + ) && + value.readbackWire === null + ); + return ( + value.role === 'access_readback' && + binding.readTargets.includes(value.origin) && + (value.status === 'readback' || value.status === 'nonce_verified') && + value.readbackWire === self.wire + ); +} // Strict local storage codec only, never installed-account/effect authorization, // genuine sender factory proof, nested authenticity, read receipt or Send. export function decodePrivateRecord( @@ -537,6 +677,53 @@ export function decodePrivateRecord( ? {} : { receipts: fields.receipts as PrivateTargetReceipt[] }) }; + } else if (fields.family === 'private_access_probe') { + if ( + !canonicalLocalId(id) || + !exactLocalFields(fields, [ + 'schema', + 'family', + 'owner', + 'id', + 'revision', + 'rumorHash', + 'createdAt', + 'binding', + 'self', + 'receipts' + ]) || + !hash(fields.rumorHash) || + !unsigned(fields.createdAt) || + !unsigned(fields.revision) || + !probeBinding(fields.binding) || + !Array.isArray(fields.receipts) || + (fields.revision === 0 + ? fields.self !== null || fields.receipts.length !== 0 + : !artifact(fields.self, owner) || + !fields.receipts.every((fact) => + probeReceipt( + fact, + fields.self as PrivateCiphertextArtifact, + fields.binding as PrivateAccessProbeBinding + ) + )) + ) + return failed('malformed'); + record = { + schema: 1, + family: 'private_access_probe', + owner, + id, + revision: fields.revision, + rumorHash: fields.rumorHash, + createdAt: fields.createdAt, + binding: fields.binding, + self: + fields.self === null + ? null + : (fields.self as PrivateCiphertextArtifact), + receipts: fields.receipts as PrivateAccessProbeReceipt[] + }; } else if (fields.family === 'received_envelope') { outerMetadata = outer(fields.outer, owner, true); if ( @@ -648,5 +835,8 @@ export function inspectPrivateSendRecord( const decoded = decodePrivateRecord(raw, owner, id); if (!decoded.ok) return undefined; const value = privateRecordSnapshot(decoded.value, owner, id); - return value?.family !== 'received_envelope' ? value : undefined; + return value?.family === 'private_send_reservation' || + value?.family === 'private_send_operation' + ? value + : undefined; } diff --git a/web/src/lib/persistence/private-send-reservations.ts b/web/src/lib/persistence/private-send-reservations.ts @@ -11,7 +11,8 @@ import { } from './database.ts'; import { inspectPrivateSendReservation, - inspectPrivateSendRecord, + decodePrivateRecord, + privateRecordSnapshot, type PrivateSendReservation } from './private-records.ts'; export { @@ -177,13 +178,26 @@ export function reservePrivateSendReservation( refuse('corrupt_record'); return; } - const value = inspectPrivateSendRecord(row.wire, scope.owner, id); - if (!value) { + const decoded = decodePrivateRecord(row.wire, scope.owner, id), + value = + decoded.ok && + privateRecordSnapshot(decoded.value, scope.owner, id); + if (!value || value.family === 'received_envelope') { refuse('corrupt_record'); return; } count += 1; - if (value.id === candidate.id) + if ( + value.id === candidate.id && + value.family === 'private_access_probe' + ) { + refuse('conflict'); + return; + } + if ( + value.id === candidate.id && + value.family !== 'private_access_probe' + ) existing = { schema: 1, family: 'private_send_reservation', @@ -194,7 +208,11 @@ export function reservePrivateSendReservation( rumorHash: value.rumorHash, createdAt: value.createdAt }; - if (value.rumorHash === candidate.rumorHash) collision = true; + if ( + value.family !== 'private_access_probe' && + value.rumorHash === candidate.rumorHash + ) + collision = true; bytes += new TextEncoder().encode(JSON.stringify(row)).length; if ( count > LOCAL_PERSISTENCE_BUDGETS.unfinishedPrivateSends || diff --git a/web/src/lib/persistence/private-sends.ts b/web/src/lib/persistence/private-sends.ts @@ -84,7 +84,8 @@ export async function readSelfRecoveryBase( const row = privateRecordSnapshot(loaded.value, record.owner, record.id); if ( !row || - row.family === 'received_envelope' || + (row.family !== 'private_send_reservation' && + row.family !== 'private_send_operation') || row.peer !== record.peer || row.rumorHash !== record.rumorHash || row.createdAt !== record.createdAt @@ -168,7 +169,11 @@ export async function commitSelfRecovery( captured.record.owner, captured.record.id ); - if (!base || base.family === 'received_envelope') + if ( + !base || + (base.family !== 'private_send_reservation' && + base.family !== 'private_send_operation') + ) return { status: 'invalid_record' }; if ( captured.recoveryWire !== undefined && diff --git a/web/src/lib/persistence/private-storage.ts b/web/src/lib/persistence/private-storage.ts @@ -285,9 +285,11 @@ function validTransition( ): boolean { if (!base) return ( - next.family === 'received_envelope' && next.revision === 0 && - next.read === null + ((next.family === 'received_envelope' && next.read === null) || + (next.family === 'private_access_probe' && + next.self === null && + next.receipts.length === 0)) ); if ( base.owner !== next.owner || @@ -303,6 +305,19 @@ function validTransition( base.sources.every((source) => next.sources.includes(source)) ); } + if (base.family === 'private_access_probe') + return ( + next.family === base.family && + next.rumorHash === base.rumorHash && + next.createdAt === base.createdAt && + JSON.stringify(next.binding) === JSON.stringify(base.binding) && + (base.self === null || + JSON.stringify(base.self) === JSON.stringify(next.self)) && + base.receipts.every( + (fact, index) => + JSON.stringify(fact) === JSON.stringify(next.receipts[index]) + ) + ); if ( next.family !== 'private_send_operation' || base.peer !== next.peer || diff --git a/web/tests/e2e/harness/private-storage.ts b/web/tests/e2e/harness/private-storage.ts @@ -96,6 +96,59 @@ export async function makeFixture() { peerArtifact: padded ? outer(peer, index, padded) : null }; } + function probe(index: number, prepared = false, padded = false) { + const origin = 'wss://inbox.example.org', + policyWire = JSON.stringify({ + schemaVersion: 1, + public: [ + { + origin: 'wss://public.example.org', + read: true, + write: false, + nip50: false + } + ], + inbox: [{ origin, read: true, write: true }], + postingEnabled: false, + messagingEnabled: true, + operatorDenylist: [] + }); + return { + schema: 1, + family: 'private_access_probe', + owner, + id: id(index), + revision: prepared ? 1 : 0, + rumorHash: index.toString(16).padStart(64, '0'), + createdAt: 1700000000, + binding: { + preferenceId: 'f'.repeat(64), + preferenceCreatedAt: 1699999999, + readTargets: [origin], + archiveTargets: [origin], + policyWire, + operatorWire: JSON.stringify({ + schemaVersion: 1, + revision: 1, + authority: 'source_fixture', + policyWire, + evidenceSha256: 'a'.repeat(64), + relays: [ + { + origin, + auth: 'not_required', + recipientRead: 'supported', + namedArchiveAck: 'supported', + exactReadback: 'supported', + retention: 'operator_defined' + } + ] + }) + }, + self: prepared ? outer(owner, index, padded) : null, + receipts: [] + }; + } function received(index: number, padded = false) { const artifact = outer(owner, index, padded); return { @@ -110,7 +163,7 @@ export async function makeFixture() { read: null }; } - function handle(record: { owner: string; id: string }) { + function handle<T extends { owner: string; id: string }>(record: T) { const result = decodePrivateRecord( JSON.stringify(record), record.owner, @@ -147,6 +200,7 @@ export async function makeFixture() { repository: repo, reservation, operation, + probe, received, handle, rows, diff --git a/web/tests/e2e/private-storage.spec.ts b/web/tests/e2e/private-storage.spec.ts @@ -413,3 +413,552 @@ test('real transaction abort never acknowledges or retains a new ciphertext row' expect(result.result.ok).toBe(false); expect(result.count).toBe(0); }); + +test('CR008 probe CAS retains exact immutable ciphertext/bindings and native completion', async ({ + page +}) => { + await load(page); + const result = await page.evaluate(async () => { + const f = window.hcp080Fixture, + s = window.hcp080, + reservation = f.probe(0), + prepared = { ...reservation, revision: 1, self: f.probe(0, true).self }, + base = f.handle(reservation), + next = f.handle(prepared); + const create = await s.commitPrivateRecord(f.repository, base, null), + commit = await s.commitPrivateRecord(f.repository, next, base), + loaded = await s.loadPrivateRecord( + f.repository, + 'private_sends', + reservation.id + ), + retry = await s.commitPrivateRecord(f.repository, next, base); + const before = JSON.stringify(await f.rows('private_sends')); + const changes = [ + { rumorHash: 'e'.repeat(64) }, + { createdAt: prepared.createdAt + 1 }, + { self: f.probe(1, true).self }, + { binding: { ...prepared.binding, preferenceId: 'e'.repeat(64) } } + ]; + const refused = []; + for (const patch of changes) { + const decoded = s.decodePrivateRecord( + JSON.stringify({ ...prepared, revision: 2, ...patch }), + s.owner, + reservation.id + ); + refused.push( + !decoded.ok || + !(await s.commitPrivateRecord(f.repository, decoded.value, next)).ok + ); + } + const ordinary = { ...f.operation(0), revision: 2, self: prepared.self }, + decodedOrdinary = s.decodePrivateRecord( + JSON.stringify(ordinary), + s.owner, + reservation.id + ); + if (!decodedOrdinary.ok) + throw Error('valid ordinary family transition control missing'); + refused.push( + !(await s.commitPrivateRecord(f.repository, decodedOrdinary.value, next)) + .ok + ); + return { + create: create.ok, + commit: commit.ok, + retry: retry.ok && retry.value.state, + original: + loaded.ok && + s.privateRecordWire(loaded.value, s.owner, reservation.id) === + s.privateRecordWire(next, s.owner, reservation.id), + refused, + unchanged: before === JSON.stringify(await f.rows('private_sends')), + count: (await f.rows('private_sends')).length + }; + }); + expect(result).toEqual({ + create: true, + commit: true, + retry: 'existing', + original: true, + refused: [true, true, true, true, true], + unchanged: true, + count: 1 + }); +}); + +test('CR008 append-only probe receipts use whole-wire CAS under actual concurrent writers', async ({ + page +}) => { + await load(page); + const result = await page.evaluate(async () => { + const f = window.hcp080Fixture, + s = window.hcp080, + reservation = f.probe(0), + prepared = { ...reservation, revision: 1, self: f.probe(0, true).self! }, + base = f.handle(reservation), + next = f.handle(prepared); + await s.commitPrivateRecord(f.repository, base, null); + await s.commitPrivateRecord(f.repository, next, base); + const fact = { + actionId: s.id(1), + origin: prepared.binding.archiveTargets[0], + role: 'access_archive', + attempt: 1, + eventId: prepared.self.eventId, + status: 'unknown', + observedAtMilliseconds: 1, + readbackWire: null + }, + a = { ...prepared, revision: 2, receipts: [fact] }, + b = { + ...prepared, + revision: 2, + receipts: [{ ...fact, actionId: s.id(2) }] + }; + const races = await Promise.all( + [a, b].map((row) => + s.commitPrivateRecord(f.repository, f.handle(row), next) + ) + ); + const loaded = await s.loadPrivateRecord( + f.repository, + 'private_sends', + prepared.id + ); + if (!loaded.ok) throw Error('probe disappeared'); + const row = JSON.parse( + s.privateRecordWire(loaded.value, s.owner, prepared.id)! + ) as typeof a; + const deleted = await s.commitPrivateRecord( + f.repository, + f.handle({ ...row, revision: 3, receipts: [] }), + loaded.value + ), + relabelled = await s.commitPrivateRecord( + f.repository, + f.handle({ + ...row, + revision: 3, + receipts: [{ ...row.receipts[0], status: 'accepted' }] + }), + loaded.value + ), + append = await s.commitPrivateRecord( + f.repository, + f.handle({ + ...row, + revision: 3, + receipts: [...row.receipts, { ...fact, status: 'accepted' }] + }), + loaded.value + ); + return { + races: races.map((r) => (r.ok ? 'committed' : r.reason)).sort(), + deleted: deleted.ok, + relabelled: relabelled.ok, + append: append.ok, + count: (await f.rows('private_sends')).length + }; + }); + expect(result).toEqual({ + races: ['committed', 'conflict'], + deleted: false, + relabelled: false, + append: true, + count: 1 + }); +}); + +test('CR008 probes and ordinary sends share exactly 100 retained rows in both admission directions', async ({ + page +}) => { + await load(page); + const result = await page.evaluate(async () => { + const f = window.hcp080Fixture, + s = window.hcp080; + const originals = Array.from({ length: 99 }, (_, n) => + n < 50 ? f.probe(n) : f.reservation(n) + ); + await f.inject( + 'private_sends', + originals.map((row) => ({ + owner: s.owner, + id: row.id, + wire: s.privateRecordWire(f.handle(row), s.owner, row.id) + })) + ); + const ordinary = await f.reserve(100), + before = JSON.stringify(await f.rows('private_sends')), + probe = await s.commitPrivateRecord( + f.repository, + f.handle(f.probe(101)), + null + ), + full = await f.reserve(102), + collision = await f.reserve(0); + return { + ordinary: ordinary.ok, + probe: probe.ok ? 'unexpected' : probe.reason, + full: full.ok ? 'unexpected' : full.reason, + collision: collision.ok ? 'unexpected' : collision.reason, + unchanged: before === JSON.stringify(await f.rows('private_sends')), + count: (await f.rows('private_sends')).length + }; + }); + expect(result).toEqual({ + ordinary: true, + probe: 'capacity', + full: 'capacity', + collision: 'conflict', + unchanged: true, + count: 100 + }); +}); + +test('CR008 outbox bytes include complete probe artifact/readback metadata below the row ceiling', async ({ + page +}) => { + await load(page); + const result = await page.evaluate(async () => { + const f = window.hcp080Fixture, + s = window.hcp080; + const rows = []; + let total = 0; + for (let index = 0; index < 100; index++) { + const probe = f.probe(index, true, true), + self = probe.self!, + record = { + ...probe, + revision: 2, + receipts: [ + { + actionId: s.id(500), + origin: probe.binding.readTargets[0], + role: 'access_readback', + attempt: 1, + eventId: self.eventId, + status: 'readback', + observedAtMilliseconds: 1, + readbackWire: self.wire + } + ] + }, + row = { + owner: s.owner, + id: record.id, + wire: s.privateRecordWire(f.handle(record), s.owner, record.id) + }, + bytes = new TextEncoder().encode(JSON.stringify(row)).length; + if (total + bytes > 8 * 1024 * 1024) break; + total += bytes; + rows.push(row); + } + if (!rows.length || rows.length >= 100) + throw Error('byte boundary not exercised'); + await f.inject('private_sends', rows); + const original = JSON.parse(rows[rows.length - 1].wire!) as { + owner: string; + id: string; + revision: number; + receipts: { + actionId: string; + origin: string; + role: string; + attempt: number; + eventId: string; + status: string; + observedAtMilliseconds: number; + readbackWire: string; + }[]; + }, + next = { + ...original, + revision: original.revision + 1, + receipts: [...original.receipts] + }, + oldBytes = new TextEncoder().encode( + JSON.stringify(rows[rows.length - 1]) + ).length; + let growth = 0; + for ( + let index = 0; + index < 10 && total + growth <= 8 * 1024 * 1024; + index++ + ) { + next.receipts.push({ + ...original.receipts[0], + actionId: s.id(600 + index) + }); + const row = { + owner: next.owner, + id: next.id, + wire: s.privateRecordWire(f.handle(next), next.owner, next.id) + }; + growth = new TextEncoder().encode(JSON.stringify(row)).length - oldBytes; + } + if (total + growth <= 8 * 1024 * 1024) + throw Error('bounded update did not cross byte cap'); + const before = JSON.stringify(await f.rows('private_sends')), + refused = await s.commitPrivateRecord( + f.repository, + f.handle(next), + f.handle(original) + ), + inventory = await s.inspectPrivateStorage(f.repository, 'private_sends'), + physicalBytes = (await f.rows('private_sends')).reduce<number>( + (sum, row) => + sum + new TextEncoder().encode(JSON.stringify(row)).length, + 0 + ); + return { + refused: refused.ok ? 'unexpected' : refused.reason, + actualBytes: physicalBytes === total, + meteredBytes: inventory.ok && inventory.value.bytes === total, + belowCountCap: rows.length < 100, + unchanged: before === JSON.stringify(await f.rows('private_sends')) + }; + }); + expect(result).toEqual({ + refused: 'capacity', + actualBytes: true, + meteredBytes: true, + belowCountCap: true, + unchanged: true + }); +}); + +test('CR008 a probe can take the mixed last slot while the next ordinary reservation is refused', async ({ + page +}) => { + await load(page); + const result = await page.evaluate(async () => { + const f = window.hcp080Fixture, + s = window.hcp080; + const records = Array.from({ length: 99 }, (_, n) => + n < 50 ? f.reservation(n) : f.probe(n) + ); + await f.inject( + 'private_sends', + records.map((row) => ({ + owner: row.owner, + id: row.id, + wire: s.privateRecordWire(f.handle(row), row.owner, row.id) + })) + ); + const probe = await s.commitPrivateRecord( + f.repository, + f.handle(f.probe(100)), + null + ), + before = JSON.stringify(await f.rows('private_sends')), + ordinary = await f.reserve(101); + return { + probe: probe.ok, + ordinary: ordinary.ok ? 'unexpected' : ordinary.reason, + unchanged: before === JSON.stringify(await f.rows('private_sends')), + count: (await f.rows('private_sends')).length + }; + }); + expect(result).toEqual({ + probe: true, + ordinary: 'capacity', + unchanged: true, + count: 100 + }); +}); + +test('CR008 actual probe growth leaves insufficient physical bytes for an ordinary reservation', async ({ + page +}) => { + await load(page); + const result = await page.evaluate(async () => { + const f = window.hcp080Fixture, + s = window.hcp080, + cap = 8 * 1024 * 1024; + const makeRecord = (index: number) => { + const probe = f.probe(index, true, true), + self = probe.self!; + return { + ...probe, + self, + revision: 2, + receipts: [ + { + actionId: s.id(500), + origin: probe.binding.readTargets[0], + role: 'access_readback', + attempt: 1, + eventId: self.eventId, + status: 'readback', + observedAtMilliseconds: 1, + readbackWire: self.wire + } + ] + }; + }; + type Record = ReturnType<typeof makeRecord>; + const stored = (record: { owner: string; id: string }) => ({ + owner: record.owner, + id: record.id, + wire: s.privateRecordWire(f.handle(record), record.owner, record.id) + }); + const bytes = (record: { owner: string; id: string }) => + new TextEncoder().encode(JSON.stringify(stored(record))).length; + // Signed-wire whitespace varies structural fixture charging, not inner + // nonce/source proof. Every readback retains the same exact outer wire. + const withWire = (record: Record, wire: string): Record => ({ + ...record, + self: { ...record.self, wire }, + receipts: record.receipts.map((fact) => ({ ...fact, readbackWire: wire })) + }); + const records: Record[] = []; + let total = 0; + for (let index = 0; index < 100; index++) { + const record = makeRecord(index), + size = bytes(record); + if (total + size > cap) break; + total += size; + records.push(record); + } + if (!records.length || records.length >= 100) + throw Error('byte-only fixture missing'); + const original = records[records.length - 1], + originalBytes = bytes(original), + next = { ...original, revision: 3, receipts: [...original.receipts] }; + for ( + let index = 0; + index < 10 && total - originalBytes + bytes(next) <= cap; + index++ + ) + next.receipts.push({ + ...original.receipts[0], + actionId: s.id(600 + index) + }); + const ordinaryBytes = bytes(f.reservation(999)), + overflow = total - originalBytes + bytes(next) - cap, + perCharacter = + bytes(next) - bytes(withWire(next, original.self.wire.slice(0, -1))), + trim = Math.ceil( + (overflow + Math.floor(ordinaryBytes / 2)) / perCharacter + ); + if ( + overflow <= 0 || + perCharacter <= 0 || + trim <= 0 || + !original.self.wire.endsWith('\n'.repeat(trim)) + ) + throw Error('invalid byte boundary adjustment'); + const wire = original.self.wire.slice(0, -trim), + baseline = withWire(original, wire), + candidate = withWire(next, wire); + records[records.length - 1] = baseline; + const baselineBytes = total - originalBytes + bytes(baseline), + expected = baselineBytes - bytes(baseline) + bytes(candidate); + if (expected > cap || cap - expected >= ordinaryBytes) + throw Error('ordinary denial boundary not reached'); + await f.inject('private_sends', records.map(stored)); + const growth = await s.commitPrivateRecord( + f.repository, + f.handle(candidate), + f.handle(baseline) + ), + before = JSON.stringify(await f.rows('private_sends')), + ordinary = await f.reserve(999), + inventory = await s.inspectPrivateStorage(f.repository, 'private_sends'), + actual = (await f.rows('private_sends')).reduce<number>( + (sum, row) => + sum + new TextEncoder().encode(JSON.stringify(row)).length, + 0 + ); + return { + growth: growth.ok, + ordinary: ordinary.ok ? 'unexpected' : ordinary.reason, + bytesExact: + actual === expected && + inventory.ok && + inventory.value.bytes === expected, + belowCountCap: records.length < 100, + unchanged: before === JSON.stringify(await f.rows('private_sends')) + }; + }); + expect(result).toEqual({ + growth: true, + ordinary: 'capacity', + bytesExact: true, + belowCountCap: true, + unchanged: true + }); +}); + +test('CR008 ordinary reservation rejects a corrupt probe tail without skipping owner rows', async ({ + page +}) => { + await load(page); + const result = await page.evaluate(async () => { + const f = window.hcp080Fixture, + s = window.hcp080, + good = f.probe(0), + corrupt = f.probe(99); + await f.inject('private_sends', [ + { + owner: s.owner, + id: good.id, + wire: s.privateRecordWire(f.handle(good), s.owner, good.id) + }, + { + owner: s.owner, + id: corrupt.id, + wire: JSON.stringify({ + ...corrupt, + nonce: 'PRIVATE_CORRUPTION_SENTINEL' + }) + } + ]); + const before = JSON.stringify(await f.rows('private_sends')), + result = await f.reserve(100); + return { + refused: result.ok ? 'unexpected' : result.reason, + unchanged: before === JSON.stringify(await f.rows('private_sends')) + }; + }); + expect(result).toEqual({ refused: 'corrupt_record', unchanged: true }); +}); + +test('CR008 native abort cannot acknowledge or retain a new probe reservation', async ({ + page +}) => { + await load(page); + const result = await page.evaluate(async () => { + const f = window.hcp080Fixture, + s = window.hcp080, + row = f.probe(0), + original = Reflect.get<IDBObjectStore, 'put'>( + IDBObjectStore.prototype, + 'put' + ); + IDBObjectStore.prototype.put = function (...args) { + const request = original.apply(this, args); + request.addEventListener('success', () => this.transaction.abort(), { + once: true + }); + return request; + }; + let committed; + try { + committed = await s.commitPrivateRecord( + f.repository, + f.handle(row), + null + ); + } finally { + IDBObjectStore.prototype.put = original; + } + return { + acknowledged: committed.ok, + count: (await f.rows('private_sends')).length + }; + }); + expect(result).toEqual({ acknowledged: false, count: 0 }); +}); diff --git a/web/tests/provenance/output.test.mjs b/web/tests/provenance/output.test.mjs @@ -1937,6 +1937,9 @@ import { auditOutput } from '../../tools/check-output.mjs'; ); } for (const producer of [ + 'src/lib/config/inbox-operators.ts', + 'src/lib/persistence/private-sends.ts', + 'src/lib/nostr/self-recovery-reader.ts', 'src/lib/config/operation-flags.ts', 'src/lib/nostr/private-pool.ts', 'src/lib/messaging/inbox-access-controller.ts', diff --git a/web/tests/unit/private-access-records.test.ts b/web/tests/unit/private-access-records.test.ts @@ -0,0 +1,374 @@ +import { describe, expect, it } from 'vitest'; +import { finalizeEvent, generateSecretKey } from 'applesauce-core/helpers'; +import { nip44 } from 'applesauce-core/helpers/encryption'; +import { + decodePrivateRecord, + inspectPrivateSendRecord, + privateRecordSnapshot, + privateRecordWire, + privateReceivedOuterMetadata, + type PrivateAccessProbe, + type PrivateAccessProbeReceipt +} from '../../src/lib/persistence/private-records.ts'; +import { privateRecordSettlement } from '../../src/lib/persistence/local-inventory.ts'; +import { privateSendStatus } from '../../src/lib/messaging/send-status.ts'; + +const owner = + '79be667ef9dcbbac55a06295ce870b07029bfcdb2dce28d959f2815b16f81798'; +const peer = 'c6047f9441ed7d6d3045406e95c07cd85c778e4b8cef3ca7abac09b95c709ee5'; +const command = '12345678-1234-4234-8234-123456789abc'; +const readOrigin = 'wss://read.example.org'; +const archiveOrigin = 'wss://archive.example.org'; +function policy() { + return { + schemaVersion: 1, + public: [ + { + origin: 'wss://public.example.org', + read: true, + write: false, + nip50: false + } + ], + inbox: [ + { origin: readOrigin, read: true, write: false }, + { origin: archiveOrigin, read: false, write: true } + ], + postingEnabled: false, + messagingEnabled: true, + operatorDenylist: [] + }; +} +function operator(policyWire = JSON.stringify(policy())) { + return { + schemaVersion: 1, + revision: 1, + authority: 'source_fixture', + policyWire, + evidenceSha256: 'a'.repeat(64), + relays: [readOrigin, archiveOrigin].map((origin) => ({ + origin, + auth: 'not_required', + recipientRead: 'supported', + namedArchiveAck: 'supported', + exactReadback: 'supported', + retention: 'operator_defined' + })) + }; +} +// Genuine outer signatures/ciphertext structure only; this fixture does not +// prove nested probe contents, operator facts or an actual access workflow. +function artifact(destination = owner) { + const key = generateSecretKey(); + let conversation: Uint8Array | undefined; + try { + conversation = nip44.v2.utils.getConversationKey(key, destination); + const event = finalizeEvent( + { + kind: 1059, + created_at: 1700000000, + tags: [['p', destination]], + content: nip44.v2.encrypt( + 'Structural codec fixture; no nonce proof', + conversation + ) + }, + key + ); + return { eventId: event.id, wire: JSON.stringify(event) }; + } finally { + conversation?.fill(0); + key.fill(0); + } +} +function reservation(): PrivateAccessProbe { + const policyWire = JSON.stringify(policy()); + return { + schema: 1, + family: 'private_access_probe', + owner, + id: command, + revision: 0, + rumorHash: 'b'.repeat(64), + createdAt: 1700000000, + binding: { + preferenceId: 'c'.repeat(64), + preferenceCreatedAt: 1699999999, + readTargets: [readOrigin], + archiveTargets: [archiveOrigin], + policyWire, + operatorWire: JSON.stringify(operator(policyWire)) + }, + self: null, + receipts: [] + }; +} +function prepared(): PrivateAccessProbe { + return { ...reservation(), revision: 1, self: artifact() }; +} +function fact( + row: PrivateAccessProbe, + status: PrivateAccessProbeReceipt['status'] = 'accepted' +): PrivateAccessProbeReceipt { + const readback = status === 'readback' || status === 'nonce_verified'; + return { + actionId: command, + origin: readback ? readOrigin : archiveOrigin, + role: readback ? 'access_readback' : 'access_archive', + attempt: 1, + eventId: row.self!.eventId, + status, + observedAtMilliseconds: 1700000000000, + readbackWire: readback ? row.self!.wire : null + }; +} +const decode = (row: unknown, expectedOwner = owner, expectedId = command) => + decodePrivateRecord(JSON.stringify(row), expectedOwner, expectedId); + +describe('CR008 S2 strict separate probe journal codec', () => { + it('retains reservation and own ciphertext phases with no plaintext or permission', () => { + for (const row of [reservation(), prepared()]) { + const result = decode(row); + expect(result.ok).toBe(true); + if (!result.ok) throw Error('valid structural probe rejected'); + expect(privateRecordSnapshot(result.value, owner, command)).toEqual(row); + expect(privateRecordWire(result.value, owner, command)).toBe( + JSON.stringify(row) + ); + expect( + privateRecordSnapshot(result.value, peer, command) + ).toBeUndefined(); + expect( + privateReceivedOuterMetadata(result.value, owner, command) + ).toBeUndefined(); + expect( + inspectPrivateSendRecord(JSON.stringify(row), owner, command) + ).toBeUndefined(); + expect(privateSendStatus(result.value, owner, command)).toBeUndefined(); + expect(privateRecordSettlement(row)).toBe('protected'); + } + }); + it('admits exact local archive/readback facts without granting readiness or settled cleanup', () => { + const row = prepared(); + for (const status of [ + 'accepted', + 'refused', + 'timed_out', + 'unknown', + 'stopped', + 'readback', + 'nonce_verified' + ] as const) { + const next = { ...row, revision: 2, receipts: [fact(row, status)] }; + expect(decode(next).ok).toBe(true); + expect(privateRecordSettlement(next)).toBe('protected'); + } + const completeLooking = { + ...row, + revision: 4, + receipts: [fact(row), fact(row, 'readback'), fact(row, 'nonce_verified')] + }; + expect(decode(completeLooking).ok).toBe(true); + expect(privateRecordSettlement(completeLooking)).toBe('protected'); + expect(decode({ ...completeLooking, readiness: true }).ok).toBe(false); + }); + it('preserves explicit unsupported capability metadata without converting it into success', () => { + const row = reservation(), + declaration = operator(); + declaration.relays[0].exactReadback = 'unsupported'; + expect( + decode({ + ...row, + binding: { ...row.binding, operatorWire: JSON.stringify(declaration) } + }).ok + ).toBe(true); + }); + it('requires separate read/write grants, configured declarations and their exact policy wire', () => { + const row = reservation(); + for (const patch of [ + { readTargets: [] }, + { archiveTargets: [] }, + { readTargets: [archiveOrigin] }, + { archiveTargets: [readOrigin] }, + { readTargets: [readOrigin, readOrigin] }, + { readTargets: [readOrigin, 'wss://outside.example.org'] }, + { archiveTargets: [archiveOrigin + '/'] }, + { readTargets: [readOrigin, readOrigin, readOrigin, readOrigin] }, + { preferenceId: 'bad' }, + { preferenceCreatedAt: -1 }, + { preferenceCreatedAt: 1.1 }, + { policyWire: '{}' }, + { operatorWire: '{}' } + ]) + expect(decode({ ...row, binding: { ...row.binding, ...patch } }).ok).toBe( + false + ); + for (const declaration of [ + { + ...operator(), + authority: 'unconfigured', + evidenceSha256: null, + relays: [] + }, + { ...operator(), relays: [operator().relays[0]] }, + { + ...operator(), + policyWire: JSON.stringify({ ...policy(), messagingEnabled: false }) + } + ]) + expect( + decode({ + ...row, + binding: { ...row.binding, operatorWire: JSON.stringify(declaration) } + }).ok + ).toBe(false); + }); + it('rejects owner/id/schema/revision violations and phases lacking immutable ciphertext', () => { + const row = prepared(); + for (const patch of [ + { schema: 2 }, + { family: 'private_send_operation' }, + { owner: peer }, + { id: row.rumorHash }, + { revision: -1 }, + { revision: 1.1 }, + { revision: Number.MAX_SAFE_INTEGER + 1 }, + { rumorHash: 'bad' }, + { createdAt: -1 }, + { createdAt: 1.5 }, + { revision: 0 }, + { self: null } + ]) + expect(decode({ ...row, ...patch }).ok).toBe(false); + expect(decode(row, peer).ok).toBe(false); + expect(decode(row, owner, row.rumorHash).ok).toBe(false); + expect(decode({ ...reservation(), receipts: [fact(row)] }).ok).toBe(false); + }); + it('requires independently signed strict own1059 and preserves full original bytes', () => { + const row = prepared(), + original = JSON.parse(row.self!.wire) as Record<string, unknown>; + for (const patch of [ + { kind: 14 }, + { kind: 13 }, + { sig: '0'.repeat(128) }, + { content: 'PRIVATE_PLAINTEXT_SENTINEL' }, + { + tags: [ + ['p', owner], + ['nonce', '1', '1'] + ] + }, + { tags: [['p', peer]] }, + { extra: true } + ]) + expect( + decode({ + ...row, + self: { ...row.self, wire: JSON.stringify({ ...original, ...patch }) } + }).ok + ).toBe(false); + expect(decode({ ...row, self: artifact(peer) }).ok).toBe(false); + expect( + decode({ ...row, self: { ...row.self, eventId: 'd'.repeat(64) } }).ok + ).toBe(false); + expect( + decode({ + ...row, + self: { ...row.self, wire: row.self!.wire + ' '.repeat(32768) } + }).ok + ).toBe(false); + const whitespace = { + ...row, + self: { ...row.self!, wire: row.self!.wire + '\n\t' } + }, + result = decode(whitespace); + expect(result.ok).toBe(true); + if (!result.ok) throw Error('valid exact wire rejected'); + expect(privateRecordSnapshot(result.value, owner, command)).toEqual( + whitespace + ); + }); + it('rejects relabelled ordinary roles, wrong targets/ids and non-exact readbacks', () => { + const row = prepared(); + for (const patch of [ + { actionId: 'bad' }, + { role: 'peer' }, + { role: 'self_archive' }, + { origin: readOrigin }, + { attempt: 0 }, + { attempt: 4 }, + { attempt: 1.1 }, + { eventId: 'd'.repeat(64) }, + { status: 'readback' }, + { observedAtMilliseconds: -1 }, + { readbackWire: row.self!.wire } + ]) + expect( + decode({ ...row, revision: 2, receipts: [{ ...fact(row), ...patch }] }) + .ok + ).toBe(false); + for (const patch of [ + { origin: archiveOrigin }, + { readbackWire: null }, + { readbackWire: row.self!.wire + '\n' }, + { status: 'accepted' }, + { status: 'nonce_verified', readbackWire: artifact().wire } + ]) + expect( + decode({ + ...row, + revision: 2, + receipts: [{ ...fact(row, 'readback'), ...patch }] + }).ok + ).toBe(false); + }); + it('rejects plaintext, unknown/missing fields and duplicate aliases at every nested level', () => { + const row = prepared(); + for (const key of [ + 'body', + 'nonce', + 'subject', + 'peer', + 'session', + 'verified' + ]) { + expect(decode({ ...row, [key]: 'PRIVATE_SENTINEL' }).ok).toBe(false); + expect( + decode({ + ...row, + binding: { ...row.binding, [key]: 'PRIVATE_SENTINEL' } + }).ok + ).toBe(false); + } + for (const key of Object.keys(row)) { + const broken: Record<string, unknown> = { ...row }; + delete broken[key]; + expect(decode(broken).ok).toBe(false); + } + for (const key of Object.keys(row.binding)) { + const broken: Record<string, unknown> = { ...row.binding }; + delete broken[key]; + expect(decode({ ...row, binding: broken }).ok).toBe(false); + } + const raw = JSON.stringify(row); + for (const duplicate of [ + raw.replace('"schema":1', '"schema":2,"schema":1'), + raw.replace( + '"preferenceId":', + '"\\u0070referenceId":"d","preferenceId":' + ), + raw.replace('"eventId":', '"eventId":"d","eventId":') + ]) + expect(decodePrivateRecord(duplicate, owner, command).ok).toBe(false); + for (const operatorWire of [ + JSON.stringify(operator()).replace( + '"revision":1', + '"revision":2,"revision":1' + ), + JSON.stringify(operator(), null, 2) + ]) + expect( + decode({ ...row, binding: { ...row.binding, operatorWire } }).ok + ).toBe(false); + }); +}); diff --git a/web/tools/check-output.mjs b/web/tools/check-output.mjs @@ -292,6 +292,8 @@ async function operationalFlagsAdmission(web) { 'c698313143943749bb457674825b648f6af29477f07cae960f3435c035cd6bd8', 'src/lib/config/operation-flags.ts': 'd5e0ce74a17de7a06100dcc75886616655fbd398c657027e7d6990d97aa8a0c1', + 'src/lib/config/inbox-operators.ts': + '52a4a739bf7434e3dea529858456ab49bbbbd517de789dac7f6407b687e5c07a', 'src/lib/config/relays.ts': 'ca8c63df89509728a7b87e65232f1da751621ed4777993a079730472a0923957', 'src/lib/config/support.ts': @@ -314,6 +316,8 @@ async function operationalFlagsAdmission(web) { '9cc82877bfa8dbb2a7fa41bceb842793349416271f19569f49fdd5cfc1de07e5', 'src/lib/messaging/inbox-setup-operation.ts': '245c6ce88b146dc731e7ace4f16dc9b5002a87a997f5568e4811b0c4a2daf035', + 'src/lib/nostr/self-recovery-reader.ts': + 'b15be31d13499b6e397f8b8dc691076e2b41b4157bf62013e5105cdd03875fa6', 'src/lib/nostr/private-pool.ts': 'b4c718364625b3caacbc5cc5f98bd79a575a5d66dddb2d7f59f03351a1308a6d', 'src/lib/nostr/inbox-ingress.ts': @@ -335,7 +339,7 @@ async function operationalFlagsAdmission(web) { 'src/lib/messaging/rumor-plan.ts': 'b622889e96f911501524cd86f9fca9f2207ce853767494fb30799b00ae8275ed', 'src/lib/persistence/private-send-reservations.ts': - '825188b71265162676d363ae25d98adfad0d3128c48012f993b2dad4a3161c32', + '5a57522fdb5acabecf836fb8d642a2adfb4bc7e041843b38fd1b96b673b3942d', 'src/lib/messaging/send-identity.ts': 'cc840afbf155e18030bea9b475884ca3e0068b79ef3da1459b661fe2822499df', 'src/lib/messaging/unlocked-session.ts': @@ -387,9 +391,11 @@ async function operationalFlagsAdmission(web) { 'src/lib/persistence/local-public-hides.ts': '4f0e64ed0fabbe9f86014a0512e7dbd3c81711f28ca2c626e2dafa5cda349f83', 'src/lib/persistence/private-records.ts': - 'a9a7c450808ea363594f2cce5d50c48b8a614197dd0b9690c4860d8387419dcf', + '2e5947e19df337ac1a7cd76b0f2cd6ec11cdb85d3fd38128e127fa8e3f30723a', + 'src/lib/persistence/private-sends.ts': + '6696f4179370cad373c06debf57b919598d53b3d25b6d2a6054a557608e4eb9c', 'src/lib/persistence/private-storage.ts': - '49b9ef328e569e93c2e88f4c0e8e3e927985fb9ac53daa6814b7471451b81104', + '66bab9a0a0a699b70ecba75c002ac0de20a84f3d015f5caefbe1697d0f6456bf', 'src/lib/persistence/public-publications.ts': 'be99c4114fb32880e0a9b48ab3593645532853fb4166fb506f398416db41a194', 'src/lib/persistence/public-receipts.ts': @@ -556,6 +562,8 @@ async function privacyDataAdmission(web) { '14443151ff819a11a4f9c71e4ff756d1fbdd7cf6c36242ac712c378e68583aa2', 'src/lib/config/deployment-support.ts': 'c698313143943749bb457674825b648f6af29477f07cae960f3435c035cd6bd8', + 'src/lib/config/inbox-operators.ts': + '52a4a739bf7434e3dea529858456ab49bbbbd517de789dac7f6407b687e5c07a', 'src/lib/config/relays.ts': 'ca8c63df89509728a7b87e65232f1da751621ed4777993a079730472a0923957', 'src/lib/config/support.ts': @@ -576,6 +584,8 @@ async function privacyDataAdmission(web) { 'be704e6cbe777722c3eb80ec9843f00afd7bac8c52af0c2af7294f2437414553', 'src/lib/messaging/inbox-list.ts': '9cc82877bfa8dbb2a7fa41bceb842793349416271f19569f49fdd5cfc1de07e5', + 'src/lib/nostr/self-recovery-reader.ts': + 'b15be31d13499b6e397f8b8dc691076e2b41b4157bf62013e5105cdd03875fa6', 'src/lib/nostr/private-pool.ts': 'b4c718364625b3caacbc5cc5f98bd79a575a5d66dddb2d7f59f03351a1308a6d', 'src/lib/nostr/inbox-ingress.ts': @@ -593,7 +603,7 @@ async function privacyDataAdmission(web) { 'src/lib/messaging/rumor-plan.ts': 'b622889e96f911501524cd86f9fca9f2207ce853767494fb30799b00ae8275ed', 'src/lib/persistence/private-send-reservations.ts': - '825188b71265162676d363ae25d98adfad0d3128c48012f993b2dad4a3161c32', + '5a57522fdb5acabecf836fb8d642a2adfb4bc7e041843b38fd1b96b673b3942d', 'src/lib/messaging/send-identity.ts': 'cc840afbf155e18030bea9b475884ca3e0068b79ef3da1459b661fe2822499df', 'src/lib/messaging/unlocked-session.ts': @@ -643,9 +653,11 @@ async function privacyDataAdmission(web) { 'src/lib/persistence/local-public-hides.ts': '4f0e64ed0fabbe9f86014a0512e7dbd3c81711f28ca2c626e2dafa5cda349f83', 'src/lib/persistence/private-records.ts': - 'a9a7c450808ea363594f2cce5d50c48b8a614197dd0b9690c4860d8387419dcf', + '2e5947e19df337ac1a7cd76b0f2cd6ec11cdb85d3fd38128e127fa8e3f30723a', + 'src/lib/persistence/private-sends.ts': + '6696f4179370cad373c06debf57b919598d53b3d25b6d2a6054a557608e4eb9c', 'src/lib/persistence/private-storage.ts': - '49b9ef328e569e93c2e88f4c0e8e3e927985fb9ac53daa6814b7471451b81104', + '66bab9a0a0a699b70ecba75c002ac0de20a84f3d015f5caefbe1697d0f6456bf', 'src/lib/persistence/public-publications.ts': 'be99c4114fb32880e0a9b48ab3593645532853fb4166fb506f398416db41a194', 'src/lib/persistence/public-receipts.ts': @@ -812,7 +824,7 @@ async function supportReportingAdmission(web) { 'src/lib/messaging/rumor-plan.ts': 'b622889e96f911501524cd86f9fca9f2207ce853767494fb30799b00ae8275ed', 'src/lib/persistence/private-send-reservations.ts': - '825188b71265162676d363ae25d98adfad0d3128c48012f993b2dad4a3161c32', + '5a57522fdb5acabecf836fb8d642a2adfb4bc7e041843b38fd1b96b673b3942d', 'src/lib/messaging/send-identity.ts': 'cc840afbf155e18030bea9b475884ca3e0068b79ef3da1459b661fe2822499df', 'src/lib/messaging/unlocked-session.ts': @@ -848,7 +860,7 @@ async function supportReportingAdmission(web) { 'src/lib/persistence/local-public-hides.ts': '4f0e64ed0fabbe9f86014a0512e7dbd3c81711f28ca2c626e2dafa5cda349f83', 'src/lib/persistence/private-storage.ts': - '49b9ef328e569e93c2e88f4c0e8e3e927985fb9ac53daa6814b7471451b81104', + '66bab9a0a0a699b70ecba75c002ac0de20a84f3d015f5caefbe1697d0f6456bf', 'src/lib/persistence/public-publications.ts': 'be99c4114fb32880e0a9b48ab3593645532853fb4166fb506f398416db41a194', 'src/lib/persistence/public-receipts.ts': @@ -1001,7 +1013,7 @@ async function privateBlockingAdmission(web) { 'src/lib/messaging/rumor-plan.ts': 'b622889e96f911501524cd86f9fca9f2207ce853767494fb30799b00ae8275ed', 'src/lib/persistence/private-send-reservations.ts': - '825188b71265162676d363ae25d98adfad0d3128c48012f993b2dad4a3161c32', + '5a57522fdb5acabecf836fb8d642a2adfb4bc7e041843b38fd1b96b673b3942d', 'src/lib/messaging/send-identity.ts': 'cc840afbf155e18030bea9b475884ca3e0068b79ef3da1459b661fe2822499df', 'src/lib/messaging/unlocked-session.ts': @@ -1035,7 +1047,7 @@ async function privateBlockingAdmission(web) { 'src/lib/persistence/local-public-hides.ts': '4f0e64ed0fabbe9f86014a0512e7dbd3c81711f28ca2c626e2dafa5cda349f83', 'src/lib/persistence/private-storage.ts': - '49b9ef328e569e93c2e88f4c0e8e3e927985fb9ac53daa6814b7471451b81104', + '66bab9a0a0a699b70ecba75c002ac0de20a84f3d015f5caefbe1697d0f6456bf', 'src/lib/persistence/public-publications.ts': 'be99c4114fb32880e0a9b48ab3593645532853fb4166fb506f398416db41a194', 'src/lib/persistence/public-receipts.ts': @@ -2158,7 +2170,7 @@ async function inboxPresentationAdmission(web) { 'src/lib/messaging/conversation-thread.ts': '7367f0e6d96a9f249514f66c2459274e856eb83462523e37264d4cd97d2e36d1', 'src/lib/persistence/private-storage.ts': - '49b9ef328e569e93c2e88f4c0e8e3e927985fb9ac53daa6814b7471451b81104', + '66bab9a0a0a699b70ecba75c002ac0de20a84f3d015f5caefbe1697d0f6456bf', 'src/routes/messages/[conversationId=local_id]/+page.svelte': 'b06c6189adee80b68bc6657fa0e8504551fe9a8b1655a6d81807ebee9930a5e7', 'src/lib/components/MessageComposer.svelte': @@ -2168,7 +2180,7 @@ async function inboxPresentationAdmission(web) { 'src/lib/messaging/rumor-plan.ts': 'b622889e96f911501524cd86f9fca9f2207ce853767494fb30799b00ae8275ed', 'src/lib/persistence/private-send-reservations.ts': - '825188b71265162676d363ae25d98adfad0d3128c48012f993b2dad4a3161c32', + '5a57522fdb5acabecf836fb8d642a2adfb4bc7e041843b38fd1b96b673b3942d', 'src/lib/messaging/send-identity.ts': 'cc840afbf155e18030bea9b475884ca3e0068b79ef3da1459b661fe2822499df', 'src/lib/components/ConversationOptions.svelte':