@netkitty/codec 1.0.0

package/dist/headers/MPLS.js

@@ -0,0 +1,145 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MPLS = 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");
+/**
+ * MPLS — Multiprotocol Label Switching (RFC 3032), carried directly in an Ethernet II frame with
+ * EtherType 0x8847 (unicast) or 0x8848 (multicast) — an Ethernet child, no IP/UDP below it. The MPLS
+ * shim is a label stack: a sequence of 4-byte entries, each packing a 20-bit Label, a 3-bit Traffic
+ * Class / Experimental field (TC/EXP), a 1-bit Bottom-of-Stack flag (S), and an 8-bit Time To Live
+ * (TTL). The stack repeats until an entry with S=1 (the bottom of stack); the encapsulated packet
+ * (typically IPv4/IPv6, dispatched by the first payload nibble) follows immediately after it.
+ *
+ * This codec is the label-stack leaf: it decodes the stack (each entry's structured label/tc/s/ttl)
+ * up to and including the S=1 entry, then keeps the encapsulated packet after it as an opaque `payload`
+ * hex field so MPLS is a self-contained byte-perfect leaf. (It deliberately consumes the payload rather
+ * than leaving it to the codec's recursion: with IPv4/IPv6.match unchanged the inner IP would not fall
+ * to RawData but be claimed by the greedy EthernetII content heuristic, which emits an un-re-encodable
+ * layer for a short trailer. Owning the bytes keeps decode→encode from ever throwing.) Each entry and
+ * the payload are re-emitted verbatim, so a well-formed shim round-trips byte-for-byte. Structured inner
+ * IPv4/IPv6 recursion is a serial follow-up (IPv4/IPv6.match must learn an 'mpls' parent branch
+ * dispatching on the first payload nibble, at which point `payload` becomes real child layers).
+ */
+class MPLS extends BaseHeader_1.BaseHeader {
+    constructor() {
+        super(...arguments);
+        this.id = 'mpls';
+        this.name = 'Multiprotocol Label Switching';
+        this.nickname = 'MPLS';
+        this.matchKeys = ['ethertype:8847', 'ethertype:8848'];
+        //A leaf header for this slice: the encapsulated packet is left to the codec's recursion (inner IP
+        //recursion is a serial follow-up — see the class doc), so nothing demuxes off MPLS yet.
+        this.demuxProducers = [];
+    }
+    static #schemaCache;
+    get SCHEMA() {
+        return (MPLS.#schemaCache ??= MPLS.#buildSchema());
+    }
+    static #buildSchema() {
+        return {
+            type: 'object',
+            summary: 'MPLS ${entries.length} labels',
+            properties: {
+                entries: {
+                    type: 'array',
+                    label: 'Label Stack',
+                    items: {
+                        type: 'object',
+                        label: 'Label Stack Entry',
+                        properties: {
+                            label: { type: 'integer', label: 'Label', minimum: 0, maximum: 1048575 },
+                            tc: { type: 'integer', label: 'Traffic Class', minimum: 0, maximum: 7 },
+                            s: { type: 'integer', label: 'Bottom of Stack', minimum: 0, maximum: 1 },
+                            ttl: { type: 'integer', label: 'Time To Live', minimum: 0, maximum: 255 }
+                        }
+                    },
+                    decode: function () {
+                        //The label stack has no length field of its own — it runs until an entry with S=1
+                        //(bottom of stack). Bound the walk by the remaining frame bytes, reading each
+                        //4-byte entry as label(20)+tc(3)+s(1)+ttl(8), MSB-first. A truncated final entry
+                        //(fewer than 4 bytes left) stops the walk without being consumed.
+                        const available = this.packet.length - this.startPos;
+                        const entries = [];
+                        let offset = 0;
+                        while (offset + 4 <= available) {
+                            const label = this.readBits(offset, 4, 0, 20);
+                            const tc = this.readBits(offset, 4, 20, 3);
+                            const s = this.readBits(offset, 4, 23, 1);
+                            const ttl = this.readBits(offset, 4, 24, 8);
+                            entries.push({ label: label, tc: tc, s: s, ttl: ttl });
+                            offset += 4;
+                            //Bottom of stack — the encapsulated payload follows, left to the codec's
+                            //recursion (do not read into it).
+                            if (s === 1)
+                                break;
+                        }
+                        this.instance.entries.setValue(entries);
+                    },
+                    encode: function () {
+                        //Faithful executor: emit each supplied entry exactly as given (S and TC kept
+                        //verbatim), even a stack that never sets S=1 — a crafted frame may be malformed.
+                        const entries = this.instance.entries.getValue([]);
+                        let offset = 0;
+                        if (entries) {
+                            for (let i = 0; i < entries.length; i++) {
+                                const entry = entries[i] ? entries[i] : {};
+                                let label = entry.label ? entry.label : 0;
+                                //Label is a 20-bit field. A larger value cannot be represented; clamp and
+                                //record the error rather than letting writeBits wrap it modulo 2^20 (which
+                                //would silently corrupt the label).
+                                if (label > 1048575) {
+                                    this.recordError(`entries[${i}].label`, 'Maximum label is 1048575');
+                                    label = 1048575;
+                                }
+                                if (label < 0) {
+                                    this.recordError(`entries[${i}].label`, 'Minimum label is 0');
+                                    label = 0;
+                                }
+                                //writeBits masks each field to its width, so label/tc/s/ttl never clobber.
+                                this.writeBits(offset, 4, 0, 20, label);
+                                this.writeBits(offset, 4, 20, 3, entry.tc ? entry.tc : 0);
+                                this.writeBits(offset, 4, 23, 1, entry.s ? entry.s : 0);
+                                this.writeBits(offset, 4, 24, 8, entry.ttl ? entry.ttl : 0);
+                                offset += 4;
+                            }
+                        }
+                    }
+                },
+                //The encapsulated packet after the label stack, kept as opaque hex so MPLS owns every
+                //byte and is a self-contained byte-perfect leaf (see the class doc for why it is not left
+                //to the codec's recursion). It starts right after the stack — entries.length × 4 bytes.
+                payload: {
+                    type: 'string',
+                    label: 'Payload',
+                    contentEncoding: StringContentEncodingEnum_1.StringContentEncodingEnum.HEX,
+                    decode: function () {
+                        const stackBytes = (this.instance.entries.getValue([]) || []).length * 4;
+                        const available = this.packet.length - this.startPos;
+                        const payloadLength = available - stackBytes;
+                        this.instance.payload.setValue(payloadLength > 0 ? (0, BufferToHex_1.BufferToHex)(this.readBytes(stackBytes, payloadLength)) : '');
+                    },
+                    encode: function () {
+                        const stackBytes = (this.instance.entries.getValue([]) || []).length * 4;
+                        const payload = this.instance.payload.getValue('');
+                        if (payload)
+                            this.writeBytes(stackBytes, (0, HexToBuffer_1.HexToBuffer)(payload));
+                    }
+                }
+            }
+        };
+    }
+    match() {
+        //An Ethernet child selected by EtherType 0x8847 (unicast) or 0x8848 (multicast), stored as a
+        //lowercase 4-hex string on the parent. Require at least one 4-byte label stack entry.
+        if (!this.prevCodecModule)
+            return false;
+        const etherType = this.prevCodecModule.instance.etherType.getValue();
+        if (etherType !== '8847' && etherType !== '8848')
+            return false;
+        return this.packet.length - this.startPos >= 4;
+    }
+}
+exports.MPLS = MPLS;

