@netkitty/codec 1.0.0

package/dist/headers/SFlow.js

@@ -0,0 +1,242 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SFlow = void 0;
+const BaseHeader_1 = require("../abstracts/BaseHeader");
+const BufferToNumber_1 = require("../helper/BufferToNumber");
+const NumberToBuffer_1 = require("../helper/NumberToBuffer");
+const BufferToIP_1 = require("../helper/BufferToIP");
+const IPToBuffer_1 = require("../helper/IPToBuffer");
+const BufferToHex_1 = require("../helper/BufferToHex");
+const HexToBuffer_1 = require("../helper/HexToBuffer");
+const StringContentEncodingEnum_1 = require("../lib/StringContentEncodingEnum");
+//Fixed geometry of an sFlow v5 datagram. The head up to (and including) agentAddressType is 8 bytes;
+//the agent address is 4 bytes (IPv4) or 16 bytes (IPv6); then four 4-byte fields (subAgentId,
+//sequenceNumber, sysUptime, numSamples) precede the sample list. Each sample carries an 8-byte tag
+//(sampleType + sampleLength) followed by sampleLength opaque bytes.
+const AGENT_ADDRESS_OFFSET = 8;
+const IPV4_ADDRESS_LENGTH = 4;
+const IPV6_ADDRESS_LENGTH = 16;
+const AGENT_ADDRESS_TYPE_IPV6 = 2;
+const TRAILER_FIELDS_LENGTH = 16;
+const SAMPLE_TAG_LENGTH = 8;
+/**
+ * sFlow v5 — sampled flow monitoring export (sflow.org v5 spec; historically RFC 3176 for v4). Rides
+ * UDP, conventionally destination port 6343. All fields are big-endian.
+ *
+ * The datagram header is: version (=5), agentAddressType (1 = IPv4, 2 = IPv6), the agent address
+ * (4 bytes for IPv4, 16 bytes for IPv6 — the ONLY variable-length part of the fixed header, and it
+ * shifts every downstream offset), subAgentId, sequenceNumber, sysUptime, and numSamples. Then
+ * `numSamples` sample records follow, each a 4-byte sampleType (enterprise << 12 | format), a 4-byte
+ * sampleLength, and sampleLength opaque bytes carried verbatim as hex (structuring the per-format
+ * flow/counter records is a later slice).
+ *
+ * The sample walk is bounded by BOTH `numSamples` and the bytes actually captured, so a lying
+ * numSamples in a truncated frame can never over-read; any trailing bytes fall to the raw layer.
+ * numSamples is honored when supplied (so a malformed datagram round-trips byte-for-byte) and derived
+ * from samples.length only when absent (crafting). This is a leaf header — nothing demuxes off sFlow.
+ */
+class SFlow extends BaseHeader_1.BaseHeader {
+    constructor() {
+        super(...arguments);
+        this.id = 'sflow';
+        this.name = 'sFlow v5';
+        this.nickname = 'sFlow';
+        //Port-defined (udp:6343). sFlow does carry a content signature — the first four bytes are the
+        //version (=5) — but that alone is weak, so it stays a plain bucket entry (no heuristicFallback):
+        //sFlow v5 only when it rides its well-known UDP port.
+        this.matchKeys = ['udpport:6343'];
+        //Leaf header: the sample records are terminal opaque data, nothing demuxes off sFlow.
+        this.demuxProducers = [];
+    }
+    static #schemaCache;
+    get SCHEMA() {
+        return (SFlow.#schemaCache ??= SFlow.#buildSchema());
+    }
+    /** Length in bytes of the agent address, driven by the decoded agentAddressType (IPv6 → 16, else 4). */
+    #agentAddressLength() {
+        return this.instance.agentAddressType.getValue(1) === AGENT_ADDRESS_TYPE_IPV6 ? IPV6_ADDRESS_LENGTH : IPV4_ADDRESS_LENGTH;
+    }
+    /** Offset of subAgentId — the first field after the variable-length agent address. */
+    #subAgentIdOffset() {
+        return AGENT_ADDRESS_OFFSET + this.#agentAddressLength();
+    }
+    /** Offset of the first sample record: the whole fixed header (address-type dependent). */
+    #headerLength() {
+        return this.#subAgentIdOffset() + TRAILER_FIELDS_LENGTH;
+    }
+    /** Bytes available for this sFlow datagram: the frame end, clamped by the UDP payload length. */
+    #available() {
+        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;
+    }
+    /** A big-endian uint32 field at a dynamic (address-type driven) offset produced by `offset`. */
+    static #uint32At(name, offset, label) {
+        return {
+            type: 'integer',
+            label: label,
+            minimum: 0,
+            maximum: 4294967295,
+            decode: function () {
+                this.instance[name].setValue((0, BufferToNumber_1.BufferToUInt32)(this.readBytes(offset.call(this), 4)));
+            },
+            encode: function () {
+                const node = this.instance[name];
+                let value = node.getValue(0, (nodePath) => this.recordError(nodePath, 'Not Found'));
+                if (value > 4294967295) {
+                    this.recordError(node.getPath(), 'Maximum value is 4294967295');
+                    value = 4294967295;
+                }
+                if (value < 0) {
+                    this.recordError(node.getPath(), 'Minimum value is 0');
+                    value = 0;
+                }
+                node.setValue(value);
+                this.writeBytes(offset.call(this), (0, NumberToBuffer_1.UInt32ToBuffer)(value));
+            }
+        };
+    }
+    static #buildSchema() {
+        return {
+            type: 'object',
+            summary: 'sFlow ${numSamples} samples',
+            properties: {
+                version: SFlow.fieldUInt('version', 0, 4, 'Version'),
+                agentAddressType: SFlow.fieldUInt('agentAddressType', 4, 4, 'Agent Address Type'),
+                //The only variable-length field of the fixed header: 4 bytes as a dotted quad for IPv4
+                //(type 1), 16 bytes kept verbatim as hex for IPv6 (type 2). Its length shifts every
+                //downstream offset, so all trailing fields compute their offset from #subAgentIdOffset().
+                agentAddress: {
+                    type: 'string',
+                    label: 'Agent Address',
+                    decode: function () {
+                        const length = this.instance.agentAddressType.getValue(1) === AGENT_ADDRESS_TYPE_IPV6 ? IPV6_ADDRESS_LENGTH : IPV4_ADDRESS_LENGTH;
+                        const buffer = this.readBytes(AGENT_ADDRESS_OFFSET, length);
+                        this.instance.agentAddress.setValue(length === IPV6_ADDRESS_LENGTH ? (0, BufferToHex_1.BufferToHex)(buffer) : (0, BufferToIP_1.BufferToIPv4)(buffer));
+                    },
+                    encode: function () {
+                        const node = this.instance.agentAddress;
+                        if (this.instance.agentAddressType.getValue(1) === AGENT_ADDRESS_TYPE_IPV6) {
+                            const value = node.getValue('00'.repeat(IPV6_ADDRESS_LENGTH), (nodePath) => this.recordError(nodePath, 'Not Found'));
+                            node.setValue(value);
+                            this.writeBytes(AGENT_ADDRESS_OFFSET, (0, HexToBuffer_1.HexToBuffer)(value));
+                        }
+                        else {
+                            const value = node.getValue('0.0.0.0', (nodePath) => this.recordError(nodePath, 'Not Found'));
+                            node.setValue(value);
+                            this.writeBytes(AGENT_ADDRESS_OFFSET, (0, IPToBuffer_1.IPv4ToBuffer)(value));
+                        }
+                    }
+                },
+                subAgentId: SFlow.#uint32At('subAgentId', function () {
+                    return this.#subAgentIdOffset();
+                }, 'Sub Agent ID'),
+                sequenceNumber: SFlow.#uint32At('sequenceNumber', function () {
+                    return this.#subAgentIdOffset() + 4;
+                }, 'Sequence Number'),
+                sysUptime: SFlow.#uint32At('sysUptime', function () {
+                    return this.#subAgentIdOffset() + 8;
+                }, 'System Uptime'),
+                numSamples: {
+                    type: 'integer',
+                    label: 'Number of Samples',
+                    minimum: 0,
+                    maximum: 4294967295,
+                    decode: function () {
+                        this.instance.numSamples.setValue((0, BufferToNumber_1.BufferToUInt32)(this.readBytes(this.#subAgentIdOffset() + 12, 4)));
+                    },
+                    encode: function () {
+                        //Honor an explicitly-set numSamples (even a lying one — so a malformed capture still
+                        //round-trips byte-for-byte); derive from the sample array only when absent (crafting).
+                        let numSamples = this.instance.numSamples.getValue();
+                        if (numSamples === undefined || numSamples === null) {
+                            const samples = this.instance.samples.getValue();
+                            numSamples = Array.isArray(samples) ? samples.length : 0;
+                        }
+                        if (numSamples > 4294967295) {
+                            this.recordError(this.instance.numSamples.getPath(), 'Maximum value is 4294967295');
+                            numSamples = 4294967295;
+                        }
+                        if (numSamples < 0) {
+                            this.recordError(this.instance.numSamples.getPath(), 'Minimum value is 0');
+                            numSamples = 0;
+                        }
+                        this.instance.numSamples.setValue(numSamples);
+                        this.writeBytes(this.#subAgentIdOffset() + 12, (0, NumberToBuffer_1.UInt32ToBuffer)(numSamples));
+                    }
+                },
+                samples: {
+                    type: 'array',
+                    label: 'Samples',
+                    items: {
+                        type: 'object',
+                        label: 'Sample',
+                        properties: {
+                            sampleType: { type: 'integer', label: 'Sample Type', minimum: 0, maximum: 4294967295 },
+                            sampleLength: { type: 'integer', label: 'Sample Length', minimum: 0, maximum: 4294967295 },
+                            sampleData: { type: 'string', label: 'Sample Data', contentEncoding: StringContentEncodingEnum_1.StringContentEncodingEnum.HEX }
+                        }
+                    },
+                    decode: function () {
+                        //Bound the walk by BOTH the declared numSamples and the captured bytes: a lying
+                        //numSamples in a truncated frame must never read past the buffer. Each record is an
+                        //8-byte tag (type + length) followed by `sampleLength` opaque bytes.
+                        const numSamples = this.instance.numSamples.getValue(0);
+                        const end = this.#available();
+                        const samples = [];
+                        let offset = this.#headerLength();
+                        for (let i = 0; i < numSamples; i++) {
+                            if (offset + SAMPLE_TAG_LENGTH > end)
+                                break;
+                            const sampleType = (0, BufferToNumber_1.BufferToUInt32)(this.readBytes(offset, 4, true));
+                            const sampleLength = (0, BufferToNumber_1.BufferToUInt32)(this.readBytes(offset + 4, 4, true));
+                            if (offset + SAMPLE_TAG_LENGTH + sampleLength > end)
+                                break;
+                            this.readBytes(offset, SAMPLE_TAG_LENGTH + sampleLength);
+                            const sampleData = sampleLength > 0 ? (0, BufferToHex_1.BufferToHex)(this.packet.subarray(this.getPacketOffset(offset + SAMPLE_TAG_LENGTH), this.getPacketOffset(offset + SAMPLE_TAG_LENGTH + sampleLength))) : '';
+                            samples.push({ sampleType: sampleType, sampleLength: sampleLength, sampleData: sampleData });
+                            offset += SAMPLE_TAG_LENGTH + sampleLength;
+                        }
+                        this.instance.samples.setValue(samples);
+                    },
+                    encode: function () {
+                        const samples = this.instance.samples.getValue();
+                        if (!Array.isArray(samples))
+                            return;
+                        let offset = this.#headerLength();
+                        for (const sample of samples) {
+                            const body = (0, HexToBuffer_1.HexToBuffer)(sample.sampleData ? sample.sampleData : '');
+                            //Honor an explicit sampleLength (byte-perfect for decoded frames), else derive
+                            //it from the opaque body.
+                            const sampleLength = (sample.sampleLength !== undefined && sample.sampleLength !== null)
+                                ? sample.sampleLength
+                                : body.length;
+                            this.writeBytes(offset, (0, NumberToBuffer_1.UInt32ToBuffer)(sample.sampleType ? sample.sampleType : 0));
+                            this.writeBytes(offset + 4, (0, NumberToBuffer_1.UInt32ToBuffer)(sampleLength));
+                            offset += SAMPLE_TAG_LENGTH;
+                            if (body.length) {
+                                this.writeBytes(offset, body);
+                                offset += body.length;
+                            }
+                        }
+                    }
+                }
+            }
+        };
+    }
+    match() {
+        if (!this.prevCodecModule || this.prevCodecModule.id !== 'udp')
+            return false;
+        //Require the smallest possible datagram (IPv4-agent header = 28 bytes) and the version
+        //signature (=5). Anything else on port 6343 falls through to raw.
+        if (this.#available() < 28)
+            return false;
+        const version = (0, BufferToNumber_1.BufferToUInt32)(this.packet.subarray(this.startPos, this.startPos + 4));
+        return version === 5;
+    }
+}
+exports.SFlow = SFlow;

package/dist/headers/SIP.d.ts

@@ -0,0 +1,27 @@
+import { BaseHeader } from '../abstracts/BaseHeader';
+import { ProtocolJSONSchema } from '../schema/ProtocolJSONSchema';
+import { DemuxProducer } from '../types/DemuxProducer';
+/**
+ * SIP — the Session Initiation Protocol (RFC 3261), the signalling protocol for VoIP/IMS carried over
+ * UDP or TCP port 5060. A SIP message is US-ASCII text: a start-line, then header lines, a CRLF, and an
+ * optional body. The start-line is either a Request-Line (`METHOD SP Request-URI SP SIP-Version CRLF`)
+ * or a Status-Line (`SIP-Version SP Status-Code SP Reason-Phrase CRLF`).
+ *
+ * Like Syslog, the message body is text whose full internal structure (dozens of header fields, an
+ * arbitrary body of any content-type) is far richer than a form needs — and whitespace/header ordering
+ * is significant to some peers. So the ENTIRE raw message is kept verbatim as the authoritative
+ * `message` field (hex) and re-emitted untouched; only the start-line is parsed on decode into
+ * display-only metadata (method/uri/version or status-code/reason). Encode never reconstructs the
+ * message from the parsed fields — it writes `message` back byte-for-byte — so any conformant (or even
+ * malformed) SIP message round-trips exactly.
+ */
+export declare class SIP 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/SIP.js

@@ -0,0 +1,146 @@
+"use strict";
+var _a;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SIP = 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");
+/** SIP request methods (RFC 3261 + common extensions) used only to recognize a request start-line. */
+const SIP_METHODS = ['INVITE', 'ACK', 'BYE', 'CANCEL', 'OPTIONS', 'REGISTER', 'PRACK', 'SUBSCRIBE', 'NOTIFY', 'PUBLISH', 'INFO', 'REFER', 'MESSAGE', 'UPDATE'];
+/**
+ * SIP — the Session Initiation Protocol (RFC 3261), the signalling protocol for VoIP/IMS carried over
+ * UDP or TCP port 5060. A SIP message is US-ASCII text: a start-line, then header lines, a CRLF, and an
+ * optional body. The start-line is either a Request-Line (`METHOD SP Request-URI SP SIP-Version CRLF`)
+ * or a Status-Line (`SIP-Version SP Status-Code SP Reason-Phrase CRLF`).
+ *
+ * Like Syslog, the message body is text whose full internal structure (dozens of header fields, an
+ * arbitrary body of any content-type) is far richer than a form needs — and whitespace/header ordering
+ * is significant to some peers. So the ENTIRE raw message is kept verbatim as the authoritative
+ * `message` field (hex) and re-emitted untouched; only the start-line is parsed on decode into
+ * display-only metadata (method/uri/version or status-code/reason). Encode never reconstructs the
+ * message from the parsed fields — it writes `message` back byte-for-byte — so any conformant (or even
+ * malformed) SIP message round-trips exactly.
+ */
+class SIP extends BaseHeader_1.BaseHeader {
+    constructor() {
+        super(...arguments);
+        this.id = 'sip';
+        this.name = 'Session Initiation Protocol';
+        this.nickname = 'SIP';
+        this.matchKeys = ['udpport:5060', 'tcpport:5060'];
+        //A leaf header — the SIP body (SDP, etc.) and the dialog it belongs to are a higher-layer concern.
+        this.demuxProducers = [];
+    }
+    static #schemaCache;
+    get SCHEMA() {
+        return (_a.#schemaCache ??= _a.#buildSchema());
+    }
+    /**
+     * Bytes of this header: for UDP, bounded by the datagram length (so a retained FCS/padding is not
+     * absorbed); for TCP there is no per-message length, so take the rest of the segment.
+     */
+    #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;
+    }
+    /** The first line of the message (up to the first CRLF, or the whole payload if none). */
+    static #firstLine(text) {
+        const idx = text.indexOf('\r\n');
+        return idx >= 0 ? text.slice(0, idx) : text;
+    }
+    /**
+     * Parse the start-line into the display-only metadata fields. A Status-Line begins with the
+     * SIP-Version ("SIP/2.0"); anything else is treated as a Request-Line. Populated on decode only —
+     * these fields have no encode, so they never affect the re-emitted bytes.
+     */
+    #parseStartLine(text) {
+        const line = _a.#firstLine(text);
+        if (line.startsWith('SIP/')) {
+            //Status-Line: SIP-Version SP Status-Code SP Reason-Phrase
+            const match = line.match(/^(\S+)\s+(\d{3})\s*(.*)$/);
+            this.instance.isRequest.setValue(false);
+            this.instance.method.setValue('');
+            this.instance.requestUri.setValue('');
+            this.instance.version.setValue(match ? match[1] : (line.split(' ')[0] || ''));
+            this.instance.statusCode.setValue(match ? Number(match[2]) : 0);
+            this.instance.reasonPhrase.setValue(match ? match[3] : '');
+            return;
+        }
+        //Request-Line: METHOD SP Request-URI SP SIP-Version
+        const parts = line.split(' ');
+        this.instance.isRequest.setValue(true);
+        this.instance.method.setValue(parts[0] ? parts[0] : '');
+        this.instance.requestUri.setValue(parts.length > 1 ? parts[1] : '');
+        //The SIP-Version is the last whitespace-delimited token; the Request-URI itself has no spaces.
+        this.instance.version.setValue(parts.length > 2 ? parts[parts.length - 1] : '');
+        this.instance.statusCode.setValue(0);
+        this.instance.reasonPhrase.setValue('');
+    }
+    static #buildSchema() {
+        return {
+            type: 'object',
+            summary: 'SIP ${method}${statusCode}',
+            properties: {
+                //The whole raw message is the single source of truth: decoded verbatim to hex and
+                //re-emitted untouched (byte-perfect for any SIP message). The start-line is parsed into
+                //the display-only metadata below, which carry no codec of their own.
+                message: {
+                    type: 'string',
+                    label: 'Message',
+                    contentEncoding: StringContentEncodingEnum_1.StringContentEncodingEnum.HEX,
+                    decode: function () {
+                        const available = this.#payloadLength();
+                        if (available <= 0) {
+                            this.instance.message.setValue('');
+                            this.#parseStartLine('');
+                            return;
+                        }
+                        const raw = this.readBytes(0, available);
+                        this.instance.message.setValue((0, BufferToHex_1.BufferToHex)(raw));
+                        this.#parseStartLine(raw.toString('latin1'));
+                    },
+                    encode: function () {
+                        //Re-emit the authoritative message verbatim — never reconstruct from metadata.
+                        this.writeBytes(0, (0, HexToBuffer_1.HexToBuffer)(this.instance.message.getValue('')));
+                    }
+                },
+                //Display-only metadata parsed from the start-line on decode (no encode — populated by the
+                //message field above, never read back). isRequest distinguishes a Request-Line from a
+                //Status-Line; method/requestUri are for requests, statusCode/reasonPhrase for responses.
+                isRequest: { type: 'boolean', label: 'Is Request' },
+                method: { type: 'string', label: 'Method' },
+                requestUri: { type: 'string', label: 'Request URI' },
+                version: { type: 'string', label: 'Version' },
+                statusCode: { type: 'integer', label: 'Status Code', minimum: 0, maximum: 999 },
+                reasonPhrase: { type: 'string', label: 'Reason Phrase' }
+            }
+        };
+    }
+    match() {
+        //SIP rides on UDP/TCP port 5060 as US-ASCII text. Recognize it by the start-line signature: a
+        //known request method followed by a space, or the "SIP/2.0" response version — so non-SIP
+        //traffic on port 5060 falls through to raw rather than claiming an un-decodable text layer.
+        if (!this.prevCodecModule)
+            return false;
+        if (this.prevCodecModule.id !== 'udp' && this.prevCodecModule.id !== 'tcp')
+            return false;
+        if (this.#payloadLength() <= 0)
+            return false;
+        const lead = this.readBytes(0, 16, true).toString('latin1');
+        if (lead.startsWith('SIP/2.0'))
+            return true;
+        for (const method of SIP_METHODS) {
+            if (lead.startsWith(method + ' '))
+                return true;
+        }
+        return false;
+    }
+}
+exports.SIP = SIP;
+_a = SIP;

