tricu

module-probe.mjs (11540B)

---

 // Production adapters + real page; expected values are independent arithmetic,
 // native header contracts, and the CLI cases in native-modules.py.
 const assert=(ok,message)=>{if(!ok)throw Error(message);};
 const equal=(actual,expected,label)=>assert(JSON.stringify(actual)===JSON.stringify(expected),label+': '+JSON.stringify(actual));
 async function rejects(fn,pattern){try{await fn();}catch(e){assert(pattern.test(e.message),'Wrong rejection: '+e.message);return;}throw Error('Expected '+pattern);}
 const el=id=>document.getElementById(id),delay=ms=>new Promise(r=>setTimeout(r,ms));
 async function status(value){for(let i=0;i<4500;i++){if(el('status').textContent===value)return;await delay(20);}throw Error('Timed out '+value+': '+el('status').textContent+' '+el('compile-diagnostic').textContent);}
 const input=(id,value)=>{el(id).value=value;el(id).dispatchEvent(new Event('input'));};
 const change=(id,value)=>{el(id).value=value;el(id).dispatchEvent(new Event('change'));};
 export async function run(control,backend='haskell-wasm'){
  const base=new URL('../',document.querySelector('script[type=module][src]').src);
  const {createRuntimeSession}=(await import(new URL('dist/probe-api.js',base))).runtimeSession;
  const {packageIndex,packageReleases}=(await import(new URL('dist/probe-api.js',base))).packages;
  const releases=packageIndex(await(await fetch(new URL('packages.json',base))).json());
  const lib=name=>packageReleases(releases,'tricu-lib-'+name)[0];
  const math=lib('native-math'),foundation=lib('base'),io=lib('io'),modules=lib('source-module');
  const host={before:async()=>{},after:()=>{},write:()=>{},read:async()=>'',running:()=>{}};
  const fault=async data=>{await fetch(control+'/fault',{method:'POST',body:JSON.stringify(data)});};
  const source=`-- native header; position masking must preserve this line\n!import ${math.manifest} as N\n!export answer\nprivate = 99\nanswer = N.add 40 2`;
  const s=await createRuntimeSession(backend,true);
  const value=async expression=>(await s.runExpression(expression,'number','pure',host)).value;
  try {
   const catalogue=await(await fetch(new URL('catalogue.json',base))).json();
   const fixtures=await(await fetch('/zig-fixtures.json')).json();
   for(const demo of catalogue){
    assert(demo.environment==='empty','Every demo is editable without hidden helper injection');
    await s.compile(demo.source,demo.environment);
    for(const c of fixtures.demos[demo.id].haskellCases){
     let terminal='';
     const result=await s.run(c.export,c.arguments.map(value=>({type:'tree',value})),'ternary',demo.mode,
       {...host,read:async()=>c.input,write:text=>{terminal+=text;}});
     equal(result.value,c.result,'Recompiled demo golden '+demo.id);
     equal(terminal,c.terminal,'Recompiled terminal '+demo.id);
    }
   }
   equal(await s.compile(source),['answer'],'Only explicit public exports');
   equal(await value('answer'),'42','Qualified module application');
   equal(await value('N.add answer private'),'141','Imported and private local bindings survive expression runs');
   await s.compile(source,'practical');
   await rejects(()=>value('isNat? 1'),/unresolved name/); // native headers override legacy demo profiles
   for(let i=0;i<10;i++)equal(await value('N.add answer 1'),'43','Repeated retained imported application');
   await rejects(()=>s.run('private',[],'number','pure',host),/Missing definition|missing export/);
   equal(await s.compile(`!import ${foundation.manifest} *\n!export answer\nanswer = add 20 22`),['answer'],'Open full base has no implicit contract collisions');
   equal(await value('add answer 8'),'50','Open library helpers retained');
   await s.compile(`!import ${foundation.manifest} *\n!export checkedIdentity\ncheckedIdentity x =@nat? x`);
   equal(await value('checkedIdentity 42'),'42','Native annotations resolve explicit contract imports');
   equal(await s.compile(`!import ${math.manifest} as A\n!import ${math.manifest} as B\n!export *\nanswer = A.add (B.add 10 11) 21`),['answer'],'Same manifest under two aliases');
   equal(await value('answer'),'42','Repeated reference');
   await s.compile(`!import ${modules.manifest} as M\n!export answer\nanswer = M.sourceModuleQualified "N" "add"`);
   equal((await s.runExpression('answer','string','pure',host)).value,'N.add','Compiler helper library is ordinarily importable');
   const goldens=await(await fetch('/module-goldens.json')).json();
   for(const golden of goldens.trees){
    await s.compile(golden.source);
    const tree=(await s.run(golden.name,[],'ternary','pure',host)).value;
    equal(tree.length,golden.bytes,'Complete native function tree length');
    const hash=[...new Uint8Array(await crypto.subtle.digest('SHA-256',new TextEncoder().encode(tree)))].map(n=>n.toString(16).padStart(2,'0')).join('');
    equal(hash,golden.ternaryAsciiSha256,'Exact function tree agrees with independent native compiler');
   }
   const names=await s.compile(`!export * from ${io.manifest}`);
   assert(names.includes('io')&&names.includes('readFile')&&names.length>16,'Header-only full re-export');
   equal((await s.run('io',[{type:'number',value:'42'}],'tree','pure',host)).type,'tree','Re-export is executable, not source expansion');
   await rejects(()=>value('readFile'),/unresolved name/); // reexports do not introduce lexical imports
   await s.compile(`!import ${io.manifest} as I\n!export main\nmain = I.io (I.readFile "no-browser-filesystem")`);
   await rejects(()=>s.run('main',[],'string','io',host),/Unsupported.*20|unsupported.*20/i);
   await s.compile(`!import ${math.manifest} as N\n!export answer\nloop x = loop x\nanswer = N.add 40 2`);
   equal(await value('answer'),'42','Unused divergent function is never normalized');
   const failures=[
    [`!import ${math.manifest}\n!export answer\nanswer = 42`,/hash imports require an alias/],
    [`!import ${math.manifest} as N\n!import ${math.manifest} as N\n!export answer\nanswer = 42`,/duplicate imported name/],
    [`!import ${math.manifest} *\n!export add\nadd x y = x`,/Compiler diagnostic 46/],
    [`!import ${math.manifest} as N\nanswer = 42`,/module requires an export/],
    [`!export absent\nanswer = 42`,/undeclared local export/],
    [`!export answer\n!export *\nanswer = 42`,/duplicate export/],
    [`!export * from ${math.manifest}\n!export * from ${math.manifest}`,/duplicate export/],
    [`!import prelude *\n!export answer\nanswer = 42`,/workspace/],
    [`!source prelude\n!export answer\nanswer = 42`,/workspace/],
    [`!import ${'0'.repeat(64)} as X\n!export answer\nanswer = 42`,/Unknown module manifest/],
    [`!import ${math.manifest} as N\n!export answer\nanswer = missing`,/Compiler diagnostic 20 at 3:/],
   ];
   for(const [text,pattern] of failures){
    await rejects(()=>s.compile(text),pattern);
    await rejects(()=>value('answer'),/unresolved name/);
    await s.compile(source);equal(await value('answer'),'42','Recover after failed module compilation');
   }
   for(const field of ['moduleMissing','moduleCorrupt']){
    await fault({[field]:releases.find(r=>r.manifest===math.manifest).hash});
    await rejects(()=>s.compile(source),/HTTP 404|SHA-256 mismatch/);
    await rejects(()=>value('answer'),/unresolved name/);
    await fault({[field]:null});
    await s.compile(source);equal(await value('answer'),'42','Fetch retry');
   }
   await fault({moduleManifest:math.manifest});
   await rejects(()=>s.compile(source),/Module manifest mismatch/);
   await fault({moduleManifest:null});
   await s.compile(source);
   const memory=[];
   for(let i=0;i<12;i++){
    await s.compile(source);equal(await value('N.add answer 1'),'43','Repeated module replacement');
    if(s.diagnostics){s.collect();memory.push(s.diagnostics());}
   }
   if(memory.length){
    equal(memory.at(-1).owned,memory[0].owned,'No retained import handle leak');
    assert(Math.max(...memory.slice(6).map(x=>x.linearMemoryBytes))<=Math.max(...memory.slice(0,6).map(x=>x.linearMemoryBytes))+65536,'Module memory plateaus');
   }
   await s.compile(`!import ${math.manifest} as N\n!export answer\nbrowserExpression0 = 9\nanswer = 42`);
   equal(await value('N.add answer browserExpression0'),'51','Temporary expression names avoid private locals');
   await s.compile('answer = 7');equal(await value('answer'),'7','Legacy scratch remains supported');
   await rejects(()=>value('N.add 1 2'),/unresolved name/);
  }finally{s.dispose();await fault({moduleMissing:null,moduleCorrupt:null,moduleManifest:null});}
  // Exercise the actual editable page, including Worker termination and rebuilding.
  await status('Ready');change('runtime-backend',backend);await status('Ready');
  document.querySelector('[data-compiler-example=module]').click();await status('Compiled');
  assert(el('source-editor').value.includes(math.manifest),'Module example uses an indexed manifest, not a bundle digest');
  input('expression-editor','answer');change('output-type','number');el('run').click();await status('Finished');
  equal(el('result').textContent,'42','Module scratch example');
  input('source-editor',source);el('compile').click();await status('Compiled');
  equal([...el('export').options].map(x=>x.value),['answer'],'Page public selector');
  input('expression-editor','N.add answer private');change('output-type','number');el('run').click();await status('Finished');
  equal(el('result').textContent,'141','Actual page imported expression');
  input('source-editor',`!import ${math.manifest} as N\n!export answer\nloop x = loop x\nanswer = N.add 40 2`);
  el('compile').click();await status('Compiled');
  input('expression-editor','loop t');el('run').click();await status('Running');await delay(100);el('stop').click();await status('Stopped');
  assert(el('run').disabled,'Stop discards imported heap');
  el('compile').click();await status('Compiled');input('expression-editor','N.add answer 1');el('run').click();await status('Finished');
  equal(el('result').textContent,'43','Stop/recompile reconstructs verified imports');
  // Edit the actual parser/lexer examples, not a scratch copy; verify changed
  // behavior, then restore the authenticated original and its behavior.
  for(const [id,before,after,expression,field,want,original] of [
   ['parser','N.inRange c 97 122','N.inRange c 65 90','parseNames "RED,GREEN"','status','ok','error'],
   ['lexer','N.inRange character 97 122','N.inRange character 65 90','scanWord "HELLO,world"','matched','HELLO',''],
  ]){
   change('program-picker','demo:'+id);await status('Ready');
   assert(!el('source-editor').hidden&&!el('source-editor').readOnly,'Editable '+id);
   const source=el('source-editor').value;assert(source.includes(before),'Known predicate');
   input('source-editor',source.replace(before,after));el('compile').click();await status('Compiled');
   input('expression-editor',expression);change('output-type','record');el('run').click();await status('Finished');
   equal(JSON.parse(el('result').textContent)[field],want,'Edited '+id+' result');
   el('restore-source').click();await status('Ready');equal(el('source-editor').value,source,'Restore '+id);
   input('expression-editor',expression);change('output-type','record');el('run').click();await status('Finished');
   equal(JSON.parse(el('result').textContent)[field],original,'Restored '+id+' behavior');
  }
  return {userAgent:navigator.userAgent,checks:['all sixteen editable demos match native goldens; parser/lexer edit and restore; native headers; qualified/open imports; full reexports; retained private/import scope; collision/diagnostic controls; transport and manifest faults; no capabilities; repeated replacement/GC; actual page Stop/recompile']};
 }