tricu

browser-parity.mjs (11032B)

---

 import {CompilerWorker} from './client.mjs';
 import {decodeBundle} from './site/bundle.js';
 import {snapshotBundle,exportedTree} from './bridge.mjs';
 const assert=(value,message)=>{if(!value)throw Error(message);};
 const equal=(a,b,message)=>assert(JSON.stringify(a)===JSON.stringify(b),message+': '+JSON.stringify(a).slice(0,200));
 async function rejects(action,pattern){try{await action();}catch(e){assert(pattern.test(e.message),'Unexpected rejection: '+e.message);return;}throw Error('Expected rejection '+pattern);}
 export async function runParity(){
   const index=await(await fetch('./parity/index.json')).json(),demos=await(await fetch('./parity/demos.json')).json();
   const report={checks:[],packages:0,applications:0,ioRuns:0,compiledDemos:0};
   const w=new CompilerWorker();
   const request=async m=>JSON.parse((await w.request(m)).text);
   const load=async name=>{
     const bytes=await(await fetch('./parity/'+name+'.arboricx')).arrayBuffer();
     const names=await request({type:'load',bytes,hash:index[name]});
     return {bytes,names};
   };
   async function runIO(name,args,input){
     let event=await request({type:'io-start',name,arguments:args}),terminal='',steps=0;
     const trace=[];let awaitingAfter=null;
     while(event.kind!=='done'){
       assert(++steps<600,'IO event loop failed to finish');
       trace.push(event.kind+':'+(event.name??''));
       if(event.kind==='before'){assert(awaitingAfter===null,'Missing after trace');awaitingAfter={step:event.step,name:event.name};}
       if(event.kind==='after'){assert(awaitingAfter&&event.step===awaitingAfter.step&&event.name===awaitingAfter.name&&typeof event.value==='string','After trace contract');awaitingAfter=null;}
       if(event.kind==='write')terminal+=event.text;
       const old=event.token;
       if(event.kind==='read'){
         await rejects(()=>request({type:'io-resume',token:old,value:'bad\nline'}),/one bounded line/);
         await w.request({type:'collect'}); // Paused continuations survive a major GC.
       }
       event=await request({type:'io-resume',token:old,value:event.kind==='read'?(input??''):''});
       await rejects(()=>request({type:'io-resume',token:old,value:''}),/stale|no IO interaction/);
     }
     const snapshot=await request({type:'io-snapshot'});
     const tree=exportedTree(snapshotBundle(snapshot,'result'),'result','ternary').text;
     report.ioRuns++;
     return {terminal,tree,trace};
   }
   try{
     const ready=await w.request({type:'init',compiler:false});
     assert(ready.compilerHash===null,'Package-only initialization claims a compiler');
     const stats=await w.request({type:'stats'});
     equal(JSON.parse(stats.text),{linearMemoryBytes:stats.linearBytes},'Stats must report only actual linear memory');
     await rejects(()=>w.request({type:'compile',source:'id x = x'}),/not initialized/);
     const identity=await load('identity'),id=identity.names[0];
     await rejects(()=>request({type:'load',bytes:identity.bytes,hash:'0'.repeat(64)}),/SHA-256 mismatch/);
     await rejects(()=>load('wrong-profile'),/manifest semantics/);
     equal((await request({type:'evaluate',name:id,arguments:[{type:'number',value:'42'}],output:'number'})).value,'42','Failed load changed prior package');
     for(const vector of demos.codecVectors){
       const type=vector.kind,value=type==='number'?String(vector.value):vector.value;
       const result=await request({type:'evaluate',name:id,arguments:[{type,value}],output:type});
       equal(result.value,value,'Scalar codec');
       const observed=await w.request({type:'observe',name:id,arguments:[vector.tree]});
       equal(observed.text,vector.tree,'Canonical scalar tree');
     }
     for(const value of [true,false])equal((await request({type:'evaluate',name:id,arguments:[{type:'bool',value}],output:'bool'})).value,value,'Boolean codec');
     equal((await request({type:'evaluate',name:id,arguments:[{type:'bytes',value:[0,1,127,128,255]}],output:'bytes'})).value,[0,1,127,128,255],'Byte codec');
     await rejects(()=>request({type:'evaluate',name:id,arguments:[{type:'number',value:'256'}],output:'bool'}),/Boolean/);
     await rejects(()=>request({type:'evaluate',name:id,arguments:[{type:'list',value:[{type:'number',value:'256'}]}],output:'bytes'}),/Invalid byte/);
     await rejects(()=>request({type:'evaluate',name:id,arguments:[{type:'list',value:[{type:'number',value:'55296'}]}],output:'string'}),/Surrogate/);
     const record={type:'list',value:[
       {type:'list',value:[{type:'string',value:'__proto__'},{type:'number',value:'0'},{type:'string',value:'safe'}]},
       {type:'list',value:[{type:'string',value:'n'},{type:'number',value:'1'},{type:'number',value:'42'}]},
       {type:'list',value:[{type:'string',value:'b'},{type:'number',value:'2'},{type:'bool',value:true}]}
     ]};
     const decoded=(await request({type:'evaluate',name:id,arguments:[record],output:'record'})).value;
     assert(Object.hasOwn(decoded,'__proto__')&&decoded.__proto__==='safe'&&decoded.n===42&&decoded.b===true,'Record codec / prototype key');
     await rejects(()=>request({type:'evaluate',name:id,arguments:[{type:'list',value:[record.value[0],record.value[0]]}],output:'record'}),/unique/);
     const list=(await request({type:'evaluate',name:id,arguments:[{type:'list',value:[{type:'number',value:'42'},{type:'bool',value:true}]}],output:'list'})).value;
     equal(list.length,2,'List codec');assert(list.every(v=>Array.isArray(v.nodes)),'List previews');
     report.checks.push('authenticated arbitrary bundle load; failed loads preserve previous exports; all seven site codecs and negative controls');
     await load('exponential');
     const preview=await request({type:'preview',name:'root',limit:8});
     assert(preview.truncated&&preview.nodes.length===8,'Bounded preview must truncate');
     const snapshot=await request({type:'snapshot',name:'root',limit:100});
     assert(!snapshot.truncated&&snapshot.nodes.length<=41,'Snapshot expanded sharing');
     const runtimeDag=exportedTree(snapshotBundle(snapshot,'root'),'root','dag');
     assert(runtimeDag.bytes<10000,'Runtime DAG export expanded sharing');
     const immutableDag=await request({type:'export',name:'root',format:'dag'});
     assert(immutableDag.bytes<10000,'Stored DAG export expanded sharing');
     await rejects(()=>request({type:'export',name:'root',format:'ternary'}),/Expanded tree/);
     await rejects(()=>Promise.resolve(exportedTree(snapshotBundle(preview,'root'),'root','dag')),/partial export/);
     report.checks.push('40-level exponential sharing preserved in runtime snapshot and immutable DAG export; bounded preview and expansion rejection');
     for(const [name,demo] of Object.entries(demos.demos)){
       await load(name);report.packages++;
       for(const c of demo.haskellCases){
         const args=c.arguments.map(value=>({type:'tree',value}));
         if(demo.mode==='io'){
           const actual=await runIO(c.export,args,c.input);
           equal(actual.tree,c.result,'IO result '+name);equal(actual.terminal,c.terminal,'IO terminal '+name);
         }else equal((await w.request({type:'observe',name:c.export,arguments:c.arguments})).text,c.result,'Published program '+name);
         report.applications++;
       }
       const stored=await request({type:'export',name:demo.haskellCases[0].export,format:'dag'});
       assert(stored.extension==='dag'&&stored.bytes>0,'Stored definition export');
     }
     report.checks.push('all curated published packages and Haskell result/terminal goldens');
     for(const [name,pattern] of [['bad-version',/version/],['unsupported-io',/Unsupported browser IO action/],['abort-io',/aborted/],['output-limit',/output limit/],['action-limit',/action limit/]]){
       await load(name);
       await rejects(()=>runIO('root',[],''),pattern);
       await request({type:'io-cancel'});
     }
     await load('greet');
     let event=await request({type:'io-start',name:demos.demos.greet.haskellCases[0].export,arguments:[]});
     await rejects(()=>load('identity'),/pending/);
     await request({type:'io-cancel'});
     await rejects(()=>request({type:'io-resume',token:event.token,value:''}),/no IO interaction/);
     await load('identity');
     equal((await request({type:'evaluate',name:id,arguments:[{type:'string',value:'recovered'}],output:'string'})).value,'recovered','IO errors poisoned runtime');
     report.checks.push('IO envelope/version/action/output limits; abort without forcing huge payload; stale-token rejection; GC while awaiting input; explicit cancellation and recovery');
   }finally{w.dispose();}
   // A compiler-capable session exercises all profiles without package loading
   // replacing the retained compiler/environment.
   const c=new CompilerWorker();
   try{
     const ready=await c.request({type:'init'},Infinity);
     equal(ready.compilerHash,demos.compilerBundleSha256,'Ready compiler pin');
     const environments=await(await fetch('./parity/environments.json')).json();
     const profile=environments.profiles.practical;
     const support=await(await fetch('./parity/environment-practical.arboricx')).arrayBuffer();
     for(const [name,demo] of Object.entries(demos.demos)){
       const environment=demo.supportSourceSha256?{bytes:support,hash:profile.hash,names:profile.names}:null;
       await c.request({type:'compile',source:demo.source,environment,base:new URL('./parity/',location.href).href},60000);
       const first=demo.haskellCases[0];
       if(demo.mode!=='io')equal((await c.request({type:'observe',name:first.export,arguments:first.arguments})).text,first.result,'Compiled demo '+name);
       const exported=JSON.parse((await c.request({type:'export',name:first.export,format:'dag'})).text);
       assert(exported.bytes>0,'Compiled DAG export');
       report.compiledDemos++;
     }
     await rejects(()=>c.request({type:'compile',source:'x = t',environment:{bytes:support,hash:'0'.repeat(64),names:profile.names}}),/SHA-256 mismatch/);
     const previous=Object.values(demos.demos).at(-1).haskellCases[0].export;
     await rejects(()=>c.request({type:'observe',name:previous,arguments:[]}),/missing export/);
     await c.request({type:'compile',source:'q x = x x\nlazy = t (q q) t\naborted = t "tricuIO" (t 1 (t 2 (q q)))'},null);
     const partial=JSON.parse((await c.request({type:'preview',name:'lazy',limit:1},2000)).text);
     assert(partial.nodes.length===1&&partial.truncated,'Preview forced excluded divergent child');
     const before=JSON.parse((await c.request({type:'io-start',name:'aborted'},2000)).text);
     assert(before.kind==='before'&&before.name==='abortIO','Abort before event');
     await rejects(()=>c.request({type:'io-resume',token:before.token,value:''},2000),/aborted/);
     await c.request({type:'io-cancel'});
     report.checks.push('all ten native demo sources compile with explicit imports; compiled graph-preserving export; environment authentication; ready compiler pin');
     report.checks.push('preview and abort trace do not force excluded divergent payloads; null/Infinity disable request timer');
   }finally{c.dispose();}
   return report;
 }