package/dist/headers/SLMP.d.ts

@@ -0,0 +1,36 @@
+import { BaseHeader } from '../abstracts/BaseHeader';
+import { ProtocolJSONSchema } from '../schema/ProtocolJSONSchema';
+import { DemuxProducer } from '../types/DemuxProducer';
+/**
+ * SLMP — SeamLess Message Protocol (Mitsubishi Electric MELSEC / iQ-R, "SLMP"), the open industrial
+ * protocol that carries MELSEC device read/write and control requests, commonly on TCP & UDP port 5007.
+ * This codec models the ubiquitous 3E-frame BINARY encoding. Every 3E request begins with the subheader
+ * 0x5000 (wire bytes `50 00`) and every response with 0xD000 (`D0 00`), followed by a small routing
+ * header — Network number, Station (PC) number, request-destination Module I/O number, Multidrop station
+ * number — then a Request Data Length that counts every byte AFTER it, and finally the command payload
+ * (for a request: Monitor Timer + Command + Subcommand + device specification; for a response: End Code +
+ * response data).
+ *
+ * ⚠️ Except for the 2-byte subheader marker (kept in wire order as `50 00` / `D0 00`, i.e. big-endian
+ * 0x5000 / 0xD000), every multi-byte field in the 3E binary frame is LITTLE-ENDIAN. There is no
+ * little-endian helper in this codebase, so the uint16 fields are read/written byte-by-byte in their
+ * closures.
+ *
+ * Byte-perfect strategy (minimal slice, per the SLMP layout being command-dependent): structure the
+ * subheader + routing header + Request Data Length, and keep the command-specific remainder (Monitor
+ * Timer / Command / Subcommand / device data on a request; End Code / data on a response) verbatim as
+ * `data` hex. The remainder is bounded by the Request Data Length (data ends at offset 9 + length) and
+ * the captured bytes, so a trailing / pipelined message is left to the codec's recursion / RawData. The
+ * Request Data Length is auto-computed from the data on encode when not supplied, else honored verbatim
+ * (a crafted frame may carry any length). A well-formed message round-trips byte-for-byte.
+ */
+export declare class SLMP 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/SLMP.js

