app

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

self-recovery.spec.ts (14037B)


      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 Recovery from './harness/self-recovery.ts';
      7 declare global {
      8   interface Window {
      9     hcp081: typeof Recovery;
     10     hcp081Fixture: Awaited<ReturnType<typeof Recovery.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/self-recovery.ts', import.meta.url)
     25         ),
     26         name: 'hcp081',
     27         formats: ['iife']
     28       }
     29     }
     30   });
     31   const output = Array.isArray(built) ? built[0] : built;
     32   if (!('output' in output)) throw Error('missing recovery 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: 'HCP081_REAL_SELF_IDB_ACKNOWLEDGEMENT',
     39       bundleSha256: createHash('sha256').update(bundle).digest('hex'),
     40       moduleIds: Object.keys(chunks[0].modules),
     41       qualification:
     42         'Source-only genuine SDK/IDB/WebLocks; synthetic fault boundaries, no actual 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.hcp081Fixture = await window.hcp081.makeFixture();
     52   });
     53 }
     54 test('self ciphertext is acknowledged before workflow peer permission, with no plaintext in either store', async ({
     55   page
     56 }) => {
     57   await load(page);
     58   const result = await page.evaluate(async () => {
     59     const f = window.hcp081Fixture,
     60       s = window.hcp081;
     61     try {
     62       const before = s.selfRecoveryPreparationSnapshot(f.preparation),
     63         base = f.counts();
     64       const early = await s.selfRecoveryPeerPreparation(
     65         f.preparation,
     66         {} as Parameters<typeof s.selfRecoveryPeerPreparation>[1]
     67       );
     68       const saved = await s.prepareSelfRecovery(
     69         f.preparation,
     70         'reviewed_self_recovery'
     71       );
     72       const receipt = s.preparedSelfRecovery(f.preparation),
     73         ack = receipt && s.selfRecoveryAcknowledgementSnapshot(receipt),
     74         rows = await f.stored(),
     75         publicRows = await f.publicDraftRows();
     76       const storedRows = JSON.parse(rows) as { wire: string }[];
     77       return {
     78         before: before?.state,
     79         early: Boolean(early),
     80         status: saved.status,
     81         acknowledged: Boolean(ack),
     82         copy: ack?.copy,
     83         peerReady: Boolean(
     84           receipt &&
     85           (await s.selfRecoveryPeerPreparation(f.preparation, receipt))
     86         ),
     87         plaintext: rows.includes(f.marker) || publicRows.includes(f.marker),
     88         selfOnly: storedRows[0].wire.includes('"peerArtifact":null'),
     89         encrypts: f.counts().encrypts - base.encrypts,
     90         signs: f.counts().signs - base.signs
     91       };
     92     } finally {
     93       f.close();
     94     }
     95   });
     96   expect(result).toEqual({
     97     before: 'unsaved',
     98     early: false,
     99     status: 'saved',
    100     acknowledged: true,
    101     copy: 'Saved encrypted in this browser',
    102     peerReady: true,
    103     plaintext: false,
    104     selfOnly: true,
    105     encrypts: 1,
    106     signs: 1
    107   });
    108 });
    109 test('same-command retry reuses the exact self ciphertext without any additional SDK work', async ({
    110   page
    111 }) => {
    112   await load(page);
    113   const result = await page.evaluate(async () => {
    114     const f = window.hcp081Fixture,
    115       s = window.hcp081;
    116     try {
    117       await s.prepareSelfRecovery(f.preparation, 'reviewed_self_recovery');
    118       const first = await f.stored(),
    119         before = f.counts(),
    120         receipt = s.preparedSelfRecovery(f.preparation);
    121       const retry = await s.prepareSelfRecovery(
    122         f.preparation,
    123         'reviewed_self_recovery'
    124       );
    125       return {
    126         status: retry.status,
    127         equal: first === (await f.stored()),
    128         sameReceipt: receipt === s.preparedSelfRecovery(f.preparation),
    129         counts: JSON.stringify(before) === JSON.stringify(f.counts())
    130       };
    131     } finally {
    132       f.close();
    133     }
    134   });
    135   expect(result).toEqual({
    136     status: 'saved',
    137     equal: true,
    138     sameReceipt: true,
    139     counts: true
    140   });
    141 });
    142 test('closed storage refuses acknowledgement and peer permission without a plaintext fallback', async ({
    143   page
    144 }) => {
    145   await load(page);
    146   const result = await page.evaluate(async () => {
    147     const f = window.hcp081Fixture,
    148       s = window.hcp081;
    149     try {
    150       f.closeStorage();
    151       const before = f.counts(),
    152         result = await s.prepareSelfRecovery(
    153           f.preparation,
    154           'reviewed_self_recovery'
    155         );
    156       return {
    157         status: result.status,
    158         receipt: Boolean(s.preparedSelfRecovery(f.preparation)),
    159         counts: JSON.stringify(before) === JSON.stringify(f.counts()),
    160         plaintext: (await f.stored()).includes(f.marker)
    161       };
    162     } finally {
    163       f.close();
    164     }
    165   });
    166   expect(result).toEqual({
    167     status: 'unavailable',
    168     receipt: false,
    169     counts: true,
    170     plaintext: false
    171   });
    172 });
    173 test('actual aborted self write never grants local acknowledgement or peer permission', async ({
    174   page
    175 }) => {
    176   await load(page);
    177   const result = await page.evaluate(async () => {
    178     const f = window.hcp081Fixture,
    179       s = window.hcp081;
    180     try {
    181       const prior = await f.stored(),
    182         hits = f.fault('abort'),
    183         result = await s.prepareSelfRecovery(
    184           f.preparation,
    185           'reviewed_self_recovery'
    186         );
    187       return {
    188         status: result.status,
    189         hits: hits(),
    190         receipt: Boolean(s.preparedSelfRecovery(f.preparation)),
    191         unchanged: prior === (await f.stored())
    192       };
    193     } finally {
    194       f.close();
    195     }
    196   });
    197   expect(result).toEqual({
    198     status: 'aborted',
    199     hits: 1,
    200     receipt: false,
    201     unchanged: true
    202   });
    203 });
    204 test('unknown write completion is reconciled by exact original ciphertext readback, never by regenerated crypto', async ({
    205   page
    206 }) => {
    207   await load(page);
    208   const result = await page.evaluate(async () => {
    209     const f = window.hcp081Fixture,
    210       s = window.hcp081;
    211     try {
    212       const before = f.counts(),
    213         hits = f.fault('unknown'),
    214         result = await s.prepareSelfRecovery(
    215           f.preparation,
    216           'reviewed_self_recovery'
    217         );
    218       const receipt = s.preparedSelfRecovery(f.preparation),
    219         ack = receipt && s.selfRecoveryAcknowledgementSnapshot(receipt);
    220       const rows = JSON.parse(await f.stored()) as { wire: string }[],
    221         stored = JSON.parse(rows[0].wire) as { self: { wire: string } };
    222       return {
    223         status: result.status,
    224         hits: hits(),
    225         ack: Boolean(ack),
    226         exact: Boolean(ack && stored.self.wire === ack.self.wire),
    227         encrypts: f.counts().encrypts - before.encrypts,
    228         signs: f.counts().signs - before.signs
    229       };
    230     } finally {
    231       f.close();
    232     }
    233   });
    234   expect(result).toEqual({
    235     status: 'reconciled',
    236     hits: 1,
    237     ack: true,
    238     exact: true,
    239     encrypts: 1,
    240     signs: 1
    241   });
    242 });
    243 test('late encryption after actual Disconnect grants no receipt and cannot queue peer work', async ({
    244   page
    245 }) => {
    246   await load(page);
    247   const result = await page.evaluate(async () => {
    248     const f = window.hcp081Fixture,
    249       s = window.hcp081;
    250     try {
    251       f.mode('hold_encrypt');
    252       const pending = s.prepareSelfRecovery(
    253         f.preparation,
    254         'reviewed_self_recovery'
    255       );
    256       for (let i = 0; i < 1800 && !f.pendingEncryption(); i++)
    257         await new Promise((resolve) => setTimeout(resolve, 50));
    258       if (!f.pendingEncryption()) throw Error('encryption did not enter');
    259       const repeated = await s.prepareSelfRecovery(
    260         f.preparation,
    261         'reviewed_self_recovery'
    262       );
    263       f.disconnect();
    264       f.settle();
    265       const late = await pending;
    266       const rows = JSON.parse(await f.stored()) as { wire: string }[],
    267         stored = JSON.parse(rows[0].wire) as { family: string };
    268       return {
    269         repeated: repeated.status,
    270         late: late.status,
    271         receipt: Boolean(s.preparedSelfRecovery(f.preparation)),
    272         plaintext: (await f.stored()).includes(f.marker),
    273         family: stored.family
    274       };
    275     } finally {
    276       f.settle();
    277       f.close();
    278     }
    279   });
    280   expect(result).toEqual({
    281     repeated: 'busy',
    282     late: 'stopped',
    283     receipt: false,
    284     plaintext: false,
    285     family: 'private_send_reservation'
    286   });
    287 });
    288 test('a competing owner lock refuses preparation without prompts and permits only explicit later retry', async ({
    289   page
    290 }) => {
    291   await load(page);
    292   const result = await page.evaluate(async () => {
    293     const f = window.hcp081Fixture,
    294       s = window.hcp081;
    295     let release: (() => Promise<void>) | undefined;
    296     try {
    297       release = await f.holdOwner();
    298       const before = f.counts(),
    299         refused = await s.prepareSelfRecovery(
    300           f.preparation,
    301           'reviewed_self_recovery'
    302         ),
    303         unchanged = JSON.stringify(before) === JSON.stringify(f.counts());
    304       await release();
    305       release = undefined;
    306       const later = await s.prepareSelfRecovery(
    307         f.preparation,
    308         'reviewed_self_recovery'
    309       );
    310       return { refused: refused.status, unchanged, later: later.status };
    311     } finally {
    312       await release?.();
    313       f.close();
    314     }
    315   });
    316   expect(result).toEqual({ refused: 'busy', unchanged: true, later: 'saved' });
    317 });
    318 test('a new controller with existing self evidence requires explicit recovery instead of regenerating a wrapper', async ({
    319   page
    320 }) => {
    321   await load(page);
    322   const result = await page.evaluate(async () => {
    323     const f = window.hcp081Fixture,
    324       s = window.hcp081;
    325     try {
    326       await s.prepareSelfRecovery(f.preparation, 'reviewed_self_recovery');
    327       const second = s.captureSelfRecoveryPreparation(
    328         f.repository,
    329         f.identity,
    330         f.reserved,
    331         'reviewed_self_recovery'
    332       );
    333       if (!second) throw Error('missing second controller');
    334       const before = f.counts(),
    335         bytes = await f.stored(),
    336         result = await s.prepareSelfRecovery(second, 'reviewed_self_recovery');
    337       s.stopSelfRecoveryPreparation(second);
    338       return {
    339         status: result.status,
    340         unchanged: JSON.stringify(before) === JSON.stringify(f.counts()),
    341         bytes: bytes === (await f.stored())
    342       };
    343     } finally {
    344       f.close();
    345     }
    346   });
    347   expect(result).toEqual({
    348     status: 'recovery_required',
    349     unchanged: true,
    350     bytes: true
    351   });
    352 });
    353 test('a genuine peer envelope or foreign namespace cannot acknowledge a self recovery record', async ({
    354   page
    355 }) => {
    356   await load(page);
    357   const result = await page.evaluate(async () => {
    358     const f = window.hcp081Fixture,
    359       s = window.hcp081;
    360     try {
    361       const peer = await f.peerProof(),
    362         prior = await f.stored();
    363       const denied = await s.commitSelfRecovery(
    364         f.repository,
    365         f.identity,
    366         f.reserved,
    367         peer,
    368         'reviewed_self_commit'
    369       );
    370       const self = await f.selfProof();
    371       const foreign = await s.commitSelfRecovery(
    372         f.foreignRepository,
    373         f.identity,
    374         f.reserved,
    375         self,
    376         'reviewed_self_commit'
    377       );
    378       return {
    379         denied: denied.status,
    380         foreignAcknowledged: 'receipt' in foreign,
    381         unchanged: prior === (await f.stored()),
    382         ack: Boolean(s.preparedSelfRecovery(f.preparation))
    383       };
    384     } finally {
    385       f.close();
    386     }
    387   });
    388   expect(result).toEqual({
    389     denied: 'invalid',
    390     foreignAcknowledged: false,
    391     unchanged: true,
    392     ack: false
    393   });
    394 });
    395 test('unrecognized stored evidence is preserved and refuses crypto, reset and local acknowledgement', async ({
    396   page
    397 }) => {
    398   await load(page);
    399   const result = await page.evaluate(async () => {
    400     const f = window.hcp081Fixture,
    401       s = window.hcp081;
    402     try {
    403       await f.corruptReservation();
    404       const prior = await f.stored(),
    405         before = f.counts(),
    406         result = await s.prepareSelfRecovery(
    407           f.preparation,
    408           'reviewed_self_recovery'
    409         );
    410       return {
    411         status: result.status,
    412         unchanged: prior === (await f.stored()),
    413         counts: JSON.stringify(before) === JSON.stringify(f.counts()),
    414         receipt: Boolean(s.preparedSelfRecovery(f.preparation))
    415       };
    416     } finally {
    417       f.close();
    418     }
    419   });
    420   expect(result).toEqual({
    421     status: 'corrupt_record',
    422     unchanged: true,
    423     counts: true,
    424     receipt: false
    425   });
    426 });
    427 test('ending crypto preparation preserves the acknowledged local fact and revokes workflow peer permission', async ({
    428   page
    429 }) => {
    430   await load(page);
    431   const result = await page.evaluate(async () => {
    432     const f = window.hcp081Fixture,
    433       s = window.hcp081;
    434     try {
    435       await s.prepareSelfRecovery(f.preparation, 'reviewed_self_recovery');
    436       const receipt = s.preparedSelfRecovery(f.preparation);
    437       if (!receipt) throw Error('missing actual receipt');
    438       const pair = await s.selfRecoveryPeerPreparation(f.preparation, receipt);
    439       if (!pair) throw Error('missing acknowledged permission');
    440       const before = await f.stored();
    441       f.closePeerPreparation(pair);
    442       return {
    443         savedFact: Boolean(s.selfRecoveryAcknowledgementSnapshot(receipt)),
    444         workflow: Boolean(s.selfRecoveryPreparationSnapshot(f.preparation)),
    445         peer: Boolean(
    446           await s.selfRecoveryPeerPreparation(f.preparation, receipt)
    447         ),
    448         unchanged: before === (await f.stored())
    449       };
    450     } finally {
    451       f.close();
    452     }
    453   });
    454   expect(result).toEqual({
    455     savedFact: true,
    456     workflow: false,
    457     peer: false,
    458     unchanged: true
    459   });
    460 });