tricu

browser-parity.mjs (10880B)

---

 import {CompilerWorker} from './client.mjs';
 import {drive} from './site/io-driver.js';
 import {Terminal} from './site/io-terminal.js';
 import {treeResult} from './site/tree-result.js';
 import {terminalHost} from './terminal-host.mjs';
 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,worker=w){
     const call=async m=>JSON.parse((await worker.request(m)).text);
     const selected=await call({type:'io-start',selectIO:true,name,arguments:args});
     assert(selected.kind==='v2','Only v2 selection');
     const host=terminalHost(Terminal,input),run=selected.run;
     try {
       const value=await drive({run,signal:worker.signal,discard:()=>worker.dispose(),
         turn:command=>call({type:'io-session-turn',...command}),
         view:async()=>treeResult((await call({type:'io-public-view',run,output:'ternary'})).value,'ternary'),
       },host);
       report.ioRuns++;
       return {terminal:host.terminalText,tree:value.value};
     }finally{if(!worker.disposed)await call({type:'io-public-clear',run});}
   }
   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 scalars={type:'list',value:[{type:'string',value:'λ🙂'},{type:'number',value:'1267650600228229401496703205376'}]};
     equal((await request({type:'evaluate',name:id,arguments:[scalars],output:'values'})).value,scalars.value,'Decoded list preserves scalar values and big naturals');
     await rejects(()=>request({type:'evaluate',name:id,arguments:[{type:'list',value:[{type:'bool',value:true}]}],output:'values'}),/number/);
     equal((await request({type:'evaluate',name:id,arguments:[{type:'bytes',value:Array(4096).fill(42)}],output:'values'})).value.length,4096,'Decoded list reaches 4096 elements independently of graph preview bound');
     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; scalar/list/tree 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',/IO failed/],['abort-io',/IO failed/],['retired-output',/version/],['retired-actions',/version/]]){
       await load(name);
       await rejects(()=>runIO('root',[],''),pattern);
     }
     await load('version-effect');
     await rejects(()=>request({type:'io-start',selectIO:true,name:'root',arguments:[]}),/version/);
     report.checks.push('unsupported and retired IO versions reject before events; no retry');
     await load('greet');
     const selected=await request({type:'io-start',selectIO:true,name:demos.demos.greet.haskellCases[0].export,arguments:[]});
     await rejects(()=>load('identity'),/pending/);
     await rejects(()=>request({type:'io-session-turn',run:'0',kind:'poll'}),/Stale/);
     const host=terminalHost(Terminal,null),open=host.structured.open;
     host.structured.open=(run,command)=>{open(run,command);command({run,kind:'stop'});};
     await rejects(()=>drive({run:selected.run,signal:w.signal,discard:()=>w.dispose(),
       turn:command=>request({type:'io-session-turn',...command}),
       view:async()=>{throw Error('Cancelled result was decoded');},
     },host),/cancelled/);
     await request({type:'io-public-clear',run:selected.run});
     await rejects(()=>request({type:'io-session-turn',run:selected.run,kind:'poll'}),/Stale/);
     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('v2 failed diagnostics; stale run rejection; acknowledged cancellation and recovery; legacy limit fixtures reject inertly');
   }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 2 (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');
     await rejects(()=>runIO('aborted',[],'',c),/IO failed/);
     report.checks.push('all native demo sources compile with explicit imports; compiled graph-preserving export; environment authentication; ready compiler pin');
     report.checks.push('preview and terminal failure do not force excluded divergent payloads; null/Infinity disable request timer');
   }finally{c.dispose();}
   return report;
 }