tricu

module-stage.js (4170B)

---

 import { readList, readText, text } from './codecs.js';
 import { compilerDiagnostic, SOURCE_LIMIT } from './compiler.js';
 import { fetchBytes, decodeBundle } from './bundle.js';
 import { packageIndex } from './packages.js';
 import { localModuleInputs, validateLocalModule } from './local-modules.js';
 import { fetchModule } from './module-resolver.js';
 export function stageModule(graph, library, source) {
     const call = (name, argument) => {
         const f = library.get('source_module.' + name);
         if (f === undefined)
             throw new Error('Missing native module compiler helper');
         return graph.apply(f, [argument]);
     };
     const value = (result, diagnostic = false) => {
         const [tag, payload] = graph.pair(result), flag = graph.observe(tag).node;
         if (flag.kind === 'leaf')
             throw new Error(diagnostic ? compilerDiagnostic(graph, payload) : readText(graph, graph.pair(payload)[0], 512));
         if (flag.kind !== 'stem' || graph.observe(flag.child).node.kind !== 'leaf')
             throw new Error('Invalid native module result');
         return graph.pair(payload)[0];
     };
     const [edges, rest] = graph.pair(value(call('sourceModuleHeaderStage', text(graph, source, SOURCE_LIMIT)), true));
     if (readList(graph, edges, SOURCE_LIMIT).length)
         throw new Error('Browser modules require manifest hashes; workspace and build-only sources are unavailable');
     const [uses, tail] = graph.pair(rest), [exports, body] = graph.pair(tail);
     const shapes = (rows, helper) => readList(graph, rows, SOURCE_LIMIT).map(row => {
         const [a, b] = graph.pair(value(call(helper, row)));
         return [readText(graph, a, 128), readText(graph, b, 128)];
     });
     const imports = shapes(uses, 'sourceModuleUseShape'), selected = shapes(exports, 'sourceModuleExportShape');
     return { body: readText(graph, body, SOURCE_LIMIT), imports, exports: selected, native: !!(imports.length || selected.length) };
 }
 export async function moduleDependencies(base, stage, local = []) {
     const refs = [...new Set([...stage.imports.map(i => i[0]), ...stage.exports.filter(e => e[0] === 'from').map(e => e[1])])];
     const result = new Map();
     if (!refs.length)
         return result;
     const available = new Map(localModuleInputs(local).map(entry => [entry.manifest, entry]));
     let index;
     for (const ref of refs) {
         const entry = available.get(ref);
         if (entry) {
             const checked = await validateLocalModule(entry.bytes);
             if (checked.manifest !== ref)
                 throw new Error('Local module manifest mismatch');
             result.set(ref, decodeBundle(checked.bytes));
         }
         else {
             index ??= packageIndex(JSON.parse(new TextDecoder('utf-8', { fatal: true }).decode(await fetchBytes(new URL('packages.json', base), 2_097_152))));
             result.set(ref, await fetchModule(base, ref, index));
         }
     }
     return result;
 }
 // Projection of already native-parsed export requests onto backend-owned trees.
 // Keep executable trees as backend-owned handles during interface selection.
 export function selectModuleExports(stage, locals, modules) {
     const selected = new Map();
     const add = (name, tree) => {
         if (selected.has(name))
             throw new Error('duplicate export');
         if (selected.size >= 4096)
             throw new Error('Module export limit exceeded');
         selected.set(name, tree);
     };
     for (const [name, ref] of stage.exports) {
         if (name === 'from') {
             const values = modules.get(ref);
             if (!values)
                 throw new Error('Missing re-export dependency');
             for (const [key, value] of values)
                 add(key, value);
         }
         else if (name === '*') {
             for (const [key, value] of locals)
                 add(key, value);
         }
         else {
             if (!locals.has(name))
                 throw new Error('undeclared local export');
             add(name, locals.get(name));
         }
     }
     if (!selected.size)
         throw new Error('module requires an export');
     return selected;
 }