package/dist/headers/MQTT.d.ts

@@ -0,0 +1,30 @@
+import { BaseHeader } from '../abstracts/BaseHeader';
+import { ProtocolJSONSchema } from '../schema/ProtocolJSONSchema';
+import { DemuxProducer } from '../types/DemuxProducer';
+/**
+ * MQTT — Message Queuing Telemetry Transport (OASIS MQTT 3.1.1 / 5.0), a lightweight publish/subscribe
+ * messaging protocol on TCP port 1883 (8883 for TLS). Every Control Packet begins with a 2-to-5 byte
+ * Fixed Header: a first byte carrying the 4-bit Message Type (1 CONNECT, 2 CONNACK, 3 PUBLISH, 8
+ * SUBSCRIBE, 12 PINGREQ, 13 PINGRESP, 14 DISCONNECT, …) and 4 header Flags (for PUBLISH these are
+ * DUP / QoS(2 bits) / RETAIN; for every other type they are a fixed reserved value), followed by the
+ * Remaining Length — a 1-to-4 byte variable-length integer counting the bytes of the Variable Header
+ * plus Payload that follow.
+ *
+ * This codec decodes the Fixed Header structurally (message type, the flags nibble, and the decoded
+ * Remaining Length value) and keeps the Variable Header + Payload region verbatim as `payload` hex —
+ * sub-decoding it depends on the message type and, for PUBLISH/SUBSCRIBE, on session/topic state that is
+ * cross-packet, not a single-packet concern. The Remaining Length is re-emitted as a canonical varint on
+ * encode: honored when supplied, else derived from the payload byte length. Because valid MQTT uses the
+ * minimal (canonical) varint encoding, a well-formed packet round-trips byte-for-byte; a hand-crafted
+ * frame that used a non-minimal (redundant) varint would not reproduce those extra continuation bytes.
+ */
+export declare class MQTT 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/MQTT.js

