green-screen-proxy 0.3.0

package/dist/cli.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/cli.js

@@ -0,0 +1,32 @@
+#!/usr/bin/env node
+import { parseArgs } from 'node:util';
+const { values } = parseArgs({
+    options: {
+        mock: { type: 'boolean', default: false },
+        port: { type: 'string', default: '' },
+        help: { type: 'boolean', short: 'h', default: false },
+    },
+});
+if (values.help) {
+    console.log(`green-screen-proxy — WebSocket/REST proxy for legacy terminal connections
+
+Usage: green-screen-proxy [options]
+
+Options:
+  --mock       Run with mock data (no real host connection needed)
+  --port NUM   Port to listen on (default: 3001, or PORT env var)
+  -h, --help   Show this help message
+
+Examples:
+  npx green-screen-proxy                  # Start proxy on port 3001
+  npx green-screen-proxy --mock           # Start with mock screens
+  npx green-screen-proxy --port 8080      # Start on port 8080`);
+    process.exit(0);
+}
+if (values.port) {
+    process.env.PORT = values.port;
+}
+if (values.mock) {
+    process.argv.push('--mock');
+}
+await import('./server.js');

package/dist/hp6530/connection.d.ts

@@ -0,0 +1,51 @@
+import { EventEmitter } from 'events';
+export interface ConnectionEvents {
+    connected: () => void;
+    disconnected: () => void;
+    data: (data: Buffer) => void;
+    error: (err: Error) => void;
+}
+/**
+ * Manages a TCP/Telnet connection to an HP NonStop (Tandem) system.
+ *
+ * HP 6530 terminals use standard Telnet negotiation but differ from
+ * TN5250/TN3270 in that data is stream-based — there are no IAC EOR
+ * delimited records. Instead, the host sends escape sequences inline
+ * and block-mode data transfer uses DC1 (XON) / DC3 (XOFF) for flow
+ * control.
+ */
+export declare class HP6530Connection extends EventEmitter {
+    private socket;
+    private host;
+    private port;
+    private _connected;
+    private recvBuffer;
+    /** Whether we are in XOFF state (host asked us to pause sending) */
+    private xoff;
+    /** Queue of outbound data waiting for XON */
+    private sendQueue;
+    get isConnected(): boolean;
+    get remoteHost(): string;
+    get remotePort(): number;
+    connect(host: string, port: number): Promise<void>;
+    disconnect(): void;
+    /** Send raw bytes over the socket, respecting XON/XOFF flow control */
+    sendRaw(data: Buffer): void;
+    private cleanup;
+    private onData;
+    /**
+     * Process the receive buffer. We need to:
+     * 1. Handle Telnet IAC sequences (negotiation)
+     * 2. Handle DC1/DC3 flow control characters
+     * 3. Pass remaining data (escape sequences + printable chars) to the parser
+     */
+    private processBuffer;
+    private emitData;
+    private flushSendQueue;
+    /** Find IAC SE sequence for subnegotiation end */
+    private findSubnegEnd;
+    private handleNegotiation;
+    private handleSubnegotiation;
+    private sendTerminalType;
+    private sendTelnet;
+}

package/dist/hp6530/connection.js

