tricu

haskell-session.js (6205B)

---

 import { drive } from './io-driver.js';
 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;
     structuredActive = false;
     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) {
         if (this.structuredActive && !['io-session-turn', 'io-public-view', 'io-public-clear'].includes(message.type))
             throw new Error('IO session is pending');
         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 = []) {
         if (this.structuredActive)
             throw new Error('IO session is pending');
         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 runDefinitionIO(name, output, host) {
         return this.execute({ type: 'io-definition-start', name }, output, 'io', host);
     }
     async probeIO(name) {
         return (await this.json({ type: 'probe-io', name })).value;
     }
     async inspectDefinition(name, output) {
         const message = { type: 'inspect-definition', name, output };
         if (isTreeResult(output)) {
             const snapshot = await this.json(message);
             return treeResult(snapshot.value, output);
         }
         return this.json(message);
     }
     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);
         let run;
         try {
             const event = await this.json({ ...request, selectIO: true, ioStep: host.structured?.stepping === true });
             if (event.kind !== 'v2')
                 throw new Error('Unsupported tricuIO version');
             this.structuredActive = true;
             run = event.run;
             if (!host.structured)
                 throw new Error('IO version 2 requires a structured terminal host');
             host.selected?.(2);
             return await drive({ run, signal: this.client.signal, discard: () => this.dispose(),
                 turn: command => this.json({ type: 'io-session-turn', ...command }),
                 view: () => displayed({ type: 'io-public-view', run, output }), }, host);
         }
         finally {
             // Release result/continuations even when decoding or a host hook fails.
             // A poisoned instance cannot be recovered by cancelling the interaction.
             if (run !== undefined && !this.disposed)
                 await this.request({ type: 'io-public-clear', run });
             this.structuredActive = false;
         }
     }
     stats() { return { backend: 'haskell-wasm', linearMemoryBytes: this.linearMemoryBytes }; }
     dispose() { this.client.dispose(); }
 }