tricu

editable-conformance.mjs (4062B)

---

 // Opt-in real demo compilation with explicit native manifest imports. No host
 // recompilation; expected results are retained independent Haskell captures.
 import assert from 'node:assert/strict';
 import {readFile} from 'node:fs/promises';
 import {createHash} from 'node:crypto';
 import {Graph} from '../dist/graph.js';
 import {decodeBundle,loadBundle,COMPILER_BUNDLE_LIMIT} from '../dist/bundle.js';
 import {compiledDefinitions,sourceLiteral,COMPILER_EXPORT} from '../dist/compiler.js';
 import {stageModule,selectModuleExports} from '../dist/module-stage.js';
 import {moduleIdentity} from '../dist/module-identity.js';
 import {list,text,readText} from '../dist/codecs.js';
 import {runIO} from '../dist/io.js';
 const root=new URL('../',import.meta.url);
 const catalogue=JSON.parse(await readFile(new URL('catalogue.json',root)));
 const environments=JSON.parse(await readFile(new URL('environments.json',root)));
 const goldens=JSON.parse(await readFile(new URL('demos.json',root)));
 async function bundle(hash,limit){
  const bytes=await readFile(new URL('bundles/'+hash+'.arboricx',root));
  assert.equal(createHash('sha256').update(bytes).digest('hex'),hash);
  return decodeBundle(bytes,limit);
 }
 for(const id of ['parser','lexer'])goldens.demos[id]=JSON.parse(await readFile(new URL(id+'-demo.json',root)));
 const releases=JSON.parse(await readFile(new URL('packages.json',root))).releases;
 const compiler=await bundle(environments.compiler,COMPILER_BUNDLE_LIMIT);
 for(const entry of catalogue.filter(e=>!process.argv[2]||e.id===process.argv[2])){
  const started=performance.now();
  const g=new Graph({nodes:6_000_000,fuel:Infinity,stack:100_000},{threshold:250_000});
  const library=loadBundle(g,compiler),stage=stageModule(g,library,entry.source+'\n-- Edited locally\n');
  assert.ok(stage.native);
  // Header strings/shapes now live in JS; release native parsing temporaries.
  g.collect(library.values());
  const modules=new Map(),scope=new Map();
  const roots=()=>[...library.values(),...[...modules.values()].flatMap(m=>[...m.values()])];
  let qualifiedCount=0;
  for(const [ref,qualifier] of stage.imports){
   if(!modules.has(ref)){
    const release=releases.find(r=>r.manifest===ref);assert.ok(release);
    const decoded=await bundle(release.hash);assert.equal(await moduleIdentity(decoded),ref);
    modules.set(ref,loadBundle(g,decoded));
   }
   for(const [name,value] of modules.get(ref)){
    const qualified=readText(g,g.apply(library.get('source_module.sourceModuleQualified'),[text(g,qualifier),text(g,name)]),512);
    assert.ok(!scope.has(qualified));scope.set(qualified,value);
    if(++qualifiedCount%32===0)g.collect(roots());
   }
  }
  g.collect(roots());
  const bindings=[...scope].map(([name,value])=>g.fork(text(g,name),value));
  const locals=compiledDefinitions(g,g.apply(library.get(COMPILER_EXPORT),[list(g,bindings),sourceLiteral(g,stage.body)]));
  for(const name of locals.keys())assert.ok(!scope.has(name));
  const definitions=selectModuleExports(stage,locals,modules);
  g.collect(definitions.values());
  console.log(entry.id,'compile ms',Math.round(performance.now()-started),'stats',JSON.stringify(g.stats));
  // Exactly apply the default published export using the first Haskell capture
  // for that export; evaluating the draft must reproduce the independent tree.
  const expected=goldens.demos[entry.id].haskellCases.find(c=>c.export===entry.export);
  assert.ok(expected);
  g.beginOperation();
  let result=g.apply(definitions.get(entry.export),expected.arguments.map(a=>g.fromTernary(a)));
  let terminal='';
  if(entry.mode==='io')result=await runIO(g,result,{before:async()=>{},after(){},running(){},write(s){terminal+=s;},read:async()=>expected.input},true,definitions.values());
  const actual=g.toTernary(result);
  // Compare small digests rather than permitting gigantic diagnostic diffs.
  const sha=s=>createHash('sha256').update(s).digest('hex');
  assert.equal(sha(actual),sha(expected.result),entry.id+' result');assert.equal(terminal,expected.terminal);
  console.log('PASS',entry.id,'draft equals independent Haskell result');
 }