tricu

haskell-session.js (5552B)

---

 import { moduleSnapshot } from './module-bundle.js';
 import { isTreeResult, treeResult } from './tree-result.js';
 import { expressionUnit, expressionDiagnostic } from './expression.js';
 // Backend-private protocol mapping. No WASM pointer, Haskell heap checkpoint or
 // fabricated graph statistic crosses into the shared site protocol.
 import { compilerDescriptor } from './compiler.js';
 import { fetchBytes } from './bundle.js';
 export class HaskellSession {
     client;
     linearMemoryBytes = 0;
     constructor(client) {
         this.client = client;
     }
     static async create(compiler) {
         const module = await import(new URL('../runtime/haskell/client.mjs', import.meta.url).href);
         const session = new HaskellSession(new module.CompilerWorker());
         try {
             const ready = await session.request({ type: 'init', compiler });
             if (compiler) {
                 const bytes = await fetchBytes(new URL('../compiler.json', import.meta.url), 4096);
                 const expected = compilerDescriptor(JSON.parse(new TextDecoder('utf-8', { fatal: true }).decode(bytes))).hash;
                 if (ready.compilerHash !== expected)
                     throw new Error('Runtime compiler pin mismatch');
             }
             session.compilerHash = ready.compilerHash ?? null;
             return session;
         }
         catch (error) {
             session.dispose();
             throw error;
         }
     }
     compilerHash = null;
     names = [];
     get disposed() { return this.client.disposed; }
     async request(message) {
         const reply = await this.client.request(message, null);
         this.linearMemoryBytes = reply.linearBytes;
         return reply;
     }
     async json(message) { return JSON.parse((await this.request(message)).text); }
     async load(bytes, hash) { this.names = await this.json({ type: 'load', bytes: new Uint8Array(bytes).buffer, hash }); }
     async compile(source, profileName, localModules = []) {
         this.names = [];
         const reply = await this.request({ type: 'compile', source, localModules, base: new URL('../', import.meta.url).href,
             ...(profileName === undefined ? {} : { profileName }) });
         const names = reply.text.trimEnd().split('\n').filter(Boolean);
         this.names = reply.scopeNames ?? names;
         return names;
     }
     async inspectModule(source) {
         return this.json({ type: 'module-header', source });
     }
     async exportModule() {
         const value = await this.json({ type: 'module-snapshot' });
         return moduleSnapshot(value.names, value.snapshot);
     }
     async run(name, args, output, mode, host) {
         return this.execute({ type: mode === 'pure' ? 'evaluate' : 'io-start', name, arguments: args, output }, output, mode, host);
     }
     async runExpression(source, output, mode, host) {
         const unit = expressionUnit(source, this.names);
         if (!this.compilerHash) {
             const bytes = await fetchBytes(new URL('../compiler.json', import.meta.url), 4096);
             const expected = compilerDescriptor(JSON.parse(new TextDecoder('utf-8', { fatal: true }).decode(bytes))).hash;
             const ready = await this.request({ type: 'compiler-init' });
             if (ready.compilerHash !== expected) {
                 this.dispose();
                 throw new Error('Runtime compiler pin mismatch');
             }
             this.compilerHash = expected;
         }
         try {
             return await this.execute({ type: 'expression', ...unit, output, mode }, output, mode, host);
         }
         catch (error) {
             throw expressionDiagnostic(error);
         }
     }
     async execute(request, output, mode, host) {
         const displayed = async (message) => {
             if (isTreeResult(output)) {
                 const snapshot = await this.json(message);
                 return treeResult(snapshot.value, output);
             }
             return this.json(message);
         };
         if (mode === 'pure')
             return displayed(request);
         try {
             let event = await this.json(request);
             while (event.kind !== 'done') {
                 let value = '';
                 switch (event.kind) {
                     case 'before':
                         await host.before({ step: event.step, name: event.name, detail: event.detail, depth: event.depth });
                         break;
                     case 'read':
                         value = await host.read();
                         break;
                     case 'write':
                         host.write(event.text);
                         break;
                     case 'after':
                         host.after({ step: event.step, name: event.name, value: event.value });
                         break;
                     default: throw new Error('Unknown runtime IO event');
                 }
                 host.running();
                 event = await this.json({ type: 'io-resume', token: event.token, value });
             }
             return await displayed({ type: 'io-view', output });
         }
         finally {
             // Release result/continuations even when decoding or a host hook fails.
             // A poisoned instance cannot be recovered by cancelling the interaction.
             if (!this.disposed)
                 await this.request({ type: 'io-cancel' });
         }
     }
     stats() { return { backend: 'haskell-wasm', linearMemoryBytes: this.linearMemoryBytes }; }
     dispose() { this.client.dispose(); }
 }