@netkitty/codec 1.0.0

package/dist/headers/Gopher.d.ts

@@ -0,0 +1,43 @@
+import { BaseHeader } from '../abstracts/BaseHeader';
+import { ProtocolJSONSchema } from '../schema/ProtocolJSONSchema';
+import { DemuxProducer } from '../types/DemuxProducer';
+/**
+ * Gopher — the Internet Gopher Protocol (RFC 1436), carried over TCP well-known port 70. A transaction
+ * is US-ASCII text:
+ *
+ *   REQUEST  (client → server):  "<selector>{C}"                       e.g. "/rfc/rfc1436.txt\r\n"
+ *                            or  "<selector>{TAB}<search>{C}"          (a type-7 index-search query)
+ *                                {C} is CR LF. The empty selector requests the root menu ("\r\n").
+ *   RESPONSE (server → client):  a series of directory items, each a Gopher menu line
+ *                                "<type><display>{TAB}<selector>{TAB}<host>{TAB}<port>{C}", the whole
+ *                                listing terminated by a lone "." line (".\r\n"); or, for a text item,
+ *                                the file body terminated the same way.
+ *
+ * MINIMAL slice (mirrors the Finger/Ident/SIP/HTTP verbatim-message pattern): a Gopher message is
+ * free-form US-ASCII framed only by CR LF and a menu grammar whose display/selector/host fields MAY carry
+ * almost any octet, and whitespace/line ordering is significant to peers. The ENTIRE payload is therefore
+ * the single source of truth — decoded verbatim to hex in the authoritative `message` field and
+ * re-emitted byte-for-byte on encode. On top of that the first line is parsed into DISPLAY-ONLY metadata:
+ * whether the transaction is a request or a response (decided by the TCP port direction — dst 70 is a
+ * request, src 70 a response), the request selector and optional type-7 search term, and whether the
+ * payload is terminated by the "." end-of-transmission line. Those metadata carry no codec of their own
+ * and never reconstruct the bytes — the message owns them. So any Gopher payload (a selector request, a
+ * menu response, a text body, or a truncated fragment) round-trips exactly.
+ *
+ * Matching rationale (NO heuristicFallback): Gopher is claimed ONLY on the tcp:70 bucket. A request line
+ * is arbitrary US-ASCII text with no distinctive off-port content signature, so recognizing it relies
+ * entirely on the well-known port; joining the global content-heuristic chain would mislabel arbitrary
+ * text TCP payloads on any port. Confining Gopher to tcp:70 keeps that impossible; alt-port Gopher is rare
+ * and falls losslessly to raw. As the terminal verbatim layer it consumes to the end of the segment (like
+ * Finger/Ident/HTTP) so a well-formed frame round-trips byte-for-byte.
+ */
+export declare class Gopher extends BaseHeader {
+    #private;
+    get SCHEMA(): ProtocolJSONSchema;
+    readonly id: string;
+    readonly name: string;
+    readonly nickname: string;
+    readonly matchKeys: string[];
+    match(): boolean;
+    readonly demuxProducers: DemuxProducer[];
+}

package/dist/headers/Gopher.js

