app

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

commit 9f9acc6e68ae84ceff9aeb3ee6b350392a17fc43
parent cbb222637127034174b0216a59d983878b342132
Author: triesap <tyson@radroots.org>
Date:   Tue,  6 Oct 2026 14:17:13 +0000

availability: Bound public working-set retention safely (HCP-037)

- Admit at most 32 MiB of genuine shared public event payload before SDK effects.
- Carry generic newest heads and authorized deletion evidence across views and runs.
- Clear unavailable projections and retain failed cleanup controls for retry.
- Verify exact capacity, lifecycle shutdown and reentry with unit and SDK regressions.

Diffstat:
Mweb/src/lib/catalog/resolve-head.ts | 139++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++-----------------
Aweb/src/lib/catalog/retention.ts | 192+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Mweb/src/lib/config/budgets.ts | 5+++++
Aweb/src/lib/nostr/public-kinds.ts | 4++++
Mweb/src/lib/nostr/public-store.ts | 80++++++++++++++++++++++++++++++++++++++++++++++++++-----------------------------
Mweb/src/lib/runtime/public-runtime.ts | 142+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++----
Aweb/tests/integration/public-retention.test.ts | 203+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Aweb/tests/unit/retention.test.ts | 363+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Aweb/tests/unit/store-retention.test.ts | 301+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
9 files changed, 1363 insertions(+), 66 deletions(-)

