tricu

compiler-worker.ts (7176B)

---

 import { compileExpression } from './expression.js';
 import { resumeValue } from './io.js';
 import { environmentProfile } from './packages.js';
 import { BROWSER_BUDGET, collectionPolicy } from './execution.js';
 import { contractEnvironment } from './contracts.js';
 import { Graph, type NodeId } from './graph.js';
 import { COMPILER_BUNDLE_LIMIT, fetchBundle, fetchBytes, loadBundle } from './bundle.js';
 import { literals, makeLiteral, outputType, view, list, text } from './codecs.js';
 import { runIO } from './io.js';
 import { COMPILER_EXPORT, compilerDescriptor, sourceLiteral, sourceText, compiledDefinitions } from './compiler.js';
 import type { CompilerClient, CompilerMessage } from './compiler-protocol.js';
 import type { RequestId } from './protocol.js';
 const scope = globalThis as unknown as { postMessage(message: CompilerMessage): void; onmessage: ((event: MessageEvent<unknown>) => void) | null };
 const base = new URL('../', import.meta.url);
 const send = (message: CompilerMessage): void => scope.postMessage(message);
 const running = (): void => send({ type: 'state', state: 'running' });
 let phase: 'empty' | 'compiling' | 'ready' | 'running' | 'done' = 'empty';
 let graph: Graph | undefined, exports: Map<string, NodeId> | undefined;
 let requestId = 0;
 let pending: { id: RequestId; kind: 'step' | 'input'; resolve(value: string): void; reject(error: Error): void } | undefined;
 function request(kind: 'step' | 'input'): Promise<string> {
   if (pending) throw new Error('Driver already waiting');
   const id = ++requestId as RequestId;
   return new Promise((resolve, reject) => { pending = { id, kind, resolve, reject }; send({ type: 'state', state: kind, id }); });
 }
 async function compile(source: unknown, profileName?: string): Promise<void> {
   phase = 'compiling'; running(); const start = performance.now();
   const budget = BROWSER_BUDGET;
   graph = new Graph(budget, collectionPolicy(budget));
   const input = sourceLiteral(graph, source); // Validate before downloading a compiler.
   const bytes = await fetchBytes(new URL('compiler.json', base), 4096);
   const raw: unknown = JSON.parse(new TextDecoder('utf-8', { fatal: true }).decode(bytes));
   const { hash } = compilerDescriptor(raw);
   const bundle = await fetchBundle(new URL(`/_arboricx/bundle/hash/${hash}`, base), hash, COMPILER_BUNDLE_LIMIT);
   const library = loadBundle(graph, bundle), compiler = library.get(COMPILER_EXPORT);
   if (compiler === undefined) throw new Error('Missing stable compiler entrypoint');
   let environment: NodeId;
   if (profileName === undefined) environment = contractEnvironment(graph, library);
   else {
     const bytes = await fetchBytes(new URL('environments.json', base), 32_768);
     const selected = environmentProfile(JSON.parse(new TextDecoder('utf-8', { fatal: true }).decode(bytes)) as unknown, profileName);
     if (selected.compiler !== hash) throw new Error('Demo environment/compiler pin mismatch');
     const bindings: NodeId[] = [];
     if (selected.profile) {
       const support = await fetchBundle(new URL(`/_arboricx/bundle/hash/${selected.profile.hash}`, base), selected.profile.hash);
       const values = loadBundle(graph, support);
       for (const name of selected.profile.names) {
         const tree = values.get(name);
         if (tree === undefined) throw new Error(`Missing demo environment binding ${name}`);
         bindings.push(graph.fork(text(graph, name), tree));
       }
     }
     environment = list(graph, bindings);
   }
   exports = compiledDefinitions(graph, graph.apply(compiler, [environment, input]));
   graph.collect(exports.values()); // Safe phase boundary; compiler/input temporaries are no longer caller roots.
   phase = 'ready'; send({ type: 'compiled', names: [...exports.keys()], draft: { graph: graph.checkpoint(), exports: [...exports] }, stats: graph.stats, milliseconds: performance.now() - start });
 }
 async function run(message: Extract<CompilerClient, { type: 'run' }>): Promise<void> {
   if (!graph || !exports) throw new Error('Compile a unit first');
   phase = 'running'; running();
   const fn = message.expression === undefined ? exports.get(message.export) : await compileExpression(graph, exports, message.expression);
   if (fn === undefined) throw new Error('Unknown compiled definition');
   if (message.mode !== 'pure' && message.mode !== 'io') throw new Error('Unsupported execution mode');
   const type = outputType(message.output), args = literals(message.arguments).map(value => makeLiteral(graph!, value));
   let result = message.expression === undefined ? graph.apply(fn, args) : fn;
   if (message.mode === 'io') result = await runIO(graph, result, {
     async before(event) { send({ type: 'trace', phase: 'before', event }); if (message.step) await request('step'); running(); },
     after(event) { send({ type: 'trace', phase: 'after', event }); }, write(text) { send({ type: 'output', text }); },
     read() { return request('input'); }, running,
   }, true, exports.values());
   const displayed = view(graph, result, type);
   graph.collect(exports.values()); // Drop this run's temporaries, retaining every definition.
   phase = 'ready'; send({ type: 'done', result: displayed, stats: graph.stats });
 }
 scope.onmessage = ({ data }) => {
   if (!data || typeof data !== 'object' || Array.isArray(data)) return;
   const message = data as Record<string, unknown>;
   if (message['type'] === 'resume') {
     if (!pending || message['id'] !== pending.id) return;
     const value = resumeValue(pending.kind, message['value']);
     if (value === undefined) return;
     const waiter = pending; pending = undefined; waiter.resolve(value);
     return;
   }
   let operation: Promise<void>;
   try {
     if (message['type'] === 'restore' && phase === 'empty') {
       // Only the owning page supplies this trusted in-memory checkpoint.
       const restored = data as Extract<CompilerClient, { type: 'restore' }>;
       const budget = BROWSER_BUDGET;
       graph = Graph.restore(restored.draft.graph, budget, collectionPolicy(budget));
       exports = new Map(restored.draft.exports); phase = 'ready'; return;
     } else if (message['type'] === 'compile' && phase === 'empty') {
       if (message['environment'] !== undefined && (typeof message['environment'] !== 'string' || message['environment'].length > 128)) throw new Error('Invalid demo environment');
       operation = compile(message['source'], message['environment'] as string | undefined);
     } else if (message['type'] === 'run' && phase === 'ready') {
       if (typeof message['export'] !== 'string' || message['export'].length > 128) throw new Error('Invalid compiled selection');
       operation = run({ type: 'run', export: message['export'], arguments: message['arguments'],
         ...(message['expression'] === undefined ? {} : { expression: sourceText(message['expression']) }),
         output: outputType(message['output']), mode: message['mode'] as 'pure' | 'io', step: message['step'] === true });
     } else return;
   } catch (error) { operation = Promise.reject(error); }
   operation.catch((error: unknown) => { phase = 'done'; send({ type: 'error', message: error instanceof Error ? error.message : String(error) }); });
 };