tricu

modules.test.mjs (6405B)

---

 import test from 'node:test';
 import assert from 'node:assert/strict';
 import {readFile, readdir} from 'node:fs/promises';
 import {decodeBundle, sha256} from '../dist/bundle.js';
 import {indexedObject, moduleIdentity, moduleHash} from '../dist/module-identity.js';
 import {fetchModule} from '../dist/module-resolver.js';
 import {packageIndex, packageReleases} from '../dist/packages.js';
 const site = new URL('../', import.meta.url), root = new URL('../../', site);
 const releases = packageIndex(JSON.parse(await readFile(new URL('packages.json', site))));
 const bytes = r => readFile(new URL(`bundles/${r.hash}.arboricx`, site));
 const libraries = [...new Set(releases.filter(r => r.name.startsWith('tricu-lib-')).map(r => r.name))]
   .map(name => packageReleases(releases, name)[0]);
 
 test('every library source has a complete-interface package; no module allowlist', async () => {
   const paths = [];
   async function walk(directory) {
     for (const entry of await readdir(new URL(directory, root), {withFileTypes:true})) {
       const path = directory + entry.name;
       if (entry.isDirectory()) await walk(path + '/');
       else if (entry.name.endsWith('.tri')) paths.push(path);
     }
   }
   await walk('lib/');
   assert.deepEqual(libraries.map(r => r.title).sort(), paths.sort());
   for (const cohort of ['compiler-library', 'support-library']) {
     const fixture = decodeBundle(await readFile(new URL(`test/fixtures/${cohort}.arboricx`, root)));
     const metadata = await readFile(new URL(`test/fixtures/${cohort}.v1`, root), 'utf8');
     for (const row of metadata.split('\n').filter(s => s.startsWith('module\t'))) {
       const [, , alias, path] = row.split('\t');
       if (!path.startsWith('lib/')) continue;
       const release = libraries.find(r => r.title === path);
       assert.ok(release, path);
       const bundle = decodeBundle(await bytes(release));
       assert.deepEqual(bundle.exports.map(e => e.name), fixture.exports.filter(e => e.name.startsWith(alias + '.')).map(e => e.name.slice(alias.length + 1)), path);
     }
   }
 });
 
 test('browser manifest identities match every independently native-published library interface', async () => {
   assert.ok(libraries.length > 0);
   for (const release of libraries) {
     const data = await bytes(release);
     assert.equal(await sha256(data), release.hash, release.name);
     assert.equal(await moduleIdentity(decodeBundle(data)), release.manifest, release.name);
   }
 });
 
 test('indexed extraction is name-neutral, ignores unrelated roots/metadata, preserves physical sharing', async () => {
   const b = decodeBundle(await readFile(new URL('test/fixtures/id.arboricx', root)));
   const expected = await sha256(indexedObject(b, b.exports[0].root));
   b.metadata = {description:'not executable identity'};
   b.exports[0].name = 'renamed';
   b.nodes.push({kind:'fork',left:0,right:0});
   assert.equal(await sha256(indexedObject(b, b.exports[0].root)), expected);
   const shared = {nodes:[{kind:'leaf'}],roots:[31],exports:[{name:'tree',root:31,kind:'term',abi:'arboricx.abi.tree.v1'}],metadata:{}};
   for(let i=1;i<=31;i++) shared.nodes.push({kind:'fork',left:i-1,right:i-1});
   const object = indexedObject(shared,31);
   assert.ok(object.length < 2048);
   assert.equal(decodeBundle(object).nodes.length,32);
   assert.equal((await moduleIdentity(shared)).length,64);
   await assert.rejects(moduleIdentity({...shared,exports:[]}), /nonempty native/);
   await assert.rejects(moduleIdentity({...shared,exports:[{...shared.exports[0],name:'bad name'}]}), /native module/);
   assert.throws(()=>moduleHash('../path'), /hash/);
 });
 
 test('manifest transport rejects unknown refs, wrong manifest, corrupt bytes and HTTP failure', async () => {
   const release = libraries.find(r => r.title === 'lib/packages/io.tri');
   const data = await bytes(release), calls = [], original = globalThis.fetch;
   let response = () => new Response(data);
   globalThis.fetch = async (url, options) => { calls.push({url:String(url),options}); return response(); };
   const base = new URL('https://example.invalid/nested/site/');
   try {
     const loaded = await fetchModule(base, release.manifest, releases);
     assert.equal(loaded.exports.length,6);
     assert.equal(calls[0].url, `https://example.invalid/_arboricx/bundle/hash/${release.hash}`);
     assert.deepEqual(calls[0].options, {redirect:'error',credentials:'omit'});
     const count = calls.length;
     await assert.rejects(fetchModule(base, '0'.repeat(64), releases), /Unknown module manifest/);
     await assert.rejects(fetchModule(base, release.hash, releases), /Unknown module manifest/);
     assert.equal(calls.length,count);
     await assert.rejects(fetchModule(base, '0'.repeat(64), [{...release,manifest:'0'.repeat(64)}]), /Module manifest mismatch/);
     response = () => new Response(new Uint8Array([1,2,3]));
     await assert.rejects(fetchModule(base, release.manifest, releases), /SHA-256 mismatch/);
     response = () => new Response('missing',{status:404});
     await assert.rejects(fetchModule(base, release.manifest, releases), /HTTP 404/);
     response = () => new Response(data);
     assert.equal((await fetchModule(base, release.manifest, releases)).exports.length,6);
   } finally { globalThis.fetch = original; }
 });
 
 test('native-parsed export projection retains opaque trees without evaluating them', async () => {
   const {selectModuleExports} = await import('../dist/module-stage.js');
   const value = new Proxy({}, {get(){throw Error('Executable tree must remain opaque');}});
   const locals = new Map([['private', value], ['answer', value]]);
   const dependencies = new Map([['pin', new Map([['id', value]])]]);
   const stage = exports => ({body:'',imports:[],exports,native:true});
   assert.deepEqual([...selectModuleExports(stage([['answer','']]),locals,dependencies).keys()],['answer']);
   assert.deepEqual([...selectModuleExports(stage([['*',''],['from','pin']]),locals,dependencies).keys()],['private','answer','id']);
   for(const [exports,pattern] of [[[],/requires an export/],[[['absent','']],/undeclared local/],[[['answer',''],['*','']],/duplicate export/],[[['from','missing']],/Missing re-export/]]){
     assert.throws(()=>selectModuleExports(stage(exports),locals,dependencies),pattern);
   }
   const huge = new Map(Array.from({length:4097},(_,i)=>['n'+i,value]));
   assert.throws(()=>selectModuleExports(stage([['*','']]),huge,dependencies),/export limit/);
 });