diff --git a/web/src/lib/catalog/resolve-head.ts b/web/src/lib/catalog/resolve-head.ts @@ -22,6 +22,10 @@ import { import { subscribePublicView, publicViewRunCurrent, + publicViewProjectionAvailable, + publicViewKnownEvidence, + retainPublicViewHeads, + settlePublicViewProjection, type PublicView } from '../runtime/public-runtime.ts'; import { @@ -40,6 +44,7 @@ import { type FoodHeadState } from './head-state.ts'; import { evaluatePublicHeadDeletion } from './deletions.ts'; +import type { KnownPublicEvidence } from './retention.ts'; import type { WallClock } from './clock-policy.ts'; declare const resolverBrand: unique symbol; @@ -63,7 +68,13 @@ interface Entry { readonly state: FoodHeadState; readonly group: Group; } +export interface KnownHeadSource { + readonly retain: (heads: readonly PublicHead[]) => boolean; + readonly read: (head: PublicHead) => KnownPublicEvidence; + readonly available: () => boolean; +} interface Owner { + readonly available: () => boolean; readonly resolve: (heads: readonly PublicHead[]) => void; readonly snapshot: () => readonly HeadResolution[]; readonly close: () => void; @@ -91,7 +102,8 @@ function emptyRows<T>(): readonly T[] { export function createHeadResolver( run: PublicRun, subscribe: HeadSubscriber, - clock: WallClock + clock: WallClock, + known?: KnownHeadSource ): HeadResolver { publicRunSnapshot(run); const readClock = clock.nowSeconds; @@ -103,6 +115,30 @@ export function createHeadResolver( let groups = emptyRows<Group>(); let closed = false; const active = () => !closed && publicRunSnapshot(run).active; + function mergeKnown(head: PublicHead): PublicHead { + const row = known?.read(head); + if (!row) return head; + for (const request of row.requests) { + const snapshot = deletionRequestSnapshot(request); + if (snapshot) evidence.set(snapshot.id, request); + } + return row.head; + } + function clearProjection() { + entries.clear(); + evidence.clear(); + const pending = groups; + groups = emptyRows<Group>(); + for (const group of pending) { + try { + group.close(); + } catch { + groups = groups.concat(group); + } + } + if (groups.length) throw new Error('head_resolver_close_failed'); + } + const retained = () => known?.available() ?? true; function groupFor(heads: readonly PublicHead[]): Group { const queries = headResolutionQueries(heads), keys = new Map(heads.map((h) => [publicHeadKey(h), true])); @@ -169,7 +205,11 @@ export function createHeadResolver( return; } const entry = entries.get(key); - if (entry) advanceFoodHeadState(entry.state, proof); + if (entry && candidate) + advanceFoodHeadState( + entry.state, + publicHeadEnvelope(mergeKnown(candidate)) + ); }); if (!active()) { incomplete = true; @@ -202,6 +242,7 @@ export function createHeadResolver( }; } owners.set(token, { + available: retained, resolve(heads) { if (!active()) throw new Error('head_resolver_inactive'); // Validate the complete batch and total coordinate admission before any @@ -214,13 +255,17 @@ export function createHeadResolver( ); if (entries.size + fresh.length > PUBLIC_QUERY_BUDGETS.coordinatesPerRun) throw new Error('head_resolver_coordinate_limit'); + if (!retained() || (known && !known.retain(heads))) { + clearProjection(); + return; + } const group = fresh.length === 0 ? undefined : groupFor(fresh); if (group) groups = groups.concat(group); // Reserve every coordinate before caller-controlled clocks or openers. let prepared = false; let created = emptyRows<FoodHeadState>(); for (const head of fresh) { - const state = createFoodHeadState(head, { + const state = createFoodHeadState(mergeKnown(head), { nowSeconds: () => (prepared ? readClock() : NaN) }); entries.set(publicHeadKey(head), { state, group: group! }); @@ -230,37 +275,57 @@ export function createHeadResolver( for (const state of created) refreshFoodHeadState(state); for (const head of heads) { const entry = entries.get(publicHeadKey(head)); - if (entry) advanceFoodHeadState(entry.state, publicHeadEnvelope(head)); + if (entry) + advanceFoodHeadState( + entry.state, + publicHeadEnvelope(mergeKnown(head)) + ); } if (group && active()) group.open(); }, snapshot() { + if (!retained()) { + clearProjection(); + return []; + } const available = active(); - return Array.from(entries, ([key, entry]) => { - const deletion = evaluatePublicHeadDeletion( - foodHeadStateHead(entry.state), - Array.from(evidence.values()) - ); - const state = foodHeadStateSnapshot(entry.state); - const complete = available && entry.group.complete(); - return { - key, - state: { - ...state, - food: deletion.outcome === 'suppressed' ? undefined : state.food - }, - deletion, - deletionProofs: Array.from(evidence.values()).flatMap((r) => { - const proof = deletionRequestEnvelope(r); - return proof === undefined ? [] : [proof]; - }), - headSources: entry.group.head(), - deletionSources: entry.group.deletion(), - coverage: complete ? 'bounded-eose' : 'partial', - lastKnown: !complete, - definitiveAbsence: false - }; - }); + const rows: readonly HeadResolution[] = Array.from( + entries, + ([key, entry]) => { + advanceFoodHeadState( + entry.state, + publicHeadEnvelope(mergeKnown(foodHeadStateHead(entry.state))) + ); + const deletion = evaluatePublicHeadDeletion( + foodHeadStateHead(entry.state), + Array.from(evidence.values()) + ); + const state = foodHeadStateSnapshot(entry.state); + const complete = available && entry.group.complete(); + return { + key, + state: { + ...state, + food: deletion.outcome === 'suppressed' ? undefined : state.food + }, + deletion, + deletionProofs: Array.from(evidence.values()).flatMap((r) => { + const proof = deletionRequestEnvelope(r); + return proof === undefined ? [] : [proof]; + }), + headSources: entry.group.head(), + deletionSources: entry.group.deletion(), + coverage: complete ? 'bounded-eose' : 'partial', + lastKnown: !complete, + definitiveAbsence: false + }; + } + ); + if (!retained()) { + clearProjection(); + return []; + } + return rows; }, close() { closed = true; @@ -297,9 +362,17 @@ export function createPublicViewHeadResolver( run, (kind, filters, next) => subscribePublicView(view, run, kind, filters, next), - clock + clock, + { + retain: (heads) => retainPublicViewHeads(view, run, heads), + read: (head) => publicViewKnownEvidence(view, head), + available: () => publicViewProjectionAvailable(view) + } ); viewResolvers.set(run, { view, resolver }); + settlePublicViewProjection(view, () => { + headResolutionSnapshot(resolver); + }); return resolver; } export function resolveHeads( @@ -316,3 +389,9 @@ export function headResolutionSnapshot( export function closeHeadResolver(resolver: HeadResolver): void { ownerOf(resolver).close(); } + +export function headResolverRetentionState( + resolver: HeadResolver +): Readonly<{ available: boolean; definitiveAbsence: false }> { + return { available: ownerOf(resolver).available(), definitiveAbsence: false }; +} diff --git a/web/src/lib/catalog/retention.ts b/web/src/lib/catalog/retention.ts @@ -0,0 +1,192 @@ +import { PUBLIC_RETENTION_BUDGETS } from '../config/budgets.ts'; +import { isPublicEnvelopeKind } from '../nostr/public-kinds.ts'; +import { + verifiedEnvelopeSnapshot, + type VerifiedEnvelope +} from '../nostr/verified-envelope.ts'; +import { + admitDeletionRequest, + deletionRequestSnapshot, + canonicalDeletionCoordinate, + type DeletionRequest +} from '../nostr/deletion-adapter.ts'; +import { + createPublicHeadCandidate, + publicHeadKey, + publicHeadEnvelope, + selectPublicHead, + type PublicHead +} from './heads.ts'; + +declare const retentionBrand: unique symbol; +export type PublicRetention = Readonly<{ readonly [retentionBrand]: true }>; +export type RetentionSnapshot = Readonly<{ + payloadBytes: number; + events: number; + stopped: boolean; + closed: boolean; + reason: undefined | 'payload_limit' | 'installation_unavailable'; +}>; +export type KnownPublicEvidence = Readonly<{ + head: PublicHead; + requests: readonly DeletionRequest[]; +}>; +type Admission = + 'accepted' | 'duplicate' | 'not_public' | 'rejected' | 'limit' | 'closed'; +interface Owner { + readonly admit: ( + proof: VerifiedEnvelope, + install: () => boolean + ) => Admission; + readonly snapshot: () => RetentionSnapshot; + readonly envelope: (id: string) => VerifiedEnvelope | undefined; + readonly known: (head: PublicHead) => KnownPublicEvidence; + readonly close: () => void; +} +const owners = new WeakMap<PublicRetention, Owner>(); +function ownerOf(token: PublicRetention): Owner { + const owner = owners.get(token); + if (!owner) throw new Error('public_retention_invalid'); + return owner; +} +export function createPublicRetention(): PublicRetention { + const proofs = new Map<string, VerifiedEnvelope>(), + heads = new Map<string, PublicHead>(), + exact = new Map<string, DeletionRequest>(), + addresses = new Map<string, DeletionRequest>(); + let bytes = 0, + closed = false, + reason: RetentionSnapshot['reason']; + const key = (author: string, target: string) => + JSON.stringify([author, target]); + const owner: Owner = { + admit(proof, install) { + if (closed) return 'closed'; + if (reason) return 'limit'; + const event = verifiedEnvelopeSnapshot(proof); + if (!event) return 'rejected'; + if (!isPublicEnvelopeKind(event.kind)) return 'not_public'; + if (proofs.has(event.id)) return 'duplicate'; + // Logical serialized public payload, not a JS heap or transport bound. + const charge = new TextEncoder().encode(JSON.stringify(event)).length; + if (charge > PUBLIC_RETENTION_BUDGETS.payloadBytes - bytes) { + reason = 'payload_limit'; + return 'limit'; + } + // Reserve evidence before a trusted SDK installer can synchronously reenter. + proofs.set(event.id, proof); + bytes += charge; + const candidate = createPublicHeadCandidate(proof); + if (candidate) { + const coordinate = publicHeadKey(candidate); + heads.set( + coordinate, + selectPublicHead(heads.get(coordinate), candidate).head + ); + } + if (event.kind === 5) { + const admitted = admitDeletionRequest(proof); + if (admitted.ok) { + const request = deletionRequestSnapshot(admitted.value)!; + for (const target of request.eventTargets) { + const k = key(request.pubkey, target.eventId), + previous = exact.get(k); + if (!previous || request.id < deletionRequestSnapshot(previous)!.id) + exact.set(k, admitted.value); + } + for (const target of request.addressTargets) { + const k = key(request.pubkey, target.coordinate), + previous = addresses.get(k), + row = previous && deletionRequestSnapshot(previous); + if ( + !row || + request.created_at > row.created_at || + (request.created_at === row.created_at && request.id < row.id) + ) + addresses.set(k, admitted.value); + } + } + } + try { + if (!install()) { + reason = 'installation_unavailable'; + return closed ? 'closed' : 'rejected'; + } + } catch { + reason = 'installation_unavailable'; + return closed ? 'closed' : 'rejected'; + } + return closed ? 'closed' : reason ? 'limit' : 'accepted'; + }, + snapshot: () => ({ + payloadBytes: bytes, + events: proofs.size, + stopped: reason !== undefined, + closed, + reason + }), + envelope: (id) => (closed ? undefined : proofs.get(id)), + known(input) { + const head = selectPublicHead( + input, + heads.get(publicHeadKey(input)) ?? input + ).head; + const event = verifiedEnvelopeSnapshot(publicHeadEnvelope(head))!; + const identifier = + event.kind === 30402 ? event.tags.find((t) => t[0] === 'd')?.[1] : ''; + const coordinate = + identifier === undefined + ? undefined + : canonicalDeletionCoordinate( + `${event.kind}:${event.pubkey}:${identifier}` + ); + const e = exact.get(key(event.pubkey, event.id)), + a = + coordinate === undefined + ? undefined + : addresses.get(key(event.pubkey, coordinate)); + return { + head, + requests: e ? [e, ...(a && a !== e ? [a] : [])] : a ? [a] : [] + }; + }, + close() { + closed = true; + proofs.clear(); + heads.clear(); + exact.clear(); + addresses.clear(); + bytes = 0; + } + }; + const token = Object.freeze({}) as PublicRetention; + owners.set(token, owner); + return token; +} +export function retainPublicEnvelope( + owner: PublicRetention, + proof: VerifiedEnvelope, + install: () => boolean = () => true +): Admission { + return ownerOf(owner).admit(proof, install); +} +export function publicRetentionSnapshot( + owner: PublicRetention +): RetentionSnapshot { + return ownerOf(owner).snapshot(); +} +export function publicRetentionEnvelope( + owner: PublicRetention, + id: string +): VerifiedEnvelope | undefined { + return ownerOf(owner).envelope(id); +} +export function publicRetentionKnown( + owner: PublicRetention, + head: PublicHead +): KnownPublicEvidence { + return ownerOf(owner).known(head); +} +export function closePublicRetention(owner: PublicRetention): void { + ownerOf(owner).close(); +} diff --git a/web/src/lib/config/budgets.ts b/web/src/lib/config/budgets.ts @@ -25,3 +25,8 @@ export const PUBLIC_QUERY_BUDGETS = Object.freeze({ requestedPerRelay: 200, coordinatesPerRun: publicDeliveryLimit }); + +// Shared logical retained public-event payload across every view and run. +export const PUBLIC_RETENTION_BUDGETS = Object.freeze({ + payloadBytes: 33554432 +}); diff --git a/web/src/lib/nostr/public-kinds.ts b/web/src/lib/nostr/public-kinds.ts @@ -0,0 +1,4 @@ +// One approved public inventory for observations, SDK storage and retention. +export function isPublicEnvelopeKind(kind: unknown): kind is number { + return typeof kind === 'number' && [0, 5, 10050, 30402].includes(kind); +} diff --git a/web/src/lib/nostr/public-store.ts b/web/src/lib/nostr/public-store.ts @@ -5,6 +5,19 @@ import { type VerifiedEnvelope } from './verified-envelope.ts'; import type { NostrEvent } from 'applesauce-core/helpers'; +import { isPublicEnvelopeKind } from './public-kinds.ts'; +export { isPublicEnvelopeKind } from './public-kinds.ts'; +import { + createPublicRetention, + retainPublicEnvelope, + publicRetentionEnvelope, + publicRetentionSnapshot, + publicRetentionKnown, + closePublicRetention, + type RetentionSnapshot, + type KnownPublicEvidence +} from '../catalog/retention.ts'; +import type { PublicHead } from '../catalog/heads.ts'; declare const ownedStore: unique symbol; export type PublicStore = Readonly<{ readonly [ownedStore]: true }>; @@ -12,24 +25,20 @@ interface Owner { readonly closed: () => boolean; readonly insert: ( token: VerifiedEnvelope - ) => 'accepted' | 'duplicate' | 'not_public' | 'rejected' | 'closed'; + ) => + 'accepted' | 'duplicate' | 'not_public' | 'rejected' | 'limit' | 'closed'; readonly envelope: (id: string) => VerifiedEnvelope | undefined; readonly versions: ( kind: number, pubkey: string, identifier: string ) => readonly VerifiedEnvelope[]; + readonly retention: () => RetentionSnapshot; + readonly known: (head: PublicHead) => KnownPublicEvidence; 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 { @@ -55,11 +64,6 @@ const options: Readonly<EventStoreOptions> & { keepExpired: true, verifyEvent: verifyStoredEvent }; -// The same approved inventory gates public source observations and storage. -export function isPublicEnvelopeKind(kind: unknown): kind is number { - return typeof kind === 'number' && [0, 5, 10050, 30402].includes(kind); -} - // 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 { @@ -69,7 +73,7 @@ export function getPublicStore(): PublicStore | undefined { return lifetime; } const sdk = new EventStore(options); - const proofs = new Map<string, VerifiedEnvelope>(); + const retention = createPublicRetention(); let closed = false; const owner: Owner = { closed: () => closed, @@ -83,39 +87,47 @@ export function getPublicStore(): PublicStore | undefined { 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'; + // Kind5 is retained proof without activating SDK DeleteManager. + // Admission reserves bounded coherent evidence BEFORE SDK installation. + return retainPublicEnvelope( + retention, + sanitized.value, + () => event.kind === 5 || sdk.add(event) !== null + ); }, envelope(id) { - return closed ? undefined : proofs.get(id); + return closed ? undefined : publicRetentionEnvelope(retention, id); }, versions(kind, pubkey, identifier) { - if (closed) return []; + if (closed || publicRetentionSnapshot(retention).stopped) return []; return ( sdk.getReplaceableHistory(kind, pubkey, identifier) ?? [] ).flatMap((event) => { - const proof = proofs.get(event.id); + const proof = publicRetentionEnvelope(retention, event.id); return proof ? [proof] : []; }); }, + retention: () => publicRetentionSnapshot(retention), + known: (head) => publicRetentionKnown(retention, head), close() { if (closed) return; closed = true; - proofs.clear(); + closePublicRetention(retention); 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 final = publicRetentionSnapshot(retention); + owners.set(token, { + closed: () => true, + insert: () => 'closed', + envelope: () => undefined, + versions: () => [], + retention: () => ({ ...final }), + known: (head) => ({ head, requests: [] }), + close: () => undefined + }); } } }; @@ -152,3 +164,13 @@ export function publicStoreVersions( export function closePublicStore(owner: PublicStore): void { ownerOf(owner).close(); } + +export function publicStoreRetention(owner: PublicStore): RetentionSnapshot { + return ownerOf(owner).retention(); +} +export function publicStoreKnownEvidence( + owner: PublicStore, + head: PublicHead +): KnownPublicEvidence { + return ownerOf(owner).known(head); +} diff --git a/web/src/lib/runtime/public-runtime.ts b/web/src/lib/runtime/public-runtime.ts @@ -10,6 +10,8 @@ import { getPublicStore, insertPublicEnvelope, closePublicStore, + publicStoreRetention, + publicStoreKnownEvidence, type PublicStore } from '../nostr/public-store.ts'; import { @@ -26,6 +28,8 @@ import { type RequestClock } from '../nostr/request-scope.ts'; import type { PublicFilter } from '../nostr/exports.ts'; +import { publicHeadEnvelope, type PublicHead } from '../catalog/heads.ts'; +import type { KnownPublicEvidence } from '../catalog/retention.ts'; import type { VerifiedEnvelope } from '../nostr/verified-envelope.ts'; declare const contextBrand: unique symbol; declare const runtimeBrand: unique symbol; @@ -41,6 +45,8 @@ interface RuntimeOwner { readonly policy: RelayPolicy; readonly views: Map<PublicView, () => boolean>; readonly closed: () => boolean; + readonly projectionValid: (retry?: boolean) => boolean; + readonly invalidateProjection: () => void; readonly close: () => void; } interface ContextOwner { @@ -56,6 +62,8 @@ interface ViewOwner { readonly runtime: RuntimeOwner; readonly begin: () => PublicRun; readonly current: (run: PublicRun) => boolean; + readonly settling: () => boolean; + readonly settleWith: (refresh: () => void) => void; readonly dispose: () => boolean; } const contexts = new WeakMap<PublicRuntimeContext, ContextOwner>(), @@ -109,7 +117,9 @@ export function createPublicRuntimeContext(): PublicRuntimeContext { if (!pool || !store) return undefined; const scheduler = createPublicScheduler(clock), registered = new Map<PublicView, () => boolean>(); - let terminal = false; + let terminal = false, + invalidated = false, + invalidating = false; const token = Object.freeze({}) as PublicRuntime; const runtime: RuntimeOwner = { pool, @@ -118,11 +128,36 @@ export function createPublicRuntimeContext(): PublicRuntimeContext { policy, views: registered, closed: () => terminal, + projectionValid(retry = true) { + const retained = publicStoreRetention(store); + if (retained.stopped || (!terminal && retained.closed)) + invalidated = true; + // A settler reads the terminal flag without recursively retrying its + // own disposal. The outer cleanup loop keeps failed controls live. + if (invalidated && retry) runtime.invalidateProjection(); + return !invalidated; + }, + invalidateProjection() { + invalidated = true; + if (invalidating) return; + invalidating = true; + let failed = false; + try { + for (const dispose of registered.values()) + if (!dispose()) failed = true; + } finally { + invalidating = false; + } + if (failed) throw new Error('public_projection_close_failed'); + }, close() { terminal = true; let failed = false; for (const dispose of registered.values()) if (!dispose()) failed = true; + // Reentrant or failed settlement cannot preserve a coherent projection + // across store teardown. Terminal uncertainty clears every view. + if (failed) invalidated = true; try { closePublicScheduler(scheduler); } catch { @@ -182,24 +217,67 @@ export function closePublicRuntime(context: PublicRuntimeContext): void { contextOf(context).close(); } export function createPublicView(runtime: PublicRuntime): PublicView { - const shared = runtimeOf(runtime), - token = Object.freeze({}) as PublicView; + const shared = runtimeOf(runtime); + if (!shared.projectionValid()) + throw new Error('public_projection_unavailable'); + const token = Object.freeze({}) as PublicView; let run: PublicRun | undefined, disposed = false; + let generation = 0, + settler: (() => void) | undefined, + settling = false; + function settle() { + const refresh = settler; + settler = undefined; // Detach before any caller-controlled clock reentry. + if (!refresh) return; + settling = true; + try { + refresh?.(); + } catch (error) { + if (!settler) settler = refresh; + throw error; + } finally { + settling = false; + } + } const owner: ViewOwner = { runtime: shared, begin() { - if (disposed || shared.closed()) throw new Error('public_view_closed'); - if (run) disposePublicRun(run); + if (disposed || shared.closed() || !shared.projectionValid()) + throw new Error('public_view_closed'); + const operation = ++generation, + previous = run; + // Generation reserves the transition; keep failed old controls retryable. + try { + settle(); + } finally { + if (previous) disposePublicRun(previous); + } + if ( + operation !== generation || + disposed || + shared.closed() || + !shared.projectionValid() + ) + throw new Error('public_view_run_superseded'); run = createPublicRun(shared.scheduler, shared.policy); return run; }, + settling: () => settling, + settleWith(refresh) { + const previous = settler; + settler = refresh; + previous?.(); + }, current(candidate) { return !disposed && !shared.closed() && run === candidate; }, dispose() { disposed = true; + generation++; + if (settling) return false; try { + settle(); if (run) disposePublicRun(run); shared.views.delete(token); return true; @@ -247,8 +325,58 @@ export function subscribePublicView( ), (event) => { if (!owner.current(run)) return; - insertPublicEnvelope(owner.runtime.store, event); - if (owner.current(run)) onVerified(event); + const result = insertPublicEnvelope(owner.runtime.store, event); + if (result === 'limit' || result === 'rejected' || result === 'closed') { + owner.runtime.invalidateProjection(); + return; + } + if ( + (result === 'accepted' || result === 'duplicate') && + owner.current(run) + ) + onVerified(event); } ); } + +// Capacity invalidation differs from ordinary teardown: last-known snapshots +// remain available on normal close, while a breached working set clears all views. +export function publicViewProjectionAvailable(view: PublicView): boolean { + const owner = viewOf(view); + return owner.runtime.projectionValid(!owner.settling()); +} +export function publicViewKnownEvidence( + view: PublicView, + head: PublicHead +): KnownPublicEvidence { + return publicStoreKnownEvidence(viewOf(view).runtime.store, head); +} +export function retainPublicViewHeads( + view: PublicView, + run: PublicRun, + heads: readonly PublicHead[] +): boolean { + const owner = viewOf(view); + if (!publicViewRunCurrent(view, run) || !owner.runtime.projectionValid()) + return false; + for (const head of heads) { + const result = insertPublicEnvelope( + owner.runtime.store, + publicHeadEnvelope(head) + ); + if (result !== 'accepted' && result !== 'duplicate') { + owner.runtime.invalidateProjection(); + return false; + } + } + return owner.runtime.projectionValid(); +} + +// Trusted model binding holds only the current projection for this view. +// Replacement/disposal settles it while retained shared lifecycle proof is live. +export function settlePublicViewProjection( + view: PublicView, + refresh: () => void +): void { + viewOf(view).settleWith(refresh); +} diff --git a/web/tests/integration/public-retention.test.ts b/web/tests/integration/public-retention.test.ts @@ -0,0 +1,203 @@ +import test from 'node:test'; +import assert from 'node:assert/strict'; +import { once } from 'node:events'; +import { finalizeEvent } from 'applesauce-core/helpers'; +import WebSocket, { WebSocketServer } from 'ws'; +import { validateRelayPolicy } from '../../src/lib/config/relays.ts'; +import { + createPublicRuntimeContext, + mountPublicRuntime, + createPublicView, + beginPublicViewRun, + closePublicRuntime, + publicViewProjectionAvailable +} from '../../src/lib/runtime/public-runtime.ts'; +import { + getPublicStore, + insertPublicEnvelope, + publicStoreRetention +} from '../../src/lib/nostr/public-store.ts'; +import { verifyEnvelope } from '../../src/lib/nostr/verified-envelope.ts'; +import { publicRunSnapshot } from '../../src/lib/nostr/request-scope.ts'; +import { createPublicHeadCandidate } from '../../src/lib/catalog/heads.ts'; +import { + createPublicViewHeadResolver, + resolveHeads, + headResolutionSnapshot, + headResolverRetentionState +} from '../../src/lib/catalog/resolve-head.ts'; + +await test('actual shared SDK retention carries lifecycle evidence across runs and coherently stops all public views at 32MiB', async () => { + const key = crypto.getRandomValues(new Uint8Array(32)); + const signed = (time: number, tags: string[][], content = '', kind = 30402) => + finalizeEvent({ kind, created_at: time, tags, content }, key); + const proof = (event: ReturnType<typeof signed>) => { + const p = verifyEnvelope(JSON.stringify(event)); + assert.ok(p.ok); + return p.value; + }; + const old = signed(100, [['d', 'item']]), + newer = signed(101, [ + ['d', 'item'], + ['status', 'unknown'] + ]); + const deleted = signed(1, [['e', newer.id]], '', 5); + const privateWork = { + unsent: 'private memory owned separately', + outbox: ['unfinished'] + }; + const originalPrivate = structuredClone(privateWork); + const origin = 'wss://one.example.org', + server = new WebSocketServer({ + host: '127.0.0.1', + port: 0, + maxPayload: 4096 + }); + const sockets: WebSocket[] = [], + requests: { socket: WebSocket; id: string; kind: number }[] = [], + closes: string[] = []; + server.on('connection', (socket) => { + sockets.push(socket); + socket.on('message', (bytes) => { + const buffer = Array.isArray(bytes) + ? Buffer.concat(bytes) + : Buffer.isBuffer(bytes) + ? bytes + : Buffer.from(bytes); + const frame = JSON.parse(buffer.toString('utf8')) as unknown[]; + if (frame[0] === 'CLOSE') closes.push(String(frame[1])); + if (frame[0] !== 'REQ') return; + const kind = (frame[2] as { kinds: number[] }).kinds[0], + id = String(frame[1]); + requests.push({ socket, id, kind }); + if (kind === 30402) socket.send(JSON.stringify(['EVENT', id, old])); + if (requests.length <= 4) socket.send(JSON.stringify(['EOSE', id])); + }); + }); + await once(server, 'listening'); + const address = server.address(); + assert.ok(address && typeof address !== 'string'); + const port = address.port; + const priorWindow = Object.getOwnPropertyDescriptor(globalThis, 'window'), + priorSocket = globalThis.WebSocket; + class FixtureSocket extends WebSocket { + constructor(url: string | URL) { + assert.equal(String(url).replace(/\/$/, ''), origin); + super(`ws://127.0.0.1:${port}`); + } + } + Object.defineProperty(globalThis, 'window', { + configurable: true, + value: {} + }); + globalThis.WebSocket = + FixtureSocket as unknown as typeof globalThis.WebSocket; + const context = createPublicRuntimeContext(); + const settle = async (predicate: () => boolean) => { + for (let n = 0; n < 200 && !predicate(); n++) + await new Promise((r) => setTimeout(r, 5)); + assert.ok(predicate()); + }; + try { + const policy = validateRelayPolicy( + JSON.stringify({ + schemaVersion: 1, + public: [{ origin, read: true, write: false, nip50: false }], + inbox: [], + postingEnabled: false, + messagingEnabled: false, + operatorDenylist: [] + }) + )!; + const runtime = mountPublicRuntime(context, policy)!, + store = getPublicStore()!; + for (const event of [old, deleted, newer]) + assert.equal(insertPublicEnvelope(store, proof(event)), 'accepted'); + const head = createPublicHeadCandidate(proof(old))!; + const views = [createPublicView(runtime), createPublicView(runtime)], + runs = views.map((v) => beginPublicViewRun(v)); + const resolvers = views.map((v, i) => + createPublicViewHeadResolver(v, runs[i], { nowSeconds: () => 200 }) + ); + for (const resolver of resolvers) { + resolveHeads(resolver, [head]); + const row = headResolutionSnapshot(resolver)[0]; + assert.equal(row.state.head.id, newer.id); + assert.equal(row.deletion.outcome, 'suppressed'); + } + await settle( + () => + requests.length === 4 && + resolvers.every( + (r) => headResolutionSnapshot(r)[0].coverage === 'bounded-eose' + ) + ); + for (const resolver of resolvers) + assert.equal( + headResolutionSnapshot(resolver)[0].deletion.outcome, + 'suppressed' + ); + // Fill the genuine shared owner to its real inclusive limit; no toy cap. + const cap = 33554432; + let time = 1000; + for (;;) { + const tags = [['d', `bulk-${time}`]], + empty = signed(time, tags), + remaining = cap - publicStoreRetention(store).payloadBytes, + overhead = Buffer.byteLength(JSON.stringify(empty)), + length = Math.min(131000, remaining - overhead); + assert.ok(length >= 0); + assert.equal( + insertPublicEnvelope( + store, + proof(signed(time, tags, 'a'.repeat(length))) + ), + 'accepted' + ); + time++; + if (publicStoreRetention(store).payloadBytes === cap) break; + } + assert.equal(publicStoreRetention(store).stopped, false); + // Fresh actual SDK requests remain pending while overflow arrives on wire. + const nextRuns = views.map((v) => beginPublicViewRun(v)); + const nextResolvers = views.map((v, i) => + createPublicViewHeadResolver(v, nextRuns[i], { nowSeconds: () => 200 }) + ); + for (const resolver of nextResolvers) resolveHeads(resolver, [head]); + await settle(() => requests.length === 8); + const source = requests.slice(4).find((r) => r.kind === 30402)!; + source.socket.send( + JSON.stringify(['EVENT', source.id, signed(time, [['d', 'item']])]) + ); + await settle(() => publicStoreRetention(store).stopped); + for (let i = 0; i < views.length; i++) { + assert.equal(publicViewProjectionAvailable(views[i]), false); + assert.deepEqual(headResolutionSnapshot(nextResolvers[i]), []); + assert.deepEqual(headResolutionSnapshot(resolvers[i]), []); + assert.deepEqual(headResolverRetentionState(nextResolvers[i]), { + available: false, + definitiveAbsence: false + }); + assert.equal(publicRunSnapshot(nextRuns[i]).active, false); + assert.equal(publicRunSnapshot(nextRuns[i]).activeRequests, 0); + } + await settle(() => requests.slice(4).every((r) => closes.includes(r.id))); + source.socket.send(JSON.stringify(['EVENT', source.id, old])); + assert.equal(insertPublicEnvelope(store, proof(old)), 'limit'); + assert.equal(publicStoreRetention(store).payloadBytes, cap); + assert.deepEqual(privateWork, originalPrivate); + assert.throws(() => beginPublicViewRun(views[0])); + closePublicRuntime(context); + assert.equal(headResolverRetentionState(nextResolvers[0]).available, false); + } finally { + closePublicRuntime(context); + key.fill(0); + globalThis.WebSocket = priorSocket; + if (priorWindow) Object.defineProperty(globalThis, 'window', priorWindow); + else delete (globalThis as { window?: unknown }).window; + for (const socket of sockets) socket.terminate(); + await new Promise<void>((resolve, reject) => + server.close((e) => (e ? reject(e) : resolve())) + ); + } +}); diff --git a/web/tests/unit/retention.test.ts b/web/tests/unit/retention.test.ts @@ -0,0 +1,363 @@ +import { afterAll, describe, expect, it } from 'vitest'; +import { finalizeEvent } from 'applesauce-core/helpers'; +import { verifyEnvelope } from '../../src/lib/nostr/verified-envelope.ts'; +import { + createPublicHeadCandidate, + publicHeadSnapshot +} from '../../src/lib/catalog/heads.ts'; +import { evaluatePublicHeadDeletion } from '../../src/lib/catalog/deletions.ts'; +import { + createPublicRetention, + retainPublicEnvelope, + publicRetentionSnapshot, + publicRetentionEnvelope, + publicRetentionKnown, + closePublicRetention +} from '../../src/lib/catalog/retention.ts'; + +const keys: Uint8Array[] = []; +afterAll(() => { + for (const key of keys) key.fill(0); +}); +function fixture() { + const key = crypto.getRandomValues(new Uint8Array(32)); + keys.push(key); + const proof = ( + time: number, + tags: string[][] = [['d', 'item']], + content = '', + kind = 30402 + ) => { + const raw = JSON.stringify( + finalizeEvent({ kind, created_at: time, tags, content }, key) + ); + const p = verifyEnvelope(raw); + if (!p.ok) throw Error('signed retention fixture'); + return { + proof: p.value, + raw, + event: JSON.parse(raw) as { id: string; pubkey: string } + }; + }; + const head = (p: ReturnType<typeof proof>) => { + const h = createPublicHeadCandidate(p.proof); + if (!h) throw Error('head fixture'); + return h; + }; + return { proof, head, owner: createPublicRetention() }; +} +describe('coherent public working-set retention', () => { + it('counts actual UTF8 serialized event payload once per verified ID and exposes detached metrics', () => { + const f = fixture(), + p = f.proof(100, [['d', '菜']], 'multiline\n菜'); + expect(retainPublicEnvelope(f.owner, p.proof)).toBe('accepted'); + const bytes = new TextEncoder().encode(p.raw).length; + expect(publicRetentionSnapshot(f.owner)).toMatchObject({ + payloadBytes: bytes, + events: 1, + stopped: false, + closed: false + }); + expect(retainPublicEnvelope(f.owner, p.proof)).toBe('duplicate'); + const row = publicRetentionSnapshot(f.owner); + (row as unknown as { payloadBytes: number }).payloadBytes = 0; + expect(publicRetentionSnapshot(f.owner).payloadBytes).toBe(bytes); + expect(publicRetentionEnvelope(f.owner, p.event.id)).toBe(p.proof); + }); + it('retains the generic newest incompatible coordinate winner ahead of focused selection', () => { + const f = fixture(), + old = f.proof(100), + next = f.proof(101, [ + ['d', 'item'], + ['status', 'unknown'] + ]); + retainPublicEnvelope(f.owner, old.proof); + retainPublicEnvelope(f.owner, next.proof); + const known = publicRetentionKnown(f.owner, f.head(old)); + expect(publicHeadSnapshot(known.head).id).toBe(next.event.id); + expect(publicRetentionEnvelope(f.owner, old.event.id)).toBe(old.proof); + }); + it('retains authorized tombstones before their target and across later lookups without redelivery', () => { + const f = fixture(), + target = f.proof(100), + request = f.proof(1, [['e', target.event.id]], '', 5); + retainPublicEnvelope(f.owner, request.proof); + retainPublicEnvelope(f.owner, target.proof); + const known = publicRetentionKnown(f.owner, f.head(target)); + expect(known.requests).toHaveLength(1); + expect(evaluatePublicHeadDeletion(known.head, known.requests).outcome).toBe( + 'suppressed' + ); + expect(retainPublicEnvelope(f.owner, target.proof)).toBe('duplicate'); + expect( + evaluatePublicHeadDeletion( + known.head, + publicRetentionKnown(f.owner, f.head(target)).requests + ).outcome + ).toBe('suppressed'); + }); + it('retains greatest inclusive address cutoff and canonical exact-ID authority without imposing k or time on e', () => { + const f = fixture(), + target = f.proof(100), + coordinate = `30402:${target.event.pubkey}:item`; + const old = f.proof(99, [['a', coordinate]], '', 5), + current = f.proof( + 100, + [ + ['a', coordinate], + ['k', '30402'] + ], + '', + 5 + ), + exact = f.proof(1, [['e', target.event.id]], '', 5); + for (const p of [target, old, current, exact]) + retainPublicEnvelope(f.owner, p.proof); + const known = publicRetentionKnown(f.owner, f.head(target)); + const decision = evaluatePublicHeadDeletion(known.head, known.requests); + expect(decision.outcome).toBe('suppressed'); + expect(decision.addressReference?.inclusiveCutoff).toBe(100); + expect(decision.eventReference?.requestId).toBe(exact.event.id); + }); + it('a missing first d cannot acquire address deletion authority from generic empty head identity', () => { + const f = fixture(), + target = f.proof(100, []), + request = f.proof(100, [['a', `30402:${target.event.pubkey}:`]], '', 5); + retainPublicEnvelope(f.owner, target.proof); + retainPublicEnvelope(f.owner, request.proof); + const known = publicRetentionKnown(f.owner, f.head(target)); + expect(evaluatePublicHeadDeletion(known.head, known.requests).outcome).toBe( + 'visible' + ); + }); + it('denies forged and non-public proofs before installation or public accounting', () => { + const f = fixture(); + let installs = 0; + const install = () => { + installs++; + return true; + }; + expect( + retainPublicEnvelope( + f.owner, + {} as ReturnType<typeof f.proof>['proof'], + install + ) + ).toBe('rejected'); + expect( + retainPublicEnvelope( + f.owner, + f.proof(100, [], 'opaque test envelope', 1059).proof, + install + ) + ).toBe('not_public'); + expect(installs).toBe(0); + expect(publicRetentionSnapshot(f.owner)).toMatchObject({ + events: 0, + payloadBytes: 0, + stopped: false + }); + }); + it('accepts the inclusive real32MiB boundary, then stops before installation and retains all lifecycle evidence', () => { + const f = fixture(), + target = f.proof(100), + request = f.proof(1, [['e', target.event.id]], '', 5); + for (const p of [target, request]) retainPublicEnvelope(f.owner, p.proof); + const cap = 33554432; + let time = 1000; + for (;;) { + const empty = f.proof(time, [['d', `bulk-${time}`]]), + overhead = new TextEncoder().encode(empty.raw).length, + remaining = cap - publicRetentionSnapshot(f.owner).payloadBytes; + const length = Math.min(131000, remaining - overhead); + expect(length).toBeGreaterThanOrEqual(0); + const p = f.proof(time, [['d', `bulk-${time}`]], 'a'.repeat(length)); + expect(retainPublicEnvelope(f.owner, p.proof)).toBe('accepted'); + time++; + if (publicRetentionSnapshot(f.owner).payloadBytes === cap) break; + } + expect(publicRetentionSnapshot(f.owner)).toMatchObject({ + payloadBytes: cap, + stopped: false + }); + expect(retainPublicEnvelope(f.owner, target.proof)).toBe('duplicate'); + let installs = 0; + const tooMany = f.proof(time); + expect( + retainPublicEnvelope(f.owner, tooMany.proof, () => { + installs++; + return true; + }) + ).toBe('limit'); + expect(installs).toBe(0); + expect(publicRetentionSnapshot(f.owner)).toMatchObject({ + payloadBytes: cap, + stopped: true, + reason: 'payload_limit' + }); + expect(retainPublicEnvelope(f.owner, target.proof)).toBe('limit'); + const known = publicRetentionKnown(f.owner, f.head(target)); + expect(evaluatePublicHeadDeletion(known.head, known.requests).outcome).toBe( + 'suppressed' + ); + expect(publicRetentionEnvelope(f.owner, request.event.id)).toBe( + request.proof + ); + }, 30000); + it('reserves coherent evidence before installer reentry and stops on installation failure', () => { + const f = fixture(), + old = f.proof(100), + newer = f.proof(101); + expect( + retainPublicEnvelope(f.owner, old.proof, () => { + expect(publicRetentionEnvelope(f.owner, old.event.id)).toBe(old.proof); + expect(retainPublicEnvelope(f.owner, newer.proof)).toBe('accepted'); + return true; + }) + ).toBe('accepted'); + expect( + publicHeadSnapshot(publicRetentionKnown(f.owner, f.head(old)).head).id + ).toBe(newer.event.id); + const failed = f.proof(102); + expect(retainPublicEnvelope(f.owner, failed.proof, () => false)).toBe( + 'rejected' + ); + expect(publicRetentionSnapshot(f.owner)).toMatchObject({ + stopped: true, + reason: 'installation_unavailable' + }); + expect(retainPublicEnvelope(f.owner, old.proof)).toBe('limit'); + }); + it('terminal disposal cannot reset public admission or touch a separately owned private envelope', () => { + const f = fixture(), + publicValue = f.proof(100), + privateValue = f.proof(100, [], 'opaque private test payload', 1059); + retainPublicEnvelope(f.owner, publicValue.proof); + const original = privateValue.raw; + closePublicRetention(f.owner); + expect(publicRetentionSnapshot(f.owner)).toMatchObject({ + closed: true, + events: 0, + payloadBytes: 0 + }); + expect(retainPublicEnvelope(f.owner, publicValue.proof)).toBe('closed'); + expect( + publicRetentionEnvelope(f.owner, publicValue.event.id) + ).toBeUndefined(); + expect(privateValue.raw).toBe(original); + expect(verifyEnvelope(privateValue.raw).ok).toBe(true); + }); +}); + +import { validateRelayPolicy } from '../../src/lib/config/relays.ts'; +import { + createPublicScheduler, + createPublicRun, + openPublicRequest, + closePublicScheduler +} from '../../src/lib/nostr/request-scope.ts'; +import { + createHeadResolver, + resolveHeads, + headResolutionSnapshot +} from '../../src/lib/catalog/resolve-head.ts'; +function resolverFixture() { + const f = fixture(); + const policy = validateRelayPolicy( + JSON.stringify({ + schemaVersion: 1, + public: [ + { + origin: 'wss://one.example.org', + read: true, + write: false, + nip50: false + } + ], + inbox: [], + postingEnabled: false, + messagingEnabled: false, + operatorDenylist: [] + }) + )!; + const scheduler = createPublicScheduler({ + now: () => 0, + schedule: () => () => {} + }), + run = createPublicRun(scheduler, policy); + return { ...f, scheduler, run }; +} +it('retries failed projection cleanup without repeating a successful request stop', () => { + const f = resolverFixture(); + let available = true, + headStops = 0, + deletionStops = 0; + const resolver = createHeadResolver( + f.run, + (kind, filters, next) => + openPublicRequest( + f.run, + kind, + () => () => { + if (kind === 'head') { + headStops++; + if (headStops === 1) throw Error('one cleanup failure'); + } else deletionStops++; + }, + next + ), + { nowSeconds: () => 200 }, + { + retain: () => true, + read: (head) => ({ head, requests: [] }), + available: () => available + } + ); + try { + resolveHeads(resolver, [f.head(f.proof(100))]); + available = false; + expect(() => headResolutionSnapshot(resolver)).toThrow( + 'head_resolver_close_failed' + ); + expect(headStops).toBe(1); + expect(deletionStops).toBe(1); + expect(headResolutionSnapshot(resolver)).toEqual([]); + expect(headStops).toBe(2); + expect(deletionStops).toBe(1); + } finally { + closePublicScheduler(f.scheduler); + } +}); +it('a snapshot clock cannot publish rows after reentrant retention invalidation', () => { + const f = resolverFixture(); + let available = true, + armed = false; + const old = f.proof(100), + newer = f.proof(101); + retainPublicEnvelope(f.owner, old.proof); + const resolver = createHeadResolver( + f.run, + (kind, filters, next) => + openPublicRequest(f.run, kind, () => () => {}, next), + { + nowSeconds: () => { + if (armed) available = false; + return 200; + } + }, + { + retain: () => true, + read: (head) => publicRetentionKnown(f.owner, head), + available: () => available + } + ); + try { + resolveHeads(resolver, [f.head(old)]); + retainPublicEnvelope(f.owner, newer.proof); + armed = true; + expect(headResolutionSnapshot(resolver)).toEqual([]); + expect(headResolutionSnapshot(resolver)).toEqual([]); + } finally { + closePublicScheduler(f.scheduler); + } +}); diff --git a/web/tests/unit/store-retention.test.ts b/web/tests/unit/store-retention.test.ts @@ -0,0 +1,301 @@ +import { beforeEach, afterEach, describe, it, expect, vi } from 'vitest'; +import { readFileSync } from 'node:fs'; +import { finalizeEvent } from 'applesauce-core/helpers'; + +let store: typeof import('../../src/lib/nostr/public-store.ts'); +let envelope: typeof import('../../src/lib/nostr/verified-envelope.ts'); +let heads: typeof import('../../src/lib/catalog/heads.ts'); +let deletions: typeof import('../../src/lib/catalog/deletions.ts'); +beforeEach(async () => { + vi.resetModules(); + store = await import('../../src/lib/nostr/public-store.ts'); + envelope = await import('../../src/lib/nostr/verified-envelope.ts'); + heads = await import('../../src/lib/catalog/heads.ts'); + deletions = await import('../../src/lib/catalog/deletions.ts'); + vi.stubGlobal('window', {}); +}); +afterEach(() => { + vi.restoreAllMocks(); + vi.unstubAllGlobals(); +}); +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 base = JSON.parse( + corpus.vectors.find((v) => v.id.endsWith('_032'))!.signed_wires.previous +) as { tags: string[][]; content: string; created_at: number }; +function wire( + time: number, + tags = base.tags, + content = base.content, + kind = 30402, + key?: Uint8Array +) { + const secret = key ?? crypto.getRandomValues(new Uint8Array(32)); + try { + return JSON.stringify( + finalizeEvent({ kind, created_at: time, tags, content }, secret) + ); + } finally { + if (!key) secret.fill(0); + } +} +function proof(raw: string) { + const p = envelope.verifyEnvelope(raw); + if (!p.ok) throw Error('store retention fixture'); + return p.value; +} +describe('actual SDK public working-set ownership', () => { + it('indexes retained generic newer heads and same-author deletion without SDK erasure', () => { + const owner = store.getPublicStore()!, + key = crypto.getRandomValues(new Uint8Array(32)); + try { + const old = proof( + wire(base.created_at, base.tags, base.content, 30402, key) + ), + next = proof( + wire( + base.created_at + 1, + base.tags.map((t) => + t[0] === 'status' ? ['status', 'unknown'] : [...t] + ), + base.content, + 30402, + key + ) + ); + const nextId = envelope.verifiedEnvelopeSnapshot(next)!.id; + const request = proof( + wire(base.created_at - 1, [['e', nextId]], '', 5, key) + ); + for (const p of [old, request, next]) + expect(store.insertPublicEnvelope(owner, p)).toBe('accepted'); + const h = heads.createPublicHeadCandidate(old)!; + const known = store.publicStoreKnownEvidence(owner, h); + expect(heads.publicHeadSnapshot(known.head).id).toBe(nextId); + expect( + deletions.evaluatePublicHeadDeletion(known.head, known.requests).outcome + ).toBe('suppressed'); + expect(store.publicStoreEnvelope(owner, nextId)).toBeDefined(); + expect(store.publicStoreRetention(owner).events).toBe(3); + } finally { + key.fill(0); + store.closePublicStore(owner); + } + }); + it('rejects signed private kinds without changing public retention or exposing their envelope', () => { + const owner = store.getPublicStore()!; + try { + const p = proof( + wire(base.created_at, [], 'opaque private test envelope', 1059) + ); + expect(store.insertPublicEnvelope(owner, p)).toBe('not_public'); + expect(store.publicStoreRetention(owner)).toMatchObject({ + payloadBytes: 0, + events: 0, + stopped: false + }); + expect( + store.publicStoreEnvelope( + owner, + envelope.verifiedEnvelopeSnapshot(p)!.id + ) + ).toBeUndefined(); + } finally { + store.closePublicStore(owner); + } + }); +}); + +for (const evidenceKind of ['newer', 'deletion'] as const) + it(`normal shared runtime close settles unconsumed ${evidenceKind} evidence before SDK disposal`, async () => { + const runtime = await import('../../src/lib/runtime/public-runtime.ts'), + resolver = await import('../../src/lib/catalog/resolve-head.ts'); + const context = runtime.createPublicRuntimeContext(), + mounted = runtime.mountPublicRuntime(context)!, + view = runtime.createPublicView(mounted), + run = runtime.beginPublicViewRun(view); + const key = crypto.getRandomValues(new Uint8Array(32)); + try { + const old = proof( + wire(base.created_at, base.tags, base.content, 30402, key) + ), + h = heads.createPublicHeadCandidate(old)!, + model = resolver.createPublicViewHeadResolver(view, run, { + nowSeconds: () => base.created_at + 10 + }); + resolver.resolveHeads(model, [h]); + expect( + resolver.headResolutionSnapshot(model)[0].state.food + ).toBeDefined(); + const next = proof( + wire( + base.created_at + 1, + base.tags.map((t) => + t[0] === 'status' ? ['status', 'unknown'] : [...t] + ), + base.content, + 30402, + key + ) + ); + const admitted = + evidenceKind === 'newer' + ? next + : proof( + wire( + base.created_at - 1, + [['e', envelope.verifiedEnvelopeSnapshot(old)!.id]], + '', + 5, + key + ) + ); + expect( + store.insertPublicEnvelope(store.getPublicStore()!, admitted) + ).toBe('accepted'); + runtime.closePublicRuntime(context); + const row = resolver.headResolutionSnapshot(model)[0]; + expect(row.lastKnown).toBe(true); + expect(row.state.food).toBeUndefined(); + if (evidenceKind === 'newer') + expect(row.state.head.id).toBe( + envelope.verifiedEnvelopeSnapshot(next)!.id + ); + else expect(row.deletion.outcome).toBe('suppressed'); + } finally { + key.fill(0); + runtime.closePublicRuntime(context); + } + }); +it('a settlement clock reentry cannot overwrite a newer view run', async () => { + const runtime = await import('../../src/lib/runtime/public-runtime.ts'), + resolver = await import('../../src/lib/catalog/resolve-head.ts'); + const context = runtime.createPublicRuntimeContext(), + mounted = runtime.mountPublicRuntime(context)!, + view = runtime.createPublicView(mounted), + run = runtime.beginPublicViewRun(view); + const key = crypto.getRandomValues(new Uint8Array(32)); + let armed = false, + nested: ReturnType<typeof runtime.beginPublicViewRun> | undefined; + try { + const old = proof( + wire(base.created_at, base.tags, base.content, 30402, key) + ), + next = proof( + wire(base.created_at + 1, base.tags, base.content, 30402, key) + ), + model = resolver.createPublicViewHeadResolver(view, run, { + nowSeconds: () => { + if (armed) { + armed = false; + nested = runtime.beginPublicViewRun(view); + } + return base.created_at + 10; + } + }); + resolver.resolveHeads(model, [heads.createPublicHeadCandidate(old)!]); + store.insertPublicEnvelope(store.getPublicStore()!, next); + armed = true; + expect(() => runtime.beginPublicViewRun(view)).toThrow( + 'public_view_run_superseded' + ); + expect(nested).toBeDefined(); + expect(runtime.publicViewRunCurrent(view, nested!)).toBe(true); + expect(resolver.headResolutionSnapshot(model)[0].state.head.id).toBe( + envelope.verifiedEnvelopeSnapshot(next)!.id + ); + } finally { + key.fill(0); + runtime.closePublicRuntime(context); + } +}); +it('terminal public invalidation retries failed view settlement independently', async () => { + const runtime = await import('../../src/lib/runtime/public-runtime.ts'); + const context = runtime.createPublicRuntimeContext(), + mounted = runtime.mountPublicRuntime(context)!, + a = runtime.createPublicView(mounted), + b = runtime.createPublicView(mounted); + const arun = runtime.beginPublicViewRun(a), + brun = runtime.beginPublicViewRun(b); + let acalls = 0, + bcalls = 0; + runtime.settlePublicViewProjection(a, () => { + acalls++; + if (acalls === 1) throw Error('one settlement failure'); + }); + runtime.settlePublicViewProjection(b, () => { + bcalls++; + }); + try { + store.closePublicStore(store.getPublicStore()!); + expect(() => runtime.publicViewProjectionAvailable(a)).toThrow( + 'public_projection_close_failed' + ); + expect(acalls).toBe(1); + expect(bcalls).toBe(1); + expect(runtime.publicViewProjectionAvailable(a)).toBe(false); + expect(acalls).toBe(2); + expect(bcalls).toBe(1); + expect(runtime.publicViewRunCurrent(a, arun)).toBe(false); + expect(runtime.publicViewRunCurrent(b, brun)).toBe(false); + } finally { + runtime.closePublicRuntime(context); + } +}); +it('nested close during settlement cannot discard newly admitted shared evidence beneath returned rows', async () => { + const runtime = await import('../../src/lib/runtime/public-runtime.ts'), + resolver = await import('../../src/lib/catalog/resolve-head.ts'); + const context = runtime.createPublicRuntimeContext(), + mounted = runtime.mountPublicRuntime(context)!, + view = runtime.createPublicView(mounted), + run = runtime.beginPublicViewRun(view), + key = crypto.getRandomValues(new Uint8Array(32)); + let armed = false; + try { + const old = proof( + wire(base.created_at, base.tags, base.content, 30402, key) + ), + next = proof( + wire(base.created_at + 1, base.tags, base.content, 30402, key) + ), + unknown = proof( + wire( + base.created_at + 2, + base.tags.map((t) => + t[0] === 'status' ? ['status', 'unknown'] : [...t] + ), + base.content, + 30402, + key + ) + ); + const model = resolver.createPublicViewHeadResolver(view, run, { + nowSeconds: () => { + if (armed) { + armed = false; + expect( + store.insertPublicEnvelope(store.getPublicStore()!, unknown) + ).toBe('accepted'); + runtime.closePublicRuntime(context); + } + return base.created_at + 10; + } + }); + resolver.resolveHeads(model, [heads.createPublicHeadCandidate(old)!]); + store.insertPublicEnvelope(store.getPublicStore()!, next); + armed = true; + runtime.closePublicRuntime(context); + expect(resolver.headResolutionSnapshot(model)).toEqual([]); + expect(runtime.publicViewProjectionAvailable(view)).toBe(false); + } finally { + key.fill(0); + runtime.closePublicRuntime(context); + } +});