commit 554afb6602c34c4335f9209e89488f0d8f4f0b14
parent b77e50537ccbc01fbd35e73cdab6cd3d8c0c3cf4
Author: triesap <tyson@radroots.org>
Date: Tue, 6 Oct 2026 09:15:35 +0000
web: Own HarvestCircle verified public event storage
- Keep supported SDK verification and evidence-preserving options enabled
- Retain sanitized public proof before product lifecycle filtering
- Isolate private events and dispose the anonymous store terminally
- Qualify direct SDK admission and public store contract boundaries
Diffstat:
4 files changed, 546 insertions(+), 0 deletions(-)
diff --git a/web/src/lib/nostr/public-store.ts b/web/src/lib/nostr/public-store.ts
@@ -0,0 +1,150 @@
+import { EventStore, type EventStoreOptions } from 'applesauce-core';
+import {
+ verifyEnvelope,
+ verifiedEnvelopeSnapshot,
+ type VerifiedEnvelope
+} from './verified-envelope.ts';
+import type { NostrEvent } from 'applesauce-core/helpers';
+
+declare const ownedStore: unique symbol;
+export type PublicStore = Readonly<{ readonly [ownedStore]: true }>;
+interface Owner {
+ readonly closed: () => boolean;
+ readonly insert: (
+ token: VerifiedEnvelope
+ ) => 'accepted' | 'duplicate' | 'not_public' | 'rejected' | 'closed';
+ readonly envelope: (id: string) => VerifiedEnvelope | undefined;
+ readonly versions: (
+ kind: number,
+ pubkey: string,
+ identifier: string
+ ) => readonly VerifiedEnvelope[];
+ readonly close: () => void;
+}
+const owners = new WeakMap<PublicStore, Owner>();
+let lifetime: PublicStore | undefined;
+const disposedOwner: Owner = {
+ closed: () => true,
+ insert: () => 'closed',
+ envelope: () => undefined,
+ versions: () => [],
+ close: () => undefined
+};
+
+function signedFields(event: NostrEvent): NostrEvent {
+ return {
+ 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
+ };
+}
+// Only fresh signed fields cross SDK verification: verified/cache/decrypt/relay
+// symbols and unprocessed extra metadata are never verification or cache proof.
+function verifyStoredEvent(event: NostrEvent): boolean {
+ return verifyEnvelope(JSON.stringify(signedFields(event))).ok;
+}
+const options: Readonly<EventStoreOptions> & {
+ readonly verifyEvent: typeof verifyStoredEvent;
+} = {
+ keepOldVersions: true,
+ keepDeleted: true,
+ keepExpired: true,
+ verifyEvent: verifyStoredEvent
+};
+
+// Import/SSR is inert. The private SDK instance and mutable verifier setter are
+// never exposed; acquisition accepts no caller options or private session state.
+export function getPublicStore(): PublicStore | undefined {
+ if (typeof window === 'undefined') return undefined;
+ if (lifetime) {
+ if (ownerOf(lifetime).closed()) throw new Error('public_store_closed');
+ return lifetime;
+ }
+ const sdk = new EventStore(options);
+ const proofs = new Map<string, VerifiedEnvelope>();
+ let closed = false;
+ const owner: Owner = {
+ closed: () => closed,
+ insert(token) {
+ if (closed) return 'closed';
+ const snapshot = verifiedEnvelopeSnapshot(token);
+ if (!snapshot) return 'rejected';
+ // This application's approved public inventory. Private wrappers, inner
+ // plaintext and connection AUTH belong to separate owners, never here.
+ if (![0, 5, 10050, 30402].includes(snapshot.kind)) return 'not_public';
+ const event = signedFields(snapshot);
+ const sanitized = verifyEnvelope(JSON.stringify(event));
+ if (!sanitized.ok) return 'rejected';
+ if (proofs.has(event.id)) return 'duplicate';
+ // Pinned core6.2.0 handles deletion and some replacement paths before
+ // verifyEvent. Outer genuine proof/fresh verification precedes every SDK
+ // branch. Kind5 stays exact evidence without activating DeleteManager.
+ // keepOldVersions/keepExpired preserve verified incompatible/old heads;
+ // SDK filtered queries are never product lifecycle authority. HCP033-037
+ // own head/deletion/display-expiry/working-set disposal policy.
+ if (event.kind !== 5 && sdk.add(event) === null) return 'rejected';
+ proofs.set(event.id, sanitized.value);
+ return 'accepted';
+ },
+ envelope(id) {
+ return closed ? undefined : proofs.get(id);
+ },
+ versions(kind, pubkey, identifier) {
+ if (closed) return [];
+ return (
+ sdk.getReplaceableHistory(kind, pubkey, identifier) ?? []
+ ).flatMap((event) => {
+ const proof = proofs.get(event.id);
+ return proof ? [proof] : [];
+ });
+ },
+ close() {
+ if (closed) return;
+ closed = true;
+ proofs.clear();
+ try {
+ sdk.dispose();
+ } finally {
+ // Remove the owner's closures retaining the SDK and its signed data.
+ // Terminal disposal is not a JavaScript secure-memory-erasure claim.
+ owners.set(token, disposedOwner);
+ }
+ }
+ };
+ const token = Object.freeze({}) as PublicStore;
+ owners.set(token, owner);
+ lifetime = token;
+ return token;
+}
+function ownerOf(token: PublicStore): Owner {
+ const owner = owners.get(token);
+ if (!owner) throw new Error('public_store_invalid');
+ return owner;
+}
+export function insertPublicEnvelope(
+ owner: PublicStore,
+ token: VerifiedEnvelope
+): ReturnType<Owner['insert']> {
+ return ownerOf(owner).insert(token);
+}
+export function publicStoreEnvelope(
+ owner: PublicStore,
+ id: string
+): VerifiedEnvelope | undefined {
+ return ownerOf(owner).envelope(id);
+}
+export function publicStoreVersions(
+ owner: PublicStore,
+ kind: number,
+ pubkey: string,
+ identifier: string
+): readonly VerifiedEnvelope[] {
+ return ownerOf(owner).versions(kind, pubkey, identifier);
+}
+export function closePublicStore(owner: PublicStore): void {
+ ownerOf(owner).close();
+}
diff --git a/web/tests/provenance/source-boundaries.test.mjs b/web/tests/provenance/source-boundaries.test.mjs
@@ -1855,6 +1855,59 @@ for (const [name, specifier] of [
);
}
+test('HCP030 admits a direct add on an immutable actual EventStore instance', async () => {
+ await fixture(async ({ directory, put, execute }) => {
+ await confineSvelte(directory);
+ const { cp } = await import('node:fs/promises');
+ await cp(
+ await realpath(path.join(root, 'node_modules/applesauce-core')),
+ path.join(directory, 'node_modules/applesauce-core'),
+ { recursive: true }
+ );
+ await put(
+ 'src/lib/nostr/store.ts',
+ "import { EventStore } from 'applesauce-core'; const sdk = new EventStore({keepOldVersions:true}); export function admit(event:unknown){return sdk.add(event);}"
+ );
+ await put(
+ 'src/routes/+page.ts',
+ "export { admit } from '../lib/nostr/store';"
+ );
+ const result = execute();
+ assert.equal(result.status, 0, result.stderr);
+ });
+});
+for (const source of [
+ 'export function admit(sdk:{add:(value:unknown)=>unknown},event:unknown){return sdk.add(event);}',
+ 'class EventStore { add(value:unknown){return value;} } const sdk = new EventStore(); export function admit(event:unknown){return sdk.add(event);}',
+ "import { EventStore } from 'applesauce-core'; const sdk = new EventStore(); const add=sdk.add; export function admit(event:unknown){return add(event);}",
+ "import { EventStore } from 'applesauce-core'; const sdk = new EventStore(); export function admit(event:unknown){return sdk['add'](event);}",
+ "import { EventStore } from 'applesauce-core'; let sdk = new EventStore(); export function admit(event:unknown){return sdk.add(event);}",
+ "import { EventStore } from 'applesauce-core'; const sdk = new EventStore(); sdk=opaque; export function admit(event:unknown){return sdk.add(event);}",
+ "import { EventStore } from 'applesauce-core'; EventStore=opaque; const sdk = new EventStore(); export function admit(event:unknown){return sdk.add(event);}",
+ "import { EventStore } from 'applesauce-core'; const sdk = new EventStore(); export function admit(){return sdk.add();}",
+ "import { EventStore } from 'applesauce-core'; const sdk = new EventStore(); export function admit(event:unknown){return sdk.add(event,event);}",
+ "import { EventStore } from 'applesauce-core'; const Constructor=EventStore; const sdk = new Constructor(); export function admit(event:unknown){return sdk.add(event);}",
+ "import { EventStore } from 'applesauce-core'; const sdk = new EventStore(); sdk.add=opaque; export function admit(event:unknown){return sdk.add(event);}",
+ "import { EventStore } from 'applesauce-core'; const sdk = new EventStore(); export function admit(event:unknown){return sdk.add.call(sdk,event);}"
+])
+ test(`HCP030 rejects unqualified or escaped EventStore mutation: ${source}`, async () => {
+ await fixture(async ({ directory, put, execute }) => {
+ await confineSvelte(directory);
+ const { cp } = await import('node:fs/promises');
+ await cp(
+ await realpath(path.join(root, 'node_modules/applesauce-core')),
+ path.join(directory, 'node_modules/applesauce-core'),
+ { recursive: true }
+ );
+ await put('src/lib/nostr/store.ts', source);
+ await put(
+ 'src/routes/+page.ts',
+ "export { admit } from '../lib/nostr/store';"
+ );
+ reject(execute(), /mutation|owned|prototype/);
+ });
+ });
+
test('HCP029 admits direct read-only descriptor inspection of unknown data', async () => {
await fixture(async ({ put, execute }) => {
await put(
diff --git a/web/tests/unit/store-contract.test.ts b/web/tests/unit/store-contract.test.ts
@@ -0,0 +1,309 @@
+import { beforeEach, afterEach, describe, expect, it, vi } from 'vitest';
+import { readFileSync } from 'node:fs';
+import { finalizeEvent, verifiedSymbol } from 'applesauce-core/helpers';
+
+const corpus = JSON.parse(
+ readFileSync(
+ new URL(
+ '../../../contracts/interop/food_availability/corpus.v1.json',
+ import.meta.url
+ ),
+ 'utf8'
+ )
+) as { vectors: { id: string; signed_wires: Record<string, string> }[] };
+const wires = (suffix: string) =>
+ corpus.vectors.find((row) => row.id.endsWith(suffix))!.signed_wires;
+let store: typeof import('../../src/lib/nostr/public-store.ts');
+let envelope: typeof import('../../src/lib/nostr/verified-envelope.ts');
+beforeEach(async () => {
+ vi.resetModules();
+ store = await import('../../src/lib/nostr/public-store.ts');
+ envelope = await import('../../src/lib/nostr/verified-envelope.ts');
+});
+afterEach(() => {
+ vi.restoreAllMocks();
+ vi.unstubAllGlobals();
+});
+function proof(raw: string) {
+ const result = envelope.verifyEnvelope(raw);
+ expect(result.ok).toBe(true);
+ if (!result.ok) throw new Error('Expected qualified signed test event');
+ return result.value;
+}
+function browserStore() {
+ vi.stubGlobal('window', {});
+ return store.getPublicStore()!;
+}
+// Ephemeral test-only signing material never becomes a fixture, production
+// provider, persisted input, output or user identity.
+function signed(kind: number, tags: string[][] = [], content = '') {
+ const secret = crypto.getRandomValues(new Uint8Array(32));
+ return JSON.stringify(
+ finalizeEvent({ kind, tags, content, created_at: 1700000060 }, secret)
+ );
+}
+describe('public store contract', () => {
+ it('does no browser work during SSR and owns one anonymous browser lifetime', () => {
+ vi.stubGlobal('window', undefined);
+ expect(store.getPublicStore()).toBeUndefined();
+ const owner = browserStore();
+ expect(store.getPublicStore()).toBe(owner);
+ expect(Object.keys(owner)).toEqual([]);
+ expect(Object.isFrozen(owner)).toBe(true);
+ store.closePublicStore(owner);
+ expect(() => store.getPublicStore()).toThrow('public_store_closed');
+ });
+ it('has an explicit callable verifier and fixed evidence-preserving SDK options', async () => {
+ const { EventStore } = await import('applesauce-core');
+ // eslint-disable-next-line @typescript-eslint/unbound-method -- Explicit receiver supplied by original.call(this, event) below.
+ const original = EventStore.prototype.add;
+ const checks: boolean[] = [];
+ vi.spyOn(EventStore.prototype, 'add').mockImplementation(function (
+ this: InstanceType<typeof EventStore>,
+ event
+ ) {
+ checks.push(
+ typeof this.verifyEvent === 'function' &&
+ this.keepOldVersions &&
+ this.keepDeleted &&
+ this.keepExpired
+ );
+ expect(this.verifyEvent!(event)).toBe(true);
+ expect(this.verifyEvent!({ ...event, sig: '0'.repeat(128) })).toBe(false);
+ return original.call(this, event);
+ });
+ const owner = browserStore();
+ expect(store.insertPublicEnvelope(owner, proof(wires('_014').event))).toBe(
+ 'accepted'
+ );
+ expect(checks).toEqual([true]);
+ expect('verifyEvent' in owner).toBe(false);
+ // @ts-expect-error The production acquisition API accepts no store options.
+ expect(store.getPublicStore({ verifyEvent: undefined })).toBe(owner);
+ store.closePublicStore(owner);
+ });
+ it('rejects forged and mutated cached input before it can poison a verified winner', () => {
+ const owner = browserStore();
+ const old = proof(wires('_032').previous);
+ expect(store.insertPublicEnvelope(owner, old)).toBe('accepted');
+ const invalid = JSON.parse(wires('_032').current) as Record<
+ string | symbol,
+ unknown
+ >;
+ invalid.content = 'mutated';
+ invalid[verifiedSymbol] = true;
+ expect(
+ store.insertPublicEnvelope(
+ owner,
+ invalid as unknown as ReturnType<typeof proof>
+ )
+ ).toBe('rejected');
+ expect(
+ store.insertPublicEnvelope(
+ owner,
+ Object.freeze({}) as ReturnType<typeof proof>
+ )
+ ).toBe('rejected');
+ const event = envelope.verifiedEnvelopeSnapshot(old)!;
+ expect(
+ store
+ .publicStoreVersions(owner, event.kind, event.pubkey, 'nantes-carrots')
+ .map((token) => envelope.verifiedEnvelopeSnapshot(token))
+ ).toEqual([event]);
+ expect(envelope.verifyEnvelope(JSON.stringify(invalid)).ok).toBe(false);
+ store.closePublicStore(owner);
+ });
+ it('preserves both valid versions before focused filtering and exposes detached proof lists', () => {
+ const owner = browserStore();
+ const newest = proof(wires('_032').current);
+ const older = proof(wires('_032').previous);
+ expect(store.insertPublicEnvelope(owner, newest)).toBe('accepted');
+ expect(store.insertPublicEnvelope(owner, older)).toBe('accepted');
+ const event = envelope.verifiedEnvelopeSnapshot(newest)!;
+ const versions = store.publicStoreVersions(
+ owner,
+ event.kind,
+ event.pubkey,
+ 'nantes-carrots'
+ );
+ expect(
+ new Set(
+ versions.map((token) => envelope.verifiedEnvelopeSnapshot(token)!.id)
+ )
+ ).toEqual(
+ new Set([
+ envelope.verifiedEnvelopeSnapshot(newest)!.id,
+ envelope.verifiedEnvelopeSnapshot(older)!.id
+ ])
+ );
+ (versions as unknown as unknown[]).pop();
+ expect(
+ store.publicStoreVersions(
+ owner,
+ event.kind,
+ event.pubkey,
+ 'nantes-carrots'
+ )
+ ).toHaveLength(2);
+ expect(
+ envelope.verifiedEnvelopeSnapshot(
+ store.publicStoreEnvelope(owner, event.id)!
+ )
+ ).toEqual(event);
+ const detached = envelope.verifiedEnvelopeSnapshot(newest)!;
+ detached.content = 'changed';
+ expect(
+ envelope.verifiedEnvelopeSnapshot(
+ store.publicStoreEnvelope(owner, event.id)!
+ )!.content
+ ).toBe(event.content);
+ store.closePublicStore(owner);
+ });
+ it('retains verified incompatible food without applying product admission', () => {
+ const owner = browserStore();
+ const incompatible = proof(wires('_020').event);
+ expect(store.insertPublicEnvelope(owner, incompatible)).toBe('accepted');
+ expect(
+ envelope.verifiedEnvelopeSnapshot(
+ store.publicStoreEnvelope(
+ owner,
+ envelope.verifiedEnvelopeSnapshot(incompatible)!.id
+ )!
+ )
+ ).toEqual(envelope.verifiedEnvelopeSnapshot(incompatible));
+ store.closePublicStore(owner);
+ });
+ it('retains deletion evidence without giving SDK deletion filtering lifecycle authority', () => {
+ const owner = browserStore();
+ const food = proof(wires('_014').event);
+ const event = envelope.verifiedEnvelopeSnapshot(food)!;
+ const deletion = proof(signed(5, [['e', event.id]]));
+ expect(store.insertPublicEnvelope(owner, deletion)).toBe('accepted');
+ expect(
+ envelope.verifiedEnvelopeSnapshot(
+ store.publicStoreEnvelope(
+ owner,
+ envelope.verifiedEnvelopeSnapshot(deletion)!.id
+ )!
+ )
+ ).toEqual(envelope.verifiedEnvelopeSnapshot(deletion));
+ expect(store.insertPublicEnvelope(owner, food)).toBe('accepted');
+ expect(
+ envelope.verifiedEnvelopeSnapshot(
+ store.publicStoreEnvelope(owner, event.id)!
+ )
+ ).toEqual(event);
+ store.closePublicStore(owner);
+ });
+ it.each([4, 13, 14, 1059, 22242])(
+ 'refuses authentic private or connection event kind %s',
+ (kind) => {
+ const owner = browserStore();
+ const token = proof(signed(kind));
+ expect(store.insertPublicEnvelope(owner, token)).toBe('not_public');
+ expect(
+ store.publicStoreEnvelope(
+ owner,
+ envelope.verifiedEnvelopeSnapshot(token)!.id
+ )
+ ).toBeUndefined();
+ store.closePublicStore(owner);
+ }
+ );
+ it('strips unprocessed decrypted metadata and SDK cache symbols from stored instances', async () => {
+ const { EventStore } = await import('applesauce-core');
+ // eslint-disable-next-line @typescript-eslint/unbound-method -- Explicit receiver supplied by original.call(this, event) below.
+ const original = EventStore.prototype.add;
+ const observed: unknown[] = [];
+ vi.spyOn(EventStore.prototype, 'add').mockImplementation(function (
+ this: InstanceType<typeof EventStore>,
+ event
+ ) {
+ observed.push(Object.keys(event).sort());
+ expect(Object.getOwnPropertySymbols(event)).toEqual([]);
+ expect('decrypted' in event).toBe(false);
+ return original.call(this, event);
+ });
+ const owner = browserStore();
+ const raw = JSON.stringify({
+ ...JSON.parse(wires('_014').event),
+ decrypted: 'HC_TEST_ONLY_PRIVATE_METADATA'
+ });
+ expect(store.insertPublicEnvelope(owner, proof(raw))).toBe('accepted');
+ expect(observed).toEqual([
+ ['content', 'created_at', 'id', 'kind', 'pubkey', 'sig', 'tags']
+ ]);
+ const clean = envelope.verifiedEnvelopeSnapshot(
+ store.publicStoreEnvelope(owner, (JSON.parse(raw) as { id: string }).id)!
+ )!;
+ expect('decrypted' in clean).toBe(false);
+ expect(Object.keys(clean).sort()).toEqual([
+ 'content',
+ 'created_at',
+ 'id',
+ 'kind',
+ 'pubkey',
+ 'sig',
+ 'tags'
+ ]);
+ store.closePublicStore(owner);
+ });
+ it('deduplicates exact proof without importing duplicate symbols or mutable metadata', () => {
+ const owner = browserStore();
+ const first = proof(wires('_014').event);
+ const second = proof(wires('_014').event);
+ expect(store.insertPublicEnvelope(owner, first)).toBe('accepted');
+ expect(store.insertPublicEnvelope(owner, second)).toBe('duplicate');
+ expect(
+ envelope.verifiedEnvelopeSnapshot(
+ store.publicStoreEnvelope(
+ owner,
+ envelope.verifiedEnvelopeSnapshot(first)!.id
+ )!
+ )
+ ).toEqual(envelope.verifiedEnvelopeSnapshot(first));
+ store.closePublicStore(owner);
+ });
+ it('retains signed expired data as evidence before product display policy', () => {
+ const owner = browserStore();
+ const token = proof(
+ signed(30402, [
+ ['d', 'expired'],
+ ['expiration', '1']
+ ])
+ );
+ expect(store.insertPublicEnvelope(owner, token)).toBe('accepted');
+ expect(
+ envelope.verifiedEnvelopeSnapshot(
+ store.publicStoreEnvelope(
+ owner,
+ envelope.verifiedEnvelopeSnapshot(token)!.id
+ )!
+ )
+ ).toEqual(envelope.verifiedEnvelopeSnapshot(token));
+ store.closePublicStore(owner);
+ });
+ it('rejects forged owners and terminally releases public proof on disposal', async () => {
+ const { EventStore } = await import('applesauce-core');
+ const disposal = vi.spyOn(EventStore.prototype, 'dispose');
+ expect(() =>
+ store.closePublicStore({} as Parameters<typeof store.closePublicStore>[0])
+ ).toThrow('public_store_invalid');
+ const owner = browserStore();
+ const token = proof(wires('_014').event);
+ store.insertPublicEnvelope(owner, token);
+ store.closePublicStore(owner);
+ store.closePublicStore(owner);
+ expect(disposal).toHaveBeenCalledTimes(1);
+ expect(
+ store.publicStoreEnvelope(
+ owner,
+ envelope.verifiedEnvelopeSnapshot(token)!.id
+ )
+ ).toBeUndefined();
+ expect(store.insertPublicEnvelope(owner, token)).toBe('closed');
+ expect(store.publicStoreVersions(owner, 30402, '0'.repeat(64), '')).toEqual(
+ []
+ );
+ });
+});
diff --git a/web/tools/source-boundaries.mjs b/web/tools/source-boundaries.mjs
@@ -343,6 +343,39 @@ function mutationAdmission(ast, report, identity = () => null) {
return null;
return { node: decl.initializer, seen: new Set([...seen, decl]) };
}
+ // The pinned EventStore is a model receiver, not a DOM collection. Admit
+ // only its direct one-argument add on an immutable actual imported instance;
+ // aliases, shadowed imports, rebound receivers and escaped methods stay red.
+ function eventStoreAdd(node) {
+ if (
+ !ts.isPropertyAccessExpression(node) ||
+ node.name.text !== 'add' ||
+ !ts.isCallExpression(node.parent) ||
+ node.parent.expression !== node ||
+ node.parent.arguments.length !== 1 ||
+ ts.isSpreadElement(node.parent.arguments[0])
+ )
+ return false;
+ const receiver = immutable(node.expression);
+ const initializer = receiver && unwrap(receiver.node);
+ if (
+ !initializer ||
+ !ts.isNewExpression(initializer) ||
+ !ts.isIdentifier(initializer.expression)
+ )
+ return false;
+ const importedClass = declaration(initializer.expression);
+ return (
+ !!importedClass &&
+ ts.isImportSpecifier(importedClass) &&
+ !importedClass.isTypeOnly &&
+ !importedClass.parent.parent.isTypeOnly &&
+ (importedClass.propertyName ?? importedClass.name).text ===
+ 'EventStore' &&
+ importedClass.parent.parent.parent.moduleSpecifier.text ===
+ 'applesauce-core'
+ );
+ }
// Reject writes and namespace escapes independently from successful sink
// resolution, so losing a binding's trust can never hide its capability.
function capabilityBinding(node) {
@@ -854,6 +887,7 @@ function mutationAdmission(ast, report, identity = () => null) {
if (
methods.has(name) &&
!primitiveMethod(node) &&
+ !eventStoreAdd(node) &&
!locationMethod &&
!(
animationMethods.has(name) &&