@@ -0,0 +1,258 @@
+import * as net from 'net';
+import { EventEmitter } from 'events';
+import { TELNET } from '../tn5250/constants.js';
+import { TERMINAL_TYPE, CTRL } from './constants.js';
+/**
+ * Manages a TCP/Telnet connection to an HP NonStop (Tandem) system.
+ *
+ * HP 6530 terminals use standard Telnet negotiation but differ from
+ * TN5250/TN3270 in that data is stream-based — there are no IAC EOR
+ * delimited records. Instead, the host sends escape sequences inline
+ * and block-mode data transfer uses DC1 (XON) / DC3 (XOFF) for flow
+ * control.
+ */
+export class HP6530Connection extends EventEmitter {
+    socket = null;
+    host = '';
+    port = 23;
+    _connected = false;
+    recvBuffer = Buffer.alloc(0);
+    /** Whether we are in XOFF state (host asked us to pause sending) */
+    xoff = false;
+    /** Queue of outbound data waiting for XON */
+    sendQueue = [];
+    get isConnected() {
+        return this._connected;
+    }
+    get remoteHost() {
+        return this.host;
+    }
+    get remotePort() {
+        return this.port;
+    }
+    connect(host, port) {
+        return new Promise((resolve, reject) => {
+            if (this.socket) {
+                this.disconnect();
+            }
+            this.host = host;
+            this.port = port;
+            this.recvBuffer = Buffer.alloc(0);
+            this.xoff = false;
+            this.sendQueue = [];
+            this.socket = new net.Socket();
+            this.socket.setTimeout(30000);
+            const onError = (err) => {
+                this.cleanup();
+                reject(err);
+            };
+            this.socket.once('error', onError);
+            this.socket.connect(port, host, () => {
+                this._connected = true;
+                this.socket.removeListener('error', onError);
+                this.socket.on('error', (err) => {
+                    this.emit('error', err);
+                    this.cleanup();
+                });
+                this.socket.on('close', () => {
+                    this.cleanup();
+                    this.emit('disconnected');
+                });
+                this.socket.on('timeout', () => {
+                    this.emit('error', new Error('Connection timeout'));
+                });
+                this.socket.on('data', (data) => this.onData(data));
+                this.emit('connected');
+                resolve();
+            });
+        });
+    }
+    disconnect() {
+        if (this.socket) {
+            this.socket.destroy();
+            this.cleanup();
+        }
+    }
+    /** Send raw bytes over the socket, respecting XON/XOFF flow control */
+    sendRaw(data) {
+        if (!this.socket || !this._connected)
+            return;
+        if (this.xoff) {
+            // Queue data until we receive XON
+            this.sendQueue.push(data);
+            return;
+        }
+        this.socket.write(data);
+    }
+    cleanup() {
+        this._connected = false;
+        this.xoff = false;
+        this.sendQueue = [];
+        if (this.socket) {
+            this.socket.removeAllListeners();
+            this.socket.destroy();
+            this.socket = null;
+        }
+    }
+    onData(data) {
+        this.recvBuffer = Buffer.concat([this.recvBuffer, data]);
+        this.processBuffer();
+    }
+    /**
+     * Process the receive buffer. We need to:
+     * 1. Handle Telnet IAC sequences (negotiation)
+     * 2. Handle DC1/DC3 flow control characters
+     * 3. Pass remaining data (escape sequences + printable chars) to the parser
+     */
+    processBuffer() {
+        while (this.recvBuffer.length > 0) {
+            const byte = this.recvBuffer[0];
+            // --- Telnet IAC handling ---
+            if (byte === TELNET.IAC) {
+                if (this.recvBuffer.length < 2)
+                    return; // need more data
+                const cmd = this.recvBuffer[1];
+                // IAC IAC = escaped 0xFF literal
+                if (cmd === TELNET.IAC) {
+                    // Emit as data
+                    this.emitData(Buffer.from([0xFF]));
+                    this.recvBuffer = this.recvBuffer.subarray(2);
+                    continue;
+                }
+                // Subnegotiation: IAC SB ... IAC SE
+                if (cmd === TELNET.SB) {
+                    const seIdx = this.findSubnegEnd();
+                    if (seIdx === -1)
+                        return; // wait for more data
+                    const subData = this.recvBuffer.subarray(2, seIdx);
+                    this.recvBuffer = this.recvBuffer.subarray(seIdx + 2);
+                    this.handleSubnegotiation(subData);
+                    continue;
+                }
+                // DO / DONT / WILL / WONT: 3 bytes
+                if (cmd === TELNET.DO || cmd === TELNET.DONT ||
+                    cmd === TELNET.WILL || cmd === TELNET.WONT) {
+                    if (this.recvBuffer.length < 3)
+                        return;
+                    const option = this.recvBuffer[2];
+                    this.recvBuffer = this.recvBuffer.subarray(3);
+                    this.handleNegotiation(cmd, option);
+                    continue;
+                }
+                // Other IAC command (2 bytes), skip
+                this.recvBuffer = this.recvBuffer.subarray(2);
+                continue;
+            }
+            // --- XON/XOFF flow control ---
+            if (byte === CTRL.DC3) {
+                // XOFF: host asks us to stop sending
+                this.xoff = true;
+                this.recvBuffer = this.recvBuffer.subarray(1);
+                continue;
+            }
+            if (byte === CTRL.DC1) {
+                // XON: host allows us to resume sending
+                this.xoff = false;
+                this.recvBuffer = this.recvBuffer.subarray(1);
+                this.flushSendQueue();
+                continue;
+            }
+            // --- Regular data (escape sequences + printable characters) ---
+            // Find the next IAC or flow control character to know how much data to emit
+            let end = 1;
+            while (end < this.recvBuffer.length) {
+                const b = this.recvBuffer[end];
+                if (b === TELNET.IAC || b === CTRL.DC1 || b === CTRL.DC3)
+                    break;
+                end++;
+            }
+            const chunk = this.recvBuffer.subarray(0, end);
+            this.recvBuffer = this.recvBuffer.subarray(end);
+            this.emitData(Buffer.from(chunk));
+        }
+    }
+    emitData(data) {
+        if (data.length > 0) {
+            this.emit('data', data);
+        }
+    }
+    flushSendQueue() {
+        if (!this.socket || !this._connected)
+            return;
+        while (this.sendQueue.length > 0 && !this.xoff) {
+            const queued = this.sendQueue.shift();
+            this.socket.write(queued);
+        }
+    }
+    /** Find IAC SE sequence for subnegotiation end */
+    findSubnegEnd() {
+        for (let i = 2; i < this.recvBuffer.length - 1; i++) {
+            if (this.recvBuffer[i] === TELNET.IAC && this.recvBuffer[i + 1] === TELNET.SE) {
+                return i;
+            }
+        }
+        return -1;
+    }
+    handleNegotiation(cmd, option) {
+        switch (cmd) {
+            case TELNET.DO:
+                // Server asks us to enable an option
+                if (option === TELNET.OPT_TTYPE ||
+                    option === TELNET.OPT_BINARY ||
+                    option === 0x03 /* SGA */ ||
+                    option === 0x01 /* ECHO */) {
+                    this.sendTelnet(TELNET.WILL, option);
+                }
+                else {
+                    this.sendTelnet(TELNET.WONT, option);
+                }
+                break;
+            case TELNET.WILL:
+                // Server offers an option
+                if (option === TELNET.OPT_BINARY ||
+                    option === 0x03 /* SGA */ ||
+                    option === 0x01 /* ECHO */) {
+                    this.sendTelnet(TELNET.DO, option);
+                }
+                else {
+                    this.sendTelnet(TELNET.DONT, option);
+                }
+                break;
+            case TELNET.DONT:
+                this.sendTelnet(TELNET.WONT, option);
+                break;
+            case TELNET.WONT:
+                this.sendTelnet(TELNET.DONT, option);
+                break;
+        }
+    }
+    handleSubnegotiation(data) {
+        if (data.length === 0)
+            return;
+        const option = data[0];
+        if (option === TELNET.OPT_TTYPE && data.length >= 2 && data[1] === TELNET.TTYPE_SEND) {
+            this.sendTerminalType();
+        }
+    }
+    sendTerminalType() {
+        const typeStr = TERMINAL_TYPE;
+        const buf = Buffer.alloc(4 + typeStr.length + 2);
+        let i = 0;
+        buf[i++] = TELNET.IAC;
+        buf[i++] = TELNET.SB;
+        buf[i++] = TELNET.OPT_TTYPE;
+        buf[i++] = TELNET.TTYPE_IS;
+        for (let j = 0; j < typeStr.length; j++) {
+            buf[i++] = typeStr.charCodeAt(j);
+        }
+        buf[i++] = TELNET.IAC;
+        buf[i++] = TELNET.SE;
+        this.sendRaw(buf);
+    }
+    sendTelnet(cmd, option) {
+        if (this.socket && this._connected) {
+            // Bypass flow control for Telnet negotiation
+            this.socket.write(Buffer.from([TELNET.IAC, cmd, option]));
+        }
+    }
+}

