tricu

compiler-worker.js (6921B)

---

 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 } 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';
 const scope = globalThis;
 const base = new URL('../', import.meta.url);
 const send = (message) => scope.postMessage(message);
 const running = () => send({ type: 'state', state: 'running' });
 let phase = 'empty';
 let graph, exports;
 let requestId = 0;
 let pending;
 function request(kind) {
     if (pending)
         throw new Error('Driver already waiting');
     const id = ++requestId;
     return new Promise((resolve, reject) => { pending = { id, kind, resolve, reject }; send({ type: 'state', state: kind, id }); });
 }
 async function compile(source, profileName) {
     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 = 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;
     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)), profileName);
         if (selected.compiler !== hash)
             throw new Error('Demo environment/compiler pin mismatch');
         const bindings = [];
         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) {
     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;
     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;
     try {
         if (message['type'] === 'restore' && phase === 'empty') {
             // Only the owning page supplies this trusted in-memory checkpoint.
             const restored = data;
             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']);
         }
         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'], step: message['step'] === true });
         }
         else
             return;
     }
     catch (error) {
         operation = Promise.reject(error);
     }
     operation.catch((error) => { phase = 'done'; send({ type: 'error', message: error instanceof Error ? error.message : String(error) }); });
 };