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