package/dist/hp6530/constants.d.ts

@@ -0,0 +1,64 @@
+export { TELNET } from '../tn5250/constants.js';
+/** Terminal type string for Telnet TTYPE negotiation */
+export declare const TERMINAL_TYPE = "T6530";
+/** Alternative terminal type */
+export declare const TERMINAL_TYPE_ALT = "HP700/96";
+/** Screen dimensions */
+export declare const SCREEN: {
+    readonly ROWS: 24;
+    readonly COLS: 80;
+};
+export declare const CTRL: {
+    readonly NUL: 0;
+    readonly SOH: 1;
+    readonly STX: 2;
+    readonly ETX: 3;
+    readonly EOT: 4;
+    readonly ENQ: 5;
+    readonly ACK: 6;
+    readonly BEL: 7;
+    readonly BS: 8;
+    readonly HT: 9;
+    readonly LF: 10;
+    readonly VT: 11;
+    readonly FF: 12;
+    readonly CR: 13;
+    readonly SO: 14;
+    readonly SI: 15;
+    readonly DC1: 17;
+    readonly DC3: 19;
+    readonly ESC: 27;
+    readonly DEL: 127;
+};
+/** Direct cursor address: ESC [ row ; col H (VT-style CUP) */
+export declare const ESC_CUP_PREFIX: Buffer<ArrayBuffer>;
+export declare const ESC_CUP_SEP = 59;
+export declare const ESC_CUP_SUFFIX = 72;
+/** Clear to end of display */
+export declare const ESC_CLEAR_EOS: Buffer<ArrayBuffer>;
+/** Clear to end of line */
+export declare const ESC_CLEAR_EOL: Buffer<ArrayBuffer>;
+/** Start protected field */
+export declare const ESC_PROTECT_START: Buffer<ArrayBuffer>;
+/** End protected field (start unprotected) */
+export declare const ESC_PROTECT_END: Buffer<ArrayBuffer>;
+export declare const ATTR: {
+    readonly NORMAL: 64;
+    readonly HALF_BRIGHT: 66;
+    readonly UNDERLINE: 68;
+    readonly BLINK: 72;
+    readonly INVERSE: 74;
+    readonly UNDERLINE_INVERSE: 76;
+};
+/** Attribute escape sequence prefix: ESC & d */
+export declare const ESC_ATTR_PREFIX: Buffer<ArrayBuffer>;
+/** Map of attribute code to human-readable name */
+export declare const ATTR_NAMES: Record<number, string>;
+/** F1–F8: ESC p through ESC w (0x70–0x77) */
+/** F9–F16: ESC ` through ESC g (0x60–0x67) — varies by model */
+/** SF1–SF16: shifted versions — ESC P through ESC W (0x50–0x57) for SF1-SF8,
+ *  ESC H through ESC O (0x48–0x4F) for SF9-SF16 — varies by model */
+export declare const FKEY_SEQUENCES: Record<string, Buffer>;
+export declare const ARROW_SEQUENCES: Record<string, Buffer>;
+export declare const KEY_TO_SEQUENCE: Record<string, Buffer>;
+export declare const FKEY_BYTE_TO_NAME: Record<number, string>;

