observations.mjs (14600B)
1 import assert from 'node:assert/strict'; 2 3 export async function runObservations(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,capture=false)=>(capture?WorkspaceFixture.open_capture: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,selection=1)=>{const owner=await WorkspaceFixture.create(n+1);await owner.admit(n,false);await owner.bind_plan(n,await owner.new_delivery_plan(n));const seal=await owner.obtain(n,0,false);await owner.capture(seal);await owner.install(n);const envelope=await owner.envelope(n,0,0);await owner.store_envelope(n,1,selection,0,envelope);return{owner,envelope,receipt:receipt(owner,n+1)};}; 18 const query=async(owner,n,id=1)=>JSON.parse(await owner.query_observations(n,0,id)); 19 const retain=async(s,original)=>JSON.parse(await s.owner.retain_observation(original,false)); 20 const put=IDBObjectStore.prototype.put,add=IDBObjectStore.prototype.add,abort=IDBTransaction.prototype.abort; 21 const reset=()=>{IDBObjectStore.prototype.put=put;IDBTransaction.prototype.abort=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 req=add.call(this,bytes,redirect??at);req.addEventListener('error',event=>event.preventDefault());return req;}return put.call(this,bytes,at);}; 24 IDBTransaction.prototype.abort=function(){if(this.db.name===namespace)return;return abort.call(this);}; 25 }; 26 try { 27 if(profile==='observations') { 28 const n=230,s=await setup(n,3),empty=await rows(s.receipt);same(await query(s.owner,n),[]);sameRows(await rows(s.receipt),empty); 29 passed('actual target observation query preserves absence without inventing an acknowledgement'); 30 const first=await s.owner.observation(n,0,1,0,1,0),later=await s.owner.observation(n,0,1,0,1,1000100),expected=JSON.parse(first.original()); 31 await rejects(()=>s.owner.retain_observation(first,true),'unauthorized');sameRows(await rows(s.receipt),empty); 32 const saved=await retain(s,first);same(saved.kind,'committed');same(saved.report,expected);same(expected.at,null);same(expected.ordinal,1);same(expected.attempted,true);same(await query(s.owner,n),[expected]); 33 passed('actual observation commit requires original proof and preserves exact linkage, absent time and normalized details'); 34 const before=await rows(s.receipt),random=Crypto.prototype.getRandomValues; 35 try{Crypto.prototype.getRandomValues=()=>{throw Error('exact observation replay used new entropy');};same((await retain(s,later)).report,expected);}finally{Crypto.prototype.getRandomValues=random;} 36 sameRows(await rows(s.receipt),before); 37 passed('first original class observation remains byte-identical when replay supplies a different time and details'); 38 for(const kind of [2,3,4,5,6]){const value=await s.owner.observation(n,0,1,0,kind,1000000+kind);same((await retain(s,value)).report,JSON.parse(value.original()));} 39 const classes=await query(s.owner,n);same(classes.length,6);same(classes.map(value=>value.class),[1,2,3,4,5,6]);same(classes[5].attempted,false);same(classes[0],expected); 40 passed('all six actual protected outcome classes append independently without erasing earlier acceptance'); 41 const accepted=await s.owner.observation(n,0,1,1,1,1000100);await retain(s,accepted);const snapshot=JSON.parse(await s.owner.snapshot(n));same(snapshot.observations,7);same(snapshot.deliveries,1);same(snapshot.publications.length,1); 42 passed('coherent actual snapshot retains per-target observations alongside the original message, work and D attempt'); 43 const alternate=s.owner.alternate_envelope(s.envelope),stable=await rows(s.receipt);same(alternate.event(),s.envelope.event());if(alternate.raw()===s.envelope.raw())throw Error('alternate fixture signature unchanged');await rejects(()=>s.owner.store_envelope(n,2,1,0,alternate),'idempotency_conflict');sameRows(await rows(s.receipt),stable); 44 passed('independently valid alternate signed outer representation with the same event ID cannot replace retained bytes'); 45 const golden=await query(s.owner,n);await s.owner.close();return{tests,receipt:s.receipt,operation:n,index:0,id:1,golden}; 46 } 47 if(profile==='observation_faults') { 48 const n=232,s=await setup(n),original=await s.owner.observation(n,0,1,0,2,0),expected=JSON.parse(original.original()),before=await rows(s.receipt); 49 let written=false; 50 try{IDBObjectStore.prototype.put=function(bytes,key){const req=put.call(this,bytes,key);if(this.transaction.db.name===s.receipt.namespace&&kb(key)[16]===8)req.addEventListener('success',()=>{written=true;this.transaction.abort();},{once:true});return req;};await rejects(()=>retain(s,original),'storage_failure');}finally{reset();} 51 same(written,true);sameRows(await rows(s.receipt),before);same((await retain(s,original)).report,expected); 52 passed('actual observation write success followed by abort rolls back and preserves the caller original for retry'); 53 const late=await s.owner.observation(n,0,1,0,3,1000200),captureOnly=await s.owner.observation(n,0,1,0,5,0);s.owner.set_time(2500);same((await retain(s,late)).kind,'committed');await rejects(()=>s.owner.query_observation_scope(late),'grant_expired');await s.owner.close(); 54 s.owner=await open(s.receipt,true);s.owner.set_time(0);same((await retain(s,captureOnly)).report,JSON.parse(captureOnly.original()));const lateUnknown=await s.owner.retain_observation(late,false);same(JSON.parse(lateUnknown).report,JSON.parse(late.original()));await rejects(()=>s.owner.query_observation_scope(late),'unauthorized');await rejects(()=>s.owner.authenticate(),'unauthorized');await s.owner.close(); 55 passed('expired and unavailable-clock capture-only owners retain original obtained target evidence without fresh access'); 56 const revokedN=234,revoked=await setup(revokedN),observed=await revoked.owner.observation(revokedN,0,1,0,4,1000300);await revoked.owner.revoke();same((await retain(revoked,observed)).kind,'committed');await revoked.owner.close();revoked.owner=await open(revoked.receipt,true);same((await retain(revoked,observed)).report,JSON.parse(observed.original()));await rejects(()=>revoked.owner.authenticate(),'unauthorized');await revoked.owner.close(); 57 passed('revocation cannot discard obtained evidence authenticated against the actual original D attempt'); 58 const unknownN=236,unknown=await setup(unknownN),value=await unknown.owner.observation(unknownN,0,1,0,5,0),all=await rows(unknown.receipt),unchanged=all.keys.find(k=>kb(k)[16]===1&&kb(k)[20]===1);let result; 59 try{result=JSON.parse(await unknown.owner.retain_observation_unknown(value,()=>inject(unknown.receipt.namespace,unchanged)));}finally{reset();} 60 same(result.kind,'unknown');same(result.report,JSON.parse(value.original()));await unknown.owner.close();let reopened=await open(unknown.receipt);same(await query(reopened,unknownN),[result.report]);await reopened.close(); 61 passed('actual unexpected transaction completion returns the original uncertain observation and reconciliation reads the actual retained fact'); 62 const partialN=242,partial=await setup(partialN),partialValue=await partial.owner.observation(partialN,0,1,0,5,0),partialRows=await rows(partial.receipt),old=partialRows.keys.find(k=>kb(k)[16]===1&&kb(k)[20]===1),target=new Uint8Array(partialRows.keys.find(k=>kb(k)[16]===7&&kb(k)[20]===0));target[16]=8;target[21]=0;target[22]=5; 63 try{result=JSON.parse(await partial.owner.retain_observation_unknown(partialValue,()=>inject(partial.receipt.namespace,target,old)));}finally{reset();} 64 same(result.kind,'unknown');same(result.report,JSON.parse(partialValue.original()));await partial.owner.close();reopened=await open(partial.receipt);same(await query(reopened,partialN),[]);same(JSON.parse(await reopened.retain_observation(partialValue,false)).report,result.report);same(await query(reopened,partialN),[result.report]);await reopened.close(); 65 passed('actual incomplete observation retention stays unknown until exact query and recapture confirm the caller original without redispatch'); 66 const cancelN=238,cancel=await setup(cancelN),cancelled=await cancel.owner.observation(cancelN,0,1,0,6,0),golden=JSON.parse(cancelled.original());cancel.owner.abandon_observation(cancelled);cancelled.free();cancel.owner.abandon_close();await cancel.owner.close();reopened=await open(cancel.receipt);same(await query(reopened,cancelN),[golden]);await reopened.close(); 67 passed('accepted observation owns bounded input through lost observer, original disposal and cancelled close'); 68 return{tests}; 69 } 70 if(profile==='observation_corruption') { 71 const n=240,s=await setup(n);await s.owner.store_envelope(n,2,2,16,s.envelope);const a=await s.owner.observation(n,0,1,0,1,0),b=await s.owner.observation(n,0,2,1,2,1000000);await retain(s,a);await retain(s,b); 72 await rejects(()=>s.owner.observation(n,0,1,1,1,0),'invalid_evidence');await rejects(()=>s.owner.observation(n,0,1,0,7,0),'invalid_evidence');await s.owner.close();const stable=await rows(s.receipt); 73 passed('shared checked normalized data refuses unselected targets and recipient-delivered meaning for relay outcomes'); 74 const found=(family,ordinal)=>stable.keys.find(k=>kb(k)[16]===family&&kb(k)[19]===ordinal),observation=found(8,1),other=found(8,2),original=stable.values[stable.keys.indexOf(observation)]; 75 for(const mode of ['tampered','foreign_attempt','unselected_target','changed_class','missing_D','missing_T2','missing_S']) { 76 await change(s.receipt,store=>{ 77 if(mode==='tampered'){const bytes=new Uint8Array(original);bytes[bytes.length-1]^=1;store.put(bytes,observation);} 78 if(mode==='foreign_attempt')store.put(stable.values[stable.keys.indexOf(other)],observation); 79 if(mode==='unselected_target'||mode==='changed_class'){const key=new Uint8Array(observation);key[mode==='changed_class'?22:21]=mode==='changed_class'?2:1;store.delete(observation);store.put(original,key);} 80 if(mode==='missing_D')stable.keys.filter(k=>[7,9].includes(kb(k)[16])&&kb(k)[19]===1).forEach(k=>store.delete(k)); 81 if(mode==='missing_T2'||mode==='missing_S')stable.keys.filter(k=>(mode==='missing_T2'?[5,6]:[3,4]).includes(kb(k)[16])).forEach(k=>store.delete(k)); 82 }); 83 const damaged=await rows(s.receipt);let owner=await open(s.receipt);await rejects(()=>query(owner,n),'recovery_required');await owner.close();owner=await open(s.receipt);await rejects(()=>owner.install(n),'recovery_required');await owner.close();owner=await open(s.receipt);await rejects(()=>owner.retain_observation(a,false),'recovery_required');await owner.close();if(mode==='missing_S'){owner=await open(s.receipt);await rejects(()=>owner.claim(n,0),'recovery_required');await owner.close();}sameRows(await rows(s.receipt),damaged);await restore(s.receipt,stable); 84 passed('actual '+mode+' observation damage refuses query, replacement and capture while preserving damaged bytes'); 85 } 86 return{tests}; 87 } 88 throw Error('unknown observation profile'); 89 } finally {reset();} 90 },profile); 91 if(result.receipt) { 92 const message={kind:'observation_query',...result.receipt,operation:result.operation,index:result.index,id:result.id}; 93 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); 94 assert.deepEqual(worker,{reports:result.golden});result.tests.push('actual worker termination and fresh WASM retain original target observations'); 95 await page.reload(); 96 const reports=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 reports=JSON.parse(await owner.query_observations(r.operation,r.index,r.id));await owner.close();return reports;},result); 97 assert.deepEqual(reports,result.golden);result.tests.push('actual page and WASM restart preserve immutable original outcome classes, details and optional times');delete result.receipt;delete result.golden; 98 } 99 return result; 100 }