tricu

gc.test.mjs (5126B)

---

 import test from 'node:test';
 import assert from 'node:assert/strict';
 import {readFile} from 'node:fs/promises';
 import {Graph} from '../dist/graph.js';
 import {text,natural,readText} from '../dist/codecs.js';
 import {runIO} from '../dist/io.js';
 test('tracing preserves sharing and stable handles; stale IDs are never reused',()=>{
  const g=new Graph({fuel:10000}),garbage=g.stem(g.leaf);let root=g.leaf;
  for(let i=0;i<31;i++)root=g.fork(root,root);
  const before=g.preview(root);g.collect([root]);
  assert.equal(g.stats.nodes,32);assert.equal(g.stats.reclaimed,1);
  assert.deepEqual(g.preview(root),before);
  const fresh=g.stem(g.leaf);assert.notEqual(fresh,garbage);
  assert.throws(()=>g.observe(garbage),/Invalid node handle/);
  assert.equal(g.observe(root).node.left,g.observe(root).node.right);
 });
 test('marking traces application/ref edges without forcing discarded divergence',()=>{
  const g=new Graph({fuel:10000}),q=g.fromTernary('212110021100'),loop=g.app(q,q);
  const value=g.stem(loop);g.collect([value]);assert.equal(g.observe(value).node.child,loop);
  const result=g.app(g.fromTernary('200'),value);
  assert.equal(g.force(result),g.leaf);g.collect([result]);
  assert.equal(g.stats.nodes,2);assert.equal(g.force(result),g.leaf);
 });
 test('automatic reducer collections preserve every pre-entry caller handle',()=>{
  const g=new Graph({nodes:1000,fuel:100000},{threshold:8});
  const caller=g.fromTernary('2100'),I=g.fromTernary('21100');
  let app=g.leaf;for(let i=0;i<60;i++)app=g.app(I,app);
  assert.equal(g.force(app),g.leaf);assert.equal(g.toTernary(caller),'2100');
  assert.ok(g.stats.collections>0);g.collect([app,caller]);
  assert.ok(g.stats.reclaimed>50);assert.equal(g.force(app),g.leaf);
 });
 test('GC-enabled evaluator matches all 300 Haskell cases including all frame variants',async()=>{
  const corpus=JSON.parse(await readFile(new URL('./conformance.json',import.meta.url)));
  for(const c of corpus.cases){
   const g=new Graph({nodes:1000,fuel:100000},{threshold:8});
   const fn=g.fromTernary(c.program),args=c.arguments.map(x=>g.fromTernary(x));
   const result=g.apply(fn,args);assert.equal(g.toTernary(result),c.result);
   g.collect([result]);assert.equal(g.toTernary(result),c.result);
  }
 });
 test('collection is budgeted and commits atomically; no high-survival trace storm',()=>{
  const g=new Graph({fuel:5}),value=g.stem(g.leaf);
  assert.throws(()=>g.collect([value]),/fuel/);assert.equal(g.stats.nodes,2);assert.equal(g.stats.collections,0);
  const high=new Graph({nodes:40,fuel:2000},{threshold:2});let root=high.leaf;
  for(let i=0;i<20;i++)root=high.stem(root);
  assert.equal(high.force(root),root);assert.ok(high.stats.collections<=2);
 });
 test('owned IO collection retains saved continuations and input across pauses',async()=>{
  const g=new Graph({fuel:100000},{threshold:32});
  const action=(tag,payload=g.leaf)=>g.fork(natural(g,BigInt(tag)),payload);
  const pure=g.fork(g.leaf,natural(g,0n)); // K Leaf; the continuation ignores line data.
  const bind=action(1,g.fork(action(11),g.fork(g.leaf,action(0,text(g,'done')))));
  const io=g.fork(text(g,'tricuIO'),g.fork(natural(g,1n),bind));
  let resolve;const read=new Promise(r=>{resolve=r;});let waiting=false;
  const resultPromise=runIO(g,io,{before:async()=>{},after(){},write(){},running(){},read(){waiting=true;return read;}},true);
  while(!waiting)await Promise.resolve();
  assert.ok(g.stats.collections>=2);resolve('λ雪🙂');
  const result=await resultPromise;assert.equal(readText(g,result),'done');
  // A previously unrelated caller handle is invalidated only by the explicit
  // owned-IO contract, never by automatic reducer collections.
  assert.throws(()=>g.observe(pure),/Invalid node handle/);
 });
 test('explicit Infinity profile removes graph/fuel/stack ceilings without changing defaults',()=>{
  const bounded=new Graph({nodes:2,fuel:100,stack:1});bounded.stem(bounded.leaf);
  assert.throws(()=>bounded.stem(bounded.leaf),/allocation/);
  const g=new Graph({nodes:Infinity,fuel:Infinity,stack:Infinity},{threshold:8});
  const I=g.fromTernary('21100');let root=g.leaf;
  for(let i=0;i<100;i++)root=g.app(I,root);
  assert.equal(g.force(root),g.leaf);assert.equal(g.stats.fuel,Infinity);
  assert.ok(g.stats.collections>0);assert.ok(g.stats.work>100);
  for(const fuel of [NaN,-Infinity,0,-1,1.5])assert.throws(()=>new Graph({fuel}),/budget/);
 });
 test('owned IO extra roots preserve compiled definitions for repeated input runs',async()=>{
  const g=new Graph({fuel:100000},{threshold:32});
  const definition=g.fork(text(g,'tricuIO'),g.fork(natural(g,1n),g.fork(natural(g,11n),g.leaf)));
  const identity=g.fromTernary('21100');const roots=[definition,identity];
  let reads=0;
  for(const input of ['first','λ雪🙂','third']){
   const result=await runIO(g,definition,{before:async()=>{},after(){},write(){},running(){},read:async()=>{reads++;return input;}},true,roots.values());
   assert.equal(readText(g,result),input);g.collect(roots);
   assert.equal(g.toTernary(identity),'21100');
  }
  assert.equal(reads,3);assert.ok(g.stats.collections>=6);
  assert.ok(g.stats.fuel<100000); // Work stays cumulative across replays.
 });