@@ -0,0 +1,182 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Gopher = void 0;
+const BaseHeader_1 = require("../abstracts/BaseHeader");
+const BufferToHex_1 = require("../helper/BufferToHex");
+const HexToBuffer_1 = require("../helper/HexToBuffer");
+const StringContentEncodingEnum_1 = require("../lib/StringContentEncodingEnum");
+/** The Gopher well-known TCP port (RFC 1436). */
+const GOPHER_PORT = 70;
+/**
+ * Gopher — the Internet Gopher Protocol (RFC 1436), carried over TCP well-known port 70. A transaction
+ * is US-ASCII text:
+ *
+ *   REQUEST  (client → server):  "<selector>{C}"                       e.g. "/rfc/rfc1436.txt\r\n"
+ *                            or  "<selector>{TAB}<search>{C}"          (a type-7 index-search query)
+ *                                {C} is CR LF. The empty selector requests the root menu ("\r\n").
+ *   RESPONSE (server → client):  a series of directory items, each a Gopher menu line
+ *                                "<type><display>{TAB}<selector>{TAB}<host>{TAB}<port>{C}", the whole
+ *                                listing terminated by a lone "." line (".\r\n"); or, for a text item,
+ *                                the file body terminated the same way.
+ *
+ * MINIMAL slice (mirrors the Finger/Ident/SIP/HTTP verbatim-message pattern): a Gopher message is
+ * free-form US-ASCII framed only by CR LF and a menu grammar whose display/selector/host fields MAY carry
+ * almost any octet, and whitespace/line ordering is significant to peers. The ENTIRE payload is therefore
+ * the single source of truth — decoded verbatim to hex in the authoritative `message` field and
+ * re-emitted byte-for-byte on encode. On top of that the first line is parsed into DISPLAY-ONLY metadata:
+ * whether the transaction is a request or a response (decided by the TCP port direction — dst 70 is a
+ * request, src 70 a response), the request selector and optional type-7 search term, and whether the
+ * payload is terminated by the "." end-of-transmission line. Those metadata carry no codec of their own
+ * and never reconstruct the bytes — the message owns them. So any Gopher payload (a selector request, a
+ * menu response, a text body, or a truncated fragment) round-trips exactly.
+ *
+ * Matching rationale (NO heuristicFallback): Gopher is claimed ONLY on the tcp:70 bucket. A request line
+ * is arbitrary US-ASCII text with no distinctive off-port content signature, so recognizing it relies
+ * entirely on the well-known port; joining the global content-heuristic chain would mislabel arbitrary
+ * text TCP payloads on any port. Confining Gopher to tcp:70 keeps that impossible; alt-port Gopher is rare
+ * and falls losslessly to raw. As the terminal verbatim layer it consumes to the end of the segment (like
+ * Finger/Ident/HTTP) so a well-formed frame round-trips byte-for-byte.
+ */
+class Gopher extends BaseHeader_1.BaseHeader {
+    constructor() {
+        super(...arguments);
+        this.id = 'gopher';
+        this.name = 'Internet Gopher Protocol';
+        this.nickname = 'Gopher';
+        //Gopher is recognized ONLY on the well-known port 70 — deliberately NOT via heuristicFallback. A
+        //request/response line is arbitrary US-ASCII text with no distinctive off-port content signature, so
+        //its recognition depends entirely on the port bucket; joining the global heuristic chain would
+        //mislabel arbitrary text TCP payloads on any port. See the class doc for the full rationale.
+        this.matchKeys = ['tcpport:70'];
+        //A leaf header — a Gopher request/response is a single free-form text transaction; nothing demuxes
+        //off it.
+        this.demuxProducers = [];
+    }
+    static #schemaCache;
+    get SCHEMA() {
+        return (Gopher.#schemaCache ??= Gopher.#buildSchema());
+    }
+    /** Bytes available to this header: Gopher rides on TCP, which has no per-message length. */
+    #payloadLength() {
+        const available = this.packet.length - this.startPos;
+        return available < 0 ? 0 : available;
+    }
+    /**
+     * True when this transaction is a client request (TCP destination port 70), false for a server
+     * response (source port 70). Read from the parent TCP layer for display only; when neither port is 70
+     * (an alt-port capture that still reached this bucket via a custom match) it defaults to a request.
+     */
+    #isRequestDirection() {
+        const tcp = this.prevCodecModule;
+        if (!tcp)
+            return true;
+        const dstport = tcp.instance.dstport.getValue(0);
+        const srcport = tcp.instance.srcport.getValue(0);
+        if (srcport === GOPHER_PORT && dstport !== GOPHER_PORT)
+            return false;
+        return true;
+    }
+    /**
+     * Parse the first line into the display-only metadata fields. A request line is
+     * `<selector>[{TAB}<search>]{C}`; a response is a menu/text body terminated by a lone "." line.
+     * Populated on decode only — these fields have no encode, so they never affect the re-emitted bytes
+     * and never mutate `message`. Never throws: missing tokens yield empty strings / 0.
+     */
+    #parse(text) {
+        const isRequest = this.#isRequestDirection();
+        this.instance.isRequest.setValue(isRequest);
+        //Isolate the first line (up to the first CR LF, or a lone LF); `message` still holds all bytes.
+        let firstLine = text;
+        const lf = firstLine.indexOf('\n');
+        if (lf >= 0)
+            firstLine = firstLine.slice(0, lf);
+        if (firstLine.endsWith('\r'))
+            firstLine = firstLine.slice(0, -1);
+        //A Gopher payload is complete when it ends with the "." end-of-transmission line (".\r\n", or a
+        //lone "." with a tolerated bare LF, or the whole payload being just ".").
+        const hasTerminator = /(^|\r?\n)\.\r?\n$/.test(text) || text === '.\r\n' || text === '.\n' || text === '.';
+        this.instance.hasTerminator.setValue(hasTerminator);
+        if (isRequest) {
+            //Request: the selector is the first line, optionally followed by a TAB + search term (type 7).
+            const tab = firstLine.indexOf('\t');
+            const selector = tab >= 0 ? firstLine.slice(0, tab) : firstLine;
+            const search = tab >= 0 ? firstLine.slice(tab + 1) : '';
+            this.instance.selector.setValue(selector);
+            this.instance.searchTerm.setValue(search);
+            this.instance.itemCount.setValue(0);
+            const shown = selector === '' ? '(root)' : selector;
+            this.instance.summaryInfo.setValue(search ? `request ${shown} search="${search}"` : `request ${shown}`);
+            return;
+        }
+        //Response: count the menu/text lines that precede the terminating "." line. Split on LF, drop the
+        //optional trailing empty element after the last CR LF, and stop at the "." terminator line.
+        this.instance.selector.setValue('');
+        this.instance.searchTerm.setValue('');
+        const lines = text.split('\n');
+        let count = 0;
+        for (const rawLine of lines) {
+            const line = rawLine.endsWith('\r') ? rawLine.slice(0, -1) : rawLine;
+            if (line === '.')
+                break;
+            if (line === '')
+                continue;
+            count++;
+        }
+        this.instance.itemCount.setValue(count);
+        this.instance.summaryInfo.setValue(`response ${count} line${count === 1 ? '' : 's'}${hasTerminator ? '' : ' (partial)'}`);
+    }
+    static #buildSchema() {
+        return {
+            type: 'object',
+            summary: 'Gopher ${summaryInfo}',
+            properties: {
+                //Display-only metadata parsed on decode (no encode — populated by the `message` field
+                //below, never read back). isRequest is decided by the TCP port direction; selector and
+                //searchTerm apply to a request; itemCount to a response; hasTerminator flags the "." end.
+                isRequest: { type: 'boolean', label: 'Is Request', default: false },
+                selector: { type: 'string', label: 'Selector', default: '' },
+                searchTerm: { type: 'string', label: 'Search Term', default: '' },
+                itemCount: { type: 'integer', label: 'Item Count', minimum: 0, default: 0 },
+                hasTerminator: { type: 'boolean', label: 'Has Terminator', default: false },
+                //Drives the one-line summary (request selector / response line count).
+                summaryInfo: { type: 'string', label: 'Summary', hidden: true, default: '' },
+                //The whole raw payload is the single source of truth: decoded verbatim to hex and
+                //re-emitted untouched (byte-perfect for any Gopher payload). The first line is parsed into
+                //the display-only metadata above, which carry no codec of their own.
+                message: {
+                    type: 'string',
+                    label: 'Message',
+                    contentEncoding: StringContentEncodingEnum_1.StringContentEncodingEnum.HEX,
+                    default: '',
+                    decode: function () {
+                        const available = this.#payloadLength();
+                        if (available <= 0) {
+                            this.instance.message.setValue('');
+                            this.#parse('');
+                            return;
+                        }
+                        const raw = this.readBytes(0, available);
+                        this.instance.message.setValue((0, BufferToHex_1.BufferToHex)(raw));
+                        this.#parse(raw.toString('latin1'));
+                    },
+                    encode: function () {
+                        //Re-emit the authoritative payload verbatim — never reconstruct from metadata.
+                        this.writeBytes(0, (0, HexToBuffer_1.HexToBuffer)(this.instance.message.getValue('')));
+                    }
+                }
+            }
+        };
+    }
+    match() {
+        //Reached only on the tcp:70 bucket. Port 70 IS Gopher's, so any non-empty payload over TCP is
+        //claimed and kept verbatim (byte-perfect) — deliberately without a printable-text gate, so a
+        //binary text/menu body is never wrongly dropped to raw. An empty payload (a bare ACK) is not
+        //claimed.
+        if (!this.prevCodecModule)
+            return false;
+        if (this.prevCodecModule.id !== 'tcp')
+            return false;
+        return this.#payloadLength() >= 1;
+    }
+}
+exports.Gopher = Gopher;

