@netkitty/codec 1.0.0

package/dist/headers/PPPoESession.js

@@ -0,0 +1,125 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PPPoESession = 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");
+/**
+ * PPPoE Session Stage (RFC 2516), carried directly in an Ethernet II frame with EtherType 0x8864 (an
+ * Ethernet child — no IP/UDP). The 6-byte PPPoE header is a byte holding Version (high 4 bits, 1) and
+ * Type (low 4 bits, 1), a 1-byte Code (0x00 in the Session Stage), a 2-byte Session ID (non-zero), and
+ * a 2-byte Length (the octet count of the PPPoE payload — i.e. the PPP portion, which starts with the
+ * 2-byte PPP Protocol field). The payload follows: a 2-byte PPP Protocol (e.g. 0x0021 IPv4, 0x0057
+ * IPv6, 0xc021 LCP, 0x8021 IPCP) and its data.
+ *
+ * This minimal slice decodes the 6-byte header plus the 2-byte PPP Protocol and keeps the PPP data
+ * verbatim as `payload` hex (byte-perfect), bounded by the Length field so trailing Ethernet padding is
+ * left to the codec's recursion / RawData. The Length is honored verbatim when supplied (a crafted
+ * frame may lie) else derived from the actual payload (2-byte Protocol + data). A well-formed frame
+ * round-trips byte-for-byte. Inner IPv4/IPv6/LCP recursion is deferred to a serial follow-up (it needs
+ * a pppProtocol-driven demux into IPv4/IPv6.match); for now the PPP payload is a bounded-hex leaf.
+ */
+class PPPoESession extends BaseHeader_1.BaseHeader {
+    constructor() {
+        super(...arguments);
+        this.id = 'pppoe-sess';
+        this.name = 'PPP-over-Ethernet Session';
+        this.nickname = 'PPPoE Session';
+        this.matchKeys = ['ethertype:8864'];
+        //A leaf header for this slice — the inner PPP payload (IPv4/IPv6/LCP) is deferred to a serial
+        //follow-up that will add a pppProtocol-driven demux; for now it is kept as bounded-hex `payload`.
+        this.demuxProducers = [];
+    }
+    static #schemaCache;
+    get SCHEMA() {
+        return (PPPoESession.#schemaCache ??= PPPoESession.#buildSchema());
+    }
+    static #buildSchema() {
+        return {
+            type: 'object',
+            summary: 'PPPoE Session id=${sessionId} proto=${pppProtocol}',
+            properties: {
+                //Byte 0: Version in the high 4 bits, Type in the low 4 bits (both 1 in RFC 2516). Split
+                //into two nibble fields so the editor sees them, kept verbatim for byte-perfect.
+                version: {
+                    type: 'integer', label: 'Version', minimum: 0, maximum: 15,
+                    decode: function () { this.instance.version.setValue(this.readBits(0, 1, 0, 4)); },
+                    encode: function () { this.writeBits(0, 1, 0, 4, this.instance.version.getValue(0)); }
+                },
+                type: {
+                    type: 'integer', label: 'Type', minimum: 0, maximum: 15,
+                    decode: function () { this.instance.type.setValue(this.readBits(0, 1, 4, 4)); },
+                    encode: function () { this.writeBits(0, 1, 4, 4, this.instance.type.getValue(0)); }
+                },
+                //Code — 0x00 in the Session Stage (Discovery Stage codes live in a separate header).
+                code: this.fieldUInt('code', 1, 1, 'Code'),
+                //Session ID — assigned during Discovery; non-zero for an established session.
+                sessionId: this.fieldUInt('sessionId', 2, 2, 'Session ID'),
+                length: {
+                    type: 'integer',
+                    label: 'Length',
+                    minimum: 0,
+                    maximum: 65535,
+                    decode: function () {
+                        this.instance.length.setValue((0, BufferToNumber_1.BufferToUInt16)(this.readBytes(4, 2)));
+                    },
+                    encode: function () {
+                        //Length counts the PPPoE payload = 2-byte PPP Protocol + data. Honored when
+                        //supplied (a crafted frame may lie); else derived from the actual payload.
+                        const provided = this.instance.length.getValue();
+                        let value = (provided !== undefined && provided !== null)
+                            ? provided
+                            : 2 + (0, HexToBuffer_1.HexToBuffer)(this.instance.payload.getValue('')).length;
+                        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);
+                        this.writeBytes(4, (0, NumberToBuffer_1.UInt16ToBuffer)(value));
+                    }
+                },
+                //The 2-byte PPP Protocol at the start of the payload (offset 6), kept as a lowercase hex
+                //string. A serial follow-up will make this a demux producer into the inner IPv4/IPv6/LCP.
+                pppProtocol: this.fieldHex('pppProtocol', 6, 2, 'PPP Protocol'),
+                //The PPP data after the Protocol field (offset 8), kept verbatim. Bounded by the Length
+                //field (payload ends at header offset 6 + Length) and the captured bytes, so trailing
+                //Ethernet padding / pipelined data is left to the codec's recursion / RawData.
+                payload: {
+                    type: 'string',
+                    label: 'Payload',
+                    contentEncoding: StringContentEncodingEnum_1.StringContentEncodingEnum.HEX,
+                    decode: function () {
+                        const remaining = this.packet.length - this.startPos;
+                        const length = this.instance.length.getValue(0);
+                        let end = 6 + length;
+                        if (end > remaining)
+                            end = remaining;
+                        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() {
+        //An Ethernet (or VLAN) child selected by EtherType 0x8864 (stored as a lowercase 4-hex string).
+        //Require the 6-byte PPPoE header minimum.
+        if (!this.prevCodecModule)
+            return false;
+        if (this.prevCodecModule.instance.etherType.getValue() !== '8864')
+            return false;
+        return this.packet.length - this.startPos >= 6;
+    }
+}
+exports.PPPoESession = PPPoESession;

package/dist/headers/PPTP.d.ts

@@ -0,0 +1,30 @@
+import { BaseHeader } from '../abstracts/BaseHeader';
+import { ProtocolJSONSchema } from '../schema/ProtocolJSONSchema';
+import { DemuxProducer } from '../types/DemuxProducer';
+/**
+ * Point-to-Point Tunnelling Protocol (PPTP, RFC 2637), TCP port 1723 — the control connection. Every
+ * PPTP control message begins with a fixed 8-byte common header — a 2-byte Length (the total octet
+ * count of this control message, including the header), a 2-byte PDU type (1 = control message), and a
+ * 4-byte Magic Cookie (the constant 0x1A2B3C4D) — followed, for control messages, by a 2-byte Control
+ * Message Type (1 Start-Control-Connection-Request, 2 …-Reply, 3 Stop-Control-Connection-Request,
+ * 7 Outgoing-Call-Request, 8 …-Reply, etc.) and a 2-byte Reserved0 field, then the type-specific body.
+ *
+ * The body layout differs per control message type (SCCRQ's protocol version / framing & bearer
+ * capabilities / host & vendor strings, Outgoing-Call's call id & bearer type, …) and several fields
+ * carry negotiation context, so this single-message codec keeps the body verbatim as `body` hex
+ * (byte-perfect) and does not sub-decode it. The Length is auto-computed from the structured header +
+ * body on encode when not supplied, else honored verbatim (a crafted message may lie); the message is
+ * bounded by Length so a second pipelined control message or trailing bytes are left to the codec's
+ * recursion / RawData. The Magic Cookie is kept verbatim (honored) rather than re-derived, and the
+ * Reserved0 field is preserved and re-emitted untouched. A well-formed message round-trips byte-for-byte.
+ */
+export declare class PPTP 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/PPTP.js

@@ -0,0 +1,122 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PPTP = 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");
+/** PPTP magic cookie (RFC 2637 §2.1): a constant 0x1A2B3C4D used to sync/verify the control channel. */
+const PPTP_MAGIC_COOKIE = 0x1a2b3c4d;
+/**
+ * Point-to-Point Tunnelling Protocol (PPTP, RFC 2637), TCP port 1723 — the control connection. Every
+ * PPTP control message begins with a fixed 8-byte common header — a 2-byte Length (the total octet
+ * count of this control message, including the header), a 2-byte PDU type (1 = control message), and a
+ * 4-byte Magic Cookie (the constant 0x1A2B3C4D) — followed, for control messages, by a 2-byte Control
+ * Message Type (1 Start-Control-Connection-Request, 2 …-Reply, 3 Stop-Control-Connection-Request,
+ * 7 Outgoing-Call-Request, 8 …-Reply, etc.) and a 2-byte Reserved0 field, then the type-specific body.
+ *
+ * The body layout differs per control message type (SCCRQ's protocol version / framing & bearer
+ * capabilities / host & vendor strings, Outgoing-Call's call id & bearer type, …) and several fields
+ * carry negotiation context, so this single-message codec keeps the body verbatim as `body` hex
+ * (byte-perfect) and does not sub-decode it. The Length is auto-computed from the structured header +
+ * body on encode when not supplied, else honored verbatim (a crafted message may lie); the message is
+ * bounded by Length so a second pipelined control message or trailing bytes are left to the codec's
+ * recursion / RawData. The Magic Cookie is kept verbatim (honored) rather than re-derived, and the
+ * Reserved0 field is preserved and re-emitted untouched. A well-formed message round-trips byte-for-byte.
+ */
+class PPTP extends BaseHeader_1.BaseHeader {
+    constructor() {
+        super(...arguments);
+        this.id = 'pptp';
+        this.name = 'Point-to-Point Tunnelling Protocol';
+        this.nickname = 'PPTP';
+        this.matchKeys = ['tcpport:1723'];
+        //A leaf header — the type-specific control-message body requires per-type parsing.
+        this.demuxProducers = [];
+    }
+    static #schemaCache;
+    get SCHEMA() {
+        return (PPTP.#schemaCache ??= PPTP.#buildSchema());
+    }
+    static #buildSchema() {
+        return {
+            type: 'object',
+            summary: 'PPTP ctrlType=${controlMessageType} len=${length}',
+            properties: {
+                length: {
+                    type: 'integer',
+                    label: 'Length',
+                    minimum: 0,
+                    maximum: 65535,
+                    decode: function () {
+                        this.instance.length.setValue((0, BufferToNumber_1.BufferToUInt16)(this.readBytes(0, 2)));
+                    },
+                    encode: function () {
+                        //Length counts the whole control message = 12-byte structured header
+                        //(length + pduType + magicCookie + controlMessageType + reserved0) + body. Honored
+                        //when supplied (a crafted message may lie); else derived from the body.
+                        const provided = this.instance.length.getValue();
+                        let value = (provided !== undefined && provided !== null)
+                            ? provided
+                            : 12 + (0, HexToBuffer_1.HexToBuffer)(this.instance.body.getValue('')).length;
+                        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);
+                        this.writeBytes(0, (0, NumberToBuffer_1.UInt16ToBuffer)(value));
+                    }
+                },
+                //The PDU type (RFC 2637 §2.1). 1 = control message; this codec structures control
+                //messages, the only PDU type carried on the TCP control connection.
+                pduType: this.fieldUInt('pduType', 2, 2, 'PDU Type'),
+                //The Magic Cookie constant 0x1A2B3C4D. Kept verbatim (honored, not re-derived) so a
+                //crafted/desynced cookie still round-trips.
+                magicCookie: this.fieldHex('magicCookie', 4, 4, 'Magic Cookie'),
+                controlMessageType: this.fieldUInt('controlMessageType', 8, 2, 'Control Message Type'),
+                //Reserved (MUST be 0 per RFC 2637); preserved and re-emitted untouched.
+                reserved0: this.fieldHex('reserved0', 10, 2, 'Reserved0'),
+                //The type-specific body after the 12-byte structured header, kept verbatim. Bounded by the
+                //message Length (the message ends at offset Length) and the captured bytes, so trailing /
+                //pipelined control messages are left to the codec's recursion / RawData.
+                body: {
+                    type: 'string',
+                    label: 'Body',
+                    contentEncoding: StringContentEncodingEnum_1.StringContentEncodingEnum.HEX,
+                    decode: function () {
+                        const remaining = this.packet.length - this.startPos;
+                        const length = this.instance.length.getValue(0);
+                        let end = length;
+                        if (end > remaining)
+                            end = remaining;
+                        this.instance.body.setValue(end > 12 ? (0, BufferToHex_1.BufferToHex)(this.readBytes(12, end - 12)) : '');
+                    },
+                    encode: function () {
+                        const body = this.instance.body.getValue('');
+                        if (body)
+                            this.writeBytes(12, (0, HexToBuffer_1.HexToBuffer)(body));
+                    }
+                }
+            }
+        };
+    }
+    match() {
+        //PPTP's control connection rides on TCP port 1723. Require the full 12-byte structured header and
+        //the Magic Cookie signature (0x1A2B3C4D at offset 4) so non-PPTP 1723 traffic falls through to
+        //raw. The cookie is a strong, distinctive content signature, but selection stays port-bucketed
+        //(matchKeys) to stay conservative like the other length-bounded TCP payload codecs.
+        if (!this.prevCodecModule || this.prevCodecModule.id !== 'tcp')
+            return false;
+        if (this.packet.length - this.startPos < 12)
+            return false;
+        return (0, BufferToNumber_1.BufferToUInt16)(this.readBytes(4, 2, true)) === (PPTP_MAGIC_COOKIE >>> 16)
+            && (0, BufferToNumber_1.BufferToUInt16)(this.readBytes(6, 2, true)) === (PPTP_MAGIC_COOKIE & 0xffff);
+    }
+}
+exports.PPTP = PPTP;

package/dist/headers/PROFINETRT.d.ts

@@ -0,0 +1,28 @@
+import { BaseHeader } from '../abstracts/BaseHeader';
+import { ProtocolJSONSchema } from '../schema/ProtocolJSONSchema';
+import { DemuxProducer } from '../types/DemuxProducer';
+/**
+ * PROFINET Real-Time (PROFINET-RT / PN-IO cyclic) — IEC 61158-6-10 / IEC 61784, carried directly in an
+ * Ethernet II frame with EtherType 0x8892 (an Ethernet child — no IP/UDP). The frame opens with a 2-byte
+ * big-endian FrameID that identifies the frame's type/purpose; the FrameID value ranges select the class
+ * of traffic (0x0100-0x06FF isochronous RT_CLASS_3, 0x8000-0xBFFF cyclic RT_CLASS_1/2, 0xFC00-0xFCFF DCP,
+ * 0xFF00-0xFF43 acyclic/alarms, etc.). Everything after the FrameID is the frame's data.
+ *
+ * For cyclic frames the data is the IO data followed — at the very end, before any Ethernet padding — by
+ * a 4-byte APDU-Status (CycleCounter uint16 BE, DataStatus, TransferStatus). Because trailing Ethernet
+ * padding on short frames sits AFTER the APDU-Status, splitting it out reliably needs the true data
+ * length (from the GSD / IO configuration), which this minimal slice does not have. So everything after
+ * the FrameID is kept verbatim as `data` (hex) and re-emitted untouched, so every frame — cyclic or
+ * acyclic — round-trips byte-for-byte. Structuring the APDU-Status (and distinguishing it from padding)
+ * is a deferred slice. PROFINET-RT is a leaf here — nothing demuxes above it.
+ */
+export declare class PROFINETRT 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/PROFINETRT.js

@@ -0,0 +1,74 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PROFINETRT = 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");
+/**
+ * PROFINET Real-Time (PROFINET-RT / PN-IO cyclic) — IEC 61158-6-10 / IEC 61784, carried directly in an
+ * Ethernet II frame with EtherType 0x8892 (an Ethernet child — no IP/UDP). The frame opens with a 2-byte
+ * big-endian FrameID that identifies the frame's type/purpose; the FrameID value ranges select the class
+ * of traffic (0x0100-0x06FF isochronous RT_CLASS_3, 0x8000-0xBFFF cyclic RT_CLASS_1/2, 0xFC00-0xFCFF DCP,
+ * 0xFF00-0xFF43 acyclic/alarms, etc.). Everything after the FrameID is the frame's data.
+ *
+ * For cyclic frames the data is the IO data followed — at the very end, before any Ethernet padding — by
+ * a 4-byte APDU-Status (CycleCounter uint16 BE, DataStatus, TransferStatus). Because trailing Ethernet
+ * padding on short frames sits AFTER the APDU-Status, splitting it out reliably needs the true data
+ * length (from the GSD / IO configuration), which this minimal slice does not have. So everything after
+ * the FrameID is kept verbatim as `data` (hex) and re-emitted untouched, so every frame — cyclic or
+ * acyclic — round-trips byte-for-byte. Structuring the APDU-Status (and distinguishing it from padding)
+ * is a deferred slice. PROFINET-RT is a leaf here — nothing demuxes above it.
+ */
+class PROFINETRT extends BaseHeader_1.BaseHeader {
+    constructor() {
+        super(...arguments);
+        this.id = 'pnio';
+        this.name = 'PROFINET Real-Time';
+        this.nickname = 'PROFINET-RT';
+        this.matchKeys = ['ethertype:8892'];
+        //A leaf header — nothing demuxes above PROFINET-RT.
+        this.demuxProducers = [];
+    }
+    static #schemaCache;
+    get SCHEMA() {
+        return (PROFINETRT.#schemaCache ??= PROFINETRT.#buildSchema());
+    }
+    static #buildSchema() {
+        return {
+            type: 'object',
+            summary: 'PROFINET-RT frameId=${frameId}',
+            properties: {
+                frameId: this.fieldUInt('frameId', 0, 2, 'Frame ID'),
+                //Everything after the 2-byte FrameID, kept verbatim as hex so the IO data + APDU-Status
+                //(+ any Ethernet padding) round-trip byte-for-byte. Structuring the APDU-Status is a
+                //deferred slice (see the class doc): it cannot be split from trailing padding without the
+                //true data length from the IO configuration.
+                data: {
+                    type: 'string',
+                    label: 'Data',
+                    contentEncoding: StringContentEncodingEnum_1.StringContentEncodingEnum.HEX,
+                    decode: function () {
+                        const remaining = this.packet.length - this.startPos;
+                        this.instance.data.setValue(remaining > 2 ? (0, BufferToHex_1.BufferToHex)(this.readBytes(2, remaining - 2)) : '');
+                    },
+                    encode: function () {
+                        const data = this.instance.data.getValue('');
+                        if (data)
+                            this.writeBytes(2, (0, HexToBuffer_1.HexToBuffer)(data));
+                    }
+                }
+            }
+        };
+    }
+    match() {
+        //An Ethernet child selected by EtherType 0x8892 (stored as a lowercase 4-hex string). Require the
+        //2-byte minimum for the FrameID.
+        if (!this.prevCodecModule || this.prevCodecModule.id !== 'eth')
+            return false;
+        if (this.prevCodecModule.instance.etherType.getValue() !== '8892')
+            return false;
+        return this.packet.length - this.startPos >= 2;
+    }
+}
+exports.PROFINETRT = PROFINETRT;

package/dist/headers/PTP.d.ts

@@ -0,0 +1,34 @@
+import { BaseHeader } from '../abstracts/BaseHeader';
+import { ProtocolJSONSchema } from '../schema/ProtocolJSONSchema';
+import { DemuxProducer } from '../types/DemuxProducer';
+/**
+ * PTP — the Precision Time Protocol version 2 (IEEE 1588-2008, with 1588-2019 field naming). A
+ * sub-microsecond clock-synchronization protocol widely deployed in power-system substations (IEC 61850
+ * / IEEE C37.238 power profile) and industrial automation. It is dual-carried: directly over Ethernet
+ * with EtherType 0x88F7 (an Ethernet child — no IP), or over UDP/IPv4/6 on the event port 319 and the
+ * general port 320.
+ *
+ * Every PTP message begins with the same 34-byte common header (IEEE 1588-2008 §13.3): a
+ * messageType / majorSdoId(transportSpecific) nibble pair, a versionPTP / minorVersionPTP nibble pair,
+ * the total messageLength, domainNumber, a minorSdoId(reserved) octet, a 2-byte flagField, an 8-byte
+ * correctionField, a 4-byte reserved(messageTypeSpecific) field, the 10-byte sourcePortIdentity
+ * (8-byte clockIdentity + 2-byte portNumber), sequenceId, controlField, and the signed
+ * logMessageInterval — followed by the message-type-specific body.
+ *
+ * The per-type body (Sync/Follow_Up timestamps, Announce clock-quality, Delay/Pdelay, Signaling and
+ * Management TLVs) is kept verbatim as `body` hex (byte-perfect) and not sub-decoded in this slice. The
+ * messageLength is honored verbatim on encode when supplied (a crafted message may lie) else derived
+ * from the body; the message is bounded by messageLength and the transport payload, so a min-size
+ * Ethernet frame's trailing padding is left to the codec's recursion / RawData. The correctionField is
+ * kept verbatim (never recomputed) — a well-formed message round-trips byte-for-byte.
+ */
+export declare class PTP 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/PTP.js

@@ -0,0 +1,213 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PTP = 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");
+/**
+ * PTP — the Precision Time Protocol version 2 (IEEE 1588-2008, with 1588-2019 field naming). A
+ * sub-microsecond clock-synchronization protocol widely deployed in power-system substations (IEC 61850
+ * / IEEE C37.238 power profile) and industrial automation. It is dual-carried: directly over Ethernet
+ * with EtherType 0x88F7 (an Ethernet child — no IP), or over UDP/IPv4/6 on the event port 319 and the
+ * general port 320.
+ *
+ * Every PTP message begins with the same 34-byte common header (IEEE 1588-2008 §13.3): a
+ * messageType / majorSdoId(transportSpecific) nibble pair, a versionPTP / minorVersionPTP nibble pair,
+ * the total messageLength, domainNumber, a minorSdoId(reserved) octet, a 2-byte flagField, an 8-byte
+ * correctionField, a 4-byte reserved(messageTypeSpecific) field, the 10-byte sourcePortIdentity
+ * (8-byte clockIdentity + 2-byte portNumber), sequenceId, controlField, and the signed
+ * logMessageInterval — followed by the message-type-specific body.
+ *
+ * The per-type body (Sync/Follow_Up timestamps, Announce clock-quality, Delay/Pdelay, Signaling and
+ * Management TLVs) is kept verbatim as `body` hex (byte-perfect) and not sub-decoded in this slice. The
+ * messageLength is honored verbatim on encode when supplied (a crafted message may lie) else derived
+ * from the body; the message is bounded by messageLength and the transport payload, so a min-size
+ * Ethernet frame's trailing padding is left to the codec's recursion / RawData. The correctionField is
+ * kept verbatim (never recomputed) — a well-formed message round-trips byte-for-byte.
+ */
+class PTP extends BaseHeader_1.BaseHeader {
+    constructor() {
+        super(...arguments);
+        this.id = 'ptp';
+        this.name = 'Precision Time Protocol';
+        this.nickname = 'PTP';
+        this.matchKeys = ['ethertype:88f7', 'udpport:319', 'udpport:320'];
+        //A leaf header — the per-message-type body (timestamps, Announce clock-quality, Signaling/Management
+        //TLVs) is kept verbatim and sub-decoding is deferred to a later slice.
+        this.demuxProducers = [];
+    }
+    static #schemaCache;
+    get SCHEMA() {
+        return (PTP.#schemaCache ??= PTP.#buildSchema());
+    }
+    /**
+     * Bytes of PTP available in the enclosing transport. Over UDP the datagram length bounds the message
+     * (so retained Ethernet padding / a trailing FCS is not absorbed); over raw Ethernet there is no
+     * transport length field, so take the rest of the captured frame (messageLength then bounds the body).
+     */
+    #available() {
+        let available = 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 < available)
+                available = udpLength - 8;
+        }
+        return available < 0 ? 0 : available;
+    }
+    /**
+     * Header-relative end offset of the PTP message: the messageLength field, clamped down to the bytes
+     * the transport actually made available (#available). Never less than the 34-byte common header, so
+     * the body walk is bounded even when a malformed messageLength overstates the message.
+     */
+    #bodyEnd() {
+        let end = this.instance.messageLength.getValue(0);
+        const available = this.#available();
+        if (available && available < end)
+            end = available;
+        if (end < 34)
+            end = 34;
+        return end;
+    }
+    /** A 4-bit nibble within a single octet (bitOffset 0 = the high nibble, MSB-first). */
+    static #nibble(name, byteOffset, bitOffset, label) {
+        return {
+            type: 'integer',
+            label: label,
+            minimum: 0,
+            maximum: 15,
+            decode: function () {
+                this.instance[name].setValue(this.readBits(byteOffset, 1, bitOffset, 4));
+            },
+            encode: function () {
+                //writeBits masks the field, so the two nibbles of the same octet never clobber each other.
+                this.writeBits(byteOffset, 1, bitOffset, 4, this.instance[name].getValue(0));
+            }
+        };
+    }
+    static #buildSchema() {
+        return {
+            type: 'object',
+            summary: 'PTPv2 msgType=${messageType} seq=${sequenceId}',
+            properties: {
+                //Byte 0 (MSB first): majorSdoId/transportSpecific (high nibble), messageType (low nibble).
+                //messageType: 0 Sync, 1 Delay_Req, 2 Pdelay_Req, 3 Pdelay_Resp, 8 Follow_Up, 9 Delay_Resp,
+                //0xA Pdelay_Resp_Follow_Up, 0xB Announce, 0xC Signaling, 0xD Management.
+                majorSdoId: this.#nibble('majorSdoId', 0, 0, 'Major SDO ID / Transport Specific'),
+                messageType: this.#nibble('messageType', 0, 4, 'Message Type'),
+                //Byte 1 (MSB first): minorVersionPTP (high nibble, reserved/0 in 1588-2008), versionPTP
+                //(low nibble, 2 for PTPv2).
+                minorVersionPTP: this.#nibble('minorVersionPTP', 1, 0, 'Minor Version PTP'),
+                versionPTP: this.#nibble('versionPTP', 1, 4, 'Version PTP'),
+                messageLength: {
+                    type: 'integer',
+                    label: 'Message Length',
+                    minimum: 34,
+                    maximum: 65535,
+                    decode: function () {
+                        this.instance.messageLength.setValue((0, BufferToNumber_1.BufferToUInt16)(this.readBytes(2, 2)));
+                    },
+                    encode: function () {
+                        //messageLength counts the whole message = 34-byte header + body. Honored when
+                        //supplied (a crafted message may lie); else derived from the body.
+                        const provided = this.instance.messageLength.getValue();
+                        let value = (provided !== undefined && provided !== null)
+                            ? provided
+                            : 34 + (0, HexToBuffer_1.HexToBuffer)(this.instance.body.getValue('')).length;
+                        if (value > 65535) {
+                            this.recordError(this.instance.messageLength.getPath(), 'Maximum value is 65535');
+                            value = 65535;
+                        }
+                        this.instance.messageLength.setValue(value);
+                        this.writeBytes(2, (0, NumberToBuffer_1.UInt16ToBuffer)(value));
+                    }
+                },
+                domainNumber: this.fieldUInt('domainNumber', 4, 1, 'Domain Number'),
+                //minorSdoId (1588-2019) / reserved (1588-2008), byte 5 — kept verbatim for byte-perfect.
+                minorSdoId: this.fieldUInt('minorSdoId', 5, 1, 'Minor SDO ID'),
+                //flagField (bytes 6-7): alternateMaster/twoStep/unicast/PTP-profile/security/etc. Kept as
+                //hex — the per-bit meaning is message-type dependent; a form still round-trips it exactly.
+                flags: this.fieldHex('flags', 6, 2, 'Flags'),
+                //correctionField (bytes 8-15): signed 64-bit scaled nanoseconds. Kept verbatim (never
+                //recomputed), so a captured message round-trips byte-for-byte.
+                correctionField: this.fieldHex('correctionField', 8, 8, 'Correction Field'),
+                //reserved (bytes 16-19) / messageTypeSpecific in 1588-2019 — kept verbatim.
+                reserved: this.fieldHex('reserved', 16, 4, 'Reserved'),
+                //sourcePortIdentity (bytes 20-29): the 8-byte clockIdentity + 2-byte portNumber of the
+                //originating port.
+                sourcePortIdentity: {
+                    type: 'object',
+                    label: 'Source Port Identity',
+                    properties: {
+                        clockIdentity: {
+                            type: 'string',
+                            label: 'Clock Identity',
+                            contentEncoding: StringContentEncodingEnum_1.StringContentEncodingEnum.HEX,
+                            decode: function () {
+                                this.instance.sourcePortIdentity.clockIdentity.setValue((0, BufferToHex_1.BufferToHex)(this.readBytes(20, 8)));
+                            },
+                            encode: function () {
+                                this.writeBytes(20, (0, HexToBuffer_1.HexToBuffer)(this.instance.sourcePortIdentity.clockIdentity.getValue('0000000000000000')));
+                            }
+                        },
+                        portNumber: {
+                            type: 'integer',
+                            label: 'Source Port Number',
+                            minimum: 0,
+                            maximum: 65535,
+                            decode: function () {
+                                this.instance.sourcePortIdentity.portNumber.setValue((0, BufferToNumber_1.BufferToUInt16)(this.readBytes(28, 2)));
+                            },
+                            encode: function () {
+                                this.writeBytes(28, (0, NumberToBuffer_1.UInt16ToBuffer)(this.instance.sourcePortIdentity.portNumber.getValue(0)));
+                            }
+                        }
+                    }
+                },
+                sequenceId: this.fieldUInt('sequenceId', 30, 2, 'Sequence ID'),
+                controlField: this.fieldUInt('controlField', 32, 1, 'Control Field'),
+                logMessageInterval: this.fieldInt8('logMessageInterval', 33, 'Log Message Interval'),
+                //The message-type-specific body after the 34-byte header, kept verbatim. Bounded by the
+                //messageLength (the message ends at offset messageLength) and the transport payload, so
+                //Ethernet padding / a pipelined message is left to the codec's recursion / RawData.
+                body: {
+                    type: 'string',
+                    label: 'Body',
+                    contentEncoding: StringContentEncodingEnum_1.StringContentEncodingEnum.HEX,
+                    decode: function () {
+                        const end = this.#bodyEnd();
+                        this.instance.body.setValue(end > 34 ? (0, BufferToHex_1.BufferToHex)(this.readBytes(34, end - 34)) : '');
+                    },
+                    encode: function () {
+                        const body = this.instance.body.getValue('');
+                        if (body)
+                            this.writeBytes(34, (0, HexToBuffer_1.HexToBuffer)(body));
+                    }
+                }
+            }
+        };
+    }
+    match() {
+        //PTP is dual-carried: directly over Ethernet (EtherType 0x88F7) or over UDP on the event port
+        //319 / general port 320 (accept src too, to catch responses). Require the full 34-byte common
+        //header within the transport payload.
+        if (!this.prevCodecModule)
+            return false;
+        const prev = this.prevCodecModule;
+        if (prev.id === 'udp') {
+            const dstport = prev.instance.dstport.getValue(0);
+            const srcport = prev.instance.srcport.getValue(0);
+            if (dstport !== 319 && dstport !== 320 && srcport !== 319 && srcport !== 320)
+                return false;
+            return this.#available() >= 34;
+        }
+        //Ethernet (or a VLAN/HSR parent) child selected by EtherType 0x88F7 (a lowercase 4-hex string).
+        if (prev.instance.etherType.getValue() !== '88f7')
+            return false;
+        return this.packet.length - this.startPos >= 34;
+    }
+}
+exports.PTP = PTP;