tricu

io-v2-public.test.mjs (9029B)

---

 import test from 'node:test';
 import assert from 'node:assert/strict';
 import {Graph} from '../dist/graph.js';
 import {readText,readNatural,readList,view} from '../dist/codecs.js';
 import {constructors} from '../dist/io-v2-private.js';
 import {Wire} from '../dist/io-v2-core.js';
 import {Session} from '../dist/io-v2-session.js';
 import {envelope,available} from '../dist/io-v2-profile.js';
 import {drive} from '../dist/io-v2-driver.js';
 function fixture(){
  const g=new Graph(),t=constructors({leaf:g.leaf,observe:g.observe.bind(g),stem:g.stem.bind(g),fork:g.fork.bind(g),app:g.app.bind(g)}),w=new Wire(t,1n);
  const n=x=>t.natural(BigInt(x)),a=(tag,p=t.leaf)=>t.fork(n(tag),p),request=(group,op,p=t.leaf,revision=1)=>a(10,t.fork(t.text(group),t.fork(n(revision),t.fork(t.text(op),p))));
  return {g,t,w,n,a,request,session:(action,steps=128)=>new Session(t,action,'1',roots=>g.collect([...roots]),{summarize:false,steps,backend:'test-native'})};
 }
 const host=()=>({before:async()=>{},after(){},read(){throw Error('legacy read');},write(){throw Error('legacy write');},running(){}});
 const driver=(s,read)=>({run:s.run,turn:c=>s.turn(c),view:async()=>read(s.core.result.value)});
 async function finish(s){for(let i=0;i<100;i++){const r=await s.turn({run:s.run,kind:'poll'});if(r.done)return r;}throw Error('stalled');}
 const result=(f,s)=>f.w.pair(f.w.pair(s.core.result.value)[1])[0];
 test('public framing is bounded and leaves action opaque; unknown versions never trial-execute',()=>{
  const f=fixture(),poison=f.g.app(f.g.leaf,f.g.leaf),original=f.t.observe;f.t.observe=h=>{if(h===poison)throw Error('payload forced');return original(h);};
  for(const version of [2])assert.deepEqual(envelope(f.t,f.t.fork(f.t.text('tricuIO'),f.t.fork(f.n(version),poison))),{version,action:poison});
  const padded=f.t.fork(f.t.stem(f.t.leaf),f.t.fork(f.t.leaf,f.t.leaf));
  assert.throws(()=>envelope(f.t,f.t.fork(f.t.text('tricuIO'),f.t.fork(padded,poison))),/version/);
  for(const version of [0,1,3,4])assert.throws(()=>envelope(f.t,f.t.fork(f.t.text('tricuIO'),f.t.fork(f.n(version),poison))),/version/);
  assert.throws(()=>envelope(f.t,f.t.fork(f.t.text('tricuIOx'),poison)),/sentinel/);
 });
 test('browser capabilities and inert inspection agree on exact implemented facilities',async()=>{
  const f=fixture(),s=f.session(f.request('runtime','capabilities'));await finish(s);
  const rows=new Map(readList(f.g,result(f,s),20).map(h=>{const [k,v]=readList(f.g,h,2);return [readText(f.g,k),v];}));
  assert.equal(readText(f.g,rows.get('backend')),'test-native');assert.equal(readText(f.g,rows.get('authority')),'browser-terminal');
  const groups=readList(f.g,rows.get('groups'),20).map(h=>{const [group,revision,ops]=readList(f.g,h,3);return [readText(f.g,group),readNatural(f.g,revision).toString(),readList(f.g,ops,10).map(h=>readText(f.g,h))];});
  assert.deepEqual(groups,[['runtime','1',['capabilities','inspect']],['standard','1',['input','output','error']],['stream','1',['read','write']],['resource','1',['close']],['utf8','1',['encode','decode']]]);
  for(const [group,,ops]of groups)for(const op of ops)assert(available(group,1,op));
  for(const group of ['file','tcp','process','clock','__proto__','constructor'])assert(!available(group,1,'open'));
  for(const [group,op,rev,label]of [['stream','write',1,'available'],['stream','write',2,'unsupported'],['file','open',1,'unsupported']]){
   const q=fixture(),poison=q.g.app(q.g.leaf,q.g.leaf),observe=q.t.observe;q.t.observe=h=>{if(h===poison)throw Error('argument forced');return observe(h);};
   const inspect=q.session(q.request('runtime','inspect',q.request(group,op,poison,rev)));await finish(inspect);
   const out=readList(q.g,result(q,inspect),5);assert.equal(readText(q.g,out[4]),label);assert(!inspect.core.hasFault);
  }
 });
 test('public sessions never summarize a completed payload before the selected full codec',async()=>{
  const f=fixture(),payload=f.t.text('λ😀'),s=f.session(f.a(0,payload));
  let rendered=false,closed;
  const out=await drive(driver(s,h=>{rendered=true;return view(f.g,h,'string');}),{...host(),v2:{open(){},event(){throw Error('unexpected event');},close(_run,settled){closed=settled;assert(!rendered);}}});
  assert.equal(out.value,'λ😀');assert.equal(closed,true);
  const q=fixture(),opaque=q.g.app(q.g.leaf,q.g.leaf),observe=q.t.observe;q.t.observe=h=>{if(h===opaque)throw Error('summary forced payload');return observe(h);};
  const retained=q.session(q.a(0,opaque));assert.equal((await finish(retained)).outcome.value,null);
 });
 test('public Stop cancels a pending read and waits for physical acknowledgement',async()=>{
  const f=fixture(),s=f.session(f.request('stream','read',f.t.fork(f.w.marker('io.v2.resource',1),f.n(4))));
  let send,closed=false,cancelled=false,stale;
  await assert.rejects(drive(driver(s,()=>{throw Error('cancelled payload viewed');}),{...host(),v2:{
   open(_run,command){send=command;stale=command;},
   event(event){if(event.kind==='read')send({run:'1',kind:'stop'});else{
    assert.equal(event.kind,'cancel');cancelled=true;
    setTimeout(()=>{assert(!closed);send({run:'1',kind:'reply',reply:{...event,kind:'cancelled'}});},10);
   }},close(_run,settled){assert(cancelled);assert(settled);closed=true;}
  }}),/cancelled/);
  assert(closed);stale({run:'1',kind:'stop'});assert.equal(s.events.counts.pending,0);
 });
 test('step hooks cannot block structured stop, including a never-resolving pause',async()=>{
  const f=fixture(),s=f.session(f.a(0,f.n(42)),1);let send,seen=0;
  await assert.rejects(drive(driver(s,()=>{throw Error('unexpected view');}),{...host(),before(){seen++;queueMicrotask(()=>send({run:'1',kind:'stop'}));return new Promise(()=>{});},v2:{stepping:true,open(_r,c){send=c;},event(){throw Error('unexpected event');},close(_r,settled){assert(settled);}}}),/cancelled/);
  assert.equal(seen,1);
 });
 test('undefined step-hook rejection is preserved after cleanup, and renderer failure occurs after settlement',async()=>{
  for(const phase of ['step','view']){
   const f=fixture(),s=f.session(f.a(0,f.n(42)),1);let closed=false;
   try{await drive(driver(s,()=>{if(phase==='view')throw undefined;return {}; }),{...host(),before:async()=>{if(phase==='step')throw undefined;},v2:{stepping:true,open(){},event(){},close(_r,settled){closed=settled;}}});assert.fail('must reject');}
   catch(e){assert.equal(e,undefined);assert(closed);}
  }
 });
 
 test('unexpected driver loss is labelled unacknowledged, never a successful cleanup',async()=>{
  let settled,viewed=false,discarded=false;
  await assert.rejects(drive({run:'1',discard(){discarded=true;},turn:async()=>{throw Error('runtime lost');},view:async()=>{viewed=true;}},{...host(),v2:{open(){},event(){},close(_r,value){settled=value;}}}),/runtime lost/);
  assert.equal(settled,false);assert.equal(viewed,false);assert(discarded);
 });
 test('unknown facilities/revisions are ordinary opaque errors; malformed inspection is not execution',async()=>{
  for(const [group,operation,revision]of [['file','open',1],['runtime','capabilities',2]]){
   const f=fixture(),poison=f.g.app(f.g.leaf,f.g.leaf),observe=f.t.observe;f.t.observe=h=>{if(h===poison)throw Error('unknown argument forced');return observe(h);};
   const s=f.session(f.request(group,operation,poison,revision));await finish(s);assert(!s.core.hasFault);
   assert.equal(readText(f.g,readList(f.g,result(f,s),4)[0]),'unsupported');
  }
  const f=fixture(),s=f.session(f.request('runtime','inspect',f.t.leaf));await finish(s);assert(!s.core.hasFault);
  assert.equal(readText(f.g,readList(f.g,result(f,s),4)[0]),'invalid-argument');
 });
 
 test('emergency disposal interrupts an idle read without inventing physical acknowledgement',async()=>{
  const f=fixture(),s=f.session(f.request('stream','read',f.t.fork(f.w.marker('io.v2.resource',1),f.n(4))));
  let settled;const lifetime=new AbortController();
  await assert.rejects(drive({...driver(s,()=>{throw Error('unexpected view');}),signal:lifetime.signal},{...host(),v2:{open(){},event(event){assert.equal(event.kind,'read');setTimeout(()=>lifetime.abort(Error('runtime disposed')),10);},close(_r,value){settled=value;}}}),/disposed/);
  assert.equal(settled,false);assert.equal(s.events.counts.pending,1,'no fabricated cancelled reply');
 });
 
 test('completed runs remove emergency-disposal listeners rather than retaining per-turn history',async()=>{
  const controller=new AbortController(),signal=controller.signal,add=signal.addEventListener.bind(signal),remove=signal.removeEventListener.bind(signal);let listeners=0,peak=0;
  signal.addEventListener=(...args)=>{listeners++;peak=Math.max(peak,listeners);return add(...args);};signal.removeEventListener=(...args)=>{listeners--;return remove(...args);};
  for(let run=0;run<5;run++){
   const f=fixture();let action=f.a(0,f.n(42));for(let i=0;i<20;i++)action=f.a(1,f.t.fork(f.a(0),f.t.fork(f.t.leaf,action)));
   const s=f.session(action,1);await drive({...driver(s,h=>view(f.g,h,'number')),signal},{...host(),v2:{stepping:true,open(){},event(){},close(){}}});assert.equal(listeners,0);
  }
  assert.equal(peak,1);
 });