package/dist/headers/HARTIP.d.ts

@@ -0,0 +1,30 @@
+import { BaseHeader } from '../abstracts/BaseHeader';
+import { ProtocolJSONSchema } from '../schema/ProtocolJSONSchema';
+import { DemuxProducer } from '../types/DemuxProducer';
+/**
+ * HART-IP (HART over IP, FieldComm Group spec HCF_SPEC-085), the process-automation transport that
+ * carries HART commands over UDP and TCP port 5094. Every HART-IP message begins with a fixed 8-byte
+ * header: Version (== 1), Message Type (0 Request, 1 Response, 2 Publish/Notify, 3 NAK), Message ID
+ * (0 Session Initiate, 1 Session Close, 2 Keep Alive, 3 Token-Passing PDU, 4 Direct PDU), a Status
+ * byte, a 2-byte Sequence Number, and a 2-byte Byte Count — the total message length including this
+ * 8-byte header. The HART PDU payload follows.
+ *
+ * Byte-perfect strategy (minimal slice): the 8-byte header is structured; the HART PDU (a session
+ * record, a command frame, or a token-passing / direct PDU whose layout depends on the Message ID and
+ * the HART command set) is kept verbatim as `payload` hex, bounded by the Byte Count and the transport
+ * payload (UDP length − 8, or the captured TCP bytes). The Byte Count is auto-computed from the payload
+ * on encode when not supplied, else honored verbatim (a crafted message may lie); the message is bounded
+ * by Byte Count so a second pipelined message or trailing bytes are left to the codec's recursion /
+ * RawData. Both UDP and TCP use the same 8-byte header (HART-IP has no TCP record-marking prefix). A
+ * well-formed message round-trips byte-for-byte.
+ */
+export declare class HARTIP extends BaseHeader {
+    #private;
+    get SCHEMA(): ProtocolJSONSchema;
+    readonly id: string;
+    readonly name: string;
+    readonly nickname: string;
+    readonly matchKeys: string[];
+    match(): boolean;
+    readonly demuxProducers: DemuxProducer[];
+}

