app

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

local-data-review.ts (29853B)


      1 // HC_TEST_ONLY_RELAY: original production UI/storage with a controlled SDK.
      2 // No loopback or controlled provider result represents live extension Q.
      3 import { mount, unmount } from 'svelte';
      4 import { validateRelayPolicy } from '../../../src/lib/config/relays.ts';
      5 import { verifyEnvelope } from '../../../src/lib/nostr/verified-envelope.ts';
      6 import { captureEnquiryContext } from '../../../src/lib/messaging/enquiry-context.ts';
      7 import {
      8   captureEnquiryRumor,
      9   stopRumorPlan
     10 } from '../../../src/lib/messaging/rumor-plan.ts';
     11 import {
     12   reserveSendIdentity,
     13   reservedSendSnapshot
     14 } from '../../../src/lib/messaging/send-identity.ts';
     15 import {
     16   captureSelfRecoveryPreparation,
     17   prepareSelfRecovery,
     18   preparePairedDelivery,
     19   preparedPairedDelivery,
     20   stopSelfRecoveryPreparation
     21 } from '../../../src/lib/messaging/prepare-send.ts';
     22 import { createInboxResolver } from '../../../src/lib/messaging/resolve-inbox.ts';
     23 import { createInboxRoutePlan } from '../../../src/lib/messaging/inbox-routing.ts';
     24 import {
     25   createPublicScheduler,
     26   createPublicRun,
     27   openInboxRequest,
     28   closePublicScheduler
     29 } from '../../../src/lib/nostr/request-scope.ts';
     30 
     31 import Panel from '../../../src/lib/components/LocalDataReview.svelte';
     32 import { makeFixture } from './approved-signing.ts';
     33 import { finalizeEvent, getEventHash } from 'applesauce-core/helpers';
     34 import { nip44 } from 'applesauce-core/helpers/encryption';
     35 import {
     36   createIdentityViewContext,
     37   mountIdentityView,
     38   connectIdentityView,
     39   probeIdentityViewMessaging,
     40   identityViewSession,
     41   disconnectIdentityView,
     42   closeIdentityView
     43 } from '../../../src/lib/runtime/view-context.ts';
     44 import {
     45   createLocalDataReview,
     46   reviewLocalData,
     47   localDataReviewSnapshot,
     48   previewLocalDataRemoval,
     49   confirmLocalDataRemoval,
     50   closeLocalDataReview
     51 } from '../../../src/lib/persistence/local-data-review.ts';
     52 import {
     53   openBrowserDatabase,
     54   closeBrowserDatabase,
     55   browserDatabaseTransaction
     56 } from '../../../src/lib/persistence/database.ts';
     57 import {
     58   createPublicDraftRepository,
     59   createPublicDraft,
     60   savePublicDraft
     61 } from '../../../src/lib/persistence/drafts.ts';
     62 import {
     63   createPublicQuotaRepository,
     64   admitPublicOperation
     65 } from '../../../src/lib/persistence/quota.ts';
     66 import { identityLocalOwnership } from '../../../src/lib/runtime/identity-session.ts';
     67 import {
     68   createPrivateSession,
     69   withIdlePrivateLocalStorage
     70 } from '../../../src/lib/runtime/private-session.ts';
     71 import {
     72   createPrivateSendReservationRepository,
     73   reservePrivateSendReservation
     74 } from '../../../src/lib/persistence/private-send-reservations.ts';
     75 import {
     76   createPrivateStorageRepository,
     77   commitPrivateRecord,
     78   listPrivateReceivedRecords
     79 } from '../../../src/lib/persistence/private-storage.ts';
     80 import {
     81   decodePrivateRecord,
     82   privateRecordIdentity,
     83   privateRecordSnapshot,
     84   type PrivateSendOperation
     85 } from '../../../src/lib/persistence/private-records.ts';
     86 
     87 export async function createFixture(mode = 'normal') {
     88   const signer = makeFixture(),
     89     foreign = makeFixture(),
     90     owner = signer.owner;
     91   const prior = Object.getOwnPropertyDescriptor(window, 'nostr');
     92   let changedKey = false;
     93   let counts = { reads: 0, signs: 0, encrypts: 0, decrypts: 0 };
     94   Object.defineProperty(window, 'nostr', {
     95     configurable: true,
     96     value: {
     97       getPublicKey() {
     98         counts.reads++;
     99         return Promise.resolve(changedKey ? foreign.owner : owner);
    100       },
    101       signEvent(template: Parameters<typeof signer.sign>[0]) {
    102         counts.signs++;
    103         return Promise.resolve(signer.sign(template));
    104       },
    105       nip44: {
    106         encrypt(peer: string, text: string) {
    107           counts.encrypts++;
    108           return Promise.resolve(signer.encrypt(peer, text));
    109         },
    110         decrypt(peer: string, text: string) {
    111           counts.decrypts++;
    112           return Promise.resolve(signer.decrypt(peer, text));
    113         }
    114       }
    115     }
    116   });
    117   const identity = createIdentityViewContext();
    118   mountIdentityView(identity);
    119   await connectIdentityView(identity);
    120   if (mode === 'messaging' || mode === 'outbox')
    121     await probeIdentityViewMessaging(identity, 'reviewed_self_copy');
    122   if (!identityViewSession(identity))
    123     throw Error('original connected identity absent');
    124   const opened = await openBrowserDatabase();
    125   if (opened.state !== 'ready') throw Error('native database absent');
    126   const database = opened.owner,
    127     drafts = createPublicDraftRepository(database, owner),
    128     foreignDrafts = createPublicDraftRepository(database, foreign.owner),
    129     quota = createPublicQuotaRepository(database, owner),
    130     priv = createPrivateStorageRepository(database, owner),
    131     foreignPriv = createPrivateStorageRepository(database, foreign.owner);
    132   if (!drafts || !foreignDrafts || !quota || !priv || !foreignPriv)
    133     throw Error('original namespaces absent');
    134   const form = {
    135     title: 'PUBLIC DRAFT BODY SENTINEL',
    136     description: '',
    137     location: '',
    138     amount: '',
    139     currency: '',
    140     unit: '',
    141     quantity: '',
    142     contactType: '' as const,
    143     contactValue: ''
    144   };
    145   const first = await createPublicDraft(drafts, form),
    146     second = await createPublicDraft(drafts, form),
    147     other = await createPublicDraft(foreignDrafts, {
    148       ...form,
    149       title: 'PRIVATE OWNER B SENTINEL'
    150     });
    151   if (
    152     !first.ok ||
    153     !second.ok ||
    154     !other.ok ||
    155     !(await admitPublicOperation(quota, signer.id, signer.record)).ok
    156   )
    157     throw Error('original public data absent');
    158   const outerSecret = new Uint8Array(32).fill(69),
    159     ids: string[] = [];
    160   try {
    161     for (const [target, repository, offset] of [
    162       [owner, priv, 0],
    163       [owner, priv, 1],
    164       [foreign.owner, foreignPriv, 2]
    165     ] as const) {
    166       const key = nip44.v2.utils.getConversationKey(outerSecret, target);
    167       let content: string;
    168       try {
    169         content = nip44.v2.encrypt('controlled opaque seal bytes', key);
    170       } finally {
    171         key.fill(0);
    172       }
    173       const outer = finalizeEvent(
    174         {
    175           kind: 1059,
    176           created_at: 1700000000 + offset,
    177           tags: [['p', target]],
    178           content
    179         },
    180         outerSecret
    181       );
    182       const row = decodePrivateRecord(
    183         JSON.stringify({
    184           schema: 1,
    185           family: 'received_envelope',
    186           owner: target,
    187           id: outer.id,
    188           revision: 0,
    189           outer: JSON.stringify(outer),
    190           observedAtMilliseconds: 100,
    191           sources: ['wss://archive.example.org'],
    192           read: null
    193         }),
    194         target,
    195         outer.id
    196       );
    197       if (
    198         !row.ok ||
    199         !(await commitPrivateRecord(repository, row.value, null)).ok
    200       )
    201         throw Error('real encrypted structural copy absent');
    202       if (target === owner) ids.push(outer.id);
    203     }
    204   } finally {
    205     outerSecret.fill(0);
    206   }
    207   const reservationId = crypto.randomUUID();
    208   const reservationWire = JSON.stringify({
    209     schema: 1,
    210     family: 'private_send_reservation',
    211     owner,
    212     id: reservationId,
    213     revision: 0,
    214     peer: foreign.owner,
    215     rumorHash: 'b'.repeat(64),
    216     createdAt: 1700000000
    217   });
    218   const reservationRepository = createPrivateSendReservationRepository(
    219     database,
    220     owner
    221   );
    222   const originalIdentity = identityViewSession(identity);
    223   const ownership =
    224     originalIdentity && identityLocalOwnership(originalIdentity);
    225   if (!reservationRepository || !ownership)
    226     throw Error('original outbox scope absent');
    227   if (
    228     mode !== 'outbox' &&
    229     !(
    230       await reservePrivateSendReservation(
    231         reservationRepository,
    232         reservationWire,
    233         1700000000,
    234         ownership.current
    235       )
    236     ).ok
    237   )
    238     throw Error('original protected outbox absent');
    239   const settledIds = Array.from<string>([]);
    240   function pairedRecord(index: number): PrivateSendOperation {
    241     const id = crypto.randomUUID(),
    242       rumorTemplate = {
    243         pubkey: owner,
    244         kind: 14,
    245         created_at: 1700000000 + index,
    246         tags: [['p', foreign.owner]],
    247         content: 'CR004_TEST_ONLY_nested_capacity_' + index
    248       },
    249       rumor = { ...rumorTemplate, id: getEventHash(rumorTemplate) };
    250     const artifact = (destination: string) => {
    251       const seal = signer.sign({
    252         kind: 13,
    253         created_at: 1700000000 + index,
    254         tags: [],
    255         content: signer.encrypt(destination, JSON.stringify(rumor))
    256       });
    257       const wrapper = crypto.getRandomValues(new Uint8Array(32)),
    258         conversation = nip44.v2.utils.getConversationKey(wrapper, destination);
    259       try {
    260         const outer = finalizeEvent(
    261           {
    262             kind: 1059,
    263             created_at: 1700000000 + index,
    264             tags: [['p', destination]],
    265             content: nip44.v2.encrypt(JSON.stringify(seal), conversation)
    266           },
    267           wrapper
    268         );
    269         return { eventId: outer.id, wire: JSON.stringify(outer) };
    270       } finally {
    271         wrapper.fill(0);
    272         conversation.fill(0);
    273       }
    274     };
    275     const self = artifact(owner),
    276       peerArtifact = artifact(foreign.owner);
    277     const route = (
    278       role: 'peer' | 'self_archive',
    279       author: string,
    280       origin: string
    281     ) => ({
    282       role,
    283       author,
    284       targets: [origin],
    285       knownBase: { author, id: 'c'.repeat(64), createdAt: 100 },
    286       sources: [
    287         {
    288           source: 'wss://discovery.example.org',
    289           state: 'eose' as const,
    290           head: { id: 'c'.repeat(64), createdAt: 100 }
    291         }
    292       ]
    293     });
    294     // Seeded local receipt bookkeeping only, not genuine remote ACK/operator Q.
    295     return {
    296       schema: 1,
    297       family: 'private_send_operation',
    298       owner,
    299       id,
    300       revision: 1,
    301       peer: foreign.owner,
    302       rumorHash: rumor.id,
    303       createdAt: rumor.created_at,
    304       self,
    305       peerArtifact,
    306       deliveryPlan: {
    307         state: 'prepared',
    308         routes: {
    309           peer: route('peer', foreign.owner, 'wss://peer.example.org'),
    310           archive: route('self_archive', owner, 'wss://archive.example.org')
    311         }
    312       },
    313       receipts: [
    314         {
    315           actionId: crypto.randomUUID(),
    316           origin: 'wss://peer.example.org',
    317           role: 'peer',
    318           attempt: 1,
    319           eventId: peerArtifact.eventId,
    320           status: 'accepted',
    321           observedAtMilliseconds: 1700000000000,
    322           readbackWire: null
    323         },
    324         {
    325           actionId: crypto.randomUUID(),
    326           origin: 'wss://archive.example.org',
    327           role: 'self_archive',
    328           attempt: 1,
    329           eventId: self.eventId,
    330           status: 'accepted',
    331           observedAtMilliseconds: 1700000000000,
    332           readbackWire: null
    333         }
    334       ]
    335     };
    336   }
    337   if (mode === 'outbox') {
    338     const rows = Array.from({ length: 100 }, (_, index) => pairedRecord(index));
    339     for (const row of rows) {
    340       if (!decodePrivateRecord(JSON.stringify(row), owner, row.id).ok)
    341         throw Error('strict nested-pair journal fixture rejected');
    342       settledIds.push(row.id);
    343     }
    344     const tx = browserDatabaseTransaction(
    345       database,
    346       ['private_sends'],
    347       'readwrite'
    348     );
    349     for (const row of rows)
    350       tx.objectStore('private_sends').put({
    351         owner,
    352         id: row.id,
    353         wire: JSON.stringify(row)
    354       });
    355     await new Promise<void>((resolve, reject) => {
    356       tx.addEventListener('complete', () => resolve());
    357       tx.addEventListener('abort', () => reject(Error('capacity seed abort')));
    358     });
    359   }
    360   const corruptId = crypto.randomUUID();
    361   async function transactionRows() {
    362     const tx = browserDatabaseTransaction(
    363       database,
    364       [
    365         'public_drafts',
    366         'public_operations',
    367         'received_envelopes',
    368         'private_sends'
    369       ],
    370       'readonly'
    371     );
    372     const requests = [
    373       'public_drafts',
    374       'public_operations',
    375       'received_envelopes',
    376       'private_sends'
    377     ].map((name) => tx.objectStore(name).getAll());
    378     await new Promise<void>((resolve, reject) => {
    379       tx.addEventListener('complete', () => resolve());
    380       tx.addEventListener('abort', () =>
    381         reject(Error('native observation abort'))
    382       );
    383     });
    384     return requests.map(
    385       (request) =>
    386         request.result as { owner: string; id: string; wire: string }[]
    387     );
    388   }
    389   if (mode === 'corrupt') {
    390     const tx = browserDatabaseTransaction(
    391       database,
    392       ['public_operations'],
    393       'readwrite'
    394     );
    395     tx.objectStore('public_operations').put({
    396       owner,
    397       id: corruptId,
    398       wire: '{"schema":99}'
    399     });
    400     await new Promise<void>((resolve, reject) => {
    401       tx.addEventListener('complete', () => resolve());
    402       tx.addEventListener('abort', () => reject(Error('fixture seed abort')));
    403     });
    404   }
    405   counts = { reads: 0, signs: 0, encrypts: 0, decrypts: 0 };
    406   const review = createLocalDataReview(identity);
    407   const target = document.createElement('div');
    408   target.id = 'hcp125-panel';
    409   document.body.append(target);
    410   const component = mount(Panel, { target, props: { review } });
    411   const inspect = () => reviewLocalData(review, 'reviewed_local_inventory');
    412   const preview = () =>
    413     previewLocalDataRemoval(
    414       review,
    415       'public',
    416       JSON.stringify(['public_draft:' + first.value.id])
    417     );
    418   const confirm = () =>
    419     confirmLocalDataRemoval(review, 'reviewed_local_removal');
    420   return {
    421     owner,
    422     settledIds: () => settledIds.slice(),
    423     async reviewAndPreviewOutbox() {
    424       await inspect();
    425       return previewLocalDataRemoval(
    426         review,
    427         'outbox',
    428         JSON.stringify([settledIds[0]])
    429       );
    430     },
    431     // Actual local sender factories; controlled discovery/SDK inputs are not
    432     // remote delivery, an installed extension, or operator qualification.
    433     async freshSend() {
    434       const session = identityViewSession(identity);
    435       if (!session) throw Error('original sender identity absent');
    436       const food = foreign.sign({
    437         kind: 30402,
    438         created_at: Math.floor(Date.now() / 1000),
    439         content: 'Fresh capacity fixture carrots',
    440         tags: [
    441           ['d', 'capacity-carrots'],
    442           ['title', 'Carrots'],
    443           ['summary', 'Fresh carrots'],
    444           ['published_at', '1700000000'],
    445           ['location', 'Victoria'],
    446           ['price', '3.5', 'CAD'],
    447           ['radroots:price_unit', 'lb'],
    448           ['status', 'active']
    449         ]
    450       });
    451       const verified = verifyEnvelope(JSON.stringify(food)),
    452         context = verified.ok && captureEnquiryContext(verified.value),
    453         rumor =
    454           context &&
    455           captureEnquiryRumor(
    456             session,
    457             context,
    458             'CR004 fresh factory send',
    459             Math.floor(Date.now() / 1000)
    460           );
    461       if (!rumor) throw Error('genuine fresh rumor absent');
    462       const schedulers: ReturnType<typeof createPublicScheduler>[] = [];
    463       let preparation: ReturnType<typeof captureSelfRecoveryPreparation>;
    464       try {
    465         const reserved = await reserveSendIdentity(
    466           reservationRepository,
    467           session,
    468           crypto.randomUUID(),
    469           rumor,
    470           'reviewed_private_intent'
    471         );
    472         if (!('identity' in reserved)) return { reservation: reserved.status };
    473         const id = reservedSendSnapshot(reserved.identity)?.id;
    474         preparation = captureSelfRecoveryPreparation(
    475           priv,
    476           session,
    477           reserved.identity,
    478           'reviewed_self_recovery'
    479         );
    480         if (!preparation) throw Error('actual self-first factory absent');
    481         const self = await prepareSelfRecovery(
    482           preparation,
    483           'reviewed_self_recovery'
    484         );
    485         const discovery = 'wss://discovery.example.org',
    486           peerOrigin = 'wss://peer.example.org',
    487           archiveOrigin = 'wss://archive.example.org';
    488         const policy = validateRelayPolicy(
    489           JSON.stringify({
    490             schemaVersion: 1,
    491             public: [
    492               { origin: discovery, read: true, write: false, nip50: false }
    493             ],
    494             inbox: [peerOrigin, archiveOrigin].map((origin) => ({
    495               origin,
    496               read: true,
    497               write: true
    498             })),
    499             postingEnabled: false,
    500             messagingEnabled: true,
    501             operatorDenylist: []
    502           })
    503         );
    504         if (!policy) throw Error('controlled discovery policy absent');
    505         function resolve(signer: typeof foreign, origin: string) {
    506           const event = signer.sign({
    507               kind: 10050,
    508               created_at: Math.floor(Date.now() / 1000),
    509               tags: [['relay', origin]],
    510               content: ''
    511             }),
    512             scheduler = createPublicScheduler(),
    513             run = createPublicRun(scheduler, policy!);
    514           schedulers.push(scheduler);
    515           return createInboxResolver(
    516             run,
    517             signer.owner,
    518             (next) =>
    519               openInboxRequest(
    520                 run,
    521                 signer.owner,
    522                 (sink) => {
    523                   sink({
    524                     type: 'EVENT',
    525                     from: discovery,
    526                     id: 'CR004_TEST_ONLY',
    527                     event
    528                   });
    529                   sink({
    530                     type: 'EOSE',
    531                     from: discovery,
    532                     id: 'CR004_TEST_ONLY'
    533                   });
    534                   return () => {};
    535                 },
    536                 next
    537               ),
    538             () => ownership?.current() === true
    539           );
    540         }
    541         const own = resolve(signer, archiveOrigin),
    542           other = resolve(foreign, peerOrigin),
    543           plan = createInboxRoutePlan(policy, owner, foreign.owner, own, other);
    544         if (!plan) throw Error('actual reviewed route plan absent');
    545         const pair = await preparePairedDelivery(
    546           preparation,
    547           { policy, own, other, plan },
    548           'reviewed_pair_preparation'
    549         );
    550         return {
    551           reservation: reserved.status,
    552           self: self.status,
    553           pair: pair.status,
    554           paired: !!preparedPairedDelivery(preparation),
    555           id
    556         };
    557       } finally {
    558         if (preparation) stopSelfRecoveryPreparation(preparation);
    559         stopRumorPlan(rumor);
    560         for (const scheduler of schedulers) closePublicScheduler(scheduler);
    561       }
    562     },
    563     async reserveNext() {
    564       const result = await reservePrivateSendReservation(
    565         reservationRepository,
    566         JSON.stringify({
    567           schema: 1,
    568           family: 'private_send_reservation',
    569           owner,
    570           id: crypto.randomUUID(),
    571           revision: 0,
    572           peer: foreign.owner,
    573           rumorHash: '8'.repeat(64),
    574           createdAt: 1700000000
    575         }),
    576         1700000000,
    577         ownership.current
    578       );
    579       return result.ok ? 'reserved' : result.reason;
    580     },
    581     async changeOutbox() {
    582       const stored = (await transactionRows())[3].find(
    583         (row) => row.id === settledIds[0]
    584       );
    585       if (!stored) throw Error('original outbox row absent');
    586       const decoded = decodePrivateRecord(stored.wire, owner, stored.id),
    587         record =
    588           decoded.ok && privateRecordSnapshot(decoded.value, owner, stored.id);
    589       if (
    590         !decoded.ok ||
    591         !record ||
    592         record.family !== 'private_send_operation' ||
    593         !record.receipts?.length
    594       )
    595         throw Error('original paired record absent');
    596       const next = decodePrivateRecord(
    597         JSON.stringify({
    598           ...record,
    599           revision: record.revision + 1,
    600           receipts: [
    601             ...record.receipts,
    602             {
    603               ...record.receipts[0],
    604               actionId: crypto.randomUUID(),
    605               status: 'unknown'
    606             }
    607           ]
    608         }),
    609         owner,
    610         record.id
    611       );
    612       if (
    613         !next.ok ||
    614         !(await commitPrivateRecord(priv, next.value, decoded.value)).ok
    615       )
    616         throw Error('actual outbox CAS change absent');
    617     },
    618     switchKey: () => {
    619       changedKey = true;
    620     },
    621     async confirmWhileSdkBusy() {
    622       const original = identityViewSession(identity);
    623       if (!original) throw Error('actual identity absent');
    624       const session = await createPrivateSession(
    625         original,
    626         'reviewed_private_session'
    627       );
    628       if (!session) throw Error('actual private session absent');
    629       let entered = () => {},
    630         release = () => {};
    631       const ready = new Promise<void>((resolve) => {
    632         entered = resolve;
    633       });
    634       const held = withIdlePrivateLocalStorage(
    635         session,
    636         () =>
    637           new Promise<void>((resolve) => {
    638             release = resolve;
    639             entered();
    640           })
    641       );
    642       await ready;
    643       try {
    644         return await confirm();
    645       } finally {
    646         release();
    647         await held;
    648       }
    649     },
    650     async abortOutboxDelete(unknown = false) {
    651       const descriptor = Object.getOwnPropertyDescriptor(
    652         IDBObjectStore.prototype,
    653         'delete'
    654       );
    655       if (!descriptor) throw Error('actual delete descriptor absent');
    656       const nativeDelete = descriptor.value as IDBObjectStore['delete'],
    657         nativeAbort = Reflect.get<IDBTransaction, 'abort'>(
    658           IDBTransaction.prototype,
    659           'abort'
    660         );
    661       let deletes = 0,
    662         aborts = 0;
    663       let terminal: Promise<'abort' | 'complete'> | undefined;
    664       IDBObjectStore.prototype.delete = function (...args) {
    665         const request = Reflect.apply(nativeDelete, this, args);
    666         if (this.name === 'private_sends') {
    667           const transaction = this.transaction;
    668           terminal = new Promise((resolve) => {
    669             transaction.addEventListener('abort', () => {
    670               aborts++;
    671               resolve('abort');
    672             });
    673             transaction.addEventListener('complete', () => resolve('complete'));
    674           });
    675           if (unknown) {
    676             this.transaction.abort = () => {
    677               throw Error('controlled lost abort capability');
    678             };
    679             throw Error(
    680               'controlled lost delete result after actual queued request'
    681             );
    682           }
    683           request.addEventListener(
    684             'success',
    685             () => {
    686               deletes++;
    687               Reflect.apply(nativeAbort, this.transaction, []);
    688             },
    689             { once: true }
    690           );
    691         }
    692         return request;
    693       };
    694       try {
    695         const confirmed = await confirm(),
    696           nativeTerminal = terminal && (await terminal);
    697         return { confirmed, deletes, aborts, nativeTerminal };
    698       } finally {
    699         Object.defineProperty(IDBObjectStore.prototype, 'delete', descriptor);
    700       }
    701     },
    702     effects: () => ({ ...counts }),
    703     snapshot: () => localDataReviewSnapshot(review),
    704     review: inspect,
    705     confirm,
    706     async reviewAndPreview() {
    707       await inspect();
    708       if (!(await preview())) throw Error('original public preview absent');
    709     },
    710     async reviewAndPreviewReceived() {
    711       await inspect();
    712       if (
    713         !(await previewLocalDataRemoval(
    714           review,
    715           'received',
    716           JSON.stringify([ids[0]])
    717         ))
    718       )
    719         throw Error('original received preview absent');
    720     },
    721     changeDraft: () =>
    722       savePublicDraft(drafts, first.value.id, 0, {
    723         ...form,
    724         title: 'new actual revision'
    725       }),
    726     async changeReceived() {
    727       const scan = await listPrivateReceivedRecords(priv);
    728       if (!scan.ok) throw Error('native scan absent');
    729       const handle = scan.value.find(
    730         (row) => privateRecordIdentity(row)?.id === ids[0]
    731       );
    732       const row = handle && privateRecordSnapshot(handle, owner, ids[0]);
    733       if (!handle || row?.family !== 'received_envelope')
    734         throw Error('native selected copy absent');
    735       const next = decodePrivateRecord(
    736         JSON.stringify({
    737           ...row,
    738           revision: row.revision + 1,
    739           sources: [...row.sources, 'wss://other.example.org']
    740         }),
    741         owner,
    742         row.id
    743       );
    744       if (!next.ok || !(await commitPrivateRecord(priv, next.value, handle)).ok)
    745         throw Error('real received CAS change absent');
    746     },
    747     async rows() {
    748       const [publicRows, operations, received, outbox] =
    749         await transactionRows();
    750       return {
    751         publicDrafts: publicRows.filter((row) => row.owner === owner).length,
    752         foreignDrafts: publicRows.filter((row) => row.owner === foreign.owner)
    753           .length,
    754         publicOperations: operations.filter((row) => row.owner === owner)
    755           .length,
    756         received: received.filter((row) => row.owner === owner).length,
    757         foreignReceived: received.filter((row) => row.owner === foreign.owner)
    758           .length,
    759         outbox: outbox.filter((row) => row.owner === owner).length
    760       };
    761     },
    762     async rawCorrupt() {
    763       return (await transactionRows())[1].find((row) => row.id === corruptId)
    764         ?.wire;
    765     },
    766     logout: () => disconnectIdentityView(identity),
    767     dispose: () => closeLocalDataReview(review),
    768     async hostileSelections() {
    769       const key = 'public_draft:' + first.value.id;
    770       const values = [
    771         'not JSON',
    772         '[]',
    773         JSON.stringify([key, key]),
    774         JSON.stringify(['public_operation:' + signer.id]),
    775         JSON.stringify(['public_draft:' + other.value.id])
    776       ];
    777       const results: boolean[] = [];
    778       for (const value of values)
    779         results.push(await previewLocalDataRemoval(review, 'public', value));
    780       return results;
    781     },
    782     async confirmWhileLocked() {
    783       let release = () => {},
    784         entered = () => {};
    785       const ready = new Promise<void>((resolve) => {
    786         entered = resolve;
    787       });
    788       const held = navigator.locks.request(
    789         'harvestcircle:owner:' + owner,
    790         async () => {
    791           entered();
    792           await new Promise<void>((resolve) => {
    793             release = resolve;
    794           });
    795         }
    796       );
    797       await ready;
    798       try {
    799         return await confirm();
    800       } finally {
    801         release();
    802         await held;
    803       }
    804     },
    805     async abortDuringDelete() {
    806       const descriptor = Object.getOwnPropertyDescriptor(
    807         IDBObjectStore.prototype,
    808         'delete'
    809       );
    810       if (!descriptor) throw Error('native delete descriptor absent');
    811       const nativeDelete = descriptor.value as IDBObjectStore['delete'];
    812       let deleteSuccesses = 0,
    813         nativeAborts = 0;
    814       let terminal: Promise<'abort' | 'complete'> | undefined;
    815       IDBObjectStore.prototype.delete = function (...args) {
    816         const request = nativeDelete.apply(this, args);
    817         if (this.name === 'public_drafts') {
    818           const transaction = this.transaction;
    819           terminal = new Promise((resolve) => {
    820             transaction.addEventListener('abort', () => {
    821               nativeAborts++;
    822               resolve('abort');
    823             });
    824             transaction.addEventListener('complete', () => resolve('complete'));
    825           });
    826           request.addEventListener('success', () => {
    827             deleteSuccesses++;
    828             disconnectIdentityView(identity);
    829           });
    830         }
    831         return request;
    832       };
    833       try {
    834         const confirmed = await confirm();
    835         const nativeTerminal = terminal && (await terminal);
    836         return { confirmed, deleteSuccesses, nativeAborts, nativeTerminal };
    837       } finally {
    838         Object.defineProperty(IDBObjectStore.prototype, 'delete', descriptor);
    839       }
    840     },
    841     async oldConfirmationThenNewPreview() {
    842       await inspect();
    843       if (
    844         !(await previewLocalDataRemoval(
    845           review,
    846           'received',
    847           JSON.stringify([ids[0]])
    848         ))
    849       )
    850         throw Error('old actual selection absent');
    851       const native = navigator.locks.request.bind(navigator.locks);
    852       let release = () => {},
    853         markHeld = () => {},
    854         held = false;
    855       const reached = new Promise<void>((resolve) => {
    856         markHeld = resolve;
    857       });
    858       const pause = new Promise<void>((resolve) => {
    859         release = resolve;
    860       });
    861       const originalMethod = Reflect.get<LockManager, 'request'>(
    862         navigator.locks,
    863         'request'
    864       );
    865       navigator.locks.request = (
    866         name: string,
    867         options: LockOptions | LockGrantedCallback<unknown>,
    868         callback?: LockGrantedCallback<unknown>
    869       ) => {
    870         if (typeof options === 'function') return native(name, options);
    871         if (!callback) throw Error('real callback absent');
    872         return native(name, options, async (lock) => {
    873           const result: unknown = await callback(lock);
    874           if (!held && name === 'harvestcircle:owner:' + owner && lock) {
    875             held = true;
    876             markHeld();
    877             await pause;
    878           }
    879           return result;
    880         });
    881       };
    882       let old: Promise<boolean> | undefined;
    883       try {
    884         old = confirm();
    885         await reached;
    886         disconnectIdentityView(identity);
    887         await connectIdentityView(identity);
    888         await probeIdentityViewMessaging(identity, 'reviewed_self_copy');
    889         await inspect();
    890         const newer = await previewLocalDataRemoval(
    891           review,
    892           'received',
    893           JSON.stringify([ids[1]])
    894         );
    895         release();
    896         const oldConfirmed = await old;
    897         const currentPreview = localDataReviewSnapshot(review);
    898         const newConfirmed = await confirm();
    899         return { held, newer, oldConfirmed, currentPreview, newConfirmed };
    900       } finally {
    901         release();
    902         if (old) await old;
    903         navigator.locks.request = originalMethod;
    904       }
    905     },
    906     async close() {
    907       closeLocalDataReview(review);
    908       await unmount(component);
    909       target.remove();
    910       closeIdentityView(identity);
    911       closeBrowserDatabase(database);
    912       signer.close();
    913       foreign.close();
    914       if (prior) Object.defineProperty(window, 'nostr', prior);
    915       else Reflect.deleteProperty(window, 'nostr');
    916     }
    917   };
    918 }