tricu

browser-page.mjs (8503B)

---

 // Driven by browser.mjs over CDP; every operation has a main-thread timeout.
 const assert = (ok,message) => { if (!ok) throw new Error(message); };
 const bytes = async path => { const r=await fetch(path); if(!r.ok)throw new Error(path); return r.arrayBuffer(); };
 const digest = async b => Array.from(new Uint8Array(await crypto.subtle.digest('SHA-256',b)),x=>x.toString(16).padStart(2,'0')).join('');
 function client() {
   const worker = new Worker(new URL('./worker.mjs',import.meta.url),{type:'module'});
   let id=0; const waiting=new Map(), unsolicited=[];
   const terminate = () => { worker.terminate(); for(const w of waiting.values()){clearTimeout(w.timer);w.reject(new Error('Terminated'));} waiting.clear(); };
   worker.onmessage=({data})=>{
     const w=waiting.get(data.id);
     if(!w){unsolicited.push(data);return;}
     waiting.delete(data.id);clearTimeout(w.timer);
     if(data.type==='error')w.reject(new Error(data.message));else w.resolve(data);
   };
   worker.onerror=e=>{for(const w of waiting.values()){clearTimeout(w.timer);w.reject(new Error(e.message));}waiting.clear();};
   return {terminate,unsolicited,send:m=>new Promise((resolve,reject)=>{
     const request=++id;
     const timer=setTimeout(()=>{waiting.delete(request);terminate();reject(new Error('Worker deadline'));},30_000);
     waiting.set(request,{resolve,reject,timer});worker.postMessage({...m,id:request});
   })};
 }
 // Only used to validate small, complete snapshots against independent goldens.
 function snapshotTree(snapshot) {
   assert(!snapshot.truncated,'Unexpected truncated fixture preview');
   const nodes=new Map(snapshot.nodes.map(n=>[n.id,n]));
   const aliases=new Map((snapshot.aliases??[]).map(a=>[a.from,a.to]));
   const pending=[snapshot.root], chars=[];
   while(pending.length) {
     assert(chars.length<10000,'Preview fixture expansion limit');
     let id=pending.pop();
     for(let i=0;aliases.has(id);i++){assert(i<256,'Alias cycle');id=aliases.get(id);}
     const node=nodes.get(id);assert(node,'Missing preview node');
     chars.push(String(node.children.length));pending.push(...[...node.children].reverse());
   }
   return chars.join('');
 }
 export async function run() {
   const wasm=await bytes('/arboricx.wasm'), identity=await bytes('/test/fixtures/id.arboricx');
   const goldens=await (await fetch('/ext/demo-site/test/compiler-conformance.json')).json();
   const compiler=await bytes(`/ext/demo-site/bundles/${goldens.compilerBundleSha256}.arboricx`);
   const init=(host,bundle,hash,name)=>({type:'init',backend:host==='wasm'?'zig-wasm':'js',bundle,hash,name,artifacts:{wasm}});
   const idHash=await digest(identity), samples=[], controls=[];
   let ticks=0;const heartbeat=setInterval(()=>ticks++,10);
   try {
     for(const host of ['js','wasm']) {
       const c=client();
       try {
         // A rejected hash never constructs the evaluator. Retry initialization.
         await c.send(init(host,identity,'0'.repeat(64))).then(()=>{throw new Error('Accepted wrong hash');},e=>assert(/hash mismatch/.test(e.message),'Wrong hash error: '+e.message));
         const malformed=new Uint8Array(identity.byteLength+1);malformed.set(new Uint8Array(identity));
         let invalidRejected=false;
         try{await c.send(init(host,malformed.buffer,await digest(malformed)));}catch{invalidRejected=true;}
         assert(invalidRejected,'Accepted malformed bundle with matching hash');
         const ready=await c.send(init(host,identity,idHash));
         assert(ready.backend===(host==='wasm'?'zig-wasm':'js'),'Wrong selected backend');
         await c.send(init(host==='wasm'?'js':'wasm',identity,idHash)).then(
           ()=>{throw new Error('Switched live session backend');},
           e=>assert(/Already initialized/.test(e.message),'Wrong session-switch error'));
         let surrogateRejected=false;
         try{await c.send({type:'text',value:'\ud800'});}catch{surrogateRejected=true;}
         assert(surrogateRejected,'Accepted unpaired surrogate');
         const unicode='\ufeff\0λ雪🙂\uffff\u{10ffff}';
         for(let i=0;i<10;i++)assert((await c.send({type:'text',value:unicode})).value===unicode,'Unicode mismatch');
       } finally {c.terminate();}
       controls.push(`${host}: hash/profile rejection, invalid surrogate recovery and Unicode`);
     }
     // Alternate fresh Worker order. Capture compilation (lazy definition handles)
     // separately from independent full definition/result validation.
     for(let round=0;round<3;round++)for(const host of round%2?['wasm','js']:['js','wasm']) {
       const c=client();
       try {
         await c.send(init(host,compiler,goldens.compilerBundleSha256,goldens.export));
         let repeatStats;
         for(let index=0;index<4;index++) {
           const golden=goldens.cases[index];
           const compiled=await c.send({type:'compile',source:golden.source});
           assert(JSON.stringify([...compiled.names].sort())===JSON.stringify(Object.keys(golden.definitions).sort()),'Definition names mismatch');
           const observeStart=performance.now();
           for(const [name,value] of Object.entries(golden.definitions))
             assert((await c.send({type:'inspect',name,arguments:[]})).value===value,`Definition mismatch ${name}`);
           assert((await c.send({type:'inspect',name:golden.export,arguments:golden.arguments})).value===golden.result,'Applied result mismatch');
           const observedMs=performance.now()-observeStart;
           let previewMs=0;
           for(const [name,value] of Object.entries(golden.definitions)) {
             const preview=await c.send({type:'preview',name,limit:256});
             assert(snapshotTree(preview.value)===value,`Preview mismatch ${name}`);
             previewMs+=preview.ms;
           }
           const {stats}=await c.send({type:'collect'});
           samples.push({host,round,case:index,compileMs:compiled.ms,observeRoundTripMs:observedMs,previewMs,stats});
         }
         // Replace retained exports, then verify compiler-only/definition roots
         // stabilize live counts after warm-up and explicit collection.
         for(let i=0;i<8;i++) {
           await c.send({type:'compile',source:goldens.cases[0].source});
           assert((await c.send({type:'inspect',name:'id',arguments:goldens.cases[0].arguments})).value===goldens.cases[0].result,'Retained compiler changed');
           const {stats}=await c.send({type:'collect'});
           if(host==='wasm' && repeatStats)assert(stats.owned===repeatStats.owned && stats.liveAfterCollect===repeatStats.liveAfterCollect,'Retained-session leak: '+JSON.stringify({stats,repeatStats}));
           repeatStats=stats;
         }
         for(const bad of goldens.cases.filter(x=>x.diagnostic)) {
           let diagnostic;
           try {await c.send({type:'compile',source:bad.source});} catch(error) {diagnostic=error.message;}
           assert(diagnostic?.includes(bad.diagnostic),'Compiler diagnostic mismatch: '+diagnostic);
           assert((await c.send({type:'inspect',name:'id',arguments:goldens.cases[0].arguments})).value===goldens.cases[0].result,'Failed compilation destroyed retained exports');
         }
         await c.send({type:'compile',source:goldens.cases[0].source});
         assert((await c.send({type:'inspect',name:'id',arguments:goldens.cases[0].arguments})).value===goldens.cases[0].result,'Compiler failed to recover');
       } finally {c.terminate();}
     }
     for(const host of ['js','wasm']) {
       const c=client();
       try {
         await c.send(init(host,identity,idHash));
         const before=ticks;
         assert((await c.send({type:'diverge'})).type==='running','No divergence acknowledgment');
         await new Promise(r=>setTimeout(r,100));
         assert(ticks>before,'Main thread blocked by evaluator');
         c.terminate();
         await new Promise(r=>setTimeout(r,100));
         assert(c.unsolicited.length===0,'Divergent evaluator returned before Stop');
       } finally {c.terminate();}
       // A separate fresh Worker must still initialize and execute after Stop.
       const fresh=client();try{await fresh.send(init(host,identity,idHash));assert((await fresh.send({type:'text',value:'restart🙂'})).value==='restart🙂','Restart failed');}finally{fresh.terminate();}
       controls.push(`${host}: hard termination, responsive main thread and fresh restart`);
     }
     return {schema:1,userAgent:navigator.userAgent,wasmSha256:await digest(wasm),compilerSha256:goldens.compilerBundleSha256,samples,controls};
   } finally {clearInterval(heartbeat);}
 }