package/dist/headers/HARTIP.js

@@ -0,0 +1,145 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HARTIP = void 0;
+const BaseHeader_1 = require("../abstracts/BaseHeader");
+const BufferToHex_1 = require("../helper/BufferToHex");
+const HexToBuffer_1 = require("../helper/HexToBuffer");
+const BufferToNumber_1 = require("../helper/BufferToNumber");
+const NumberToBuffer_1 = require("../helper/NumberToBuffer");
+const StringContentEncodingEnum_1 = require("../lib/StringContentEncodingEnum");
+/**
+ * HART-IP (HART over IP, FieldComm Group spec HCF_SPEC-085), the process-automation transport that
+ * carries HART commands over UDP and TCP port 5094. Every HART-IP message begins with a fixed 8-byte
+ * header: Version (== 1), Message Type (0 Request, 1 Response, 2 Publish/Notify, 3 NAK), Message ID
+ * (0 Session Initiate, 1 Session Close, 2 Keep Alive, 3 Token-Passing PDU, 4 Direct PDU), a Status
+ * byte, a 2-byte Sequence Number, and a 2-byte Byte Count — the total message length including this
+ * 8-byte header. The HART PDU payload follows.
+ *
+ * Byte-perfect strategy (minimal slice): the 8-byte header is structured; the HART PDU (a session
+ * record, a command frame, or a token-passing / direct PDU whose layout depends on the Message ID and
+ * the HART command set) is kept verbatim as `payload` hex, bounded by the Byte Count and the transport
+ * payload (UDP length − 8, or the captured TCP bytes). The Byte Count is auto-computed from the payload
+ * on encode when not supplied, else honored verbatim (a crafted message may lie); the message is bounded
+ * by Byte Count so a second pipelined message or trailing bytes are left to the codec's recursion /
+ * RawData. Both UDP and TCP use the same 8-byte header (HART-IP has no TCP record-marking prefix). A
+ * well-formed message round-trips byte-for-byte.
+ */
+class HARTIP extends BaseHeader_1.BaseHeader {
+    constructor() {
+        super(...arguments);
+        this.id = 'hartip';
+        this.name = 'HART-IP';
+        this.nickname = 'HART-IP';
+        //HART-IP rides UDP and TCP port 5094.
+        this.matchKeys = ['udpport:5094', 'tcpport:5094'];
+        //A leaf header — the HART PDU payload requires Message-ID- and command-set-dependent parsing.
+        this.demuxProducers = [];
+    }
+    static #schemaCache;
+    get SCHEMA() {
+        return (HARTIP.#schemaCache ??= HARTIP.#buildSchema());
+    }
+    /**
+     * Header-relative end offset of the transport payload available to this HART-IP message, so a lying
+     * Byte Count never reads past the real transport payload and trailing / pipelined data is left to the
+     * codec. Over UDP the bound is (udp.length − 8); over TCP HART-IP has no framing prefix, so the bound
+     * is the captured bytes. Both clamped to what was actually captured.
+     */
+    #payloadEnd() {
+        let end = this.packet.length - this.startPos;
+        const prev = this.prevCodecModule;
+        if (prev && prev.id === 'udp') {
+            const udpLength = prev.instance.length.getValue(0);
+            if (udpLength >= 8 && udpLength - 8 < end)
+                end = udpLength - 8;
+        }
+        return end < 0 ? 0 : end;
+    }
+    static #buildSchema() {
+        return {
+            type: 'object',
+            summary: 'HART-IP type=${messageType} id=${messageId} seq=${sequenceNumber}',
+            properties: {
+                //Protocol version — 1 for the current HART-IP specification. Kept verbatim so a crafted
+                //message with any version still round-trips.
+                version: this.fieldUInt('version', 0, 1, 'Version'),
+                //0 Request, 1 Response, 2 Publish/Notify, 3 NAK. Kept as a plain clamped byte (not an Ajv
+                //enum) so any non-conformant / crafted value decoded from the wire still re-encodes
+                //without throwing — decode never fails and encode is a faithful executor.
+                messageType: this.fieldUInt('messageType', 1, 1, 'Message Type'),
+                //0 Session Initiate, 1 Session Close, 2 Keep Alive, 3 Token-Passing PDU, 4 Direct PDU.
+                messageId: this.fieldUInt('messageId', 2, 1, 'Message ID'),
+                //Response/communication status (0 on a request); an opaque byte kept verbatim.
+                status: this.fieldUInt('status', 3, 1, 'Status'),
+                //Monotonic per-session sequence number matching a response to its request.
+                sequenceNumber: this.fieldUInt('sequenceNumber', 4, 2, 'Sequence Number'),
+                byteCount: {
+                    type: 'integer',
+                    label: 'Byte Count',
+                    //minimum 0 (not 8): a crafted/corrupt message may carry a Byte Count below the 8-byte
+                    //header, and such a value must round-trip (honored verbatim) rather than being rejected
+                    //by Ajv at the encode entry — decode never fails, encode is faithful.
+                    minimum: 0,
+                    maximum: 65535,
+                    decode: function () {
+                        this.instance.byteCount.setValue((0, BufferToNumber_1.BufferToUInt16)(this.readBytes(6, 2)));
+                    },
+                    encode: function () {
+                        //Byte Count is the whole message length = 8-byte header + payload. Honored when
+                        //supplied (a crafted message may lie); else derived from the payload.
+                        const provided = this.instance.byteCount.getValue();
+                        let value = (provided !== undefined && provided !== null)
+                            ? provided
+                            : 8 + (0, HexToBuffer_1.HexToBuffer)(this.instance.payload.getValue('')).length;
+                        if (value > 65535) {
+                            this.recordError(this.instance.byteCount.getPath(), 'Maximum value is 65535');
+                            value = 65535;
+                        }
+                        if (value < 0) {
+                            this.recordError(this.instance.byteCount.getPath(), 'Minimum value is 0');
+                            value = 0;
+                        }
+                        this.instance.byteCount.setValue(value);
+                        this.writeBytes(6, (0, NumberToBuffer_1.UInt16ToBuffer)(value));
+                    }
+                },
+                //The HART PDU after the 8-byte header, kept verbatim. Bounded by the Byte Count (the
+                //message ends at offset Byte Count) and the captured transport payload, so trailing /
+                //pipelined data is left to the codec's recursion / RawData.
+                payload: {
+                    type: 'string',
+                    label: 'Payload',
+                    contentEncoding: StringContentEncodingEnum_1.StringContentEncodingEnum.HEX,
+                    decode: function () {
+                        const transportEnd = this.#payloadEnd();
+                        const byteCount = this.instance.byteCount.getValue(0);
+                        let end = byteCount;
+                        if (end > transportEnd)
+                            end = transportEnd;
+                        this.instance.payload.setValue(end > 8 ? (0, BufferToHex_1.BufferToHex)(this.readBytes(8, end - 8)) : '');
+                    },
+                    encode: function () {
+                        const payload = this.instance.payload.getValue('');
+                        if (payload)
+                            this.writeBytes(8, (0, HexToBuffer_1.HexToBuffer)(payload));
+                    }
+                }
+            }
+        };
+    }
+    match() {
+        //HART-IP is selected via the udpport:5094 / tcpport:5094 buckets. This stays a port-bucket
+        //protocol (matchKeys only, NO heuristicFallback): require the full 8-byte header within the
+        //transport payload and Version == 1 so non-HART-IP traffic on 5094 falls through to raw. The
+        //payload bound is the transport payload (udp.length − 8 / captured TCP bytes), not the whole
+        //captured frame, so Ethernet padding is not mistaken for header bytes.
+        if (!this.prevCodecModule)
+            return false;
+        if (this.prevCodecModule.id !== 'udp' && this.prevCodecModule.id !== 'tcp')
+            return false;
+        if (this.#payloadEnd() < 8)
+            return false;
+        return (0, BufferToNumber_1.BufferToUInt8)(this.readBytes(0, 1, true)) === 1;
+    }
+}
+exports.HARTIP = HARTIP;