@@ -0,0 +1,154 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SLMP = 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");
+/**
+ * SLMP — SeamLess Message Protocol (Mitsubishi Electric MELSEC / iQ-R, "SLMP"), the open industrial
+ * protocol that carries MELSEC device read/write and control requests, commonly on TCP & UDP port 5007.
+ * This codec models the ubiquitous 3E-frame BINARY encoding. Every 3E request begins with the subheader
+ * 0x5000 (wire bytes `50 00`) and every response with 0xD000 (`D0 00`), followed by a small routing
+ * header — Network number, Station (PC) number, request-destination Module I/O number, Multidrop station
+ * number — then a Request Data Length that counts every byte AFTER it, and finally the command payload
+ * (for a request: Monitor Timer + Command + Subcommand + device specification; for a response: End Code +
+ * response data).
+ *
+ * ⚠️ Except for the 2-byte subheader marker (kept in wire order as `50 00` / `D0 00`, i.e. big-endian
+ * 0x5000 / 0xD000), every multi-byte field in the 3E binary frame is LITTLE-ENDIAN. There is no
+ * little-endian helper in this codebase, so the uint16 fields are read/written byte-by-byte in their
+ * closures.
+ *
+ * Byte-perfect strategy (minimal slice, per the SLMP layout being command-dependent): structure the
+ * subheader + routing header + Request Data Length, and keep the command-specific remainder (Monitor
+ * Timer / Command / Subcommand / device data on a request; End Code / data on a response) verbatim as
+ * `data` hex. The remainder is bounded by the Request Data Length (data ends at offset 9 + length) and
+ * the captured bytes, so a trailing / pipelined message is left to the codec's recursion / RawData. The
+ * Request Data Length is auto-computed from the data on encode when not supplied, else honored verbatim
+ * (a crafted frame may carry any length). A well-formed message round-trips byte-for-byte.
+ */
+class SLMP extends BaseHeader_1.BaseHeader {
+    constructor() {
+        super(...arguments);
+        this.id = 'slmp';
+        this.name = 'SeamLess Message Protocol';
+        this.nickname = 'SLMP';
+        //MELSEC SLMP rides TCP/UDP port 5007 (selected via the tcpport:5007 / udpport:5007 buckets). This
+        //stays a port-bucket protocol: matchKeys only, NO heuristicFallback — the subheader is only a 2-byte
+        //marker, too weak to claim SLMP off port 5007, so non-SLMP 5007 traffic falls through to raw.
+        this.matchKeys = ['tcpport:5007', 'udpport:5007'];
+        //A leaf header — the command-specific device payload requires per-command parsing.
+        this.demuxProducers = [];
+    }
+    static #schemaCache;
+    get SCHEMA() {
+        return (SLMP.#schemaCache ??= SLMP.#buildSchema());
+    }
+    /** A little-endian unsigned 16-bit field of 2 octets at `offset`. */
+    static #fieldUInt16LE(name, offset, label) {
+        return {
+            type: 'integer',
+            label: label,
+            minimum: 0,
+            maximum: 65535,
+            decode: function () {
+                const b = this.readBytes(offset, 2);
+                this.instance[name].setValue(b[0] | (b[1] << 8));
+            },
+            encode: function () {
+                const node = this.instance[name];
+                let value = node.getValue(0, (nodePath) => this.recordError(nodePath, 'Not Found'));
+                if (value > 65535) {
+                    this.recordError(node.getPath(), 'Maximum value is 65535');
+                    value = 65535;
+                }
+                if (value < 0) {
+                    this.recordError(node.getPath(), 'Minimum value is 0');
+                    value = 0;
+                }
+                node.setValue(value);
+                this.writeBytes(offset, Buffer.from([value & 0xff, (value >> 8) & 0xff]));
+            }
+        };
+    }
+    static #buildSchema() {
+        return {
+            type: 'object',
+            summary: 'SLMP subheader=${subheader} len=${requestDataLength}',
+            properties: {
+                //The 2-byte frame marker, kept in wire order (big-endian): 0x5000 (`50 00`) request,
+                //0xD000 (`D0 00`) response. Not little-endian — it is a fixed signature, not a value.
+                subheader: this.fieldUInt('subheader', 0, 2, 'Subheader'),
+                networkNo: this.fieldUInt('networkNo', 2, 1, 'Network Number'),
+                stationNo: this.fieldUInt('stationNo', 3, 1, 'Station Number'),
+                //Request-destination Module I/O number (little-endian, e.g. 0x03FF = own station).
+                moduleIO: this.#fieldUInt16LE('moduleIO', 4, 'Module I/O Number'),
+                multidropStation: this.fieldUInt('multidropStation', 6, 1, 'Multidrop Station Number'),
+                //Counts every byte that FOLLOWS this field (Monitor Timer + Command + Subcommand + device
+                //data on a request; End Code + data on a response). Honored when supplied (a crafted frame
+                //may lie); else derived from the encoded `data` length.
+                requestDataLength: {
+                    type: 'integer',
+                    label: 'Request Data Length',
+                    minimum: 0,
+                    maximum: 65535,
+                    decode: function () {
+                        const b = this.readBytes(7, 2);
+                        this.instance.requestDataLength.setValue(b[0] | (b[1] << 8));
+                    },
+                    encode: function () {
+                        const provided = this.instance.requestDataLength.getValue();
+                        let value = (provided !== undefined && provided !== null)
+                            ? provided
+                            : (0, HexToBuffer_1.HexToBuffer)(this.instance.data.getValue('')).length;
+                        if (value > 65535) {
+                            this.recordError(this.instance.requestDataLength.getPath(), 'Maximum value is 65535');
+                            value = 65535;
+                        }
+                        if (value < 0) {
+                            this.recordError(this.instance.requestDataLength.getPath(), 'Minimum value is 0');
+                            value = 0;
+                        }
+                        this.instance.requestDataLength.setValue(value);
+                        this.writeBytes(7, Buffer.from([value & 0xff, (value >> 8) & 0xff]));
+                    }
+                },
+                //The command-specific remainder, kept verbatim. Bounded by Request Data Length (the frame
+                //ends at offset 9 + length) and the captured bytes, so trailing / pipelined data is left
+                //to the codec's recursion / RawData.
+                data: {
+                    type: 'string',
+                    label: 'Data',
+                    contentEncoding: StringContentEncodingEnum_1.StringContentEncodingEnum.HEX,
+                    decode: function () {
+                        const available = this.packet.length - this.startPos;
+                        const length = this.instance.requestDataLength.getValue(0);
+                        let end = 9 + length;
+                        if (end > available)
+                            end = available;
+                        this.instance.data.setValue(end > 9 ? (0, BufferToHex_1.BufferToHex)(this.readBytes(9, end - 9)) : '');
+                    },
+                    encode: function () {
+                        const data = this.instance.data.getValue('');
+                        if (data)
+                            this.writeBytes(9, (0, HexToBuffer_1.HexToBuffer)(data));
+                    }
+                }
+            }
+        };
+    }
+    match() {
+        //SLMP rides TCP/UDP port 5007. Require the full 9-byte 3E-frame header and a valid 3E-binary
+        //subheader (0x5000 request or 0xD000 response) so non-SLMP 5007 traffic falls through to raw.
+        if (!this.prevCodecModule)
+            return false;
+        if (this.prevCodecModule.id !== 'tcp' && this.prevCodecModule.id !== 'udp')
+            return false;
+        if (this.packet.length - this.startPos < 9)
+            return false;
+        const subheader = (0, BufferToHex_1.BufferToHex)(this.readBytes(0, 2, true));
+        return subheader === '5000' || subheader === 'd000';
+    }
+}
+exports.SLMP = SLMP;