@@ -0,0 +1,173 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MQTT = 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 StringContentEncodingEnum_1 = require("../lib/StringContentEncodingEnum");
+/**
+ * MQTT — Message Queuing Telemetry Transport (OASIS MQTT 3.1.1 / 5.0), a lightweight publish/subscribe
+ * messaging protocol on TCP port 1883 (8883 for TLS). Every Control Packet begins with a 2-to-5 byte
+ * Fixed Header: a first byte carrying the 4-bit Message Type (1 CONNECT, 2 CONNACK, 3 PUBLISH, 8
+ * SUBSCRIBE, 12 PINGREQ, 13 PINGRESP, 14 DISCONNECT, …) and 4 header Flags (for PUBLISH these are
+ * DUP / QoS(2 bits) / RETAIN; for every other type they are a fixed reserved value), followed by the
+ * Remaining Length — a 1-to-4 byte variable-length integer counting the bytes of the Variable Header
+ * plus Payload that follow.
+ *
+ * This codec decodes the Fixed Header structurally (message type, the flags nibble, and the decoded
+ * Remaining Length value) and keeps the Variable Header + Payload region verbatim as `payload` hex —
+ * sub-decoding it depends on the message type and, for PUBLISH/SUBSCRIBE, on session/topic state that is
+ * cross-packet, not a single-packet concern. The Remaining Length is re-emitted as a canonical varint on
+ * encode: honored when supplied, else derived from the payload byte length. Because valid MQTT uses the
+ * minimal (canonical) varint encoding, a well-formed packet round-trips byte-for-byte; a hand-crafted
+ * frame that used a non-minimal (redundant) varint would not reproduce those extra continuation bytes.
+ */
+class MQTT extends BaseHeader_1.BaseHeader {
+    constructor() {
+        super(...arguments);
+        //Byte length of the Remaining Length varint for the current packet. Set when the remainingLength
+        //field decodes/encodes and read by the payload field to locate the start of the Variable Header +
+        //Payload region (offset 1 + this many bytes). Per-instance; decode/encode create fresh instances.
+        this.#varintLength = 1;
+        this.id = 'mqtt';
+        this.name = 'MQTT';
+        this.nickname = 'MQTT';
+        this.matchKeys = ['tcpport:1883'];
+        //A leaf header — the Variable Header + Payload is kept as hex, not demuxed further.
+        this.demuxProducers = [];
+    }
+    static #schemaCache;
+    get SCHEMA() {
+        return (MQTT.#schemaCache ??= MQTT.#buildSchema());
+    }
+    //Byte length of the Remaining Length varint for the current packet. Set when the remainingLength
+    //field decodes/encodes and read by the payload field to locate the start of the Variable Header +
+    //Payload region (offset 1 + this many bytes). Per-instance; decode/encode create fresh instances.
+    #varintLength;
+    /** Decode the Remaining Length variable-length integer at `offset` (MQTT algorithm: low 7 bits are
+     * value, high bit 0x80 means "more bytes follow", up to 4 bytes). Returns the decoded value and how
+     * many bytes it occupied. */
+    #readRemainingLength(offset) {
+        let value = 0;
+        let multiplier = 1;
+        let byteLength = 0;
+        for (let i = 0; i < 4; i++) {
+            const byte = (0, BufferToNumber_1.BufferToUInt8)(this.readBytes(offset + i, 1));
+            value += (byte & 0x7f) * multiplier;
+            multiplier *= 128;
+            byteLength++;
+            if ((byte & 0x80) === 0)
+                break;
+        }
+        return { value: value, byteLength: byteLength };
+    }
+    /** Encode `value` as a canonical (minimal) MQTT Remaining Length varint. */
+    #writeRemainingLength(value) {
+        const bytes = [];
+        let remaining = value >= 0 ? value : 0;
+        do {
+            let encodedByte = remaining % 128;
+            remaining = Math.floor(remaining / 128);
+            if (remaining > 0)
+                encodedByte |= 0x80;
+            bytes.push(encodedByte);
+        } while (remaining > 0 && bytes.length < 4);
+        return Buffer.from(bytes);
+    }
+    static #buildSchema() {
+        return {
+            type: 'object',
+            summary: 'MQTT type=${messageType}',
+            properties: {
+                //First byte, high nibble (bits 7-4): the Control Packet type.
+                messageType: {
+                    type: 'integer',
+                    label: 'Message Type',
+                    minimum: 0,
+                    maximum: 15,
+                    decode: function () {
+                        this.instance.messageType.setValue(this.readBits(0, 1, 0, 4));
+                    },
+                    encode: function () {
+                        this.writeBits(0, 1, 0, 4, this.instance.messageType.getValue(0));
+                    }
+                },
+                //First byte, low nibble (bits 3-0): the header flags. For PUBLISH these are DUP / QoS(2) /
+                //RETAIN; for other types a fixed reserved value. Kept as the raw nibble (byte-perfect).
+                flags: {
+                    type: 'integer',
+                    label: 'Flags',
+                    minimum: 0,
+                    maximum: 15,
+                    decode: function () {
+                        this.instance.flags.setValue(this.readBits(0, 1, 4, 4));
+                    },
+                    encode: function () {
+                        this.writeBits(0, 1, 4, 4, this.instance.flags.getValue(0));
+                    }
+                },
+                //The decoded value of the Remaining Length varint (length of Variable Header + Payload).
+                remainingLength: {
+                    type: 'integer',
+                    label: 'Remaining Length',
+                    minimum: 0,
+                    maximum: 268435455,
+                    decode: function () {
+                        const result = this.#readRemainingLength(1);
+                        this.#varintLength = result.byteLength;
+                        this.instance.remainingLength.setValue(result.value);
+                    },
+                    encode: function () {
+                        //Honored when supplied (a crafted packet may carry any value); else derived from the
+                        //payload byte length. Re-emitted as a canonical varint — reproduces the wire bytes
+                        //for well-formed (minimally encoded) frames.
+                        const provided = this.instance.remainingLength.getValue();
+                        const value = (provided !== undefined && provided !== null)
+                            ? provided
+                            : (0, HexToBuffer_1.HexToBuffer)(this.instance.payload.getValue('')).length;
+                        this.instance.remainingLength.setValue(value);
+                        const varint = this.#writeRemainingLength(value);
+                        this.#varintLength = varint.length;
+                        this.writeBytes(1, varint);
+                    }
+                },
+                //Variable Header + Payload, kept verbatim. Starts after the fixed header (offset 1 + the
+                //varint bytes) and spans Remaining Length bytes, clamped to the captured bytes so a
+                //truncated frame stays in-bounds and trailing/pipelined data is left to the codec's recursion.
+                payload: {
+                    type: 'string',
+                    label: 'Payload',
+                    contentEncoding: StringContentEncodingEnum_1.StringContentEncodingEnum.HEX,
+                    decode: function () {
+                        const remaining = this.packet.length - this.startPos;
+                        const start = 1 + this.#varintLength;
+                        const length = this.instance.remainingLength.getValue(0);
+                        let end = start + length;
+                        if (end > remaining)
+                            end = remaining;
+                        this.instance.payload.setValue(end > start ? (0, BufferToHex_1.BufferToHex)(this.readBytes(start, end - start)) : '');
+                    },
+                    encode: function () {
+                        const payload = this.instance.payload.getValue('');
+                        if (payload)
+                            this.writeBytes(1 + this.#varintLength, (0, HexToBuffer_1.HexToBuffer)(payload));
+                    }
+                }
+            }
+        };
+    }
+    match() {
+        //MQTT rides on TCP port 1883. Require at least the 2-byte minimum Fixed Header and a plausible
+        //Control Packet type (1..15; 0 is forbidden) as a content signature so non-MQTT 1883 traffic
+        //falls through to raw.
+        if (!this.prevCodecModule || this.prevCodecModule.id !== 'tcp')
+            return false;
+        if (this.packet.length - this.startPos < 2)
+            return false;
+        const byte0 = (0, BufferToNumber_1.BufferToUInt8)(this.readBytes(0, 1, true));
+        const messageType = byte0 >> 4;
+        return messageType >= 1 && messageType <= 15;
+    }
+}
+exports.MQTT = MQTT;