package/dist/headers/HSR.d.ts

@@ -0,0 +1,27 @@
+import { ProtocolJSONSchema } from '../schema/ProtocolJSONSchema';
+import { BaseHeader } from '../abstracts/BaseHeader';
+import { DemuxProducer } from '../types/DemuxProducer';
+/**
+ * HSR — High-availability Seamless Redundancy (IEC 62439-3), an L2 redundancy tag carried with EtherType
+ * 0x892f. This codec decodes the 6-octet HSR tag: a 4-bit Path / network id (`path`, top nibble of the
+ * first 2 octets) and a 12-bit LSDU Size (`lsduSize`, the low 12 bits) packed into the same 2-octet
+ * window, a 16-bit Sequence Number (`seqNr`, offset 2), and the 16-bit original EtherType of the carried
+ * frame (`etherType`, offset 4, a lowercase 4-hex string). `path` and `lsduSize` overlay disjoint bit
+ * ranges so their two encode closures write the shared window without clobbering each other; `lsduSize`
+ * is a plain read/write value and is NOT used to bound the carried frame (the inner protocol self-bounds).
+ *
+ * The trailing field is deliberately named `etherType` and stored exactly like VLAN/Ethernet, and is
+ * published as an `ethertype` demux key, so L2 children (GOOSE, SV, VLAN, ARP…) discriminate on it
+ * normally. match() mirrors VLAN: it fires whenever the carrying layer's EtherType is 0x892f — directly
+ * on Ethernet, inside a VLAN, or nested in another HSR tag — provided at least the 6 tag octets are
+ * present.
+ */
+export declare class HSR extends BaseHeader {
+    SCHEMA: ProtocolJSONSchema;
+    readonly id: string;
+    readonly matchKeys: string[];
+    readonly demuxProducers: DemuxProducer[];
+    readonly name: string;
+    readonly nickname: string;
+    match(): boolean;
+}

