app

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

reply-composer.ts (15718B)


      1 import { mount, unmount } from 'svelte';
      2 import type { beforeNavigate as KitBeforeNavigate } from '$app/navigation';
      3 type BeforeNavigate = Parameters<Parameters<typeof KitBeforeNavigate>[0]>[0];
      4 import {
      5   finalizeEvent,
      6   type UnsignedEvent,
      7   type NostrEvent
      8 } from 'applesauce-core/helpers';
      9 import { renderFixture as renderThread } from './conversation-thread.ts';
     10 import Panel from './reply-composer-panel.svelte';
     11 import {
     12   createReplyController,
     13   createRuntimeReplyController,
     14   replySnapshot,
     15   replyText,
     16   updateReplyText,
     17   sendReply,
     18   closeReplyController,
     19   requestReplyNavigation,
     20   keepReplyEditing,
     21   discardReplyNavigation,
     22   selectReplyParent
     23 } from '../../../src/lib/messaging/reply-controller.ts';
     24 import {
     25   inboxListSnapshot,
     26   inboxReplyOwnership
     27 } from '../../../src/lib/messaging/inbox-view.ts';
     28 import {
     29   captureAuthenticatedReplyRumor,
     30   rumorPlanSnapshot,
     31   stopRumorPlan
     32 } from '../../../src/lib/messaging/rumor-plan.ts';
     33 import {
     34   createIdentitySession,
     35   connectIdentity,
     36   probeIdentityMessaging,
     37   disconnectIdentity
     38 } from '../../../src/lib/runtime/identity-session.ts';
     39 import {
     40   inboxSetupViewOwnership,
     41   inboxSetupViewSnapshot
     42 } from '../../../src/lib/messaging/inbox-setup-view.ts';
     43 import { createInboxResolver } from '../../../src/lib/messaging/resolve-inbox.ts';
     44 import { browserDatabaseTransaction } from '../../../src/lib/persistence/database.ts';
     45 import {
     46   createPublicScheduler,
     47   createPublicRun,
     48   openInboxRequest,
     49   closePublicScheduler,
     50   type RequestClock
     51 } from '../../../src/lib/nostr/request-scope.ts';
     52 import {
     53   createPublicRuntimeContext,
     54   mountPublicRuntime,
     55   closePublicRuntime
     56 } from '../../../src/lib/runtime/public-runtime.ts';
     57 
     58 const navigation: ((event: BeforeNavigate) => void)[] = [];
     59 let destinations = Array.from<string>([]);
     60 export function beforeNavigate(callback: (event: BeforeNavigate) => void) {
     61   navigation.push(callback);
     62 }
     63 export function goto(destination: string | URL) {
     64   destinations = destinations.concat(String(destination));
     65   return Promise.resolve();
     66 }
     67 export async function renderReplyFixture(qualified = true, production = false) {
     68   navigation.length = 0;
     69   destinations = [];
     70   const manager = navigator.locks;
     71   const originalDescriptor = Object.getOwnPropertyDescriptor(
     72     manager,
     73     'request'
     74   );
     75   const originalRequest = Reflect.get(manager, 'request');
     76   let crossOwnerSecond: string | undefined;
     77   let nativeTransactions: {
     78     stores: string[];
     79     outcome: 'abort' | 'complete';
     80   }[] = [];
     81   let restoreTransaction = () => {};
     82   let commandIds: string[] = [];
     83   let lockAttempts: { name: string; ifAvailable: boolean; granted: boolean }[] =
     84     [];
     85   const observedRequest = ((...args: unknown[]) => {
     86     const callbackIndex = args.length - 1;
     87     const callback = args[callbackIndex] as (lock: Lock | null) => unknown;
     88     const options = args.length === 3 ? (args[1] as LockOptions) : undefined;
     89     const forwarded = args.slice();
     90     forwarded[callbackIndex] = (lock: Lock | null) => {
     91       lockAttempts = lockAttempts.concat({
     92         name: String(args[0]),
     93         ifAvailable: options?.ifAvailable === true,
     94         granted: lock !== null
     95       });
     96       if (lock && options?.ifAvailable && args[0] === crossOwnerSecond) {
     97         crossOwnerSecond = undefined;
     98         const capturedSecond = Math.floor(clockSamples.at(-1)!.value / 1000);
     99         return (async () => {
    100           await new Promise<void>((resolve) => {
    101             function forwardAfterBoundary() {
    102               if (Math.floor(originalNow() / 1000) === capturedSecond) {
    103                 window.setTimeout(forwardAfterBoundary, 1);
    104                 return;
    105               }
    106               resolve();
    107             }
    108             window.setTimeout(
    109               forwardAfterBoundary,
    110               Math.max(1, (capturedSecond + 1) * 1000 - originalNow() + 1)
    111             );
    112           });
    113           return callback(lock);
    114         })();
    115       }
    116       return callback(lock);
    117     };
    118     return Reflect.apply(
    119       originalRequest,
    120       manager,
    121       forwarded
    122     ) as Promise<unknown>;
    123   }) as typeof manager.request;
    124   manager.request = observedRequest;
    125   const originalNowDescriptor = Object.getOwnPropertyDescriptor(Date, 'now');
    126   const originalNow = Reflect.get(Date, 'now');
    127   let clockSamples: { value: number; stack: string | undefined }[] = [];
    128   const observedNow = () => {
    129     const value = originalNow();
    130     clockSamples = clockSamples.concat({
    131       value,
    132       stack: new Error().stack?.split('\n').slice(1, 5).join('\n')
    133     });
    134     return value;
    135   };
    136   Date.now = observedNow;
    137   function restoreSendClock() {
    138     crossOwnerSecond = undefined;
    139     restoreTransaction();
    140     restoreTransaction = () => {};
    141     if (Date.now === observedNow && originalNowDescriptor)
    142       Object.defineProperty(Date, 'now', originalNowDescriptor);
    143   }
    144 
    145   let clockOffset = 0,
    146     alive = true;
    147   let nextTimer = 0;
    148   const timers = new Map<number, { at: number; callback: () => void }>();
    149   const ownSchedulers: ReturnType<typeof createPublicScheduler>[] = [];
    150   const clock: RequestClock = {
    151     now: () => clockOffset,
    152     schedule(callback, delay) {
    153       const id = ++nextTimer;
    154       timers.set(id, { at: clockOffset + delay, callback });
    155       return () => timers.delete(id);
    156     }
    157   };
    158   function advanceClock() {
    159     const target = clockOffset + 15_001;
    160     for (;;) {
    161       const next = [...timers]
    162         .filter(([, timer]) => timer.at <= target)
    163         .sort((a, b) => a[1].at - b[1].at || a[0] - b[0])[0];
    164       if (!next) break;
    165       const [id, timer] = next;
    166       timers.delete(id);
    167       clockOffset = timer.at;
    168       timer.callback();
    169     }
    170     clockOffset = target;
    171   }
    172   const freshOwn: NonNullable<Parameters<typeof renderThread>[3]> = (
    173     owner,
    174     policy
    175   ) => {
    176     const event = finalizeEvent(
    177       {
    178         kind: 10050,
    179         created_at: 100,
    180         tags: [['relay', 'wss://archive.example.org']],
    181         content: ''
    182       },
    183       new Uint8Array(32).fill(83)
    184     );
    185     if (event.pubkey !== owner) throw Error('wrong genuine owner');
    186     const scheduler = createPublicScheduler({
    187       now: () => 0,
    188       schedule: () => () => {}
    189     });
    190     ownSchedulers.push(scheduler);
    191     const run = createPublicRun(scheduler, policy);
    192     return Promise.resolve(
    193       createInboxResolver(
    194         run,
    195         owner,
    196         (next) =>
    197           openInboxRequest(
    198             run,
    199             owner,
    200             (sink) => {
    201               sink({
    202                 type: 'EVENT',
    203                 from: 'wss://discovery.example.org',
    204                 id: 'fixture',
    205                 event
    206               });
    207               sink({
    208                 type: 'EOSE',
    209                 from: 'wss://discovery.example.org',
    210                 id: 'fixture'
    211               });
    212               return () => {};
    213             },
    214             next
    215           ),
    216         () => alive
    217       )
    218     );
    219   };
    220   const thread = await renderThread(
    221     'inbound',
    222     undefined,
    223     qualified,
    224     production ? freshOwn : undefined
    225   );
    226   await thread.checkSetup();
    227   if (!(await thread.unlock())) throw Error('no genuine unlocked thread');
    228   let gate = false,
    229     lookups = 0;
    230   const scope = inboxReplyOwnership(
    231     thread.controller,
    232     thread.conversationId,
    233     thread.firstRumor
    234   );
    235   const setup = scope && inboxSetupViewOwnership(scope.setup);
    236   const publicContext = production ? createPublicRuntimeContext() : undefined;
    237   const runtime =
    238     publicContext &&
    239     setup &&
    240     mountPublicRuntime(publicContext, setup.policy, clock);
    241   if (production && !runtime) throw Error('no genuine public runtime');
    242   const candidate = runtime
    243     ? createRuntimeReplyController(
    244         thread.controller,
    245         thread.conversationId,
    246         thread.firstRumor,
    247         runtime
    248       )
    249     : createReplyController(
    250         thread.controller,
    251         thread.conversationId,
    252         thread.firstRumor,
    253         {
    254           lookupPeer: (peer) => {
    255             lookups++;
    256             if (gate) throw Error('controlled same-page setup cancellation');
    257             return Promise.resolve(thread.replyLookup(peer));
    258           }
    259         }
    260       );
    261   if (!candidate) throw Error('no original reply controller');
    262   const controller = candidate;
    263   const target = document.createElement('div');
    264   document.body.append(target);
    265   let clicks = 0;
    266   target.addEventListener(
    267     'click',
    268     () => {
    269       clicks++;
    270     },
    271     { capture: true }
    272   );
    273   const mounted = mount(Panel, { target, props: { controller } });
    274   let unmounted = false,
    275     held = false,
    276     release: (() => void) | undefined;
    277   const provider = window.nostr as
    278     { signEvent(event: UnsignedEvent): Promise<NostrEvent> } | undefined;
    279   if (!provider) throw Error('no actual fixture provider');
    280   const nativeSign = provider.signEvent.bind(provider);
    281   provider.signEvent = (event: UnsignedEvent) =>
    282     held
    283       ? new Promise<NostrEvent>((resolve, reject) => {
    284           release = () => {
    285             held = false;
    286             nativeSign(event).then(resolve, reject);
    287           };
    288         })
    289       : nativeSign(event);
    290   async function closeComposer() {
    291     if (unmounted) return;
    292     unmounted = true;
    293     await unmount(mounted);
    294     closeReplyController(controller);
    295     target.remove();
    296   }
    297   return {
    298     owner: thread.owner,
    299     peer: thread.peer,
    300     parent: thread.firstRumor,
    301     conversationId: thread.conversationId,
    302     snapshot: () => replySnapshot(controller),
    303     diagnostic: async () => ({
    304       setup: inboxSetupViewSnapshot(scope?.setup),
    305       locks: await navigator.locks.query(),
    306       lockAttempts: lockAttempts.slice(),
    307       clicks,
    308       clockSamples: clockSamples.slice(),
    309       nativeTransactions: nativeTransactions.slice(),
    310       commandIds: commandIds.slice()
    311     }),
    312     resetDiagnostics: () => {
    313       lockAttempts = [];
    314       clicks = 0;
    315       clockSamples = [];
    316       nativeTransactions = [];
    317       commandIds = [];
    318     },
    319     configureSendClock(crossSecond: boolean) {
    320       if (!scope) throw Error('no original reply scope');
    321       crossOwnerSecond = crossSecond
    322         ? 'harvestcircle:owner:' + scope.owner
    323         : undefined;
    324       Date.now = observedNow;
    325       const db = browserDatabaseTransaction(
    326         scope.database,
    327         ['private_sends'],
    328         'readonly'
    329       ).db;
    330       const descriptor = Object.getOwnPropertyDescriptor(db, 'transaction');
    331       const original = Reflect.get(db, 'transaction');
    332       const uuidDescriptor = Object.getOwnPropertyDescriptor(
    333         crypto,
    334         'randomUUID'
    335       );
    336       const originalUuid = Reflect.get(crypto, 'randomUUID');
    337       const observedUuid = () => {
    338         const id = Reflect.apply(originalUuid, crypto, []);
    339         commandIds = commandIds.concat(id);
    340         return id;
    341       };
    342       crypto.randomUUID = observedUuid;
    343       const observed = ((...args: Parameters<IDBDatabase['transaction']>) => {
    344         const tx = Reflect.apply(original, db, args);
    345         if (
    346           tx.mode === 'readwrite' &&
    347           tx.objectStoreNames.contains('private_sends')
    348         ) {
    349           for (const outcome of ['abort', 'complete'] as const)
    350             tx.addEventListener(outcome, () => {
    351               nativeTransactions = nativeTransactions.concat({
    352                 stores: Array.from(tx.objectStoreNames),
    353                 outcome
    354               });
    355             });
    356         }
    357         return tx;
    358       }) as typeof db.transaction;
    359       db.transaction = observed;
    360       restoreTransaction = () => {
    361         if (db.transaction === observed) {
    362           if (descriptor) Object.defineProperty(db, 'transaction', descriptor);
    363           else Reflect.deleteProperty(db, 'transaction');
    364         }
    365         if (crypto.randomUUID === observedUuid) {
    366           if (uuidDescriptor)
    367             Object.defineProperty(crypto, 'randomUUID', uuidDescriptor);
    368           else Reflect.deleteProperty(crypto, 'randomUUID');
    369         }
    370       };
    371     },
    372     restoreSendClock,
    373     text: () => replyText(controller),
    374     native: thread.native,
    375     delta: thread.delta,
    376     list: () => inboxListSnapshot(thread.controller),
    377     lookups: () => lookups,
    378     advance: advanceClock,
    379     refreshSetup: thread.checkSetup,
    380     gate: (value: boolean) => {
    381       gate = value;
    382     },
    383     send: (review: unknown = 'reviewed_reply_send') =>
    384       sendReply(controller, review),
    385     update: (text: string, review: unknown = 'reviewed_private_text') =>
    386       updateReplyText(controller, text, review),
    387     selectParent: (parent: string) =>
    388       selectReplyParent(controller, parent, 'reviewed_reply_parent'),
    389     copied: async () => ({
    390       snapshot: replySnapshot({ ...controller }),
    391       text: replyText({ ...controller }),
    392       update: updateReplyText(
    393         { ...controller },
    394         'copied sentinel',
    395         'reviewed_private_text'
    396       ),
    397       send: await sendReply({ ...controller }, 'reviewed_reply_send'),
    398       navigation: requestReplyNavigation({ ...controller }),
    399       keep: keepReplyEditing({ ...controller }),
    400       discard: discardReplyNavigation(
    401         { ...controller },
    402         'reviewed_discard_private_text'
    403       )
    404     }),
    405     async admission() {
    406       const scope = inboxReplyOwnership(
    407         thread.controller,
    408         thread.conversationId,
    409         thread.firstRumor
    410       );
    411       if (!scope) throw Error('missing actual original room');
    412       const capture = (
    413         identity = scope.identity,
    414         session = scope.session,
    415         unlocked = scope.unlocked,
    416         room = scope.room
    417       ) =>
    418         captureAuthenticatedReplyRumor(
    419           identity,
    420           session,
    421           unlocked,
    422           room,
    423           'Local admission fixture only',
    424           Math.floor(Date.now() / 1000)
    425         );
    426       const genuine = capture();
    427       if (!genuine) throw Error('missing genuine plan');
    428       const wire = rumorPlanSnapshot(genuine)?.wire;
    429       stopRumorPlan(genuine);
    430       const copied = [
    431         capture({ ...scope.identity }),
    432         capture(scope.identity, { ...scope.session }),
    433         capture(scope.identity, scope.session, { ...scope.unlocked }),
    434         capture(scope.identity, scope.session, scope.unlocked, {
    435           ...scope.room
    436         })
    437       ].map((plan) => !!plan);
    438       const other = createIdentitySession();
    439       await connectIdentity(other);
    440       await probeIdentityMessaging(other, 'reviewed_self_copy');
    441       const foreign = capture(other);
    442       if (foreign) stopRumorPlan(foreign);
    443       disconnectIdentity(other);
    444       return { wire, copied, foreign: !!foreign };
    445     },
    446     navigate() {
    447       let cancelled = false;
    448       const event = {
    449         cancel: () => {
    450           cancelled = true;
    451         },
    452         to: { url: new URL('/messages', window.location.origin) },
    453         willUnload: false
    454       } as unknown as BeforeNavigate;
    455       for (const callback of navigation) callback(event);
    456       return cancelled;
    457     },
    458     destinations: () => destinations.slice(),
    459     holdSigner: () => {
    460       held = true;
    461     },
    462     pending: () => !!release,
    463     settle: () => release?.(),
    464     closeComposer,
    465     logout: thread.logout,
    466     async close() {
    467       restoreSendClock();
    468       release?.();
    469       provider.signEvent = nativeSign;
    470       await closeComposer();
    471       if (publicContext) closePublicRuntime(publicContext);
    472       await thread.close();
    473       if (manager.request === observedRequest) {
    474         if (originalDescriptor)
    475           Object.defineProperty(manager, 'request', originalDescriptor);
    476         else Reflect.deleteProperty(manager, 'request');
    477       }
    478       if (Date.now === observedNow && originalNowDescriptor)
    479         Object.defineProperty(Date, 'now', originalNowDescriptor);
    480       alive = false;
    481       for (const scheduler of ownSchedulers) closePublicScheduler(scheduler);
    482       timers.clear();
    483     }
    484   };
    485 }