commit b26cf65b35de5463ad9dfc177d332a2c150f2902
parent aae0805cc6c754219508c30fb93ec1468eface68
Author: triesap <tyson@radroots.org>
Date: Wed, 7 Oct 2026 04:08:29 +0000
messages: create the identity-scoped private transport runtime (HCP-057)
- Share the reviewed Applesauce factory across separate public and private lifetimes.
- Bind explicit private activation and finite reads to the actual identity generation.
- Bound approved inbox candidates and retain unavailable state after cleanup failure.
- Verify SDK isolation, stale ownership, bounded reads and asynchronous cleanup recovery.
Diffstat:
9 files changed, 1424 insertions(+), 7 deletions(-)
diff --git a/web/src/lib/config/budgets.ts b/web/src/lib/config/budgets.ts
@@ -6,6 +6,17 @@ export const RELAY_BUDGETS = Object.freeze({
inbox: 3
});
+// Finite private transport page; duplicates and rejected ciphertext count.
+// Full history/live coordination has separate owners. These are logical
+// post-SDK-parse limits, not browser WebSocket allocation guarantees.
+export const PRIVATE_TRANSPORT_BUDGETS = Object.freeze({
+ requestedPerRelay: 200,
+ deliveries: 500,
+ processedBytes: 8388608,
+ pageMilliseconds: 15000,
+ envelopeBytes: 32768
+});
+
// Approved public-run admission limits shared by all primary/auxiliary sources.
// Logical post-parse work accounting; no WebSocket preallocation guarantee.
const publicDeliveryLimit = 2000;
diff --git a/web/src/lib/nostr/extension.ts b/web/src/lib/nostr/extension.ts
@@ -81,6 +81,8 @@ type Controller = {
recheck(): Promise<ExtensionSnapshot>;
probe(review: unknown): Promise<ExtensionSnapshot>;
capture(): PublicEffectCapture | undefined;
+ captureMessaging(): PublicEffectCapture | undefined;
+ subscribeInvalidation(listener: () => void): () => void;
expire(approval: ApprovedPublicSigning, lease: PublicEffectLease): void;
sign(
approval: ApprovedPublicSigning,
@@ -136,6 +138,16 @@ async function freshKey(
// Lexically owned per-adapter state; no mutable opaque receiver, browser handle
// or imported signer escapes through the WeakMap/controller boundary.
export function createExtensionAdapter(): ExtensionAdapter {
+ const invalidations = new Map<symbol, () => void>();
+ function notifyInvalidation() {
+ for (const listener of invalidations.values()) {
+ try {
+ listener();
+ } catch {
+ /* Cleanup failure stays owned by its scope. */
+ }
+ }
+ }
let key: string | null = null,
signingCandidate = false;
let messaging: 'not_probed' | 'unsupported' | 'refused' | 'capable' =
@@ -164,6 +176,7 @@ export function createExtensionAdapter(): ExtensionAdapter {
signingCandidate = false;
messaging = 'not_probed';
reason = nextReason;
+ notifyInvalidation();
}
function disconnect() {
generation = Symbol();
@@ -213,6 +226,7 @@ export function createExtensionAdapter(): ExtensionAdapter {
guest(error instanceof ExtensionMissingError ? 'missing' : 'refused');
} finally {
pending = null;
+ notifyInvalidation();
}
return busy ? { ...snapshot(), admission: 'busy' } : snapshot();
}
@@ -507,6 +521,36 @@ export function createExtensionAdapter(): ExtensionAdapter {
current: () => generation === original && !cancelled && key === owner
};
},
+ captureMessaging() {
+ if (
+ !key ||
+ cancelled ||
+ !signingCandidate ||
+ messaging !== 'capable' ||
+ pending ||
+ signing
+ )
+ return undefined;
+ const owner = key,
+ original = generation;
+ return {
+ owner,
+ session: original,
+ current: () =>
+ generation === original &&
+ !cancelled &&
+ key === owner &&
+ signingCandidate &&
+ messaging === 'capable'
+ };
+ },
+ subscribeInvalidation(listener) {
+ const id = Symbol();
+ invalidations.set(id, listener);
+ return () => {
+ invalidations.delete(id);
+ };
+ },
sign,
expire(approval, lease) {
if (activeSigning?.approval === approval && activeSigning.lease === lease)
@@ -573,6 +617,17 @@ export function extensionOwnershipCapture(
): PublicEffectCapture | undefined {
return adapters.get(adapter)?.capture();
}
+export function extensionMessagingOwnershipCapture(
+ adapter: ExtensionAdapter
+): PublicEffectCapture | undefined {
+ return adapters.get(adapter)?.captureMessaging();
+}
+export function subscribeExtensionInvalidation(
+ adapter: ExtensionAdapter,
+ listener: () => void
+): () => void {
+ return adapters.get(adapter)?.subscribeInvalidation(listener) ?? (() => {});
+}
// Internal exact original operation port. Expiry pauses the real scheduler;
// neither this method nor a UI timeout pretends to cancel the SDK promise.
export function markApprovedSigningWaitExpired(
diff --git a/web/src/lib/nostr/pool-factory.ts b/web/src/lib/nostr/pool-factory.ts
@@ -0,0 +1,12 @@
+import { RelayPool } from 'applesauce-relay/pool';
+// One implementation, distinct SDK instances and relay/AUTH stores. Only owned
+// adapters call this factory; no SDK/options are exposed through UI capabilities.
+export function createScopedRelayPool(): RelayPool {
+ if (typeof window === 'undefined') throw new Error('relay_pool_browser_only');
+ return new RelayPool({
+ keepAlive: 0,
+ enablePing: false,
+ requestReconnect: 0,
+ subscriptionReconnect: 0
+ });
+}
diff --git a/web/src/lib/nostr/private-pool.ts b/web/src/lib/nostr/private-pool.ts
@@ -0,0 +1,302 @@
+import { createScopedRelayPool } from './pool-factory.ts';
+import { readRelayPolicy, type RelayPolicy } from '../config/relays.ts';
+import { PRIVATE_TRANSPORT_BUDGETS, RELAY_BUDGETS } from '../config/budgets.ts';
+import {
+ privateSessionOwnership,
+ subscribePrivateSessionClose,
+ recheckPrivateSession,
+ type PrivateSession
+} from '../runtime/private-session.ts';
+import { boundedUtf8 } from '../contracts/food-availability-v1/text.ts';
+declare const poolBrand: unique symbol;
+export type PrivatePool = Readonly<{ [poolBrand]: true }>;
+export type PrivatePageMessage =
+ | Readonly<{ type: 'candidate'; from: string; wire: string }>
+ | Readonly<{
+ type: 'end';
+ reason:
+ | 'complete'
+ | 'closed'
+ | 'stale'
+ | 'error'
+ | 'budget'
+ | 'elapsed'
+ | 'stopped';
+ }>;
+type Owner = {
+ session: PrivateSession;
+ policy: RelayPolicy;
+ origins: readonly string[];
+ token: PrivatePool;
+ closed(): boolean;
+ cleaned(): boolean;
+ subscribe(
+ limit: number,
+ listener: (message: PrivatePageMessage) => void
+ ): () => void;
+ close(): void;
+};
+const pools = new WeakMap<PrivatePool, Owner>();
+let lifetime: Owner | undefined;
+// Fixed scope selection is not authenticated owner10050 membership/readiness.
+// No production receive workflow calls this until its later inbox owner exists.
+export function getPrivatePool(
+ session: PrivateSession,
+ policy: RelayPolicy,
+ selected: readonly string[]
+): PrivatePool | undefined {
+ if (typeof window === 'undefined') return undefined;
+ const capture = privateSessionOwnership(session);
+ if (!capture) throw new Error('private_session_invalid');
+ const manifest = readRelayPolicy(policy);
+ if (!manifest.messagingEnabled) throw new Error('private_pool_disabled');
+ const length = Array.isArray(selected) ? selected.length : 0;
+ if (length < 1 || length > RELAY_BUDGETS.inbox)
+ throw new Error('private_pool_origins_invalid');
+ const selectedOrigins = new Map<string, true>();
+ for (let i = 0; i < length; i++) {
+ const origin = selected[i];
+ if (
+ typeof origin !== 'string' ||
+ selectedOrigins.has(origin) ||
+ !manifest.inbox.some((row) => row.origin === origin && row.read)
+ )
+ throw new Error('private_pool_origins_invalid');
+ selectedOrigins.set(origin, true);
+ }
+ const origins = [...selectedOrigins.keys()];
+ // Untrusted selection access can run code. Recheck before factory admission.
+ if (!capture.current()) throw new Error('private_session_invalid');
+ if (lifetime) {
+ if (!lifetime.cleaned()) {
+ if (lifetime.closed()) throw new Error('private_pool_closed');
+ if (
+ lifetime.session !== session ||
+ lifetime.policy !== policy ||
+ lifetime.origins.length !== origins.length ||
+ lifetime.origins.some((origin, i) => origin !== origins[i])
+ )
+ throw new Error('private_pool_in_use');
+ return lifetime.token;
+ }
+ }
+ const token = Object.freeze({}) as PrivatePool;
+ const sdk = createScopedRelayPool();
+ let closed = false,
+ cleaned = false,
+ busy = false,
+ cleanupRequired = false;
+ let active = () => {};
+ let off = () => {};
+ const owner: Owner = {
+ session,
+ policy,
+ origins,
+ token,
+ closed: () => closed,
+ cleaned: () => cleaned,
+ subscribe(limit, listener) {
+ if (closed || !capture.current()) {
+ owner.close();
+ throw new Error('private_pool_closed');
+ }
+ if (cleanupRequired) throw new Error('private_page_cleanup_required');
+ if (busy) throw new Error('private_page_busy');
+ busy = true;
+ let ended = false,
+ deliveries = 0,
+ bytes = 0;
+ let release = () => {};
+ let timer: ReturnType<typeof setTimeout> | undefined;
+ const completed = new Map<string, true>();
+ let started = 0;
+ function emit(message: PrivatePageMessage) {
+ try {
+ listener(message);
+ } catch {
+ /* Consumer cannot interrupt cleanup. */
+ }
+ }
+ function finish(
+ reason: Extract<PrivatePageMessage, { type: 'end' }>['reason'],
+ propagate = false
+ ) {
+ if (ended) {
+ if (cleanupRequired && propagate) {
+ release();
+ cleanupRequired = false;
+ busy = false;
+ }
+ return;
+ }
+ ended = true;
+ if (timer !== undefined) clearTimeout(timer);
+ let failure: unknown;
+ try {
+ release();
+ } catch (error) {
+ cleanupRequired = true;
+ failure = error;
+ } finally {
+ busy = cleanupRequired;
+ emit({ type: 'end', reason: cleanupRequired ? 'error' : reason });
+ }
+ // SDK and timer callbacks report finite error state without leaking an
+ // exception. Explicit stop/close can report failure and retry release.
+ if (cleanupRequired && propagate) throw failure;
+ }
+ active = () => {
+ finish('closed', true);
+ release();
+ };
+ // Reserve the page before awaiting fresh extension ownership. Stop/logout
+ // fence the continuation and no socket may open from a stale key result.
+ void recheckPrivateSession(session)
+ .then((fresh) => {
+ if (ended) return;
+ if (!fresh || closed || !capture.current()) {
+ finish('stale');
+ return;
+ }
+ started = performance.now();
+ if (ended || closed || !capture.current()) {
+ if (!ended) finish('stale');
+ return;
+ }
+ const subscription = sdk
+ .req(
+ [...origins],
+ [{ kinds: [1059], '#p': [capture.owner], limit }],
+ {
+ waitForAuth: false,
+ reconnect: false,
+ resubscribe: false
+ }
+ )
+ .subscribe({
+ next(message) {
+ if (ended) return;
+ if (closed || !capture.current()) {
+ finish('stale');
+ owner.close();
+ return;
+ }
+ const elapsed = performance.now() - started;
+ if (ended || closed || !capture.current()) {
+ if (!ended) finish('stale');
+ owner.close();
+ return;
+ }
+ if (elapsed >= PRIVATE_TRANSPORT_BUDGETS.pageMilliseconds) {
+ finish('elapsed');
+ return;
+ }
+ if (message.type === 'EOSE') {
+ completed.set(message.from, true);
+ if (completed.size === origins.length) finish('complete');
+ } else if (message.type === 'EVENT') {
+ deliveries++;
+ if (deliveries > PRIVATE_TRANSPORT_BUDGETS.deliveries) {
+ finish('budget');
+ return;
+ }
+ const wire = JSON.stringify(message.event);
+ // Charge actual encoded bytes, including rejected envelopes. An
+ // input beyond the remaining budget stops before encoding it.
+ if (
+ typeof wire !== 'string' ||
+ !boundedUtf8(
+ wire,
+ PRIVATE_TRANSPORT_BUDGETS.processedBytes - bytes
+ )
+ ) {
+ finish('budget');
+ return;
+ }
+ bytes += new TextEncoder().encode(wire).length;
+ const accepted = boundedUtf8(
+ wire,
+ PRIVATE_TRANSPORT_BUDGETS.envelopeBytes
+ );
+ if (accepted)
+ emit({ type: 'candidate', from: message.from, wire });
+ } else if (message.type === 'ERROR') finish('error');
+ },
+ complete: () => finish('complete'),
+ error: () => finish('error')
+ });
+ release = () => {
+ subscription.unsubscribe();
+ };
+ if (ended || closed || !capture.current()) {
+ release();
+ if (!ended) finish('stale');
+ } else {
+ timer = setTimeout(
+ () => finish('elapsed'),
+ PRIVATE_TRANSPORT_BUDGETS.pageMilliseconds
+ );
+ }
+ })
+ .catch(() => {
+ if (!ended) finish('error');
+ });
+ return () => finish('stopped', true);
+ },
+ close() {
+ if (cleaned) return;
+ closed = true;
+ let failed = false;
+ try {
+ active();
+ } catch {
+ failed = true;
+ }
+ try {
+ sdk.close();
+ } catch {
+ failed = true;
+ }
+ if (!failed) {
+ cleanupRequired = false;
+ cleaned = true;
+ off();
+ }
+ if (failed) throw new Error('private_pool_close_failed');
+ }
+ };
+ // Install ownership before observer registration; reentry cannot allocate a
+ // second private SDK. A failed close retains this unavailable page lifetime.
+ pools.set(token, owner);
+ lifetime = owner;
+ off = subscribePrivateSessionClose(session, () => owner.close());
+ if (!capture.current()) {
+ owner.close();
+ throw new Error('private_session_invalid');
+ }
+ return token;
+}
+function ownerOf(token: PrivatePool): Owner {
+ const owner = pools.get(token);
+ if (!owner) throw new Error('private_pool_invalid');
+ return owner;
+}
+export function privatePoolOrigins(token: PrivatePool): readonly string[] {
+ return [...ownerOf(token).origins];
+}
+export function subscribePrivatePage(
+ token: PrivatePool,
+ requested: number,
+ listener: (message: PrivatePageMessage) => void
+): () => void {
+ if (
+ !Number.isInteger(requested) ||
+ requested < 1 ||
+ requested > PRIVATE_TRANSPORT_BUDGETS.requestedPerRelay
+ )
+ throw new Error('private_page_limit_invalid');
+ return ownerOf(token).subscribe(requested, listener);
+}
+export function closePrivatePool(token: PrivatePool): void {
+ ownerOf(token).close();
+}
diff --git a/web/src/lib/nostr/public-pool.ts b/web/src/lib/nostr/public-pool.ts
@@ -1,4 +1,4 @@
-import { RelayPool } from 'applesauce-relay/pool';
+import { createScopedRelayPool } from './pool-factory.ts';
import { deploymentRelayPolicy } from '../config/deployment-relays.ts';
import {
publicRelayTargets,
@@ -40,12 +40,7 @@ export function getPublicPool(
}
const token = Object.freeze({}) as PublicPool;
const origins = publicRelayTargets(policy, 'read');
- const sdk = new RelayPool({
- keepAlive: 0,
- enablePing: false,
- requestReconnect: 0,
- subscriptionReconnect: 0
- });
+ const sdk = createScopedRelayPool();
const active = new Map<() => void, true>();
let closed = false;
let cleanupComplete = false;
diff --git a/web/src/lib/runtime/identity-session.ts b/web/src/lib/runtime/identity-session.ts
@@ -6,6 +6,8 @@ import {
probeExtensionAdapter,
disconnectExtensionAdapter,
extensionOwnershipCapture,
+ extensionMessagingOwnershipCapture,
+ subscribeExtensionInvalidation,
signApprovedExtensionAdapter,
markApprovedSigningWaitExpired,
type ApprovedSignResult,
@@ -140,6 +142,21 @@ export function disconnectIdentity(session: IdentitySession): void {
const adapter = sessions.get(session);
if (adapter) disconnectExtensionAdapter(adapter);
}
+// Internal messaging lifecycle ports. Captured observation is not an inbox
+// configuration, AUTH, private store or publication permission.
+export function identityMessagingOwnership(
+ session: IdentitySession
+): PublicEffectCapture | undefined {
+ const adapter = sessions.get(session);
+ return adapter && extensionMessagingOwnershipCapture(adapter);
+}
+export function subscribeIdentityInvalidation(
+ session: IdentitySession,
+ listener: () => void
+): () => void {
+ const adapter = sessions.get(session);
+ return adapter ? subscribeExtensionInvalidation(adapter, listener) : () => {};
+}
// Explicit route/input lifecycle event. No draft, DB, reconnect or SDK effect.
export function invalidateIdentityOperations(session: IdentitySession): void {
views.get(session)?.invalidate();
diff --git a/web/src/lib/runtime/private-session.ts b/web/src/lib/runtime/private-session.ts
@@ -0,0 +1,135 @@
+import {
+ identityMessagingOwnership,
+ recheckIdentityOwner,
+ subscribeIdentityInvalidation,
+ type IdentitySession
+} from './identity-session.ts';
+import type { PublicEffectCapture } from './effect-ownership.ts';
+declare const privateBrand: unique symbol;
+export type PrivateSession = Readonly<{ [privateBrand]: true }>;
+type Controller = {
+ identity: IdentitySession;
+ capture: PublicEffectCapture;
+ current(): boolean;
+ close(): void;
+ subscribe(listener: () => void): () => void;
+};
+const sessions = new WeakMap<PrivateSession, Controller>();
+const currentSessions = new WeakMap<IdentitySession, PrivateSession>();
+// No sockets, decryption, stores or readiness on construction. Only an explicit
+// capability action may perform the fresh owner recheck through the page SDK
+// scheduler. The generation is the real adapter's, not a caller-supplied key.
+export async function createPrivateSession(
+ identity: IdentitySession,
+ review: unknown
+): Promise<PrivateSession | undefined> {
+ if (typeof window === 'undefined' || review !== 'reviewed_private_session')
+ return undefined;
+ const before = identityMessagingOwnership(identity);
+ if (!before) return undefined;
+ const checked = await recheckIdentityOwner(identity);
+ const capture = identityMessagingOwnership(identity);
+ if (
+ !before.current() ||
+ checked.state !== 'messaging_capable' ||
+ checked.admission === 'busy' ||
+ !capture ||
+ capture.owner !== before.owner ||
+ capture.session !== before.session
+ )
+ return undefined;
+ const existing = currentSessions.get(identity);
+ if (existing && sessions.get(existing)?.current()) return existing;
+ const token = Object.freeze({}) as PrivateSession;
+ const listeners = new Map<symbol, () => void>();
+ let closed = false;
+ let unsubscribe = () => {};
+ const current = () => !closed && capture.current();
+ function close() {
+ if (closed) return;
+ closed = true;
+ unsubscribe();
+ for (const listener of listeners.values()) {
+ try {
+ listener();
+ } catch {
+ /* Pool retains failed cleanup until retry. */
+ }
+ }
+ listeners.clear();
+ }
+ sessions.set(token, {
+ identity,
+ capture,
+ current,
+ close,
+ subscribe(listener) {
+ if (!current()) {
+ close();
+ listener();
+ return () => {};
+ }
+ const id = Symbol();
+ listeners.set(id, listener);
+ return () => {
+ listeners.delete(id);
+ };
+ }
+ });
+ unsubscribe = subscribeIdentityInvalidation(identity, () => {
+ if (!current()) close();
+ });
+ // Observe again after registering: no missed invalidation/acquisition seam.
+ if (!current()) {
+ close();
+ return undefined;
+ }
+ currentSessions.set(identity, token);
+ return token;
+}
+export function privateSessionOwnership(
+ token: PrivateSession
+): PublicEffectCapture | undefined {
+ const state = sessions.get(token);
+ if (!state?.current()) {
+ state?.close();
+ return undefined;
+ }
+ return {
+ owner: state.capture.owner,
+ session: state.capture.session,
+ current: () => state.current()
+ };
+}
+export function privateSessionSnapshot(
+ token: PrivateSession
+): Readonly<{ owner: string; current: boolean }> | undefined {
+ const state = sessions.get(token);
+ return state && { owner: state.capture.owner, current: state.current() };
+}
+export function subscribePrivateSessionClose(
+ token: PrivateSession,
+ listener: () => void
+): () => void {
+ const state = sessions.get(token);
+ if (!state) throw new Error('private_session_invalid');
+ return state.subscribe(listener);
+}
+export function closePrivateSession(token: PrivateSession): void {
+ sessions.get(token)?.close();
+}
+// Every new finite network action gets a fresh SDK owner observation; neither
+// a remembered key nor a still-current presentation snapshot substitutes.
+export async function recheckPrivateSession(
+ token: PrivateSession
+): Promise<boolean> {
+ const state = sessions.get(token);
+ if (!state?.current()) return false;
+ const checked = await recheckIdentityOwner(state.identity);
+ return (
+ state.current() &&
+ checked.state === 'messaging_capable' &&
+ checked.publicKey === state.capture.owner &&
+ checked.admission !== 'busy'
+ );
+}
diff --git a/web/tests/integration/private-pool.test.ts b/web/tests/integration/private-pool.test.ts
@@ -0,0 +1,861 @@
+import { test } from 'node:test';
+import assert from 'node:assert/strict';
+import { once } from 'node:events';
+import WebSocket, { WebSocketServer } from 'ws';
+import { RelayPool } from 'applesauce-relay/pool';
+import { createRequire } from 'node:module';
+import { validateRelayPolicy } from '../../src/lib/config/relays.ts';
+import {
+ createIdentitySession,
+ connectIdentity,
+ probeIdentityMessaging,
+ disconnectIdentity,
+ recheckIdentityOwner
+} from '../../src/lib/runtime/identity-session.ts';
+import {
+ createPrivateSession,
+ privateSessionSnapshot,
+ closePrivateSession
+} from '../../src/lib/runtime/private-session.ts';
+import {
+ getPrivatePool,
+ privatePoolOrigins,
+ subscribePrivatePage,
+ closePrivatePool,
+ type PrivatePageMessage
+} from '../../src/lib/nostr/private-pool.ts';
+import {
+ getPublicPool,
+ subscribePublicPool,
+ closePublicPool
+} from '../../src/lib/nostr/public-pool.ts';
+
+// HC_TEST_ONLY_RELAY/provider: genuine pinned SDK, fixed logical origins mapped
+// solely here to loopback. Echo cipher and AUTH-state instrumentation qualify
+// transport/lifecycle isolation, never encryption, signatures or relay access.
+await test('private page transport keeps actual SDK scopes and ownership separate', async (t) => {
+ // Resolve the SDK's actual pinned transitive RxJS for teardown fault injection;
+ // it is not a new application dependency or replacement Observable.
+ const sdkRxjs: unknown = createRequire(
+ import.meta.resolve('applesauce-relay/pool')
+ )('rxjs');
+ const Subscription = (
+ sdkRxjs as {
+ Subscription: {
+ prototype: ReturnType<ReturnType<RelayPool['req']>['subscribe']>;
+ };
+ }
+ ).Subscription;
+ const owner =
+ '79be667ef9dcbbac55a06295ce870b07029bfcdb2dce28d959f2815b16f81798';
+ const other =
+ 'c6047f9441ed7d6d3045406e95c07cd85c778e4b8cef3ca7abac09b95c709ee5';
+ const origins = [
+ 'wss://relay.example.org',
+ 'wss://relay-two.example.org',
+ 'wss://relay-three.example.org'
+ ];
+ const policy = validateRelayPolicy(
+ JSON.stringify({
+ schemaVersion: 1,
+ public: origins.map((origin) => ({
+ origin,
+ read: true,
+ write: false,
+ nip50: false
+ })),
+ inbox: origins.map((origin) => ({ origin, read: true, write: true })),
+ postingEnabled: false,
+ messagingEnabled: true,
+ operatorDenylist: []
+ })
+ );
+ assert.ok(policy);
+ assert.equal(
+ await createPrivateSession(
+ createIdentitySession(),
+ 'reviewed_private_session'
+ ),
+ undefined
+ );
+ assert.equal(getPrivatePool({} as never, policy, origins), undefined);
+ const originalSocket = globalThis.WebSocket,
+ originalFetch = globalThis.fetch,
+ originalReq = Reflect.get(RelayPool.prototype, 'req'),
+ originalClose = Reflect.get(RelayPool.prototype, 'close');
+ assert.equal(
+ Object.getOwnPropertyDescriptor(globalThis, 'window'),
+ undefined
+ );
+ const server = new WebSocketServer({
+ host: '127.0.0.1',
+ port: 0,
+ maxPayload: 65536
+ });
+ const sockets: WebSocket[] = [];
+ const frames: unknown[][] = [];
+ let delivery:
+ | 'normal'
+ | 'flood'
+ | 'oversize'
+ | 'hold'
+ | 'byte-flood'
+ | 'rejected-byte-flood'
+ | 'single' = 'normal';
+ let eventWritten = false;
+ let heldReady = () => {};
+ let heldRequests = 0;
+ const raw = {
+ id: '1'.repeat(64),
+ pubkey: other,
+ kind: 1059,
+ created_at: 1,
+ tags: [['p', owner]],
+ content: 'untrusted ciphertext',
+ sig: '0'.repeat(128)
+ };
+ server.on('connection', (socket) => {
+ sockets.push(socket);
+ socket.send(JSON.stringify(['AUTH', 'unsolicited-challenge']));
+ socket.on('message', (bytes) => {
+ const buffer = Array.isArray(bytes)
+ ? Buffer.concat(bytes)
+ : Buffer.isBuffer(bytes)
+ ? bytes
+ : Buffer.from(bytes);
+ const frame: unknown = JSON.parse(buffer.toString('utf8'));
+ assert.ok(Array.isArray(frame));
+ frames.push(frame);
+ if (frame[0] !== 'REQ') return;
+ const filter = frame[2] as { kinds: number[] };
+ if (filter.kinds[0] === 1059 && delivery === 'hold') {
+ heldRequests++;
+ if (heldRequests === 3) heldReady();
+ } else if (
+ filter.kinds[0] === 1059 &&
+ (delivery === 'flood' ||
+ delivery === 'byte-flood' ||
+ delivery === 'rejected-byte-flood')
+ ) {
+ const candidate =
+ delivery === 'flood'
+ ? raw
+ : {
+ ...raw,
+ content: 'x'.repeat(delivery === 'byte-flood' ? 20000 : 40000)
+ };
+ for (let i = 0; i < 501; i++)
+ socket.send(JSON.stringify(['EVENT', frame[1], candidate]));
+ } else if (filter.kinds[0] === 1059 && delivery === 'single') {
+ eventWritten = true;
+ socket.send(JSON.stringify(['EVENT', frame[1], raw]));
+ socket.send(JSON.stringify(['EOSE', frame[1]]));
+ } else if (filter.kinds[0] === 1059 && delivery === 'oversize') {
+ socket.send(
+ JSON.stringify([
+ 'EVENT',
+ frame[1],
+ { ...raw, content: 'x'.repeat(32768) }
+ ])
+ );
+ socket.send(JSON.stringify(['EOSE', frame[1]]));
+ } else socket.send(JSON.stringify(['EOSE', frame[1]]));
+ });
+ });
+ await once(server, 'listening');
+ const address = server.address();
+ assert.ok(address && typeof address !== 'string');
+ const fixturePort = address.port;
+ let key = owner,
+ calls = 0,
+ signs = 0,
+ constructed = 0;
+ class FixtureSocket extends WebSocket {
+ constructor(url: string | URL) {
+ assert.ok(origins.includes(new URL(String(url)).origin));
+ constructed++;
+ super(`ws://127.0.0.1:${fixturePort}`);
+ }
+ }
+ Object.defineProperty(globalThis, 'window', {
+ configurable: true,
+ value: {
+ nostr: {
+ getPublicKey: () => {
+ calls++;
+ return Promise.resolve(key);
+ },
+ signEvent: () => {
+ signs++;
+ return Promise.reject(new Error('Unexpected signer'));
+ },
+ nip44: {
+ encrypt: (_peer: string, text: string) =>
+ Promise.resolve('fixture:' + text),
+ decrypt: (_peer: string, text: string) =>
+ Promise.resolve(text.slice(8))
+ }
+ }
+ }
+ });
+ globalThis.WebSocket =
+ FixtureSocket as unknown as typeof globalThis.WebSocket;
+ globalThis.fetch = () =>
+ Promise.reject(new Error('Unexpected information fetch'));
+ const sdkScopes = new Map<'public' | 'private', RelayPool>();
+ const allScopes = new Set<RelayPool>();
+ let requestCalls = 0;
+ RelayPool.prototype.req = function (relays, filters, options) {
+ requestCalls++;
+ allScopes.add(this);
+ assert.ok(Array.isArray(filters));
+ const filter = filters[0] as { kinds: number[] };
+ sdkScopes.set(filter.kinds[0] === 1059 ? 'private' : 'public', this);
+ return originalReq.call(this, relays, filters, options);
+ };
+ const identity = createIdentitySession();
+ let privateSession: Awaited<ReturnType<typeof createPrivateSession>>;
+ let privatePool: ReturnType<typeof getPrivatePool>;
+ let publicPool: ReturnType<typeof getPublicPool>;
+ const stops: Array<() => void> = [];
+ function publicPage() {
+ return new Promise<void>((resolve) => {
+ const seen = new Set<string>();
+ stops.push(
+ subscribePublicPool(
+ publicPool!,
+ [{ kinds: [30402], limit: 1 }],
+ (message) => {
+ if (message.type === 'EOSE') {
+ seen.add(message.from);
+ if (seen.size === 3) resolve();
+ }
+ }
+ )
+ );
+ });
+ }
+ async function heldPage() {
+ delivery = 'hold';
+ heldRequests = 0;
+ const ready = new Promise<void>((resolve) => {
+ heldReady = resolve;
+ });
+ stops.push(subscribePrivatePage(privatePool!, 200, () => {}));
+ await ready;
+ }
+ try {
+ await t.test(
+ 'guest, forged and unreviewed session cannot acquire sockets',
+ async () => {
+ assert.equal(
+ await createPrivateSession(identity, 'unreviewed'),
+ undefined
+ );
+ assert.equal(
+ await createPrivateSession(identity, 'reviewed_private_session'),
+ undefined
+ );
+ assert.throws(
+ () => getPrivatePool({} as never, policy, origins),
+ /private_session_invalid/
+ );
+ assert.equal(constructed, 0);
+ assert.equal(calls, 0);
+ }
+ );
+ await connectIdentity(identity);
+ await probeIdentityMessaging(identity, 'reviewed_self_copy');
+ await t.test(
+ 'explicit admission rechecks the genuine owner through the shared SDK',
+ async () => {
+ const before = calls;
+ privateSession = await createPrivateSession(
+ identity,
+ 'reviewed_private_session'
+ );
+ assert.ok(privateSession);
+ assert.equal(calls, before + 1);
+ assert.deepEqual(Object.keys(privateSession), []);
+ assert.ok(Object.isFrozen(privateSession));
+ assert.deepEqual(privateSessionSnapshot(privateSession), {
+ owner,
+ current: true
+ });
+ assert.equal(constructed, 0);
+ }
+ );
+ await t.test(
+ 'selection refuses hints, duplicates and oversized destination sets before egress',
+ () => {
+ assert.throws(
+ () =>
+ getPrivatePool(privateSession!, policy, [
+ ...origins,
+ 'wss://unapproved.example.org'
+ ]),
+ /private_pool_origins_invalid/
+ );
+ assert.throws(
+ () =>
+ getPrivatePool(privateSession!, policy, [
+ 'wss://unapproved.example.org'
+ ]),
+ /private_pool_origins_invalid/
+ );
+ assert.throws(
+ () =>
+ getPrivatePool(privateSession!, policy, [origins[0], origins[0]]),
+ /private_pool_origins_invalid/
+ );
+ const selected = [...origins];
+ let reentrant: ReturnType<typeof getPrivatePool>;
+ Object.defineProperty(selected, '0', {
+ configurable: true,
+ get: () => {
+ reentrant = getPrivatePool(privateSession!, policy, origins);
+ return origins[0];
+ }
+ });
+ privatePool = getPrivatePool(privateSession!, policy, selected);
+ assert.ok(privatePool);
+ assert.equal(privatePool, reentrant);
+ Object.defineProperty(selected, '0', {
+ configurable: true,
+ writable: true,
+ value: origins[0]
+ });
+ selected[0] = 'wss://unapproved.example.org';
+ const detached = privatePoolOrigins(privatePool) as string[];
+ detached.push('wss://unapproved.example.org');
+ assert.deepEqual(privatePoolOrigins(privatePool), origins);
+ assert.equal(
+ getPrivatePool(privateSession!, policy, origins),
+ privatePool
+ );
+ assert.throws(
+ () => subscribePrivatePage(privatePool!, 201, () => {}),
+ /private_page_limit_invalid/
+ );
+ assert.equal(constructed, 0);
+ }
+ );
+ await t.test(
+ 'three public and three private same-origin sockets have separate AUTH state',
+ async () => {
+ publicPool = getPublicPool(policy);
+ assert.ok(publicPool);
+ await publicPage();
+ await heldPage();
+ assert.equal(constructed, 6);
+ assert.equal(server.clients.size, 6);
+ const pub = sdkScopes.get('public'),
+ priv = sdkScopes.get('private');
+ assert.ok(pub && priv);
+ assert.notEqual(pub, priv);
+ for (const origin of origins) {
+ const a = pub.relay(origin),
+ b = priv.relay(origin);
+ assert.notEqual(a, b);
+ assert.notEqual(a.authentication$, b.authentication$);
+ b.authentication$.next({
+ ...raw,
+ kind: 22242,
+ pubkey: owner
+ } as never);
+ assert.equal(a.authentication, null);
+ }
+ assert.equal(signs, 0);
+ assert.ok(
+ frames.every((frame) => frame[0] !== 'AUTH' && frame[0] !== 'EVENT')
+ );
+ const privateReq = frames.filter(
+ (frame) => (frame[2] as { kinds?: number[] })?.kinds?.[0] === 1059
+ );
+ assert.equal(privateReq.length, 3);
+ for (const frame of privateReq)
+ assert.deepEqual(frame[2], {
+ kinds: [1059],
+ '#p': [owner],
+ limit: 200
+ });
+ }
+ );
+ await t.test(
+ 'logout closes actual private sockets and public discovery continues',
+ async () => {
+ const privateSockets = sockets.slice(3, 6);
+ const closed = privateSockets.map((socket) => once(socket, 'close'));
+ disconnectIdentity(identity);
+ await Promise.all(closed);
+ assert.equal(server.clients.size, 3);
+ assert.equal(privateSessionSnapshot(privateSession!)?.current, false);
+ assert.throws(
+ () => subscribePrivatePage(privatePool!, 1, () => {}),
+ /private_pool_closed/
+ );
+ await publicPage();
+ assert.equal(constructed, 6);
+ }
+ );
+ await t.test(
+ 'same-author reconnect cannot revive an old scope or consume stale callbacks',
+ async () => {
+ await connectIdentity(identity);
+ await probeIdentityMessaging(identity, 'reviewed_self_copy');
+ assert.equal(privateSessionSnapshot(privateSession!)?.current, false);
+ const next = await createPrivateSession(
+ identity,
+ 'reviewed_private_session'
+ );
+ assert.ok(next);
+ assert.notEqual(next, privateSession);
+ privateSession = next;
+ privatePool = getPrivatePool(next, policy, origins);
+ assert.ok(privatePool);
+ const before = constructed;
+ await heldPage();
+ assert.equal(constructed, before + 3);
+ }
+ );
+ await t.test(
+ 'failed SDK cleanup blocks replacement until exact cleanup retry succeeds',
+ () => {
+ const before = constructed;
+ const held = sdkScopes.get('private');
+ assert.ok(held);
+ RelayPool.prototype.close = function () {
+ if (this === held) throw new Error('HC_TEST_ONLY_CLOSE_FAILURE');
+ return originalClose.call(this);
+ };
+ assert.throws(
+ () => closePrivatePool(privatePool!),
+ /private_pool_close_failed/
+ );
+ assert.throws(
+ () => getPrivatePool(privateSession!, policy, origins),
+ /private_pool_closed/
+ );
+ assert.equal(constructed, before);
+ RelayPool.prototype.close = originalClose;
+ closePrivatePool(privatePool!);
+ }
+ );
+ await t.test(
+ 'observed account loss closes session generation without affecting public scope',
+ async () => {
+ privatePool = getPrivatePool(privateSession!, policy, origins);
+ assert.ok(privatePool);
+ await heldPage();
+ const newest = [...server.clients].filter(
+ (socket) => !sockets.slice(0, 3).includes(socket)
+ );
+ const closed = newest.map((socket) => once(socket, 'close'));
+ key = other;
+ await recheckIdentityOwner(identity);
+ await Promise.all(closed);
+ assert.equal(privateSessionSnapshot(privateSession!)?.current, false);
+ assert.equal(
+ await createPrivateSession(identity, 'reviewed_private_session'),
+ undefined
+ );
+ await publicPage();
+ assert.equal(signs, 0);
+ }
+ );
+ key = owner;
+ await connectIdentity(identity);
+ await probeIdentityMessaging(identity, 'reviewed_self_copy');
+ privateSession = await createPrivateSession(
+ identity,
+ 'reviewed_private_session'
+ );
+ assert.ok(privateSession);
+ privatePool = getPrivatePool(privateSession, policy, origins);
+ assert.ok(privatePool);
+ await t.test(
+ 'oversized raw envelope is counted and rejected before consumer delivery',
+ async () => {
+ delivery = 'oversize';
+ let candidates = 0;
+ await new Promise<void>((resolve) => {
+ stops.push(
+ subscribePrivatePage(privatePool!, 200, (message) => {
+ if (message.type === 'candidate') candidates++;
+ else resolve();
+ })
+ );
+ });
+ assert.equal(candidates, 0);
+ delivery = 'normal';
+ }
+ );
+ await t.test(
+ 'duplicate deliveries consume the finite 500-candidate budget',
+ async () => {
+ delivery = 'flood';
+ let candidates = 0;
+ const end = await new Promise<PrivatePageMessage>((resolve) => {
+ stops.push(
+ subscribePrivatePage(privatePool!, 200, (message) => {
+ if (message.type === 'candidate') candidates++;
+ else resolve(message);
+ })
+ );
+ });
+ assert.equal(candidates, 500);
+ assert.deepEqual(end, { type: 'end', reason: 'budget' });
+ delivery = 'normal';
+ }
+ );
+ await t.test(
+ 'encoded bytes and rejected envelopes consume the exact finite 8MiB budget',
+ async () => {
+ delivery = 'byte-flood';
+ let candidates = 0,
+ bytes = 0;
+ const end = await new Promise<PrivatePageMessage>((resolve) => {
+ stops.push(
+ subscribePrivatePage(privatePool!, 200, (message) => {
+ if (message.type === 'candidate') {
+ candidates++;
+ bytes += Buffer.byteLength(message.wire, 'utf8');
+ } else resolve(message);
+ })
+ );
+ });
+ const charge = Buffer.byteLength(
+ JSON.stringify({ ...raw, content: 'x'.repeat(20000) }),
+ 'utf8'
+ );
+ assert.equal(candidates, Math.floor(8388608 / charge));
+ assert.ok(bytes <= 8388608);
+ assert.deepEqual(end, { type: 'end', reason: 'budget' });
+ delivery = 'rejected-byte-flood';
+ let rejectedCandidates = 0;
+ const rejectedEnd = await new Promise<PrivatePageMessage>((resolve) => {
+ stops.push(
+ subscribePrivatePage(privatePool!, 200, (message) => {
+ if (message.type === 'candidate') rejectedCandidates++;
+ else resolve(message);
+ })
+ );
+ });
+ assert.equal(rejectedCandidates, 0);
+ assert.deepEqual(rejectedEnd, { type: 'end', reason: 'budget' });
+ delivery = 'normal';
+ }
+ );
+ await t.test(
+ 'finite network page enforces the original 15second elapsed boundary',
+ async () => {
+ delivery = 'hold';
+ const original = performance.now.bind(performance),
+ descriptor = Object.getOwnPropertyDescriptor(performance, 'now');
+ let observations = 0;
+ Object.defineProperty(performance, 'now', {
+ configurable: true,
+ value: () => {
+ observations++;
+ return original() + (observations > 1 ? 15000 : 0);
+ }
+ });
+ try {
+ const end = await new Promise<PrivatePageMessage>((resolve) => {
+ stops.push(
+ subscribePrivatePage(privatePool!, 200, (message) => {
+ if (message.type === 'end') resolve(message);
+ })
+ );
+ });
+ assert.ok(observations > 1);
+ assert.deepEqual(end, { type: 'end', reason: 'elapsed' });
+ } finally {
+ if (descriptor) Object.defineProperty(performance, 'now', descriptor);
+ else Reflect.deleteProperty(performance, 'now');
+ delivery = 'normal';
+ }
+ }
+ );
+ await t.test(
+ 'asynchronous EOSE cleanup failure emits error and retains unavailable page without escaping',
+ async () => {
+ delivery = 'normal';
+ const original = Reflect.get(Subscription.prototype, 'unsubscribe');
+ let failNext = true;
+ Subscription.prototype.unsubscribe = function () {
+ if (failNext && new Error().stack?.includes('at release (')) {
+ failNext = false;
+ throw new Error('HC_TEST_ONLY_ASYNC_UNSUBSCRIBE_FAILURE');
+ }
+ return original.call(this);
+ };
+ try {
+ const end = await new Promise<PrivatePageMessage>((resolve) => {
+ stops.push(
+ subscribePrivatePage(privatePool!, 200, (message) => {
+ if (message.type === 'end') resolve(message);
+ })
+ );
+ });
+ assert.deepEqual(end, { type: 'end', reason: 'error' });
+ assert.throws(
+ () => subscribePrivatePage(privatePool!, 1, () => {}),
+ /private_page_cleanup_required/
+ );
+ await new Promise<void>((resolve) => setImmediate(resolve));
+ } finally {
+ Subscription.prototype.unsubscribe = original;
+ closePrivatePool(privatePool!);
+ privatePool = getPrivatePool(privateSession!, policy, origins);
+ assert.ok(privatePool);
+ }
+ }
+ );
+ await t.test(
+ 'failed page unsubscribe keeps new SDK admission blocked until cleanup retry',
+ async () => {
+ await heldPage();
+ const stop = stops[stops.length - 1];
+ const original = Reflect.get(Subscription.prototype, 'unsubscribe');
+ let failNext = true;
+ Subscription.prototype.unsubscribe = function () {
+ if (failNext) {
+ failNext = false;
+ throw new Error('HC_TEST_ONLY_UNSUBSCRIBE_FAILURE');
+ }
+ return original.call(this);
+ };
+ let unexpected: (() => void) | undefined;
+ const before = requestCalls;
+ try {
+ assert.throws(() => stop(), /HC_TEST_ONLY_UNSUBSCRIBE_FAILURE/);
+ assert.throws(() => {
+ unexpected = subscribePrivatePage(privatePool!, 1, () => {});
+ }, /private_pool_closed|private_page_cleanup_required/);
+ assert.equal(requestCalls, before);
+ } finally {
+ unexpected?.();
+ Subscription.prototype.unsubscribe = original;
+ closePrivatePool(privatePool!);
+ }
+ }
+ );
+ await t.test(
+ 'clock reentry cannot admit an SDK request after owner logout',
+ async () => {
+ await new Promise<void>((resolve) => setImmediate(resolve));
+ assert.equal(
+ (await recheckIdentityOwner(identity)).state,
+ 'messaging_capable'
+ );
+ privatePool = getPrivatePool(privateSession!, policy, origins);
+ assert.ok(privatePool);
+ const original = performance.now.bind(performance);
+ const descriptor = Object.getOwnPropertyDescriptor(performance, 'now');
+ const before = requestCalls;
+ let invalidations = 0;
+ Object.defineProperty(performance, 'now', {
+ configurable: true,
+ value: () => {
+ invalidations++;
+ disconnectIdentity(identity);
+ return original();
+ }
+ });
+ try {
+ await new Promise<void>((resolve) => {
+ stops.push(
+ subscribePrivatePage(privatePool!, 1, (message) => {
+ if (message.type === 'end') resolve();
+ })
+ );
+ });
+ assert.ok(invalidations > 0);
+ assert.equal(requestCalls, before);
+ } finally {
+ if (descriptor) Object.defineProperty(performance, 'now', descriptor);
+ else Reflect.deleteProperty(performance, 'now');
+ }
+ }
+ );
+ await t.test(
+ 'candidate clock reentry cannot disclose old-owner ciphertext after logout',
+ async () => {
+ await connectIdentity(identity);
+ await probeIdentityMessaging(identity, 'reviewed_self_copy');
+ privateSession = await createPrivateSession(
+ identity,
+ 'reviewed_private_session'
+ );
+ assert.ok(privateSession);
+ privatePool = getPrivatePool(privateSession, policy, [origins[0]]);
+ assert.ok(privatePool);
+ delivery = 'single';
+ eventWritten = false;
+ let candidates = 0,
+ invalidations = 0;
+ const original = performance.now.bind(performance),
+ descriptor = Object.getOwnPropertyDescriptor(performance, 'now');
+ Object.defineProperty(performance, 'now', {
+ configurable: true,
+ value: () => {
+ if (eventWritten) {
+ invalidations++;
+ disconnectIdentity(identity);
+ }
+ return original();
+ }
+ });
+ try {
+ await new Promise<void>((resolve) => {
+ stops.push(
+ subscribePrivatePage(privatePool!, 1, (message) => {
+ if (message.type === 'candidate') candidates++;
+ else resolve();
+ })
+ );
+ });
+ assert.ok(eventWritten && invalidations > 0);
+ assert.equal(candidates, 0);
+ assert.equal(privateSessionSnapshot(privateSession)?.current, false);
+ } finally {
+ if (descriptor) Object.defineProperty(performance, 'now', descriptor);
+ else Reflect.deleteProperty(performance, 'now');
+ delivery = 'normal';
+ }
+ }
+ );
+ await t.test(
+ 'delayed genuine SDK owner response cannot open old-session sockets after logout',
+ async () => {
+ await connectIdentity(identity);
+ await probeIdentityMessaging(identity, 'reviewed_self_copy');
+ privateSession = await createPrivateSession(
+ identity,
+ 'reviewed_private_session'
+ );
+ assert.ok(privateSession);
+ privatePool = getPrivatePool(privateSession, policy, origins);
+ assert.ok(privatePool);
+ const browser = Reflect.get(globalThis, 'window');
+ const provider: unknown = browser.nostr;
+ assert.ok(provider && typeof provider === 'object');
+ const descriptor = Object.getOwnPropertyDescriptor(
+ provider,
+ 'getPublicKey'
+ );
+ assert.ok(descriptor);
+ let release = (_key: string) => {
+ void _key;
+ };
+ let entered = () => {};
+ const observed = new Promise<void>((resolve) => {
+ entered = resolve;
+ });
+ Object.defineProperty(provider, 'getPublicKey', {
+ configurable: true,
+ value: () => {
+ entered();
+ return new Promise<string>((resolve) => {
+ release = resolve;
+ });
+ }
+ });
+ const before = requestCalls;
+ let candidates = 0;
+ const end = new Promise<PrivatePageMessage>((resolve) => {
+ stops.push(
+ subscribePrivatePage(privatePool!, 1, (message) => {
+ if (message.type === 'candidate') candidates++;
+ else resolve(message);
+ })
+ );
+ });
+ try {
+ await observed;
+ disconnectIdentity(identity);
+ assert.deepEqual(await end, { type: 'end', reason: 'closed' });
+ Object.defineProperty(provider, 'getPublicKey', descriptor);
+ release(owner);
+ await new Promise<void>((resolve) => setImmediate(resolve));
+ assert.equal(requestCalls, before);
+ assert.equal(candidates, 0);
+ assert.equal(privateSessionSnapshot(privateSession)?.current, false);
+ key = other;
+ await connectIdentity(identity);
+ await probeIdentityMessaging(identity, 'reviewed_self_copy');
+ const next = await createPrivateSession(
+ identity,
+ 'reviewed_private_session'
+ );
+ assert.ok(next);
+ assert.deepEqual(privateSessionSnapshot(next), {
+ owner: other,
+ current: true
+ });
+ assert.equal(privateSessionSnapshot(privateSession)?.current, false);
+ closePrivateSession(next);
+ disconnectIdentity(identity);
+ key = owner;
+ } finally {
+ Object.defineProperty(provider, 'getPublicKey', descriptor);
+ release(owner);
+ }
+ }
+ );
+ await t.test(
+ 'capability loss closes actual private transport and signing alone cannot reopen it',
+ async () => {
+ await connectIdentity(identity);
+ await probeIdentityMessaging(identity, 'reviewed_self_copy');
+ privateSession = await createPrivateSession(
+ identity,
+ 'reviewed_private_session'
+ );
+ assert.ok(privateSession);
+ privatePool = getPrivatePool(privateSession, policy, origins);
+ assert.ok(privatePool);
+ await heldPage();
+ const newest = [...server.clients].filter(
+ (socket) => !sockets.slice(0, 3).includes(socket)
+ );
+ const closed = newest.map((socket) => once(socket, 'close'));
+ const browser = Reflect.get(globalThis, 'window');
+ const provider: unknown = browser.nostr;
+ assert.ok(provider && typeof provider === 'object');
+ Object.defineProperty(provider, 'nip44', {
+ configurable: true,
+ value: undefined
+ });
+ const checked = await recheckIdentityOwner(identity);
+ await Promise.all(closed);
+ assert.equal(checked.state, 'signing_only');
+ assert.equal(privateSessionSnapshot(privateSession)?.current, false);
+ const before = constructed;
+ assert.equal(
+ await createPrivateSession(identity, 'reviewed_private_session'),
+ undefined
+ );
+ assert.equal(constructed, before);
+ await publicPage();
+ }
+ );
+ } finally {
+ RelayPool.prototype.close = originalClose;
+ if (privatePool) closePrivatePool(privatePool);
+ if (privateSession) closePrivateSession(privateSession);
+ disconnectIdentity(identity);
+ for (const stop of stops) stop();
+ if (publicPool) closePublicPool(publicPool);
+ RelayPool.prototype.req = originalReq;
+ for (const scope of allScopes) scope.close();
+ for (const socket of server.clients) socket.terminate();
+ await new Promise<void>((resolve, reject) =>
+ server.close((error) => (error ? reject(error) : resolve()))
+ );
+ globalThis.WebSocket = originalSocket;
+ globalThis.fetch = originalFetch;
+ Reflect.deleteProperty(globalThis, 'window');
+ }
+});
diff --git a/web/tests/unit/private-session.test.ts b/web/tests/unit/private-session.test.ts
@@ -0,0 +1,29 @@
+import { expect, it } from 'vitest';
+import { createIdentitySession } from '../../src/lib/runtime/identity-session.ts';
+import {
+ createPrivateSession,
+ privateSessionSnapshot,
+ privateSessionOwnership,
+ closePrivateSession,
+ type PrivateSession
+} from '../../src/lib/runtime/private-session.ts';
+import { getPrivatePool } from '../../src/lib/nostr/private-pool.ts';
+it('SSR private import and explicit admission acquire no browser transport', async () => {
+ const identity = createIdentitySession();
+ expect(
+ await createPrivateSession(identity, 'reviewed_private_session')
+ ).toBeUndefined();
+ expect(getPrivatePool({} as PrivateSession, {} as never, [])).toBeUndefined();
+});
+it('guest observation and unreviewed admission do not create private authority', async () => {
+ const identity = createIdentitySession();
+ expect(await createPrivateSession(identity, 'unreviewed')).toBeUndefined();
+ expect(
+ await createPrivateSession({} as never, 'reviewed_private_session')
+ ).toBeUndefined();
+});
+it('forged private session cannot expose an owner or generation', () => {
+ expect(privateSessionSnapshot({} as PrivateSession)).toBeUndefined();
+ expect(privateSessionOwnership({} as PrivateSession)).toBeUndefined();
+ expect(() => closePrivateSession({} as PrivateSession)).not.toThrow();
+});