commit 3b445b6868e71abed555650dbd9e1e42979b3f56
parent ec97682146488facba77bbe8da94f16a8ac2b1b6
Author: triesap <tyson@radroots.org>
Date: Wed, 7 Oct 2026 05:33:24 +0000
messages: close private scopes on disconnect and suspension (HCP-060)
- Retain failed cleanup callbacks for explicit retry and block replacement sessions.
- Add terminal visibility and route disposal for genuine private scopes.
- Confine document visibility access to the reviewed disposal source.
- Verify actual SDK socket cleanup, public continuity and snapshot compatibility.
Diffstat:
6 files changed, 686 insertions(+), 19 deletions(-)
diff --git a/web/src/lib/runtime/dispose.ts b/web/src/lib/runtime/dispose.ts
@@ -0,0 +1,96 @@
+import {
+ privateSessionOwnership,
+ privateSessionCleanupRequired,
+ subscribePrivateSessionClose,
+ closePrivateSession,
+ type PrivateSession
+} from './private-session.ts';
+declare const visibilityBrand: unique symbol;
+export type PrivateVisibilityScope = Readonly<{ [visibilityBrand]: true }>;
+type Snapshot = Readonly<{ active: boolean; cleanupRequired: boolean }>;
+type Controller = { snapshot(): Snapshot; close(): boolean };
+const scopes = new WeakMap<PrivateVisibilityScope, Controller>();
+const sessions = new WeakMap<PrivateSession, PrivateVisibilityScope>();
+
+// Explicit internal Messages lifetime; no automatic unlock, fetch, decrypt,
+// provider request or hidden notification. Later Messages activation owns the
+// call and route disposal. Visibility returning does not revive a closed scope.
+export function getPrivateVisibilityScope(
+ session: PrivateSession
+): PrivateVisibilityScope | undefined {
+ if (typeof window === 'undefined' || typeof document === 'undefined')
+ return undefined;
+ const observed = privateSessionOwnership(session);
+ if (!observed) throw new Error('private_session_invalid');
+ const capture = observed;
+ const prior = sessions.get(session);
+ if (prior) return prior;
+ const token = Object.freeze({}) as PrivateVisibilityScope;
+ let closed = false,
+ registered = false;
+ let off = () => {};
+ function cleanupVisibility() {
+ closed = true;
+ if (registered) {
+ document.removeEventListener('visibilitychange', onVisibility);
+ registered = false;
+ }
+ off();
+ }
+ function close() {
+ // Session closure drains all caches and sockets even if one cleanup fails.
+ const cleaned = closePrivateSession(session);
+ try {
+ cleanupVisibility();
+ } catch {
+ return false;
+ }
+ if (!cleaned) return false;
+ scopes.set(token, {
+ snapshot: () => ({ active: false, cleanupRequired: false }),
+ close: () => true
+ });
+ return true;
+ }
+ function onVisibility() {
+ if (document.visibilityState !== 'visible') close();
+ }
+ scopes.set(token, {
+ snapshot: () => ({
+ active:
+ !closed && capture.current() && document.visibilityState === 'visible',
+ cleanupRequired:
+ closed && (registered || privateSessionCleanupRequired(session))
+ }),
+ close
+ });
+ sessions.set(session, token);
+ off = subscribePrivateSessionClose(session, cleanupVisibility);
+ if (!closed && capture.current() && document.visibilityState === 'visible') {
+ // Own the registration before its synchronous host call can reenter.
+ registered = true;
+ try {
+ document.addEventListener('visibilitychange', onVisibility);
+ } catch {
+ close();
+ throw new Error('private_visibility_unavailable');
+ }
+ }
+ if (!capture.current() || document.visibilityState !== 'visible') close();
+ return token;
+}
+function controller(token: PrivateVisibilityScope): Controller {
+ const state = scopes.get(token);
+ if (!state) throw new Error('private_visibility_invalid');
+ return state;
+}
+export function privateVisibilitySnapshot(
+ token: PrivateVisibilityScope
+): Snapshot {
+ return controller(token).snapshot();
+}
+export function closePrivateVisibilityScope(
+ token: PrivateVisibilityScope
+): boolean {
+ return controller(token).close();
+}
diff --git a/web/src/lib/runtime/private-session.ts b/web/src/lib/runtime/private-session.ts
@@ -11,7 +11,8 @@ type Controller = {
identity: IdentitySession;
capture: PublicEffectCapture;
current(): boolean;
- close(): void;
+ close(): boolean;
+ cleanupRequired(): boolean;
subscribe(listener: () => void): () => void;
};
const sessions = new WeakMap<PrivateSession, Controller>();
@@ -25,6 +26,11 @@ export async function createPrivateSession(
): Promise<PrivateSession | undefined> {
if (typeof window === 'undefined' || review !== 'reviewed_private_session')
return undefined;
+ // Retire unresolved old resources before any new provider observation. A new
+ // author/generation cannot replace failed authenticated socket ownership.
+ const previous = currentSessions.get(identity);
+ const prior = previous && sessions.get(previous);
+ if (prior && !prior.current() && !prior.close()) return undefined;
const before = identityMessagingOwnership(identity);
if (!before) return undefined;
const checked = await recheckIdentityOwner(identity);
@@ -40,37 +46,43 @@ export async function createPrivateSession(
return undefined;
const existing = currentSessions.get(identity);
if (existing && sessions.get(existing)?.current()) return existing;
+ if (existing && !sessions.get(existing)?.close()) return undefined;
const token = Object.freeze({}) as PrivateSession;
const listeners = new Map<symbol, () => void>();
let closed = false;
+ let closing = false;
let unsubscribe = () => {};
const current = () => !closed && capture.current();
function close() {
- if (closed) return;
closed = true;
- unsubscribe();
- for (const listener of listeners.values()) {
- try {
- listener();
- } catch {
- /* Pool retains failed cleanup until retry. */
+ if (closing) return false;
+ closing = true;
+ try {
+ unsubscribe();
+ for (const [id, listener] of listeners) {
+ try {
+ listener();
+ listeners.delete(id);
+ } catch {
+ // Keep only failed cleanup registrations for an actual retry. Drain
+ // other resources now; passive invalidation never leaks exceptions.
+ }
}
+ } finally {
+ closing = false;
}
- listeners.clear();
+ return listeners.size === 0;
}
sessions.set(token, {
identity,
capture,
current,
close,
+ cleanupRequired: () => closed && listeners.size !== 0,
subscribe(listener) {
- if (!current()) {
- close();
- listener();
- return () => {};
- }
const id = Symbol();
listeners.set(id, listener);
+ if (!current()) close();
return () => {
listeners.delete(id);
};
@@ -105,7 +117,15 @@ export function privateSessionSnapshot(
token: PrivateSession
): Readonly<{ owner: string; current: boolean }> | undefined {
const state = sessions.get(token);
- return state && { owner: state.capture.owner, current: state.current() };
+ return (
+ state && {
+ owner: state.capture.owner,
+ current: state.current()
+ }
+ );
+}
+export function privateSessionCleanupRequired(token: PrivateSession): boolean {
+ return sessions.get(token)?.cleanupRequired() ?? false;
}
export function subscribePrivateSessionClose(
token: PrivateSession,
@@ -115,8 +135,8 @@ export function subscribePrivateSessionClose(
if (!state) throw new Error('private_session_invalid');
return state.subscribe(listener);
}
-export function closePrivateSession(token: PrivateSession): void {
- sessions.get(token)?.close();
+export function closePrivateSession(token: PrivateSession): boolean {
+ return sessions.get(token)?.close() ?? false;
}
// Every new finite network action gets a fresh SDK owner observation; neither
// a remembered key nor a still-current presentation snapshot substitutes.
diff --git a/web/tests/integration/private-dispose.test.ts b/web/tests/integration/private-dispose.test.ts
@@ -0,0 +1,455 @@
+import { test } from 'node:test';
+import assert from 'node:assert/strict';
+import { once } from 'node:events';
+import WebSocket, { WebSocketServer } from 'ws';
+import { RelayPool } from 'applesauce-relay/pool';
+import {
+ createIdentitySession,
+ connectIdentity,
+ probeIdentityMessaging,
+ disconnectIdentity,
+ recheckIdentityOwner
+} from '../../src/lib/runtime/identity-session.ts';
+import {
+ createPrivateSession,
+ closePrivateSession,
+ privateSessionSnapshot,
+ privateSessionCleanupRequired,
+ subscribePrivateSessionClose
+} from '../../src/lib/runtime/private-session.ts';
+import {
+ getPrivateVisibilityScope,
+ privateVisibilitySnapshot,
+ closePrivateVisibilityScope
+} from '../../src/lib/runtime/dispose.ts';
+import {
+ getPrivatePool,
+ subscribePrivatePage,
+ closePrivatePool
+} from '../../src/lib/nostr/private-pool.ts';
+import {
+ getPublicPool,
+ subscribePublicPool,
+ closePublicPool
+} from '../../src/lib/nostr/public-pool.ts';
+import {
+ getPrivateCacheScope,
+ retainPrivateCacheWire,
+ privateCacheWire,
+ privateCacheSnapshot
+} from '../../src/lib/nostr/private-cache-scope.ts';
+import {
+ getPrivateEnvelopeCapability,
+ privateEnvelopeConstructionOwnership
+} from '../../src/lib/nostr/private-envelope-capability.ts';
+import { validateRelayPolicy } from '../../src/lib/config/relays.ts';
+
+// HC_TEST_ONLY_PROVIDER/RELAY/DOCUMENT: actual SDK sockets on isolated loopback;
+// echo probe and controlled EventTarget qualify lifetime, not crypto/browser Q.
+await test('private disposal owns real SDK sockets, retryable cleanup and terminal visibility while public browsing continues', async (t) => {
+ const owner =
+ '79be667ef9dcbbac55a06295ce870b07029bfcdb2dce28d959f2815b16f81798';
+ const other =
+ 'c6047f9441ed7d6d3045406e95c07cd85c778e4b8cef3ca7abac09b95c709ee5';
+ const origin = 'wss://relay.example.org';
+ const policy = validateRelayPolicy(
+ JSON.stringify({
+ schemaVersion: 1,
+ public: [{ origin, read: true, write: false, nip50: false }],
+ inbox: [{ origin, read: true, write: true }],
+ postingEnabled: false,
+ messagingEnabled: true,
+ operatorDenylist: []
+ })
+ );
+ assert.ok(policy);
+ const server = new WebSocketServer({
+ host: '127.0.0.1',
+ port: 0,
+ maxPayload: 65536
+ });
+ const requests = new Map<WebSocket, { kind: number; id: string }>();
+ let privateReady = () => {};
+ server.on('connection', (socket) =>
+ socket.on('message', (bytes) => {
+ const buffer = Array.isArray(bytes)
+ ? Buffer.concat(bytes)
+ : Buffer.isBuffer(bytes)
+ ? bytes
+ : Buffer.from(bytes);
+ const frame: unknown = JSON.parse(buffer.toString('utf8'));
+ assert.ok(Array.isArray(frame));
+ if (frame[0] !== 'REQ') return;
+ const filter = frame[2] as { kinds: number[] };
+ requests.set(socket, { kind: filter.kinds[0], id: frame[1] as string });
+ if (filter.kinds[0] === 1059) privateReady();
+ else socket.send(JSON.stringify(['EOSE', frame[1]]));
+ })
+ );
+ await once(server, 'listening');
+ const address = server.address();
+ assert.ok(address && typeof address !== 'string');
+ const fixturePort = address.port;
+ const originalSocket = globalThis.WebSocket,
+ originalFetch = globalThis.fetch,
+ originalReq = Reflect.get<RelayPool, 'req'>(RelayPool.prototype, 'req'),
+ originalClose = Reflect.get<RelayPool, 'close'>(
+ RelayPool.prototype,
+ 'close'
+ );
+ const documentTarget = new EventTarget();
+ Object.defineProperty(documentTarget, 'visibilityState', {
+ configurable: true,
+ writable: true,
+ value: 'visible'
+ });
+ Object.defineProperty(globalThis, 'document', {
+ configurable: true,
+ value: documentTarget
+ });
+ let key = owner,
+ prompts = 0,
+ signatures = 0;
+ Object.defineProperty(globalThis, 'window', {
+ configurable: true,
+ value: {
+ nostr: {
+ getPublicKey: () => {
+ prompts++;
+ return Promise.resolve(key);
+ },
+ signEvent: () => {
+ signatures++;
+ return Promise.reject(new Error('HC_TEST_ONLY_UNEXPECTED_SIGN'));
+ },
+ nip44: {
+ encrypt: (_peer: string, text: string) =>
+ Promise.resolve('fixture:' + text),
+ decrypt: (_peer: string, text: string) =>
+ Promise.resolve(text.slice(8))
+ }
+ }
+ }
+ });
+ class FixtureSocket extends WebSocket {
+ constructor(url: string | URL) {
+ assert.equal(new URL(String(url)).origin, origin);
+ super(`ws://127.0.0.1:${fixturePort}`);
+ }
+ }
+ globalThis.WebSocket =
+ FixtureSocket as unknown as typeof globalThis.WebSocket;
+ globalThis.fetch = () =>
+ Promise.reject(new Error('HC_TEST_ONLY_UNEXPECTED_FETCH'));
+ const sdkScopes = new Map<'public' | 'private', RelayPool>();
+ RelayPool.prototype.req = function (relays, filters, options) {
+ assert.ok(Array.isArray(filters));
+ const filter = filters[0] as { kinds: number[] };
+ sdkScopes.set(filter.kinds[0] === 1059 ? 'private' : 'public', this);
+ return originalReq.call(this, relays, filters, options);
+ };
+ const identity = createIdentitySession();
+ let pool: ReturnType<typeof getPrivatePool>,
+ publicPool: ReturnType<typeof getPublicPool>;
+ const stops: Array<() => void> = [];
+ async function connect() {
+ assert.equal((await connectIdentity(identity)).state, 'signing_only');
+ assert.equal(
+ (await probeIdentityMessaging(identity, 'reviewed_self_copy')).state,
+ 'messaging_capable'
+ );
+ const session = await createPrivateSession(
+ identity,
+ 'reviewed_private_session'
+ );
+ assert.ok(session);
+ return session;
+ }
+ async function held(session: Awaited<ReturnType<typeof connect>>) {
+ pool = getPrivatePool(session, policy!, [origin]);
+ assert.ok(pool);
+ const ready = new Promise<void>((resolve) => {
+ privateReady = resolve;
+ });
+ stops.push(subscribePrivatePage(pool, 1, () => {}));
+ await ready;
+ return [...server.clients].filter((s) => requests.get(s)?.kind === 1059);
+ }
+ async function publicPage() {
+ assert.ok(publicPool);
+ await new Promise<void>((resolve) => {
+ stops.push(
+ subscribePublicPool(
+ publicPool!,
+ [{ kinds: [0], limit: 1 }],
+ (message) => {
+ if (message.type === 'EOSE') resolve();
+ }
+ )
+ );
+ });
+ }
+ function visible(value: 'visible' | 'hidden') {
+ Object.defineProperty(documentTarget, 'visibilityState', {
+ configurable: true,
+ writable: true,
+ value
+ });
+ documentTarget.dispatchEvent(new Event('visibilitychange'));
+ }
+ try {
+ await t.test(
+ 'guest and forged scopes allocate no sockets or provider prompts',
+ () => {
+ assert.throws(
+ () => getPrivateVisibilityScope({} as never),
+ /private_session_invalid/
+ );
+ assert.equal(prompts, 0);
+ assert.equal(server.clients.size, 0);
+ }
+ );
+ publicPool = getPublicPool(policy);
+ assert.ok(publicPool);
+ await publicPage();
+ const publicSdk = sdkScopes.get('public');
+ assert.ok(publicSdk);
+ let session = await connect();
+ await t.test(
+ 'hidden document closes actual private sockets, caches and permissions without affecting public SDK',
+ async () => {
+ const cache = getPrivateCacheScope(session, 'projection_ownership');
+ assert.ok(cache);
+ assert.equal(
+ retainPrivateCacheWire(
+ cache,
+ 'a'.repeat(64),
+ '"HC_TEST_ONLY_SYNTHETIC_OWNERSHIP"'
+ ),
+ 'accepted'
+ );
+ const capability = getPrivateEnvelopeCapability(session);
+ assert.ok(capability);
+ const scope = getPrivateVisibilityScope(session);
+ assert.ok(scope);
+ assert.equal(privateVisibilitySnapshot(scope).active, true);
+ const sockets = await held(session),
+ closed = sockets.map((s) => once(s, 'close'));
+ assert.equal(sockets.length, 1);
+ const late = () =>
+ retainPrivateCacheWire(
+ cache,
+ 'b'.repeat(64),
+ '"HC_TEST_ONLY_LATE_OWNERSHIP"'
+ );
+ visible('hidden');
+ await Promise.all(closed);
+ assert.deepEqual(privateVisibilitySnapshot(scope), {
+ active: false,
+ cleanupRequired: false
+ });
+ assert.equal(privateSessionSnapshot(session)?.current, false);
+ assert.equal(privateCacheWire(cache, 'a'.repeat(64)), undefined);
+ assert.equal(privateCacheSnapshot(cache).count, 0);
+ assert.equal(late(), 'closed');
+ assert.equal(
+ privateEnvelopeConstructionOwnership(capability),
+ undefined
+ );
+ const before = prompts;
+ visible('visible');
+ assert.equal(prompts, before);
+ assert.equal(privateVisibilitySnapshot(scope).active, false);
+ await publicPage();
+ assert.equal(sdkScopes.get('public'), publicSdk);
+ }
+ );
+ session = await connect();
+ await t.test(
+ 'failed physical SDK close is retained, drains other resources and blocks replacement before provider prompts',
+ async () => {
+ const cache = getPrivateCacheScope(session, 'projection_ownership');
+ assert.ok(cache);
+ retainPrivateCacheWire(
+ cache,
+ 'c'.repeat(64),
+ '"HC_TEST_ONLY_SYNTHETIC_OWNERSHIP"'
+ );
+ const sockets = await held(session);
+ const sdk = sdkScopes.get('private');
+ assert.ok(sdk);
+ let closeCalls = 0;
+ RelayPool.prototype.close = function () {
+ if (this === sdk) {
+ closeCalls++;
+ throw new Error('HC_TEST_ONLY_CLOSE_FAILURE');
+ }
+ return originalClose.call(this);
+ };
+ disconnectIdentity(identity);
+ assert.equal(privateSessionSnapshot(session)?.current, false);
+ assert.equal(privateSessionCleanupRequired(session), true);
+ assert.equal(privateCacheSnapshot(cache).count, 0);
+ assert.equal(closePrivateSession(session), false);
+ assert.ok(closeCalls >= 2);
+ assert.equal((await connectIdentity(identity)).state, 'signing_only');
+ assert.equal(
+ (await probeIdentityMessaging(identity, 'reviewed_self_copy')).state,
+ 'messaging_capable'
+ );
+ const before = prompts;
+ assert.equal(
+ await createPrivateSession(identity, 'reviewed_private_session'),
+ undefined
+ );
+ assert.equal(prompts, before);
+ await publicPage();
+ assert.equal(sdkScopes.get('public'), publicSdk);
+ const closed = sockets.map((s) => once(s, 'close'));
+ RelayPool.prototype.close = originalClose;
+ assert.equal(closePrivateSession(session), true);
+ await Promise.all(closed);
+ assert.equal(privateSessionCleanupRequired(session), false);
+ const next = await createPrivateSession(
+ identity,
+ 'reviewed_private_session'
+ );
+ assert.ok(next);
+ assert.notEqual(next, session);
+ session = next;
+ }
+ );
+ await t.test(
+ 'successful callbacks drain once and failed registrations retry without reviving authority',
+ () => {
+ let failed = 0,
+ success = 0;
+ subscribePrivateSessionClose(session, () => {
+ failed++;
+ if (failed === 1) throw new Error('HC_TEST_ONLY_CALLBACK_FAILURE');
+ });
+ subscribePrivateSessionClose(session, () => {
+ success++;
+ });
+ assert.equal(closePrivateSession(session), false);
+ assert.equal(success, 1);
+ assert.equal(failed, 1);
+ assert.equal(closePrivateSession(session), true);
+ assert.equal(success, 1);
+ assert.equal(failed, 2);
+ }
+ );
+ session = await connect();
+ await t.test(
+ 'explicit route disposal and observed account loss close actual scopes with no hidden restart',
+ async () => {
+ const scope = getPrivateVisibilityScope(session);
+ assert.ok(scope);
+ const sockets = await held(session);
+ const closed = sockets.map((s) => once(s, 'close'));
+ assert.equal(closePrivateVisibilityScope(scope), true);
+ await Promise.all(closed);
+ assert.equal(privateVisibilitySnapshot(scope).active, false);
+ visible('hidden');
+ visible('visible');
+ assert.equal(privateVisibilitySnapshot(scope).active, false);
+ await publicPage();
+ session = await connect();
+ const replacement = getPrivateVisibilityScope(session);
+ assert.ok(replacement);
+ const nextSockets = await held(session),
+ nextClosed = nextSockets.map((s) => once(s, 'close'));
+ key = other;
+ assert.equal((await recheckIdentityOwner(identity)).state, 'guest');
+ await Promise.all(nextClosed);
+ assert.equal(privateVisibilitySnapshot(replacement).active, false);
+ await publicPage();
+ assert.equal(signatures, 0);
+ }
+ );
+ await t.test(
+ 'initially hidden visibility admission suspends without provider or socket effects',
+ async () => {
+ session = await connect();
+ visible('hidden');
+ const before = prompts;
+ const socketCount = server.clients.size;
+ const scope = getPrivateVisibilityScope(session);
+ assert.ok(scope);
+ assert.deepEqual(privateVisibilitySnapshot(scope), {
+ active: false,
+ cleanupRequired: false
+ });
+ assert.equal(prompts, before);
+ assert.equal(server.clients.size, socketCount);
+ visible('visible');
+ assert.equal(privateVisibilitySnapshot(scope).active, false);
+ await publicPage();
+ }
+ );
+ await t.test(
+ 'failed visibility listener removal stays terminal and blocks new admission until actual retry',
+ async () => {
+ session = await connect();
+ const scope = getPrivateVisibilityScope(session);
+ assert.ok(scope);
+ const remove = Reflect.get<EventTarget, 'removeEventListener'>(
+ EventTarget.prototype,
+ 'removeEventListener'
+ );
+ Object.defineProperty(documentTarget, 'removeEventListener', {
+ configurable: true,
+ value: () => {
+ throw new Error('HC_TEST_ONLY_LISTENER_REMOVAL_FAILURE');
+ }
+ });
+ try {
+ assert.equal(closePrivateVisibilityScope(scope), false);
+ assert.deepEqual(privateVisibilitySnapshot(scope), {
+ active: false,
+ cleanupRequired: true
+ });
+ const before = prompts;
+ assert.equal(
+ await createPrivateSession(identity, 'reviewed_private_session'),
+ undefined
+ );
+ assert.equal(prompts, before);
+ await publicPage();
+ } finally {
+ Object.defineProperty(documentTarget, 'removeEventListener', {
+ configurable: true,
+ value: remove
+ });
+ }
+ assert.equal(closePrivateVisibilityScope(scope), true);
+ assert.deepEqual(privateVisibilitySnapshot(scope), {
+ active: false,
+ cleanupRequired: false
+ });
+ const next = await createPrivateSession(
+ identity,
+ 'reviewed_private_session'
+ );
+ assert.ok(next);
+ assert.notEqual(next, session);
+ session = next;
+ }
+ );
+ } finally {
+ RelayPool.prototype.close = originalClose;
+ disconnectIdentity(identity);
+ if (pool) closePrivatePool(pool);
+ for (const stop of stops) stop();
+ if (publicPool) closePublicPool(publicPool);
+ RelayPool.prototype.req = originalReq;
+ globalThis.WebSocket = originalSocket;
+ globalThis.fetch = originalFetch;
+ Reflect.deleteProperty(globalThis, 'window');
+ Reflect.deleteProperty(globalThis, 'document');
+ for (const socket of server.clients) socket.terminate();
+ await new Promise<void>((resolve, reject) =>
+ server.close((error) => (error ? reject(error) : resolve()))
+ );
+ }
+});
diff --git a/web/tests/provenance/source-boundaries.test.mjs b/web/tests/provenance/source-boundaries.test.mjs
@@ -16,6 +16,44 @@ import path from 'node:path';
import { fileURLToPath } from 'node:url';
import { test } from 'node:test';
+test('HCP060 document visibility access is confined to the exact disposal producer', async () => {
+ await fixture(async ({ directory, put, execute }) => {
+ await confineSvelte(directory);
+ const helper = await readFile(
+ path.join(root, 'src/lib/runtime/dispose.ts'),
+ 'utf8'
+ );
+ // Source grammar fixture only, not product session or lifecycle qualification.
+ await put(
+ 'src/lib/runtime/private-session.ts',
+ 'export type PrivateSession = {}; export function privateSessionOwnership(){return undefined;} export function subscribePrivateSessionClose(){return ()=>{};} export function closePrivateSession(){return true;} export function privateSessionCleanupRequired(){return false;}'
+ );
+ await put('src/lib/runtime/dispose.ts', helper);
+ assert.equal(execute().status, 0);
+ for (const code of [
+ 'export const value=document.visibilityState;',
+ 'document.addEventListener("visibilitychange",()=>{});',
+ 'document.removeEventListener("visibilitychange",()=>{});',
+ 'const owner=document;owner.addEventListener("visibilitychange",()=>{});',
+ 'const observe=document.addEventListener;observe("visibilitychange",()=>{});',
+ 'document["addEventListener"]("visibilitychange",()=>{});',
+ 'window.document.addEventListener("visibilitychange",()=>{});'
+ ]) {
+ await put('src/routes/+page.ts', code);
+ assert.notEqual(execute().status, 0, code);
+ }
+ await put('src/routes/+page.ts', 'export const value=1;');
+ await put(
+ 'src/lib/runtime/dispose.ts',
+ helper + '\n document.addEventListener("click",()=>{});'
+ );
+ assert.notEqual(execute().status, 0);
+ await put('src/lib/runtime/dispose.ts', helper);
+ await put('src/lib/runtime/copied-dispose.ts', helper);
+ assert.notEqual(execute().status, 0);
+ });
+});
+
test('HCP044 clipboard access is confined to the exact public copy producer', async () => {
await fixture(async ({ directory, put, execute }) => {
await confineSvelte(directory);
diff --git a/web/tests/unit/private-dispose.test.ts b/web/tests/unit/private-dispose.test.ts
@@ -0,0 +1,17 @@
+import { expect, it } from 'vitest';
+import {
+ getPrivateVisibilityScope,
+ privateVisibilitySnapshot,
+ closePrivateVisibilityScope
+} from '../../src/lib/runtime/dispose.ts';
+it('SSR visibility scope acquisition is inert without a browser or provider', () => {
+ expect(getPrivateVisibilityScope({} as never)).toBeUndefined();
+});
+it('forged visibility handles have no lifecycle authority', () => {
+ expect(() => privateVisibilitySnapshot({} as never)).toThrow(
+ 'private_visibility_invalid'
+ );
+ expect(() => closePrivateVisibilityScope({} as never)).toThrow(
+ 'private_visibility_invalid'
+ );
+});
diff --git a/web/tools/source-boundaries.mjs b/web/tools/source-boundaries.mjs
@@ -118,7 +118,8 @@ function mutationAdmission(
report,
identity = () => null,
reviewedScroll = false,
- reviewedCopy = false
+ reviewedCopy = false,
+ reviewedVisibility = false
) {
// Bind this admitted AST only, without libs, module resolution, file reads,
// config loading or evaluation. Symbols distinguish aliases and shadowing.
@@ -170,6 +171,35 @@ function mutationAdmission(
top.parent.expression === top
)
top = top.parent;
+ // Only the byte-pinned private disposal owner observes scalar visibility
+ // and owns this one fixed event registration. No document handle escapes.
+ if (reviewedVisibility) {
+ const receiver = ts.isCallExpression(top) ? top.expression : top;
+ if (
+ ts.isPropertyAccessExpression(receiver) &&
+ ts.isIdentifier(receiver.expression) &&
+ receiver.expression.text === 'document' &&
+ !checker.getSymbolAtLocation(receiver.expression)
+ ) {
+ if (
+ !ts.isCallExpression(top) &&
+ receiver.name.text === 'visibilityState'
+ )
+ return true;
+ if (
+ ts.isCallExpression(top) &&
+ ['addEventListener', 'removeEventListener'].includes(
+ receiver.name.text
+ ) &&
+ top.arguments.length === 2 &&
+ ts.isStringLiteralLike(top.arguments[0]) &&
+ top.arguments[0].text === 'visibilitychange' &&
+ ts.isIdentifier(top.arguments[1]) &&
+ top.arguments[1].text === 'onVisibility'
+ )
+ return true;
+ }
+ }
const action =
ts.isCallExpression(top) &&
['focus', 'blur', 'scrollIntoView'].includes(member(top.expression)) &&
@@ -1517,6 +1547,16 @@ export async function auditSource(root) {
complain(file, `unresolved production import ${specifier}`);
}
}
+ const visibilityFile = path.join(root, 'src/lib/runtime/dispose.ts');
+ const visibilityTrusted =
+ files.has(visibilityFile) &&
+ createHash('sha256').update(files.get(visibilityFile)).digest('hex') ===
+ 'f236ad457215aff0ace7bdf4cd9d7c1b7ffefa8a49d2d3821f8ca6a79b4bec97';
+ if (files.has(visibilityFile) && !visibilityTrusted)
+ complain(
+ visibilityFile,
+ 'visibility disposal source identity does not match reviewed pin'
+ );
const copyFile = path.join(root, 'src/lib/navigation-copy.ts');
const copyTrusted =
files.has(copyFile) &&
@@ -2031,7 +2071,8 @@ export async function auditSource(root) {
: exportIdentity(target, exported);
},
file === scrollFile && scrollTrusted,
- file === copyFile && copyTrusted
+ file === copyFile && copyTrusted,
+ file === visibilityFile && visibilityTrusted
);
if (ast.referencedFiles.length || ast.typeReferenceDirectives.length)
complain(file, 'source reference directives are forbidden');