tricu

haskell-session.ts (6230B)

---

 import type { ModuleStage } from './module-stage.js';
 import { moduleSnapshot } from './module-bundle.js';
 import type { LocalModuleInput } from './local-modules.js';
 import { isTreeResult, treeResult } from './tree-result.js';
 import type { GraphPreview } from './graph.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, type BundleHash } from './bundle.js';
 import type { Literal, OutputType, ValueView } from './codecs.js';
 import type { IOHost } from './io.js';
 import type { RuntimeStats } from './runtime-backends.js';
 interface Reply { text: string; linearBytes: number; compilerHash?: string | null; scopeNames?: string[]; }
 interface Client {
   disposed: boolean;
   request(message: object, timeout?: number | null): Promise<Reply>;
   dispose(reason?: string): void;
 }
 export class HaskellSession {
   private linearMemoryBytes = 0;
   private constructor(private readonly client: Client) {}
   static async create(compiler: boolean): Promise<HaskellSession> {
     const module = await import(new URL('../runtime/haskell/client.mjs', import.meta.url).href) as { CompilerWorker: new () => Client };
     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)) as unknown).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; }
   }
   private compilerHash: string | null = null;
   private names: string[] = [];
   get disposed(): boolean { return this.client.disposed; }
   private async request(message: object): Promise<Reply> {
     const reply = await this.client.request(message, null);
     this.linearMemoryBytes = reply.linearBytes;
     return reply;
   }
   private async json<T>(message: object): Promise<T> { return JSON.parse((await this.request(message)).text) as T; }
   async load(bytes: Uint8Array, hash: BundleHash): Promise<void> { this.names = await this.json<string[]>({ type: 'load', bytes: new Uint8Array(bytes).buffer, hash }); }
   async compile(source: string, profileName?: string, localModules: LocalModuleInput[] = []): Promise<string[]> {
     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: string): Promise<ModuleStage> {
     return this.json<ModuleStage>({ type: 'module-header', source });
   }
   async exportModule(): Promise<Uint8Array> {
     const value = await this.json<{ names: string[]; snapshot: GraphPreview }>({ type: 'module-snapshot' });
     return moduleSnapshot(value.names, value.snapshot);
   }
   async run(name: string, args: Literal[], output: OutputType, mode: 'pure' | 'io', host: IOHost): Promise<ValueView> {
     return this.execute({ type: mode === 'pure' ? 'evaluate' : 'io-start', name, arguments: args, output }, output, mode, host);
   }
   async runExpression(source: string, output: OutputType, mode: 'pure' | 'io', host: IOHost): Promise<ValueView> {
     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)) as unknown).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); }
   }
   private async execute(request: object, output: OutputType, mode: 'pure' | 'io', host: IOHost): Promise<ValueView> {
     const displayed = async (message: object): Promise<ValueView> => {
       if (isTreeResult(output)) {
         const snapshot = await this.json<{ value: GraphPreview }>(message);
         return treeResult(snapshot.value, output);
       }
       return this.json<ValueView>(message);
     };
     if (mode === 'pure') return displayed(request);
     type Event = { kind: string; token: number; step: number; name: string; detail: string; depth: number; value: string; text: string };
     try {
       let event = await this.json<Event>(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<Event>({ 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(): RuntimeStats { return { backend: 'haskell-wasm', linearMemoryBytes: this.linearMemoryBytes }; }
   dispose(): void { this.client.dispose(); }
 }