package/dist/hp6530/constants.js

@@ -0,0 +1,135 @@
+// === Telnet Constants (reuse from TN5250) ===
+export { TELNET } from '../tn5250/constants.js';
+// === HP 6530 Terminal Constants ===
+/** Terminal type string for Telnet TTYPE negotiation */
+export const TERMINAL_TYPE = 'T6530';
+/** Alternative terminal type */
+export const TERMINAL_TYPE_ALT = 'HP700/96';
+/** Screen dimensions */
+export const SCREEN = {
+    ROWS: 24,
+    COLS: 80,
+};
+// === Control Characters ===
+export const CTRL = {
+    NUL: 0x00,
+    SOH: 0x01, // Start of header
+    STX: 0x02, // Start of text
+    ETX: 0x03, // End of text
+    EOT: 0x04, // End of transmission
+    ENQ: 0x05, // Enquiry
+    ACK: 0x06, // Acknowledge
+    BEL: 0x07, // Bell
+    BS: 0x08, // Backspace
+    HT: 0x09, // Horizontal tab
+    LF: 0x0A, // Line feed
+    VT: 0x0B, // Vertical tab
+    FF: 0x0C, // Form feed
+    CR: 0x0D, // Carriage return
+    SO: 0x0E, // Shift out
+    SI: 0x0F, // Shift in
+    DC1: 0x11, // XON — Device control 1 (resume transmission)
+    DC3: 0x13, // XOFF — Device control 3 (pause transmission)
+    ESC: 0x1B, // Escape
+    DEL: 0x7F, // Delete
+};
+// === 6530 Escape Sequences ===
+// These are the byte sequences sent from the host to control the terminal.
+/** Direct cursor address: ESC [ row ; col H (VT-style CUP) */
+export const ESC_CUP_PREFIX = Buffer.from([0x1B, 0x5B]); // ESC [
+export const ESC_CUP_SEP = 0x3B; // ';'
+export const ESC_CUP_SUFFIX = 0x48; // 'H'
+/** Clear to end of display */
+export const ESC_CLEAR_EOS = Buffer.from([0x1B, 0x4A]); // ESC J
+/** Clear to end of line */
+export const ESC_CLEAR_EOL = Buffer.from([0x1B, 0x4B]); // ESC K
+/** Start protected field */
+export const ESC_PROTECT_START = Buffer.from([0x1B, 0x29]); // ESC )
+/** End protected field (start unprotected) */
+export const ESC_PROTECT_END = Buffer.from([0x1B, 0x28]); // ESC (
+// === Display Attribute Escape Sequences ===
+// Format: ESC & d <code>
+export const ATTR = {
+    NORMAL: 0x40, // '@' — Normal display / reset attributes
+    HALF_BRIGHT: 0x42, // 'B' — Dim
+    UNDERLINE: 0x44, // 'D' — Underline
+    BLINK: 0x48, // 'H' — Blink
+    INVERSE: 0x4A, // 'J' — Inverse video
+    UNDERLINE_INVERSE: 0x4C, // 'L' — Underline + inverse
+};
+/** Attribute escape sequence prefix: ESC & d */
+export const ESC_ATTR_PREFIX = Buffer.from([0x1B, 0x26, 0x64]); // ESC & d
+/** Map of attribute code to human-readable name */
+export const ATTR_NAMES = {
+    [ATTR.NORMAL]: 'normal',
+    [ATTR.HALF_BRIGHT]: 'half_bright',
+    [ATTR.UNDERLINE]: 'underline',
+    [ATTR.BLINK]: 'blink',
+    [ATTR.INVERSE]: 'inverse',
+    [ATTR.UNDERLINE_INVERSE]: 'underline_inverse',
+};
+// === Function Key Escape Sequences ===
+// Sequences sent from the terminal to the host when function keys are pressed.
+/** F1–F8: ESC p through ESC w (0x70–0x77) */
+/** F9–F16: ESC ` through ESC g (0x60–0x67) — varies by model */
+/** SF1–SF16: shifted versions — ESC P through ESC W (0x50–0x57) for SF1-SF8,
+ *  ESC H through ESC O (0x48–0x4F) for SF9-SF16 — varies by model */
+export const FKEY_SEQUENCES = {
+    // F1–F8: ESC p through ESC w
+    F1: Buffer.from([0x1B, 0x70]), // ESC p
+    F2: Buffer.from([0x1B, 0x71]), // ESC q
+    F3: Buffer.from([0x1B, 0x72]), // ESC r
+    F4: Buffer.from([0x1B, 0x73]), // ESC s
+    F5: Buffer.from([0x1B, 0x74]), // ESC t
+    F6: Buffer.from([0x1B, 0x75]), // ESC u
+    F7: Buffer.from([0x1B, 0x76]), // ESC v
+    F8: Buffer.from([0x1B, 0x77]), // ESC w
+    // F9–F16: ESC ` through ESC g
+    F9: Buffer.from([0x1B, 0x60]), // ESC `
+    F10: Buffer.from([0x1B, 0x61]), // ESC a
+    F11: Buffer.from([0x1B, 0x62]), // ESC b
+    F12: Buffer.from([0x1B, 0x63]), // ESC c
+    F13: Buffer.from([0x1B, 0x64]), // ESC d
+    F14: Buffer.from([0x1B, 0x65]), // ESC e
+    F15: Buffer.from([0x1B, 0x66]), // ESC f
+    F16: Buffer.from([0x1B, 0x67]), // ESC g
+    // SF1–SF8 (shifted): ESC P through ESC W
+    SF1: Buffer.from([0x1B, 0x50]), // ESC P
+    SF2: Buffer.from([0x1B, 0x51]), // ESC Q
+    SF3: Buffer.from([0x1B, 0x52]), // ESC R
+    SF4: Buffer.from([0x1B, 0x53]), // ESC S
+    SF5: Buffer.from([0x1B, 0x54]), // ESC T
+    SF6: Buffer.from([0x1B, 0x55]), // ESC U
+    SF7: Buffer.from([0x1B, 0x56]), // ESC V
+    SF8: Buffer.from([0x1B, 0x57]), // ESC W
+    // SF9–SF16 (shifted): ESC H through ESC O
+    SF9: Buffer.from([0x1B, 0x48]), // ESC H
+    SF10: Buffer.from([0x1B, 0x49]), // ESC I
+    SF11: Buffer.from([0x1B, 0x4A]), // ESC J (note: conflicts with clear EOS in host→terminal direction)
+    SF12: Buffer.from([0x1B, 0x4B]), // ESC K
+    SF13: Buffer.from([0x1B, 0x4C]), // ESC L
+    SF14: Buffer.from([0x1B, 0x4D]), // ESC M
+    SF15: Buffer.from([0x1B, 0x4E]), // ESC N
+    SF16: Buffer.from([0x1B, 0x4F]), // ESC O
+};
+// === Arrow Key Sequences (terminal → host) ===
+export const ARROW_SEQUENCES = {
+    UP: Buffer.from([0x1B, 0x41]), // ESC A
+    DOWN: Buffer.from([0x1B, 0x42]), // ESC B
+    RIGHT: Buffer.from([0x1B, 0x43]), // ESC C
+    LEFT: Buffer.from([0x1B, 0x44]), // ESC D
+};
+// === Combined key-to-sequence map ===
+export const KEY_TO_SEQUENCE = {
+    ...FKEY_SEQUENCES,
+    ...ARROW_SEQUENCES,
+    ENTER: Buffer.from([CTRL.CR]),
+    TAB: Buffer.from([CTRL.HT]),
+    BACKSPACE: Buffer.from([CTRL.BS]),
+    DELETE: Buffer.from([CTRL.DEL]),
+};
+// === Reverse lookup: sequence second byte → function key name (for F-keys only) ===
+export const FKEY_BYTE_TO_NAME = {};
+for (const [name, seq] of Object.entries(FKEY_SEQUENCES)) {
+    FKEY_BYTE_TO_NAME[seq[1]] = name;
+}