package/dist/headers/MQTTSN.d.ts

@@ -0,0 +1,34 @@
+import { BaseHeader } from '../abstracts/BaseHeader';
+import { ProtocolJSONSchema } from '../schema/ProtocolJSONSchema';
+import { DemuxProducer } from '../types/DemuxProducer';
+/**
+ * MQTT-SN — MQTT for Sensor Networks (v1.2), the UDP-datagram publish/subscribe protocol for
+ * constrained/wireless sensor networks (commonly gateway UDP ports 1883 or 10000). NOT to be confused
+ * with MQTT itself, which is the TCP/1883 stream protocol handled by the separate `mqtt` header.
+ *
+ * Every message begins with a variable-length Length field: the first octet is either the whole
+ * message length (1..255, counting the Length field itself + the Message Type + the body), OR the
+ * escape value 0x01, in which case the next TWO octets are the real length as a big-endian uint16
+ * (used when the message is 256..65535 octets). The Length is followed by a 1-octet Message Type
+ * (0x00 ADVERTISE, 0x04 CONNECT, 0x05 CONNACK, 0x0C PUBLISH, 0x12 SUBSCRIBE, …) and then the
+ * type-specific body.
+ *
+ * Because the per-type body layout (flags, topic ids/names, QoS, will) is message-type dependent and,
+ * for PUBLISH/SUBSCRIBE, ties into cross-datagram topic-registration state, this single-datagram codec
+ * keeps the body verbatim as `body` hex (byte-perfect) and does not sub-decode it. The Length is
+ * honored when supplied (a crafted datagram may lie), else derived from the body; the wire form (1- vs
+ * 3-octet Length) is derived from the Length value (>255 ⇒ 3-octet escape form), matching how a
+ * conformant sender chooses it, so a well-formed datagram round-trips byte-for-byte. The message is
+ * bounded by its Length and the UDP payload, so trailing bytes fall through to the codec's recursion /
+ * RawData.
+ */
+export declare class MQTTSN 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/MQTTSN.js

