lib

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

journal.mjs (17157B)


      1 import assert from 'node:assert/strict';
      2 
      3 export async function runJournal(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 receipt=(owner,n)=>({n,fingerprint:Array.from(owner.fingerprint()),selection:Array.from(owner.selection()),proof:Array.from(owner.proof()),namespace:owner.data_namespace()});
     11     const open=(r,capture=false)=>(capture?WorkspaceFixture.open_capture:WorkspaceFixture.open)(r.n,new Uint8Array(r.fingerprint),new Uint8Array(r.selection),new Uint8Array(r.proof));
     12     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;});
     13     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();}};
     14     const sameRows=(a,b)=>{same(a.keys.map(kb),b.keys.map(kb));same(a.values.map(kb),b.values.map(kb));};
     15     const plan=async(owner,n)=>{await owner.admit(n,false);await owner.bind_plan(n,await owner.new_delivery_plan(n));return owner.obtain(n,0,false);};
     16     const setup=async n=>{const owner=await WorkspaceFixture.create(n+1),seal=await plan(owner,n);return{owner,seal,receipt:receipt(owner,n+1)};};
     17     const nativePut=IDBObjectStore.prototype.put,nativeAdd=IDBObjectStore.prototype.add,nativeAbort=IDBTransaction.prototype.abort,nativeClose=IDBDatabase.prototype.close,nativeOpen=IDBFactory.prototype.open;
     18     const reset=()=>{IDBObjectStore.prototype.put=nativePut;IDBTransaction.prototype.abort=nativeAbort;IDBDatabase.prototype.close=nativeClose;IDBFactory.prototype.open=nativeOpen;};
     19     const inject=(namespace,key,redirect)=>{
     20       IDBObjectStore.prototype.put=function(bytes,at){if(this.transaction.db.name===namespace&&JSON.stringify(kb(at))===JSON.stringify(kb(key))){const req=nativeAdd.call(this,bytes,redirect??at);req.addEventListener('error',event=>event.preventDefault());return req;}return nativePut.call(this,bytes,at);};
     21       IDBTransaction.prototype.abort=function(){if(this.db.name===namespace)return;return nativeAbort.call(this);};
     22     };
     23     const unknownSeal=async s=>{const prefix=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(s.receipt.n-1)]))).slice(0,16),all=await rows(s.receipt),at=all.keys.find(k=>kb(k)[16]===1&&kb(k)[20]===1&&kb(k).slice(0,16).every((byte,index)=>byte===prefix[index]));if(!at)throw Error('missing original operation fault target');try{inject(s.receipt.namespace,at);return Array.from(await s.owner.capture_unknown(s.seal));}finally{reset();}};
     24     const setupDelivery=async n=>{const s=await setup(n);await s.owner.capture(s.seal);await s.owner.install(n);s.envelope=await s.owner.envelope(n,0,0);await s.owner.store_envelope(n,1,3,0,s.envelope);return s;};
     25     const faultTarget=async s=>(await rows(s.receipt)).keys.find(k=>kb(k)[16]===1&&kb(k)[20]===1);
     26     const unknownObservation=async(s,value)=>{const at=await faultTarget(s);try{return JSON.parse(await s.owner.retain_observation_unknown(value,()=>inject(s.receipt.namespace,at)));}finally{reset();}};
     27     try {
     28       if(profile==='journal') {
     29         const n=200,s=await setup(n),anchor=await unknownSeal(s);await rejects(()=>s.owner.authenticate(),'closed');const stable=await rows(s.receipt);let closes=0,opens=0;
     30         try{IDBDatabase.prototype.close=function(){if(this.name===s.receipt.namespace)closes++;return nativeClose.call(this);};IDBFactory.prototype.open=function(...args){if(args[0]===s.receipt.namespace)opens++;return nativeOpen.apply(this,args);};await rejects(()=>s.owner.reconcile(s.seal,true),'unauthorized');same(closes,0);same(opens,0);}finally{reset();}
     31         sameRows(await rows(s.receipt),stable);await rejects(()=>open(s.receipt,true),'writer_active');
     32         passed('actual uncertain shared journal refuses ordinary admission and wrong-proof recovery without disposing its original connection or writer');
     33         let contender,opened=false,original;
     34         try{IDBFactory.prototype.open=function(...args){if(args[0]===s.receipt.namespace&&!opened){opened=true;contender=open(s.receipt,true).then(()=> 'unexpected_writer',error=>String(error));}return nativeOpen.apply(this,args);};original=Array.from(await s.owner.reconcile(s.seal,false));same(original.slice(0,32),anchor.slice(64,96));same(Array.from(await s.owner.captured_original(s.seal)),original);same(opened,true);same(await contender,'writer_active');same(await s.owner.authenticate(),1);}finally{reset();}
     35         sameRows(await rows(s.receipt),stable);await s.owner.close();
     36         passed('actual shared-trait reconciliation closes and reopens under the same retained writer and confirms the original capture transaction and bytes');
     37         const otherN=202,other=await setup(otherN),older=await plan(other.owner,otherN+2);await other.owner.capture(older);await unknownSeal(other);await other.owner.reconcile(older,false);await rejects(()=>other.owner.authenticate(),'closed');await other.owner.reconcile(other.seal,false);same(await other.owner.authenticate(),1);await other.owner.close();
     38         passed('confirming an unrelated older seal cannot clear the original uncertain capture identity');
     39         const lateN=206,late=await setup(lateN);await late.owner.revoke();late.owner.set_time(0);const lateAnchor=await unknownSeal(late),confirmed=Array.from(await late.owner.reconcile(late.seal,false));same(confirmed.slice(0,32),lateAnchor.slice(64,96));await late.owner.close();
     40         passed('actual original-proof reconciliation retains revoked and unavailable-clock obtained material without fresh authority');
     41         const cancelN=208,cancel=await setup(cancelN);await unknownSeal(cancel);cancel.owner.abandon_reconcile(cancel.seal);cancel.seal.free();cancel.owner.abandon_close();await cancel.owner.close();const reopened=await open(cancel.receipt);if((await reopened.captured(cancelN,0)).length===0)throw Error('cancelled recovery discarded original obtained bytes');await reopened.close();
     42         passed('accepted same-owner recovery survives lost observation and original disposal while final close drains before releasing the writer');
     43         return{tests,receipt:s.receipt,operation:n,golden:original};
     44       }
     45       if(profile==='journal_observations') {
     46         const n=210,s=await setupDelivery(n),original=await s.owner.observation(n,0,1,0,1,0),later=await s.owner.observation(n,0,1,0,1,1000100),other=await s.owner.observation(n,0,1,0,3,1000200),expected=JSON.parse(original.original());same((await unknownObservation(s,original)).report,expected);await rejects(()=>s.owner.authenticate(),'closed');await rejects(()=>s.owner.retain_observation(original,true),'unauthorized');
     47         same(JSON.parse(await s.owner.retain_observation(other,false)).kind,'committed');await rejects(()=>s.owner.authenticate(),'closed');same(JSON.parse(await s.owner.retain_observation(later,false)).report,expected);same(await s.owner.authenticate(),1);const actual=JSON.parse(await s.owner.query_observations(n,0,1));same(actual.length,2);same(actual.find(value=>value.class===1),expected);await s.owner.close();
     48         passed('actual same-owner target recovery preserves first details and unknown time while another outcome class cannot clear the original uncertainty');
     49         const missingN=212,missing=await setupDelivery(missingN),value=await missing.owner.observation(missingN,0,1,0,5,0),before=await rows(missing.receipt),old=await faultTarget(missing),target=new Uint8Array(before.keys.find(k=>kb(k)[16]===7&&kb(k)[20]===0));target[16]=8;target[21]=0;target[22]=5;let result;
     50         try{result=JSON.parse(await missing.owner.retain_observation_unknown(value,()=>inject(missing.receipt.namespace,target,old)));}finally{reset();}same(result.kind,'unknown');same((await rows(missing.receipt)).keys.filter(k=>kb(k)[16]===8).length,0);same(JSON.parse(await missing.owner.retain_observation(value,false)).report,JSON.parse(value.original()));same(await missing.owner.authenticate(),1);same(JSON.parse(await missing.owner.query_observations(missingN,0,1)),[result.report]);await missing.owner.close();
     51         passed('actual same-owner reconciliation recaptures the exact obtained observation after unexpected completion omitted its row');
     52         const lateN=214,late=await setupDelivery(lateN),lateValue=await late.owner.observation(lateN,0,1,0,4,0);await late.owner.revoke();late.owner.set_time(0);await unknownObservation(late,lateValue);same(JSON.parse(await late.owner.retain_observation(lateValue,false)).report,JSON.parse(lateValue.original()));await late.owner.close();
     53         passed('actual same-owner target recovery uses retained proof despite revocation and an unavailable clock');
     54         const generalN=216,general=await setupDelivery(generalN),oldValue=await general.owner.observation(generalN,0,1,0,1,0),unchanged=await faultTarget(general);
     55         try{result=JSON.parse(await general.owner.store_envelope_unknown(generalN,2,1,general.envelope,()=>inject(general.receipt.namespace,unchanged)));}finally{reset();}same(result.kind,'unknown');same(JSON.parse(await general.owner.retain_observation(oldValue,false)).kind,'committed');await rejects(()=>general.owner.authenticate(),'closed');await general.owner.close();let reopened=await open(general.receipt);same(JSON.parse(await reopened.query_observations(generalN,0,1)),[JSON.parse(oldValue.original())]);await reopened.close();
     56         passed('retaining an older obtained fact cannot clear general delivery uncertainty or authorize fresh work');
     57         const multipleN=218,multiple=await setupDelivery(multipleN),a=await multiple.owner.observation(multipleN,0,1,0,1,0),b=await multiple.owner.observation(multipleN,0,1,1,2,0);same((await unknownObservation(multiple,a)).kind,'unknown');same((await unknownObservation(multiple,b)).kind,'unknown');await multiple.owner.retain_observation(a,false);await rejects(()=>multiple.owner.authenticate(),'closed');await multiple.owner.retain_observation(b,false);await rejects(()=>multiple.owner.authenticate(),'closed');await multiple.owner.close();reopened=await open(multiple.receipt);same(JSON.parse(await reopened.query_observations(multipleN,0,1)).length,2);await reopened.close();
     58         passed('multiple unrelated uncertain target captures require explicit reopening even when each original fact is subsequently confirmed');
     59         return{tests};
     60       }
     61       if(profile==='journal_reopen') {
     62         const n=180,s=await setup(n),anchor=await unknownSeal(s),stable=await rows(s.receipt);let upgraded=false;
     63         try{IDBFactory.prototype.open=function(...args){if(args[0]===s.receipt.namespace&&!upgraded){upgraded=true;const upgrade=nativeOpen.call(this,args[0],2);upgrade.onupgradeneeded=()=>upgrade.result.createObjectStore('foreign_fixture');upgrade.onsuccess=()=>upgrade.result.close();}return nativeOpen.apply(this,args);};await rejects(()=>s.owner.reconcile(s.seal,false),'recovery_required');}finally{reset();}
     64         same(upgraded,true);
     65         const actual=await new Promise((resolve,reject)=>{const request=indexedDB.open(s.receipt.namespace);request.onerror=reject;request.onsuccess=async()=>{const db=request.result;try{const state=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;});resolve({version:db.version,stores:Array.from(db.objectStoreNames),...state});}catch(error){reject(error);}finally{db.close();}};});same(actual.version,2);same(actual.stores,['foreign_fixture','records']);sameRows(actual,stable);await rejects(()=>open(s.receipt,true),'writer_active');let opened=0;
     66         try{IDBFactory.prototype.open=function(...args){if(args[0]===s.receipt.namespace)opened++;return nativeOpen.apply(this,args);};await rejects(()=>s.owner.reconcile(s.seal,true),'unauthorized');same(opened,0);}finally{reset();}
     67         passed('actual incompatible existing schema refuses recovery without repair, preserves protected rows and retains writer and original-proof authorization');
     68         // This restores only an isolated test database after verifying refusal.
     69         // The SDK never creates, repairs, downgrades or restores the namespace.
     70         await new Promise((resolve,reject)=>{const request=indexedDB.deleteDatabase(s.receipt.namespace);request.onsuccess=resolve;request.onerror=reject;request.onblocked=()=>reject(Error('fixture namespace deletion blocked'));});
     71         await new Promise((resolve,reject)=>{const request=indexedDB.open(s.receipt.namespace,1);request.onupgradeneeded=()=>request.result.createObjectStore('records');request.onerror=reject;request.onsuccess=()=>{const db=request.result,tx=db.transaction('records','readwrite'),store=tx.objectStore('records');stable.keys.forEach((key,i)=>store.put(stable.values[i],key));tx.oncomplete=()=>{db.close();resolve();};tx.onabort=()=>{db.close();reject(Error('fixture original restoration aborted'));};};});
     72         const restored=Array.from(await s.owner.reconcile(s.seal,false));same(restored.slice(0,32),anchor.slice(64,96));same(await s.owner.authenticate(),1);sameRows(await rows(s.receipt),stable);await s.owner.close();
     73         passed('cached original grant authorization permits same-owner retry after failed reopen only when the isolated original schema and bytes are restored');
     74         const damagedN=182,damaged=await setup(damagedN);await unknownSeal(damaged);const intact=await rows(damaged.receipt),claim=intact.keys.find(k=>kb(k)[16]===3);let db=await rawOpen(damaged.receipt);await new Promise((resolve,reject)=>{const tx=db.transaction('records','readwrite');tx.objectStore('records').delete(claim);tx.oncomplete=resolve;tx.onabort=reject;});db.close();const broken=await rows(damaged.receipt);await rejects(()=>damaged.owner.reconcile(damaged.seal,false),'recovery_required');sameRows(await rows(damaged.receipt),broken);await rejects(()=>damaged.owner.authenticate(),'closed');await rejects(()=>open(damaged.receipt,true),'writer_active');
     75         passed('actual missing original claim cannot become capture authority or replacement during same-owner recovery');
     76         db=await rawOpen(damaged.receipt);await new Promise((resolve,reject)=>{const tx=db.transaction('records','readwrite'),store=tx.objectStore('records');intact.keys.forEach((key,i)=>store.put(intact.values[i],key));tx.oncomplete=resolve;tx.onabort=reject;});db.close();await damaged.owner.reconcile(damaged.seal,false);same(await damaged.owner.authenticate(),1);sameRows(await rows(damaged.receipt),intact);await damaged.owner.close();
     77         passed('failed original-claim validation retains uncertainty and writer until the actual original capture can be confirmed');
     78         return{tests};
     79       }
     80       throw Error('journal profile is not implemented yet');
     81     } finally {reset();}
     82   },profile);
     83   if(result.receipt) {
     84     const message={kind:'recovered_query',...result.receipt,operation:result.operation};
     85     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);
     86     assert.deepEqual(worker,{captured:result.golden});result.tests.push('actual worker termination and fresh WASM preserve the exact reconciled original capture');
     87     await page.reload();const captured=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 captured=Array.from(await owner.captured(r.operation,0));await owner.close();return captured;},result);
     88     assert.deepEqual(captured,result.golden);result.tests.push('actual page and WASM restart preserve original reconciled transaction, representation digest and unknown observation time');delete result.receipt;delete result.golden;
     89   }
     90   assert(result.tests.length>0);return result;
     91 }