package/dist/hp6530/encoder.d.ts

@@ -0,0 +1,37 @@
+import { HP6530Screen } from './screen.js';
+/**
+ * Encodes client input into HP 6530 wire-format data for sending
+ * to an HP NonStop (Tandem) host.
+ *
+ * In block mode, the terminal collects all modified unprotected field
+ * data and sends it as a single transmission when an action key
+ * (ENTER, function key) is pressed.
+ */
+export declare class HP6530Encoder {
+    private screen;
+    constructor(screen: HP6530Screen);
+    /**
+     * Build a block-mode response for a key press.
+     *
+     * For action keys (ENTER, function keys), we:
+     * 1. Send the function key escape sequence
+     * 2. Preceded by all modified unprotected field data
+     *
+     * The field data format for block-mode transmission:
+     *   DC1 (XON) signals start of block
+     *   For each modified field: position + data
+     *   Followed by the key sequence
+     *   CR signals end of input
+     *
+     * Returns a Buffer ready to send, or null if the key is unknown.
+     */
+    buildKeyResponse(keyName: string): Buffer | null;
+    /**
+     * Insert text at the current cursor position in the current
+     * unprotected field. Updates the screen buffer and marks the
+     * field as modified.
+     *
+     * Returns true if text was successfully inserted.
+     */
+    insertText(text: string): boolean;
+}