@@ -0,0 +1,177 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MQTTSN = 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");
+/**
+ * MQTT-SN — MQTT for Sensor Networks (v1.2), the UDP-datagram publish/subscribe protocol for
+ * constrained/wireless sensor networks (commonly gateway UDP ports 1883 or 10000). NOT to be confused
+ * with MQTT itself, which is the TCP/1883 stream protocol handled by the separate `mqtt` header.
+ *
+ * Every message begins with a variable-length Length field: the first octet is either the whole
+ * message length (1..255, counting the Length field itself + the Message Type + the body), OR the
+ * escape value 0x01, in which case the next TWO octets are the real length as a big-endian uint16
+ * (used when the message is 256..65535 octets). The Length is followed by a 1-octet Message Type
+ * (0x00 ADVERTISE, 0x04 CONNECT, 0x05 CONNACK, 0x0C PUBLISH, 0x12 SUBSCRIBE, …) and then the
+ * type-specific body.
+ *
+ * Because the per-type body layout (flags, topic ids/names, QoS, will) is message-type dependent and,
+ * for PUBLISH/SUBSCRIBE, ties into cross-datagram topic-registration state, this single-datagram codec
+ * keeps the body verbatim as `body` hex (byte-perfect) and does not sub-decode it. The Length is
+ * honored when supplied (a crafted datagram may lie), else derived from the body; the wire form (1- vs
+ * 3-octet Length) is derived from the Length value (>255 ⇒ 3-octet escape form), matching how a
+ * conformant sender chooses it, so a well-formed datagram round-trips byte-for-byte. The message is
+ * bounded by its Length and the UDP payload, so trailing bytes fall through to the codec's recursion /
+ * RawData.
+ */
+class MQTTSN extends BaseHeader_1.BaseHeader {
+    constructor() {
+        super(...arguments);
+        this.id = 'mqttsn';
+        this.name = 'MQTT for Sensor Networks';
+        this.nickname = 'MQTT-SN';
+        //MQTT-SN rides UDP at gateway ports 1883 / 10000. It carries no fixed content magic (the first
+        //octet is a length), so selection stays port-bucketed with a minimum-length guard; no
+        //heuristicFallback (a length-led header has no signature reliable enough to claim arbitrary ports).
+        this.matchKeys = ['udpport:1883', 'udpport:10000'];
+        //A leaf header — the per-type body needs message-type-dependent, cross-datagram parsing.
+        this.demuxProducers = [];
+    }
+    static #schemaCache;
+    get SCHEMA() {
+        return (MQTTSN.#schemaCache ??= MQTTSN.#buildSchema());
+    }
+    /** The MQTT-SN message length bounded by the UDP datagram (so retained FCS/padding is not absorbed). */
+    #payloadLength() {
+        let available = this.packet.length - this.startPos;
+        if (this.prevCodecModule && this.prevCodecModule.id === 'udp') {
+            const udpLength = this.prevCodecModule.instance.length.getValue(0);
+            if (udpLength >= 8 && udpLength - 8 < available)
+                available = udpLength - 8;
+        }
+        return available < 0 ? 0 : available;
+    }
+    /** Wire size of the Length field as seen on decode: the escape octet 0x01 ⇒ 3-octet form, else 1-octet. */
+    #decodePrefixSize() {
+        return (0, BufferToNumber_1.BufferToUInt8)(this.readBytes(0, 1, true)) === 0x01 ? 3 : 1;
+    }
+    /** Wire size of the Length field for a given Length value: >255 needs the 3-octet escape form. */
+    static #prefixSizeFor(length) {
+        return length > 255 ? 3 : 1;
+    }
+    static #buildSchema() {
+        return {
+            type: 'object',
+            summary: 'MQTT-SN type=${msgType} len=${length}',
+            properties: {
+                //The whole-message octet count (Length field + Message Type + body). 1-octet on the wire
+                //when <256, else the 0x01 escape octet followed by a big-endian uint16. Honored when
+                //supplied (a crafted datagram may lie); else derived from the body byte length.
+                length: {
+                    type: 'integer',
+                    label: 'Length',
+                    minimum: 0,
+                    maximum: 65535,
+                    decode: function () {
+                        if (this.#payloadLength() < 1) {
+                            this.instance.length.setValue(0);
+                            return;
+                        }
+                        const b0 = (0, BufferToNumber_1.BufferToUInt8)(this.readBytes(0, 1));
+                        //Escape form: the next 2 octets are the real length (big-endian). readBytes
+                        //clamps at the buffer end and BufferToUInt16 tolerates a short read, so a
+                        //truncated escape-form Length never throws.
+                        this.instance.length.setValue(b0 === 0x01 ? (0, BufferToNumber_1.BufferToUInt16)(this.readBytes(1, 2)) : b0);
+                    },
+                    encode: function () {
+                        const provided = this.instance.length.getValue();
+                        let value;
+                        if (provided !== undefined && provided !== null) {
+                            value = provided;
+                        }
+                        else {
+                            //Derive: whole-message = 1-octet-Length(1) + Message Type(1) + body. If that
+                            //overflows the 1-octet form (>255) the escape form adds 2 more Length octets.
+                            const bodyLength = (0, HexToBuffer_1.HexToBuffer)(this.instance.body.getValue('')).length;
+                            value = 2 + bodyLength;
+                            if (value > 255)
+                                value = 4 + bodyLength;
+                        }
+                        if (value > 65535) {
+                            this.recordError(this.instance.length.getPath(), 'Maximum value is 65535');
+                            value = 65535;
+                        }
+                        if (value < 0) {
+                            this.recordError(this.instance.length.getPath(), 'Minimum value is 0');
+                            value = 0;
+                        }
+                        this.instance.length.setValue(value);
+                        if (value > 255) {
+                            this.writeBytes(0, Buffer.from([0x01, (value >> 8) & 0xff, value & 0xff]));
+                        }
+                        else {
+                            this.writeBytes(0, (0, NumberToBuffer_1.UInt8ToBuffer)(value));
+                        }
+                    }
+                },
+                //Message Type octet (0x00 ADVERTISE, 0x04 CONNECT, 0x05 CONNACK, 0x0C PUBLISH, 0x12
+                //SUBSCRIBE, …). Kept as a plain uint so any on-wire type value round-trips.
+                msgType: {
+                    type: 'integer',
+                    label: 'Message Type',
+                    minimum: 0,
+                    maximum: 255,
+                    decode: function () {
+                        this.instance.msgType.setValue((0, BufferToNumber_1.BufferToUInt8)(this.readBytes(this.#decodePrefixSize(), 1)));
+                    },
+                    encode: function () {
+                        const node = this.instance.msgType;
+                        let value = node.getValue(0, (nodePath) => this.recordError(nodePath, 'Not Found'));
+                        if (value > 255) {
+                            this.recordError(node.getPath(), 'Maximum value is 255');
+                            value = 255;
+                        }
+                        if (value < 0) {
+                            this.recordError(node.getPath(), 'Minimum value is 0');
+                            value = 0;
+                        }
+                        node.setValue(value);
+                        this.writeBytes(MQTTSN.#prefixSizeFor(this.instance.length.getValue(0)), (0, NumberToBuffer_1.UInt8ToBuffer)(value));
+                    }
+                },
+                //The type-specific body after the Length + Message Type, kept verbatim. Bounded by the
+                //message Length and the UDP payload, so trailing/pipelined data is left to the codec's
+                //recursion / RawData.
+                body: {
+                    type: 'string',
+                    label: 'Body',
+                    contentEncoding: StringContentEncodingEnum_1.StringContentEncodingEnum.HEX,
+                    decode: function () {
+                        const prefix = this.#decodePrefixSize();
+                        const available = this.#payloadLength();
+                        let end = this.instance.length.getValue(0);
+                        if (end > available)
+                            end = available;
+                        const bodyStart = prefix + 1;
+                        this.instance.body.setValue(end > bodyStart ? (0, BufferToHex_1.BufferToHex)(this.readBytes(bodyStart, end - bodyStart)) : '');
+                    },
+                    encode: function () {
+                        const body = this.instance.body.getValue('');
+                        if (body)
+                            this.writeBytes(MQTTSN.#prefixSizeFor(this.instance.length.getValue(0)) + 1, (0, HexToBuffer_1.HexToBuffer)(body));
+                    }
+                }
+            }
+        };
+    }
+    match() {
+        //Require at least the minimal 1-octet Length + Message Type within the UDP payload, so a shorter
+        //datagram on the port falls through to raw rather than claiming an un-decodable layer.
+        return !!this.prevCodecModule && this.prevCodecModule.id === 'udp' && this.#payloadLength() >= 2;
+    }
+}
+exports.MQTTSN = MQTTSN;

package/dist/headers/MarkerProtocol.d.ts

@@ -0,0 +1,32 @@
+import { BaseHeader } from '../abstracts/BaseHeader';
+import { ProtocolJSONSchema } from '../schema/ProtocolJSONSchema';
+import { DemuxProducer } from '../types/DemuxProducer';
+/**
+ * Marker Protocol — the Link Aggregation Marker Protocol (IEEE 802.3ad / 802.1AX), the second of the
+ * Slow Protocols carried directly in an Ethernet II frame with EtherType 0x8809 (an Ethernet child — no
+ * IP/UDP). It shares the frame type with LACP and is disambiguated by byte 0, the Slow-Protocols
+ * Subtype: 1 = LACP (claimed by the LACP header), 2 = Marker (claimed here). Byte 1 is the Version.
+ * What follows is a flat sequence of TLVs — each a 1-byte Type + 1-byte Length (the Length counts the 2
+ * header octets, so the value is Length-2 bytes) + value bytes: the Marker Information TLV (type 0x01,
+ * len 0x10) or Marker Response TLV (type 0x02, len 0x10) — carrying Requester_Port (2), Requester_System
+ * (6), Requester_Transaction_ID (4) and Pad (2) — then the Terminator (type 0x00, len 0x00). After the
+ * Terminator the PDU is padded with reserved octets to fill the fixed PDU length. Marker has no length
+ * field of its own — it runs to the end of the frame.
+ *
+ * TLVs are carried generically (type + on-wire length + verbatim hex value) so every TLV round-trips
+ * byte-for-byte; per-TLV semantic decoding (requester port/system/transaction id) is a later enrichment.
+ * The Length is honored verbatim on encode when supplied (a crafted PDU may lie), else derived from the
+ * value (2 + value bytes; 0 for the Terminator). The walk stops at the Terminator (type 0) or when the
+ * frame is exhausted; any bytes after the Terminator are the reserved padding, kept verbatim in
+ * `reserved` so the frame is reproduced exactly.
+ */
+export declare class MarkerProtocol extends BaseHeader {
+    #private;
+    get SCHEMA(): ProtocolJSONSchema;
+    readonly id: string;
+    readonly name: string;
+    readonly nickname: string;
+    readonly matchKeys: string[];
+    match(): boolean;
+    readonly demuxProducers: DemuxProducer[];
+}