tricu

zig-session-probe.mjs (7087B)

---

 // Independent complete Haskell captures, exercised through Zig's coarse adapter.
 const assert=(ok,message)=>{if(!ok)throw Error(message);};
 const equal=(a,b,label)=>assert(JSON.stringify(a)===JSON.stringify(b),label+': '+JSON.stringify(a).slice(0,160));
 async function rejects(fn,pattern){try{await fn();}catch(e){assert(pattern.test(e.message),'Wrong rejection: '+e.message);return;}throw Error('Expected '+pattern);}
 export async function run() {
  const base=new URL('../',document.querySelector('script[type=module][src]').src);
  const {create}=await import(new URL('runtime/zig/site-session.mjs',base));
  const fixtures=await(await fetch('/zig-fixtures.json')).json();
  const catalogue=await(await fetch(new URL('catalogue.json',base))).json();
  const report={packages:0,applications:0,compiledDemos:0,checks:[],memory:[]};
  const host=input=>({before:async()=>{},after:()=>{},read:async()=>input,write:()=>{},running:()=>{}});
  const bytes=async hash=>new Uint8Array(await(await fetch('/_arboricx/bundle/hash/'+hash)).arrayBuffer());
  const s=await create({base,compiler:false});
  try {
   for(const [name,demo] of Object.entries(fixtures.demos)) {
    await s.load(await bytes(demo.hash),demo.hash);report.packages++;
    for(const c of demo.haskellCases){
     let terminal='',before;
     const hooks=host(c.input);
     hooks.before=async e=>{assert(!before,'Missing after');before=e;};
     hooks.after=e=>{assert(e.step===before?.step&&e.name===before.name,'Trace ordering/name');before=undefined;};
     hooks.read=async()=>{s.collect();return c.input;};hooks.write=text=>{terminal+=text;};
     equal(await s.inspect(c.export,c.arguments.map(value=>({type:'tree',value})),demo.mode,hooks),c.result,'Full golden '+name);
     equal(terminal,c.terminal,'Terminal '+name);report.applications++;
    }
   }
   const negatives=await(await fetch('/zig-negative.json')).json();
   for(const [name,pattern] of [['version',/version/],['unsupported',/Unsupported/],['abort',/aborted/],['output',/output limit/],['actions',/action limit/]]){
    const f=negatives[name];await s.load(new Uint8Array(f.bytes),f.hash);
    await rejects(()=>s.run('root',[],'tree','io',host()),pattern);
   }
   const shared=negatives.sharing;await s.load(new Uint8Array(shared.bytes),shared.hash);
   const preview=(await s.run('root',[],'tree','pure',host())).value;
   assert(!preview.truncated&&preview.nodes.length===41,'Physical sharing expanded');
   assert(preview.nodes.filter(n=>n.kind==='fork').every(n=>n.children[0]===n.children[1]),'Lost child aliases');
   const intro=fixtures.demos.intro;await s.load(await bytes(intro.hash),intro.hash);
   const invoke=(arg,type)=>s.run('identity',[arg],type,'pure',host());
   for(const vector of fixtures.codecVectors){const type=vector.kind,value=type==='number'?String(vector.value):vector.value;equal((await invoke({type,value},type)).value,value,'Scalar codec');}
   for(const value of [true,false])equal((await invoke({type:'bool',value},'bool')).value,value,'Boolean');
   equal((await invoke({type:'bytes',value:[0,1,127,128,255]},'bytes')).value,[0,1,127,128,255],'Bytes');
   await rejects(()=>invoke({type:'number',value:'256'},'bool'),/Boolean/);
   await rejects(()=>invoke({type:'list',value:[{type:'number',value:'256'}]},'bytes'),/byte/);
   await rejects(()=>invoke({type:'list',value:[{type:'number',value:'55296'}]},'string'),/status 5/);
   await rejects(()=>invoke({type:'string',value:'\ud800'},'string'),/surrogate/);
   const record={type:'list',value:[{type:'list',value:[{type:'string',value:'__proto__'},{type:'number',value:'0'},{type:'string',value:'safe'}]}]};
   const decoded=(await invoke(record,'record')).value;assert(Object.hasOwn(decoded,'__proto__')&&decoded.__proto__==='safe','Prototype-safe record');
   await rejects(()=>invoke({type:'list',value:[record.value[0],record.value[0]]},'record'),/unique/);
   equal((await invoke({type:'list',value:[{type:'number',value:'42'}]},'list')).value.length,1,'List');
   const original=await bytes(intro.hash);
   await rejects(()=>s.load(original,'0'.repeat(64)),/SHA-256 mismatch/);
   const mutable=original.slice(),loading=s.load(mutable,intro.hash);mutable.fill(0);await loading;
   equal((await invoke({type:'number',value:'42'},'number')).value,'42','Load must authenticate an immutable snapshot');
   const baseline=s.diagnostics().owned;
   for(let i=0;i<50;i++){
    equal((await invoke({type:'string',value:'λ雪🙂'},'string')).value,'λ雪🙂','Retained run');
    s.collect();equal(s.diagnostics().owned,baseline,'Temporary owned-handle leak');
    report.memory.push(s.diagnostics().linearMemoryBytes);
   }
   assert(Math.max(...report.memory.slice(25))<=Math.max(...report.memory.slice(0,25))+65536,'Memory failed to plateau');
   report.checks.push('117 complete published goldens; IO GC/trace ordering/limits; seven codecs/negative controls; physical sharing; ownership and memory plateau');
   const greet=fixtures.demos.greet;await s.load(await bytes(greet.hash),greet.hash);
   let entered;const paused=new Promise(resolve=>{entered=resolve;});
   const running=s.run(greet.haskellCases[0].export,[],'string','io',{...host(''),before:()=>{entered();return new Promise(()=>{});}});
   running.catch(()=>{});await paused;s.dispose();await rejects(()=>running,/Disposed/);assert(s.disposed,'Disposed session reused');
  }finally{s.dispose();}
  const c=await create({base,compiler:true});
  try {
   for(const [name,demo] of Object.entries(fixtures.demos)){
    const entry=catalogue.find(x=>x.hash===demo.hash);assert(entry,'Catalogue fixture pin');
    await c.compile(demo.source,entry.environment);
    const first=demo.haskellCases[0];
    equal(await c.inspect(first.export,first.arguments.map(value=>({type:'tree',value})),demo.mode,host(first.input)),first.result,'Compiled '+name);report.compiledDemos++;
   }
   const intro=fixtures.demos.intro;await c.compile(intro.source,'empty');
   await rejects(()=>c.compile('name = unavailableName','empty'),/Compiler diagnostic/);
   // Retired stale-definition retention: a failed replacement cannot expose the
   // previous program or its imported scope. Runtime/IO errors still retain it.
   await rejects(()=>c.run('answer',[],'number','pure',host()),/Missing definition/);
   const greet=fixtures.demos.greet;await c.compile(greet.source,'empty');
   await rejects(()=>c.run(greet.haskellCases[0].export,[],'string','io',{...host('x'),before:async()=>{throw Error('host failed');}}),/host failed/);
   const first=greet.haskellCases[0];equal(await c.inspect(first.export,[],greet.mode,host(first.input)),first.result,'Host-error cleanup preserves definitions');
   await c.compile('q x = x x\nlazy = t (q q) t\naborted = t \"tricuIO\" (t 1 (t 2 (q q)))','empty');
   const partial=await c.preview('lazy',1);assert(partial.nodes.length===1&&partial.truncated,'Preview forced excluded divergent child');
   await rejects(()=>c.run('aborted',[],'tree','io',host()),/aborted/);
   report.checks.push('ten complete native source demos; compile-error invalidation/host-error retention; nonforcing divergent preview/abort');
  }finally{c.dispose();}
  return report;
 }