tricu

browser-page.mjs (6019B)

---

 import {CompilerWorker} from './client.mjs';
 import {runParity} from './parity.mjs';
 const assert=(v,message)=>{if(!v)throw Error(message);};
 async function rejects(action,pattern){try{await action();}catch(e){assert(pattern.test(e.message),'Unexpected error: '+e.message);return;}throw Error('Expected rejection');}
 window.runProbe=async()=>{
   const goldens=await (await fetch('./goldens.json')).json();
   const report={userAgent:navigator.userAgent,cold:[],jobs:[],memory:[],checks:[]};
   // Fresh workers; browser/network/module caches may be warm after the first.
   for(let i=0;i<3;i++){
     const w=new CompilerWorker();try{report.cold.push(await w.request({type:'init'}));}finally{w.dispose();}
   }
   const corrupt=new CompilerWorker();
   try{await rejects(()=>corrupt.request({type:'init',corrupt:'compiler.dag'}),/SHA-256 mismatch/);}
   finally{corrupt.dispose();}
   const corruptEnv=new CompilerWorker();
   try{await rejects(()=>corruptEnv.request({type:'init',corrupt:'environment.tsv'}),/SHA-256 mismatch/);}
   finally{corruptEnv.dispose();}
   const corruptExports=new CompilerWorker();
   try{await rejects(()=>corruptExports.request({type:'init',corrupt:'compiler-exports.tsv'}),/SHA-256 mismatch/);}
   finally{corruptExports.dispose();}
   report.checks.push('corrupt prepared DAG/environment/compiler-export roots rejected');
   const w=new CompilerWorker();
   try{
     report.initialization=await w.request({type:'init'});
     for(let round=0;round<5;round++)for(const [id,c] of goldens.cases.entries()){
       if(c.mode==='io')continue;
       if(c.diagnostic){
         let diagnostic;
         try{await w.request({type:'compile',source:c.source});}catch(e){diagnostic=e.message;}
         assert(diagnostic===c.diagnostic,'Compiler diagnostic mismatch: '+diagnostic);
         continue;
       }
       const compile=await w.request({type:'compile',source:c.source});
       assert(JSON.stringify(compile.text.trim().split('\n'))===JSON.stringify(Object.keys(c.definitions)),'Export names mismatch');
       const dump=await w.request({type:'dump'});
       assert(dump.text===Object.entries(c.definitions).map(([n,t])=>n+'\t'+t+'\n').join(''),'Complete definitions mismatch');
       const run=await w.request({type:'observe',name:c.export,arguments:c.arguments});
       assert(run.text===c.result,'Compiled execution mismatch');
       report.jobs.push({round,id,compileMs:compile.milliseconds,dumpMs:dump.milliseconds,runMs:run.milliseconds,
         roundtripMs:compile.roundtripMs+dump.roundtripMs+run.roundtripMs,linearBytes:run.linearBytes});
     }
     const unicode=goldens.cases.find(c=>c.mode==='io');
     await w.request({type:'compile',source:'value = '+JSON.stringify(unicode.input)});
     assert((await w.request({type:'observe',name:'value',arguments:[]})).text===unicode.result,'Unicode scalar source/result mismatch');
     report.checks.push('Unicode source crosses UTF-8 boundary and matches independent scalar-tree golden');
     const identity=goldens.cases[0];
     const compiling=w.request({type:'compile',source:identity.source});
     await rejects(()=>w.request({type:'dump'}),/busy/);
     await compiling;
     await rejects(()=>w.request({type:'compile',source:'\ud800'}),/Unicode/);
     await rejects(()=>w.request({type:'compile',source:'x'.repeat(16385)}),/limit/);
     await rejects(()=>w.request({type:'compile',source:goldens.cases.find(c=>c.diagnostic).source}),/Compiler diagnostic/);
     await rejects(()=>w.request({type:'observe',name:'id',arguments:identity.arguments}),/missing export/);
     await w.request({type:'compile',source:identity.source});
     await rejects(()=>w.request({type:'observe',name:'id',arguments:['2']}),/invalid ternary/);
     assert((await w.request({type:'observe',name:'id',arguments:identity.arguments})).text===identity.result,'Malformed argument poisoned runtime');
     report.checks.push('compiler/Unicode/size errors invalidate replaced definitions; argument errors preserve them');
     for(let round=0;round<30;round++){
       const c=goldens.cases[round%2===0?3:5];
       await w.request({type:'compile',source:c.source});
       const result=await w.request({type:'observe',name:c.export,arguments:c.arguments});
       assert(result.text===c.result,'Repeated execution mismatch');
       const reset=await w.request({type:'reset'});report.memory.push(reset.linearBytes);
     }
     await rejects(()=>w.request({type:'observe',name:'main',arguments:[]}),/missing export/);
     assert(Math.max(...report.memory.slice(15))<=Math.max(...report.memory.slice(0,15))+2*65536,'Linear memory did not plateau');
     report.checks.push('30 compile/run/reset cycles; old exports inaccessible; linear memory plateau');
     await w.request({type:'compile',source:identity.source});
     let ticks=0;const heartbeat=setInterval(()=>ticks++,5);
     const start=performance.now();
     try{
       // Known self-application diverger from the site's lazy conformance tests.
       await rejects(()=>w.request({type:'observe',name:'id',arguments:['212110021100','212110021100']},75),/deadline/);
     }finally{clearInterval(heartbeat);}
     report.termination={milliseconds:performance.now()-start,mainThreadTicks:ticks};
     assert(ticks>0,'Main thread blocked');
     await rejects(()=>w.request({type:'dump'}),/Disposed/);
     report.checks.push('non-returning reduction terminated; main thread responsive');
   }finally{w.dispose();}
   const replacement=new CompilerWorker();
   try{
     await replacement.request({type:'init'});
     await replacement.request({type:'compile',source:goldens.cases[0].source});
     assert((await replacement.request({type:'observe',name:'id',arguments:goldens.cases[0].arguments})).text===goldens.cases[0].result,'Replacement Worker failed');
     report.checks.push('fresh Worker succeeds after cancellation');
   }finally{replacement.dispose();}
   // Do not serialize transferred byte buffers into the report.
   for(const x of [...report.cold,report.initialization])delete x.bytes;
   report.parity=await runParity();
   return report;
 };