tricu

module-stage.ts (4481B)

---

 // Decode the pinned native compiler's header API.
 import type { Graph, NodeId } from './graph.js';
 import { readList, readText, text } from './codecs.js';
 import { compilerDiagnostic, SOURCE_LIMIT } from './compiler.js';
 import { fetchBytes, decodeBundle, type Bundle } from './bundle.js';
 import { packageIndex } from './packages.js';
 import { localModuleInputs, validateLocalModule, type LocalModuleInput } from './local-modules.js';
 import { fetchModule } from './module-resolver.js';
 export interface ModuleStage {
   body: string;
   imports: [string, string][]; // immutable reference, qualifier (or *)
   exports: [string, string][]; // local name/*, or from + immutable reference
   native: boolean;
 }
 export function stageModule(graph: Graph, library: Map<string, NodeId>, source: string): ModuleStage {
   const call = (name: string, argument: NodeId): NodeId => {
     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: NodeId, diagnostic = false): NodeId => {
     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: NodeId, helper: string): [string, string][] => 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: URL, stage: ModuleStage, local: LocalModuleInput[] = []): Promise<Map<string, Bundle>> {
   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<string, Bundle>();
   if (!refs.length) return result;
   const available = new Map(localModuleInputs(local).map(entry => [entry.manifest, entry]));
   let index: ReturnType<typeof packageIndex> | undefined;
   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))) as unknown);
       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<T>(stage: ModuleStage, locals: Map<string, T>, modules: Map<string, Map<string, T>>): Map<string, T> {
   const selected = new Map<string, T>();
   const add = (name: string, tree: T): void => {
     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;
 }