commit 0c1d9f424b32953869eed96da19ce4cf1f809088
parent f405253b5775c21d1d7aea766e3b6ef028783690
Author: triesap <tyson@radroots.org>
Date: Wed, 14 Oct 2026 04:48:58 +0000
harvestcircle_web: Own scoped private AUTH and connection cleanup
- Bind explicit AUTH to genuine current sessions, inbox heads, targets and guarded responses.
- Share bounded role scopes and original connection leases with physical closure barriers.
- Preserve attempt accounting and exact cleanup retry across receive and delivery owners.
- Verify hostile source guards, lifecycle races and 204 affected browser workflows.
Diffstat:
23 files changed, 2933 insertions(+), 334 deletions(-)
diff --git a/web/src/lib/messaging/inbox-access-controller.ts b/web/src/lib/messaging/inbox-access-controller.ts
@@ -0,0 +1,314 @@
+import {
+ inboxRelayTargets,
+ publicRelayTargets,
+ readRelayPolicy,
+ type RelayPolicy
+} from '../config/relays.ts';
+import { inboxPreferenceSnapshot } from '../nostr/inbox-preferences.ts';
+import {
+ beginInboxAuthentication,
+ respondInboxAuthentication,
+ closeInboxAuthentication,
+ inboxAuthSnapshot,
+ type InboxAuthAction
+} from '../nostr/inbox-auth.ts';
+import {
+ getPrivatePool,
+ closePrivatePool,
+ privatePoolCleanupRequired,
+ type PrivatePool
+} from '../nostr/private-pool.ts';
+import {
+ privateSessionOwnership,
+ subscribePrivateSessionClose,
+ type PrivateSession
+} from '../runtime/private-session.ts';
+import {
+ inboxResolutionSnapshot,
+ inboxResolverCurrentAfterSample,
+ type InboxResolver
+} from './resolve-inbox.ts';
+
+declare const accessBrand: unique symbol;
+export type InboxAccessController = Readonly<{ [accessBrand]: true }>;
+type Binding = Readonly<{
+ owner: string;
+ preferenceId: string;
+ readTargets: string[];
+ archiveTargets: string[];
+}>;
+export type InboxAccessSnapshot = Readonly<
+ Binding & {
+ state: string;
+ busy: boolean;
+ cleanupRequired: boolean;
+ readiness: 'unavailable';
+ auth: { origin: string; state: string; responses: number }[];
+ }
+>;
+type Control = {
+ policy: RelayPolicy;
+ binding: string;
+ current(): boolean;
+ closed(): boolean;
+ cleanupRequired(): boolean;
+ snapshot(): InboxAccessSnapshot;
+ authenticate(origin: unknown, review: unknown): Promise<string>;
+ respond(origin: unknown, review: unknown): Promise<string>;
+ close(): boolean;
+};
+const controllers = new WeakMap<InboxAccessController, Control>();
+const currentControllers = new WeakMap<PrivateSession, InboxAccessController>();
+function binding(
+ session: PrivateSession,
+ policy: RelayPolicy,
+ own: InboxResolver
+): Binding | undefined {
+ try {
+ const capture = privateSessionOwnership(session),
+ head = inboxResolutionSnapshot(own);
+ const sources = publicRelayTargets(policy, 'read');
+ const preference = head.head && inboxPreferenceSnapshot(head.head);
+ if (
+ !capture?.current() ||
+ !readRelayPolicy(policy).messagingEnabled ||
+ head.author !== capture.owner ||
+ head.status !== 'ready' ||
+ head.coverage !== 'bounded-eose' ||
+ !preference ||
+ preference.status !== 'supported' ||
+ preference.author !== capture.owner ||
+ preference.id !== head.knownBase?.id ||
+ preference.createdAt !== head.knownBase.createdAt ||
+ !sources.length ||
+ head.sources.length !== sources.length ||
+ !sources.every((origin) =>
+ head.sources.some(
+ (source) => source.source === origin && source.state === 'eose'
+ )
+ )
+ )
+ return undefined;
+ const readTargets = inboxRelayTargets(
+ policy,
+ preference.relays,
+ 'read'
+ ).slice();
+ const archiveTargets = inboxRelayTargets(
+ policy,
+ preference.relays,
+ 'write'
+ ).slice();
+ if (
+ !readTargets.length ||
+ !archiveTargets.length ||
+ !capture.current() ||
+ !inboxResolverCurrentAfterSample(own)
+ )
+ return undefined;
+ return {
+ owner: capture.owner,
+ preferenceId: preference.id,
+ readTargets,
+ archiveTargets
+ };
+ } catch {
+ return undefined;
+ }
+}
+// Capture only genuine current discovery/session metadata. No socket, provider,
+// AUTH, probe or publication occurs here. AUTH alone never grants readiness;
+// the separate qualified access probe must supply that later capability.
+export function createInboxAccessController(
+ session: PrivateSession,
+ policy: RelayPolicy,
+ own: InboxResolver
+): InboxAccessController | undefined {
+ if (typeof window === 'undefined') return undefined;
+ const captured = binding(session, policy, own);
+ if (!captured) return undefined;
+ const initial = captured;
+ const wire = JSON.stringify(initial),
+ previous = currentControllers.get(session);
+ const prior = previous && controllers.get(previous);
+ if (
+ prior &&
+ !prior.closed() &&
+ prior.current() &&
+ prior.policy === policy &&
+ prior.binding === wire
+ )
+ return previous;
+ // Stale or failed disposal cannot be silently replaced by another capture.
+ if (prior && (!prior.closed() || prior.cleanupRequired())) return undefined;
+ const token = Object.freeze({}) as InboxAccessController;
+ const auth = new Map<string, InboxAuthAction>();
+ let pool: PrivatePool | undefined,
+ closed = false,
+ cleaned = false,
+ busy = false,
+ epoch = 0,
+ phase = 'not_checked';
+ let off = () => {};
+ const current = () =>
+ !closed && JSON.stringify(binding(session, policy, own)) === wire;
+ function close(): boolean {
+ closed = true;
+ epoch++;
+ phase = 'stopped';
+ let failed = false;
+ for (const [origin, action] of auth) {
+ try {
+ closeInboxAuthentication(action);
+ auth.delete(origin);
+ } catch {
+ failed = true;
+ }
+ }
+ if (pool) {
+ try {
+ closePrivatePool(pool);
+ } catch {
+ failed = true;
+ }
+ if (privatePoolCleanupRequired(pool)) failed = true;
+ }
+ cleaned = !failed;
+ if (cleaned) off();
+ return cleaned;
+ }
+ async function authenticate(
+ origin: unknown,
+ review: unknown
+ ): Promise<string> {
+ if (
+ review !== 'reviewed_inbox_connection_auth' ||
+ typeof origin !== 'string' ||
+ !current() ||
+ (!initial.readTargets.includes(origin) &&
+ !initial.archiveTargets.includes(origin))
+ )
+ return 'unavailable';
+ if (busy) return 'busy';
+ const existing = auth.get(origin);
+ if (existing) return inboxAuthSnapshot(existing)?.state ?? 'stopped';
+ busy = true;
+ const generation = epoch;
+ try {
+ pool ??= getPrivatePool(
+ session,
+ policy,
+ Array.from(
+ new Set([...initial.readTargets, ...initial.archiveTargets])
+ ),
+ token,
+ 'access',
+ current
+ );
+ if (!pool || !current()) return 'unavailable';
+ const action = await beginInboxAuthentication(
+ pool,
+ origin,
+ 'reviewed_connection_auth'
+ );
+ if (!action) return (phase = 'unavailable');
+ if (!current() || generation !== epoch) {
+ closeInboxAuthentication(action);
+ return 'stopped';
+ }
+ auth.set(origin, action);
+ phase = 'authenticating';
+ return inboxAuthSnapshot(action)?.state ?? 'unavailable';
+ } catch {
+ return (phase = closed ? 'stopped' : 'unavailable');
+ } finally {
+ busy = false;
+ }
+ }
+ async function respond(origin: unknown, review: unknown): Promise<string> {
+ const action = typeof origin === 'string' && auth.get(origin);
+ if (!action || review !== 'reviewed_inbox_auth_response' || !current())
+ return 'unavailable';
+ if (busy) return 'busy';
+ busy = true;
+ const generation = epoch;
+ try {
+ const result = await respondInboxAuthentication(action);
+ if (!current() || generation !== epoch) {
+ closeInboxAuthentication(action);
+ return 'stopped';
+ }
+ phase = result.status;
+ return result.status;
+ } catch {
+ return (phase = closed ? 'stopped' : 'unavailable');
+ } finally {
+ busy = false;
+ }
+ }
+ controllers.set(token, {
+ policy,
+ binding: wire,
+ current,
+ closed: () => closed,
+ cleanupRequired: () =>
+ closed && (!cleaned || (!!pool && privatePoolCleanupRequired(pool))),
+ authenticate,
+ respond,
+ close,
+ snapshot: () => ({
+ ...initial,
+ readTargets: [...initial.readTargets],
+ archiveTargets: [...initial.archiveTargets],
+ state: closed ? 'stopped' : current() ? phase : 'stale',
+ busy,
+ cleanupRequired:
+ closed && (!cleaned || (!!pool && privatePoolCleanupRequired(pool))),
+ readiness: 'unavailable',
+ auth: [...auth].map(([origin, action]) => ({
+ origin,
+ state: inboxAuthSnapshot(action)?.state ?? 'stopped',
+ responses: inboxAuthSnapshot(action)?.responses ?? 0
+ }))
+ })
+ });
+ off = subscribePrivateSessionClose(session, () => {
+ if (!close()) throw Error('inbox_access_cleanup_required');
+ });
+ if (!current()) {
+ close();
+ return undefined;
+ }
+ currentControllers.set(session, token);
+ return token;
+}
+export function inboxAccessControllerSnapshot(
+ token: InboxAccessController
+): InboxAccessSnapshot | undefined {
+ return controllers.get(token)?.snapshot();
+}
+export function authenticateInboxAccess(
+ token: InboxAccessController,
+ origin: unknown,
+ review: unknown
+): Promise<string> {
+ return (
+ controllers.get(token)?.authenticate(origin, review) ??
+ Promise.resolve('unavailable')
+ );
+}
+export function respondInboxAccessAuthentication(
+ token: InboxAccessController,
+ origin: unknown,
+ review: unknown
+): Promise<string> {
+ return (
+ controllers.get(token)?.respond(origin, review) ??
+ Promise.resolve('unavailable')
+ );
+}
+export function closeInboxAccessController(
+ token: InboxAccessController
+): boolean {
+ return controllers.get(token)?.close() ?? false;
+}
diff --git a/web/src/lib/messaging/inbox-sync.ts b/web/src/lib/messaging/inbox-sync.ts
@@ -181,9 +181,16 @@ export function captureInboxSync(
);
};
if (!current()) return undefined;
- const pool = getPrivatePool(session, policy, targets);
- if (!pool) return undefined;
const token = Object.freeze({}) as InboxSync;
+ const pool = getPrivatePool(
+ session,
+ policy,
+ targets,
+ token,
+ 'receive',
+ current
+ );
+ if (!pool) return undefined;
let state: State = 'ready',
candidates = 0,
bytes = 0,
@@ -398,7 +405,11 @@ export function captureInboxSync(
queueMicrotask(() => {
if (stopped || failed) return;
if (!current()) {
- stop();
+ try {
+ stop();
+ } catch {
+ /* Original incomplete cleanup remains retryable. */
+ }
return;
}
state = 'live';
diff --git a/web/src/lib/messaging/product-request-controller.ts b/web/src/lib/messaging/product-request-controller.ts
@@ -67,7 +67,12 @@ import {
selfRecoveryPreparationSnapshot,
type SelfRecoveryPreparation
} from './prepare-send.ts';
-import { getPrivatePool } from '../nostr/private-pool.ts';
+import {
+ getPrivatePool,
+ closePrivatePool,
+ privatePoolCleanupRequired,
+ type PrivatePool
+} from '../nostr/private-pool.ts';
import {
capturePrivateRetry,
runPrivateRetry,
@@ -75,7 +80,10 @@ import {
type PrivateRetry
} from './retry-send.ts';
import { newLocalId } from '../private-handles.ts';
-import { privateSessionOwnership } from '../runtime/private-session.ts';
+import {
+ privateSessionOwnership,
+ subscribePrivateSessionClose
+} from '../runtime/private-session.ts';
declare const requestBrand: unique symbol;
export type ProductRequestController = Readonly<{ [requestBrand]: true }>;
@@ -142,6 +150,7 @@ export function createProductRequestController(
let plan: RumorPlan | undefined,
preparation: SelfRecoveryPreparation | undefined,
retry: PrivateRetry | undefined;
+ let privateOff = () => {};
let identityOff = () => {},
generation = 0;
const source = runtime && createPublicView(runtime);
@@ -151,13 +160,29 @@ export function createProductRequestController(
if (preserveComposer && composer) privateComposerSnapshot(composer);
if (retry) stopPrivateRetry(retry);
if (plan) stopRumorPlan(plan);
+ releasePool();
if (!preserveComposer) {
if (composer) closePrivateComposer(composer);
composer = undefined;
}
}
- function close() {
- if (!active) return;
+ let pool: PrivatePool | undefined;
+ let poolCleanupFailed = false;
+ function releasePool() {
+ if (!pool) return true;
+ try {
+ poolCleanupFailed = false;
+ closePrivatePool(pool);
+ if (privatePoolCleanupRequired(pool)) return false;
+ pool = undefined;
+ return true;
+ } catch {
+ poolCleanupFailed = true;
+ return false;
+ }
+ }
+ function close(sessionCleanup = false) {
+ if (!active && !pool) return;
active = false;
stopWork();
identityOff();
@@ -165,10 +190,20 @@ export function createProductRequestController(
if (resolver) closeInboxResolver(resolver);
if (source) disposePublicView(source);
if (database) closeBrowserDatabase(database);
+ if (!releasePool()) {
+ if (poolCleanupFailed || sessionCleanup)
+ throw Error('private_delivery_cleanup_required');
+ return;
+ }
+ privateOff();
}
function current() {
if (!active || !productEnquirySnapshot(enquiry)) {
- close();
+ try {
+ close();
+ } catch {
+ /* Exact original disposal stays retryable. */
+ }
return false;
}
return true;
@@ -483,14 +518,22 @@ export function createProductRequestController(
!receipt
)
return needsAction();
- const pool = getPrivatePool(
+ if (!releasePool()) return needsAction();
+ pool = getPrivatePool(
captured.own.session!,
captured.own.policy,
Array.from(
new Set([...routeData.peer.targets, ...routeData.archive.targets])
- )
+ ),
+ token,
+ 'delivery',
+ admitted
);
if (!pool || !admitted()) return needsAction();
+ privateOff();
+ privateOff = subscribePrivateSessionClose(captured.own.session!, () =>
+ close(true)
+ );
retry = capturePrivateRetry(
repository,
captured.own.session!,
@@ -512,6 +555,7 @@ export function createProductRequestController(
return admitted() ? needsAction() : { status: 'stopped' };
} finally {
busy = false;
+ releasePool();
}
}
const token = Object.freeze({}) as ProductRequestController;
diff --git a/web/src/lib/messaging/reply-controller.ts b/web/src/lib/messaging/reply-controller.ts
@@ -50,7 +50,12 @@ import {
selfRecoveryPreparationSnapshot,
type SelfRecoveryPreparation
} from './prepare-send.ts';
-import { getPrivatePool } from '../nostr/private-pool.ts';
+import {
+ getPrivatePool,
+ closePrivatePool,
+ privatePoolCleanupRequired,
+ type PrivatePool
+} from '../nostr/private-pool.ts';
import {
capturePrivateRetry,
runPrivateRetry,
@@ -132,19 +137,44 @@ export function createReplyController(
retry: PrivateRetry | undefined;
let identityOff = () => {},
privateOff = () => {};
- function close() {
- if (!active) return;
+ let pool: PrivatePool | undefined;
+ let poolCleanupFailed = false;
+ function releasePool() {
+ if (!pool) return true;
+ try {
+ poolCleanupFailed = false;
+ closePrivatePool(pool);
+ if (privatePoolCleanupRequired(pool)) return false;
+ pool = undefined;
+ return true;
+ } catch {
+ poolCleanupFailed = true;
+ return false;
+ }
+ }
+ function close(sessionCleanup = false) {
+ if (!active && !pool) return;
active = false;
if (retry) stopPrivateRetry(retry);
closePrivateComposer(composer!);
if (plan) stopRumorPlan(plan);
+ const clean = releasePool();
+ options.close?.();
+ if (!clean) {
+ if (poolCleanupFailed || sessionCleanup)
+ throw Error('private_delivery_cleanup_required');
+ return;
+ }
identityOff();
privateOff();
- options.close?.();
}
function current() {
if (!active || !scope?.current() || !privateComposerSnapshot(composer!)) {
- close();
+ try {
+ close();
+ } catch {
+ /* Exact original disposal stays retryable. */
+ }
return false;
}
return true;
@@ -327,7 +357,15 @@ export function createReplyController(
const origins = Array.from(
new Set([...routeData.peer.targets, ...routeData.archive.targets])
);
- const pool = getPrivatePool(captured.session, setup.policy, origins);
+ if (!releasePool()) return needsAction();
+ pool = getPrivatePool(
+ captured.session,
+ setup.policy,
+ origins,
+ token,
+ 'delivery',
+ admitted
+ );
if (!pool || !admitted()) return needsAction();
retry = capturePrivateRetry(
captured.repository,
@@ -350,6 +388,7 @@ export function createReplyController(
return current() ? needsAction() : { status: 'stopped' };
} finally {
busy = false;
+ releasePool();
}
}
const token = Object.freeze({}) as ReplyController;
@@ -388,7 +427,9 @@ export function createReplyController(
identityOff = subscribeIdentityInvalidation(original.identity, () => {
if (!original.current()) close();
});
- privateOff = subscribePrivateSessionClose(original.session, close);
+ privateOff = subscribePrivateSessionClose(original.session, () =>
+ close(true)
+ );
return current() ? token : undefined;
}
diff --git a/web/src/lib/nostr/inbox-ingress.ts b/web/src/lib/nostr/inbox-ingress.ts
@@ -130,9 +130,16 @@ export function captureInboxIngress(
);
};
if (!current()) return undefined;
- const pool = getPrivatePool(session, policy, targets);
- if (!pool) return undefined;
const token = Object.freeze({}) as InboxIngress;
+ const pool = getPrivatePool(
+ session,
+ policy,
+ targets,
+ token,
+ 'receive',
+ current
+ );
+ if (!pool) return undefined;
let state: State = 'ready',
candidates = 0,
bytes = 0,
diff --git a/web/src/lib/nostr/private-pool.ts b/web/src/lib/nostr/private-pool.ts
@@ -108,6 +108,10 @@ function finiteBudget(): FiniteBudget {
}
};
}
+type ScopedConnectionCleanup = Readonly<{
+ current(): boolean;
+ close(): void;
+}>;
type Owner = {
session: PrivateSession;
policy: RelayPolicy;
@@ -116,13 +120,22 @@ type Owner = {
token: PrivatePool;
closed(): boolean;
cleaned(): boolean;
+ unavailable(): boolean;
publish(
permission: PrivatePublication,
- signal: AbortSignal
+ signal: AbortSignal,
+ scopeCurrent?: () => boolean,
+ retainConnection?: (
+ origin: string,
+ cleanup: ScopedConnectionCleanup
+ ) => boolean
): Promise<PrivateGiftWrapAttemptResult>;
auth(
origin: string,
- admission: InboxAuthAdmission
+ admission: InboxAuthAdmission,
+ admittedPool?: PrivatePool,
+ scopeCurrent?: () => boolean,
+ retainCleanup?: (cleanup: () => void) => void
): Promise<PrivateAuthConnection | undefined>;
subscribe(
limit: number,
@@ -130,9 +143,23 @@ type Owner = {
since?: number,
budget?: FiniteBudget,
until?: number,
- source?: string
+ source?: string,
+ reads?: readonly string[],
+ scopeCurrent?: () => boolean,
+ retainConnection?: (
+ origin: string,
+ cleanup: ScopedConnectionCleanup
+ ) => boolean
+ ): () => void;
+ subscribeLive(
+ listener: (message: PrivateLiveMessage) => void,
+ reads?: readonly string[],
+ scopeCurrent?: () => boolean,
+ retainConnection?: (
+ origin: string,
+ cleanup: ScopedConnectionCleanup
+ ) => boolean
): () => void;
- subscribeLive(listener: (message: PrivateLiveMessage) => void): () => void;
close(): void;
};
declare const connectionBrand: unique symbol;
@@ -159,17 +186,203 @@ type AuthControl = {
const authConnections = new WeakMap<PrivateAuthConnection, AuthControl>();
const pools = new WeakMap<PrivatePool, Owner>();
let lifetime: Owner | undefined;
+type ScopeRole = 'receive' | 'delivery' | 'access';
+const scopes = new WeakMap<Owner, WeakMap<object, Map<string, PrivatePool>>>();
+// Consumer identity is lexical workflow ownership, never a relay/access proof.
+// Weak ownership retains at most45 bounded selections per live consumer. All
+// selections share the one session SDK; ciphertext/plaintext is absent here.
+function scopedPool(
+ base: Owner,
+ consumer: object,
+ selected: readonly string[],
+ role: ScopeRole,
+ authorized: () => boolean
+): PrivatePool {
+ const consumers =
+ scopes.get(base) ?? new WeakMap<object, Map<string, PrivatePool>>();
+ scopes.set(base, consumers);
+ const owned = consumers.get(consumer) ?? new Map<string, PrivatePool>();
+ consumers.set(consumer, owned);
+ const key = JSON.stringify([role, selected]);
+ const previous = owned.get(key);
+ const prior = previous && pools.get(previous);
+ if (previous && prior && !prior.closed()) return previous;
+ if (prior && !prior.cleaned()) throw Error('private_pool_close_failed');
+ const token = Object.freeze({}) as PrivatePool;
+ const origins = [...selected];
+ const readOrigins =
+ role === 'delivery'
+ ? []
+ : origins.filter((origin) => base.readOrigins.includes(origin));
+ const life = new AbortController();
+ const stops = new Map<symbol, () => void>();
+ const authStops = new Map<string, () => void>();
+ const connections = new Map<string, ScopedConnectionCleanup>();
+ let closed = false,
+ cleaned = false;
+ const current = () =>
+ !closed &&
+ !base.closed() &&
+ authorized() &&
+ !!privateSessionOwnership(base.session)?.current() &&
+ !closed &&
+ !base.closed();
+ function track(start: (ended: () => void) => () => void): () => void {
+ if (!current()) throw Error('private_pool_closed');
+ const id = Symbol();
+ let release = () => {},
+ ended = false;
+ const stop = () => {
+ release();
+ stops.delete(id);
+ };
+ stops.set(id, stop);
+ try {
+ release = start(() => {
+ ended = true;
+ if (!base.unavailable()) stops.delete(id);
+ });
+ if (ended && !base.unavailable()) stops.delete(id);
+ return stop;
+ } catch (error) {
+ stops.delete(id);
+ throw error;
+ }
+ }
+ function retainConnection(origin: string, cleanup: ScopedConnectionCleanup) {
+ const previous = connections.get(origin);
+ if (previous?.current()) return false;
+ previous?.close();
+ connections.set(origin, cleanup);
+ return true;
+ }
+ const scope: Owner = {
+ session: base.session,
+ policy: base.policy,
+ origins,
+ readOrigins,
+ token,
+ closed: () => closed || base.closed(),
+ cleaned: () => (cleaned && !base.unavailable()) || base.cleaned(),
+ unavailable: () => base.unavailable() || (closed && !cleaned),
+ publish(permission, signal) {
+ const view = privatePublicationSnapshot(permission);
+ return current() && view && origins.includes(view.origin)
+ ? base.publish(
+ permission,
+ AbortSignal.any([signal, life.signal]),
+ current,
+ retainConnection
+ )
+ : Promise.resolve({ status: 'stopped' });
+ },
+ async auth(origin, admission) {
+ if (!current() || !origins.includes(origin)) return undefined;
+ const connection = await base.auth(
+ origin,
+ admission,
+ token,
+ current,
+ (cleanup) => {
+ authStops.set(origin, cleanup);
+ }
+ );
+ if (!connection) return undefined;
+ if (!current()) {
+ closePrivateAuthConnection(connection);
+ return undefined;
+ }
+ authStops.set(origin, () => closePrivateAuthConnection(connection));
+ return connection;
+ },
+ subscribe(limit, listener, since, budget, until, source) {
+ return track((ended) =>
+ base.subscribe(
+ limit,
+ (message) => {
+ if (message.type === 'end') ended();
+ listener(message);
+ },
+ since,
+ budget,
+ until,
+ source,
+ readOrigins,
+ current,
+ retainConnection
+ )
+ );
+ },
+ subscribeLive(listener) {
+ return track((ended) =>
+ base.subscribeLive(
+ (message) => {
+ if (message.type === 'end') ended();
+ listener(message);
+ },
+ readOrigins,
+ current,
+ retainConnection
+ )
+ );
+ },
+ close() {
+ closed = true;
+ life.abort();
+ let failed = false;
+ for (const [id, stop] of stops) {
+ try {
+ stop();
+ stops.delete(id);
+ } catch {
+ failed = true;
+ }
+ }
+ for (const [origin, stop] of authStops) {
+ try {
+ stop();
+ authStops.delete(origin);
+ } catch {
+ failed = true;
+ }
+ }
+ for (const [origin, connection] of connections) {
+ try {
+ connection.close();
+ connections.delete(origin);
+ } catch {
+ failed = true;
+ }
+ }
+ cleaned = !failed;
+ if (failed) throw Error('private_pool_close_failed');
+ }
+ };
+ pools.set(token, scope);
+ owned.set(key, token);
+ return token;
+}
// 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[]
+ selected: readonly string[],
+ consumer: object = session,
+ role: ScopeRole = 'receive',
+ authorized: () => boolean = () => true
): PrivatePool | undefined {
if (typeof window === 'undefined') return undefined;
const captured = privateSessionOwnership(session);
if (!captured) throw new Error('private_session_invalid');
const capture = captured;
+ if (
+ !consumer ||
+ typeof consumer !== 'object' ||
+ !['receive', 'delivery', 'access'].includes(role) ||
+ typeof authorized !== 'function'
+ )
+ throw Error('private_pool_scope_invalid');
const manifest = readRelayPolicy(policy);
if (!manifest.messagingEnabled) throw new Error('private_pool_disabled');
const length = Array.isArray(selected) ? selected.length : 0;
@@ -189,7 +402,10 @@ export function getPrivatePool(
throw new Error('private_pool_origins_invalid');
selectedOrigins.set(origin, true);
}
- const origins = [...selectedOrigins.keys()];
+ const selectedTargets = [...selectedOrigins.keys()];
+ // SDK identity is fixed by the entire bounded manifest, while each consumer
+ // retains only its reviewed role/targets. No connection opens on acquisition.
+ const origins = manifest.inbox.map((row) => row.origin);
const readOrigins = origins.filter((origin) =>
manifest.inbox.some((row) => row.origin === origin && row.read)
);
@@ -197,15 +413,11 @@ export function getPrivatePool(
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])
- )
+ if (lifetime.closed() || lifetime.unavailable())
+ throw new Error('private_pool_closed');
+ if (lifetime.session !== session || lifetime.policy !== policy)
throw new Error('private_pool_in_use');
- return lifetime.token;
+ return scopedPool(lifetime, consumer, selectedTargets, role, authorized);
}
}
const token = Object.freeze({}) as PrivatePool;
@@ -220,9 +432,146 @@ export function getPrivatePool(
liveCleanupRequired = false;
let off = () => {};
const authCleanup = new Map<string, () => void>();
+ const authFailed = new Map<string, true>();
+ const authRetiring = new Map<string, true>();
const publicationStops = new Map<() => void, true>();
let publishing = false,
publicationCleanupRequired = false;
+ type Connection = Readonly<{
+ retiring(): boolean;
+ retire(): void;
+ reserve(): Readonly<{
+ relay: ReturnType<typeof sdk.relay>;
+ start(): void;
+ close(): void;
+ retire(): void;
+ pending(): boolean;
+ current(): boolean;
+ }>;
+ }>;
+ const connections = new Map<string, Connection>();
+ function leaseConnection(origin: string) {
+ const previous = connections.get(origin);
+ if (previous) {
+ if (previous.retiring()) throw Error('private_connection_close_pending');
+ return previous.reserve();
+ }
+ const relay = sdk.relay(origin);
+ let references = 0,
+ started = false,
+ physicallyClosed = false,
+ retiring = false,
+ disposed = false,
+ releaseBridge = () => {},
+ unwatch = () => {};
+ function retire() {
+ if (disposed) return;
+ retiring = true;
+ releaseBridge();
+ sdk.remove(relay);
+ if (started && !physicallyClosed) return;
+ unwatch();
+ disposed = true;
+ if (connections.get(origin) === original) connections.delete(origin);
+ }
+ const original: Connection = {
+ retiring: () => retiring,
+ retire,
+ reserve() {
+ references++;
+ let released = false;
+ return {
+ relay,
+ start() {
+ if (
+ released ||
+ closed ||
+ retiring ||
+ disposed ||
+ !capture.current()
+ )
+ throw Error('private_connection_closed');
+ if (started) return;
+ started = true;
+ let starting = true,
+ opened = false,
+ noSocket = false;
+ const open = relay.open$.subscribe(() => {
+ opened = true;
+ });
+ function startupFailure() {
+ if (!starting || opened || noSocket) return;
+ noSocket = true;
+ started = false;
+ retiring = true;
+ queueMicrotask(() => {
+ try {
+ retire();
+ } catch {
+ /* Retry retained. */
+ }
+ });
+ }
+ const error = relay.error$.subscribe((failure) => {
+ // Original NEVER/no filters cannot receive a remote callback
+ // before this synchronous subscribe returns. Only a native
+ // constructor failure proves no physical socket in that stack.
+ if (failure) startupFailure();
+ });
+ const bridge = relay
+ .req(NEVER, {
+ waitForAuth: false,
+ reconnect: false,
+ resubscribe: false
+ })
+ .subscribe({
+ error() {
+ startupFailure();
+ if (!noSocket) {
+ retiring = true;
+ queueMicrotask(() => {
+ try {
+ retire();
+ } catch {
+ /* Actual closure still required. */
+ }
+ });
+ }
+ }
+ });
+ starting = false;
+ open.unsubscribe();
+ error.unsubscribe();
+ releaseBridge = () => bridge.unsubscribe();
+ if (noSocket) throw Error('private_connection_start_failed');
+ },
+ close() {
+ if (!released) {
+ released = true;
+ references--;
+ }
+ // Cancel keepAlive's zero timer before a closing socket can reopen.
+ if (references === 0) retire();
+ },
+ retire,
+ pending: () => started && !physicallyClosed && !disposed,
+ current: () => !retiring && !disposed
+ };
+ }
+ };
+ connections.set(origin, original);
+ const lost = relay.close$.subscribe(() => {
+ physicallyClosed = true;
+ try {
+ retire();
+ if (closed) owner.close();
+ } catch {
+ /* Original physical retirement remains retryable. */
+ }
+ });
+ unwatch = () => lost.unsubscribe();
+ return original.reserve();
+ }
const owner: Owner = {
session,
policy,
@@ -231,18 +580,36 @@ export function getPrivatePool(
token,
closed: () => closed,
cleaned: () => cleaned,
- async publish(permission, signal) {
- const view = privatePublicationSnapshot(permission);
+ unavailable: () =>
+ cleanupRequired ||
+ liveCleanupRequired ||
+ publicationCleanupRequired ||
+ authFailed.size !== 0 ||
+ authRetiring.size !== 0 ||
+ [...connections.values()].some((connection) => connection.retiring()),
+ async publish(
+ permission,
+ signal,
+ scopeCurrent = () => true,
+ retainConnection
+ ) {
+ const observed = privatePublicationSnapshot(permission);
+ if (!observed) return { status: 'stopped' };
+ const view = observed;
if (
- !view ||
publishing ||
closed ||
cleanupRequired ||
publicationCleanupRequired ||
signal.aborted ||
+ !scopeCurrent() ||
!capture.current() ||
+ authRetiring.has(view.origin) ||
+ authFailed.has(view.origin) ||
view.owner !== capture.owner ||
!origins.includes(view.origin) ||
+ authRetiring.has(view.origin) ||
+ authFailed.has(view.origin) ||
!manifest.inbox.some(
({ origin: allowed, write }) => allowed === view.origin && write
) ||
@@ -257,14 +624,25 @@ export function getPrivatePool(
!(await recheckPrivateSession(session)) ||
closed ||
signal.aborted ||
- !capture.current()
+ !scopeCurrent() ||
+ !capture.current() ||
+ authRetiring.has(view.origin) ||
+ authFailed.has(view.origin)
)
return { status: 'stopped' };
return await navigator.locks.request(
'harvestcircle:owner:' + capture.owner,
{ mode: 'exclusive', ifAvailable: true },
async (lock) => {
- if (!lock || closed || signal.aborted || !capture.current())
+ if (
+ !lock ||
+ closed ||
+ signal.aborted ||
+ !scopeCurrent() ||
+ !capture.current() ||
+ authRetiring.has(view.origin) ||
+ authFailed.has(view.origin)
+ )
return { status: 'stopped' as const };
const admitted = await takePrivatePublication(
permission,
@@ -276,41 +654,63 @@ export function getPrivatePool(
!admitted ||
closed ||
signal.aborted ||
+ !scopeCurrent() ||
!capture.current() ||
+ authRetiring.has(view.origin) ||
+ authFailed.has(view.origin) ||
!admitted.current()
)
return { status: 'stopped' as const };
+ const connection = leaseConnection(view.origin);
const network = admitted.beginNetwork();
- if (admitted.networkMetered && !network)
+ if (admitted.networkMetered && !network) {
+ connection.close();
return { status: 'stopped' as const };
+ }
+ if (
+ !scopeCurrent() ||
+ !capture.current() ||
+ closed ||
+ signal.aborted ||
+ authRetiring.has(view.origin) ||
+ authFailed.has(view.origin)
+ ) {
+ network?.finish();
+ connection.close();
+ return { status: 'stopped' as const };
+ }
return await new Promise<PrivateGiftWrapAttemptResult>(
(resolve) => {
let ended = false,
attempted = false,
release = () => {},
- fenceTimer: ReturnType<typeof setTimeout> | undefined;
+ fenceTimer: ReturnType<typeof setTimeout> | undefined,
+ timer: ReturnType<typeof setTimeout> | undefined,
+ retainedConnection = false;
function finish(
status: PrivateGiftWrapAttemptResult['status']
) {
if (ended) return;
ended = true;
network?.finish();
- clearTimeout(timer);
+ if (timer !== undefined) clearTimeout(timer);
if (fenceTimer !== undefined) clearTimeout(fenceTimer);
signal.removeEventListener('abort', stop);
try {
release();
+ if (!retainedConnection) connection.close();
publicationStops.delete(stop);
} catch {
publicationCleanupRequired = true;
status = 'unknown';
}
+ if (!attempted) status = 'stopped';
const result: PrivateGiftWrapAttemptResult = {
status,
role: admitted!.role,
origin: admitted!.origin,
eventId: admitted!.eventId,
- ...(network
+ ...(attempted && network
? { actionId: network.actionId, attempt: network.attempt }
: {})
};
@@ -337,6 +737,7 @@ export function getPrivatePool(
function stop() {
if (ended) {
release();
+ if (!retainedConnection) connection.close();
publicationStops.delete(stop);
return;
}
@@ -351,7 +752,10 @@ export function getPrivatePool(
if (
closed ||
signal.aborted ||
+ !scopeCurrent() ||
!capture.current() ||
+ authRetiring.has(view.origin) ||
+ authFailed.has(view.origin) ||
!admitted!.current()
) {
finish('stopped');
@@ -359,22 +763,26 @@ export function getPrivatePool(
}
fenceTimer = setTimeout(() => fence(), 50);
}
- const relay = sdk.relay(view.origin);
- const allowance =
- network?.remaining() ??
- PRIVATE_PUBLICATION_BUDGETS.networkActionMilliseconds;
- const timeout =
- Number.isFinite(relay.eventTimeout) && relay.eventTimeout > 0
- ? Math.min(allowance, relay.eventTimeout)
- : allowance;
- const timer = setTimeout(() => finish('timed_out'), timeout);
- signal.addEventListener('abort', stop, { once: true });
- publicationStops.set(stop, true);
try {
+ const relay = connection.relay;
+ const allowance =
+ network?.remaining() ??
+ PRIVATE_PUBLICATION_BUDGETS.networkActionMilliseconds;
+ const timeout =
+ Number.isFinite(relay.eventTimeout) &&
+ relay.eventTimeout > 0
+ ? Math.min(allowance, relay.eventTimeout)
+ : allowance;
+ timer = setTimeout(() => finish('timed_out'), timeout);
+ signal.addEventListener('abort', stop, { once: true });
+ publicationStops.set(stop, true);
if (
closed ||
signal.aborted ||
+ !scopeCurrent() ||
!capture.current() ||
+ authRetiring.has(view.origin) ||
+ authFailed.has(view.origin) ||
!admitted.current()
) {
finish('stopped');
@@ -382,6 +790,12 @@ export function getPrivatePool(
}
// The only private EVENT port accepts the freshly read-back1059;
// no caller event, key, relay template or SDK option crosses it.
+ connection.start();
+ retainedConnection =
+ retainConnection?.(view.origin, {
+ current: connection.current,
+ close: connection.close
+ }) ?? false;
attempted = true;
const subscription = relay
.event(admitted.event, 'EVENT')
@@ -430,17 +844,25 @@ export function getPrivatePool(
publishing = false;
}
},
- async auth(origin, admission) {
+ async auth(
+ origin,
+ admission,
+ admittedPool = token,
+ scopeCurrent = () => true,
+ retainCleanup = () => {}
+ ) {
if (
closed ||
cleanupRequired ||
!origins.includes(origin) ||
- !readOrigins.includes(origin) ||
+ !scopeCurrent() ||
+ authFailed.size !== 0 ||
authCleanup.has(origin) ||
+ authRetiring.has(origin) ||
!capture.current()
)
return undefined;
- if (!takeInboxAuthAdmission(admission, owner.token, origin))
+ if (!takeInboxAuthAdmission(admission, admittedPool, origin))
return undefined;
// Reserve before any provider job. No duplicate reviewed action may reset
// a live connection's response admission counter.
@@ -453,26 +875,50 @@ export function getPrivatePool(
let reservation: PrivateAuthChallenge | undefined;
let sent = false;
const releases = new Map<symbol, () => void>();
+ let retireRelay = () => {};
+ let disposed = false;
+ let pendingClose = () => false;
+ let closeWatch = () => {};
function cleanup() {
+ if (disposed) return;
stopped = true;
challenge = undefined;
generation = undefined;
let failed = false;
- for (const release of releases.values()) {
+ for (const [id, release] of releases) {
try {
release();
+ releases.delete(id);
} catch {
failed = true;
}
}
- if (failed) throw new Error('private_auth_cleanup_required');
+ try {
+ retireRelay();
+ } catch {
+ failed = true;
+ }
+ if (failed) {
+ authFailed.set(origin, true);
+ throw new Error('private_auth_cleanup_required');
+ }
+ if (pendingClose()) {
+ authRetiring.set(origin, true);
+ return;
+ }
+ closeWatch();
+ disposed = true;
+ authCleanup.delete(origin);
+ authFailed.delete(origin);
+ authRetiring.delete(origin);
}
authCleanup.set(origin, cleanup);
+ retainCleanup(cleanup);
const halt = () => {
if (stopped) return;
stopped = true;
try {
- owner.close();
+ cleanup();
} catch {
/* Actual control retained for retry. */
}
@@ -481,177 +927,223 @@ export function getPrivatePool(
!(await recheckPrivateSession(session)) ||
closed ||
stopped ||
+ !scopeCurrent() ||
!capture.current()
) {
halt();
return undefined;
}
- const relay = sdk.relay(origin);
- const token = Object.freeze({}) as PrivateAuthConnection;
- // A private page may already own this actual SDK connection. Its open$
- // Subject does not replay; initialize from its genuine connected state.
- if (relay.connected$.value) generation = Symbol();
- function current() {
- return (
- !stopped && !closed && capture.current() && generation !== undefined
- );
- }
- const control: AuthControl = {
- invalidate(proof) {
- if (
- !proofs.has(proof) ||
- !proof.current() ||
- !current() ||
- proof.connection !== generation ||
- proof.challenge !== challenge
- )
- return false;
- return invalidatePrivateSessionGeneration(session);
- },
- stopped: () => !current(),
- challenge() {
- if (!current() || challenge === undefined || responded)
- return undefined;
- const exact = challenge,
- stamp = generation!;
- const proof: PrivateAuthChallenge = {
- owner: capture.owner,
- session: capture.session,
- connection: stamp,
- relay: relay.url,
- challenge: exact,
- current: () =>
- current() && generation === stamp && challenge === exact
- };
- proofs.set(proof, true);
- return proof;
- },
- reserve(proof) {
- if (
- !proofs.has(proof) ||
- reservation !== undefined ||
- !proof.current() ||
- !current() ||
- responded ||
- proof.connection !== generation ||
- proof.challenge !== challenge ||
- responses >= PRIVATE_AUTH_BUDGETS.responsesPerConnectionAction
- )
- return false;
- responses++;
- reservation = proof;
- sent = false;
- return true;
- },
- async send(proof, approved) {
- const wire = takeGuardedInboxAuthResponse(approved, proof);
- const verified = verifyEnvelope(wire);
- const event = verified.ok
- ? verifiedEnvelopeSnapshot(verified.value)
- : undefined;
- if (
- !proofs.has(proof) ||
- reservation !== proof ||
- sent ||
- !event ||
- event.kind !== 22242 ||
- event.pubkey !== capture.owner ||
- event.content !== '' ||
- JSON.stringify(event.tags) !==
- JSON.stringify([
- ['relay', relay.url],
- ['challenge', proof.challenge]
- ]) ||
- !proof.current() ||
- !current() ||
- proof.connection !== generation ||
- proof.challenge !== challenge
- )
- return 'stopped';
- try {
- sent = true;
- const response = await relay.auth(event);
- if (!proof.current() || !current()) return 'stopped';
- if (response.ok) {
- responded = true;
- return 'accepted';
+ try {
+ const connection = leaseConnection(origin);
+ retireRelay = () => {
+ connection.close();
+ connection.retire();
+ };
+ const actualRelay = connection.relay;
+ pendingClose = connection.pending;
+ const token = Object.freeze({}) as PrivateAuthConnection;
+ // A private page may already own this actual SDK connection. Its open$
+ // Subject does not replay; initialize from its genuine connected state.
+ if (actualRelay.connected$.value) generation = Symbol();
+ function current() {
+ return (
+ !stopped &&
+ !closed &&
+ scopeCurrent() &&
+ capture.current() &&
+ generation !== undefined
+ );
+ }
+ const control: AuthControl = {
+ invalidate(proof) {
+ if (
+ !proofs.has(proof) ||
+ !proof.current() ||
+ !current() ||
+ proof.connection !== generation ||
+ proof.challenge !== challenge
+ )
+ return false;
+ return invalidatePrivateSessionGeneration(session);
+ },
+ stopped: () => !current(),
+ challenge() {
+ if (!current() || challenge === undefined || responded)
+ return undefined;
+ const exact = challenge,
+ stamp = generation!;
+ const proof: PrivateAuthChallenge = {
+ owner: capture.owner,
+ session: capture.session,
+ connection: stamp,
+ relay: actualRelay.url,
+ challenge: exact,
+ current: () =>
+ current() && generation === stamp && challenge === exact
+ };
+ proofs.set(proof, true);
+ return proof;
+ },
+ reserve(proof) {
+ if (
+ !proofs.has(proof) ||
+ reservation !== undefined ||
+ !proof.current() ||
+ !current() ||
+ responded ||
+ proof.connection !== generation ||
+ proof.challenge !== challenge ||
+ responses >= PRIVATE_AUTH_BUDGETS.responsesPerConnectionAction
+ )
+ return false;
+ responses++;
+ reservation = proof;
+ sent = false;
+ return true;
+ },
+ async send(proof, approved) {
+ const wire = takeGuardedInboxAuthResponse(approved, proof);
+ const verified = verifyEnvelope(wire);
+ const event = verified.ok
+ ? verifiedEnvelopeSnapshot(verified.value)
+ : undefined;
+ if (
+ !proofs.has(proof) ||
+ reservation !== proof ||
+ sent ||
+ !event ||
+ event.kind !== 22242 ||
+ event.pubkey !== capture.owner ||
+ event.content !== '' ||
+ JSON.stringify(event.tags) !==
+ JSON.stringify([
+ ['relay', actualRelay.url],
+ ['challenge', proof.challenge]
+ ]) ||
+ !proof.current() ||
+ !current() ||
+ proof.connection !== generation ||
+ proof.challenge !== challenge
+ )
+ return 'stopped';
+ try {
+ sent = true;
+ const response = await actualRelay.auth(event);
+ if (!proof.current() || !current()) return 'stopped';
+ if (response.ok) {
+ responded = true;
+ return 'accepted';
+ }
+ const outcome =
+ response.message === 'Timeout' ? 'unknown' : 'refused';
+ halt();
+ return outcome;
+ } catch {
+ halt();
+ return 'unknown';
}
- const outcome =
- response.message === 'Timeout' ? 'unknown' : 'refused';
- halt();
- return outcome;
+ },
+ close: cleanup
+ };
+ authConnections.set(token, control);
+ const opened = actualRelay.open$.subscribe(() => {
+ if (!stopped && !closed && capture.current()) generation = Symbol();
+ });
+ releases.set(Symbol(), () => opened.unsubscribe());
+ const lost = actualRelay.close$.subscribe(() => {
+ halt();
+ try {
+ cleanup();
+ if (closed) owner.close();
} catch {
+ /* Keep owned disposal retryable. */
+ }
+ });
+ closeWatch = () => lost.unsubscribe();
+ const closing = actualRelay.closing$.subscribe(halt);
+ releases.set(Symbol(), () => closing.unsubscribe());
+ const challenges = actualRelay.challenge$.subscribe((next: unknown) => {
+ if (stopped || closed || !capture.current()) {
halt();
- return 'unknown';
+ return;
}
- },
- close: () => owner.close()
- };
- authConnections.set(token, control);
- const opened = relay.open$.subscribe(() => {
- if (!stopped && !closed && capture.current()) generation = Symbol();
- });
- releases.set(Symbol(), () => opened.unsubscribe());
- const lost = relay.close$.subscribe(halt);
- releases.set(Symbol(), () => lost.unsubscribe());
- const closing = relay.closing$.subscribe(halt);
- releases.set(Symbol(), () => closing.unsubscribe());
- const challenges = relay.challenge$.subscribe((next: unknown) => {
- if (stopped || closed || !capture.current()) {
- halt();
- return;
+ if (next === null) return;
+ if (
+ typeof next !== 'string' ||
+ !next ||
+ !boundedEnvelopeTags([
+ ['relay', actualRelay.url],
+ ['challenge', next]
+ ]) ||
+ !generation
+ ) {
+ halt();
+ return;
+ }
+ if (next === challenge) return;
+ if (
+ responses >= PRIVATE_AUTH_BUDGETS.responsesPerConnectionAction ||
+ (challenge !== undefined && !responded)
+ ) {
+ halt();
+ return;
+ }
+ challenge = next;
+ responded = false;
+ reservation = undefined;
+ });
+ releases.set(Symbol(), () => challenges.unsubscribe());
+ if (closed || stopped || !capture.current()) {
+ cleanup();
+ return undefined;
}
- if (next === null) return;
- if (
- typeof next !== 'string' ||
- !next ||
- !boundedEnvelopeTags([
- ['relay', relay.url],
- ['challenge', next]
- ]) ||
- !generation
- ) {
- halt();
- return;
+ // Official Observable filter input holds the watchTower without emitting
+ // a filter/REQ. Its own CLOSE at teardown is ordinary SDK control cleanup.
+ connection.start();
+ const hold = actualRelay
+ .req(NEVER, {
+ waitForAuth: false,
+ reconnect: false,
+ resubscribe: false
+ })
+ .subscribe({ error: halt, complete: halt });
+ releases.set(Symbol(), () => hold.unsubscribe());
+ if (closed || stopped || !capture.current()) {
+ cleanup();
+ return undefined;
}
- if (next === challenge) return;
- if (
- responses >= PRIVATE_AUTH_BUDGETS.responsesPerConnectionAction ||
- (challenge !== undefined && !responded)
- ) {
- halt();
- return;
+ return token;
+ } catch {
+ try {
+ cleanup();
+ } catch {
+ /* Original failed cleanup retained. */
}
- challenge = next;
- responded = false;
- reservation = undefined;
- });
- releases.set(Symbol(), () => challenges.unsubscribe());
- if (closed || stopped || !capture.current()) {
- cleanup();
- owner.close();
- return undefined;
- }
- // Official Observable filter input holds the watchTower without emitting
- // a filter/REQ. Its own CLOSE at teardown is ordinary SDK control cleanup.
- const hold = relay
- .req(NEVER, {
- waitForAuth: false,
- reconnect: false,
- resubscribe: false
- })
- .subscribe({ error: halt, complete: halt });
- releases.set(Symbol(), () => hold.unsubscribe());
- if (closed || stopped || !capture.current()) {
- cleanup();
- owner.close();
return undefined;
}
- return token;
},
- subscribeLive(listener) {
- if (!readOrigins.length) throw Error('private_read_origins_unavailable');
- if (closed || !capture.current()) throw Error('private_pool_closed');
+ subscribeLive(
+ listener,
+ reads = readOrigins,
+ scopeCurrent = () => true,
+ retainConnection
+ ) {
+ if (!reads.length) throw Error('private_read_origins_unavailable');
+ if (
+ reads.some(
+ (origin) => authRetiring.has(origin) || authFailed.has(origin)
+ )
+ )
+ throw Error('private_auth_cleanup_required');
+ if (
+ closed ||
+ !scopeCurrent() ||
+ !capture.current() ||
+ reads.some(
+ (origin) => authRetiring.has(origin) || authFailed.has(origin)
+ )
+ )
+ throw Error('private_pool_closed');
if (liveBusy || liveCleanupRequired) throw Error('private_live_busy');
liveBusy = true;
let ended = false,
@@ -659,6 +1151,14 @@ export function getPrivatePool(
serial = 0;
const opened = new Map<string, true>(),
meters = new Map<string, Map<number, { at: number; bytes: number }>>();
+ const leased = new Map<string, ReturnType<typeof leaseConnection>>();
+ function releaseAll() {
+ release();
+ for (const [origin, connection] of leased) {
+ connection.close();
+ leased.delete(origin);
+ }
+ }
function emit(message: PrivateLiveMessage) {
try {
listener(message);
@@ -672,7 +1172,7 @@ export function getPrivatePool(
) {
if (ended) {
if (liveCleanupRequired && propagate) {
- release();
+ releaseAll();
liveCleanupRequired = false;
liveBusy = false;
}
@@ -681,7 +1181,7 @@ export function getPrivatePool(
ended = true;
let failure: unknown;
try {
- release();
+ releaseAll();
liveCleanupRequired = false;
liveBusy = false;
} catch (error) {
@@ -695,43 +1195,66 @@ export function getPrivatePool(
}
liveActive = () => {
finish('closed', true);
- release();
+ releaseAll();
};
void recheckPrivateSession(session)
.then((fresh) => {
if (ended) return;
- if (!fresh || closed || !capture.current()) {
+ if (
+ !fresh ||
+ closed ||
+ !scopeCurrent() ||
+ !capture.current() ||
+ reads.some(
+ (origin) => authRetiring.has(origin) || authFailed.has(origin)
+ )
+ ) {
finish('stale');
return;
}
- const subscription = sdk
- .req(
- [...readOrigins],
- [...privateInboxQueries(capture.owner, 'live')],
- {
- waitForAuth: false,
- reconnect: false,
- resubscribe: false
- }
+ for (const origin of reads) {
+ const connection = leaseConnection(origin);
+ leased.set(origin, connection);
+ connection.start();
+ if (
+ retainConnection?.(origin, {
+ current: connection.current,
+ close: connection.close
+ })
)
+ leased.delete(origin);
+ }
+ const subscription = sdk
+ .req([...reads], [...privateInboxQueries(capture.owner, 'live')], {
+ waitForAuth: false,
+ reconnect: false,
+ resubscribe: false
+ })
.subscribe({
next(message) {
if (ended) return;
- if (closed || !capture.current()) {
+ if (
+ closed ||
+ !scopeCurrent() ||
+ !capture.current() ||
+ reads.some(
+ (origin) =>
+ authRetiring.has(origin) || authFailed.has(origin)
+ )
+ ) {
finish('stale');
return;
}
const origin = message.from.endsWith('/')
? message.from.slice(0, -1)
: message.from;
- if (!readOrigins.includes(origin)) {
+ if (!reads.includes(origin)) {
finish('error');
return;
}
if (message.type === 'OPEN') {
opened.set(origin, true);
- if (opened.size === readOrigins.length)
- emit({ type: 'open' });
+ if (opened.size === reads.length) emit({ type: 'open' });
} else if (message.type === 'EVENT') {
const now = performance.now();
let meter = meters.get(origin);
@@ -780,8 +1303,16 @@ export function getPrivatePool(
complete: () => finish('closed')
});
release = () => subscription.unsubscribe();
- if (ended || closed || !capture.current()) {
- release();
+ if (
+ ended ||
+ closed ||
+ !scopeCurrent() ||
+ !capture.current() ||
+ reads.some(
+ (origin) => authRetiring.has(origin) || authFailed.has(origin)
+ )
+ ) {
+ releaseAll();
if (!ended) finish('stale');
}
})
@@ -790,15 +1321,38 @@ export function getPrivatePool(
});
return () => finish('stopped', true);
},
- subscribe(limit, listener, since, sharedBudget, until, source) {
+ subscribe(
+ limit,
+ listener,
+ since,
+ sharedBudget,
+ until,
+ source,
+ reads = readOrigins,
+ scopeCurrent = () => true,
+ retainConnection
+ ) {
const targets =
source === undefined
- ? readOrigins
- : readOrigins.filter((origin) => origin === source);
+ ? reads
+ : reads.filter((origin) => origin === source);
if (targets.length === 0)
throw new Error('private_read_origins_unavailable');
- if (closed || !capture.current()) {
- owner.close();
+ if (
+ targets.some(
+ (origin) => authRetiring.has(origin) || authFailed.has(origin)
+ )
+ )
+ throw Error('private_auth_cleanup_required');
+ if (
+ closed ||
+ !scopeCurrent() ||
+ !capture.current() ||
+ targets.some(
+ (origin) => authRetiring.has(origin) || authFailed.has(origin)
+ )
+ ) {
+ if (closed || !capture.current()) owner.close();
throw new Error('private_pool_closed');
}
if (cleanupRequired) throw new Error('private_page_cleanup_required');
@@ -811,6 +1365,14 @@ export function getPrivatePool(
let timer: ReturnType<typeof setTimeout> | undefined;
const completed = new Map<string, true>();
let started = 0;
+ const leased = new Map<string, ReturnType<typeof leaseConnection>>();
+ function releaseAll() {
+ release();
+ for (const [origin, connection] of leased) {
+ connection.close();
+ leased.delete(origin);
+ }
+ }
function emit(message: PrivatePageMessage) {
try {
listener(message);
@@ -824,7 +1386,7 @@ export function getPrivatePool(
) {
if (ended) {
if (cleanupRequired && propagate) {
- release();
+ releaseAll();
cleanupRequired = false;
busy = false;
}
@@ -835,7 +1397,7 @@ export function getPrivatePool(
if (timer !== undefined) clearTimeout(timer);
let failure: unknown;
try {
- release();
+ releaseAll();
} catch (error) {
cleanupRequired = true;
failure = error;
@@ -855,14 +1417,22 @@ export function getPrivatePool(
}
active = () => {
finish('closed', true);
- release();
+ releaseAll();
};
// 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()) {
+ if (
+ !fresh ||
+ closed ||
+ !scopeCurrent() ||
+ !capture.current() ||
+ targets.some(
+ (origin) => authRetiring.has(origin) || authFailed.has(origin)
+ )
+ ) {
finish('stale');
return;
}
@@ -871,10 +1441,30 @@ export function getPrivatePool(
return;
}
started = performance.now();
- if (ended || closed || !capture.current()) {
+ if (
+ ended ||
+ closed ||
+ !scopeCurrent() ||
+ !capture.current() ||
+ targets.some(
+ (origin) => authRetiring.has(origin) || authFailed.has(origin)
+ )
+ ) {
if (!ended) finish('stale');
return;
}
+ for (const origin of targets) {
+ const connection = leaseConnection(origin);
+ leased.set(origin, connection);
+ connection.start();
+ if (
+ retainConnection?.(origin, {
+ current: connection.current,
+ close: connection.close
+ })
+ )
+ leased.delete(origin);
+ }
const subscription = sdk
.req(
[...targets],
@@ -893,15 +1483,44 @@ export function getPrivatePool(
.subscribe({
next(message) {
if (ended) return;
- if (closed || !capture.current()) {
+ if (
+ closed ||
+ !scopeCurrent() ||
+ !capture.current() ||
+ targets.some(
+ (origin) =>
+ authRetiring.has(origin) || authFailed.has(origin)
+ )
+ ) {
finish('stale');
- owner.close();
+ if (closed || !capture.current()) {
+ try {
+ owner.close();
+ } catch {
+ /* Original session cleanup retains pending/failure. */
+ }
+ }
return;
}
const elapsed = budget.elapsed() + performance.now() - started;
- if (ended || closed || !capture.current()) {
+ if (
+ ended ||
+ closed ||
+ !scopeCurrent() ||
+ !capture.current() ||
+ targets.some(
+ (origin) =>
+ authRetiring.has(origin) || authFailed.has(origin)
+ )
+ ) {
if (!ended) finish('stale');
- owner.close();
+ if (closed || !capture.current()) {
+ try {
+ owner.close();
+ } catch {
+ /* Original session cleanup retains pending/failure. */
+ }
+ }
return;
}
if (elapsed >= PRIVATE_TRANSPORT_BUDGETS.pageMilliseconds) {
@@ -941,8 +1560,16 @@ export function getPrivatePool(
release = () => {
subscription.unsubscribe();
};
- if (ended || closed || !capture.current()) {
- release();
+ if (
+ ended ||
+ closed ||
+ !scopeCurrent() ||
+ !capture.current() ||
+ targets.some(
+ (origin) => authRetiring.has(origin) || authFailed.has(origin)
+ )
+ ) {
+ releaseAll();
if (!ended) finish('stale');
} else {
timer = setTimeout(
@@ -987,11 +1614,20 @@ export function getPrivatePool(
failed = true;
}
}
+ for (const connection of connections.values()) {
+ try {
+ connection.retire();
+ } catch {
+ failed = true;
+ }
+ }
try {
sdk.close();
} catch {
failed = true;
}
+ if (!failed && (authRetiring.size !== 0 || connections.size !== 0))
+ throw Error('private_pool_close_pending');
if (!failed) {
cleanupRequired = false;
cleaned = true;
@@ -1009,7 +1645,7 @@ export function getPrivatePool(
owner.close();
throw new Error('private_session_invalid');
}
- return token;
+ return scopedPool(owner, consumer, selectedTargets, role, authorized);
}
function ownerOf(token: PrivatePool): Owner {
const owner = pools.get(token);
@@ -1019,6 +1655,9 @@ function ownerOf(token: PrivatePool): Owner {
export function privatePoolOrigins(token: PrivatePool): readonly string[] {
return [...ownerOf(token).origins];
}
+export function privatePoolCleanupRequired(token: PrivatePool): boolean {
+ return ownerOf(token).unavailable();
+}
export function subscribePrivatePage(
token: PrivatePool,
requested: number,
diff --git a/web/tests/e2e/harness/history-cursor.ts b/web/tests/e2e/harness/history-cursor.ts
@@ -62,12 +62,38 @@ export async function makeFixture(
'reviewed_private_session'
);
if (!session) throw Error('missing genuine session');
+ const capturedSession = session;
const capture = privateSessionOwnership(session)!;
const unlocked = captureUnlockedSession(session, 'reviewed_messages_unlock');
if (!unlocked) throw Error('missing genuine unlock');
const publicStore = getPublicStore()!;
const self = (await f.row())!.record.self;
let ingress: InboxSync | undefined;
+ async function retireOriginalSync() {
+ for (;;) {
+ let incomplete = false;
+ try {
+ if (ingress) stopInboxSync(ingress);
+ } catch (error) {
+ if (
+ !(error instanceof Error) ||
+ error.message !== 'private_inbox_cleanup_required'
+ )
+ throw error;
+ incomplete = true;
+ }
+ const sessionClean = closePrivateSession(capturedSession);
+ if (!incomplete && sessionClean) {
+ if (ingress && inboxSyncSnapshot(ingress)?.cleanupRequired)
+ throw Error('actual original sync cleanup remains incomplete');
+ return;
+ }
+ // Retry exact original disposal after its actual SDK close observers;
+ // this wait starts no retrieval, permission or replacement session.
+ await new Promise<void>((resolve) => setTimeout(resolve, 0));
+ }
+ }
+
let authorized = true;
let restoreFault = () => {};
let releaseKey: (() => void) | undefined;
@@ -135,9 +161,7 @@ export async function makeFixture(
if (!ingress) return false;
return startInboxSync(ingress, review);
},
- stop() {
- if (ingress) stopInboxSync(ingress);
- },
+ stop: retireOriginalSync,
snapshot: () => ingress && inboxSyncSnapshot(ingress),
async stored(id = self.eventId) {
const row = await loadPrivateRecord(
@@ -153,9 +177,7 @@ export async function makeFixture(
closeUnlock() {
closeUnlockedSession(unlocked);
},
- navigateAway() {
- if (ingress) stopInboxSync(ingress);
- },
+ navigateAway: retireOriginalSync,
changeKey() {
f.mode('changed_key');
},
@@ -237,13 +259,13 @@ export async function makeFixture(
IDBIndex.prototype.openCursor = cursor;
};
},
- close() {
+ async close() {
const release = releaseKey;
releaseKey = undefined;
restoreKey();
release?.();
restoreFault();
- if (ingress) stopInboxSync(ingress);
+ await retireOriginalSync();
closePrivateSession(session);
f.close();
}
diff --git a/web/tests/e2e/harness/history-pagination.ts b/web/tests/e2e/harness/history-pagination.ts
@@ -90,6 +90,7 @@ export async function makeFixture(
'reviewed_private_session'
);
if (!session) throw Error('missing genuine session');
+ const capturedSession = session;
const capture = privateSessionOwnership(session)!;
const unlocked = captureUnlockedSession(session, 'reviewed_messages_unlock');
if (!unlocked) throw Error('missing genuine unlock');
@@ -144,6 +145,31 @@ export async function makeFixture(
const publicStore = getPublicStore()!;
const self = (await f.row())!.record.self;
let ingress: InboxSync | undefined;
+ async function retireOriginalSync() {
+ for (;;) {
+ let incomplete = false;
+ try {
+ if (ingress) stopInboxSync(ingress);
+ } catch (error) {
+ if (
+ !(error instanceof Error) ||
+ error.message !== 'private_inbox_cleanup_required'
+ )
+ throw error;
+ incomplete = true;
+ }
+ const sessionClean = closePrivateSession(capturedSession);
+ if (!incomplete && sessionClean) {
+ if (ingress && inboxSyncSnapshot(ingress)?.cleanupRequired)
+ throw Error('actual original sync cleanup remains incomplete');
+ return;
+ }
+ // Retry exact original disposal after its actual SDK close observers;
+ // this wait starts no retrieval, permission or replacement session.
+ await new Promise<void>((resolve) => setTimeout(resolve, 0));
+ }
+ }
+
let older: OlderInbox | undefined;
let capacityWires: string[] = [],
capacityWrites = 0;
@@ -214,9 +240,7 @@ export async function makeFixture(
if (!ingress) return false;
return startInboxSync(ingress, review);
},
- stop() {
- if (ingress) stopInboxSync(ingress);
- },
+ stop: retireOriginalSync,
snapshot: () => ingress && inboxSyncSnapshot(ingress),
captureOlder(review: unknown = 'reviewed_load_older') {
if (!ingress) return false;
@@ -347,9 +371,7 @@ export async function makeFixture(
closeUnlock() {
closeUnlockedSession(unlocked);
},
- navigateAway() {
- if (ingress) stopInboxSync(ingress);
- },
+ navigateAway: retireOriginalSync,
changeKey() {
f.mode('changed_key');
},
@@ -431,7 +453,7 @@ export async function makeFixture(
IDBIndex.prototype.openCursor = cursor;
};
},
- close() {
+ async close() {
const release = releaseKey;
releaseKey = undefined;
restoreKey();
@@ -439,7 +461,7 @@ export async function makeFixture(
restoreFault();
if (older) stopOlderInbox(older);
closePublicScheduler(scheduler);
- if (ingress) stopInboxSync(ingress);
+ await retireOriginalSync();
closePrivateSession(session);
f.close();
}
diff --git a/web/tests/e2e/harness/inbox-access-controller.ts b/web/tests/e2e/harness/inbox-access-controller.ts
@@ -0,0 +1,151 @@
+import { makeAuthFixture } from './inbox-auth.ts';
+import { validateRelayPolicy } from '../../../src/lib/config/relays.ts';
+import {
+ createPublicRuntimeContext,
+ mountPublicRuntime,
+ closePublicRuntime,
+ createPublicView,
+ beginPublicViewRun,
+ disposePublicView
+} from '../../../src/lib/runtime/public-runtime.ts';
+import {
+ resolveInboxPreference,
+ settleInboxResolver,
+ inboxResolverCurrentAfterSample,
+ type InboxResolver
+} from '../../../src/lib/messaging/resolve-inbox.ts';
+import {
+ createInboxAccessController,
+ closeInboxAccessController
+} from '../../../src/lib/messaging/inbox-access-controller.ts';
+import {
+ getPrivatePool,
+ subscribePrivatePage,
+ subscribePrivateLive,
+ closePrivatePool,
+ type PrivatePool
+} from '../../../src/lib/nostr/private-pool.ts';
+export * from '../../../src/lib/messaging/inbox-access-controller.ts';
+export { installCloseFailure } from './inbox-auth.ts';
+import {
+ createPrivateSession,
+ closePrivateSession,
+ type PrivateSession
+} from '../../../src/lib/runtime/private-session.ts';
+export const origins = [
+ 'wss://inbox.example.org',
+ 'wss://peer.example.org',
+ 'wss://archive.example.org'
+];
+// Genuine actors/SDK discovery/AUTH with controlled loopback/provided identity;
+// no installed extension, access probe, operator or full qualification claim.
+export async function makeControllerFixture() {
+ const capturedPolicy = validateRelayPolicy(
+ JSON.stringify({
+ schemaVersion: 1,
+ public: [
+ {
+ origin: 'wss://discovery.example.org',
+ read: true,
+ write: true,
+ nip50: false
+ }
+ ],
+ inbox: origins.map((origin) => ({ origin, read: true, write: true })),
+ postingEnabled: true,
+ messagingEnabled: true,
+ operatorDenylist: []
+ })
+ );
+ if (!capturedPolicy) throw Error('fixture policy');
+ const policy = capturedPolicy;
+ const fixture = await makeAuthFixture(policy);
+ const context = createPublicRuntimeContext(),
+ runtime = mountPublicRuntime(context, policy);
+ if (!runtime) throw Error('actual public runtime');
+ const view = createPublicView(runtime);
+ let controller: ReturnType<typeof createInboxAccessController>,
+ own: InboxResolver | undefined,
+ successor: PrivateSession | undefined;
+ const pools = new Map<PrivatePool, true>();
+ function scope(
+ selected: string[],
+ role: 'receive' | 'delivery',
+ bindHead = false
+ ) {
+ const pool = getPrivatePool(
+ fixture.session,
+ policy,
+ selected,
+ Object.freeze({}),
+ role,
+ bindHead
+ ? () => !!own && inboxResolverCurrentAfterSample(own)
+ : () => true
+ );
+ if (!pool) throw Error('actual scoped private pool');
+ pools.set(pool, true);
+ return pool;
+ }
+ return {
+ ...fixture,
+ async capture() {
+ const run = beginPublicViewRun(view);
+ own = resolveInboxPreference(view, run, fixture.owner);
+ await settleInboxResolver(own);
+ controller = createInboxAccessController(fixture.session, policy, own);
+ if (!controller) throw Error('actual access controller');
+ return controller;
+ },
+ churnHead() {
+ beginPublicViewRun(view);
+ },
+ scope,
+ page(pool: PrivatePool, ended: (reason: string) => void = () => {}) {
+ return subscribePrivatePage(pool, 1, (message) => {
+ if (message.type === 'end') ended(message.reason);
+ });
+ },
+ live(
+ pool: PrivatePool,
+ onOpen: () => void,
+ candidate: () => void = () => {}
+ ) {
+ return subscribePrivateLive(pool, (message) => {
+ if (message.type === 'open') onOpen();
+ if (message.type === 'candidate') candidate();
+ });
+ },
+ closeSession() {
+ return closePrivateSession(fixture.session);
+ },
+ async successorScope() {
+ successor ??= await createPrivateSession(
+ fixture.identity,
+ 'reviewed_private_session'
+ );
+ if (!successor) throw Error('genuine successor session unavailable');
+ const pool = getPrivatePool(
+ successor,
+ policy,
+ origins,
+ Object.freeze({}),
+ 'receive'
+ );
+ if (!pool) throw Error('genuine successor pool unavailable');
+ pools.set(pool, true);
+ return pool;
+ },
+ stopScope(pool: PrivatePool) {
+ closePrivatePool(pool);
+ },
+ close() {
+ if (controller) closeInboxAccessController(controller);
+ for (const pool of pools.keys()) closePrivatePool(pool);
+ if (successor) closePrivateSession(successor);
+ disposePublicView(view);
+ closePublicRuntime(context);
+ fixture.close();
+ }
+ };
+}
diff --git a/web/tests/e2e/harness/inbox-auth.ts b/web/tests/e2e/harness/inbox-auth.ts
@@ -28,6 +28,7 @@ import {
subscribePrivatePage
} from '../../../src/lib/nostr/private-pool.ts';
import { RelayPool } from 'applesauce-relay';
+import type { RelayPolicy } from '../../../src/lib/config/relays.ts';
export {
beginInboxAuthentication,
respondInboxAuthentication,
@@ -44,7 +45,7 @@ export {
closePublicPool
} from '../../../src/lib/nostr/public-pool.ts';
export { inbox, fixturePolicy };
-export async function makeAuthFixture() {
+export async function makeAuthFixture(selectedPolicy?: RelayPolicy) {
const fixture = makeFixture(10050),
identity = createIdentitySession();
let mode: 'exact' | 'author' | 'relay' | 'challenge' | 'cached' | 'denied' =
@@ -53,17 +54,18 @@ export async function makeAuthFixture() {
changed = false,
invalidKey = false;
let before = () => Promise.resolve();
+ let beforeKey = () => Promise.resolve();
Object.defineProperty(window, 'nostr', {
configurable: true,
value: {
- getPublicKey: () =>
- Promise.resolve(
- invalidKey
- ? 'not-a-public-key'
- : changed
- ? 'f'.repeat(64)
- : fixture.owner
- ),
+ getPublicKey: async () => {
+ await beforeKey();
+ return invalidKey
+ ? 'not-a-public-key'
+ : changed
+ ? 'f'.repeat(64)
+ : fixture.owner;
+ },
signEvent: async (input: Parameters<typeof fixture.sign>[0]) => {
signs++;
await before();
@@ -89,7 +91,7 @@ export async function makeAuthFixture() {
'reviewed_private_session'
);
if (!session) throw new Error('missing genuine private session');
- const policy = fixturePolicy(),
+ const policy = selectedPolicy ?? fixturePolicy(),
pool = getPrivatePool(session, policy, [inbox]);
if (!pool) throw new Error('missing private pool');
const store = getPrivateStore(session);
@@ -109,6 +111,24 @@ export async function makeAuthFixture() {
return {
pool,
policy,
+ identity,
+ session,
+ preferenceWire(
+ relays: readonly string[],
+ seconds = Math.floor(Date.now() / 1000)
+ ) {
+ return JSON.stringify(
+ fixture.sign({
+ kind: 10050,
+ created_at: seconds,
+ tags: relays.map((origin) => ['relay', origin]),
+ content: ''
+ })
+ );
+ },
+ beforeKey(next: typeof beforeKey) {
+ beforeKey = next;
+ },
owner: fixture.owner,
signs: () => signs,
mode: (next: typeof mode) => {
@@ -143,6 +163,10 @@ export async function makeAuthFixture() {
}),
async staleGenerationInvalidation() {
disconnectIdentity(identity);
+ while (ActualPrivateSession.privateSessionCleanupRequired(session)) {
+ closePrivateSession(session);
+ await new Promise<void>((resolve) => setTimeout(resolve, 0));
+ }
await connectIdentity(identity);
await probeIdentityMessaging(identity, 'reviewed_self_copy');
const successor = await createPrivateSession(
@@ -196,6 +220,15 @@ export async function makeAuthFixture() {
}
throw new Error('missing real challenge for bypass test');
},
+ async closeAndWait() {
+ closePrivateSession(session);
+ disconnectIdentity(identity);
+ fixture.close();
+ while (ActualPrivateSession.privateSessionCleanupRequired(session)) {
+ closePrivateSession(session);
+ await new Promise<void>((resolve) => setTimeout(resolve, 0));
+ }
+ },
close: () => {
closePrivateSession(session);
disconnectIdentity(identity);
@@ -204,13 +237,13 @@ export async function makeAuthFixture() {
};
}
export function installCloseFailure() {
- const original = Reflect.get<RelayPool, 'close'>(
+ const original = Reflect.get<RelayPool, 'remove'>(
RelayPool.prototype,
- 'close'
+ 'remove'
);
let failing = true;
- RelayPool.prototype.close = function (
- ...args: Parameters<RelayPool['close']>
+ RelayPool.prototype.remove = function (
+ ...args: Parameters<RelayPool['remove']>
) {
if (failing) throw new Error('controlled physical cleanup fault');
return original.apply(this, args);
@@ -220,7 +253,7 @@ export function installCloseFailure() {
failing = false;
},
restore: () => {
- RelayPool.prototype.close = original;
+ RelayPool.prototype.remove = original;
}
};
}
diff --git a/web/tests/e2e/harness/inbox-sync.ts b/web/tests/e2e/harness/inbox-sync.ts
@@ -44,12 +44,38 @@ export async function makeFixture() {
'reviewed_private_session'
);
if (!session) throw Error('missing genuine session');
+ const capturedSession = session;
const capture = privateSessionOwnership(session)!;
const unlocked = captureUnlockedSession(session, 'reviewed_messages_unlock');
if (!unlocked) throw Error('missing genuine unlock');
const publicStore = getPublicStore()!;
const self = (await f.row())!.record.self;
let ingress: InboxSync | undefined;
+ async function retireOriginalSync() {
+ for (;;) {
+ let incomplete = false;
+ try {
+ if (ingress) stopInboxSync(ingress);
+ } catch (error) {
+ if (
+ !(error instanceof Error) ||
+ error.message !== 'private_inbox_cleanup_required'
+ )
+ throw error;
+ incomplete = true;
+ }
+ const sessionClean = closePrivateSession(capturedSession);
+ if (!incomplete && sessionClean) {
+ if (ingress && inboxSyncSnapshot(ingress)?.cleanupRequired)
+ throw Error('actual original sync cleanup remains incomplete');
+ return;
+ }
+ // Retry exact original disposal after its actual SDK close observers;
+ // this wait starts no retrieval, permission or replacement session.
+ await new Promise<void>((resolve) => setTimeout(resolve, 0));
+ }
+ }
+
let authorized = true;
let restoreFault = () => {};
let releaseKey: (() => void) | undefined;
@@ -82,9 +108,7 @@ export async function makeFixture() {
if (!ingress) return false;
return startInboxSync(ingress, review);
},
- stop() {
- if (ingress) stopInboxSync(ingress);
- },
+ stop: retireOriginalSync,
snapshot: () => ingress && inboxSyncSnapshot(ingress),
async stored(id = self.eventId) {
const row = await loadPrivateRecord(
@@ -100,9 +124,7 @@ export async function makeFixture() {
closeUnlock() {
closeUnlockedSession(unlocked);
},
- navigateAway() {
- if (ingress) stopInboxSync(ingress);
- },
+ navigateAway: retireOriginalSync,
changeKey() {
f.mode('changed_key');
},
@@ -184,13 +206,13 @@ export async function makeFixture() {
IDBIndex.prototype.openCursor = cursor;
};
},
- close() {
+ async close() {
const release = releaseKey;
releaseKey = undefined;
restoreKey();
release?.();
restoreFault();
- if (ingress) stopInboxSync(ingress);
+ await retireOriginalSync();
closePrivateSession(session);
f.close();
}
diff --git a/web/tests/e2e/harness/paired-delivery.ts b/web/tests/e2e/harness/paired-delivery.ts
@@ -54,14 +54,21 @@ const discovery = 'wss://discovery.example.org',
// Disposable existing source fixture provider signs actual public10050 facts;
// local discovery observations qualify route semantics only, never relay Q.
export async function makeFixture(
- options: Readonly<{ messaging?: boolean; peerRead?: boolean }> = {}
+ options: Readonly<{
+ messaging?: boolean;
+ peerRead?: boolean;
+ sharedOrigin?: boolean;
+ }> = {}
) {
const f = await makeSelfFixture(),
policy = validateRelayPolicy(
JSON.stringify({
schemaVersion: 1,
public: [{ origin: discovery, read: true, write: false, nip50: false }],
- inbox: [peerOrigin, archiveOrigin].map((origin) => ({
+ inbox: (options.sharedOrigin
+ ? [peerOrigin]
+ : [peerOrigin, archiveOrigin]
+ ).map((origin) => ({
origin,
read: origin === peerOrigin ? options.peerRead !== false : true,
write: true
@@ -84,7 +91,9 @@ export async function makeFixture(
const signed = await provider.signEvent({
kind: 10050,
created_at: 100,
- tags: [['relay', peer ? peerOrigin : archiveOrigin]],
+ tags: [
+ ['relay', peer || options.sharedOrigin ? peerOrigin : archiveOrigin]
+ ],
content: ''
});
f.mode('normal');
diff --git a/web/tests/e2e/harness/private-publisher.ts b/web/tests/e2e/harness/private-publisher.ts
@@ -16,6 +16,8 @@ import {
} from '../../../src/lib/nostr/private-pool.ts';
import {
capturePrivatePublication,
+ capturePrivatePublicationAction,
+ type PrivatePublicationAction,
privatePublicationSnapshot,
type PrivatePublication
} from '../../../src/lib/nostr/private-publisher.ts';
@@ -36,19 +38,25 @@ import {
} from '../../../src/lib/messaging/composer-state.ts';
import { disconnectIdentity } from '../../../src/lib/runtime/identity-session.ts';
export { privatePublicationSnapshot, publishPrivateGiftWrapAttempt };
-export async function makeFixture(writeOnly = false) {
- const f = await makePairFixture({ messaging: true, peerRead: !writeOnly });
+import { RelayPool } from 'applesauce-relay/pool';
+export async function makeFixture(writeOnly = false, sharedOrigin = false) {
+ const f = await makePairFixture({
+ messaging: true,
+ peerRead: !writeOnly,
+ sharedOrigin
+ });
const session = await createPrivateSession(
f.identity,
'reviewed_private_session'
);
if (!session) throw Error('missing genuine private session');
const peerOrigin = 'wss://peer.example.org',
- archiveOrigin = 'wss://archive.example.org';
- const pool = getPrivatePool(session, f.context.policy, [
- peerOrigin,
- archiveOrigin
- ]);
+ archiveOrigin = sharedOrigin ? peerOrigin : 'wss://archive.example.org';
+ const pool = getPrivatePool(
+ session,
+ f.context.policy,
+ Array.from(new Set([peerOrigin, archiveOrigin]))
+ );
if (!pool) throw Error('missing actual private pool');
const controller = new AbortController();
let composer: PrivateComposer | undefined;
@@ -108,7 +116,8 @@ export async function makeFixture(writeOnly = false) {
function permission(
role: 'peer' | 'self_archive',
origin = role === 'peer' ? peerOrigin : archiveOrigin,
- review: unknown = 'reviewed_private_delivery'
+ review: unknown = 'reviewed_private_delivery',
+ action?: PrivatePublicationAction
) {
const receipt = preparedPairedDelivery(f.preparation);
return receipt
@@ -119,12 +128,60 @@ export async function makeFixture(writeOnly = false) {
f.context,
role,
origin,
- review
+ review,
+ action
)
: undefined;
}
- async function publish(token: PrivatePublication) {
- return publishPrivateGiftWrapAttempt(pool!, token, controller.signal);
+ async function publish(
+ token: PrivatePublication,
+ signal = controller.signal
+ ) {
+ return publishPrivateGiftWrapAttempt(pool!, token, signal);
+ }
+ function action() {
+ const receipt = preparedPairedDelivery(f.preparation);
+ return receipt
+ ? capturePrivatePublicationAction(
+ f.repository,
+ session!,
+ receipt,
+ f.context,
+ 'reviewed_private_retry'
+ )
+ : undefined;
+ }
+ function failAcquisition() {
+ const original = Reflect.get<RelayPool, 'relay'>(
+ RelayPool.prototype,
+ 'relay'
+ );
+ RelayPool.prototype.relay = function (origin) {
+ if (new URL(origin).origin === peerOrigin)
+ throw Error('controlled original SDK acquisition failure');
+ return original.call(this, origin);
+ };
+ return () => {
+ RelayPool.prototype.relay = original;
+ };
+ }
+ function abortOnActualNetworkClock(abort: AbortController) {
+ const original = performance.now.bind(performance);
+ let observed = false;
+ performance.now = () => {
+ const value = original();
+ if (!observed && /at clock \(/.test(new Error().stack ?? '')) {
+ observed = true;
+ abort.abort();
+ }
+ return value;
+ };
+ return {
+ observed: () => observed,
+ restore: () => {
+ performance.now = original;
+ }
+ };
}
async function deliver(
role: 'peer' | 'self_archive',
@@ -204,6 +261,9 @@ export async function makeFixture(writeOnly = false) {
prepareSelfOnly: () =>
prepareSelfRecovery(f.preparation, 'reviewed_self_recovery'),
permission,
+ action,
+ failAcquisition,
+ abortOnActualNetworkClock,
publish,
deliver,
remove,
diff --git a/web/tests/e2e/inbox-access-controller.spec.ts b/web/tests/e2e/inbox-access-controller.spec.ts
@@ -0,0 +1,788 @@
+import { test, expect, type Page } from '@playwright/test';
+import { build } from 'vite';
+import { fileURLToPath } from 'node:url';
+import { once } from 'node:events';
+import { WebSocketServer, type WebSocket } from 'ws';
+import { createStaticHarness } from '../integration/harness/static.ts';
+import type * as Fixture from './harness/inbox-access-controller.ts';
+declare global {
+ interface Window {
+ cr007: typeof Fixture;
+ cr007Fixture: Awaited<ReturnType<typeof Fixture.makeControllerFixture>>;
+ cr007Controller: NonNullable<
+ Awaited<ReturnType<Window['cr007Fixture']['capture']>>
+ >;
+ cr007Pending?: Promise<string>;
+ cr007Release?: () => void;
+ cr007Waiting?: boolean;
+ cr007Open?: boolean;
+ cr007StopLive?: () => void;
+ cr007StopPage?: () => void;
+ cr007PageEnd?: string;
+ cr007LiveEvents?: number;
+ cr007DelayClose?: boolean;
+ cr007HeldClose?: (() => void)[];
+ cr007ThrowConstructor?: string;
+ cr007Reconnected?: boolean;
+ cr007Fault?: ReturnType<typeof Fixture.installCloseFailure>;
+ }
+}
+let server: Awaited<ReturnType<typeof createStaticHarness>>,
+ sockets: WebSocketServer,
+ endpoint: string,
+ bundle: string;
+let head = '',
+ accept = true;
+const frames: { origin: string; frame: unknown[] }[] = [];
+const connections = new Map<WebSocket, string>();
+let peakPrivateConnections = 0,
+ constructedPrivateConnections = 0;
+test.beforeAll(async () => {
+ server = await createStaticHarness();
+ sockets = new WebSocketServer({
+ host: '127.0.0.1',
+ port: 0,
+ maxPayload: 65536
+ });
+ await once(sockets, 'listening');
+ const address = sockets.address();
+ if (!address || typeof address === 'string') throw Error('owned loopback');
+ endpoint = 'ws://127.0.0.1:' + address.port;
+ sockets.on('connection', (socket, request) => {
+ const origin =
+ new URL(request.url ?? '/', endpoint).searchParams.get('origin') ?? '';
+ connections.set(socket, origin);
+ if (origin !== 'wss://discovery.example.org') {
+ constructedPrivateConnections++;
+ peakPrivateConnections = Math.max(
+ peakPrivateConnections,
+ [...connections.values()].filter(
+ (from) => from !== 'wss://discovery.example.org'
+ ).length
+ );
+ }
+ socket.on('close', () => connections.delete(socket));
+ socket.send(JSON.stringify(['AUTH', 'cr007-controlled-challenge']));
+ socket.on('message', (bytes) => {
+ const raw = Buffer.isBuffer(bytes)
+ ? bytes
+ : Array.isArray(bytes)
+ ? Buffer.concat(bytes)
+ : Buffer.from(bytes);
+ const frame = JSON.parse(raw.toString()) as unknown[];
+ frames.push({ origin, frame });
+ if (frame[0] === 'AUTH')
+ socket.send(
+ JSON.stringify([
+ 'OK',
+ (frame[1] as { id: string }).id,
+ accept,
+ accept ? '' : 'blocked: controlled refusal'
+ ])
+ );
+ if (frame[0] === 'REQ' && origin === 'wss://discovery.example.org') {
+ const filter = frame[2] as { kinds?: number[] };
+ if (filter.kinds?.includes(10050) && head)
+ socket.send(JSON.stringify(['EVENT', frame[1], JSON.parse(head)]));
+ socket.send(JSON.stringify(['EOSE', frame[1]]));
+ }
+ });
+ });
+ const result = await build({
+ configFile: false,
+ logLevel: 'silent',
+ build: {
+ write: false,
+ minify: false,
+ lib: {
+ entry: fileURLToPath(
+ new URL('./harness/inbox-access-controller.ts', import.meta.url)
+ ),
+ name: 'cr007',
+ formats: ['iife']
+ }
+ }
+ });
+ const output = Array.isArray(result) ? result[0] : result;
+ if (!('output' in output)) throw Error('actual fixture bundle');
+ const chunks = output.output.filter((chunk) => chunk.type === 'chunk');
+ expect(chunks).toHaveLength(1);
+ bundle = chunks[0].code;
+});
+test.afterAll(async () => {
+ for (const socket of sockets.clients) socket.terminate();
+ await new Promise<void>((resolve) => sockets.close(() => resolve()));
+ await server.close();
+});
+test.beforeEach(async ({ page }) => {
+ await expect.poll(() => connections.size).toBe(0);
+ peakPrivateConnections = 0;
+ constructedPrivateConnections = 0;
+ head = '';
+ accept = true;
+ frames.length = 0;
+ await page.addInitScript(
+ ({ endpoint }) => {
+ const Native = window.WebSocket;
+ window.WebSocket = class extends Native {
+ constructor(url: string | URL, protocols?: string | string[]) {
+ const origin = new URL(String(url)).origin;
+ if (
+ ![
+ 'wss://discovery.example.org',
+ 'wss://inbox.example.org',
+ 'wss://peer.example.org',
+ 'wss://archive.example.org'
+ ].includes(origin)
+ )
+ throw Error('unexpected fixture egress');
+ if (window.cr007ThrowConstructor === origin) {
+ window.cr007ThrowConstructor = undefined;
+ throw Error('controlled native constructor failure before super');
+ }
+ super(endpoint + '/?origin=' + encodeURIComponent(origin), protocols);
+ }
+ override close(code?: number, reason?: string) {
+ if (
+ window.cr007DelayClose &&
+ !this.url.includes(
+ encodeURIComponent('wss://discovery.example.org')
+ )
+ ) {
+ (window.cr007HeldClose ??= []).push(() =>
+ super.close(code, reason)
+ );
+ } else super.close(code, reason);
+ }
+ };
+ },
+ { endpoint }
+ );
+ await page.goto(server.url + '/search');
+ await page.addScriptTag({ content: bundle });
+ head = await page.evaluate(async () => {
+ window.cr007Fixture = await window.cr007.makeControllerFixture();
+ return window.cr007Fixture.preferenceWire([window.cr007.origins[0]]);
+ });
+ await page.evaluate(async () => {
+ window.cr007Controller = await window.cr007Fixture.capture();
+ });
+});
+test.afterEach(async ({ page }) => {
+ if (!page.isClosed())
+ await page.evaluate(() => {
+ window.cr007Fault?.restore();
+ window.cr007Release?.();
+ window.cr007StopPage?.();
+ window.cr007StopLive?.();
+ window.cr007DelayClose = false;
+ for (const release of window.cr007HeldClose ?? []) release();
+ window.cr007Fixture.close();
+ });
+});
+async function challenge(page: Page) {
+ await page.evaluate(() =>
+ window.cr007.authenticateInboxAccess(
+ window.cr007Controller,
+ window.cr007.origins[0],
+ 'reviewed_inbox_connection_auth'
+ )
+ );
+ await expect
+ .poll(() =>
+ page.evaluate(
+ () =>
+ window.cr007.inboxAccessControllerSnapshot(window.cr007Controller)
+ ?.auth[0]?.state
+ )
+ )
+ .toBe('challenge');
+}
+test('genuine controller capture has no private connection or sign and never claims readiness', async ({
+ page
+}) => {
+ expect(
+ [...connections.values()].filter(
+ (origin) => origin !== 'wss://discovery.example.org'
+ )
+ ).toHaveLength(0);
+ const result = await page.evaluate(async () => ({
+ snapshot: window.cr007.inboxAccessControllerSnapshot(
+ window.cr007Controller
+ ),
+ signs: window.cr007Fixture.signs(),
+ wrong: await window.cr007.authenticateInboxAccess(
+ window.cr007Controller,
+ window.cr007.origins[0],
+ 'wrong-review'
+ )
+ }));
+ expect(result.signs).toBe(0);
+ expect(result.wrong).toBe('unavailable');
+ expect(result.snapshot?.readiness).toBe('unavailable');
+ expect(
+ frames.some(({ frame }) => ['AUTH', 'EVENT'].includes(String(frame[0])))
+ ).toBe(false);
+});
+test('explicit current owner AUTH sends real signed22242 only and duplicate initiation cannot reset it', async ({
+ page
+}) => {
+ await challenge(page);
+ expect(
+ await page.evaluate(() =>
+ window.cr007.respondInboxAccessAuthentication(
+ window.cr007Controller,
+ window.cr007.origins[0],
+ 'reviewed_inbox_auth_response'
+ )
+ )
+ ).toBe('accepted');
+ expect(
+ await page.evaluate(() =>
+ window.cr007.authenticateInboxAccess(
+ window.cr007Controller,
+ window.cr007.origins[0],
+ 'reviewed_inbox_connection_auth'
+ )
+ )
+ ).toBe('accepted');
+ const sent = frames.filter(({ frame }) => frame[0] === 'AUTH');
+ expect(sent).toHaveLength(1);
+ expect(sent[0].frame[1]).toMatchObject({
+ kind: 22242,
+ pubkey: await page.evaluate(() => window.cr007Fixture.owner),
+ tags: [
+ ['relay', 'wss://inbox.example.org/'],
+ ['challenge', 'cr007-controlled-challenge']
+ ]
+ });
+ expect(frames.some(({ frame }) => frame[0] === 'EVENT')).toBe(false);
+ expect(
+ await page.evaluate(
+ () =>
+ window.cr007.inboxAccessControllerSnapshot(window.cr007Controller)
+ ?.readiness
+ )
+ ).toBe('unavailable');
+});
+test('actual discovery generation churn during pending signing cannot emit late AUTH', async ({
+ page
+}) => {
+ await challenge(page);
+ await page.evaluate(() => {
+ window.cr007Fixture.beforeSign(
+ () =>
+ new Promise<void>((resolve) => {
+ window.cr007Waiting = true;
+ window.cr007Release = resolve;
+ })
+ );
+ window.cr007Pending = window.cr007.respondInboxAccessAuthentication(
+ window.cr007Controller,
+ window.cr007.origins[0],
+ 'reviewed_inbox_auth_response'
+ );
+ });
+ await expect.poll(() => page.evaluate(() => window.cr007Waiting)).toBe(true);
+ await page.evaluate(() => {
+ window.cr007Fixture.churnHead();
+ window.cr007Release?.();
+ });
+ expect(await page.evaluate(() => window.cr007Pending)).toBe('stopped');
+ expect(frames.filter(({ frame }) => frame[0] === 'AUTH')).toHaveLength(0);
+});
+test('actual discovery churn during pending fresh key cannot open an AUTH socket', async ({
+ page
+}) => {
+ await page.evaluate(() => {
+ window.cr007Fixture.beforeKey(
+ () =>
+ new Promise<void>((resolve) => {
+ window.cr007Waiting = true;
+ window.cr007Release = resolve;
+ })
+ );
+ window.cr007Pending = window.cr007.authenticateInboxAccess(
+ window.cr007Controller,
+ window.cr007.origins[0],
+ 'reviewed_inbox_connection_auth'
+ );
+ });
+ await expect.poll(() => page.evaluate(() => window.cr007Waiting)).toBe(true);
+ await page.evaluate(() => {
+ window.cr007Fixture.churnHead();
+ window.cr007Release?.();
+ });
+ expect(await page.evaluate(() => window.cr007Pending)).not.toBe('accepted');
+ expect(
+ [...connections.values()].filter(
+ (origin) => origin !== 'wss://discovery.example.org'
+ )
+ ).toHaveLength(0);
+ expect(frames.filter(({ frame }) => frame[0] === 'AUTH')).toHaveLength(0);
+});
+test('selected live receive scope reaches OPEN while a delivery scope cannot borrow reads', async ({
+ page
+}) => {
+ const result = await page.evaluate(() => {
+ const receive = window.cr007Fixture.scope(
+ [window.cr007.origins[2]],
+ 'receive'
+ );
+ window.cr007StopLive = window.cr007Fixture.live(receive, () => {
+ window.cr007Open = true;
+ });
+ const delivery = window.cr007Fixture.scope(
+ [window.cr007.origins[1]],
+ 'delivery'
+ );
+ let refused = false;
+ try {
+ window.cr007Fixture.page(delivery);
+ } catch {
+ refused = true;
+ }
+ return refused;
+ });
+ expect(result).toBe(true);
+ await expect.poll(() => page.evaluate(() => window.cr007Open)).toBe(true);
+ expect(
+ frames.filter(
+ ({ origin, frame }) =>
+ origin === 'wss://peer.example.org' && frame[0] === 'REQ'
+ )
+ ).toHaveLength(0);
+});
+test('closing AUTH controller leaves independent other-origin receive and anonymous discovery intact', async ({
+ page
+}) => {
+ await challenge(page);
+ await page.evaluate(() => {
+ const receive = window.cr007Fixture.scope(
+ [window.cr007.origins[2]],
+ 'receive'
+ );
+ window.cr007StopLive = window.cr007Fixture.live(receive, () => {
+ window.cr007Open = true;
+ });
+ });
+ await expect.poll(() => page.evaluate(() => window.cr007Open)).toBe(true);
+ await expect
+ .poll(
+ () =>
+ [...connections.values()].filter(
+ (origin) => origin === 'wss://archive.example.org'
+ ).length
+ )
+ .toBe(1);
+ await page.evaluate(() =>
+ window.cr007.closeInboxAccessController(window.cr007Controller)
+ );
+ await expect
+ .poll(
+ () =>
+ [...connections.values()].filter(
+ (origin) => origin === 'wss://inbox.example.org'
+ ).length
+ )
+ .toBe(0);
+ expect(
+ [...connections.values()].filter(
+ (origin) => origin === 'wss://archive.example.org'
+ )
+ ).toHaveLength(1);
+ expect(await page.evaluate(() => window.cr007Open)).toBe(true);
+});
+
+test('scope-only current-head page invalidation leaves another origin live', async ({
+ page
+}) => {
+ await page.evaluate(() => {
+ const receive = window.cr007Fixture.scope(
+ [window.cr007.origins[2]],
+ 'receive'
+ );
+ window.cr007LiveEvents = 0;
+ window.cr007StopLive = window.cr007Fixture.live(
+ receive,
+ () => {
+ window.cr007Open = true;
+ },
+ () => {
+ window.cr007LiveEvents = (window.cr007LiveEvents ?? 0) + 1;
+ }
+ );
+ });
+ await expect.poll(() => page.evaluate(() => window.cr007Open)).toBe(true);
+ await expect
+ .poll(
+ () =>
+ [...connections.values()].filter(
+ (origin) => origin === 'wss://archive.example.org'
+ ).length
+ )
+ .toBe(1);
+ await page.evaluate(() => {
+ const pageScope = window.cr007Fixture.scope(
+ [window.cr007.origins[0]],
+ 'receive',
+ true
+ );
+ window.cr007StopPage = window.cr007Fixture.page(pageScope, (reason) => {
+ window.cr007PageEnd = reason;
+ });
+ });
+ await expect
+ .poll(
+ () =>
+ frames.filter(
+ ({ origin, frame }) =>
+ origin === 'wss://inbox.example.org' && frame[0] === 'REQ'
+ ).length
+ )
+ .toBe(1);
+ await page.evaluate(() => window.cr007Fixture.churnHead());
+ const request = frames.find(
+ ({ origin, frame }) =>
+ origin === 'wss://inbox.example.org' && frame[0] === 'REQ'
+ );
+ expect(request).toBeDefined();
+ for (const [socket, origin] of connections) {
+ if (origin === 'wss://inbox.example.org')
+ socket.send(JSON.stringify(['EOSE', request!.frame[1]]));
+ if (origin === 'wss://archive.example.org') {
+ const live = frames.find(
+ ({ origin: from, frame }) => from === origin && frame[0] === 'REQ'
+ );
+ socket.send(
+ JSON.stringify([
+ 'EVENT',
+ live!.frame[1],
+ {
+ id: '1'.repeat(64),
+ pubkey: '2'.repeat(64),
+ kind: 1059,
+ created_at: 1,
+ tags: [],
+ content: '',
+ sig: '3'.repeat(128)
+ }
+ ])
+ );
+ }
+ }
+ await expect
+ .poll(() => page.evaluate(() => window.cr007PageEnd))
+ .toBe('stale');
+ await expect.poll(() => page.evaluate(() => window.cr007LiveEvents)).toBe(1);
+ expect(
+ [...connections.values()].filter(
+ (origin) => origin === 'wss://archive.example.org'
+ )
+ ).toHaveLength(1);
+});
+test('pending receive fresh-key wait is fenced by genuine discovery-head churn', async ({
+ page
+}) => {
+ await page.evaluate(() => {
+ window.cr007Fixture.beforeKey(
+ () =>
+ new Promise<void>((resolve) => {
+ window.cr007Waiting = true;
+ window.cr007Release = resolve;
+ })
+ );
+ const receive = window.cr007Fixture.scope(
+ [window.cr007.origins[0]],
+ 'receive',
+ true
+ );
+ window.cr007StopPage = window.cr007Fixture.page(receive, (reason) => {
+ window.cr007PageEnd = reason;
+ });
+ });
+ await expect.poll(() => page.evaluate(() => window.cr007Waiting)).toBe(true);
+ await page.evaluate(() => {
+ window.cr007Fixture.churnHead();
+ window.cr007Release?.();
+ });
+ await expect
+ .poll(() => page.evaluate(() => window.cr007PageEnd))
+ .toBe('stale');
+ expect(
+ frames.filter(
+ ({ origin, frame }) =>
+ origin === 'wss://inbox.example.org' && frame[0] === 'REQ'
+ )
+ ).toHaveLength(0);
+ expect(
+ [...connections.values()].filter(
+ (origin) => origin !== 'wss://discovery.example.org'
+ )
+ ).toHaveLength(0);
+});
+test('AUTH retirement blocks a pending same-origin receive until actual physical close', async ({
+ page
+}) => {
+ await challenge(page);
+ await page.evaluate(() => {
+ window.cr007DelayClose = true;
+ window.cr007Fixture.beforeKey(
+ () =>
+ new Promise<void>((resolve) => {
+ window.cr007Waiting = true;
+ window.cr007Release = resolve;
+ })
+ );
+ const receive = window.cr007Fixture.scope(
+ [window.cr007.origins[0]],
+ 'receive'
+ );
+ window.cr007StopPage = window.cr007Fixture.page(receive, (reason) => {
+ window.cr007PageEnd = reason;
+ });
+ });
+ await expect.poll(() => page.evaluate(() => window.cr007Waiting)).toBe(true);
+ await page.evaluate(() => {
+ window.cr007.closeInboxAccessController(window.cr007Controller);
+ window.cr007Release?.();
+ });
+ await expect
+ .poll(() => page.evaluate(() => window.cr007PageEnd))
+ .toBe('stale');
+ expect(
+ frames.filter(
+ ({ origin, frame }) =>
+ origin === 'wss://inbox.example.org' && frame[0] === 'REQ'
+ )
+ ).toHaveLength(0);
+ expect(
+ [...connections.values()].filter(
+ (origin) => origin === 'wss://inbox.example.org'
+ )
+ ).toHaveLength(1);
+ expect(
+ await page.evaluate(() => {
+ try {
+ window.cr007Fixture.scope([window.cr007.origins[0]], 'receive');
+ return false;
+ } catch {
+ return true;
+ }
+ })
+ ).toBe(true);
+ await page.evaluate(() => {
+ window.cr007DelayClose = false;
+ for (const release of window.cr007HeldClose ?? []) release();
+ });
+ await expect
+ .poll(
+ () =>
+ [...connections.values()].filter(
+ (origin) => origin === 'wss://inbox.example.org'
+ ).length
+ )
+ .toBe(0);
+});
+test('ordinary three-socket session teardown blocks replacement until actual close', async ({
+ page
+}) => {
+ await page.evaluate(() => {
+ const receive = window.cr007Fixture.scope(window.cr007.origins, 'receive');
+ window.cr007StopLive = window.cr007Fixture.live(receive, () => {
+ window.cr007Open = true;
+ });
+ });
+ await expect.poll(() => page.evaluate(() => window.cr007Open)).toBe(true);
+ await expect
+ .poll(
+ () =>
+ [...connections.values()].filter(
+ (origin) => origin !== 'wss://discovery.example.org'
+ ).length
+ )
+ .toBe(3);
+ expect(
+ [...connections.values()].filter(
+ (origin) => origin !== 'wss://discovery.example.org'
+ )
+ ).toHaveLength(3);
+ const originalSockets = [...connections.keys()].filter(
+ (socket) => connections.get(socket) !== 'wss://discovery.example.org'
+ );
+ const result = await page.evaluate(async () => {
+ window.cr007DelayClose = true;
+ const closed = window.cr007Fixture.closeSession();
+ try {
+ await window.cr007Fixture.successorScope();
+ return { closed, blocked: false };
+ } catch {
+ return { closed, blocked: true };
+ }
+ });
+ expect(result).toEqual({ closed: false, blocked: true });
+ expect(
+ [...connections.keys()].filter(
+ (socket) => connections.get(socket) !== 'wss://discovery.example.org'
+ )
+ ).toEqual(originalSockets);
+ expect(constructedPrivateConnections).toBe(3);
+ expect(peakPrivateConnections).toBe(3);
+ expect(
+ [...connections.values()].filter(
+ (origin) => origin !== 'wss://discovery.example.org'
+ )
+ ).toHaveLength(3);
+ await page.evaluate(() => {
+ window.cr007DelayClose = false;
+ for (const release of window.cr007HeldClose ?? []) release();
+ });
+ await expect
+ .poll(
+ () =>
+ [...connections.values()].filter(
+ (origin) => origin !== 'wss://discovery.example.org'
+ ).length
+ )
+ .toBe(0);
+ await page.evaluate(async () => {
+ const receive = await window.cr007Fixture.successorScope();
+ window.cr007StopLive = window.cr007Fixture.live(receive, () => {
+ window.cr007Reconnected = true;
+ });
+ });
+ await expect
+ .poll(() => page.evaluate(() => window.cr007Reconnected))
+ .toBe(true);
+ await expect
+ .poll(
+ () =>
+ [...connections.values()].filter(
+ (origin) => origin !== 'wss://discovery.example.org'
+ ).length
+ )
+ .toBe(3);
+ expect(
+ [...connections.values()].filter(
+ (origin) => origin !== 'wss://discovery.example.org'
+ )
+ ).toHaveLength(3);
+ await expect.poll(() => constructedPrivateConnections).toBe(6);
+ expect(peakPrivateConnections).toBe(3);
+});
+test('synchronous native constructor failure retires the original metadata and permits actual retry', async ({
+ page
+}) => {
+ await page.evaluate(() => {
+ window.cr007ThrowConstructor = window.cr007.origins[0];
+ const receive = window.cr007Fixture.scope(
+ [window.cr007.origins[0]],
+ 'receive'
+ );
+ window.cr007StopPage = window.cr007Fixture.page(receive, (reason) => {
+ window.cr007PageEnd = reason;
+ });
+ });
+ await expect
+ .poll(() => page.evaluate(() => window.cr007PageEnd))
+ .toBe('error');
+ expect(
+ [...connections.values()].filter(
+ (origin) => origin !== 'wss://discovery.example.org'
+ )
+ ).toHaveLength(0);
+ await page.evaluate(() => {
+ const receive = window.cr007Fixture.scope(
+ [window.cr007.origins[0]],
+ 'receive'
+ );
+ window.cr007StopLive = window.cr007Fixture.live(receive, () => {
+ window.cr007Open = true;
+ });
+ });
+ await expect.poll(() => page.evaluate(() => window.cr007Open)).toBe(true);
+ await expect
+ .poll(
+ () =>
+ [...connections.values()].filter(
+ (origin) => origin !== 'wss://discovery.example.org'
+ ).length
+ )
+ .toBe(1);
+ expect(
+ [...connections.values()].filter(
+ (origin) => origin !== 'wss://discovery.example.org'
+ )
+ ).toHaveLength(1);
+});
+
+test('AUTH startup native constructor failure releases the exact origin before explicit retry', async ({
+ page
+}) => {
+ const first = await page.evaluate(async () => {
+ window.cr007ThrowConstructor = window.cr007.origins[0];
+ return window.cr007.authenticateInboxAccess(
+ window.cr007Controller,
+ window.cr007.origins[0],
+ 'reviewed_inbox_connection_auth'
+ );
+ });
+ expect(first).toBe('unavailable');
+ expect(
+ [...connections.values()].filter(
+ (origin) => origin !== 'wss://discovery.example.org'
+ )
+ ).toHaveLength(0);
+ await challenge(page);
+ expect(
+ await page.evaluate(() =>
+ window.cr007.respondInboxAccessAuthentication(
+ window.cr007Controller,
+ window.cr007.origins[0],
+ 'reviewed_inbox_auth_response'
+ )
+ )
+ ).toBe('accepted');
+ expect(frames.filter(({ frame }) => frame[0] === 'AUTH')).toHaveLength(1);
+});
+
+test('failed AUTH startup cleanup stays with its original scope and retries after removal recovers', async ({
+ page
+}) => {
+ const first = await page.evaluate(async () => {
+ window.cr007ThrowConstructor = window.cr007.origins[0];
+ window.cr007Fault = window.cr007.installCloseFailure();
+ return window.cr007.authenticateInboxAccess(
+ window.cr007Controller,
+ window.cr007.origins[0],
+ 'reviewed_inbox_connection_auth'
+ );
+ });
+ expect(first).toBe('unavailable');
+ expect(
+ await page.evaluate(() =>
+ window.cr007.closeInboxAccessController(window.cr007Controller)
+ )
+ ).toBe(false);
+ await page.evaluate(() => window.cr007Fault?.allow());
+ expect(
+ await page.evaluate(() =>
+ window.cr007.closeInboxAccessController(window.cr007Controller)
+ )
+ ).toBe(true);
+ await page.evaluate(async () => {
+ window.cr007Fault?.restore();
+ window.cr007Controller = await window.cr007Fixture.capture();
+ });
+ await challenge(page);
+ expect(
+ await page.evaluate(() =>
+ window.cr007.respondInboxAccessAuthentication(
+ window.cr007Controller,
+ window.cr007.origins[0],
+ 'reviewed_inbox_auth_response'
+ )
+ )
+ ).toBe('accepted');
+ expect(frames.filter(({ frame }) => frame[0] === 'AUTH')).toHaveLength(1);
+});
diff --git a/web/tests/e2e/inbox-auth.spec.ts b/web/tests/e2e/inbox-auth.spec.ts
@@ -364,7 +364,7 @@ test('new physical connection and explicit action do not inherit accepted scope'
window.hcp068.respondInboxAuthentication(window.hcp068Action)
);
await page.evaluate(async () => {
- window.hcp068Fixture.close();
+ await window.hcp068Fixture.closeAndWait();
window.hcp068Fixture = await window.hcp068.makeAuthFixture();
const action = await window.hcp068.beginInboxAuthentication(
window.hcp068Fixture.pool,
@@ -424,7 +424,7 @@ test('raw private AUTH ports cannot bypass explicit review and guarded signing',
page
}) => {
const status = await page.evaluate(async () => {
- window.hcp068Fixture.close();
+ await window.hcp068Fixture.closeAndWait();
window.hcp068Fixture = await window.hcp068.makeAuthFixture();
return window.hcp068Fixture.rawPortBypass();
});
@@ -449,7 +449,7 @@ test('reviewed AUTH uses the same genuine already-open private page connection',
}) => {
holdPage = true;
await page.evaluate(async () => {
- window.hcp068Fixture.close();
+ await window.hcp068Fixture.closeAndWait();
window.hcp068Fixture = await window.hcp068.makeAuthFixture();
window.hcp068Fixture.startPage();
});
diff --git a/web/tests/e2e/private-publisher.spec.ts b/web/tests/e2e/private-publisher.spec.ts
@@ -2,13 +2,18 @@ import { test, expect } from '@playwright/test';
import { build } from 'vite';
import { fileURLToPath } from 'node:url';
import { once } from 'node:events';
-import { WebSocketServer } from 'ws';
+import { WebSocketServer, type WebSocket } from 'ws';
import { createStaticHarness } from '../integration/harness/static.ts';
import type * as Fixture from './harness/private-publisher.ts';
declare global {
interface Window {
hcp085: typeof Fixture;
hcp085Fixture: Awaited<ReturnType<typeof Fixture.makeFixture>>;
+ hcp085DelayClose?: boolean;
+ hcp085HeldClose?: (() => void)[];
+ hcp085SharedAction?: NonNullable<
+ ReturnType<Window['hcp085Fixture']['action']>
+ >;
}
}
let server: Awaited<ReturnType<typeof createStaticHarness>>,
@@ -16,7 +21,10 @@ let server: Awaited<ReturnType<typeof createStaticHarness>>,
endpoint: string,
bundle: string;
let frames: { origin: string; frame: unknown[] }[] = [],
- response: 'accepted' | 'refused' = 'accepted';
+ response: 'accepted' | 'refused' | 'unknown' = 'accepted';
+const physical = new Set<WebSocket>();
+let constructed = 0,
+ peak = 0;
test.beforeAll(async () => {
server = await createStaticHarness();
sockets = new WebSocketServer({
@@ -30,6 +38,10 @@ test.beforeAll(async () => {
throw Error('loopback unavailable');
endpoint = 'ws://127.0.0.1:' + address.port;
sockets.on('connection', (socket, request) => {
+ physical.add(socket);
+ constructed++;
+ peak = Math.max(peak, physical.size);
+ socket.on('close', () => physical.delete(socket));
const origin = new URL(request.url!, 'http://127.0.0.1').searchParams.get(
'origin'
)!;
@@ -41,7 +53,7 @@ test.beforeAll(async () => {
: Buffer.from(bytes);
const frame = JSON.parse(raw.toString()) as unknown[];
frames.push({ origin, frame });
- if (frame[0] === 'EVENT') {
+ if (frame[0] === 'EVENT' && response !== 'unknown') {
const event = frame[1] as { id: string };
socket.send(
JSON.stringify([
@@ -83,6 +95,9 @@ test.afterAll(async () => {
await server.close();
});
test.beforeEach(async ({ page }) => {
+ await expect.poll(() => physical.size).toBe(0);
+ constructed = 0;
+ peak = 0;
frames = [];
response = 'accepted';
await page.addInitScript(
@@ -102,6 +117,13 @@ test.beforeEach(async ({ page }) => {
protocols
);
}
+ override close(code?: number, reason?: string) {
+ if (window.hcp085DelayClose)
+ (window.hcp085HeldClose ??= []).push(() =>
+ super.close(code, reason)
+ );
+ else super.close(code, reason);
+ }
};
},
{ endpoint }
@@ -111,7 +133,11 @@ test.beforeEach(async ({ page }) => {
});
test.afterEach(async ({ page }) => {
if (!page.isClosed())
- await page.evaluate(() => window.hcp085Fixture?.close());
+ await page.evaluate(() => {
+ window.hcp085DelayClose = false;
+ for (const release of window.hcp085HeldClose ?? []) release();
+ window.hcp085Fixture?.close();
+ });
});
async function fixture(
page: import('@playwright/test').Page,
@@ -369,3 +395,161 @@ test('actual owner loss still clears the bound private composer and prevents pub
expect(result.attempt.status).toBe('stopped');
expect(frames).toEqual([]);
});
+
+for (const fault of ['SDK acquisition', 'actual network clock abort'] as const)
+ test(
+ 'original metered action releases reservation after ' +
+ fault +
+ ' and permits reviewed retry',
+ async ({ page }) => {
+ await fixture(page);
+ const result = await page.evaluate(async (fault) => {
+ const f = window.hcp085Fixture;
+ await f.prepare();
+ const action = f.action();
+ if (!action) throw Error('genuine metered action missing');
+ const firstPermission = f.permission(
+ 'peer',
+ f.peerOrigin,
+ 'reviewed_private_delivery',
+ action
+ );
+ if (!firstPermission) throw Error('genuine first permission missing');
+ const abort = new AbortController();
+ let restore: () => void,
+ observed = () => true;
+ if (fault === 'SDK acquisition') restore = f.failAcquisition();
+ else {
+ const clock = f.abortOnActualNetworkClock(abort);
+ restore = clock.restore;
+ observed = clock.observed;
+ }
+ let first;
+ try {
+ first = await f.publish(firstPermission, abort.signal);
+ } finally {
+ restore();
+ }
+ const retryPermission = f.permission(
+ 'peer',
+ f.peerOrigin,
+ 'reviewed_private_delivery',
+ action
+ );
+ if (!retryPermission)
+ throw Error('genuine original action retry permission missing');
+ const retry = await f.publish(
+ retryPermission,
+ new AbortController().signal
+ );
+ return { first, retry, observed: observed() };
+ }, fault);
+ expect(result.observed).toBe(true);
+ expect(result.first.status).toBe('stopped');
+ expect(result.first.actionId).toBeUndefined();
+ expect(result.first.attempt).toBeUndefined();
+ expect(result.retry.status).toBe('accepted');
+ expect(result.retry.attempt).toBe(fault === 'SDK acquisition' ? 1 : 2);
+ expect(frames.filter(({ frame }) => frame[0] === 'EVENT')).toHaveLength(
+ 1
+ );
+ }
+ );
+
+test('genuine shared-origin peer and archive roles reuse one original connection and distinct exact artifacts', async ({
+ page
+}) => {
+ const result = await page.evaluate(async () => {
+ window.hcp085Fixture = await window.hcp085.makeFixture(false, true);
+ const f = window.hcp085Fixture;
+ window.hcp085DelayClose = true;
+ await f.prepare();
+ const action = f.action();
+ if (!action) throw Error('genuine metered action');
+ const peer = f.permission(
+ 'peer',
+ f.peerOrigin,
+ 'reviewed_private_delivery',
+ action
+ );
+ const archive = f.permission(
+ 'self_archive',
+ f.archiveOrigin,
+ 'reviewed_private_delivery',
+ action
+ );
+ if (!peer || !archive) throw Error('genuine original two-role permissions');
+ const first = await f.publish(peer);
+ const second = await f.publish(archive);
+ const retry = f.permission(
+ 'peer',
+ f.peerOrigin,
+ 'reviewed_private_delivery',
+ action
+ );
+ if (!retry) throw Error('genuine reviewed original retry');
+ const third = await f.publish(retry);
+ return { first, second, third };
+ });
+ expect(constructed).toBe(1);
+ expect(peak).toBe(1);
+ expect(physical.size).toBe(1);
+ expect(await page.evaluate(() => window.hcp085HeldClose?.length ?? 0)).toBe(
+ 0
+ );
+ expect(result.first.status).toBe('accepted');
+ expect(result.second.status).toBe('accepted');
+ expect(result.third.status).toBe('accepted');
+ expect(result.first.eventId).not.toBe(result.second.eventId);
+ expect(result.third.eventId).toBe(result.first.eventId);
+ expect(result.third.attempt).toBe(2);
+ const events = frames.filter(({ frame }) => frame[0] === 'EVENT');
+ expect(events).toHaveLength(3);
+ expect(
+ events.every(({ origin }) => origin === 'wss://peer.example.org')
+ ).toBe(true);
+});
+
+test('original shared-origin unknown EVENT retries the exact artifact on the same actual connection', async ({
+ page
+}) => {
+ response = 'unknown';
+ const first = await page.evaluate(async () => {
+ window.hcp085Fixture = await window.hcp085.makeFixture(false, true);
+ const f = window.hcp085Fixture;
+ window.hcp085DelayClose = true;
+ await f.prepare();
+ window.hcp085SharedAction = f.action();
+ if (!window.hcp085SharedAction) throw Error('genuine action');
+ const permission = f.permission(
+ 'peer',
+ f.peerOrigin,
+ 'reviewed_private_delivery',
+ window.hcp085SharedAction
+ );
+ if (!permission) throw Error('genuine permission');
+ return f.publish(permission);
+ });
+ expect(['unknown', 'timed_out']).toContain(first.status);
+ expect(constructed).toBe(1);
+ response = 'accepted';
+ const retry = await page.evaluate(async () => {
+ const f = window.hcp085Fixture;
+ const permission = f.permission(
+ 'peer',
+ f.peerOrigin,
+ 'reviewed_private_delivery',
+ window.hcp085SharedAction
+ );
+ if (!permission) throw Error('genuine original explicit retry permission');
+ return f.publish(permission);
+ });
+ expect(retry.status).toBe('accepted');
+ expect(retry.eventId).toBe(first.eventId);
+ expect(retry.attempt).toBe(2);
+ expect(constructed).toBe(1);
+ expect(peak).toBe(1);
+ const events = frames.filter(({ frame }) => frame[0] === 'EVENT');
+ expect(events).toHaveLength(2);
+ expect(events[1].frame[1]).toEqual(events[0].frame[1]);
+});
diff --git a/web/tests/e2e/product-request.spec.ts b/web/tests/e2e/product-request.spec.ts
@@ -10,6 +10,9 @@ import type * as Fixture from './harness/product-request.ts';
declare global {
interface Window {
+ cr007PendingSend?: Promise<unknown>;
+ cr007DelayPrivateClose?: boolean;
+ cr007DelayedCloses?: (() => void)[];
hcp107: typeof Fixture;
hcp107Fixture: Awaited<ReturnType<typeof Fixture.renderFixture>>;
hcp108SendClock: {
@@ -31,6 +34,7 @@ declare global {
let server: Awaited<ReturnType<typeof createStaticHarness>>;
let sockets: WebSocketServer, endpoint: string, bundle: string;
let missingOwn = false;
+let holdPrivateAck = false;
let listingStatus: 'active' | 'sold' | 'withdrawn' = 'active';
let sellerInbox:
| 'normal'
@@ -98,9 +102,10 @@ test.beforeAll(async () => {
events.push({ origin, event });
if (event.kind === 10050)
ownPreference = event as ReturnType<typeof finalizeEvent>;
- socket.send(
- JSON.stringify(['OK', event.id, true, 'controlled acceptance'])
- );
+ if (!holdPrivateAck || event.kind !== 1059)
+ socket.send(
+ JSON.stringify(['OK', event.id, true, 'controlled acceptance'])
+ );
return;
}
if (frame[0] !== 'REQ') return;
@@ -282,6 +287,7 @@ test.afterAll(async () => {
test.beforeEach(async ({ page }) => {
events = [];
missingOwn = false;
+ holdPrivateAck = false;
listingStatus = 'active';
sellerInbox = 'normal';
incompleteListing = false;
@@ -307,6 +313,15 @@ test.beforeEach(async ({ page }) => {
)
throw Error('unapproved destination');
super(endpoint + '/?source=' + encodeURIComponent(origin), protocols);
+ this.cr007Private = origin !== 'wss://discovery.example.org';
+ }
+ readonly cr007Private: boolean;
+ override close(code?: number, reason?: string) {
+ if (this.cr007Private && window.cr007DelayPrivateClose)
+ (window.cr007DelayedCloses ??= []).push(() =>
+ super.close(code, reason)
+ );
+ else super.close(code, reason);
}
};
},
@@ -317,7 +332,11 @@ test.beforeEach(async ({ page }) => {
});
test.afterEach(async ({ page }) => {
if (!page.isClosed())
- await page.evaluate(() => window.hcp107Fixture?.close());
+ await page.evaluate(() => {
+ window.cr007DelayPrivateClose = false;
+ for (const release of window.cr007DelayedCloses ?? []) release();
+ return window.hcp107Fixture?.close();
+ });
});
const panel = (page: Page) => page.locator('[data-request-fixture]');
const editor = (page: Page) =>
@@ -1672,3 +1691,33 @@ for (const outcome of [
expect(events.filter((row) => row.event.kind === 1059)).toEqual([]);
}
});
+
+test('CR007 pending actual product request EVENT plus route close settles stopped and preserves cleanup', async ({
+ page
+}) => {
+ await ready(page);
+ await unlock(page);
+ holdPrivateAck = true;
+ await page.evaluate(() => {
+ window.cr007DelayPrivateClose = true;
+ window.cr007PendingSend = window.hcp107Fixture.beginHeadless();
+ });
+ await expect
+ .poll(() => events.filter(({ event }) => event.kind === 1059).length)
+ .toBe(1);
+ await page.evaluate(() => window.hcp107Fixture.closeView());
+ expect(await page.evaluate(() => window.cr007PendingSend)).toEqual({
+ status: 'stopped'
+ });
+ expect(
+ await page.evaluate(() => window.hcp107Fixture.headlessSnapshot())
+ ).toBeUndefined();
+ expect(events.filter(({ event }) => event.kind === 1059)).toHaveLength(1);
+ expect(
+ await page.evaluate(() => window.cr007DelayedCloses?.length ?? 0)
+ ).toBeGreaterThan(0);
+ await page.evaluate(() => {
+ window.cr007DelayPrivateClose = false;
+ for (const release of window.cr007DelayedCloses ?? []) release();
+ });
+});
diff --git a/web/tests/e2e/reply-composer.spec.ts b/web/tests/e2e/reply-composer.spec.ts
@@ -9,6 +9,9 @@ import type * as Fixture from './harness/reply-composer.ts';
import { finalizeEvent } from 'applesauce-core/helpers';
declare global {
interface Window {
+ cr007PendingSend?: Promise<unknown>;
+ cr007DelayPrivateClose?: boolean;
+ cr007DelayedCloses?: (() => void)[];
hcp104: typeof Fixture;
hcp104Fixture: Awaited<ReturnType<typeof Fixture.renderReplyFixture>>;
hcp104Pending?: Promise<unknown>;
@@ -22,6 +25,7 @@ let events: unknown[][] = [],
requests: unknown[][] = [];
let servePeerPreference = false;
let holdPeerEose = false;
+let holdPrivateAck = false;
let heldPeerRequest:
| {
socket: WebSocket;
@@ -77,7 +81,8 @@ test.beforeAll(async () => {
if (frame[0] === 'EVENT') {
events.push(frame);
const event = frame[1] as { id: string };
- socket.send(JSON.stringify(['OK', event.id, true, '']));
+ if (!holdPrivateAck)
+ socket.send(JSON.stringify(['OK', event.id, true, '']));
}
if (frame[0] === 'REQ') {
requests.push(frame);
@@ -157,6 +162,16 @@ async function load(page: import('@playwright/test').Page) {
)
throw Error('unapproved destination');
super(endpoint, protocols);
+ this.cr007Private =
+ new URL(String(url)).origin !== 'wss://discovery.example.org';
+ }
+ readonly cr007Private: boolean;
+ override close(code?: number, reason?: string) {
+ if (this.cr007Private && window.cr007DelayPrivateClose)
+ (window.cr007DelayedCloses ??= []).push(() =>
+ super.close(code, reason)
+ );
+ else super.close(code, reason);
}
};
},
@@ -170,6 +185,7 @@ test.beforeEach(async ({ page }) => {
requests = [];
servePeerPreference = false;
holdPeerEose = false;
+ holdPrivateAck = false;
heldPeerRequest = undefined;
await load(page);
});
@@ -178,6 +194,8 @@ test.afterEach(async ({ page }) => {
await page.evaluate(async () => {
window.hcp104Fixture?.settle();
await window.hcp104Pending;
+ window.cr007DelayPrivateClose = false;
+ for (const release of window.cr007DelayedCloses ?? []) release();
await window.hcp104Fixture?.close();
});
});
@@ -917,3 +935,34 @@ test('later edit after opening dirty warning invalidates the reviewed discard re
expect(events).toEqual([]);
expect(requests).toEqual([]);
});
+
+test('CR007 pending actual reply EVENT plus route close settles stopped and preserves physical cleanup', async ({
+ page
+}) => {
+ await ready(page);
+ await composer(page).getByLabel('Reply', { exact: true }).fill(sentinel);
+ holdPrivateAck = true;
+ await page.evaluate(() => {
+ window.cr007DelayPrivateClose = true;
+ window.cr007PendingSend = window.hcp104Fixture.send();
+ });
+ await expect.poll(() => events.length).toBe(1);
+ await page.evaluate(() => window.hcp104Fixture.closeComposer());
+ expect(await page.evaluate(() => window.cr007PendingSend)).toEqual({
+ status: 'stopped'
+ });
+ expect(
+ await page.evaluate(() => window.hcp104Fixture.snapshot())
+ ).toBeUndefined();
+ expect(
+ await page.evaluate(() => window.hcp104Fixture.text())
+ ).toBeUndefined();
+ expect(events).toHaveLength(1);
+ expect(
+ await page.evaluate(() => window.cr007DelayedCloses?.length ?? 0)
+ ).toBeGreaterThan(0);
+ await page.evaluate(() => {
+ window.cr007DelayPrivateClose = false;
+ for (const release of window.cr007DelayedCloses ?? []) release();
+ });
+});
diff --git a/web/tests/integration/private-pool.test.ts b/web/tests/integration/private-pool.test.ts
@@ -22,6 +22,7 @@ import {
privatePoolOrigins,
subscribePrivatePage,
closePrivatePool,
+ privatePoolCleanupRequired,
type PrivatePageMessage
} from '../../src/lib/nostr/private-pool.ts';
import {
@@ -235,6 +236,13 @@ await test('private page transport keeps actual SDK scopes and ownership separat
);
});
}
+ async function awaitRetirement() {
+ while (privatePool && privatePoolCleanupRequired(privatePool)) {
+ if (privateSessionSnapshot(privateSession!)?.current === false)
+ closePrivateSession(privateSession!);
+ await new Promise<void>((resolve) => setImmediate(resolve));
+ }
+ }
async function heldPage() {
delivery = 'hold';
heldRequests = 0;
@@ -401,6 +409,7 @@ await test('private page transport keeps actual SDK scopes and ownership separat
await t.test(
'same-author reconnect cannot revive an old scope or consume stale callbacks',
async () => {
+ await awaitRetirement();
await connectIdentity(identity);
await probeIdentityMessaging(identity, 'reviewed_self_copy');
assert.equal(privateSessionSnapshot(privateSession!)?.current, false);
@@ -420,7 +429,7 @@ await test('private page transport keeps actual SDK scopes and ownership separat
);
await t.test(
'failed SDK cleanup blocks replacement until exact cleanup retry succeeds',
- () => {
+ async () => {
const before = constructed;
const held = sdkScopes.get('private');
assert.ok(held);
@@ -428,17 +437,44 @@ await test('private page transport keeps actual SDK scopes and ownership separat
if (this === held) throw new Error('HC_TEST_ONLY_CLOSE_FAILURE');
return originalClose.call(this);
};
+ // Actual session teardown owns whole-SDK disposal; an operation scope
+ // may close only its own work and cannot exercise this failure port.
+ assert.equal(closePrivateSession(privateSession!), false);
assert.throws(
- () => closePrivatePool(privatePool!),
- /private_pool_close_failed/
+ () => getPrivatePool(privateSession!, policy, origins),
+ /private_session_invalid/
+ );
+ assert.equal(
+ await createPrivateSession(identity, 'reviewed_private_session'),
+ undefined
+ );
+ const successorIdentity = createIdentitySession();
+ await connectIdentity(successorIdentity);
+ await probeIdentityMessaging(successorIdentity, 'reviewed_self_copy');
+ const blockedSuccessor = await createPrivateSession(
+ successorIdentity,
+ 'reviewed_private_session'
);
+ assert.ok(blockedSuccessor);
assert.throws(
- () => getPrivatePool(privateSession!, policy, origins),
+ () => getPrivatePool(blockedSuccessor, policy, origins),
/private_pool_closed/
);
+ closePrivateSession(blockedSuccessor);
+ disconnectIdentity(successorIdentity);
assert.equal(constructed, before);
RelayPool.prototype.close = originalClose;
- closePrivatePool(privatePool!);
+ while (!closePrivateSession(privateSession!))
+ await new Promise<void>((resolve) => setImmediate(resolve));
+ assert.equal(closePrivateSession(privateSession!), true);
+ const next = await createPrivateSession(
+ identity,
+ 'reviewed_private_session'
+ );
+ assert.ok(next);
+ privateSession = next;
+ privatePool = getPrivatePool(next, policy, origins);
+ assert.ok(privatePool);
}
);
await t.test(
@@ -607,6 +643,7 @@ await test('private page transport keeps actual SDK scopes and ownership separat
} finally {
Subscription.prototype.unsubscribe = original;
closePrivatePool(privatePool!);
+ await awaitRetirement();
privatePool = getPrivatePool(privateSession!, policy, origins);
assert.ok(privatePool);
}
@@ -638,6 +675,7 @@ await test('private page transport keeps actual SDK scopes and ownership separat
unexpected?.();
Subscription.prototype.unsubscribe = original;
closePrivatePool(privatePool!);
+ await awaitRetirement();
}
}
);
@@ -682,6 +720,7 @@ await test('private page transport keeps actual SDK scopes and ownership separat
await t.test(
'candidate clock reentry cannot disclose old-owner ciphertext after logout',
async () => {
+ await awaitRetirement();
await connectIdentity(identity);
await probeIdentityMessaging(identity, 'reviewed_self_copy');
privateSession = await createPrivateSession(
@@ -729,6 +768,7 @@ await test('private page transport keeps actual SDK scopes and ownership separat
await t.test(
'delayed genuine SDK owner response cannot open old-session sockets after logout',
async () => {
+ await awaitRetirement();
await connectIdentity(identity);
await probeIdentityMessaging(identity, 'reviewed_self_copy');
privateSession = await createPrivateSession(
@@ -807,6 +847,7 @@ await test('private page transport keeps actual SDK scopes and ownership separat
await t.test(
'capability loss closes actual private transport and signing alone cannot reopen it',
async () => {
+ await awaitRetirement();
await connectIdentity(identity);
await probeIdentityMessaging(identity, 'reviewed_self_copy');
privateSession = await createPrivateSession(
diff --git a/web/tests/provenance/output.test.mjs b/web/tests/provenance/output.test.mjs
@@ -1938,6 +1938,10 @@ import { auditOutput } from '../../tools/check-output.mjs';
}
for (const producer of [
'src/lib/config/operation-flags.ts',
+ 'src/lib/nostr/private-pool.ts',
+ 'src/lib/messaging/inbox-access-controller.ts',
+ 'src/lib/messaging/inbox-sync.ts',
+ 'src/lib/nostr/inbox-ingress.ts',
'src/lib/config/relays.ts',
'src/lib/runtime/capabilities.ts',
'src/lib/components/AppShell.svelte',
diff --git a/web/tests/provenance/source-boundaries.test.mjs b/web/tests/provenance/source-boundaries.test.mjs
@@ -18,6 +18,42 @@ import path from 'node:path';
import { fileURLToPath } from 'node:url';
import { test } from 'node:test';
+test('CR007 exact private SDK removal cannot become an arbitrary remove capability', async () => {
+ await fixture(async ({ directory, put, execute }) => {
+ await isolateScriptDependencies(directory);
+ await cp(path.join(root, 'src'), path.join(directory, 'src'), {
+ recursive: true
+ });
+ assert.equal(execute().status, 0);
+ const file = 'src/lib/nostr/private-pool.ts';
+ const source = await readFile(path.join(root, file), 'utf8');
+ assert.ok(source.includes('sdk.remove(relay)'));
+ for (const mutation of [
+ source + '\n export const unreviewedChange=1;\n',
+ source.replace('sdk.remove(relay)', 'sdk["remove"](relay)'),
+ source.replace('sdk.remove(relay)', 'sdk.remove(document.body)'),
+ source.replace('sdk.remove(relay)', '(sdk.remove)(relay)')
+ ]) {
+ await put(file, mutation);
+ const result = execute();
+ assert.notEqual(result.status, 0);
+ assert.match(result.stderr, /private relay removal source identity/);
+ }
+ await put(file, source);
+ await put('src/lib/nostr/copied-private-pool.ts', source);
+ assert.notEqual(execute().status, 0);
+ await rm(path.join(directory, 'src/lib/nostr/copied-private-pool.ts'));
+ await rm(path.join(directory, file));
+ assert.notEqual(execute().status, 0);
+ await put(file, source);
+ await put(
+ 'src/routes/+page.ts',
+ 'const receiver=document.body;receiver.remove();'
+ );
+ assert.notEqual(execute().status, 0);
+ });
+});
+
test('HCP060 document visibility access is confined to the exact disposal producer', async () => {
await fixture(async ({ directory, put, execute }) => {
await confineSvelte(directory);
diff --git a/web/tools/check-output.mjs b/web/tools/check-output.mjs
@@ -314,18 +314,24 @@ async function operationalFlagsAdmission(web) {
'9cc82877bfa8dbb2a7fa41bceb842793349416271f19569f49fdd5cfc1de07e5',
'src/lib/messaging/inbox-setup-operation.ts':
'245c6ce88b146dc731e7ace4f16dc9b5002a87a997f5568e4811b0c4a2daf035',
+ 'src/lib/nostr/private-pool.ts':
+ 'b4c718364625b3caacbc5cc5f98bd79a575a5d66dddb2d7f59f03351a1308a6d',
+ 'src/lib/nostr/inbox-ingress.ts':
+ 'f860a094a8ba767585124c795d44b7620064f73a5b3a0170041c581c0fc64ecb',
+ 'src/lib/messaging/inbox-access-controller.ts':
+ 'c3093fe329575aba43333675c28352a6c0ddf24bcbc380c27f3a1ebab6252c5b',
'src/lib/messaging/inbox-setup-view.ts':
'e85238d20f1bbcb23599b36e67910f3df784efa43f0fa0b0b7f3da7e7fd33c79',
'src/lib/messaging/inbox-setup.ts':
'7a935d8542ff8f64287d2b441a8a458d299dea4ed88beecda39cb1637dd4a9ac',
'src/lib/messaging/inbox-sync.ts':
- '84f9b3bb165a81878bb281c51d245aff7eb06a0fa55b857a49b13d0cb1cff8ae',
+ '0d91f5895e7eb054b036a5cb80897a3d60a212d470029a82d11124c8536b3d2c',
'src/lib/messaging/inbox-view.ts':
'6871707ae7395d3679856a01e87c7d8f273848e0b9ef0dc7b94f450d8417528c',
'src/lib/messaging/product-request-controller.ts':
- '0255f1d160f4f5f9d6a66d836a9473fbf4c03f9b569568a84bb4ec65c52b9c7e',
+ 'e1fab3a2bfb910c1d8b798628cf4799cd1f7e72f1d80ebc2a67e73730b6f3940',
'src/lib/messaging/reply-controller.ts':
- '60225bff6229c1f288a7f7eed55a7fdb780f853cd8b82d4f3995259a26d58eb1',
+ '8d2612b4788211b35ee8d56caa389bb88a53268bbba71407ee787c9dc23ee8a6',
'src/lib/messaging/rumor-plan.ts':
'b622889e96f911501524cd86f9fca9f2207ce853767494fb30799b00ae8275ed',
'src/lib/persistence/private-send-reservations.ts':
@@ -570,14 +576,20 @@ async function privacyDataAdmission(web) {
'be704e6cbe777722c3eb80ec9843f00afd7bac8c52af0c2af7294f2437414553',
'src/lib/messaging/inbox-list.ts':
'9cc82877bfa8dbb2a7fa41bceb842793349416271f19569f49fdd5cfc1de07e5',
+ 'src/lib/nostr/private-pool.ts':
+ 'b4c718364625b3caacbc5cc5f98bd79a575a5d66dddb2d7f59f03351a1308a6d',
+ 'src/lib/nostr/inbox-ingress.ts':
+ 'f860a094a8ba767585124c795d44b7620064f73a5b3a0170041c581c0fc64ecb',
+ 'src/lib/messaging/inbox-access-controller.ts':
+ 'c3093fe329575aba43333675c28352a6c0ddf24bcbc380c27f3a1ebab6252c5b',
'src/lib/messaging/inbox-setup-view.ts':
'4ec9025232bb1355fef1ba039b46ce0a2be10e02e348e1b4eaadc3d1f3c2fd84',
'src/lib/messaging/inbox-sync.ts':
- '84f9b3bb165a81878bb281c51d245aff7eb06a0fa55b857a49b13d0cb1cff8ae',
+ '0d91f5895e7eb054b036a5cb80897a3d60a212d470029a82d11124c8536b3d2c',
'src/lib/messaging/inbox-view.ts':
'6871707ae7395d3679856a01e87c7d8f273848e0b9ef0dc7b94f450d8417528c',
'src/lib/messaging/reply-controller.ts':
- '60225bff6229c1f288a7f7eed55a7fdb780f853cd8b82d4f3995259a26d58eb1',
+ '8d2612b4788211b35ee8d56caa389bb88a53268bbba71407ee787c9dc23ee8a6',
'src/lib/messaging/rumor-plan.ts':
'b622889e96f911501524cd86f9fca9f2207ce853767494fb30799b00ae8275ed',
'src/lib/persistence/private-send-reservations.ts':
@@ -792,11 +804,11 @@ async function supportReportingAdmission(web) {
'src/lib/messaging/inbox-setup-view.ts':
'4ec9025232bb1355fef1ba039b46ce0a2be10e02e348e1b4eaadc3d1f3c2fd84',
'src/lib/messaging/inbox-sync.ts':
- '84f9b3bb165a81878bb281c51d245aff7eb06a0fa55b857a49b13d0cb1cff8ae',
+ '0d91f5895e7eb054b036a5cb80897a3d60a212d470029a82d11124c8536b3d2c',
'src/lib/messaging/inbox-view.ts':
'6871707ae7395d3679856a01e87c7d8f273848e0b9ef0dc7b94f450d8417528c',
'src/lib/messaging/reply-controller.ts':
- '60225bff6229c1f288a7f7eed55a7fdb780f853cd8b82d4f3995259a26d58eb1',
+ '8d2612b4788211b35ee8d56caa389bb88a53268bbba71407ee787c9dc23ee8a6',
'src/lib/messaging/rumor-plan.ts':
'b622889e96f911501524cd86f9fca9f2207ce853767494fb30799b00ae8275ed',
'src/lib/persistence/private-send-reservations.ts':
@@ -981,11 +993,11 @@ async function privateBlockingAdmission(web) {
'src/lib/messaging/inbox-setup-view.ts':
'4ec9025232bb1355fef1ba039b46ce0a2be10e02e348e1b4eaadc3d1f3c2fd84',
'src/lib/messaging/inbox-sync.ts':
- '84f9b3bb165a81878bb281c51d245aff7eb06a0fa55b857a49b13d0cb1cff8ae',
+ '0d91f5895e7eb054b036a5cb80897a3d60a212d470029a82d11124c8536b3d2c',
'src/lib/messaging/inbox-view.ts':
'6871707ae7395d3679856a01e87c7d8f273848e0b9ef0dc7b94f450d8417528c',
'src/lib/messaging/reply-controller.ts':
- '60225bff6229c1f288a7f7eed55a7fdb780f853cd8b82d4f3995259a26d58eb1',
+ '8d2612b4788211b35ee8d56caa389bb88a53268bbba71407ee787c9dc23ee8a6',
'src/lib/messaging/rumor-plan.ts':
'b622889e96f911501524cd86f9fca9f2207ce853767494fb30799b00ae8275ed',
'src/lib/persistence/private-send-reservations.ts':
@@ -2130,7 +2142,7 @@ async function inboxPresentationAdmission(web) {
'src/lib/messaging/inbox-view.ts':
'f725d1e122550232efa52b26139d3047d3bbfd6d3d11b1ef0a110b5e4b4410dc',
'src/lib/messaging/inbox-sync.ts':
- '84f9b3bb165a81878bb281c51d245aff7eb06a0fa55b857a49b13d0cb1cff8ae',
+ '0d91f5895e7eb054b036a5cb80897a3d60a212d470029a82d11124c8536b3d2c',
'src/lib/messaging/inbox-setup-view.ts':
'4ec9025232bb1355fef1ba039b46ce0a2be10e02e348e1b4eaadc3d1f3c2fd84',
'src/lib/messaging/decryption-queue.ts':
diff --git a/web/tools/source-boundaries.mjs b/web/tools/source-boundaries.mjs
@@ -120,7 +120,8 @@ function mutationAdmission(
reviewedScroll = false,
reviewedCopy = false,
reviewedVisibility = false,
- reviewedReport = false
+ reviewedReport = false,
+ reviewedRelayRemoval = false
) {
// Bind this admitted AST only, without libs, module resolution, file reads,
// config loading or evaluation. Symbols distinguish aliases and shadowing.
@@ -159,6 +160,51 @@ function mutationAdmission(
ts.isStringLiteralLike(node.argumentExpression)
? node.argumentExpression.text
: null;
+ function relayRemoval(node) {
+ if (
+ !reviewedRelayRemoval ||
+ !ts.isPropertyAccessExpression(node) ||
+ node.name.text !== 'remove' ||
+ !ts.isIdentifier(node.expression) ||
+ !ts.isCallExpression(node.parent) ||
+ node.parent.expression !== node ||
+ node.parent.arguments.length !== 1 ||
+ !ts.isIdentifier(node.parent.arguments[0])
+ )
+ return false;
+ const declaration = checker.getSymbolAtLocation(
+ node.expression
+ )?.valueDeclaration;
+ if (
+ !declaration ||
+ !ts.isVariableDeclaration(declaration) ||
+ !(declaration.parent.flags & ts.NodeFlags.Const)
+ )
+ return false;
+ const call = declaration.initializer && unwrap(declaration.initializer);
+ if (
+ !call ||
+ !ts.isCallExpression(call) ||
+ call.arguments.length !== 0 ||
+ !ts.isIdentifier(call.expression)
+ )
+ return false;
+ const factory = checker.getSymbolAtLocation(call.expression)
+ ?.declarations?.[0];
+ if (
+ !factory ||
+ !ts.isImportSpecifier(factory) ||
+ (factory.propertyName?.text ?? factory.name.text) !==
+ 'createScopedRelayPool'
+ )
+ return false;
+ const imported = factory.parent.parent.parent;
+ return (
+ ts.isImportDeclaration(imported) &&
+ ts.isStringLiteral(imported.moduleSpecifier) &&
+ imported.moduleSpecifier.text === './pool-factory.ts'
+ );
+ }
function uiLeaf(node) {
let top = node;
while (
@@ -973,7 +1019,8 @@ function mutationAdmission(
!owned(node.expression) ||
!node.parent.arguments.every((argument) => pure(argument))
)
- report('opaque or indirect DOM mutation/setter APIs are forbidden');
+ if (!relayRemoval(node))
+ report('opaque or indirect DOM mutation/setter APIs are forbidden');
}
}
if (ts.isIdentifier(node)) {
@@ -1610,6 +1657,19 @@ export async function auditSource(root) {
reportFile,
'report copy source identity does not match reviewed pin'
);
+ // One reviewed transport producer may retire its own original SDK Relay.
+ // Complete bytes, original imported factory receiver and a direct call are
+ // required; no arbitrary DOM remove/alias/reflection exception is granted.
+ const relayRemovalFile = path.join(root, 'src/lib/nostr/private-pool.ts');
+ const relayRemovalTrusted =
+ files.has(relayRemovalFile) &&
+ createHash('sha256').update(files.get(relayRemovalFile)).digest('hex') ===
+ 'b4c718364625b3caacbc5cc5f98bd79a575a5d66dddb2d7f59f03351a1308a6d';
+ if (files.has(relayRemovalFile) && !relayRemovalTrusted)
+ complain(
+ relayRemovalFile,
+ 'private relay removal source identity does not match reviewed pin'
+ );
const scrollFile = path.join(root, 'src/lib/navigation-scroll.ts');
const scrollTrusted =
files.has(scrollFile) &&
@@ -2116,7 +2176,8 @@ export async function auditSource(root) {
file === scrollFile && scrollTrusted,
file === copyFile && copyTrusted,
file === visibilityFile && visibilityTrusted,
- file === reportFile && reportTrusted
+ file === reportFile && reportTrusted,
+ file === relayRemovalFile && relayRemovalTrusted
);
if (ast.referencedFiles.length || ast.typeReferenceDirectives.length)
complain(file, 'source reference directives are forbidden');