green-screen-proxy 0.3.0 → 1.0.0

package/dist/tn5250/encoder.js

@@ -19,14 +19,10 @@ export class TN5250Encoder {
         if (aidByte === undefined)
             return null;
         const parts = [];
-        // Row and column of cursor (1-based for the protocol)
         const cursorRow = this.screen.cursorRow;
         const cursorCol = this.screen.cursorCol;
-        // Build the response record
-        // Format: [row][col][aid_byte][field_data...]
-        // GDS header (6 bytes) + response data
-        const header = this.buildGDSHeader();
-        parts.push(header);
+        // GDS header: length(2) + record_type(2) + var(1) + reserved(1) + opcode(1)
+        parts.push(this.buildGDSHeader());
         // Cursor position + AID byte
         parts.push(Buffer.from([cursorRow, cursorCol, aidByte]));
         // For certain aid keys (like SysReq), no field data is sent
@@ -40,16 +36,16 @@ export class TN5250Encoder {
             if (!this.screen.isInputField(field))
                 continue;
             // SBA order to indicate field position
-            parts.push(Buffer.from([0x11, field.row, field.col])); // SBA + row + col
+            parts.push(Buffer.from([0x11, field.row, field.col]));
             // Field data in EBCDIC
             const value = this.screen.getFieldValue(field);
             const ebcdicData = Buffer.alloc(value.length);
             for (let i = 0; i < value.length; i++) {
                 ebcdicData[i] = charToEbcdic(value[i]);
             }
-            // Trim trailing spaces
+            // Trim trailing spaces and nulls
             let trimLen = ebcdicData.length;
-            while (trimLen > 0 && ebcdicData[trimLen - 1] === EBCDIC_SPACE) {
+            while (trimLen > 0 && (ebcdicData[trimLen - 1] === EBCDIC_SPACE || ebcdicData[trimLen - 1] === 0x00)) {
                 trimLen--;
             }
             if (trimLen > 0) {
@@ -59,24 +55,25 @@ export class TN5250Encoder {
         return this.wrapWithEOR(Buffer.concat(parts));
     }
     /**
-     * Build a GDS (General Data Stream) header for a response.
+     * Build a GDS header for a client response (matching tn5250j format).
+     * 10-byte header:
+     *   Bytes 0-1: record length (filled by wrapWithEOR)
+     *   Bytes 2-3: record type 0x12A0 (SNA GDS Variable)
+     *   Bytes 4-5: reserved 0x0000
+     *   Byte 6: sub-header length 0x04
+     *   Byte 7: flags 0x00
+     *   Byte 8: reserved 0x00
+     *   Byte 9: opcode 0x03 (PUT/GET response)
      */
     buildGDSHeader() {
-        // We'll fill in the length later, but for now use a placeholder
-        // The actual header format:
-        // Bytes 0-1: record length (will be filled)
-        // Bytes 2-3: record type = 0x12A0
-        // Byte 4: variable indicator (0x00)
-        // Byte 5: reserved (0x00)
-        // Byte 6: opcode (0x00 for response, 0x04 for response to save screen)
-        return Buffer.from([0x00, 0x00, 0x12, 0xA0, 0x00, 0x00, 0x00]);
+        return Buffer.from([0x00, 0x00, 0x12, 0xA0, 0x00, 0x00, 0x04, 0x00, 0x00, 0x03]);
     }
     /**
      * Wrap data with Telnet IAC EOR framing.
      * Also escapes any 0xFF bytes in the data as IAC IAC.
      */
     wrapWithEOR(data) {
-        // Update the record length in the GDS header
+        // Update GDS record length in the first 2 bytes (includes itself)
         if (data.length >= 2) {
             const len = data.length;
             data[0] = (len >> 8) & 0xFF;
@@ -119,3 +116,4 @@ export class TN5250Encoder {
         return true;
     }
 }
+//# sourceMappingURL=encoder.js.map

package/dist/tn5250/encoder.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"encoder.js","sourceRoot":"","sources":["../../src/tn5250/encoder.ts"],"names":[],"mappings":"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"}

package/dist/tn5250/parser.d.ts

@@ -4,6 +4,8 @@ import { ScreenBuffer } from './screen.js';
  */
 export declare class TN5250Parser {
     private screen;
+    /** When true, the next SF order should clear stale fields first */
+    private pendingFieldsClear;
     constructor(screen: ScreenBuffer);
     /**
      * Parse a complete 5250 record (after Telnet framing is removed).
@@ -12,6 +14,14 @@ export declare class TN5250Parser {
     parseRecord(record: Buffer): boolean;
     /** Try to parse data that doesn't have a proper GDS header */
     private tryParseRawData;
+    /**
+     * Handle records with non-standard framing (e.g. opcode 0x04 from
+     * pub400.com). These records contain valid commands (CLEAR_UNIT, WTD)
+     * but with extra sub-record marker bytes (0x04) between the GDS header
+     * and the actual commands.  We scan for the first known command byte,
+     * skipping 0x04 markers, and hand off to parseCommands.
+     */
+    private parseCommandsFromOffset;
     /** Parse one or more 5250 commands starting at offset */
     private parseCommands;
     /**
@@ -19,15 +29,31 @@ export declare class TN5250Parser {
      * Updates the screen buffer and returns the new position.
      */
     private parseOrders;
-    /** Try to detect if a byte in the 0x20-0x3F range is a field attribute vs regular character */
-    private isLikelyFieldAttribute;
-    /** Parse a field attribute byte and the following FFW/FCW */
+    /**
+     * Parse a bare field attribute byte (0x20-0x3F) that appears after SBA.
+     * In basic 5250, this is just 1 byte — no FFW/FCW follows.
+     * FFW/FCW are only present with explicit SF (Start Field, 0x1D) order.
+     */
     private parseFieldAttribute;
-    /** Parse explicit SF order field definition */
-    private parseFieldDefinition;
+    /**
+     * Parse SF (Start Field) order with FFW and optional FCW.
+     * Format: SF(0x1D) FFW1 FFW2 [FCW1 FCW2]
+     * FFW1 always has bit 6 set (0x40+). No trailing attribute byte.
+     * Display attribute is derived from FFW2.
+     */
+    private parseStartField;
+    /**
+     * Decode a display attribute byte (0x20–0x3F) into an ATTR constant.
+     * Only recognises the bits that determine display type; falls back to
+     * the SA context (displayAttr) for modifier-only bytes (0x30, 0x38, etc.).
+     */
+    private decodeDisplayAttr;
+    /** Clear stale fields when the first SF order arrives after a Reset MDT WTD */
+    private clearStaleFieldsOnce;
     /**
      * After parsing a complete screen, calculate field lengths.
      * Call this after all records for a screen have been parsed.
      */
     calculateFieldLengths(): void;
 }
+//# sourceMappingURL=parser.d.ts.map

package/dist/tn5250/parser.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"parser.d.ts","sourceRoot":"","sources":["../../src/tn5250/parser.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAY,MAAM,aAAa,CAAC;AAIrD;;GAEG;AACH,qBAAa,YAAY;IACvB,OAAO,CAAC,MAAM,CAAe;IAC7B,mEAAmE;IACnE,OAAO,CAAC,kBAAkB,CAAS;gBAEvB,MAAM,EAAE,YAAY;IAIhC;;;OAGG;IACH,WAAW,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO;IA6EpC,8DAA8D;IAC9D,OAAO,CAAC,eAAe;IAKvB;;;;;;OAMG;IACH,OAAO,CAAC,uBAAuB;IAiB/B,yDAAyD;IACzD,OAAO,CAAC,aAAa;IAkGrB;;;OAGG;IACH,OAAO,CAAC,WAAW;IAqKnB;;;;OAIG;IACH,OAAO,CAAC,mBAAmB;IAsC3B;;;;;OAKG;IACH,OAAO,CAAC,eAAe;IAuEvB;;;;OAIG;IACH,OAAO,CAAC,iBAAiB;IAQzB,+EAA+E;IAC/E,OAAO,CAAC,oBAAoB;IAO5B;;;OAGG;IACH,qBAAqB,IAAI,IAAI;CA4E9B"}

package/dist/tn5250/parser.js

@@ -1,10 +1,12 @@
 import { CMD, ORDER, OPCODE, ATTR } from './constants.js';
-import { ebcdicToChar } from './ebcdic.js';
+import { ebcdicToChar, ebcdicSymbolChar } from './ebcdic.js';
 /**
  * Parses 5250 data stream records and updates the screen buffer.
  */
 export class TN5250Parser {
     screen;
+    /** When true, the next SF order should clear stale fields first */
+    pendingFieldsClear = false;
     constructor(screen) {
         this.screen = screen;
     }
@@ -31,32 +33,48 @@ export class TN5250Parser {
         }
         const recordLen = (record[0] << 8) | record[1];
         const recordType = (record[2] << 8) | record[3];
-        const varFlag = record[4];
-        const reserved = record[5];
-        const opcode = record[6];
         // Check for GDS record type
         if (recordType !== 0x12A0) {
-            // Not a GDS record — might be raw data or something else
             return this.tryParseRawData(record);
         }
+        // Determine header layout: standard 10-byte header has a 4-byte sub-header
+        // at bytes 6-9: [sub_header_len=0x04][flags][reserved][opcode]
+        // Data starts at byte 10. Older/simpler records may use 7-byte layout.
+        let opcode;
+        let dataOffset;
+        if (record.length >= 10 && record[6] === 0x04) {
+            // 10-byte header with 4-byte sub-header
+            opcode = record[9];
+            dataOffset = 10;
+        }
+        else {
+            // 7-byte header (opcode at byte 6)
+            opcode = record[6];
+            dataOffset = 7;
+        }
         let modified = false;
         switch (opcode) {
             case OPCODE.OUTPUT:
             case OPCODE.PUT_GET:
-                // Contains one or more 5250 commands after the header
-                modified = this.parseCommands(record, 7);
+                // Use parseCommandsFromOffset to scan for CLEAR_UNIT/WTD within the data.
+                // The data may contain sub-record markers (0x04) before the actual commands,
+                // which parseCommands would misinterpret. parseCommandsFromOffset handles this
+                // by scanning for known command bytes.
+                if (record.length > dataOffset) {
+                    modified = this.parseCommandsFromOffset(record, dataOffset);
+                }
                 break;
             case OPCODE.INVITE:
-                // Invite: server is ready for input (no screen data typically)
                 break;
             case OPCODE.SAVE_SCREEN:
             case OPCODE.RESTORE_SCREEN:
-                // We don't implement save/restore, just ignore
+                if (record.length > dataOffset) {
+                    modified = this.parseCommandsFromOffset(record, dataOffset);
+                }
                 break;
             default:
-                // Try parsing as commands anyway
-                if (record.length > 7) {
-                    modified = this.parseCommands(record, 7);
+                if (record.length > dataOffset) {
+                    modified = this.parseCommandsFromOffset(record, dataOffset);
                 }
                 break;
         }
@@ -67,6 +85,30 @@ export class TN5250Parser {
         // Some servers send command data without the full GDS wrapper
         return this.parseCommands(record, 0);
     }
+    /**
+     * Handle records with non-standard framing (e.g. opcode 0x04 from
+     * pub400.com). These records contain valid commands (CLEAR_UNIT, WTD)
+     * but with extra sub-record marker bytes (0x04) between the GDS header
+     * and the actual commands.  We scan for the first known command byte,
+     * skipping 0x04 markers, and hand off to parseCommands.
+     */
+    parseCommandsFromOffset(data, start) {
+        for (let i = start; i < data.length; i++) {
+            // Skip sub-record markers (0x04)
+            if (data[i] === 0x04)
+                continue;
+            // Known command bytes — hand off to normal parsing
+            if (data[i] === CMD.WRITE_TO_DISPLAY ||
+                data[i] === CMD.CLEAR_UNIT ||
+                data[i] === CMD.CLEAR_UNIT_ALT ||
+                data[i] === CMD.WRITE_STRUCTURED_FIELD ||
+                data[i] === CMD.WRITE_ERROR_CODE ||
+                data[i] === CMD.WRITE_ERROR_CODE_WIN) {
+                return this.parseCommands(data, i);
+            }
+        }
+        return false;
+    }
     /** Parse one or more 5250 commands starting at offset */
     parseCommands(data, offset) {
         let pos = offset;
@@ -96,6 +138,8 @@ export class TN5250Parser {
                             for (const f of this.screen.fields) {
                                 f.modified = false;
                             }
+                            // Mark that subsequent SF orders in this WTD should clear stale fields
+                            this.pendingFieldsClear = true;
                         }
                         // CC1 bit 6: Clear all input fields (null fill)
                         if (cc1 & 0x40) {
@@ -160,14 +204,14 @@ export class TN5250Parser {
     parseOrders(data, pos) {
         let currentAddr = this.screen.offset(this.screen.cursorRow, this.screen.cursorCol);
         let currentAttr = ATTR.NORMAL;
+        let useSymbolCharSet = false; // SA type 0x22 can switch to APL/symbol CGCS
+        let afterSBA = false; // Track if we just processed an SBA order (field attrs follow SBA)
         while (pos < data.length) {
             const byte = data[pos];
-            // Check if we've hit another command byte — stop parsing orders
-            if (byte === CMD.WRITE_TO_DISPLAY || byte === CMD.CLEAR_UNIT ||
-                byte === CMD.CLEAR_FORMAT_TABLE || byte === CMD.WRITE_STRUCTURED_FIELD ||
-                byte === CMD.WRITE_ERROR_CODE || byte === CMD.ROLL) {
-                break;
-            }
+            // Within a WTD, all bytes are orders or EBCDIC data.
+            // Command bytes like CLEAR_UNIT (0x40 = EBCDIC space) and WTD (0x11 = SBA)
+            // overlap with valid order/data values, so we cannot break on them.
+            // parseOrders consumes data until the end of the buffer.
             switch (byte) {
                 case ORDER.SBA: {
                     // Set Buffer Address: 2 bytes follow (row, col)
@@ -177,7 +221,8 @@ export class TN5250Parser {
                     const row = data[pos++];
                     const col = data[pos++];
                     currentAddr = this.screen.offset(row, col);
-                    break;
+                    afterSBA = true; // Field attribute may follow
+                    continue; // skip the afterSBA = false at end of loop
                 }
                 case ORDER.IC: {
                     // Insert Cursor: set cursor to current address
@@ -230,13 +275,14 @@ export class TN5250Parser {
                     break;
                 }
                 case ORDER.SOH: {
-                    // Start of Header: variable-length header for input fields
+                    // Start of Header: variable-length header for input fields.
+                    // Format: [0x01] [length] [data...]
+                    // The length byte includes SOH byte + itself, so remaining = length - 2.
                     if (pos + 1 >= data.length)
                         return data.length;
                     pos++;
                     const hdrLen = data[pos++];
-                    // Skip header data (contains error line, etc.)
-                    pos += Math.max(0, hdrLen - 2); // length includes the length byte itself sometimes
+                    pos += Math.max(0, hdrLen - 2);
                     break;
                 }
                 case ORDER.TD: {
@@ -259,35 +305,49 @@ export class TN5250Parser {
                     const attrValue = data[pos++];
                     // Apply attribute at current position
                     this.screen.setAttrAt(currentAddr, attrValue);
-                    break;
+                    // Preserve afterSBA — WEA can appear between SBA and a field attribute
+                    continue;
                 }
                 case ORDER.SA: {
                     // Set Attribute: 2 bytes (attr type + value)
+                    // Type 0x00 = all/reset, 0x20 = extended highlighting,
+                    // 0x21 = foreground color, 0x22 = character set (CGCS).
+                    // Only update display attribute for types that affect it.
                     if (pos + 2 >= data.length)
                         return data.length;
                     pos++;
                     const saType = data[pos++];
                     const saValue = data[pos++];
-                    currentAttr = saValue;
-                    break;
+                    if (saType === 0x00) {
+                        currentAttr = saValue;
+                        useSymbolCharSet = false; // reset
+                    }
+                    else if (saType === 0x20) {
+                        currentAttr = saValue;
+                    }
+                    else if (saType === 0x22) {
+                        // Character set (CGCS) — non-default means APL/symbol glyphs
+                        useSymbolCharSet = saValue !== 0x00;
+                    }
+                    // Preserve afterSBA — SA sets color/highlight context before a field attribute
+                    continue;
                 }
                 case ORDER.SF: {
-                    // Start Field: field attribute byte + FFW + optional FCW
-                    // Actually, in 5250, SF isn't always 0x1D. The field definition
-                    // comes after SBA as attribute byte (0x20-0x3F range).
-                    // But let's handle explicit SF if encountered:
+                    // Start Field: explicit SF order with FFW + optional FCW
                     pos++;
-                    pos = this.parseFieldDefinition(data, pos, currentAddr, currentAttr);
+                    pos = this.parseStartField(data, pos, currentAddr, currentAttr);
+                    currentAddr++; // attribute byte occupies one screen position
                     break;
                 }
                 default: {
-                    // Check for field attribute bytes (0x20-0x3F)
-                    if (byte >= 0x20 && byte <= 0x3F && this.isLikelyFieldAttribute(data, pos)) {
+                    // Field attribute bytes (0x20-0x3F) only appear immediately after SBA
+                    if (afterSBA && byte >= 0x20 && byte <= 0x3F) {
                         pos = this.parseFieldAttribute(data, pos, currentAddr, currentAttr);
+                        currentAddr++; // attribute byte occupies one screen position
                     }
                     else {
                         // Regular EBCDIC character data
-                        const ch = ebcdicToChar(byte);
+                        const ch = useSymbolCharSet ? ebcdicSymbolChar(byte) : ebcdicToChar(byte);
                         if (currentAddr < this.screen.size) {
                             this.screen.setCharAt(currentAddr, ch);
                             this.screen.setAttrAt(currentAddr, currentAttr);
@@ -298,84 +358,138 @@ export class TN5250Parser {
                     break;
                 }
             }
+            afterSBA = false;
         }
         return pos;
     }
-    /** Try to detect if a byte in the 0x20-0x3F range is a field attribute vs regular character */
-    isLikelyFieldAttribute(data, pos) {
-        // Field attributes in 5250 are typically preceded by SBA and followed by FFW bytes
-        // This is a heuristic — in practice, the WTD command structure makes this deterministic
-        // For the 0x20 byte specifically, it's also EBCDIC space, so we need context
-        const byte = data[pos];
-        // 0x20 is very common as both space and attribute — don't treat as field attr
-        if (byte === 0x20)
-            return false;
-        // For other bytes in 0x21-0x3F range, check if followed by FFW-like bytes
-        if (pos + 2 < data.length) {
-            const next = data[pos + 1];
-            const after = data[pos + 2];
-            // FFW first byte typically has specific bit patterns
-            // If followed by reasonable FFW bytes, treat as field attribute
-            return (next & 0x40) !== 0 || next === 0x00;
-        }
-        return false;
-    }
-    /** Parse a field attribute byte and the following FFW/FCW */
+    /**
+     * Parse a bare field attribute byte (0x20-0x3F) that appears after SBA.
+     * In basic 5250, this is just 1 byte — no FFW/FCW follows.
+     * FFW/FCW are only present with explicit SF (Start Field, 0x1D) order.
+     */
     parseFieldAttribute(data, pos, addr, displayAttr) {
         const attrByte = data[pos++];
         // The attribute byte occupies a position on screen (but is not displayed)
-        // Mark this position with the attribute
         if (addr < this.screen.size) {
-            this.screen.setCharAt(addr, ' '); // Attribute position shows as space
+            this.screen.setCharAt(addr, ' ');
+        }
+        const fieldStartAddr = addr + 1;
+        const { row, col } = this.screen.toRowCol(fieldStartAddr);
+        // Map attribute byte to display characteristic, falling back to SA context.
+        const fieldDisplayAttr = this.decodeDisplayAttr(attrByte, displayAttr);
+        // Determine input vs protected from the RAW attribute byte (not SA-enhanced).
+        // Lower 3 bits: 4-6 = underscore variants (input), 7 = non-display (input).
+        // This prevents SA context from promoting a normal/protected field to input.
+        const rawType = attrByte & 0x07;
+        const isInput = rawType >= 0x04; // underscore (4,5,6) or nondisplay (7)
+        const field = {
+            row,
+            col,
+            length: 0, // Calculated later
+            ffw1: isInput ? 0x00 : 0x20, // BYPASS bit set for output fields
+            ffw2: 0,
+            fcw1: 0,
+            fcw2: 0,
+            attribute: fieldDisplayAttr,
+            rawAttrByte: attrByte,
+            modified: false,
+        };
+        this.clearStaleFieldsOnce();
+        this.screen.fields.push(field);
+        return pos;
+    }
+    /**
+     * Parse SF (Start Field) order with FFW and optional FCW.
+     * Format: SF(0x1D) FFW1 FFW2 [FCW1 FCW2]
+     * FFW1 always has bit 6 set (0x40+). No trailing attribute byte.
+     * Display attribute is derived from FFW2.
+     */
+    parseStartField(data, pos, addr, displayAttr) {
+        if (addr < this.screen.size) {
+            this.screen.setCharAt(addr, ' ');
         }
-        // Parse FFW (Field Format Word) — 2 bytes
+        // Parse FFW (Field Format Word) — 2 bytes (FFW1 has bit 6 set)
         if (pos + 1 >= data.length)
             return pos;
         const ffw1 = data[pos++];
         const ffw2 = data[pos++];
         // Check for FCW (Field Control Word) — optional, 2 bytes
+        // FCW1 has bit 7 set (>= 0x80)
         let fcw1 = 0, fcw2 = 0;
         if (pos + 1 < data.length) {
-            // FCW is present if the first byte has bit 7 set and is not another order
             const maybeFcw = data[pos];
             if (maybeFcw >= 0x80 && maybeFcw !== 0xFF) {
                 fcw1 = data[pos++];
                 fcw2 = data[pos++];
             }
         }
-        // Determine field length: from current position to next field attribute or end of screen
-        // We'll calculate it later when all fields are known; for now use a placeholder
-        const fieldStartAddr = addr + 1; // Field data starts after the attribute byte
-        const { row, col } = this.screen.toRowCol(fieldStartAddr);
-        // Determine display attribute from the attribute byte
+        // Consume the trailing field attribute byte (always present after FFW/FCW).
+        // This byte (0x20–0x3F) specifies the display attribute for the field.
         let fieldDisplayAttr = displayAttr;
-        // Map attribute byte to display characteristics
-        if (attrByte & 0x04)
-            fieldDisplayAttr = ATTR.UNDERSCORE;
-        if (attrByte & 0x08)
-            fieldDisplayAttr = ATTR.HIGH_INTENSITY;
-        if (attrByte & 0x01)
-            fieldDisplayAttr = ATTR.REVERSE;
-        if (attrByte === 0x27 || (attrByte & 0x07) === 0x07)
-            fieldDisplayAttr = ATTR.NON_DISPLAY;
+        let rawAttrByte = 0;
+        if (pos < data.length) {
+            const attrByte = data[pos];
+            if (attrByte >= 0x20 && attrByte <= 0x3F) {
+                pos++;
+                rawAttrByte = attrByte;
+                fieldDisplayAttr = this.decodeDisplayAttr(attrByte, displayAttr);
+            }
+        }
+        const fieldStartAddr = addr + 1;
+        const { row, col } = this.screen.toRowCol(fieldStartAddr);
+        // After SF + FFW + optional FCW + ATTR, the host may include a few stale
+        // bytes (field content initializers like nulls) before the next SBA order.
+        // These should not be displayed. Scan ahead (up to 4 bytes) for the next
+        // SBA — if found, skip everything in between.
+        {
+            let scan = pos;
+            const limit = Math.min(pos + 4, data.length);
+            while (scan < limit) {
+                if (data[scan] === ORDER.SBA) {
+                    pos = scan; // skip stale bytes
+                    break;
+                }
+                scan++;
+            }
+        }
         const field = {
             row,
             col,
-            length: 0, // Will be calculated
+            length: 0,
             ffw1,
             ffw2,
             fcw1,
             fcw2,
             attribute: fieldDisplayAttr,
+            rawAttrByte,
             modified: false,
         };
+        this.clearStaleFieldsOnce();
         this.screen.fields.push(field);
         return pos;
     }
-    /** Parse explicit SF order field definition */
-    parseFieldDefinition(data, pos, addr, displayAttr) {
-        // Similar to parseFieldAttribute but for explicit SF order
-        return this.parseFieldAttribute(data, pos - 1, addr, displayAttr);
+    /**
+     * Decode a display attribute byte (0x20–0x3F) into an ATTR constant.
+     * Only recognises the bits that determine display type; falls back to
+     * the SA context (displayAttr) for modifier-only bytes (0x30, 0x38, etc.).
+     */
+    decodeDisplayAttr(attrByte, displayAttr = ATTR.NORMAL) {
+        if ((attrByte & 0x07) === 0x07)
+            return ATTR.NON_DISPLAY;
+        if (attrByte & 0x04)
+            return ATTR.UNDERSCORE;
+        if (attrByte & 0x02)
+            return ATTR.HIGH_INTENSITY;
+        if (attrByte & 0x08)
+            return ATTR.HIGH_INTENSITY;
+        return displayAttr;
+    }
+    /** Clear stale fields when the first SF order arrives after a Reset MDT WTD */
+    clearStaleFieldsOnce() {
+        if (this.pendingFieldsClear) {
+            this.screen.fields = [];
+            this.pendingFieldsClear = false;
+        }
     }
     /**
      * After parsing a complete screen, calculate field lengths.
@@ -385,6 +499,12 @@ export class TN5250Parser {
         const fields = this.screen.fields;
         if (fields.length === 0)
             return;
+        // Sort fields by screen position for correct length calculation
+        fields.sort((a, b) => {
+            const posA = this.screen.offset(a.row, a.col);
+            const posB = this.screen.offset(b.row, b.col);
+            return posA - posB;
+        });
         for (let i = 0; i < fields.length; i++) {
             const current = fields[i];
             const currentStart = this.screen.offset(current.row, current.col);
@@ -396,9 +516,9 @@ export class TN5250Parser {
                 current.length = Math.max(0, nextStart - currentStart - 1);
             }
             else {
-                // Last field extends to end of screen or a reasonable default
-                const endAddr = this.screen.size;
-                current.length = Math.max(0, endAddr - currentStart);
+                // Last field wraps to first field (5250 screen is circular)
+                const firstStart = this.screen.offset(fields[0].row, fields[0].col);
+                current.length = Math.max(0, (this.screen.size - currentStart) + firstStart - 1);
                 // Cap at a reasonable maximum
                 if (current.length > this.screen.cols * 2) {
                     current.length = this.screen.cols - current.col;
@@ -408,5 +528,40 @@ export class TN5250Parser {
             if (current.length <= 0)
                 current.length = 1;
         }
+        // Ensure cursor is in a functional input field. Skip UIM framework
+        // artifact fields whose OWN attribute byte doesn't indicate underscore
+        // or non-display (they may inherit underscore from SA context but aren't
+        // real interactive fields — they exist in the panel header).
+        {
+            const allInputs = fields.filter(f => this.screen.isInputField(f));
+            if (allInputs.length > 0) {
+                const lastPos = this.screen.offset(allInputs[allInputs.length - 1].row, allInputs[allInputs.length - 1].col);
+                const functional = allInputs.filter(f => this.screen.hasNativeUnderscore(f) || this.screen.hasNativeNonDisplay(f) ||
+                    this.screen.offset(f.row, f.col) === lastPos);
+                const targets = functional.length > 0 ? functional : allInputs;
+                const cursorAddr = this.screen.offset(this.screen.cursorRow, this.screen.cursorCol);
+                const inTarget = targets.some(f => {
+                    const start = this.screen.offset(f.row, f.col);
+                    return cursorAddr >= start && cursorAddr < start + f.length;
+                });
+                if (!inTarget) {
+                    const after = targets.find(f => this.screen.offset(f.row, f.col) >= cursorAddr);
+                    const target = after || targets[targets.length - 1];
+                    this.screen.cursorRow = target.row;
+                    this.screen.cursorCol = target.col;
+                }
+            }
+        }
+        // Deduplicate fields at the same position (keep the last one)
+        const seen = new Map();
+        for (let i = 0; i < fields.length; i++) {
+            const key = `${fields[i].row},${fields[i].col}`;
+            seen.set(key, i);
+        }
+        if (seen.size < fields.length) {
+            const keep = new Set(seen.values());
+            this.screen.fields = fields.filter((_, i) => keep.has(i));
+        }
     }
 }
+//# sourceMappingURL=parser.js.map