tricu

zig-session-probe.mjs (9201B)

---

 import {terminalHost} from './terminal-host.mjs';
 // 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(control) {
  const phase=async name=>{if(control)await fetch(control+'/phase',{method:'POST',body:JSON.stringify({name})});};
  const base=new URL('../',document.querySelector('script[type=module][src]').src);
  const {Terminal}=(await import(new URL('dist/probe-api.js',base))).ioV2Terminal;
  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 releases=(await(await fetch(new URL('packages.json',base))).json()).releases;
  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 phase("full golden "+name);
    await s.load(await bytes(demo.hash),demo.hash);report.packages++;
    for(const c of demo.haskellCases){
     let terminal='',before;
     const hooks=demo.mode==='io'?terminalHost(Terminal,c.input):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;};
     if(demo.mode==='io'){const event=hooks.v2.event;hooks.v2.event=e=>{s.collect();event(e);};}
     else {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(demo.mode==='io'?hooks.terminalText:terminal,c.terminal,'Terminal '+name);report.applications++;
    }
   }
   const negatives=await(await fetch('/zig-negative.json')).json();
   {
    const f=negatives['v1-output'];await s.load(new Uint8Array(f.bytes),f.hash);
    let calls=0;const forbidden=()=>{calls++;throw Error('retired callback');};
    await rejects(()=>s.run('root',[],'tree','io',{...host(),before:forbidden,write:forbidden,read:forbidden}),/Unsupported tricuIO version/);
    equal(calls,0,'Retired v1 output never invokes host');
   }
   for(const [name,pattern] of [['version',/version/],['version-effect',/version/],['unsupported',/Unsupported/],['abort',/Unsupported tricuIO version/],['output',/Unsupported tricuIO version/],['actions',/Unsupported tricuIO version/]]){
    const f=negatives[name];await s.load(new Uint8Array(f.bytes),f.hash);
    await rejects(()=>s.run('root',[],'tree','io',host()),pattern);
   }
   {
    const f=negatives['version-effect'];await s.load(new Uint8Array(f.bytes),f.hash);
    let callbacks=0;const forbidden=()=>{callbacks++;throw Error('version gate reached host callback');};
    await rejects(()=>s.run('root',[],'tree','io',{before:forbidden,after:forbidden,read:forbidden,write:forbidden,running:forbidden}),/version/);
    equal(callbacks,0,'Unsupported version invoked host');
    report.checks.push('IO v2 rejected before host callbacks; no v1 retry');
   }
   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 scalars={type:'list',value:[{type:'string',value:'λ🙂'},{type:'number',value:'1267650600228229401496703205376'}]};
   equal((await invoke(scalars,'values')).value,scalars.value,'Decoded list preserves text and exact big naturals');
   await rejects(()=>invoke({type:'list',value:[{type:'bool',value:true}]},'values'),/number/);
   equal((await invoke({type:'bytes',value:Array(4096).fill(42)},'values')).value.length,4096,'Decoded lists are not capped at 32 preview items');
   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(`${report.applications} complete published goldens; v2 IO GC and retired framing rejection; scalar/list/tree codecs and 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 pausedHost=terminalHost(Terminal,'');pausedHost.v2.stepping=true;pausedHost.before=()=>{entered();return new Promise(()=>{});};
   const running=s.run(greet.haskellCases[0].export,[],'string','io',pausedHost);
   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||name==='intro'&&releases.some(r=>r.name==='intro'&&r.version==='0.2.0'&&r.hash===demo.hash),'Current catalogue pin or explicitly retained historical intro publication');
    await phase("source compile "+name);
    await c.compile(demo.source,entry?.environment??'empty');
    const first=demo.haskellCases[0];
    equal(await c.inspect(first.export,first.arguments.map(value=>({type:'tree',value})),demo.mode,demo.mode==='io'?terminalHost(Terminal,first.input):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');
   const failingHost=terminalHost(Terminal,'x');failingHost.v2.stepping=true;failingHost.before=async()=>{throw Error('host failed');};
   await rejects(()=>c.run(greet.haskellCases[0].export,[],'string','io',failingHost),/host failed/);
   const first=greet.haskellCases[0];equal(await c.inspect(first.export,[],greet.mode,terminalHost(Terminal,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 2 (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',terminalHost(Terminal,null)),/IO v2 failed/);
   report.checks.push('current published browser source demos and retained historical fixtures; compile-error invalidation/host-error retention; nonforcing divergent preview/abort');
  }finally{c.dispose();}
  return report;
 }