tricu

modules.test.mjs (8953B)

---

 import test from 'node:test';
 import assert from 'node:assert/strict';
 import {readFile, readdir} from 'node:fs/promises';
 import {createHash} from 'node:crypto';
 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/');
   // Historical package names remain indexed when an authored workspace alias
   // changes. Check every source and its current alias, not an allowlist or the
   // first historical release carrying the same source-path title.
   // Immutable releases can outlive their source filenames. Only the explicit
   // historical IO paths are absent; every current source still needs its exact
   // authored alias and independently checked full interface below.
   const historicalPaths = new Set(['lib/io-v2.tri','lib/io-v2/artifacts.tri',
     'lib/io-v2/http-transport.tri','lib/io-v2/objects.tri','lib/io-v2/storage.tri',
     'lib/io-v2/text.tri','lib/source/io-v2.tri','lib/arboricx/streaming-v2.tri',
     'lib/packages/io-v2.tri']);
   assert.deepEqual([...new Set(libraries.filter(r => !historicalPaths.has(r.title)).map(r => r.title))].sort(), paths.sort());
   const workspace=(await readFile(new URL('tricu.workspace',root),'utf8')).trimEnd().split('\n');
   assert.equal(workspace.shift(),'tricu.workspace.v1');
   const aliases=new Map(workspace.map(row=>{const [alias,path]=row.split('\t');return [path,alias];}));
   const currentLibrary=path=>libraries.find(r=>r.name==='tricu-lib-'+
     (aliases.get(path)??path.slice(4,-4).replaceAll('/','_').replaceAll('-','_')).replaceAll('_','-'));
   for(const path of paths){const release=currentLibrary(path);assert.ok(release,path);assert.equal(release.title,path);}
   for (const cohort of ['compiler-library', 'support-library']) {
     // The aggregate native support fixture exceeds the browser's per-module
     // node bound. Compare its independently authenticated native manifests,
     // not a relaxed browser decoder. Every actual published module below still
     // passes the unchanged browser transport/graph bounds.
     const fixtureBytes = await readFile(new URL(`test/fixtures/${cohort}.arboricx`, root));
     const fixture = cohort === 'compiler-library' ? decodeBundle(fixtureBytes) : null;
     if (!fixture) assert.throws(() => decodeBundle(fixtureBytes), /Bundle node count limit exceeded/);
     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 = currentLibrary(path);
       assert.ok(release, path);
       const bundle = decodeBundle(await bytes(release));
       let expected;
       if (fixture) expected = fixture.exports.filter(e => e.name.startsWith(alias + '.')).map(e => e.name.slice(alias.length + 1));
       else {
         const manifest = await readFile(new URL(`test/fixtures/support-receipts/${alias}.manifest`, root));
         const record = metadata.split('\n').find(line => line.startsWith(`rebuilt\t${alias}\t`)).split('\t');
         assert.equal(createHash('sha256').update('arboricx.module-manifest.v1\0').update(manifest).digest('hex'), record[3]);
         const rows = manifest.toString('utf8').trimEnd().split('\n'); assert.equal(rows.shift(), 'arboricx.module-manifest.v1');
         expected = rows.map(line => { const fields = line.split('\t'); assert.equal(fields.length, 5); assert.equal(fields[0], 'export'); return fields[1]; });
       }
       assert.deepEqual(bundle.exports.map(e => e.name), expected, 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/);
 });