app

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

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 }