app

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

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:
Aweb/src/lib/runtime/dispose.ts | 96+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Mweb/src/lib/runtime/private-session.ts | 54+++++++++++++++++++++++++++++++++++++-----------------
Aweb/tests/integration/private-dispose.test.ts | 455+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Mweb/tests/provenance/source-boundaries.test.mjs | 38++++++++++++++++++++++++++++++++++++++
Aweb/tests/unit/private-dispose.test.ts | 17+++++++++++++++++
Mweb/tools/source-boundaries.mjs | 45+++++++++++++++++++++++++++++++++++++++++++--
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');