package/dist/headers/HSR.js

@@ -0,0 +1,105 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HSR = void 0;
+const BaseHeader_1 = require("../abstracts/BaseHeader");
+const NumberToHex_1 = require("../helper/NumberToHex");
+const BufferToHex_1 = require("../helper/BufferToHex");
+/**
+ * HSR — High-availability Seamless Redundancy (IEC 62439-3), an L2 redundancy tag carried with EtherType
+ * 0x892f. This codec decodes the 6-octet HSR tag: a 4-bit Path / network id (`path`, top nibble of the
+ * first 2 octets) and a 12-bit LSDU Size (`lsduSize`, the low 12 bits) packed into the same 2-octet
+ * window, a 16-bit Sequence Number (`seqNr`, offset 2), and the 16-bit original EtherType of the carried
+ * frame (`etherType`, offset 4, a lowercase 4-hex string). `path` and `lsduSize` overlay disjoint bit
+ * ranges so their two encode closures write the shared window without clobbering each other; `lsduSize`
+ * is a plain read/write value and is NOT used to bound the carried frame (the inner protocol self-bounds).
+ *
+ * The trailing field is deliberately named `etherType` and stored exactly like VLAN/Ethernet, and is
+ * published as an `ethertype` demux key, so L2 children (GOOSE, SV, VLAN, ARP…) discriminate on it
+ * normally. match() mirrors VLAN: it fires whenever the carrying layer's EtherType is 0x892f — directly
+ * on Ethernet, inside a VLAN, or nested in another HSR tag — provided at least the 6 tag octets are
+ * present.
+ */
+class HSR extends BaseHeader_1.BaseHeader {
+    constructor() {
+        super(...arguments);
+        this.SCHEMA = {
+            type: 'object',
+            summary: 'HSR seq=${seqNr}',
+            properties: {
+                path: {
+                    type: 'integer',
+                    minimum: 0,
+                    maximum: 15,
+                    default: 0,
+                    label: 'Path',
+                    //Path (network id) and LSDUsize share the first 2 octets: Path is the top 4 bits,
+                    //LSDUsize the low 12 bits. writeBits masks its own field, so the two encode closures
+                    //overlay disjoint bit ranges into the same window without clobbering each other.
+                    decode: () => {
+                        this.instance.path.setValue(this.readBits(0, 2, 0, 4));
+                    },
+                    encode: () => {
+                        const pathValue = this.instance.path.getValue(0);
+                        this.instance.path.setValue(pathValue);
+                        this.writeBits(0, 2, 0, 4, pathValue);
+                    }
+                },
+                lsduSize: {
+                    type: 'integer',
+                    minimum: 0,
+                    maximum: 4095,
+                    default: 0,
+                    label: 'LSDU Size',
+                    //A plain read/write field: NOT used to bound the carried frame (the inner protocol
+                    //self-bounds via its own length semantics).
+                    decode: () => {
+                        this.instance.lsduSize.setValue(this.readBits(0, 2, 4, 12));
+                    },
+                    encode: () => {
+                        const lsduSizeValue = this.instance.lsduSize.getValue(0);
+                        this.instance.lsduSize.setValue(lsduSizeValue);
+                        this.writeBits(0, 2, 4, 12, lsduSizeValue);
+                    }
+                },
+                seqNr: BaseHeader_1.BaseHeader.fieldUInt('seqNr', 2, 2, 'Sequence Number'),
+                etherType: {
+                    type: 'string',
+                    minLength: 4,
+                    maxLength: 4,
+                    label: 'EtherType',
+                    //The ORIGINAL EtherType of the carried frame. MUST be named `etherType` and stored as a
+                    //lowercase 4-hex string exactly like VLAN/Ethernet, because L2 children (GOOSE, SV,
+                    //VLAN, ARP) discriminate by reading prevCodecModule.instance.etherType — a different
+                    //name would make them read undefined and fall through to RawData.
+                    decode: () => {
+                        this.instance.etherType.setValue((0, BufferToHex_1.BufferToHex)(this.readBytes(4, 2)));
+                    },
+                    encode: () => {
+                        const etherType = this.instance.etherType.getValue((0, NumberToHex_1.UInt16ToHex)(0x0000), (nodePath) => this.recordError(nodePath, 'Not Found'));
+                        const typeBuffer = Buffer.from(etherType, 'hex');
+                        if (typeBuffer.length < 2)
+                            typeBuffer.fill(0, 0, 1);
+                        this.writeBytes(4, typeBuffer.subarray(0, 2));
+                    }
+                }
+            }
+        };
+        this.id = 'hsr';
+        this.matchKeys = ['ethertype:892f'];
+        this.demuxProducers = [{ field: 'etherType', namespace: 'ethertype', kind: 'string' }];
+        this.name = 'High-availability Seamless Redundancy';
+        this.nickname = 'HSR';
+    }
+    match() {
+        //Like a VLAN tag, HSR is selected by the carrying layer's EtherType (0x892f) with no restriction
+        //on which layer that is — so it rides directly on Ethernet (the usual case) and equally inside a
+        //VLAN (VLAN-tagged HSR) or a nested HSR tag. This mirrors VLAN_802dot1Q.match exactly.
+        if (!this.prevCodecModule)
+            return false;
+        if (this.prevCodecModule.instance.etherType.getValue() !== (0, NumberToHex_1.UInt16ToHex)(0x892f))
+            return false;
+        //The 6-octet HSR tag must fit: Path/LSDUsize (2) + SeqNr (2) + carried EtherType (2).
+        return this.packet.length - this.startPos >= 6;
+    }
+}
+exports.HSR = HSR;