package/dist/headers/SLP.d.ts

@@ -0,0 +1,30 @@
+import { BaseHeader } from '../abstracts/BaseHeader';
+import { ProtocolJSONSchema } from '../schema/ProtocolJSONSchema';
+import { DemuxProducer } from '../types/DemuxProducer';
+/**
+ * SLP — Service Location Protocol Version 2 (RFC 2608), UDP (and TCP) port 427. Every SLPv2 message
+ * begins with a common header: an 8-bit Version (2), an 8-bit Function-ID (1 SrvRqst, 2 SrvRply,
+ * 3 SrvReg, 4 SrvDeReg, 5 SrvAck, 6 AttrRqst, 7 AttrRply, 8 DAAdvert, 9 SrvTypeRqst, 10 SrvTypeRply,
+ * 11 SAAdvert), a 24-bit Length (the entire message octet count including this header), a 16-bit Flags
+ * field (bit 0 Overflow, bit 1 Fresh, bit 2 Request-multicast, the remaining 13 bits reserved), a 24-bit
+ * Next Extension Offset, a 16-bit XID, a 16-bit Language Tag Length and the Language Tag of that many
+ * octets — then the Function-ID-specific body.
+ *
+ * The body layout differs per Function-ID (SrvRqst's PRList/service-type/scope/predicate/SPL SPI,
+ * SrvRply's URL entries, SrvReg's URL + attributes, …) and several sub-structures carry authentication
+ * blocks and cross-message context, so this common-header codec keeps the body verbatim as `body` hex
+ * (byte-perfect) and does not sub-decode it. The Length is auto-computed on encode when not supplied,
+ * else honored verbatim (a crafted message may lie); the Language Tag Length is likewise honor-else-
+ * derive. The message is bounded by its Length (and the UDP datagram) so trailing / pipelined bytes are
+ * left to the codec's recursion / RawData. A well-formed message round-trips byte-for-byte.
+ */
+export declare class SLP extends BaseHeader {
+    #private;
+    get SCHEMA(): ProtocolJSONSchema;
+    readonly id: string;
+    readonly name: string;
+    readonly nickname: string;
+    readonly matchKeys: string[];
+    match(): boolean;
+    readonly demuxProducers: DemuxProducer[];
+}