lib

Core libraries for Radroots
git clone https://radroots.dev/git/lib.git
Log | Files | Refs | README

delivery.mjs (15790B)


      1 import assert from 'node:assert/strict';
      2 
      3 export async function runDelivery(page, profile) {
      4   const result=await page.evaluate(async profile=>{
      5     const {default:init,WorkspaceFixture}=await import('./fixture.js');await init();
      6     const tests=[],passed=name=>{tests.push(name);console.log('PASS '+name);};
      7     const same=(a,b)=>{if(JSON.stringify(a)!==JSON.stringify(b))throw Error('assertion mismatch: '+JSON.stringify(a)+' / '+JSON.stringify(b));};
      8     const rejects=async(fn,code)=>{try{await fn();}catch(error){if(String(error)!==code)throw Error('expected '+code+', received '+String(error));return;}throw Error('expected refusal: '+code);};
      9     const kb=key=>Array.from(new Uint8Array(key));
     10     const rawOpen=r=>new Promise((resolve,reject)=>{const req=indexedDB.open(r.namespace,1);req.onupgradeneeded=()=>req.transaction.abort();req.onsuccess=()=>resolve(req.result);req.onerror=reject;});
     11     const rows=async r=>{const db=await rawOpen(r);try{return await new Promise((resolve,reject)=>{const tx=db.transaction('records','readonly'),store=tx.objectStore('records');let keys,values;store.getAllKeys().onsuccess=e=>keys=e.target.result;store.getAll().onsuccess=e=>values=e.target.result;tx.oncomplete=()=>resolve({keys,values});tx.onabort=reject;});}finally{db.close();}};
     12     const change=async(r,fn)=>{const db=await rawOpen(r);try{await new Promise((resolve,reject)=>{const tx=db.transaction('records','readwrite');fn(tx.objectStore('records'));tx.oncomplete=resolve;tx.onabort=reject;});}finally{db.close();}};
     13     const sameRows=(a,b)=>{same(a.keys.map(kb),b.keys.map(kb));same(a.values.map(kb),b.values.map(kb));};
     14     const restore=async(r,before)=>change(r,store=>{store.clear();before.keys.forEach((key,i)=>store.put(before.values[i],key));});
     15     const open=r=>WorkspaceFixture.open(r.n,new Uint8Array(r.fingerprint),new Uint8Array(r.selection),new Uint8Array(r.proof));
     16     const receipt=(owner,n)=>({n,fingerprint:Array.from(owner.fingerprint()),selection:Array.from(owner.selection()),proof:Array.from(owner.proof()),namespace:owner.data_namespace()});
     17     const setup=async(n,index=0,large=false)=>{const owner=await WorkspaceFixture.create(n+1);await owner.admit(n,false);const wire=await(large?owner.new_large_delivery_plan(n):owner.new_delivery_plan(n));await owner.bind_plan(n,wire);const seal=await owner.obtain(n,index,false);await owner.capture(seal);await owner.install(n);const envelope=await owner.envelope(n,index,0);return{owner,envelope,receipt:receipt(owner,n+1)};};
     18     const query=async(owner,n,index,id)=>JSON.parse(await owner.query_envelope(n,index,id));
     19     const store=async(s,n,id,selection=1,mode=0,envelope=s.envelope)=>JSON.parse(await s.owner.store_envelope(n,id,selection,mode,envelope));
     20     const key=async(n,kind,recipient=0,ordinal=0,part=0)=>{const digest=new Uint8Array(await crypto.subtle.digest('SHA-256',new Uint8Array([...new TextEncoder().encode('radroots.browser.local_outbox.operation.prefix.v2\0'),...new Uint8Array(32).fill(n)])));const raw=new Uint8Array(32);raw.set(digest.subarray(0,16));raw[16]=kind;raw[17]=recipient;new DataView(raw.buffer).setUint16(18,ordinal);raw[20]=part;return raw;};
     21     const put=IDBObjectStore.prototype.put,add=IDBObjectStore.prototype.add,abort=IDBTransaction.prototype.abort;
     22     const inject=(namespace,target,redirect)=>{
     23       IDBObjectStore.prototype.put=function(bytes,at){if(this.transaction.db.name===namespace&&JSON.stringify(kb(at))===JSON.stringify(kb(target))){const r=add.call(this,bytes,redirect??at);r.addEventListener('error',event=>event.preventDefault());return r;}return put.call(this,bytes,at);};
     24       IDBTransaction.prototype.abort=function(){if(this.db.name===namespace)return;return abort.call(this);};
     25     };
     26     const reset=()=>{IDBObjectStore.prototype.put=put;IDBTransaction.prototype.abort=abort;};
     27     try {
     28       if(profile==='delivery') {
     29         const n=210,s=await setup(n),before=await rows(s.receipt);
     30         const originalClaim=Array.from(await s.owner.attempt(n,0));same(await query(s.owner,n,0,1),null);await rejects(()=>store(s,n,1,1,16),'invalid_evidence');sameRows(await rows(s.receipt),before);
     31         passed('actual D absence is read without a transport invocation or replacement');
     32         const first=await store(s,n,1);same(first.kind,'claimed');same(first.report.raw,s.envelope.raw());same(first.report.event,s.envelope.event());same(first.report.targets.length,2);same(first.report.selection.length,1);same(first.report.ordinals,[1]);same(await query(s.owner,n,0,1),first.report);
     33         passed('actual D commit retains exact signed outer, original work, full policy and selected target before invocation');
     34         s.owner.set_time(1850);const random=Crypto.prototype.getRandomValues;
     35         try{Crypto.prototype.getRandomValues=()=>{throw Error('retained D acquired new entropy');};const replay=await store(s,n,1);same(replay.kind,'retained');same(replay.report,first.report);}
     36         finally{Crypto.prototype.getRandomValues=random;}
     37         passed('exact retained D replay after original delivery expiry preserves identity and never authorizes redispatch');
     38         s.owner.set_time(1600);const second=await store(s,n,2,2,16);same(second.kind,'claimed');same(second.report.raw,first.report.raw);same(second.report.policy,first.report.policy);same(second.report.ordinals,[1]);same(second.report.at,1600);if(second.report.transaction===first.report.transaction)throw Error('new D reused original transaction');
     39         passed('new selected-endpoint retry retains the original exact outer and policy after signing expiry with an independent ordinal');
     40         const stable=await rows(s.receipt);await rejects(()=>store(s,n,2,1,16),'idempotency_conflict');await rejects(()=>store(s,n,3,1,5),'idempotency_conflict');sameRows(await rows(s.receipt),stable);
     41         passed('retained request conflicts and changed original publication criterion refuse without writes');
     42         const another=await s.owner.envelope(n,0,0),third=await store(s,n,3,1,0,another);same(third.kind,'claimed');same(third.report.ordinals,[2]);if(third.report.event===first.report.event)throw Error('independent wrap reused its original event');
     43         const snapshot=JSON.parse(await s.owner.snapshot(n));same(snapshot.deliveries,3);same(snapshot.observations,0);same(snapshot.publications.length,1);same(snapshot.message.text,'\u0001'.repeat(3000));same(Array.from(await s.owner.attempt(n,0)),originalClaim);await s.owner.close();
     44         passed('fresh wrapping of the original obtained seal advances only selected transport attempts while retaining one logical message');
     45         const peerN=212,peer=await setup(peerN,1);await store(peer,peerN,1);const self=await peer.owner.obtain(peerN,0,false);await peer.owner.capture(self);await peer.owner.install(peerN);const progress=JSON.parse(await peer.owner.snapshot(peerN));same(progress.publications.length,2);same(progress.deliveries,1);await peer.owner.close();
     46         passed('actual first self claim remains legal after peer delivery retention without replacing original peer work');
     47         return{tests,receipt:s.receipt,operation:n,index:0,id:1,golden:first.report};
     48       }
     49       if(profile==='delivery_limits') {
     50         const n=214,s=await setup(n);let first;
     51         for(let id=1;id<=12;id++){const value=await store(s,n,id,1,id===1?0:16);same(value.kind,'claimed');same(value.report.ordinals,[id]);first??=value.report;same(value.report.raw,first.raw);}
     52         const exhausted=await rows(s.receipt);await rejects(()=>store(s,n,13,1,16),'delivery_attempt_limit');sameRows(await rows(s.receipt),exhausted);
     53         passed('all twelve actual selected-endpoint invocations retain contiguous ordinals and the thirteenth is refused');
     54         const other=await store(s,n,14,2,16);same(other.report.ordinals,[1]);same(other.report.raw,first.raw);same(other.report.policy,first.policy);same((await store(s,n,1)).kind,'retained');await s.owner.close();
     55         passed('an exhausted endpoint does not consume another endpoint budget or change the original completion policy');
     56         const largeN=216,large=await setup(largeN,0,true),value=await store(large,largeN,1,32768,6);same(value.kind,'claimed');same(value.report.targets.length,16);same(value.report.selection.length,1);same(value.report.ordinals,[1]);
     57         const actual=await rows(large.receipt),parts=actual.keys.map(kb).filter(key=>key[16]===7&&key[20]>0);if(parts.length<2||parts.length>24)throw Error('actual valid long-target frame did not exercise bounded multipart storage');same(actual.keys.map(kb).filter(key=>key[16]===9).length,1);same(await query(large.owner,largeN,0,1),value.report);await large.owner.close();
     58         passed('actual sixteen-target policy and last-target selection span protected private parts with one matching request index');
     59         return{tests};
     60       }
     61       if(profile==='delivery_corruption') {
     62         const n=218,s=await setup(n);await store(s,n,1);await store(s,n,2,2,16);await s.owner.close();const stable=await rows(s.receipt);
     63         const at=(kind,ordinal,part)=>stable.keys.find(k=>{const bytes=kb(k);return bytes[16]===kind&&bytes[18]===0&&bytes[19]===ordinal&&bytes[20]===part;});
     64         for(const mode of ['manifest','part','index','tampered','foreign_index','t2_loss','all_predecessors']) {
     65           await change(s.receipt,store=>{
     66             if(mode==='manifest')store.delete(at(7,1,0));if(mode==='part')store.delete(at(7,1,1));if(mode==='index')store.delete(at(9,1,0));
     67             if(mode==='tampered'){const selected=at(7,1,1),i=stable.keys.indexOf(selected),raw=new Uint8Array(stable.values[i]);raw[raw.length-1]^=1;store.put(raw,selected);}
     68             if(mode==='foreign_index')store.put(stable.values[stable.keys.indexOf(at(9,2,0))],at(9,1,0));
     69             if(mode==='t2_loss'||mode==='all_predecessors')stable.keys.filter(k=>(mode==='all_predecessors'?[3,4,5,6]:[5,6]).includes(kb(k)[16])).forEach(k=>store.delete(k));
     70           });
     71           const damaged=await rows(s.receipt);let current=await open(s.receipt);await rejects(()=>query(current,n,0,1),'recovery_required');await current.close();
     72           current=await open(s.receipt);await rejects(()=>current.install(n),'recovery_required');await current.close();
     73           if(mode==='all_predecessors'){current=await open(s.receipt);await rejects(()=>current.claim(n,0),'recovery_required');await current.close();}
     74           sameRows(await rows(s.receipt),damaged);await restore(s.receipt,stable);
     75           passed('actual '+mode+' D damage refuses original query and predecessor replacement with exact damaged bytes preserved');
     76         }
     77         return{tests};
     78       }
     79       if(profile==='delivery_faults') {
     80         const n=220,s=await setup(n),initial=await rows(s.receipt);
     81         for(const mode of [1,2,3]){const invalid=await s.owner.envelope(n,0,mode);await rejects(()=>store(s,n,1,1,0,invalid),'invalid_evidence');}
     82         await rejects(()=>store(s,n,1,1,4),'unverified_approval');sameRows(await rows(s.receipt),initial);
     83         passed('actual valid outer signatures with wrong key, wrong contained seal, participant author or unapproved relay cannot create D facts');
     84         for(const [mode,code] of [[1,'workspace_unavailable'],[2,'grant_expired'],[3,'deadline_exceeded']]){await rejects(()=>store(s,n,1,1,mode),code);await s.owner.close();sameRows(await rows(s.receipt),initial);s.owner=await open(s.receipt);}
     85         s.owner.set_time(1000);
     86         passed('actual D callback rechecks clock, grant and original delivery deadline after crypto and before mutations');
     87         let written=false;const manifest=await key(n,7,0,1,0);
     88         try{IDBObjectStore.prototype.put=function(bytes,at){const request=put.call(this,bytes,at);if(this.transaction.db.name===s.receipt.namespace&&JSON.stringify(kb(at))===JSON.stringify(kb(manifest)))request.addEventListener('success',()=>{written=true;this.transaction.abort();},{once:true});return request;};await rejects(()=>store(s,n,1),'storage_failure');}
     89         finally{reset();}
     90         same(written,true);sameRows(await rows(s.receipt),initial);same((await store(s,n,1)).kind,'claimed');await s.owner.close();
     91         passed('actual frame-write success followed by abort retains no D fact and a known-rollback retry uses the caller original');
     92         const unknownN=222,unknown=await setup(unknownN),unchanged=await key(unknownN,1,0,0,1);let anchor;
     93         try{anchor=JSON.parse(await unknown.owner.store_envelope_unknown(unknownN,1,1,unknown.envelope,()=>inject(unknown.receipt.namespace,unchanged)));}
     94         finally{reset();}
     95         same(anchor.kind,'unknown');same(anchor.request,'01'.repeat(32));if(!anchor.transaction)throw Error('uncertain D lost its original transaction');await unknown.owner.close();let reopened=await open(unknown.receipt);const retained=await query(reopened,unknownN,0,1);same(retained.transaction,anchor.transaction);same(retained.raw,unknown.envelope.raw());await reopened.close();
     96         passed('actual unexpected completion preserves original D uncertainty and reopens the exact committed frame and transaction');
     97         const partialN=224,partial=await setup(partialN),failedIndex=await key(partialN,9,0,1),oldT0=await key(partialN,1,0,0,1);
     98         try{anchor=JSON.parse(await partial.owner.store_envelope_unknown(partialN,1,1,partial.envelope,()=>inject(partial.receipt.namespace,failedIndex,oldT0)));}
     99         finally{reset();}
    100         same(anchor.kind,'unknown');if(!anchor.transaction)throw Error('partial D lost original transaction');await partial.owner.close();const damaged=await rows(partial.receipt);reopened=await open(partial.receipt);await rejects(()=>query(reopened,partialN,0,1),'recovery_required');await reopened.close();sameRows(await rows(partial.receipt),damaged);
    101         passed('actual partial D completion with a missing request index is retained as unknown and cannot become absence or replacement');
    102         const cancelN=226,cancel=await setup(cancelN);await cancel.owner.abandon_envelope(cancelN,1,1,cancel.envelope);cancel.envelope.free();cancel.owner.abandon_close();await cancel.owner.close();reopened=await open(cancel.receipt);const completed=await query(reopened,cancelN,0,1);if(!completed)throw Error('lost observer discarded accepted original D input');await reopened.close();
    103         passed('accepted D owns its bounded candidate through observer loss, original disposal and cancelled close');
    104         return{tests};
    105       }
    106       throw Error('unknown delivery profile');
    107     } finally {reset();}
    108   },profile);
    109   if(result.receipt) {
    110     const message={kind:'delivery_query',...result.receipt,operation:result.operation,index:result.index,id:result.id};
    111     const worker=await page.evaluate(message=>new Promise((resolve,reject)=>{const worker=new Worker('./worker.js',{type:'module'});worker.onmessage=e=>{if(e.data.ready){worker.postMessage(message);return;}worker.terminate();resolve(e.data);};worker.onerror=error=>{worker.terminate();reject(Error(error.message));};}),message);
    112     assert.deepEqual(worker,{report:result.golden});result.tests.push('actual worker termination and fresh WASM preserve the exact original D report');
    113     await page.reload();
    114     const report=await page.evaluate(async r=>{const{default:init,WorkspaceFixture}=await import('./fixture.js');await init();const owner=await WorkspaceFixture.open(r.receipt.n,new Uint8Array(r.receipt.fingerprint),new Uint8Array(r.receipt.selection),new Uint8Array(r.receipt.proof));const report=JSON.parse(await owner.query_envelope(r.operation,r.index,r.id));await owner.close();return report;},result);
    115     assert.deepEqual(report,result.golden);result.tests.push('actual page and WASM restart preserve original D bytes, policy, selection and transaction');
    116     delete result.receipt;delete result.golden;
    117   }
    118   return result;
    119 }