tricu

haskell-session.ts (7159B)

---

 import { drive, type Report } from './io-driver.js';
 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 {
   readonly signal: AbortSignal;
   disposed: boolean;
   request(message: object, timeout?: number | null): Promise<Reply>;
   dispose(reason?: string): void;
 }
 export class HaskellSession {
   private linearMemoryBytes = 0;
   private structuredActive = false;
   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> {
     if (this.structuredActive && !['io-session-turn', 'io-public-view', 'io-public-clear'].includes((message as { type: string }).type)) throw new Error('IO session is pending');
     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[]> {
     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: 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 runDefinitionIO(name: string, output: OutputType, host: IOHost): Promise<ValueView> {
     return this.execute({ type: 'io-definition-start', name }, output, 'io', host);
   }
   async probeIO(name: string): Promise<boolean> {
     return (await this.json<{ value: boolean }>({ type: 'probe-io', name })).value;
   }
   async inspectDefinition(name: string, output: OutputType): Promise<ValueView> {
     const message = { type: 'inspect-definition', name, output };
     if (isTreeResult(output)) {
       const snapshot = await this.json<{ value: GraphPreview }>(message);
       return treeResult(snapshot.value, output);
     }
     return this.json<ValueView>(message);
   }
   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);
     let run: string | undefined;
     try {
       const event = await this.json<{ kind: string; run: string }>({ ...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<Report>({ 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(): RuntimeStats { return { backend: 'haskell-wasm', linearMemoryBytes: this.linearMemoryBytes }; }
   dispose(): void { this.client.dispose(); }
 }