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:
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);
+ }
+});