app

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

paired-delivery.spec.ts (18117B)


      1 import { expect, test, type Page } from '@playwright/test';
      2 import { build } from 'vite';
      3 import { fileURLToPath } from 'node:url';
      4 import { createHash } from 'node:crypto';
      5 import { createStaticHarness } from '../integration/harness/static.ts';
      6 import type * as Pair from './harness/paired-delivery.ts';
      7 declare global {
      8   interface Window {
      9     hcp082: typeof Pair;
     10     hcp082Fixture: Awaited<ReturnType<typeof Pair.makeFixture>>;
     11   }
     12 }
     13 let server: Awaited<ReturnType<typeof createStaticHarness>>, bundle: string;
     14 test.beforeAll(async () => {
     15   server = await createStaticHarness();
     16   const built = await build({
     17     configFile: false,
     18     logLevel: 'silent',
     19     build: {
     20       write: false,
     21       minify: false,
     22       lib: {
     23         entry: fileURLToPath(
     24           new URL('./harness/paired-delivery.ts', import.meta.url)
     25         ),
     26         name: 'hcp082',
     27         formats: ['iife']
     28       }
     29     }
     30   });
     31   const output = Array.isArray(built) ? built[0] : built;
     32   if (!('output' in output)) throw Error('missing pair bundle');
     33   const chunks = output.output.filter((entry) => entry.type === 'chunk');
     34   expect(chunks).toHaveLength(1);
     35   bundle = chunks[0].code;
     36   console.log(
     37     JSON.stringify({
     38       fixture: 'HCP082_REAL_PAIRED_IDB_PLAN',
     39       bundleSha256: createHash('sha256').update(bundle).digest('hex'),
     40       moduleIds: Object.keys(chunks[0].modules),
     41       qualification:
     42         'Source-only actual SDK/IDB/WebLocks; controlled public preference observations, no operator Q'
     43     })
     44   );
     45 });
     46 test.afterAll(async () => server.close());
     47 async function load(page: Page) {
     48   await page.goto(server.url + '/search');
     49   await page.addScriptTag({ content: bundle });
     50   await page.evaluate(async () => {
     51     window.hcp082Fixture = await window.hcp082.makeFixture();
     52   });
     53 }
     54 
     55 test('no paired permission before self acknowledgement; complete artifacts and frozen routes commit before local readiness', async ({
     56   page
     57 }) => {
     58   await load(page);
     59   const result = await page.evaluate(async () => {
     60     const f = window.hcp082Fixture,
     61       s = window.hcp082;
     62     try {
     63       const before = f.counts(),
     64         refused = await s.preparePairedDelivery(
     65           f.preparation,
     66           f.context,
     67           'reviewed_pair_preparation'
     68         ),
     69         inert = JSON.stringify(before) === JSON.stringify(f.counts());
     70       await s.prepareSelfRecovery(f.preparation, 'reviewed_self_recovery');
     71       const self = await f.stored(),
     72         prepared = await s.preparePairedDelivery(
     73           f.preparation,
     74           f.context,
     75           'reviewed_pair_preparation'
     76         ),
     77         token = s.preparedPairedDelivery(f.preparation),
     78         row = token && s.pairedDeliveryAcknowledgementSnapshot(token),
     79         raw = await f.stored();
     80       return {
     81         refused: refused.status,
     82         inert,
     83         prepared: prepared.status,
     84         ack: !!row,
     85         state: row?.deliveryPlan.state,
     86         roles: row && [
     87           row.deliveryPlan.routes.peer.role,
     88           row.deliveryPlan.routes.archive.role
     89         ],
     90         sameRumor:
     91           row?.rumorHash ===
     92           s.selfRecoveryAcknowledgementSnapshot(
     93             s.preparedSelfRecovery(f.preparation)!
     94           )?.rumorHash,
     95         twoArtifacts: !!row?.self.wire && !!row.peerArtifact.wire,
     96         changed: raw !== self,
     97         plaintext:
     98           raw.includes(f.marker) ||
     99           (await f.publicDraftRows()).includes(f.marker)
    100       };
    101     } finally {
    102       f.close();
    103     }
    104   });
    105   expect(result).toEqual({
    106     refused: 'self_required',
    107     inert: true,
    108     prepared: 'prepared',
    109     ack: true,
    110     state: 'prepared',
    111     roles: ['peer', 'self_archive'],
    112     sameRumor: true,
    113     twoArtifacts: true,
    114     changed: true,
    115     plaintext: false
    116   });
    117 });
    118 test('same paired command retry keeps both exact wires and routes without more SDK work', async ({
    119   page
    120 }) => {
    121   await load(page);
    122   const result = await page.evaluate(async () => {
    123     const f = window.hcp082Fixture,
    124       s = window.hcp082;
    125     try {
    126       await s.prepareSelfRecovery(f.preparation, 'reviewed_self_recovery');
    127       await s.preparePairedDelivery(
    128         f.preparation,
    129         f.context,
    130         'reviewed_pair_preparation'
    131       );
    132       const token = s.preparedPairedDelivery(f.preparation),
    133         before = f.counts(),
    134         bytes = await f.stored(),
    135         again = await s.preparePairedDelivery(
    136           f.preparation,
    137           f.context,
    138           'reviewed_pair_preparation'
    139         );
    140       return {
    141         status: again.status,
    142         same: token === s.preparedPairedDelivery(f.preparation),
    143         bytes: bytes === (await f.stored()),
    144         counts: JSON.stringify(before) === JSON.stringify(f.counts())
    145       };
    146     } finally {
    147       f.close();
    148     }
    149   });
    150   expect(result).toEqual({
    151     status: 'prepared',
    152     same: true,
    153     bytes: true,
    154     counts: true
    155   });
    156 });
    157 test('genuine paired acknowledgement cannot reconcile arbitrary structurally valid stored advancement', async ({
    158   page
    159 }) => {
    160   await load(page);
    161   const result = await page.evaluate(async () => {
    162     const f = window.hcp082Fixture,
    163       s = window.hcp082;
    164     try {
    165       await s.prepareSelfRecovery(f.preparation, 'reviewed_self_recovery');
    166       await s.preparePairedDelivery(
    167         f.preparation,
    168         f.context,
    169         'reviewed_pair_preparation'
    170       );
    171       await f.changePairRevision();
    172       const changed = await f.stored(),
    173         before = f.counts(),
    174         self = await s.prepareSelfRecovery(
    175           f.preparation,
    176           'reviewed_self_recovery'
    177         ),
    178         pair = await s.preparePairedDelivery(
    179           f.preparation,
    180           f.context,
    181           'reviewed_pair_preparation'
    182         );
    183       return {
    184         self: self.status,
    185         pair: pair.status,
    186         selfAck: !!s.preparedSelfRecovery(f.preparation),
    187         pairAck: !!s.preparedPairedDelivery(f.preparation),
    188         preserved: changed === (await f.stored()),
    189         counts: JSON.stringify(before) === JSON.stringify(f.counts())
    190       };
    191     } finally {
    192       f.close();
    193     }
    194   });
    195   expect(result).toEqual({
    196     self: 'conflict',
    197     pair: 'self_required',
    198     selfAck: false,
    199     pairAck: false,
    200     preserved: true,
    201     counts: true
    202   });
    203 });
    204 for (const fault of ['abort', 'unknown'] as const)
    205   test(
    206     'actual ' + fault + ' pair write preserves truthful atomic acknowledgement',
    207     async ({ page }) => {
    208       await load(page);
    209       const result = await page.evaluate(async (mode) => {
    210         const f = window.hcp082Fixture,
    211           s = window.hcp082;
    212         try {
    213           await s.prepareSelfRecovery(f.preparation, 'reviewed_self_recovery');
    214           const old = await f.stored(),
    215             hits = f.fault(mode),
    216             result = await s.preparePairedDelivery(
    217               f.preparation,
    218               f.context,
    219               'reviewed_pair_preparation'
    220             ),
    221             receipt = s.preparedPairedDelivery(f.preparation),
    222             stored = await f.stored();
    223           return {
    224             status: result.status,
    225             hits: hits(),
    226             ack: !!receipt,
    227             unchanged: old === stored,
    228             plaintext: stored.includes(f.marker)
    229           };
    230         } finally {
    231           f.close();
    232         }
    233       }, fault);
    234       expect(result).toEqual(
    235         fault === 'abort'
    236           ? {
    237               status: 'aborted',
    238               hits: 1,
    239               ack: false,
    240               unchanged: true,
    241               plaintext: false
    242             }
    243           : {
    244               status: 'reconciled',
    245               hits: 1,
    246               ack: true,
    247               unchanged: false,
    248               plaintext: false
    249             }
    250       );
    251     }
    252   );
    253 test('peer interruption after actual encryption entry leaves only acknowledged self recovery ciphertext', async ({
    254   page
    255 }) => {
    256   await load(page);
    257   const result = await page.evaluate(async () => {
    258     const f = window.hcp082Fixture,
    259       s = window.hcp082;
    260     try {
    261       await s.prepareSelfRecovery(f.preparation, 'reviewed_self_recovery');
    262       const bytes = await f.stored();
    263       f.mode('hold_encrypt');
    264       const pending = s.preparePairedDelivery(
    265         f.preparation,
    266         f.context,
    267         'reviewed_pair_preparation'
    268       );
    269       let entered = false;
    270       for (let i = 0; i < 1800; i++) {
    271         if (f.pendingEncryption()) {
    272           entered = true;
    273           break;
    274         }
    275         await new Promise((resolve) => setTimeout(resolve, 50));
    276       }
    277       if (!entered) throw Error('peer encryption did not enter');
    278       f.disconnect();
    279       f.settle();
    280       const result = await pending;
    281       return {
    282         status: result.status,
    283         ack: !!s.preparedPairedDelivery(f.preparation),
    284         unchanged: bytes === (await f.stored())
    285       };
    286     } finally {
    287       f.close();
    288     }
    289   });
    290   expect(result).toEqual({ status: 'stopped', ack: false, unchanged: true });
    291 });
    292 test('changed route ownership after actual peer crypto blocks pair commit and preserves self', async ({
    293   page
    294 }) => {
    295   await load(page);
    296   const result = await page.evaluate(async () => {
    297     const f = window.hcp082Fixture,
    298       s = window.hcp082;
    299     try {
    300       await s.prepareSelfRecovery(f.preparation, 'reviewed_self_recovery');
    301       const bytes = await f.stored();
    302       f.mode('hold_encrypt');
    303       const pending = s.preparePairedDelivery(
    304         f.preparation,
    305         f.context,
    306         'reviewed_pair_preparation'
    307       );
    308       let entered = false;
    309       for (let i = 0; i < 1800; i++) {
    310         if (f.pendingEncryption()) {
    311           entered = true;
    312           break;
    313         }
    314         await new Promise((resolve) => setTimeout(resolve, 50));
    315       }
    316       if (!entered) throw Error('peer encryption did not enter');
    317       f.staleRoutes();
    318       f.settle();
    319       const result = await pending;
    320       return {
    321         status: result.status,
    322         ack: !!s.preparedPairedDelivery(f.preparation),
    323         unchanged: bytes === (await f.stored())
    324       };
    325     } finally {
    326       f.close();
    327     }
    328   });
    329   expect(result).toEqual({
    330     status: 'review_required',
    331     ack: false,
    332     unchanged: true
    333   });
    334 });
    335 test('different genuine peer ciphertext for the same committed command conflicts without overwriting either artifact', async ({
    336   page
    337 }) => {
    338   await load(page);
    339   const result = await page.evaluate(async () => {
    340     const f = window.hcp082Fixture,
    341       s = window.hcp082;
    342     try {
    343       await s.prepareSelfRecovery(f.preparation, 'reviewed_self_recovery');
    344       const self = s.preparedSelfRecovery(f.preparation)!;
    345       await s.preparePairedDelivery(
    346         f.preparation,
    347         f.context,
    348         'reviewed_pair_preparation'
    349       );
    350       const old = await f.stored(),
    351         peer = await f.peerProof();
    352       if (!peer) throw Error('missing competing genuine peer proof');
    353       const changed = await s.commitPairedDelivery(
    354         f.repository,
    355         f.identity,
    356         f.reserved,
    357         self,
    358         peer,
    359         f.context.plan,
    360         'reviewed_pair_commit'
    361       );
    362       return { status: changed.status, unchanged: old === (await f.stored()) };
    363     } finally {
    364       f.close();
    365     }
    366   });
    367   expect(result).toEqual({ status: 'conflict', unchanged: true });
    368 });
    369 test('stored route metadata rejects unknown plaintext and missing paired artifacts instead of fabricating readiness', async ({
    370   page
    371 }) => {
    372   await load(page);
    373   const result = await page.evaluate(async () => {
    374     const f = window.hcp082Fixture,
    375       s = window.hcp082;
    376     try {
    377       await s.prepareSelfRecovery(f.preparation, 'reviewed_self_recovery');
    378       await s.preparePairedDelivery(
    379         f.preparation,
    380         f.context,
    381         'reviewed_pair_preparation'
    382       );
    383       const token = s.preparedPairedDelivery(f.preparation)!,
    384         row = s.pairedDeliveryAcknowledgementSnapshot(token)!;
    385       const raw = {
    386         schema: 1,
    387         family: 'private_send_operation',
    388         owner: row.owner,
    389         id: row.id,
    390         revision: row.revision,
    391         peer: row.peer,
    392         rumorHash: row.rumorHash,
    393         createdAt: row.createdAt,
    394         self: row.self,
    395         peerArtifact: row.peerArtifact,
    396         deliveryPlan: row.deliveryPlan
    397       };
    398       return {
    399         valid: s.decodePrivateRecord(JSON.stringify(raw), row.owner, row.id).ok,
    400         unknown: s.decodePrivateRecord(
    401           JSON.stringify({
    402             ...raw,
    403             deliveryPlan: { ...raw.deliveryPlan, body: f.marker }
    404           }),
    405           row.owner,
    406           row.id
    407         ).ok,
    408         missing: s.decodePrivateRecord(
    409           JSON.stringify({ ...raw, peerArtifact: null }),
    410           row.owner,
    411           row.id
    412         ).ok
    413       };
    414     } finally {
    415       f.close();
    416     }
    417   });
    418   expect(result).toEqual({ valid: true, unknown: false, missing: false });
    419 });
    420 test('distinct intentional identical text is not collapsed into the prior paired command', async ({
    421   page
    422 }) => {
    423   await load(page);
    424   const result = await page.evaluate(async () => {
    425     const f = window.hcp082Fixture,
    426       s = window.hcp082;
    427     try {
    428       await s.prepareSelfRecovery(f.preparation, 'reviewed_self_recovery');
    429       const self = s.preparedSelfRecovery(f.preparation)!;
    430       await s.preparePairedDelivery(
    431         f.preparation,
    432         f.context,
    433         'reviewed_pair_preparation'
    434       );
    435       const peer = await f.peerProof(),
    436         intent = await f.distinctIntent();
    437       if (!peer) throw Error('missing genuine prior peer');
    438       const before = await f.stored();
    439       const refused = intent.identity
    440         ? await s.commitPairedDelivery(
    441             f.repository,
    442             f.identity,
    443             intent.identity,
    444             self,
    445             peer,
    446             f.context.plan,
    447             'reviewed_pair_commit'
    448           )
    449         : undefined;
    450       return {
    451         safe:
    452           intent.status === 'clock_conflict' ||
    453           (intent.status === 'reserved' &&
    454             intent.id !== s.selfRecoveryAcknowledgementSnapshot(self)?.id),
    455         refused: !intent.identity || refused?.status === 'invalid',
    456         unchanged: before === (await f.stored())
    457       };
    458     } finally {
    459       f.close();
    460     }
    461   });
    462   expect(result).toEqual({ safe: true, refused: true, unchanged: true });
    463 });
    464 test('concurrent genuine paired commits from the same self-only base produce one exact durable winner and one conflict', async ({
    465   page
    466 }) => {
    467   await load(page);
    468   const result = await page.evaluate(async () => {
    469     const f = window.hcp082Fixture,
    470       s = window.hcp082;
    471     try {
    472       await s.prepareSelfRecovery(f.preparation, 'reviewed_self_recovery');
    473       const self = s.preparedSelfRecovery(f.preparation)!,
    474         left = await f.peerProof(),
    475         right = await f.peerProof();
    476       if (!left || !right) throw Error('missing genuine competing peer proofs');
    477       const a = s.verifiedOutboundSnapshot(left),
    478         b = s.verifiedOutboundSnapshot(right);
    479       if (!a || !b || a.wire === b.wire)
    480         throw Error('competing wrappers were not distinct');
    481       const outcomes = await Promise.all([
    482         s.commitPairedDelivery(
    483           f.repository,
    484           f.identity,
    485           f.reserved,
    486           self,
    487           left,
    488           f.context.plan,
    489           'reviewed_pair_commit'
    490         ),
    491         s.commitPairedDelivery(
    492           f.repository,
    493           f.identity,
    494           f.reserved,
    495           self,
    496           right,
    497           f.context.plan,
    498           'reviewed_pair_commit'
    499         )
    500       ]);
    501       const winner = outcomes.find((value) => 'receipt' in value);
    502       if (!winner || !('receipt' in winner))
    503         throw Error('missing actual acknowledged winner');
    504       const expected = winner === outcomes[0] ? a : b,
    505         ack = s.pairedDeliveryAcknowledgementSnapshot(winner.receipt),
    506         stored = await f.storedPair(),
    507         original = s.selfRecoveryAcknowledgementSnapshot(self),
    508         wire = await f.stored();
    509       return {
    510         statuses: outcomes.map((value) => value.status).sort(),
    511         oneReceipt: outcomes.filter((value) => 'receipt' in value).length === 1,
    512         peer:
    513           stored?.peerArtifact?.wire === expected.wire &&
    514           ack?.peerArtifact.wire === expected.wire,
    515         self: stored?.self.wire === original?.self.wire,
    516         routes:
    517           JSON.stringify(stored?.deliveryPlan?.routes) ===
    518           JSON.stringify(s.inboxRoutePlanSnapshot(f.context.plan)),
    519         revision: stored?.revision === ack?.revision,
    520         plaintext: wire.includes(f.marker)
    521       };
    522     } finally {
    523       f.close();
    524     }
    525   });
    526   expect(result).toEqual({
    527     statuses: ['conflict', 'prepared'],
    528     oneReceipt: true,
    529     peer: true,
    530     self: true,
    531     routes: true,
    532     revision: true,
    533     plaintext: false
    534   });
    535 });
    536 test('explicit self then pair retry after pair commit retains genuine successor evidence and exact ciphertext', async ({
    537   page
    538 }) => {
    539   await load(page);
    540   const result = await page.evaluate(async () => {
    541     const f = window.hcp082Fixture,
    542       s = window.hcp082;
    543     try {
    544       await s.prepareSelfRecovery(f.preparation, 'reviewed_self_recovery');
    545       const self = s.preparedSelfRecovery(f.preparation);
    546       await s.preparePairedDelivery(
    547         f.preparation,
    548         f.context,
    549         'reviewed_pair_preparation'
    550       );
    551       const token = s.preparedPairedDelivery(f.preparation),
    552         bytes = await f.stored(),
    553         before = f.counts(),
    554         selfAgain = await s.prepareSelfRecovery(
    555           f.preparation,
    556           'reviewed_self_recovery'
    557         ),
    558         pairAgain = await s.preparePairedDelivery(
    559           f.preparation,
    560           f.context,
    561           'reviewed_pair_preparation'
    562         );
    563       return {
    564         self: selfAgain.status,
    565         pair: pairAgain.status,
    566         sameSelf: self === s.preparedSelfRecovery(f.preparation),
    567         samePair: token === s.preparedPairedDelivery(f.preparation),
    568         bytes: bytes === (await f.stored()),
    569         counts: JSON.stringify(before) === JSON.stringify(f.counts())
    570       };
    571     } finally {
    572       f.close();
    573     }
    574   });
    575   expect(result).toEqual({
    576     self: 'saved',
    577     pair: 'prepared',
    578     sameSelf: true,
    579     samePair: true,
    580     bytes: true,
    581     counts: true
    582   });
    583 });