commit 96e6294d9440d9fe46cc06792b3a424f04dda30b
parent d3fd495e7b3c59ec396a8f89eb027ed9de0f3f3c
Author: triesap <tyson@radroots.org>
Date: Wed, 14 Oct 2026 08:57:31 +0000
web: Acknowledge the original inbox probe ciphertext
- Persist only a genuine current self probe under the owner lock and SDK slot.
- Verify native completion and fresh physical wire before issuing a local fact.
- Reject forged custody and preserve original artifacts through uncertain outcomes.
- Prove native lifecycle and quota failures with current and historical guards.
Diffstat:
7 files changed, 1291 insertions(+), 4 deletions(-)
diff --git a/web/src/lib/persistence/inbox-probes.ts b/web/src/lib/persistence/inbox-probes.ts
@@ -0,0 +1,311 @@
+import {
+ inboxProbeGiftwrapSnapshot,
+ inboxProbeGiftwrapSeal,
+ type InboxProbeGiftwrap
+} from '../nostr/giftwrap-builder.ts';
+import { inboxProbeSealIdentity } from '../nostr/seal-builder.ts';
+import {
+ inboxProbeSnapshot,
+ inboxProbeRumorWire,
+ inboxProbeReservationHandle,
+ type InboxProbeIdentity
+} from '../nostr/inbox-access.ts';
+import {
+ privateSessionOwnership,
+ withIdlePrivateLocalStorage,
+ type PrivateSession
+} from '../runtime/private-session.ts';
+import {
+ privateStorageOwner,
+ commitPrivateRecord,
+ observePrivateRecord,
+ type PrivateStorageRepository,
+ type PrivateStorageFailure
+} from './private-storage.ts';
+import {
+ decodePrivateRecord,
+ privateRecordWire,
+ type PrivateAccessProbe
+} from './private-records.ts';
+import {
+ verifyEnvelope,
+ verifiedEnvelopeSnapshot
+} from '../nostr/verified-envelope.ts';
+
+declare const acknowledgementBrand: unique symbol;
+export type InboxProbeAcknowledgement = Readonly<{
+ [acknowledgementBrand]: true;
+}>;
+export type InboxProbeCommitResult =
+ | Readonly<{
+ status: 'prepared' | 'existing' | 'reconciled';
+ acknowledgement: InboxProbeAcknowledgement;
+ }>
+ | Readonly<{
+ status: PrivateStorageFailure | 'invalid' | 'busy' | 'stopped';
+ disposition: 'original_protected';
+ }>;
+type Saved = Readonly<{
+ repository: PrivateStorageRepository;
+ session: PrivateSession;
+ identity: InboxProbeIdentity;
+ record: PrivateAccessProbe;
+ wire: string;
+ current(): boolean;
+ revoke(): void;
+}>;
+const acknowledgements = new WeakMap<InboxProbeAcknowledgement, Saved>();
+const actions = new WeakMap<
+ InboxProbeGiftwrap,
+ Readonly<{
+ repository: PrivateStorageRepository;
+ session: PrivateSession;
+ pending(): boolean;
+ }>
+>();
+const refuse = (
+ status: PrivateStorageFailure | 'invalid' | 'busy' | 'stopped'
+): InboxProbeCommitResult => ({ status, disposition: 'original_protected' });
+
+// This owner accepts only the original genuine construction chain. Decoding a
+// row, copying a snapshot or supplying the same public key grants no authority.
+function input(
+ repository: PrivateStorageRepository,
+ session: PrivateSession,
+ wrap: InboxProbeGiftwrap
+) {
+ const artifact = inboxProbeGiftwrapSnapshot(wrap),
+ seal = inboxProbeGiftwrapSeal(wrap),
+ identity = seal && inboxProbeSealIdentity(seal),
+ reservation = identity && inboxProbeSnapshot(identity),
+ handle = identity && inboxProbeReservationHandle(identity),
+ ownership = privateSessionOwnership(session);
+ if (
+ !artifact ||
+ !identity ||
+ !reservation ||
+ !handle ||
+ !ownership?.current() ||
+ !inboxProbeRumorWire(identity, session) ||
+ privateStorageOwner(repository) !== ownership.owner ||
+ reservation.owner !== ownership.owner ||
+ artifact.owner !== reservation.owner ||
+ artifact.destination !== reservation.owner ||
+ artifact.command !== reservation.id ||
+ artifact.rumorHash !== reservation.rumorHash ||
+ artifact.createdAt !== reservation.createdAt
+ )
+ return undefined;
+ const verified = verifyEnvelope(artifact.wire),
+ event = verified.ok && verifiedEnvelopeSnapshot(verified.value),
+ reservationWire = privateRecordWire(
+ handle,
+ reservation.owner,
+ reservation.id
+ );
+ if (
+ !event ||
+ !reservationWire ||
+ event.kind !== 1059 ||
+ JSON.stringify(event.tags) !== JSON.stringify([['p', reservation.owner]])
+ )
+ return undefined;
+ const record: PrivateAccessProbe = {
+ ...reservation,
+ revision: 1,
+ self: { eventId: event.id, wire: artifact.wire },
+ receipts: []
+ },
+ decoded = decodePrivateRecord(
+ JSON.stringify(record),
+ reservation.owner,
+ reservation.id
+ );
+ if (!decoded.ok) return undefined;
+ const wire = privateRecordWire(
+ decoded.value,
+ reservation.owner,
+ reservation.id
+ );
+ if (!wire) return undefined;
+ const frozenReservation = JSON.stringify(reservation),
+ frozenArtifact = JSON.stringify(artifact);
+ function current() {
+ return (
+ ownership!.current() &&
+ !!inboxProbeRumorWire(identity!, session) &&
+ privateStorageOwner(repository) === reservation!.owner &&
+ JSON.stringify(inboxProbeSnapshot(identity!)) === frozenReservation &&
+ JSON.stringify(inboxProbeGiftwrapSnapshot(wrap)) === frozenArtifact
+ );
+ }
+ return current()
+ ? {
+ identity,
+ reservation,
+ reservationWire,
+ record,
+ handle: decoded.value,
+ wire,
+ current
+ }
+ : undefined;
+}
+
+// Native completion and a separate physical-wire observation are necessary.
+// This local acknowledgement permits neither EVENT nor readiness or cleanup.
+export async function commitInboxProbe(
+ repository: PrivateStorageRepository,
+ session: PrivateSession,
+ wrap: InboxProbeGiftwrap,
+ review: unknown
+): Promise<InboxProbeCommitResult> {
+ if (
+ typeof window === 'undefined' ||
+ review !== 'reviewed_inbox_probe_commit' ||
+ typeof wrap !== 'object' ||
+ wrap === null
+ )
+ return refuse('invalid');
+ const prior = actions.get(wrap);
+ if (prior?.pending()) return refuse('busy');
+ if (prior && (prior.repository !== repository || prior.session !== session))
+ return refuse('invalid_scope');
+ let pending = true;
+ let captured: ReturnType<typeof input>;
+ try {
+ actions.set(wrap, { repository, session, pending: () => pending });
+ captured = input(repository, session, wrap);
+ if (!captured) return refuse('invalid');
+ const original = captured;
+ if (!navigator.locks?.request) return refuse('unavailable');
+ return await navigator.locks.request(
+ 'harvestcircle:owner:' + original.reservation.owner,
+ { mode: 'exclusive', ifAvailable: true },
+ async (lock) => {
+ if (!lock) return refuse('busy');
+ if (!original.current()) return refuse('stopped');
+ const idle = await withIdlePrivateLocalStorage(
+ session,
+ async (): Promise<InboxProbeCommitResult> => {
+ if (!original.current()) return refuse('stopped');
+ const { owner, id } = original.reservation,
+ loaded = await observePrivateRecord(
+ repository,
+ 'private_sends',
+ id
+ );
+ if (!original.current()) return refuse('stopped');
+ if (!loaded.ok) return refuse(loaded.reason);
+ let status: 'prepared' | 'existing' | 'reconciled';
+ if (loaded.value.wire === original.wire) {
+ status = 'existing';
+ } else {
+ if (loaded.value.wire !== original.reservationWire)
+ return refuse('conflict');
+ const committed = await commitPrivateRecord(
+ repository,
+ original.handle,
+ loaded.value.handle
+ );
+ if (!original.current()) return refuse('stopped');
+ if (!committed.ok && committed.reason !== 'unknown_completion')
+ return refuse(committed.reason);
+ status = !committed.ok
+ ? 'reconciled'
+ : committed.value.state === 'existing'
+ ? 'existing'
+ : 'prepared';
+ }
+ const readback = await observePrivateRecord(
+ repository,
+ 'private_sends',
+ id
+ );
+ if (!original.current()) return refuse('stopped');
+ if (!readback.ok) return refuse(readback.reason);
+ if (readback.value.wire !== original.wire)
+ return refuse('conflict');
+ // The handle and physical wire have both passed complete-owner
+ // validation. Their equality is checked independently of metadata
+ // normalization; equivalent raw JSON changes cannot be hidden.
+ if (
+ privateRecordWire(readback.value.handle, owner, id) !==
+ original.wire
+ )
+ return refuse('conflict');
+ const acknowledgement = Object.freeze(
+ {}
+ ) as InboxProbeAcknowledgement;
+ let revoked = false;
+ acknowledgements.set(acknowledgement, {
+ repository,
+ session,
+ identity: original.identity,
+ record: original.record,
+ wire: original.wire,
+ current: () => !revoked && original.current(),
+ revoke: () => {
+ revoked = true;
+ }
+ });
+ return { status, acknowledgement };
+ }
+ );
+ return idle.ok
+ ? idle.value
+ : refuse(original.current() ? 'busy' : 'stopped');
+ }
+ );
+ } catch {
+ return refuse(
+ captured ? (captured.current() ? 'unavailable' : 'stopped') : 'invalid'
+ );
+ } finally {
+ pending = false;
+ if (!captured && !prior) actions.delete(wrap);
+ }
+}
+
+export function inboxProbeAcknowledgementSnapshot(
+ acknowledgement: InboxProbeAcknowledgement
+) {
+ const saved = acknowledgements.get(acknowledgement);
+ return saved?.current()
+ ? {
+ record: JSON.parse(JSON.stringify(saved.record)) as PrivateAccessProbe,
+ fact: 'acknowledged_local_probe_ciphertext_only' as const
+ }
+ : undefined;
+}
+
+export async function verifyInboxProbeAcknowledgement(
+ repository: PrivateStorageRepository,
+ session: PrivateSession,
+ acknowledgement: InboxProbeAcknowledgement
+): Promise<boolean> {
+ const saved = acknowledgements.get(acknowledgement);
+ if (
+ !saved ||
+ saved.repository !== repository ||
+ saved.session !== session ||
+ !saved.current()
+ )
+ return false;
+ const readback = await observePrivateRecord(
+ repository,
+ 'private_sends',
+ saved.record.id
+ );
+ const valid =
+ saved.current() &&
+ readback.ok &&
+ readback.value.wire === saved.wire &&
+ privateRecordWire(
+ readback.value.handle,
+ saved.record.owner,
+ saved.record.id
+ ) === saved.wire;
+ if (!valid) saved.revoke();
+ return valid;
+}
diff --git a/web/src/lib/persistence/private-storage.ts b/web/src/lib/persistence/private-storage.ts
@@ -559,6 +559,36 @@ export function retainPrivateReceivedRecord(
);
}
+// Observe only the selected validated row after actual native completion. The
+// handle normalizes metadata; wire is the original physical stored string.
+// Whole-wire custody owners must compare wire, not the normalized handle alone.
+export function observePrivateRecord(
+ repository: PrivateStorageRepository,
+ store: Store,
+ id: unknown
+): Promise<
+ PrivateStorageResult<Readonly<{ handle: PrivateRecordHandle; wire: string }>>
+> {
+ const scope = scopeOf(repository);
+ if (!scope) return Promise.resolve(failed('invalid_scope'));
+ if (
+ (store !== 'private_sends' && store !== 'received_envelopes') ||
+ typeof id !== 'string'
+ )
+ return Promise.resolve(failed('invalid_record'));
+ return transaction<Readonly<{ handle: PrivateRecordHandle; wire: string }>>(
+ scope,
+ store,
+ 'readonly',
+ (rows) => {
+ const row = rows.find((row) => row.record.id === id);
+ return row
+ ? { ok: true, value: { handle: row.handle, wire: row.wire } }
+ : failed('invalid_record');
+ }
+ );
+}
+
export function loadPrivateRecord(
repository: PrivateStorageRepository,
store: Store,
diff --git a/web/tests/e2e/harness/inbox-probe.ts b/web/tests/e2e/harness/inbox-probe.ts
@@ -42,6 +42,12 @@ import {
type InboxProbeGiftwrap
} from '../../../src/lib/nostr/giftwrap-builder.ts';
import {
+ commitInboxProbe,
+ inboxProbeAcknowledgementSnapshot,
+ type InboxProbeAcknowledgement
+} from '../../../src/lib/persistence/inbox-probes.ts';
+import { decodePrivateRecord } from '../../../src/lib/persistence/private-records.ts';
+import {
getEventHash,
generateSecretKey,
getPublicKey,
@@ -56,6 +62,10 @@ export * from '../../../src/lib/nostr/verify-outbound-envelope.ts';
export * from '../../../src/lib/messaging/inbox-access-controller.ts';
export * from '../../../src/lib/messaging/send-identity.ts';
export * from '../../../src/lib/runtime/private-session.ts';
+export * from '../../../src/lib/persistence/inbox-probes.ts';
+export * from '../../../src/lib/persistence/private-storage.ts';
+export * from '../../../src/lib/persistence/private-records.ts';
+export * from '../../../src/lib/persistence/private-sends.ts';
export type Mode =
| 'normal'
| 'hold_key'
@@ -109,6 +119,7 @@ export async function makeProbeFixture() {
operation: InboxProbeSealOperation | undefined,
seal: InboxProbeRecipientSeal | undefined,
wrap: InboxProbeGiftwrap | undefined;
+ let acknowledgement: InboxProbeAcknowledgement | undefined;
async function pause(stage: string) {
if (mode !== 'hold_' + stage) return;
waiting = stage;
@@ -216,6 +227,21 @@ export async function makeProbeFixture() {
}
);
}
+ async function inject(rows: { owner: string; id: string; wire: string }[]) {
+ const tx = browserDatabaseTransaction(
+ database,
+ ['private_sends'],
+ 'readwrite'
+ );
+ const store = tx.objectStore('private_sends');
+ for (const row of rows) store.put(row);
+ await new Promise<void>((resolve, reject) => {
+ tx.addEventListener('complete', () => resolve());
+ tx.addEventListener('abort', () =>
+ reject(Error('controlled injection abort'))
+ );
+ });
+ }
return {
...base,
repository,
@@ -256,6 +282,24 @@ export async function makeProbeFixture() {
operation: () => operation,
seal: () => seal,
wrap: () => wrap,
+ acknowledgement: () => acknowledgement,
+ async commitOriginal(review: unknown = 'reviewed_inbox_probe_commit') {
+ if (!wrap) throw Error('missing genuine original wrap');
+ const result = await commitInboxProbe(
+ repository,
+ base.session,
+ wrap,
+ review
+ );
+ if ('acknowledgement' in result) acknowledgement = result.acknowledgement;
+ return {
+ status: result.status,
+ snapshot:
+ 'acknowledgement' in result
+ ? inboxProbeAcknowledgementSnapshot(result.acknowledgement)
+ : undefined
+ };
+ },
mode(next: Mode) {
mode = next;
},
@@ -263,7 +307,115 @@ export async function makeProbeFixture() {
settle: () => release?.(),
counts: () => ({ keys, encrypts, decrypts, signs }),
stored,
- async fillCapacity() {
+ inject,
+ async removeOriginal() {
+ if (!identity) throw Error('missing genuine original');
+ const record = inboxProbeSnapshot(identity);
+ if (!record) throw Error('stale actual original');
+ const tx = browserDatabaseTransaction(
+ database,
+ ['private_sends'],
+ 'readwrite'
+ );
+ tx.objectStore('private_sends').delete([base.owner, record.id]);
+ await new Promise<void>((resolve, reject) => {
+ tx.addEventListener('complete', () => resolve());
+ tx.addEventListener('abort', () =>
+ reject(Error('controlled removal abort'))
+ );
+ });
+ },
+ installCommitCompletion(action: () => void) {
+ const original = Object.getOwnPropertyDescriptor(
+ IDBDatabase.prototype,
+ 'transaction'
+ )?.value as IDBDatabase['transaction'];
+ let fired = false;
+ IDBDatabase.prototype.transaction = function (
+ ...args: Parameters<IDBDatabase['transaction']>
+ ) {
+ const tx = original.apply(this, args);
+ if (
+ !fired &&
+ args[1] === 'readwrite' &&
+ tx.objectStoreNames.contains('private_sends')
+ ) {
+ fired = true;
+ tx.addEventListener('complete', action);
+ }
+ return tx;
+ };
+ return () => {
+ IDBDatabase.prototype.transaction = original;
+ };
+ },
+ async fillProbeByteHeadroom() {
+ if (!identity || !wrap) throw Error('missing genuine original');
+ const record = inboxProbeSnapshot(identity),
+ artifact = inboxProbeGiftwrapSnapshot(wrap);
+ if (!record || !artifact) throw Error('stale genuine original');
+ const self = {
+ eventId: (JSON.parse(artifact.wire) as { id: string }).id,
+ wire: artifact.wire
+ };
+ // Strict structural filler metadata is not actual transport/nonce evidence.
+ const filler = {
+ ...record,
+ id: crypto.randomUUID(),
+ revision: 1,
+ self,
+ receipts: [] as unknown[]
+ };
+ const fact = {
+ actionId: crypto.randomUUID(),
+ origin: record.binding.archiveTargets[0],
+ role: 'access_archive',
+ attempt: 1,
+ eventId: self.eventId,
+ status: 'accepted',
+ observedAtMilliseconds: 1,
+ readbackWire: null
+ };
+ const originalRows = await stored();
+ const physicalBytes = (rows: typeof originalRows) =>
+ rows.reduce(
+ (n, row) => n + new TextEncoder().encode(JSON.stringify(row)).length,
+ 0
+ );
+ const baseBytes = physicalBytes(originalRows);
+ const prepared = JSON.stringify({ ...record, revision: 1, self });
+ const growth =
+ physicalBytes([{ owner: base.owner, id: record.id, wire: prepared }]) -
+ baseBytes;
+ const rowAt = (n: number) => ({
+ owner: base.owner,
+ id: filler.id,
+ wire: JSON.stringify({
+ ...filler,
+ receipts: Array.from({ length: n }, () => fact)
+ })
+ });
+ const cap = 8 * 1024 * 1024;
+ const factBytes = physicalBytes([rowAt(1)]) - physicalBytes([rowAt(0)]);
+ let low = 0,
+ high = Math.floor(cap / factBytes) + 2;
+ while (low + 1 < high) {
+ const mid = Math.floor((low + high) / 2);
+ if (baseBytes + physicalBytes([rowAt(mid)]) <= cap) low = mid;
+ else high = mid;
+ }
+ const row = rowAt(low);
+ const strict = decodePrivateRecord(row.wire, row.owner, row.id);
+ if (!strict.ok) throw Error('filler must decode strictly');
+ await inject([row]);
+ const before = await stored(),
+ bytes = physicalBytes(before),
+ headroom = cap - bytes;
+ if (headroom < 0 || headroom >= growth || before.length >= 100)
+ throw Error('actual physical growth boundary missing');
+ return { bytes, headroom, growth, count: before.length };
+ },
+ async fillCapacity(count = 100) {
const secret = generateSecretKey(),
peer = getPublicKey(secret);
secret.fill(0);
@@ -273,7 +425,7 @@ export async function makeProbeFixture() {
'readwrite'
),
store = tx.objectStore('private_sends');
- for (let i = 0; i < 100; i++) {
+ for (let i = 0; i < count; i++) {
const id = crypto.randomUUID();
store.put({
owner: base.owner,
@@ -318,6 +470,61 @@ export async function makeProbeFixture() {
IDBObjectStore.prototype.put = original;
};
},
+ installUncertainCommit() {
+ const put = Object.getOwnPropertyDescriptor(
+ IDBObjectStore.prototype,
+ 'put'
+ )?.value as IDBObjectStore['put'];
+ const abort = Object.getOwnPropertyDescriptor(
+ IDBTransaction.prototype,
+ 'abort'
+ )?.value as IDBTransaction['abort'];
+ let selected: IDBTransaction | undefined,
+ nativeComplete = 0,
+ nativeAbort = 0,
+ putSuccess = 0,
+ abortRefused = 0;
+ IDBTransaction.prototype.abort = function (
+ ...args: Parameters<IDBTransaction['abort']>
+ ) {
+ if (this === selected) {
+ abortRefused++;
+ throw Error('controlled abort refusal');
+ }
+ return abort.apply(this, args);
+ };
+ IDBObjectStore.prototype.put = function (
+ ...args: Parameters<IDBObjectStore['put']>
+ ) {
+ const request = put.apply(this, args);
+ if (!selected && this.name === 'private_sends') {
+ selected = this.transaction;
+ selected.addEventListener('complete', () => {
+ nativeComplete++;
+ });
+ selected.addEventListener('abort', () => {
+ nativeAbort++;
+ });
+ request.addEventListener('success', () => {
+ putSuccess++;
+ });
+ throw Error('controlled failure after actual native put admission');
+ }
+ return request;
+ };
+ return {
+ counts: () => ({
+ nativeComplete,
+ nativeAbort,
+ putSuccess,
+ abortRefused
+ }),
+ restore: () => {
+ IDBObjectStore.prototype.put = put;
+ IDBTransaction.prototype.abort = abort;
+ }
+ };
+ },
installChangedReadback() {
const original = Object.getOwnPropertyDescriptor(
IDBDatabase.prototype,
diff --git a/web/tests/e2e/inbox-probe.spec.ts b/web/tests/e2e/inbox-probe.spec.ts
@@ -644,3 +644,600 @@ for (const stage of ['key', 'encrypt', 'decrypt', 'sign'] as const) {
});
}
}
+
+test('S4A genuine persistence acknowledges only the exact native original ciphertext without provider or transport work', async ({
+ page
+}) => {
+ await page.evaluate(() => window.p8Fixture.reserve());
+ expect(await page.evaluate(() => window.p8Fixture.prepare())).toBe('wrapped');
+ const result = await page.evaluate(async () => {
+ const f = window.p8Fixture,
+ api = window.p8,
+ before = f.counts();
+ const result = await f.commitOriginal();
+ const ack = f.acknowledgement()!;
+ const snapshot = api.inboxProbeAcknowledgementSnapshot(ack)!;
+ const observed = await api.observePrivateRecord(
+ f.repository,
+ 'private_sends',
+ snapshot.record.id
+ );
+ const rumor = JSON.parse(
+ api.inboxProbeRumorWire(f.probeIdentity()!, f.session)!
+ ) as { content: string };
+ const rows = await f.stored();
+ const firstWire = JSON.stringify(rows);
+ (snapshot.record.binding.readTargets as string[]).pop();
+ const repeat = await f.commitOriginal();
+ return {
+ status: result.status,
+ fact: result.snapshot?.fact,
+ row: result.snapshot?.record,
+ exact: observed.ok && observed.value.wire === rows[0].wire,
+ verified: await api.verifyInboxProbeAcknowledgement(
+ f.repository,
+ f.session,
+ ack
+ ),
+ repeated: repeat.status,
+ unchanged: firstWire === JSON.stringify(await f.stored()),
+ bodyAbsent:
+ !firstWire.includes(rumor.content) &&
+ !firstWire.includes(rumor.content.slice(-64)),
+ ordinaryRejected:
+ api.pairedDeliveryAcknowledgementSnapshot(
+ ack as unknown as Parameters<
+ typeof api.pairedDeliveryAcknowledgementSnapshot
+ >[0]
+ ) === undefined,
+ detached:
+ api.inboxProbeAcknowledgementSnapshot(ack)?.record.binding.readTargets
+ .length === 1,
+ before,
+ after: f.counts()
+ };
+ });
+ expect(result.status).toBe('prepared');
+ expect(result.fact).toBe('acknowledged_local_probe_ciphertext_only');
+ expect(result.row).toMatchObject({
+ family: 'private_access_probe',
+ revision: 1,
+ receipts: [],
+ self: { eventId: expect.any(String), wire: expect.any(String) }
+ });
+ expect(result.repeated).toBe('existing');
+ expect(
+ result.exact &&
+ result.verified &&
+ result.unchanged &&
+ result.bodyAbsent &&
+ result.ordinaryRejected &&
+ result.detached
+ ).toBe(true);
+ expect(result.before).toEqual(result.after);
+ expect(
+ frames.some((frame) => ['EVENT', 'AUTH'].includes(String(frame[0])))
+ ).toBe(false);
+});
+
+test('S4A simultaneous same-wrap calls admit one native original and return busy for the pending duplicate', async ({
+ page
+}) => {
+ await page.evaluate(() => window.p8Fixture.reserve());
+ await page.evaluate(() => window.p8Fixture.prepare());
+ const result = await page.evaluate(async () => {
+ const f = window.p8Fixture,
+ api = window.p8,
+ before = f.counts();
+ const results = await Promise.all(
+ [1, 2].map(() =>
+ api.commitInboxProbe(
+ f.repository,
+ f.session,
+ f.wrap()!,
+ 'reviewed_inbox_probe_commit'
+ )
+ )
+ );
+ return {
+ statuses: results.map((r) => r.status).sort(),
+ rows: (await f.stored()).length,
+ before,
+ after: f.counts()
+ };
+ });
+ expect(result.statuses).toEqual(['busy', 'prepared']);
+ expect(result.rows).toBe(1);
+ expect(result.before).toEqual(result.after);
+});
+
+test('S4A forged wraps, wrong consent and genuine alternate namespace/session cannot borrow the original', async ({
+ page
+}) => {
+ await page.evaluate(() => window.p8Fixture.reserve());
+ await page.evaluate(() => window.p8Fixture.prepare());
+ const result = await page.evaluate(async () => {
+ const f = window.p8Fixture,
+ api = window.p8;
+ const other = await f.foreignSession(),
+ before = f.counts(),
+ rows = await f.stored();
+ const wrap = f.wrap()!,
+ copy = api.inboxProbeGiftwrapSnapshot(wrap)!;
+ const results = [
+ await api.commitInboxProbe(
+ f.foreignRepository(),
+ f.session,
+ wrap,
+ 'reviewed_inbox_probe_commit'
+ ),
+ await api.commitInboxProbe(
+ f.repository,
+ other,
+ wrap,
+ 'reviewed_inbox_probe_commit'
+ ),
+ await api.commitInboxProbe(
+ f.repository,
+ f.session,
+ copy as unknown as typeof wrap,
+ 'reviewed_inbox_probe_commit'
+ ),
+ await api.commitInboxProbe(
+ f.repository,
+ f.session,
+ wrap,
+ 'reviewed_private_delivery'
+ ),
+ await api.commitInboxProbe(
+ f.repository,
+ f.session,
+ f.seal()! as unknown as typeof wrap,
+ 'reviewed_inbox_probe_commit'
+ )
+ ];
+ const genuine = await f.commitOriginal();
+ const primitiveStatuses = [];
+ for (const primitive of [null, 0, 'wrap', true]) {
+ primitiveStatuses.push(
+ (
+ await api.commitInboxProbe(
+ f.repository,
+ f.session,
+ primitive as unknown as typeof wrap,
+ 'reviewed_inbox_probe_commit'
+ )
+ ).status
+ );
+ }
+ const ack = f.acknowledgement()!;
+ return {
+ statuses: results.map((r) => r.status),
+ primitiveStatuses,
+ originalWasProtected: rows[0].wire.includes('"self":null'),
+ genuine: genuine.status,
+ forgedAck: await api.verifyInboxProbeAcknowledgement(
+ f.repository,
+ f.session,
+ genuine.snapshot as unknown as typeof ack
+ ),
+ foreign: await api.verifyInboxProbeAcknowledgement(
+ f.foreignRepository(),
+ f.session,
+ ack
+ ),
+ other: await api.verifyInboxProbeAcknowledgement(
+ f.repository,
+ other,
+ ack
+ ),
+ actual: await api.verifyInboxProbeAcknowledgement(
+ f.repository,
+ f.session,
+ ack
+ ),
+ before,
+ after: f.counts()
+ };
+ });
+ expect(result.statuses).toEqual([
+ 'invalid',
+ 'invalid',
+ 'invalid',
+ 'invalid',
+ 'invalid'
+ ]);
+ expect(result.primitiveStatuses).toEqual([
+ 'invalid',
+ 'invalid',
+ 'invalid',
+ 'invalid'
+ ]);
+ expect(result.originalWasProtected).toBe(true);
+ expect(result.genuine).toBe('prepared');
+ expect(result.forgedAck || result.foreign || result.other).toBe(false);
+ expect(result.actual).toBe(true);
+ expect(result.before).toEqual(result.after);
+});
+
+test('S4A actual owner lock and SDK slot contention preserve the native reservation for an explicit original retry', async ({
+ page
+}) => {
+ await page.evaluate(() => window.p8Fixture.reserve());
+ await page.evaluate(() => window.p8Fixture.prepare());
+ const result = await page.evaluate(async () => {
+ const f = window.p8Fixture,
+ api = window.p8,
+ rows = JSON.stringify(await f.stored()),
+ before = f.counts();
+ let releaseLock = () => {},
+ entered = () => {};
+ const enteredPromise = new Promise<void>((resolve) => {
+ entered = resolve;
+ });
+ const held = navigator.locks.request(
+ 'harvestcircle:owner:' + f.owner,
+ async () => {
+ entered();
+ await new Promise<void>((resolve) => {
+ releaseLock = resolve;
+ });
+ }
+ );
+ await enteredPromise;
+ const lock = await f.commitOriginal();
+ releaseLock();
+ await held;
+ let releaseSlot = () => {},
+ slotEntered = () => {};
+ const slotPromise = new Promise<void>((resolve) => {
+ slotEntered = resolve;
+ });
+ const slot = api.withIdlePrivateLocalStorage(f.session, async () => {
+ slotEntered();
+ await new Promise<void>((resolve) => {
+ releaseSlot = resolve;
+ });
+ });
+ await slotPromise;
+ const busy = await f.commitOriginal();
+ const unchanged = rows === JSON.stringify(await f.stored());
+ releaseSlot();
+ await slot;
+ const original = await f.commitOriginal();
+ return {
+ lock: lock.status,
+ busy: busy.status,
+ unchanged,
+ original: original.status,
+ before,
+ after: f.counts()
+ };
+ });
+ expect(result).toMatchObject({
+ lock: 'busy',
+ busy: 'busy',
+ unchanged: true,
+ original: 'prepared'
+ });
+ expect(result.before).toEqual(result.after);
+});
+
+test('S4A put success followed by native abort cannot issue a saved fact or alter the original reservation', async ({
+ page
+}) => {
+ await page.evaluate(() => window.p8Fixture.reserve());
+ await page.evaluate(() => window.p8Fixture.prepare());
+ const before = await page.evaluate(() => window.p8Fixture.stored());
+ await page.evaluate(() => {
+ window.p8Restore = window.p8Fixture.installNativeAbort();
+ });
+ expect(await page.evaluate(() => window.p8Fixture.commitOriginal())).toEqual({
+ status: 'aborted',
+ snapshot: undefined
+ });
+ expect(await page.evaluate(() => window.p8Fixture.stored())).toEqual(before);
+ expect(
+ await page.evaluate(() => window.p8Fixture.acknowledgement())
+ ).toBeUndefined();
+ await page.evaluate(() => {
+ window.p8Restore?.();
+ window.p8Restore = undefined;
+ });
+ expect(
+ await page.evaluate(() => window.p8Fixture.commitOriginal())
+ ).toMatchObject({ status: 'prepared' });
+});
+
+test('S4A genuine uncertain native completion reconciles the exact original once without rebuilding crypto', async ({
+ page
+}) => {
+ await page.evaluate(() => window.p8Fixture.reserve());
+ await page.evaluate(() => window.p8Fixture.prepare());
+ const result = await page.evaluate(async () => {
+ const f = window.p8Fixture,
+ api = window.p8,
+ before = f.counts();
+ const uncertain = f.installUncertainCommit();
+ window.p8Restore = uncertain.restore;
+ try {
+ const result = await f.commitOriginal();
+ const firstRows = JSON.stringify(await f.stored());
+ const ack = f.acknowledgement()!;
+ const verified = await api.verifyInboxProbeAcknowledgement(
+ f.repository,
+ f.session,
+ ack
+ );
+ uncertain.restore();
+ window.p8Restore = undefined;
+ const repeated = await f.commitOriginal();
+ return {
+ status: result.status,
+ verified,
+ counts: uncertain.counts(),
+ repeated: repeated.status,
+ exactOriginal: firstRows === JSON.stringify(await f.stored()),
+ before,
+ after: f.counts()
+ };
+ } finally {
+ uncertain.restore();
+ window.p8Restore = undefined;
+ }
+ });
+ expect(result).toMatchObject({
+ status: 'reconciled',
+ verified: true,
+ repeated: 'existing',
+ exactOriginal: true,
+ counts: {
+ nativeComplete: 1,
+ nativeAbort: 0,
+ putSuccess: 1,
+ abortRefused: 1
+ }
+ });
+ expect(result.before).toEqual(result.after);
+});
+
+for (const close of ['controller', 'session', 'head'] as const) {
+ test(`S4A ${close} loss at actual native completion protects saved ciphertext but issues no live acknowledgement`, async ({
+ page
+ }) => {
+ await page.evaluate(() => window.p8Fixture.reserve());
+ await page.evaluate(() => window.p8Fixture.prepare());
+ await page.evaluate((close) => {
+ const f = window.p8Fixture;
+ window.p8Restore = f.installCommitCompletion(() => {
+ if (close === 'controller')
+ window.p8.closeInboxAccessController(f.controller()!);
+ else if (close === 'session') f.closeSession();
+ else f.churnHead();
+ });
+ }, close);
+ expect(
+ await page.evaluate(() => window.p8Fixture.commitOriginal())
+ ).toEqual({ status: 'stopped', snapshot: undefined });
+ const rows = await page.evaluate(() => window.p8Fixture.stored());
+ expect(rows).toHaveLength(1);
+ expect(JSON.parse(rows[0].wire)).toMatchObject({
+ revision: 1,
+ self: { wire: expect.any(String) }
+ });
+ expect(
+ await page.evaluate(() => window.p8Fixture.acknowledgement())
+ ).toBeUndefined();
+ expect(
+ frames.some((frame) => ['EVENT', 'AUTH'].includes(String(frame[0])))
+ ).toBe(false);
+ });
+}
+
+test('S4A physical whitespace aliases remain detectable despite identical decoded canonical metadata', async ({
+ page
+}) => {
+ await page.evaluate(() => window.p8Fixture.reserve());
+ await page.evaluate(() => window.p8Fixture.prepare());
+ const result = await page.evaluate(async () => {
+ const f = window.p8Fixture,
+ api = window.p8;
+ await f.commitOriginal();
+ const ack = f.acknowledgement()!,
+ row = (await f.stored())[0];
+ const before = await api.loadPrivateRecord(
+ f.repository,
+ 'private_sends',
+ row.id
+ );
+ await f.inject([{ ...row, wire: ' ' + row.wire + '\n' }]);
+ const after = await api.loadPrivateRecord(
+ f.repository,
+ 'private_sends',
+ row.id
+ );
+ const observed = await api.observePrivateRecord(
+ f.repository,
+ 'private_sends',
+ row.id
+ );
+ const canonicalSame =
+ before.ok &&
+ after.ok &&
+ api.privateRecordWire(before.value, f.owner, row.id) ===
+ api.privateRecordWire(after.value, f.owner, row.id);
+ const verified = await api.verifyInboxProbeAcknowledgement(
+ f.repository,
+ f.session,
+ ack
+ );
+ const revoked = api.inboxProbeAcknowledgementSnapshot(ack) === undefined;
+ const retry = await f.commitOriginal();
+ return {
+ canonicalSame,
+ actualChanged: observed.ok && observed.value.wire !== row.wire,
+ verified,
+ revoked,
+ retry: retry.status,
+ count: (await f.stored()).length
+ };
+ });
+ expect(result).toEqual({
+ canonicalSame: true,
+ actualChanged: true,
+ verified: false,
+ revoked: true,
+ retry: 'conflict',
+ count: 1
+ });
+});
+
+test('S4A equivalent physical mutation queued before fresh native readback prevents the first acknowledgement', async ({
+ page
+}) => {
+ await page.evaluate(() => window.p8Fixture.reserve());
+ await page.evaluate(() => window.p8Fixture.prepare());
+ await page.evaluate(() => {
+ const f = window.p8Fixture,
+ record = window.p8.inboxProbeSnapshot(f.probeIdentity()!)!,
+ artifact = window.p8.inboxProbeGiftwrapSnapshot(f.wrap()!)!;
+ const wire = JSON.stringify({
+ ...record,
+ revision: 1,
+ self: {
+ eventId: (JSON.parse(artifact.wire) as { id: string }).id,
+ wire: artifact.wire
+ }
+ });
+ window.p8Restore = f.installCommitCompletion(() => {
+ void f.inject([{ owner: f.owner, id: record.id, wire: ' ' + wire }]);
+ });
+ });
+ expect(await page.evaluate(() => window.p8Fixture.commitOriginal())).toEqual({
+ status: 'conflict',
+ snapshot: undefined
+ });
+ expect(
+ await page.evaluate(() => window.p8Fixture.acknowledgement())
+ ).toBeUndefined();
+ expect(await page.evaluate(() => window.p8Fixture.stored())).toHaveLength(1);
+});
+
+for (const mutation of [
+ 'metadata',
+ 'later_facts',
+ 'corrupt_tail',
+ 'removed'
+] as const) {
+ test(`S4A fresh acknowledgement verification revokes ${mutation} custody without recreating an artifact`, async ({
+ page
+ }) => {
+ await page.evaluate(() => window.p8Fixture.reserve());
+ await page.evaluate(() => window.p8Fixture.prepare());
+ const result = await page.evaluate(async (mutation) => {
+ const f = window.p8Fixture,
+ api = window.p8;
+ await f.commitOriginal();
+ const ack = f.acknowledgement()!,
+ row = (await f.stored())[0];
+ const record = JSON.parse(row.wire) as {
+ createdAt: number;
+ revision: number;
+ self: { eventId: string };
+ binding: { archiveTargets: string[] };
+ receipts: unknown[];
+ };
+ if (mutation === 'removed') await f.removeOriginal();
+ else if (mutation === 'corrupt_tail')
+ await f.inject([
+ { owner: f.owner, id: crypto.randomUUID(), wire: 'broken' }
+ ]);
+ else {
+ if (mutation === 'metadata') record.createdAt++;
+ else {
+ record.revision++;
+ record.receipts.push({
+ actionId: crypto.randomUUID(),
+ origin: record.binding.archiveTargets[0],
+ role: 'access_archive',
+ attempt: 1,
+ eventId: record.self.eventId,
+ status: 'accepted',
+ observedAtMilliseconds: 1,
+ readbackWire: null
+ });
+ }
+ await f.inject([{ ...row, wire: JSON.stringify(record) }]);
+ }
+ const before = f.counts();
+ const verified = await api.verifyInboxProbeAcknowledgement(
+ f.repository,
+ f.session,
+ ack
+ );
+ const retry = await f.commitOriginal();
+ return {
+ verified,
+ revoked: api.inboxProbeAcknowledgementSnapshot(ack) === undefined,
+ status: retry.status,
+ before,
+ after: f.counts()
+ };
+ }, mutation);
+ expect(result.verified).toBe(false);
+ expect(result.revoked).toBe(true);
+ expect(['conflict', 'invalid_record', 'corrupt_record']).toContain(
+ result.status
+ );
+ expect(result.before).toEqual(result.after);
+ });
+}
+
+test('S4A preparation grows the existing row at the full joint 100-row ceiling', async ({
+ page
+}) => {
+ await page.evaluate(() => window.p8Fixture.reserve());
+ await page.evaluate(() => window.p8Fixture.prepare());
+ await page.evaluate(() => window.p8Fixture.fillCapacity(99));
+ expect(await page.evaluate(() => window.p8Fixture.stored())).toHaveLength(
+ 100
+ );
+ expect(
+ await page.evaluate(() => window.p8Fixture.commitOriginal())
+ ).toMatchObject({ status: 'prepared' });
+ expect(await page.evaluate(() => window.p8Fixture.stored())).toHaveLength(
+ 100
+ );
+});
+
+test('S4A actual complete row bytes refuse artifact growth with bounded structural filler and preserve the original', async ({
+ page
+}) => {
+ await page.evaluate(() => window.p8Fixture.reserve());
+ await page.evaluate(() => window.p8Fixture.prepare());
+ const bound = await page.evaluate(() =>
+ window.p8Fixture.fillProbeByteHeadroom()
+ );
+ expect(bound.count).toBe(2);
+ expect(bound.bytes).toBeLessThanOrEqual(8 * 1024 * 1024);
+ expect(bound.headroom).toBeLessThan(bound.growth);
+ const result = await page.evaluate(async () => {
+ const f = window.p8Fixture,
+ before = JSON.stringify(await f.stored()),
+ counts = f.counts();
+ const result = await f.commitOriginal();
+ return {
+ status: result.status,
+ unchanged: before === JSON.stringify(await f.stored()),
+ noAcknowledgement: f.acknowledgement() === undefined,
+ counts,
+ after: f.counts()
+ };
+ });
+ expect(result).toMatchObject({
+ status: 'capacity',
+ unchanged: true,
+ noAcknowledgement: true
+ });
+ expect(result.counts).toEqual(result.after);
+});
diff --git a/web/tests/provenance/output.test.mjs b/web/tests/provenance/output.test.mjs
@@ -611,6 +611,37 @@ import { auditOutput } from '../../tools/check-output.mjs';
Object.values(manifest).some((row) => row.name === 'view-context')
);
assert.ok((await f.audit()).length > 0);
+ for (const producer of [
+ 'src/lib/persistence/private-storage.ts',
+ 'src/lib/persistence/inbox-probes.ts'
+ ]) {
+ for (const change of ['changed', 'missing']) {
+ await t.test(
+ 'HCP115 shared probe storage rejects ' + change + ' ' + producer,
+ async () => {
+ const file = path.join(f.web, producer),
+ original = await readFile(file);
+ try {
+ if (change === 'changed')
+ await writeFile(
+ file,
+ Buffer.concat([original, Buffer.from('\n')])
+ );
+ else await rm(file);
+ await refresh(f);
+ await assert.rejects(
+ f.audit,
+ /Invalid owned probe storage source|ENOENT/
+ );
+ } finally {
+ await writeFile(file, original);
+ await refresh(f);
+ }
+ assert.ok((await f.audit()).length > 0);
+ }
+ );
+ }
+ }
const handles = Object.values(manifest).find(
(row) => row.name === 'private-handles'
);
@@ -1937,6 +1968,7 @@ import { auditOutput } from '../../tools/check-output.mjs';
);
}
for (const producer of [
+ 'src/lib/persistence/inbox-probes.ts',
'src/lib/nostr/inbox-access.ts',
'src/lib/nostr/seal-builder.ts',
'src/lib/nostr/giftwrap-builder.ts',
diff --git a/web/tests/unit/inbox-probe-storage.test.ts b/web/tests/unit/inbox-probe-storage.test.ts
@@ -0,0 +1,84 @@
+import { afterEach, expect, it, vi } from 'vitest';
+import type { PrivateSession } from '../../src/lib/runtime/private-session.ts';
+import type { PrivateStorageRepository } from '../../src/lib/persistence/private-storage.ts';
+import type { InboxProbeGiftwrap } from '../../src/lib/nostr/giftwrap-builder.ts';
+import type { InboxProbeAcknowledgement } from '../../src/lib/persistence/inbox-probes.ts';
+import { pairedDeliveryAcknowledgementSnapshot } from '../../src/lib/persistence/private-sends.ts';
+
+afterEach(() => vi.unstubAllGlobals());
+it('cold SSR probe persistence import and forged acknowledgements have no browser effects', async () => {
+ vi.resetModules();
+ const api = await import('../../src/lib/persistence/inbox-probes.ts');
+ expect(
+ await api.commitInboxProbe(
+ {} as PrivateStorageRepository,
+ {} as PrivateSession,
+ {} as InboxProbeGiftwrap,
+ 'reviewed_inbox_probe_commit'
+ )
+ ).toEqual({ status: 'invalid', disposition: 'original_protected' });
+ expect(
+ api.inboxProbeAcknowledgementSnapshot({} as InboxProbeAcknowledgement)
+ ).toBeUndefined();
+ expect(
+ await api.verifyInboxProbeAcknowledgement(
+ {} as PrivateStorageRepository,
+ {} as PrivateSession,
+ {} as InboxProbeAcknowledgement
+ )
+ ).toBe(false);
+});
+
+it('browser-shaped forged inputs and consent coercion cannot access storage or a provider', async () => {
+ vi.resetModules();
+ let observations = 0;
+ const trap = () => {
+ observations++;
+ throw Error('unreviewed browser work');
+ };
+ vi.stubGlobal('window', {
+ get nostr() {
+ return trap();
+ }
+ });
+ vi.stubGlobal('navigator', {
+ get locks() {
+ return trap();
+ }
+ });
+ const api = await import('../../src/lib/persistence/inbox-probes.ts');
+ const copy = Object.freeze({ owner: 'a'.repeat(64), current: () => true });
+ for (const primitive of [null, undefined, false, 0, 'wrap', Symbol()]) {
+ expect(
+ await api.commitInboxProbe(
+ copy as unknown as PrivateStorageRepository,
+ copy as unknown as PrivateSession,
+ primitive as unknown as InboxProbeGiftwrap,
+ 'reviewed_inbox_probe_commit'
+ )
+ ).toEqual({ status: 'invalid', disposition: 'original_protected' });
+ }
+ for (const review of ['reviewed_inbox_probe_commit', { toString: trap }]) {
+ expect(
+ await api.commitInboxProbe(
+ copy as unknown as PrivateStorageRepository,
+ copy as unknown as PrivateSession,
+ copy as unknown as InboxProbeGiftwrap,
+ review
+ )
+ ).toEqual({ status: 'invalid', disposition: 'original_protected' });
+ }
+ expect(
+ api.inboxProbeAcknowledgementSnapshot(
+ copy as unknown as InboxProbeAcknowledgement
+ )
+ ).toBeUndefined();
+ expect(
+ pairedDeliveryAcknowledgementSnapshot(
+ copy as unknown as Parameters<
+ typeof pairedDeliveryAcknowledgementSnapshot
+ >[0]
+ )
+ ).toBeUndefined();
+ expect(observations).toBe(0);
+});
diff --git a/web/tools/check-output.mjs b/web/tools/check-output.mjs
@@ -322,6 +322,8 @@ async function operationalFlagsAdmission(web) {
'b4c718364625b3caacbc5cc5f98bd79a575a5d66dddb2d7f59f03351a1308a6d',
'src/lib/nostr/inbox-ingress.ts':
'f860a094a8ba767585124c795d44b7620064f73a5b3a0170041c581c0fc64ecb',
+ 'src/lib/persistence/inbox-probes.ts':
+ '7441272a31386a4a70791269c31d55adaa11978ffcb094a98a5a83162aae2f99',
'src/lib/nostr/inbox-access.ts':
'fcd0a3aa216bd092b84e8ea1f4824f047367eaec6ed4e16715612554244eab0b',
'src/lib/nostr/seal-builder.ts':
@@ -401,7 +403,7 @@ async function operationalFlagsAdmission(web) {
'src/lib/persistence/private-sends.ts':
'6696f4179370cad373c06debf57b919598d53b3d25b6d2a6054a557608e4eb9c',
'src/lib/persistence/private-storage.ts':
- '66bab9a0a0a699b70ecba75c002ac0de20a84f3d015f5caefbe1697d0f6456bf',
+ 'ba4a61dd1fa08fc89d00adac3c258c1f6ae7e5c1b15165facffe76ddd71d5e91',
'src/lib/persistence/public-publications.ts':
'be99c4114fb32880e0a9b48ab3593645532853fb4166fb506f398416db41a194',
'src/lib/persistence/public-receipts.ts':
@@ -596,6 +598,8 @@ async function privacyDataAdmission(web) {
'b4c718364625b3caacbc5cc5f98bd79a575a5d66dddb2d7f59f03351a1308a6d',
'src/lib/nostr/inbox-ingress.ts':
'f860a094a8ba767585124c795d44b7620064f73a5b3a0170041c581c0fc64ecb',
+ 'src/lib/persistence/inbox-probes.ts':
+ '7441272a31386a4a70791269c31d55adaa11978ffcb094a98a5a83162aae2f99',
'src/lib/nostr/inbox-access.ts':
'fcd0a3aa216bd092b84e8ea1f4824f047367eaec6ed4e16715612554244eab0b',
'src/lib/nostr/seal-builder.ts':
@@ -669,7 +673,7 @@ async function privacyDataAdmission(web) {
'src/lib/persistence/private-sends.ts':
'6696f4179370cad373c06debf57b919598d53b3d25b6d2a6054a557608e4eb9c',
'src/lib/persistence/private-storage.ts':
- '66bab9a0a0a699b70ecba75c002ac0de20a84f3d015f5caefbe1697d0f6456bf',
+ 'ba4a61dd1fa08fc89d00adac3c258c1f6ae7e5c1b15165facffe76ddd71d5e91',
'src/lib/persistence/public-publications.ts':
'be99c4114fb32880e0a9b48ab3593645532853fb4166fb506f398416db41a194',
'src/lib/persistence/public-receipts.ts':
@@ -2153,6 +2157,24 @@ async function inboxSetupAdmission(web) {
}
return true;
}
+// The historical inbox compiler may consume this exact current shared storage
+// owner. Both producer identities are required; no old view pin is refreshed.
+/** @param {string} web */
+async function inboxProbeStorageAdmission(web) {
+ const producers = {
+ 'src/lib/persistence/private-storage.ts':
+ 'ba4a61dd1fa08fc89d00adac3c258c1f6ae7e5c1b15165facffe76ddd71d5e91',
+ 'src/lib/persistence/inbox-probes.ts':
+ '7441272a31386a4a70791269c31d55adaa11978ffcb094a98a5a83162aae2f99'
+ };
+ for (const [name, pin] of Object.entries(producers)) {
+ const bytes = await readOwned(web, name);
+ publicText(bytes);
+ if (createHash('sha256').update(bytes).digest('hex') !== pin)
+ throw new Error('Invalid owned probe storage source');
+ }
+ return true;
+}
/** @param {string} web */
async function inboxPresentationAdmission(web) {
const route = await readOwned(web, 'src/routes/messages/+page.svelte');
@@ -2207,6 +2229,10 @@ async function inboxPresentationAdmission(web) {
publicText(bytes);
if (
createHash('sha256').update(bytes).digest('hex') !== pin &&
+ !(
+ name === 'src/lib/persistence/private-storage.ts' &&
+ (await inboxProbeStorageAdmission(web))
+ ) &&
!(await privateBlockingAdmission(web))
)
throw new Error('Invalid owned inbox presentation source');