package/dist/headers/HSRP.d.ts

@@ -0,0 +1,26 @@
+import { BaseHeader } from '../abstracts/BaseHeader';
+import { ProtocolJSONSchema } from '../schema/ProtocolJSONSchema';
+import { DemuxProducer } from '../types/DemuxProducer';
+/**
+ * HSRP — Hot Standby Router Protocol version 1 (RFC 2281, Cisco), carried over UDP port 1985 to the
+ * all-routers multicast group 224.0.0.2. The version-1 message is a fixed 20 bytes: Version (0 for v1),
+ * Op Code (0 Hello / 1 Coup / 2 Resign), State (0 Initial / 1 Learn / 2 Listen / 4 Speak / 8 Standby /
+ * 16 Active), Hellotime and Holdtime (seconds), Priority, Group, a Reserved byte, an 8-byte
+ * Authentication Data field (a plaintext password, default "cisco" — kept verbatim as hex so any value
+ * round-trips), and the 4-byte Virtual IP Address.
+ *
+ * Only version 0 (HSRPv1) is decoded field-by-field; a non-zero Version (HSRPv2 uses a different,
+ * TLV-based layout on this port) falls back to a verbatim `rawBody` hex so the message still round-trips
+ * byte-for-byte. HSRP is a leaf — nothing rides on top of it. The message is bounded by the 20-byte v1
+ * mandatory section; any trailing bytes in the UDP datagram are left to the codec's recursion / RawData.
+ */
+export declare class HSRP extends BaseHeader {
+    #private;
+    get SCHEMA(): ProtocolJSONSchema;
+    readonly id: string;
+    readonly name: string;
+    readonly nickname: string;
+    readonly matchKeys: string[];
+    match(): boolean;
+    readonly demuxProducers: DemuxProducer[];
+}