tricu

io-terminal.ts (3272B)

---

 // Terminal provider; cloneable identities only, independent of evaluators.
 import type { Event, Completion } from './io-events.js';
 import { OutputBuffer } from './io-output.js';
 export type Reply = Completion & { run: string; id: number };
 export class Terminal {
   readonly output = new OutputBuffer();
   private nextAfter = 0;
   private reader: Extract<Event, { kind: 'read' }> | undefined;
   private buffered: number[] = [];
   private eof = false;
   private ended = false;
   constructor(readonly run: string) {
     if (!/^[1-9][0-9]*$/.test(run) || run.length > 20 || BigInt(run) > 0xffffffffffffffffn) throw new Error('invalid terminal run');
   }
   get waiting(): { run: string; id: number } | undefined {
     return this.reader ? { run: this.run, id: this.reader.id } : undefined;
   }
   private read(): Reply | undefined {
     const reader = this.reader;
     if (!reader || !this.buffered.length && !this.eof) return;
     const bytes = this.buffered.splice(0, reader.limit); this.reader = undefined;
     return { run: this.run, id: reader.id, kind: 'read', bytes, eof: bytes.length === 0 };
   }
   handle(event: Event): Reply | undefined {
     if (this.ended || event.run !== this.run || !Number.isSafeInteger(event.id) || event.id < 1) throw new Error('invalid terminal event');
     if (event.kind === 'cancel') {
       if (event.id > this.nextAfter || !['read', 'write'].includes(event.operation)) throw new Error('invalid terminal cancellation');
       // Completed synchronous writes/reads already have a normal acknowledgement
       // queued. A racing abort does not erase it or manufacture a second reply.
       if (this.reader?.id !== event.id) return;
       if (event.operation !== 'read') throw new Error('invalid terminal cancellation');
       this.reader = undefined;
       return { run: this.run, id: event.id, kind: 'cancelled' };
     }
     if (event.id <= this.nextAfter) throw new Error('stale terminal event');
     if (event.kind === 'read') {
       if (this.reader || !Number.isInteger(event.limit) || event.limit < 1 || event.limit > 4096) throw new Error('invalid terminal read');
       this.reader = { ...event };
     } else if (event.kind === 'write') this.output.append(event.stream, event.bytes);
     else throw new Error('invalid terminal operation');
     this.nextAfter = event.id;
     return event.kind === 'read' ? this.read() : { run: this.run, id: event.id, kind: 'write', count: event.bytes.length };
   }
   // Explicit one-line UI: no CR/LF in the submitted text, append ONE LF; an
   // empty line is data, never EOF. Scalars, not UTF-16 code units, are bounded.
   line(run: string, id: number, value: unknown): Reply | undefined {
     if (run !== this.run || this.reader?.id !== id || typeof value !== 'string' || value.length > 512 ||
         /[\r\n\uD800-\uDFFF]/u.test(value) || Array.from(value).length > 256) return;
     this.buffered = [...new TextEncoder().encode(value), 10];
     return this.read();
   }
   endInput(run: string, id: number): Reply | undefined {
     if (run !== this.run || this.reader?.id !== id) return;
     this.eof = true; return this.read();
   }
   finish(): void {
     if (this.reader) throw new Error('terminal input still pending');
     this.ended = true; this.buffered = []; this.output.finish();
   }
 }