tricu

compiler.ts (3844B)

---

 import { bundleHash, type BundleHash } from './bundle.js';
 import { Graph, type NodeId } from './graph.js';
 import { text, readText, readList, readNatural } from './codecs.js';
 export const COMPILER_EXPORT = 'source_unit.compileStableModuleDefinitions';
 export function compilerDescriptor(raw: unknown): { hash: BundleHash } {
   if (!raw || typeof raw !== 'object' || Array.isArray(raw)) throw new Error('Invalid compiler descriptor');
   const descriptor = raw as Record<string, unknown>;
   if (descriptor['schema'] !== 1 || descriptor['backend'] !== 'stable' || descriptor['export'] !== COMPILER_EXPORT) throw new Error('Invalid stable compiler descriptor');
   return { hash: bundleHash(descriptor['hash']) };
 }
 export const COMPILER_COLLECTION = Object.freeze({ threshold: 250_000 });
 export const SOURCE_LIMIT = 16_384;
 export function sourceText(source: unknown): string {
   if (typeof source !== 'string' || !source.trim()) throw new Error('Enter a source unit or native module');
   if (source.length > SOURCE_LIMIT * 2) throw new Error('Source limit exceeded');
   let count = 0;
   for (const char of source) {
     if (++count > SOURCE_LIMIT) throw new Error('Source limit exceeded');
     const scalar = char.codePointAt(0)!;
     if (scalar >= 0xd800 && scalar <= 0xdfff) throw new Error('Unpaired source surrogate');
   }
   return source;
 }
 export function sourceLiteral(graph: Graph, source: unknown): NodeId {
   return text(graph, sourceText(source), SOURCE_LIMIT);
 }
 export function compilerDiagnostic(graph: Graph, payload: NodeId): string {
   const [diagnostic] = graph.pair(payload, 'compiler error payload');
   const [code, tail] = graph.pair(diagnostic, 'diagnostic code');
   const [expected, fields] = graph.pair(tail, 'diagnostic expected');
   const [, locationFields] = graph.pair(fields, 'diagnostic found');
   const [location] = graph.pair(locationFields, 'diagnostic location');
   let where = '';
   if (graph.observe(location).node.kind !== 'leaf') {
     const [line, rest] = graph.pair(location, 'source position'), [column] = graph.pair(rest, 'source column');
     where = ` at ${readNatural(graph, line)}:${readNatural(graph, column)}`;
   }
   // Expected can be a token-kind number or a label; found/context/remainder
   // may be arbitrary trees. Decode only the compiler's known diagnostic profile.
   const number = readNatural(graph, code);
   const label = number === 2n ? `: expected token kind ${readNatural(graph, expected)}`
     : number === 20n ? `: unresolved name ${JSON.stringify(readText(graph, expected, 512))}`
     : number >= 30n ? `: expected ${JSON.stringify(readText(graph, expected, 512))}` : '';
   return `Compiler diagnostic ${number}${where}${label}`;
 }
 // Decode only the result spine/names. Compiled program trees remain lazy handles.
 // Do not normalize/serialize them merely to populate an export selector.
 export function compiledDefinitions(graph: Graph, result: NodeId, allowEmpty = false): Map<string, NodeId> {
   const [tag, payload] = graph.pair(result, 'compiler result');
   const flag = graph.observe(tag).node;
   if (flag.kind === 'leaf') throw new Error(compilerDiagnostic(graph, payload));
   if (flag.kind !== 'stem' || graph.observe(flag.child).node.kind !== 'leaf') throw new Error('Invalid compiler result tag');
   const [definitions] = graph.pair(payload, 'compiler definitions payload');
   const bindings = readList(graph, definitions, 16), exports = new Map<string, NodeId>();
   for (const binding of bindings) {
     const [nameTree, program] = graph.pair(binding, 'compiled binding');
     const name = readText(graph, nameTree, 128);
     if (!name || exports.has(name)) throw new Error('Empty/duplicate compiled definition name');
     exports.set(name, program);
   }
   if (!exports.size && !allowEmpty) throw new Error('Source unit produced no definitions');
   return exports;
 }