package/dist/hp6530/encoder.js

@@ -0,0 +1,89 @@
+import { KEY_TO_SEQUENCE, CTRL } from './constants.js';
+/**
+ * Encodes client input into HP 6530 wire-format data for sending
+ * to an HP NonStop (Tandem) host.
+ *
+ * In block mode, the terminal collects all modified unprotected field
+ * data and sends it as a single transmission when an action key
+ * (ENTER, function key) is pressed.
+ */
+export class HP6530Encoder {
+    screen;
+    constructor(screen) {
+        this.screen = screen;
+    }
+    /**
+     * Build a block-mode response for a key press.
+     *
+     * For action keys (ENTER, function keys), we:
+     * 1. Send the function key escape sequence
+     * 2. Preceded by all modified unprotected field data
+     *
+     * The field data format for block-mode transmission:
+     *   DC1 (XON) signals start of block
+     *   For each modified field: position + data
+     *   Followed by the key sequence
+     *   CR signals end of input
+     *
+     * Returns a Buffer ready to send, or null if the key is unknown.
+     */
+    buildKeyResponse(keyName) {
+        const keySeq = KEY_TO_SEQUENCE[keyName];
+        if (!keySeq)
+            return null;
+        const parts = [];
+        // For block-mode action keys (ENTER, function keys), collect field data
+        const isActionKey = keyName === 'ENTER' ||
+            keyName.startsWith('F') ||
+            keyName.startsWith('SF');
+        if (isActionKey && this.screen.fields.length > 0) {
+            // Collect all modified unprotected field data
+            for (const field of this.screen.fields) {
+                if (field.isProtected || !field.modified)
+                    continue;
+                const value = this.screen.getFieldValue(field);
+                // Trim trailing spaces
+                const trimmed = value.replace(/\s+$/, '');
+                if (trimmed.length > 0) {
+                    parts.push(Buffer.from(trimmed, 'ascii'));
+                }
+                // Field separator: HT between fields
+                parts.push(Buffer.from([CTRL.HT]));
+            }
+        }
+        // Append the key sequence itself
+        parts.push(keySeq);
+        // For ENTER in block mode, append CR if not already the key sequence
+        if (keyName !== 'ENTER' && isActionKey) {
+            parts.push(Buffer.from([CTRL.CR]));
+        }
+        return Buffer.concat(parts);
+    }
+    /**
+     * Insert text at the current cursor position in the current
+     * unprotected field. Updates the screen buffer and marks the
+     * field as modified.
+     *
+     * Returns true if text was successfully inserted.
+     */
+    insertText(text) {
+        const field = this.screen.getFieldAtCursor();
+        if (!field || field.isProtected)
+            return false;
+        const fieldStart = this.screen.offset(field.row, field.col);
+        let cursorOffset = this.screen.offset(this.screen.cursorRow, this.screen.cursorCol);
+        const fieldEnd = fieldStart + field.length;
+        for (const ch of text) {
+            if (cursorOffset >= fieldEnd)
+                break;
+            this.screen.buffer[cursorOffset] = ch;
+            cursorOffset++;
+        }
+        // Update cursor position
+        const newPos = this.screen.toRowCol(Math.min(cursorOffset, fieldEnd - 1));
+        this.screen.cursorRow = newPos.row;
+        this.screen.cursorCol = newPos.col;
+        field.modified = true;
+        return true;
+    }
+}