app

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

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:
Aweb/src/lib/messaging/private-store.ts | 161+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Aweb/src/lib/nostr/private-cache-scope.ts | 166+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Aweb/tests/integration/private-store.test.ts | 356+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Aweb/tests/unit/private-store.test.ts | 42++++++++++++++++++++++++++++++++++++++++++
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' + ); +});