tricu

worker.ts (5854B)

---

 // Test-only JS evaluator driver; excluded from the production site.
 import { sourceText } from '../compiler.js';
 import { compileExpression } from './expression.js';
 import { resumeValue } from '../io.js';
 import { publishedBundle } from '../published-bundle.js';
 import { exportTree, treeFormat } from '../tree-export.js';
 import { BROWSER_BUDGET, collectionPolicy, PACKAGE_COLLECTION } from '../execution.js';
 import { Graph } from '../graph.js';
 import { bundleHash, loadBundle, type Bundle, type BundleHash } from '../bundle.js';
 import { literals, makeLiteral, outputType, view } from '../codecs.js';
 import { runIO } from '../io.js';
 import type { ClientMessage, WorkerMessage, RequestId } from '../protocol.js';
 const scope = globalThis as unknown as { postMessage(message: WorkerMessage): void; onmessage: ((event: MessageEvent<unknown>) => void) | null };
 const send = (message: WorkerMessage): void => scope.postMessage(message);
 const running = (): void => send({ type: 'state', state: 'running' });
 let phase: 'empty' | 'loading' | 'ready' | 'running' | 'done' = 'empty';
 let graph: Graph | undefined, exports: Map<string, import('../graph.js').NodeId> | undefined;
 let stored: { hash: BundleHash; bundle: Bundle; bytes: Uint8Array } | 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 load(hash: BundleHash, localId: string | undefined): Promise<void> {
   phase = 'loading'; running();
   const loaded = await publishedBundle(hash, localId);
   const { bundle, source } = loaded;
   stored = loaded;
   const budget = BROWSER_BUDGET;
   graph = new Graph(budget, collectionPolicy(budget, PACKAGE_COLLECTION.threshold)); exports = loadBundle(graph, bundle);
   phase = 'ready';
   send({ type: 'loaded', hash, exports: bundle.exports, nodes: bundle.nodes.length, metadata: bundle.metadata, source });
 }
 async function run(message: Extract<ClientMessage, { type: 'run' }>): Promise<void> {
   if (phase !== 'ready' || !graph || !exports) throw new Error('Load a bundle before running');
   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 export');
   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;
   graph.collect([result]); // Exclusive one-run session: only this application remains owned.
   if (message.mode === 'io') result = await runIO(graph, result, {
     async before(event) { send({ type: 'trace', phase: 'before', event }); if (message.step === true) await request('step'); running(); },
     after(event) { send({ type: 'trace', phase: 'after', event }); },
     write(text) { send({ type: 'output', text }); }, read() { return request('input'); }, running,
   }, true);
   const displayed = view(graph, result, type);
   phase = 'done'; 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;
   }
   if (message['type'] === 'download' && phase === 'ready' && stored) {
     send({ type: 'downloaded', hash: stored.hash, bytes: stored.bytes }); return;
   }
   if (message['type'] === 'export' && phase === 'ready' && stored) {
     try {
       if (typeof message['export'] !== 'string' || message['export'].length > 512) throw new Error('Invalid export selection');
       const format = treeFormat(message['format']);
       const file = exportTree(stored.bundle, message['export'], format);
       send({ type: 'exported', hash: stored.hash, export: message['export'], format, file });
     } catch (error) { send({ type: 'export-error', message: error instanceof Error ? error.message : String(error) }); }
     return;
   }
   let operation: Promise<void>;
   try {
     if (message['type'] === 'load' && phase === 'empty') {
       const localId = message['localId'];
       if (localId !== undefined && (typeof localId !== 'string' || localId.length > 128)) throw new Error('Invalid catalogue ID');
       operation = load(bundleHash(message['hash']), localId);
     } else if (message['type'] === 'run' && phase === 'ready') {
       if (typeof message['export'] !== 'string' || message['export'].length > 512) throw new Error('Invalid export 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; // A Worker owns exactly one load and one run, no racing sessions.
   } catch (error) { operation = Promise.reject(error); }
   operation.catch((error: unknown) => { phase = 'done'; send({ type: 'error', message: error instanceof Error ? error.message : String(error) }); });
 };