tricu

io-public-probe.mjs (9712B)

---

 import {wait,status,change,inspect,el,pause,input} from './source-probe-helpers.mjs';
 export async function run(_control,backend){
  const assert=(ok,message)=>{if(!ok)throw Error(message);},checks=[];
  const base=new URL('../',document.querySelector('script[type=module][src]').src);
  const {runtimeSession:{createRuntimeSession},ioTerminalView:{terminalView}}=await import(new URL('dist/probe-api.js',base));
  const fixture=await(await fetch('/io-source.json')).json(),s=await createRuntimeSession(backend,false);
  const legacy={before:async()=>{},after(){},read(){throw Error('legacy read invoked');},write(){throw Error('legacy write invoked');},running(){}};
  const parent=document.createElement('div');document.body.append(parent);
  let widget,send,closed,steps=0,submitted=false,guardTask;
  function host(mode='normal'){
   parent.replaceChildren();closed=false;submitted=false;
   return {...legacy,before:async()=>{steps++;},structured:{stepping:mode==='step',
    open(run,command){send=command;widget=terminalView(parent,run,reply=>command({run,kind:'reply',reply}),()=>command({run,kind:'stop'}));},
    event(event){widget.handle(event);if(event.kind==='read'&&mode==='stop'){
      guardTask=(async()=>{try{
       for(const operation of [()=>s.inspectDefinition('main','tree'),()=>s.compile('changed = 9','empty'),()=>s.runExpression('42','number','pure',legacy)]){
        let blocked=false;try{await operation();}catch(error){blocked=/pending|busy/.test(error.message);}assert(blocked,'unrelated work entered active v2 run');
       }
      }finally{send({run:event.run,kind:'stop'});}})();
     }
     if(event.kind==='read'&&mode==='input'){
      const form=parent.querySelector('form');if(form&&!form.hidden){if(!submitted){submitted=true;form.querySelector('input').value='λ😀';form.requestSubmit();}else form.querySelector('button[type=button]').click();}
     }
    },
    close(_run,settled){assert(settled,'unacknowledged runtime loss');widget.finish();closed=true;},
   }};
  }
  try{
   await s.load(new Uint8Array(fixture.bytes),fixture.hash);
   assert(await s.probeIO('main'),'v2 inert recognition');assert(!await s.probeIO('direct'),'bare computation is not an envelope');
   for(const name of ['main','publicHandled','publicCancellation','publicBinary']){
    const out=await s.runDefinitionIO(name,'number',host());assert(out.value==='42'&&closed,'public compiled outcome '+name);
    const bytes=widget.snapshot().output.bytes,expected=name==='publicBinary'?[92,120,102,102,255,240,159]:[...new TextEncoder().encode(name==='publicCancellation'?'ready':'λ😀e\u0301\r\n')];
    assert(JSON.stringify(bytes)===JSON.stringify(expected),'public exact output '+name);
   }
   assert((await s.runDefinitionIO('publicRoundTrip','number',host('input'))).value==='42','line and EOF outcome');
   assert(JSON.stringify(widget.snapshot().output.bytes)===JSON.stringify([...new TextEncoder().encode('λ😀\n')]),'line/EOF byte preservation');
   checks.push('compiled direct/handled/cancellation/binary programs through public RuntimeSession; explicit line/EOF');
   const cases=[['string',{type:'string',value:'λ😀\0'},'λ😀\0'],['number',{type:'number',value:'184467440737095516160'},'184467440737095516160'],['bool',{type:'bool',value:true},true],['bytes',{type:'bytes',value:[0,255,240]},[0,255,240]]];
   for(const [type,literal,expected]of cases){const out=await s.run('returnValue',[literal],type,'io',host());assert(JSON.stringify(out.value)===JSON.stringify(expected),'full codec '+type);}
   for(const type of ['tree','list','tricu','triangle','dag','ternary']){
    const literal=type==='list'?{type:'list',value:[{type:'number',value:'42'}]}:{type:'tree',value:'200'};
    const observed=await s.run('returnValue',[literal],type,'io',host());assert(observed.type===type&&observed.value!==null,'full graph codec '+type);
    if(['tricu','triangle','dag','ternary'].includes(type)){const expected=await s.runExpression('t t t',type,'pure',legacy);// DAG binders reflect physical node numbering, not semantic identities.
     const alpha=text=>{const names=new Map();return text.replace(/:[fn][0-9]+/g,name=>{if(!names.has(name))names.set(name,':v'+names.size);return names.get(name);});};
     assert((type==='dag'?alpha(expected.value)===alpha(observed.value):expected.value===observed.value),'complete graph result differs from independent pure result '+type);}
   }
   const values=await s.run('returnValue',[{type:'list',value:[{type:'number',value:'42'},{type:'string',value:'hello'}]}],'values','io',host());
   assert(JSON.stringify(values.value)===JSON.stringify([{type:'number',value:'42'},{type:'string',value:'hello'}]),'values codec');
   checks.push('all public codecs including >64-bit number, full trees and decoded values');
   let rejected=false;try{await s.runDefinitionIO('publicRoundTrip','number',host('stop'));}catch(error){rejected=/cancelled/.test(error.message);}assert(rejected&&closed,'public structured cancellation');await guardTask;
   let badCodec=false;try{await s.run('returnValue',[{type:'tree',value:'10'}],'number','io',host());}catch{badCodec=true;}assert(badCodec&&closed,'codec failure after cleanup');
   assert((await s.runExpression('returnValue "expression result"','string','io',host())).value==='expression result','IO expression result');
   assert((await s.run('returnValue',[{type:'number',value:'42'}],'number','io',host('step'))).value==='42'&&steps>0,'public scheduler stepping');
   checks.push('structured Stop drains read, definitions remain usable; expression and stepping paths');
  }finally{s.dispose();parent.remove();}
  const doomed=await createRuntimeSession(backend,false);let abandoned=false;
  try{
   await doomed.load(new Uint8Array(fixture.bytes),fixture.hash);
   let rejected=false;try{await doomed.runDefinitionIO('publicRoundTrip','number',{...legacy,structured:{open(){},event(event){if(event.kind==='read')doomed.dispose();},close(_run,settled){abandoned=!settled;}}});}
   catch(error){rejected=/disposed|terminated/i.test(error.message);}assert(rejected&&abandoned,'emergency dispose must reject without claiming cleanup');
  }finally{doomed.dispose();}
  checks.push('emergency runtime disposal rejects idle read and explicitly does not acknowledge cleanup');
  // Real mounted editor + outer worker + nested native worker, not a mock host.
  await status('Ready');
  const index=await(await fetch(new URL('packages.json',base))).json();
  const io=index.releases.find(r=>r.title==='lib/io.tri'&&r.version==='0.4.0');assert(io,'authenticated complete library');
  const source=`!import ${io.manifest} as IO\n!export answer\n!export binary\n!export waiting\n!export caps\n!export classification\n!export divergentValue\ndivergentValue = IO.io (IO.pure ((x : x x) (x : x x)))\nbackendOf rows = case rows of\n  [["backend" value] | _] = value\n  [_ | rest] = backendOf rest\n  _ = "missing"\ncaps = IO.io (IO.require IO.capabilities (rows : IO.pure (backendOf rows)))\nloop = (x : x x) (x : x x)\nclassification = IO.io (IO.require (IO.inspect (IO.request "file" 1 "open" loop)) IO.pure)\nanswer = 42\nbinary = IO.io (do IO.require\n  writer <- IO.stdout\n  IO.writeAll writer [92 120 102 102 255 240 159]\n  IO.pure "returned text")\nwaiting = IO.io (do IO.require\n  reader <- IO.stdin\n  IO.readSome reader 4\n  IO.pure 42)`;
  document.querySelector('[data-compiler-example=identity]').click();input('source-editor',source);await status('Compiled');
  await inspect('caps');el('io-return-format').value='string';el('run-io').click();await status('Finished');assert(document.querySelector('.definition-card').querySelector('pre').textContent===backend,'actual native capabilities');
  await inspect('classification');el('io-return-format').value='values';el('run-io').click();await status('Finished');assert(document.querySelector('.definition-card').querySelector('pre').textContent.includes('unsupported'),'inert inspection leaves divergent arguments opaque');
  await inspect('binary');el('io-return-format').value='string';el('run-io').click();await status('Finished');
  assert(el('terminal-io').querySelector('[data-hex=output]').textContent==='5c 78 66 66 ff f0 9f','actual page lossless output');
  assert(document.querySelector('.definition-card').querySelector('pre').textContent==='returned text','actual page full returned text');
  await inspect('waiting');el('io-return-format').value='number';el('run-io').click();await wait(()=>el('terminal-io').querySelector('form input'),'v2 input');
  const old=el('terminal-io').querySelector('form');el('stop').click();assert(!el('stop').hidden,'Stop waits rather than disposing worker');
  await status('Stopped');assert(!el('terminal-io').querySelector('form'),'input physically retired');
  old.dispatchEvent(new Event('submit',{cancelable:true}));assert((await inspect('answer','number'))==='42','compiled state survives structured Stop');
  // Stop also bypasses a suspended scheduler turn.
  await inspect('waiting');el('step-mode').checked=true;el('run-io').click();await status('Paused before action');el('stop').click();await status('Stopped');el('step-mode').checked=false;
  assert((await inspect('answer','number'))==='42','compiled state survives paused Stop');
  await inspect('divergentValue');el('io-return-format').value='number';el('run-io').click();await status('IO settled; interpreting returned value');el('stop').click();await status('Stopped');
  el('compile').click();await status('Compiled');assert((await inspect('answer','number'))==='42','hard Stop after acknowledged IO settlement can rebuild');
  await pause(10);checks.push('actual page exact bytes/full return, pending-input and paused-step Stop, stale DOM isolation and reuse without recompilation');
  return {backend,checks};
 }