private-envelope-capability.ts (3192B)
1 import type { EventTemplate } from 'applesauce-core/helpers/event'; 2 import { 3 privateSessionOwnership, 4 subscribePrivateSessionClose, 5 type PrivateSession 6 } from '../runtime/private-session.ts'; 7 import type { PublicEffectCapture } from '../runtime/effect-ownership.ts'; 8 9 // Internal construction shape only, not a validated seal/recipient plan. Later 10 // preparation must establish the peer or self-copy target and authentic seal. 11 export type PrivateOuterTemplate = Readonly<{ 12 kind: 1059; 13 tags: readonly [readonly ['p', string]]; 14 content: EventTemplate['content']; 15 created_at: EventTemplate['created_at']; 16 }>; 17 declare const envelopeBrand: unique symbol; 18 export type PrivateEnvelopeCapability = Readonly<{ 19 [envelopeBrand]: PrivateOuterTemplate; 20 }>; 21 type ConstructionOwnership = Readonly<PublicEffectCapture & { kind: 1059 }>; 22 type Controller = { 23 ownership(): ConstructionOwnership | undefined; 24 close(): void; 25 }; 26 const capabilities = new WeakMap<PrivateEnvelopeCapability, Controller>(); 27 const sessions = new WeakMap<PrivateSession, PrivateEnvelopeCapability>(); 28 29 // Executable initial permission boundary, deliberately unused by product sends 30 // until HCM015. No signer is created, passed in or exposed, and no identity key 31 // or raw key API exists. Later Applesauce disposable-key use stays wholly inside 32 // the outer construction adapter; this token cannot sign a listing or decrypt. 33 export function getPrivateEnvelopeCapability( 34 session: PrivateSession 35 ): PrivateEnvelopeCapability | undefined { 36 if (typeof window === 'undefined') return undefined; 37 const observed = privateSessionOwnership(session); 38 if (!observed) throw new Error('private_session_invalid'); 39 const capture = observed; 40 const prior = sessions.get(session); 41 if (prior) { 42 if (!controller(prior).ownership()) 43 throw new Error('private_envelope_capability_closed'); 44 return prior; 45 } 46 const token = Object.freeze({}) as PrivateEnvelopeCapability; 47 let closed = false; 48 let off = () => {}; 49 function close() { 50 if (closed) return; 51 closed = true; 52 off(); 53 capabilities.set(token, { 54 ownership: () => undefined, 55 close: () => {} 56 }); 57 } 58 function current() { 59 if (closed || !capture.current()) { 60 close(); 61 return false; 62 } 63 return true; 64 } 65 capabilities.set(token, { 66 ownership: () => 67 current() 68 ? { 69 kind: 1059, 70 owner: capture.owner, 71 session: capture.session, 72 current 73 } 74 : undefined, 75 close 76 }); 77 off = subscribePrivateSessionClose(session, close); 78 if (!current()) { 79 close(); 80 return undefined; 81 } 82 sessions.set(session, token); 83 return token; 84 } 85 function controller(token: PrivateEnvelopeCapability): Controller { 86 const state = capabilities.get(token); 87 if (!state) throw new Error('private_envelope_capability_invalid'); 88 return state; 89 } 90 export function privateEnvelopeConstructionOwnership( 91 token: PrivateEnvelopeCapability 92 ): ConstructionOwnership | undefined { 93 return controller(token).ownership(); 94 } 95 export function closePrivateEnvelopeCapability( 96 token: PrivateEnvelopeCapability 97 ): void { 98 controller(token).close(); 99 }