tricu

inline-io-probe.mjs (9648B)

---

 import './source-probe-helpers.mjs';
 import {terminalHost} from './terminal-host.mjs';
 const assert=(condition,message)=>{if(!condition)throw Error(message);};
 const el=id=>document.getElementById(id),pause=ms=>new Promise(r=>setTimeout(r,ms));
 const input=(id,value)=>{if(id==='source-editor'){globalThis.__sourceEditor.replaceSource(value,true);return;}el(id).value=value;el(id).dispatchEvent(new Event('input'));};
 const change=(id,value)=>{el(id).value=value;el(id).dispatchEvent(new Event('change'));};
 async function wait(check,label){for(let i=0;i<3600;i++){if(check())return;await pause(25);}throw Error('Timeout '+label+' / '+el('status').textContent+' / '+el('operation-diagnostic').textContent);}
 const status=text=>wait(()=>el('status').textContent===text,text);
 export async function run(control,backend='haskell-wasm'){
  await status('Ready');
  assert(!el('expression-editor')&&!el('run')&&!document.querySelector('.expression-dock'),'No separate evaluation component');
  const base=new URL('../',document.querySelector('script[type=module][src]').src);
  const api=await import(new URL('dist/probe-api.js',base));
  const {createRuntimeSession}=api.runtimeSession,{Terminal}=api.ioTerminal;
  const releases=api.packages.packageIndex(await(await fetch(new URL('packages.json',base))).json());
  const lib=name=>api.packages.packageReleases(releases,'tricu-lib-'+name)[0].manifest;
  const ioDefinition='io = IO.io (IO.require IO.stdin readAction)';
  const fixture=`!import ${lib('io')} as IO
 !import ${lib('io-text')} as Text
 !export answer
 answer = 42
 readAction reader = IO.require (Text.readLine (Text.lineCursor reader) 256) (reply : case reply of
   [["line" value _] _] = IO.pure value
   [["eof"] _] = IO.pure ""
   _ = IO.fail "Invalid line reply")
 ${ioDefinition}
 wrong = t "other" (t 2 (t 0 t))
 unsupported = t "tricuIO" (t 3 (t 0 t))
 retired = t "tricuIO" (t 1 (t 11 t))
 loop = (x : x x) (x : x x)
 latent = t "tricuIO" (t 2 loop)
 write = IO.io (IO.require IO.stdout (writer : IO.require (Text.writeText writer "Explicit output") (_ : IO.pure t)))
 abort = IO.io (IO.fail loop)`;
  const session=await createRuntimeSession(backend,true);
  try{
   assert((await session.compile(Array.from({length:64},(_,i)=>`local${i} = ${i}`).join('\n'),'empty')).length===64,'Source exploration is not capped at 16 definitions');
   await session.compile(fixture,'empty');
   for(const name of ['io','write','latent','abort'])assert(await session.probeIO(name),'Supported IO envelope '+name);
   for(const name of ['answer','wrong','unsupported','retired'])assert(!await session.probeIO(name),'Non-IO or retired framing '+name);
   assert((await session.inspectDefinition('answer','number')).value==='42','Probes preserve compiled scope');
   assert((await session.runDefinitionIO('io','string',terminalHost(Terminal,'λ雪🙂'))).value==='λ雪🙂','Private IO definition runs directly');
   const output=terminalHost(Terminal,null);
   await session.runDefinitionIO('write','tricu',output);assert(output.terminalText==='Explicit output','Explicit IO executes once');
   let aborted=false;try{await session.runDefinitionIO('abort','tricu',terminalHost(Terminal,null));}catch(error){aborted=/IO failed/.test(String(error));}assert(aborted,'Failure does not force divergent diagnostic');
   assert((await session.inspectDefinition('answer','number')).value==='42','Failure preserves definitions');
  }finally{session.dispose();}
  document.querySelector('[data-compiler-example=identity]').click();input('source-editor',fixture);await status('Compiled');
  const button=name=>document.querySelector(`[aria-label="Inspect compiled definition ${name}"]`);
  const card=()=>document.querySelector('.definition-card'),view=()=>card().querySelector('pre');
  const form=()=>el('terminal-io').querySelector('form:has(input)');
  const output=()=>el('terminal-io').querySelector('[data-stream=output]').textContent;
  const open=async name=>{button(name).click();await pause(0);await wait(()=>!card().hidden&&!card().querySelector('select').disabled,'inspect '+name);};
  const advance=async check=>{for(let i=0;i<3600;i++){if(check())return;if(el('status').textContent==='Paused before action')el('next').click();await pause(25);}throw Error('Stepped IO did not progress');};
  await open('answer');assert(view().textContent==='42','Pure Auto inspection');
  assert(el('run-io').closest('section').hidden,'Pure binding has no IO run surface');
  assert(!card().querySelector('.definition-actions button').disabled,'Pure result can be copied/downloaded');button('answer').click();
  await open('latent');assert(card().textContent.includes('IO program · authenticated tricuIO envelope'),'Detection never forces divergent action');
  assert(el('terminal-io').textContent===''&&!el('input-form'),'Opening IO never executes');button('latent').click();
  // Structured Stop is not a hard interruption of divergent native reduction.
  // Exercise acknowledged cancellation below at a real pending terminal read.
  await open('write');await pause(100);assert(el('terminal-io').textContent==='','Detection emits nothing');el('run-io').click();await status('Finished');
  assert(output()==='Explicit output','Explicit inline output');el('run-io').click();await status('Finished');assert(output()==='Explicit output','Rerun clears terminal');button('write').click();
  await open('io');el('io-return-format').value='string';el('step-mode').checked=true;el('run-io').click();await status('Paused before action');
  assert(!form(),'Step stops before input admission');await advance(()=>!!form());
  assert(button('io').getAttribute('aria-disabled')==='true'&&button('io').getAttribute('aria-expanded')==='true','Active IO inspection stays highlighted');
  form().querySelector('input').value='a'.repeat(257);form().requestSubmit();assert(form()&&!form().hidden,'Invalid input remains retryable');
  form().querySelector('input').value='λ雪🙂';form().requestSubmit();await advance(()=>el('status').textContent==='Finished');assert(view().textContent==='λ雪🙂','Unicode return uses selected interpretation');
  el('step-mode').checked=false;el('run-io').click();await wait(()=>form(),'pending read');el('stop-io').click();await status('Stopped');
  assert(!form()&&!el('run-io').disabled,'Acknowledged Stop retires input and permits rerun');
  el('run-io').click();await wait(()=>form(),'reuse after Stop');card().querySelector('[aria-label="Close definition inspection"]').click();await status('Stopped');assert(card().hidden,'Closing active IO cancels and settles');
  await open('answer');assert(el('run-io').closest('section').hidden,'No stale IO controls');button('answer').click();
  await open('io');input('source-editor',fixture.replace(ioDefinition,'io = 7'));await status('Compiled');
  await wait(()=>view().textContent==='7','revision replaces IO card');assert(el('run-io').closest('section').hidden,'Edits invalidate IO recognition');
  const catalogue=await(await fetch(new URL('catalogue.json',base))).json(),names=catalogue.find(item=>item.id==='names-values');
  change('program-picker','hash');input('bundle-hash',names.hash);el('program-hash').requestSubmit();await status('Ready');
  assert(el('source-editor').hidden&&!el('package-definitions').hidden,'Source-free definition browser');
  [...el('package-definition-list').querySelectorAll('button')].find(b=>b.textContent==='answer').click();await wait(()=>view().textContent==='42'&&!card().querySelector('select').disabled,'source-free inspection');
  assert(card().parentElement.id==='package-definition-view','Source-free card remains visible');
  const conversation=catalogue.find(item=>item.id==='greet');input('bundle-hash',conversation.hash);el('program-hash').requestSubmit();await status('Ready');
  [...el('package-definition-list').querySelectorAll('button')].find(b=>b.textContent==='main').click();await wait(()=>!el('run-io').disabled,'source-free IO detection');
  const sendLine=async value=>{await wait(()=>form(),'line input');form().querySelector('input').value=value;form().requestSubmit();await status('Finished');};
  el('io-return-format').value='string';el('run-io').click();await sendLine('Source-free');assert(output()==='What is your name?\nHello, Source-free!\n','Source-free IO executes');
  change('program-picker','demo:greet');await status('Ready');await open('main');assert(el('terminal-io').textContent===''&&!el('input-form'),'Published IO is opt-in');
  el('io-return-format').value='string';el('run-io').click();await sendLine('Inline tester');assert(output().includes('Inline tester'),'Published conversation');
  el('run-io').click();await sendLine('');assert(output()==='What is your name?\nHello, !\n','Empty line is data');
  el('run-io').click();await wait(()=>form(),'EOF prompt');form().querySelector('button[type=button]').click();await status('Finished');assert(output()==='What is your name?\nEnd of input.\n'&&view().textContent==='','Explicit EOF is distinct');
  el('run-io').click();await wait(()=>form(),'cancel prompt');const stale=form();el('stop-io').click();await status('Stopped');
  assert(!form(),'Stop retires input');el('run-io').click();await wait(()=>form(),'rerun without compilation');stale.requestSubmit();await pause(50);assert(form(),'Retired form cannot consume new input');await sendLine('Still compiled');
  assert(output().includes('Still compiled'),'Stop preserves definitions');
  return {userAgent:navigator.userAgent,backend,checks:['v2-only framing; opaque latent action/failure; explicit private and public IO; scheduler stepping; Unicode and retry; EOF; rerun; acknowledged Stop and stale-form isolation; source revisions; source-free and pure inspection']};
 }