tricu

io-v2-session-probe.mjs (4998B)

---

 // Native tree sibling cancellation through cloneable events, with a real DOM
 // provider. No raw handles leave the worker/session boundary.
 export async function run(_control,backend){
  const base=new URL('../',document.querySelector('script[type=module][src]').src),fixture=(await(await fetch('/zig-negative.json')).json())['v2-session-streams'];
  const assert=(ok,message)=>{if(!ok)throw Error(message);};
  async function exercise(start,turn,stop){
   let report=await start();const events=[];
   for(let i=0;i<30&&!events.some(e=>e.kind==='write');i++){events.push(...report.events);if(!events.some(e=>e.kind==='write'))report=await turn({run:report.run,kind:'poll'});}
   const read=events.find(e=>e.kind==='read'),write=events.find(e=>e.kind==='write');assert(read&&write,'pending read blocked sibling write');
   const input=document.createElement('input');document.body.append(input);let hits=0;
   const listener=()=>{hits++;};input.addEventListener('input',listener);
   try{
    if(stop){
     report=await turn({run:report.run,kind:'stop'});
     assert(!report.done&&report.events.filter(e=>e.kind==='cancel').length===2,'stop did not cancel both providers');
     input.removeEventListener('input',listener);input.remove();
     report=await turn({run:report.run,kind:'reply',reply:{...read,kind:'cancelled'}});
     assert(!report.done,'stop forgot pending output acknowledgement');
     report=await turn({run:report.run,kind:'reply',reply:{...write,kind:'cancelled'}});
     for(let i=0;i<30&&!report.done;i++)report=await turn({run:report.run,kind:'poll'});
     assert(report.done&&report.outcome.kind==='cancelled','structured session stop did not settle');
     assert(Object.values(report.counts).every(group=>Object.values(group).every(value=>value===0)),'stop retained lifecycle state');
     return;
    }
    let rejected=false;try{await turn({run:'999',kind:'stop'});}catch{rejected=true;}assert(rejected,'wrong run accepted');
    report=await turn({run:report.run,kind:'reply',reply:{...read,run:'999',bytes:[1],eof:false}});assert(report.accepted===false,'wrong reply consumed wait');
    assert(write.bytes.length===1&&write.bytes[0]===65,'write payload mismatch');
    report=await turn({run:report.run,kind:'reply',reply:{run:write.run,id:write.id,kind:'write',count:1}});
    let cancel=report.events.find(e=>e.kind==='cancel');
    for(let i=0;i<30&&!cancel;i++){report=await turn({run:report.run,kind:'poll'});cancel=report.events.find(e=>e.kind==='cancel');}
    assert(cancel?.id===read.id,'missing read cancellation');assert(!report.done&&report.counts.events.pending===1,'abort delivery settled provider');
    input.removeEventListener('input',listener);input.dispatchEvent(new Event('input'));assert(hits===0,'listener survived cancellation');
    report=await turn({run:report.run,kind:'poll'});assert(!report.done&&input.isConnected,'unacknowledged cleanup retired run');
    input.remove();report=await turn({run:report.run,kind:'reply',reply:{...cancel,kind:'cancelled'}});
    for(let i=0;i<30&&!report.done;i++)report=await turn({run:report.run,kind:'poll'});
    assert(report.done&&report.outcome.kind==='completed'&&report.outcome.value==='42','tree run result mismatch');
    assert(Object.values(report.counts).every(group=>Object.values(group).every(value=>value===0)),'historical transport/lifecycle state retained');
   }finally{input.removeEventListener('input',listener);input.remove();}
  }
  for(const stop of [false,true]){
  if(backend==='haskell-wasm'){
   const {CompilerWorker}=await import(new URL('runtime/haskell/client.mjs',base)),client=new CompilerWorker();
   try{await client.request({type:'init',compiler:false});await client.request({type:'load',bytes:new Uint8Array(fixture.bytes).buffer,hash:fixture.hash});
    await exercise(async()=>JSON.parse((await client.request({type:'io-v2-session-start',name:'root',arguments:[]})).text),async command=>JSON.parse((await client.request({type:'io-v2-session-turn',...command})).text),stop);
   }finally{client.dispose();}
  }else{
   const {WasmRuntime}=await import('/io-v2-runtime.mjs'),{ioV2Private,ioV2Session}=await import(new URL('dist/zig-helpers.js',base));
   const g=await WasmRuntime.create(new Uint8Array(await(await fetch(new URL('runtime/zig/arboricx.wasm',base))).arrayBuffer()));
   try{await g.scopeAsync(async()=>{
    const action=g.load(new Uint8Array(fixture.bytes),'root'),tree=ioV2Private.constructors({leaf:g.leaf,observe:g.observe.bind(g),stem:g.stem.bind(g),fork:g.fork.bind(g),app:g.app.bind(g)});
    const session=new ioV2Session.Session(tree,action,'1',roots=>g.sweepScope(roots));
    await exercise(()=>session.turn({run:'1',kind:'poll'}),command=>session.turn(command),stop);
   });}finally{g.dispose();}
  }
  }
  return {backend,checks:['native tree read permits sibling write','wrong-run stop and reply reject','tree cancellation waits for DOM cleanup acknowledgement','complete42; no retained task/resource/event records','external structured stop awaits both provider acknowledgements']};
 }