commit 28a0f2b0af54d9d64a6d0f3c6610ba4f3d40423b
parent b26cf65b35de5463ad9dfc177d332a2c150f2902
Author: triesap <tyson@radroots.org>
Date: Wed, 7 Oct 2026 04:36:05 +0000
messages: create disposable private stores and cache ownership (HCP-058)
- Own bounded private ciphertext and primitive memory by genuine session generation.
- Reverify signed owner-addressed envelopes and isolate raw storage from public data.
- Clear owned cache references and fence stale reads and writes with terminal handles.
- Exercise real SDK identity changes, imported symbols and exact count and byte limits.
Diffstat:
4 files changed, 725 insertions(+), 0 deletions(-)
diff --git a/web/src/lib/messaging/private-store.ts b/web/src/lib/messaging/private-store.ts
@@ -0,0 +1,161 @@
+import {
+ privateSessionOwnership,
+ subscribePrivateSessionClose,
+ type PrivateSession
+} from '../runtime/private-session.ts';
+import {
+ getPrivateCacheScope,
+ retainPrivateCacheWire,
+ privateCacheWire,
+ privateCacheSnapshot,
+ closePrivateCacheScope
+} from '../nostr/private-cache-scope.ts';
+import {
+ verifyEnvelope,
+ verifiedEnvelopeSnapshot,
+ type VerifiedEnvelope
+} from '../nostr/verified-envelope.ts';
+import { boundedUtf8 } from '../contracts/food-availability-v1/text.ts';
+import { PRIVATE_TRANSPORT_BUDGETS } from '../config/budgets.ts';
+
+declare const storeBrand: unique symbol;
+export type PrivateStore = Readonly<{ [storeBrand]: true }>;
+type Snapshot = Readonly<{ closed: boolean; count: number; bytes: number }>;
+type Result = 'accepted' | 'duplicate' | 'rejected' | 'limit' | 'closed';
+type Controller = {
+ insert(token: VerifiedEnvelope): Result;
+ envelope(id: string): VerifiedEnvelope | undefined;
+ snapshot(): Snapshot;
+ close(): void;
+};
+const stores = new WeakMap<PrivateStore, Controller>();
+const sessions = new WeakMap<PrivateSession, PrivateStore>();
+// Only raw signed ciphertext is exposed now. Generic private memory ownership
+// is not plaintext admission: seal/rumor/room proofs and projection consumers
+// remain with the later validation owners. No public EventStore or shared SDK
+// memoized decrypt cache ever receives these objects.
+export function getPrivateStore(
+ session: PrivateSession
+): PrivateStore | undefined {
+ if (typeof window === 'undefined') return undefined;
+ const observed = privateSessionOwnership(session);
+ if (!observed) throw new Error('private_session_invalid');
+ const capture = observed;
+ const prior = sessions.get(session);
+ if (prior) {
+ if (controller(prior).snapshot().closed)
+ throw new Error('private_store_closed');
+ return prior;
+ }
+ const selectedCache = getPrivateCacheScope(session, 'raw_ciphertext');
+ if (!selectedCache) return undefined;
+ const cache = selectedCache;
+ const token = Object.freeze({}) as PrivateStore;
+ let closed = false;
+ let off = () => {};
+ function close() {
+ if (closed) return;
+ closed = true;
+ closePrivateCacheScope(cache);
+ off();
+ stores.set(token, {
+ insert: () => 'closed',
+ envelope: () => undefined,
+ snapshot: () => ({ closed: true, count: 0, bytes: 0 }),
+ close: () => {}
+ });
+ }
+ function current() {
+ if (closed || !capture.current() || privateCacheSnapshot(cache).closed) {
+ close();
+ return false;
+ }
+ return true;
+ }
+ function admitted(
+ proof: VerifiedEnvelope
+ ):
+ | Readonly<{ id: string; wire: string; proof: VerifiedEnvelope }>
+ | undefined {
+ const event = verifiedEnvelopeSnapshot(proof);
+ if (
+ !event ||
+ event.kind !== 1059 ||
+ event.tags.length !== 1 ||
+ event.tags[0].length !== 2 ||
+ event.tags[0][0] !== 'p' ||
+ event.tags[0][1] !== capture.owner
+ )
+ return undefined;
+ const wire = JSON.stringify({
+ id: event.id,
+ pubkey: event.pubkey,
+ kind: event.kind,
+ created_at: event.created_at,
+ tags: event.tags.map((tag) => [...tag]),
+ content: event.content,
+ sig: event.sig
+ });
+ if (!boundedUtf8(wire, PRIVATE_TRANSPORT_BUDGETS.envelopeBytes))
+ return undefined;
+ const checked = verifyEnvelope(wire);
+ return checked.ok
+ ? { id: event.id, wire, proof: checked.value }
+ : undefined;
+ }
+ stores.set(token, {
+ insert(proof) {
+ if (!current()) return 'closed';
+ const accepted = admitted(proof);
+ if (!accepted) return 'rejected';
+ if (!current()) return 'closed';
+ const result = retainPrivateCacheWire(cache, accepted.id, accepted.wire);
+ return result === 'conflict' ? 'rejected' : result;
+ },
+ envelope(id) {
+ if (!current()) return undefined;
+ const raw = privateCacheWire(cache, id);
+ if (raw === undefined) return undefined;
+ // Internal memory ownership never substitutes for actual signed admission.
+ const checked = verifyEnvelope(raw);
+ if (!checked.ok) return undefined;
+ const accepted = admitted(checked.value);
+ return accepted?.id === id && current() ? accepted.proof : undefined;
+ },
+ snapshot: () =>
+ current()
+ ? privateCacheSnapshot(cache)
+ : { closed: true, count: 0, bytes: 0 },
+ close
+ });
+ sessions.set(session, token);
+ off = subscribePrivateSessionClose(session, close);
+ if (!current()) {
+ close();
+ throw new Error('private_session_invalid');
+ }
+ return token;
+}
+function controller(store: PrivateStore): Controller {
+ const state = stores.get(store);
+ if (!state) throw new Error('private_store_invalid');
+ return state;
+}
+export function insertPrivateEnvelope(
+ store: PrivateStore,
+ proof: VerifiedEnvelope
+): Result {
+ return controller(store).insert(proof);
+}
+export function privateStoreEnvelope(
+ store: PrivateStore,
+ id: string
+): VerifiedEnvelope | undefined {
+ return controller(store).envelope(id);
+}
+export function privateStoreSnapshot(store: PrivateStore): Snapshot {
+ return controller(store).snapshot();
+}
+export function closePrivateStore(store: PrivateStore): void {
+ controller(store).close();
+}
diff --git a/web/src/lib/nostr/private-cache-scope.ts b/web/src/lib/nostr/private-cache-scope.ts
@@ -0,0 +1,166 @@
+import {
+ privateSessionOwnership,
+ subscribePrivateSessionClose,
+ type PrivateSession
+} from '../runtime/private-session.ts';
+import { boundedUtf8 } from '../contracts/food-availability-v1/text.ts';
+import {
+ PRIVATE_TRANSPORT_BUDGETS,
+ LOCAL_PERSISTENCE_BUDGETS
+} from '../config/budgets.ts';
+
+declare const cacheBrand: unique symbol;
+export type PrivateCacheScope = Readonly<{ [cacheBrand]: true }>;
+export type PrivateCachePurpose = 'raw_ciphertext' | 'projection_ownership';
+export type PrivateCacheResult =
+ 'accepted' | 'duplicate' | 'conflict' | 'rejected' | 'limit' | 'closed';
+type Snapshot = Readonly<{ closed: boolean; count: number; bytes: number }>;
+type Controller = {
+ current(): boolean;
+ retain(id: string, wire: unknown): PrivateCacheResult;
+ wire(id: string): string | undefined;
+ snapshot(): Snapshot;
+ clear(): void;
+ close(): void;
+};
+const scopes = new WeakMap<PrivateCacheScope, Controller>();
+const sessions = new WeakMap<
+ PrivateSession,
+ Map<PrivateCachePurpose, PrivateCacheScope>
+>();
+// Internal serialized-memory ownership only. This does not validate a message,
+// seal, participant or plaintext projection. Current product use is ciphertext;
+// later validated proofs must precede projection admission by its typed owner.
+// Primitive JSON strings cannot import SDK verification/decrypt/helper Symbols
+// or enter Applesauce module-global memoized references.
+export function getPrivateCacheScope(
+ session: PrivateSession,
+ purpose: PrivateCachePurpose
+): PrivateCacheScope | undefined {
+ if (typeof window === 'undefined') return undefined;
+ const observed = privateSessionOwnership(session);
+ if (!observed) throw new Error('private_session_invalid');
+ const capture = observed;
+ if (purpose !== 'raw_ciphertext' && purpose !== 'projection_ownership')
+ throw new Error('private_cache_purpose_invalid');
+ let owned = sessions.get(session);
+ const prior = owned?.get(purpose);
+ if (prior) {
+ if (!controller(prior).current()) throw new Error('private_cache_closed');
+ return prior;
+ }
+ if (!owned) {
+ owned = new Map();
+ sessions.set(session, owned);
+ }
+ const token = Object.freeze({}) as PrivateCacheScope;
+ const entries = new Map<string, string>();
+ let closed = false,
+ bytes = 0;
+ let off = () => {};
+ function close() {
+ if (closed) return;
+ closed = true;
+ entries.clear();
+ bytes = 0;
+ off();
+ // Retained opaque handles no longer keep the old cache, session or closure.
+ // Returned copies in caller memory cannot be securely erased by JavaScript.
+ scopes.set(token, {
+ current: () => false,
+ retain: () => 'closed',
+ wire: () => undefined,
+ snapshot: () => ({ closed: true, count: 0, bytes: 0 }),
+ clear: () => {},
+ close: () => {}
+ });
+ }
+ function current() {
+ if (closed || !capture.current()) {
+ close();
+ return false;
+ }
+ return true;
+ }
+ const state: Controller = {
+ current,
+ retain(id, raw) {
+ if (!current()) return 'closed';
+ if (
+ typeof id !== 'string' ||
+ !/^[0-9a-f]{64}$/.test(id) ||
+ typeof raw !== 'string' ||
+ !boundedUtf8(raw, PRIVATE_TRANSPORT_BUDGETS.envelopeBytes)
+ )
+ return 'rejected';
+ let wire: string;
+ try {
+ wire = JSON.stringify(JSON.parse(raw));
+ } catch {
+ return 'rejected';
+ }
+ if (!boundedUtf8(wire, PRIVATE_TRANSPORT_BUDGETS.envelopeBytes))
+ return 'rejected';
+ const existing = entries.get(id);
+ if (existing !== undefined)
+ return existing === wire ? 'duplicate' : 'conflict';
+ const size = new TextEncoder().encode(wire).length;
+ if (
+ entries.size >= LOCAL_PERSISTENCE_BUDGETS.receivedEnvelopes ||
+ size > LOCAL_PERSISTENCE_BUDGETS.receivedCiphertextBytes - bytes
+ )
+ return 'limit';
+ if (!current()) return 'closed';
+ entries.set(id, wire);
+ bytes += size;
+ return 'accepted';
+ },
+ wire: (id) => (current() ? entries.get(id) : undefined),
+ snapshot: () =>
+ current()
+ ? { closed: false, count: entries.size, bytes }
+ : { closed: true, count: 0, bytes: 0 },
+ clear() {
+ if (current()) {
+ entries.clear();
+ bytes = 0;
+ }
+ },
+ close
+ };
+ scopes.set(token, state);
+ owned.set(purpose, token);
+ off = subscribePrivateSessionClose(session, close);
+ if (!current()) {
+ close();
+ throw new Error('private_session_invalid');
+ }
+ return token;
+}
+function controller(scope: PrivateCacheScope): Controller {
+ const state = scopes.get(scope);
+ if (!state) throw new Error('private_cache_invalid');
+ return state;
+}
+export function retainPrivateCacheWire(
+ scope: PrivateCacheScope,
+ id: string,
+ wire: unknown
+): PrivateCacheResult {
+ return controller(scope).retain(id, wire);
+}
+export function privateCacheWire(
+ scope: PrivateCacheScope,
+ id: string
+): string | undefined {
+ return controller(scope).wire(id);
+}
+export function privateCacheSnapshot(scope: PrivateCacheScope): Snapshot {
+ return controller(scope).snapshot();
+}
+export function clearPrivateCacheScope(scope: PrivateCacheScope): void {
+ controller(scope).clear();
+}
+export function closePrivateCacheScope(scope: PrivateCacheScope): void {
+ controller(scope).close();
+}
diff --git a/web/tests/integration/private-store.test.ts b/web/tests/integration/private-store.test.ts
@@ -0,0 +1,356 @@
+import { test } from 'node:test';
+import assert from 'node:assert/strict';
+import {
+ finalizeEvent,
+ EncryptedContentSymbol,
+ verifiedSymbol
+} from 'applesauce-core/helpers';
+import {
+ createIdentitySession,
+ connectIdentity,
+ probeIdentityMessaging,
+ disconnectIdentity,
+ recheckIdentityOwner
+} from '../../src/lib/runtime/identity-session.ts';
+import { createPrivateSession } from '../../src/lib/runtime/private-session.ts';
+import {
+ getPrivateStore,
+ insertPrivateEnvelope,
+ privateStoreEnvelope,
+ privateStoreSnapshot
+} from '../../src/lib/messaging/private-store.ts';
+import {
+ getPrivateCacheScope,
+ retainPrivateCacheWire,
+ privateCacheWire,
+ privateCacheSnapshot,
+ clearPrivateCacheScope,
+ closePrivateCacheScope
+} from '../../src/lib/nostr/private-cache-scope.ts';
+import {
+ verifyEnvelope,
+ verifiedEnvelopeSnapshot
+} from '../../src/lib/nostr/verified-envelope.ts';
+import {
+ getPublicStore,
+ insertPublicEnvelope,
+ publicStoreEnvelope,
+ closePublicStore
+} from '../../src/lib/nostr/public-store.ts';
+
+// HC_TEST_ONLY_PROVIDER: genuine SDK ownership; echo probe is not encryption qualification.
+await test('disposable private store and synthetic ownership cache follow genuine SDK session generations', async (t) => {
+ const owner =
+ '79be667ef9dcbbac55a06295ce870b07029bfcdb2dce28d959f2815b16f81798';
+ const other =
+ 'c6047f9441ed7d6d3045406e95c07cd85c778e4b8cef3ca7abac09b95c709ee5';
+ assert.equal(typeof window, 'undefined');
+ assert.equal(getPrivateStore({} as never), undefined);
+ let key = owner,
+ prompts = 0;
+ Object.defineProperty(globalThis, 'window', {
+ configurable: true,
+ value: {
+ nostr: {
+ getPublicKey: () => {
+ prompts++;
+ return Promise.resolve(key);
+ },
+ signEvent: () =>
+ Promise.reject(new Error('HC_TEST_ONLY_UNEXPECTED_SIGN')),
+ nip44: {
+ encrypt: (_peer: string, text: string) =>
+ Promise.resolve('fixture:' + text),
+ decrypt: (_peer: string, text: string) =>
+ Promise.resolve(text.slice(8))
+ }
+ }
+ }
+ });
+ const identity = createIdentitySession();
+ function signed(
+ kind: number,
+ tags: string[][] = [],
+ content = 'HC_TEST_ONLY_CIPHERTEXT'
+ ) {
+ const ephemeral = crypto.getRandomValues(new Uint8Array(32));
+ try {
+ return JSON.stringify(
+ finalizeEvent(
+ { kind, tags, content, created_at: 1700000060 },
+ ephemeral
+ )
+ );
+ } finally {
+ ephemeral.fill(0);
+ }
+ }
+ function proof(wire: string) {
+ const r = verifyEnvelope(wire);
+ assert.ok(r.ok);
+ return r.value;
+ }
+ async function connect() {
+ assert.equal((await connectIdentity(identity)).state, 'signing_only');
+ assert.equal(
+ (await probeIdentityMessaging(identity, 'reviewed_self_copy')).state,
+ 'messaging_capable'
+ );
+ const session = await createPrivateSession(
+ identity,
+ 'reviewed_private_session'
+ );
+ assert.ok(session);
+ return session;
+ }
+ let publicStore: ReturnType<typeof getPublicStore>;
+ try {
+ await t.test(
+ 'guest and forged browser sessions cannot acquire owned state',
+ () => {
+ assert.throws(
+ () => getPrivateStore({} as never),
+ /private_session_invalid/
+ );
+ assert.throws(
+ () => getPrivateCacheScope({} as never, 'projection_ownership'),
+ /private_session_invalid/
+ );
+ assert.equal(prompts, 0);
+ }
+ );
+ const session = await connect();
+ const store = getPrivateStore(session);
+ assert.ok(store);
+ const cache = getPrivateCacheScope(session, 'projection_ownership');
+ assert.ok(cache);
+ const outer = proof(signed(1059, [['p', owner]]));
+ const id = verifiedEnvelopeSnapshot(outer)!.id;
+ await t.test(
+ 'verified owner-addressed ciphertext is isolated, immutable and duplicate-safe',
+ () => {
+ assert.equal(getPrivateStore(session), store);
+ assert.equal(insertPrivateEnvelope(store, outer), 'accepted');
+ assert.equal(insertPrivateEnvelope(store, outer), 'duplicate');
+ const view = verifiedEnvelopeSnapshot(privateStoreEnvelope(store, id)!);
+ assert.ok(view);
+ view.content = 'HC_TEST_ONLY_MUTATION';
+ view.tags[0][1] = other;
+ assert.equal(
+ verifiedEnvelopeSnapshot(privateStoreEnvelope(store, id)!)!.content,
+ 'HC_TEST_ONLY_CIPHERTEXT'
+ );
+ assert.equal(privateStoreSnapshot(store).count, 1);
+ publicStore = getPublicStore();
+ assert.ok(publicStore);
+ assert.equal(insertPublicEnvelope(publicStore, outer), 'not_public');
+ assert.equal(publicStoreEnvelope(publicStore, id), undefined);
+ }
+ );
+ await t.test(
+ 'private kind, exact routing and original outer metadata boundaries reject before retention',
+ () => {
+ for (const kind of [0, 13, 14, 30402, 22242])
+ assert.equal(
+ insertPrivateEnvelope(store, proof(signed(kind, [['p', owner]]))),
+ 'rejected'
+ );
+ for (const tags of [
+ [],
+ [['p', other]],
+ [['p', owner, 'hint']],
+ [
+ ['p', owner],
+ ['p', owner]
+ ],
+ [
+ ['p', owner],
+ ['subject', 'private']
+ ],
+ [
+ ['p', owner],
+ ['client', 'private']
+ ],
+ [
+ ['p', owner],
+ ['e', id]
+ ]
+ ])
+ assert.equal(
+ insertPrivateEnvelope(store, proof(signed(1059, tags))),
+ 'rejected'
+ );
+ assert.equal(insertPrivateEnvelope(store, {} as never), 'rejected');
+ assert.equal(
+ insertPrivateEnvelope(
+ store,
+ proof(signed(1059, [['p', owner]], 'x'.repeat(32768)))
+ ),
+ 'rejected'
+ );
+ assert.equal(privateStoreSnapshot(store).count, 1);
+ }
+ );
+ await t.test(
+ 'imported decrypted and verified symbols cannot gain trust or cross retained signed fields',
+ () => {
+ const dirty = JSON.parse(signed(1059, [['p', owner]])) as Record<
+ string | symbol,
+ unknown
+ >;
+ dirty.decrypted = 'HC_TEST_ONLY_IMPORTED_PREVIEW';
+ dirty[EncryptedContentSymbol] = {
+ body: 'HC_TEST_ONLY_IMPORTED_HELPER'
+ };
+ dirty[verifiedSymbol] = true;
+ assert.equal(insertPrivateEnvelope(store, dirty as never), 'rejected');
+ const token = proof(JSON.stringify(dirty));
+ assert.equal(insertPrivateEnvelope(store, token), 'accepted');
+ const clean = verifiedEnvelopeSnapshot(
+ privateStoreEnvelope(store, verifiedEnvelopeSnapshot(token)!.id)!
+ );
+ assert.ok(clean);
+ assert.equal('decrypted' in clean, false);
+ assert.deepEqual(Object.getOwnPropertySymbols(clean), []);
+ }
+ );
+ await t.test(
+ 'synthetic projection ownership is bounded JSON memory, never validated message admission',
+ () => {
+ const k = 'f'.repeat(64),
+ wire = JSON.stringify({ body: 'HC_TEST_ONLY_SYNTHETIC_OWNERSHIP' });
+ assert.equal(retainPrivateCacheWire(cache, k, wire), 'accepted');
+ assert.equal(retainPrivateCacheWire(cache, k, wire), 'duplicate');
+ assert.equal(retainPrivateCacheWire(cache, k, '{}'), 'conflict');
+ assert.equal(privateCacheWire(cache, k), wire);
+ assert.equal(
+ retainPrivateCacheWire(cache, 'e'.repeat(64), {
+ [EncryptedContentSymbol]: 'HC_TEST_ONLY_HELPER'
+ }),
+ 'rejected'
+ );
+ assert.equal(
+ retainPrivateCacheWire(cache, 'e'.repeat(64), 'x'.repeat(32769)),
+ 'rejected'
+ );
+ clearPrivateCacheScope(cache);
+ assert.equal(privateCacheWire(cache, k), undefined);
+ for (let i = 0; i < 2000; i++)
+ assert.equal(
+ retainPrivateCacheWire(
+ cache,
+ i.toString(16).padStart(64, '0'),
+ '{}'
+ ),
+ 'accepted'
+ );
+ assert.equal(
+ retainPrivateCacheWire(cache, 'd'.repeat(64), '{}'),
+ 'limit'
+ );
+ assert.equal(privateCacheSnapshot(cache).count, 2000);
+ clearPrivateCacheScope(cache);
+ const payload = JSON.stringify('x'.repeat(32766));
+ assert.equal(new TextEncoder().encode(payload).length, 32768);
+ for (let i = 0; i < 1536; i++)
+ assert.equal(
+ retainPrivateCacheWire(
+ cache,
+ i.toString(16).padStart(64, '0'),
+ payload
+ ),
+ 'accepted'
+ );
+ assert.equal(privateCacheSnapshot(cache).bytes, 50331648);
+ assert.equal(
+ retainPrivateCacheWire(cache, 'd'.repeat(64), '0'),
+ 'limit'
+ );
+ assert.equal(privateCacheSnapshot(cache).bytes, 50331648);
+ clearPrivateCacheScope(cache);
+ assert.equal(
+ retainPrivateCacheWire(cache, 'f'.repeat(64), wire),
+ 'accepted'
+ );
+ }
+ );
+ await t.test(
+ 'disconnect discards all owned raw and synthetic preview references and late writes',
+ () => {
+ const late = '{"body":"HC_TEST_ONLY_LATE_OWNERSHIP"}';
+ const originalParse = JSON.parse.bind(JSON);
+ const savedParse = JSON.parse;
+ JSON.parse = (...args: Parameters<typeof JSON.parse>) => {
+ const value: unknown = originalParse(...args);
+ if (args[0] === late) disconnectIdentity(identity);
+ return value;
+ };
+ try {
+ assert.equal(
+ retainPrivateCacheWire(cache, 'c'.repeat(64), late),
+ 'closed'
+ );
+ } finally {
+ JSON.parse = savedParse;
+ }
+ assert.equal(privateStoreEnvelope(store, id), undefined);
+ assert.deepEqual(privateStoreSnapshot(store), {
+ closed: true,
+ count: 0,
+ bytes: 0
+ });
+ assert.equal(insertPrivateEnvelope(store, outer), 'closed');
+ assert.equal(privateCacheWire(cache, 'f'.repeat(64)), undefined);
+ assert.deepEqual(privateCacheSnapshot(cache), {
+ closed: true,
+ count: 0,
+ bytes: 0
+ });
+ assert.equal(
+ retainPrivateCacheWire(cache, 'a'.repeat(64), '{}'),
+ 'closed'
+ );
+ closePrivateCacheScope(cache);
+ }
+ );
+ await t.test(
+ 'same-author reconnect cannot revive old store or preview; account replacement remains isolated',
+ async () => {
+ const again = await connect();
+ assert.notEqual(again, session);
+ const next = getPrivateStore(again);
+ assert.ok(next);
+ assert.notEqual(next, store);
+ assert.equal(privateStoreEnvelope(next, id), undefined);
+ assert.equal(
+ privateCacheWire(
+ getPrivateCacheScope(again, 'projection_ownership')!,
+ 'f'.repeat(64)
+ ),
+ undefined
+ );
+ key = other;
+ assert.equal((await recheckIdentityOwner(identity)).state, 'guest');
+ assert.equal(privateStoreSnapshot(next).closed, true);
+ const changed = await connect();
+ const foreign = getPrivateStore(changed);
+ assert.ok(foreign);
+ assert.equal(privateStoreEnvelope(foreign, id), undefined);
+ assert.equal(insertPrivateEnvelope(foreign, outer), 'rejected');
+ assert.equal(privateStoreEnvelope(store, id), undefined);
+ assert.ok(publicStore);
+ const publicToken = proof(signed(0, [], '{}'));
+ const publicId = verifiedEnvelopeSnapshot(publicToken)!.id;
+ assert.equal(
+ insertPublicEnvelope(publicStore, publicToken),
+ 'accepted'
+ );
+ assert.ok(publicStoreEnvelope(publicStore, publicId));
+ }
+ );
+ } finally {
+ disconnectIdentity(identity);
+ if (publicStore) closePublicStore(publicStore);
+ Reflect.deleteProperty(globalThis, 'window');
+ }
+});
diff --git a/web/tests/unit/private-store.test.ts b/web/tests/unit/private-store.test.ts
@@ -0,0 +1,42 @@
+import { expect, it } from 'vitest';
+import { createIdentitySession } from '../../src/lib/runtime/identity-session.ts';
+import { createPrivateSession } from '../../src/lib/runtime/private-session.ts';
+import {
+ getPrivateStore,
+ privateStoreEnvelope,
+ closePrivateStore
+} from '../../src/lib/messaging/private-store.ts';
+import {
+ getPrivateCacheScope,
+ privateCacheWire,
+ privateCacheSnapshot,
+ closePrivateCacheScope
+} from '../../src/lib/nostr/private-cache-scope.ts';
+
+it('SSR private store and cache acquisition has no browser or extension effect', async () => {
+ expect(getPrivateStore({} as never)).toBeUndefined();
+ expect(
+ getPrivateCacheScope({} as never, 'projection_ownership')
+ ).toBeUndefined();
+ expect(
+ await createPrivateSession(
+ createIdentitySession(),
+ 'reviewed_private_session'
+ )
+ ).toBeUndefined();
+});
+it('forged private store and generic cache handles provide no read or disposal authority', () => {
+ expect(() => privateStoreEnvelope({} as never, '0'.repeat(64))).toThrow(
+ 'private_store_invalid'
+ );
+ expect(() => privateCacheWire({} as never, '0'.repeat(64))).toThrow(
+ 'private_cache_invalid'
+ );
+ expect(() => privateCacheSnapshot({} as never)).toThrow(
+ 'private_cache_invalid'
+ );
+ expect(() => closePrivateStore({} as never)).toThrow('private_store_invalid');
+ expect(() => closePrivateCacheScope({} as never)).toThrow(
+ 'private_cache_invalid'
+ );
+});