@aircast-4g/mavlink 1.0.1 → 1.1.0

package/dist/parser/message-decoder.js

@@ -1,246 +1,428 @@
 "use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.MAVLinkMessageDecoder = void 0;
-// Message decoder for MAVLink messages
-const types_1 = require("./types");
 class MAVLinkMessageDecoder {
-    constructor() {
-        this.messageMap = new Map();
-        // Message map initialization - would be enhanced with actual message definitions
+    constructor(useGeneratedDefinitions = false) {
+        this.messageDefinitions = new Map();
+        if (useGeneratedDefinitions) {
+            this.initializeFromGeneratedDefinitions();
+        }
+        else {
+            this.initializeMessageDefinitions();
+        }
     }
     decode(frame) {
-        const timestamp = Date.now();
-        try {
-            // Decode payload based on message ID
-            const payload = this.decodePayload(frame.message_id, frame.payload);
-            const messageName = this.getMessageName(frame.message_id);
+        const messageDef = this.messageDefinitions.get(frame.message_id);
+        // Determine protocol version from magic byte if not provided
+        const protocolVersion = frame.protocol_version || (frame.magic === 0xFD ? 2 : 1);
+        if (!messageDef) {
             return {
-                timestamp,
+                timestamp: Date.now(),
                 system_id: frame.system_id,
                 component_id: frame.component_id,
                 message_id: frame.message_id,
-                message_name: messageName,
+                message_name: `UNKNOWN_${frame.message_id}`,
                 sequence: frame.sequence,
-                payload,
-                protocol_version: frame.protocol_version,
+                payload: {
+                    raw_payload: Array.from(frame.payload)
+                },
+                protocol_version: protocolVersion,
                 checksum: frame.checksum,
-                signature: frame.signature
+                crc_ok: frame.crc_ok !== false
             };
         }
+        const payload = this.decodePayload(frame.payload, messageDef.fields);
+        return {
+            timestamp: Date.now(),
+            system_id: frame.system_id,
+            component_id: frame.component_id,
+            message_id: frame.message_id,
+            message_name: messageDef.name,
+            sequence: frame.sequence,
+            payload,
+            protocol_version: protocolVersion,
+            checksum: frame.checksum,
+            crc_ok: frame.crc_ok !== false,
+            signature: frame.signature
+        };
+    }
+    decodePayload(payload, fields) {
+        const result = {};
+        const view = new DataView(payload.buffer, payload.byteOffset, payload.byteLength);
+        let offset = 0;
+        for (const field of fields) {
+            if (offset >= payload.length)
+                break;
+            const { value, bytesRead } = this.decodeField(view, offset, field);
+            result[field.name] = value;
+            offset += bytesRead;
+        }
+        return result;
+    }
+    decodeField(view, offset, field) {
+        const isArray = field.arrayLength !== undefined;
+        const arrayLength = field.arrayLength || 1;
+        if (isArray && arrayLength > 1) {
+            const values = [];
+            let totalBytes = 0;
+            for (let i = 0; i < arrayLength; i++) {
+                if (offset + totalBytes >= view.byteLength)
+                    break;
+                const { value, bytesRead } = this.decodeSingleValue(view, offset + totalBytes, field.type);
+                values.push(value);
+                totalBytes += bytesRead;
+            }
+            return { value: values, bytesRead: totalBytes };
+        }
+        else {
+            return this.decodeSingleValue(view, offset, field.type);
+        }
+    }
+    decodeSingleValue(view, offset, type) {
+        try {
+            switch (type) {
+                case 'uint8_t':
+                    return { value: view.getUint8(offset), bytesRead: 1 };
+                case 'int8_t':
+                    return { value: view.getInt8(offset), bytesRead: 1 };
+                case 'uint16_t':
+                    return { value: view.getUint16(offset, true), bytesRead: 2 };
+                case 'int16_t':
+                    return { value: view.getInt16(offset, true), bytesRead: 2 };
+                case 'uint32_t':
+                    return { value: view.getUint32(offset, true), bytesRead: 4 };
+                case 'int32_t':
+                    return { value: view.getInt32(offset, true), bytesRead: 4 };
+                case 'uint64_t':
+                    return { value: view.getBigUint64(offset, true), bytesRead: 8 };
+                case 'int64_t':
+                    return { value: view.getBigInt64(offset, true), bytesRead: 8 };
+                case 'float':
+                    return { value: view.getFloat32(offset, true), bytesRead: 4 };
+                case 'double':
+                    return { value: view.getFloat64(offset, true), bytesRead: 8 };
+                case 'char':
+                    const charCode = view.getUint8(offset);
+                    return { value: charCode === 0 ? '\0' : String.fromCharCode(charCode), bytesRead: 1 };
+                default:
+                    if (type.startsWith('char[') && type.endsWith(']')) {
+                        const length = parseInt(type.slice(5, -1));
+                        const chars = [];
+                        for (let i = 0; i < length && offset + i < view.byteLength; i++) {
+                            const charCode = view.getUint8(offset + i);
+                            if (charCode === 0)
+                                break;
+                            chars.push(String.fromCharCode(charCode));
+                        }
+                        return { value: chars.join(''), bytesRead: length };
+                    }
+                    else if (type.includes('[') && type.includes(']')) {
+                        const baseType = type.substring(0, type.indexOf('['));
+                        const arrayLength = parseInt(type.substring(type.indexOf('[') + 1, type.indexOf(']')));
+                        const values = [];
+                        let totalBytes = 0;
+                        for (let i = 0; i < arrayLength; i++) {
+                            if (offset + totalBytes >= view.byteLength)
+                                break;
+                            const { value, bytesRead } = this.decodeSingleValue(view, offset + totalBytes, baseType);
+                            values.push(value);
+                            totalBytes += bytesRead;
+                        }
+                        return { value: values, bytesRead: totalBytes };
+                    }
+                    return { value: view.getUint8(offset), bytesRead: 1 };
+            }
+        }
         catch (error) {
-            throw new types_1.ParserError(`Failed to decode message: ${error instanceof Error ? error.message : 'Unknown error'}`, frame);
+            return { value: 0, bytesRead: 1 };
         }
     }
-    decodePayload(messageId, payload) {
-        // Basic payload decoder - this would be enhanced with proper type definitions
-        const decoded = {};
-        switch (messageId) {
-            case 0: // HEARTBEAT
-                decoded.type = payload[0];
-                decoded.autopilot = payload[1];
-                decoded.base_mode = payload[2];
-                decoded.custom_mode = new DataView(payload.buffer, payload.byteOffset).getUint32(3, true);
-                decoded.system_status = payload[7];
-                decoded.mavlink_version = payload[8];
-                break;
-            case 1: // SYS_STATUS
-                decoded.onboard_control_sensors_present = new DataView(payload.buffer, payload.byteOffset).getUint32(0, true);
-                decoded.onboard_control_sensors_enabled = new DataView(payload.buffer, payload.byteOffset).getUint32(4, true);
-                decoded.onboard_control_sensors_health = new DataView(payload.buffer, payload.byteOffset).getUint32(8, true);
-                decoded.load = new DataView(payload.buffer, payload.byteOffset).getUint16(12, true);
-                decoded.voltage_battery = new DataView(payload.buffer, payload.byteOffset).getUint16(14, true);
-                decoded.current_battery = new DataView(payload.buffer, payload.byteOffset).getInt16(16, true);
-                decoded.battery_remaining = payload[18];
-                break;
-            case 4: // PING
-                decoded.time_usec = new DataView(payload.buffer, payload.byteOffset).getBigUint64(0, true);
-                decoded.seq = new DataView(payload.buffer, payload.byteOffset).getUint32(8, true);
-                decoded.target_system = payload[12];
-                decoded.target_component = payload[13];
-                break;
-            case 30: // ATTITUDE
-                decoded.time_boot_ms = new DataView(payload.buffer, payload.byteOffset).getUint32(0, true);
-                decoded.roll = new DataView(payload.buffer, payload.byteOffset).getFloat32(4, true);
-                decoded.pitch = new DataView(payload.buffer, payload.byteOffset).getFloat32(8, true);
-                decoded.yaw = new DataView(payload.buffer, payload.byteOffset).getFloat32(12, true);
-                decoded.rollspeed = new DataView(payload.buffer, payload.byteOffset).getFloat32(16, true);
-                decoded.pitchspeed = new DataView(payload.buffer, payload.byteOffset).getFloat32(20, true);
-                decoded.yawspeed = new DataView(payload.buffer, payload.byteOffset).getFloat32(24, true);
-                break;
-            case 33: // GLOBAL_POSITION_INT
-                decoded.time_boot_ms = new DataView(payload.buffer, payload.byteOffset).getUint32(0, true);
-                decoded.lat = new DataView(payload.buffer, payload.byteOffset).getInt32(4, true);
-                decoded.lon = new DataView(payload.buffer, payload.byteOffset).getInt32(8, true);
-                decoded.alt = new DataView(payload.buffer, payload.byteOffset).getInt32(12, true);
-                decoded.relative_alt = new DataView(payload.buffer, payload.byteOffset).getInt32(16, true);
-                decoded.vx = new DataView(payload.buffer, payload.byteOffset).getInt16(20, true);
-                decoded.vy = new DataView(payload.buffer, payload.byteOffset).getInt16(22, true);
-                decoded.vz = new DataView(payload.buffer, payload.byteOffset).getInt16(24, true);
-                decoded.hdg = new DataView(payload.buffer, payload.byteOffset).getUint16(26, true);
-                break;
-            default:
-                // For unknown messages, return raw bytes as hex
-                decoded.raw_data = Array.from(payload).map(b => b.toString(16).padStart(2, '0')).join('');
-                break;
+    initializeMessageDefinitions() {
+        // Common MAVLink messages - these definitions come from the official MAVLink specification
+        this.addMessageDefinition(0, 'HEARTBEAT', [
+            { name: 'type', type: 'uint8_t' },
+            { name: 'autopilot', type: 'uint8_t' },
+            { name: 'base_mode', type: 'uint8_t' },
+            { name: 'custom_mode', type: 'uint32_t' },
+            { name: 'system_status', type: 'uint8_t' },
+            { name: 'mavlink_version', type: 'uint8_t' }
+        ]);
+        this.addMessageDefinition(1, 'SYS_STATUS', [
+            { name: 'onboard_control_sensors_present', type: 'uint32_t' },
+            { name: 'onboard_control_sensors_enabled', type: 'uint32_t' },
+            { name: 'onboard_control_sensors_health', type: 'uint32_t' },
+            { name: 'load', type: 'uint16_t' },
+            { name: 'voltage_battery', type: 'uint16_t' },
+            { name: 'current_battery', type: 'int16_t' },
+            { name: 'battery_remaining', type: 'int8_t' },
+            { name: 'drop_rate_comm', type: 'uint16_t' },
+            { name: 'errors_comm', type: 'uint16_t' },
+            { name: 'errors_count1', type: 'uint16_t' },
+            { name: 'errors_count2', type: 'uint16_t' },
+            { name: 'errors_count3', type: 'uint16_t' },
+            { name: 'errors_count4', type: 'uint16_t' }
+        ]);
+        this.addMessageDefinition(2, 'SYSTEM_TIME', [
+            { name: 'time_unix_usec', type: 'uint64_t' },
+            { name: 'time_boot_ms', type: 'uint32_t' }
+        ]);
+        this.addMessageDefinition(4, 'PING', [
+            { name: 'time_usec', type: 'uint64_t' },
+            { name: 'seq', type: 'uint32_t' },
+            { name: 'target_system', type: 'uint8_t' },
+            { name: 'target_component', type: 'uint8_t' }
+        ]);
+        this.addMessageDefinition(11, 'SET_MODE', [
+            { name: 'target_system', type: 'uint8_t' },
+            { name: 'base_mode', type: 'uint8_t' },
+            { name: 'custom_mode', type: 'uint32_t' }
+        ]);
+        this.addMessageDefinition(20, 'PARAM_REQUEST_READ', [
+            { name: 'target_system', type: 'uint8_t' },
+            { name: 'target_component', type: 'uint8_t' },
+            { name: 'param_id', type: 'char[16]' },
+            { name: 'param_index', type: 'int16_t' }
+        ]);
+        this.addMessageDefinition(21, 'PARAM_REQUEST_LIST', [
+            { name: 'target_system', type: 'uint8_t' },
+            { name: 'target_component', type: 'uint8_t' }
+        ]);
+        this.addMessageDefinition(22, 'PARAM_VALUE', [
+            { name: 'param_id', type: 'char[16]' },
+            { name: 'param_value', type: 'float' },
+            { name: 'param_type', type: 'uint8_t' },
+            { name: 'param_count', type: 'uint16_t' },
+            { name: 'param_index', type: 'uint16_t' }
+        ]);
+        this.addMessageDefinition(23, 'PARAM_SET', [
+            { name: 'target_system', type: 'uint8_t' },
+            { name: 'target_component', type: 'uint8_t' },
+            { name: 'param_id', type: 'char[16]' },
+            { name: 'param_value', type: 'float' },
+            { name: 'param_type', type: 'uint8_t' }
+        ]);
+        this.addMessageDefinition(24, 'GPS_RAW_INT', [
+            { name: 'time_usec', type: 'uint64_t' },
+            { name: 'fix_type', type: 'uint8_t' },
+            { name: 'lat', type: 'int32_t' },
+            { name: 'lon', type: 'int32_t' },
+            { name: 'alt', type: 'int32_t' },
+            { name: 'eph', type: 'uint16_t' },
+            { name: 'epv', type: 'uint16_t' },
+            { name: 'vel', type: 'uint16_t' },
+            { name: 'cog', type: 'uint16_t' },
+            { name: 'satellites_visible', type: 'uint8_t' }
+        ]);
+        this.addMessageDefinition(25, 'GPS_STATUS', [
+            { name: 'satellites_visible', type: 'uint8_t' },
+            { name: 'satellite_prn', type: 'uint8_t', arrayLength: 20 },
+            { name: 'satellite_used', type: 'uint8_t', arrayLength: 20 },
+            { name: 'satellite_elevation', type: 'uint8_t', arrayLength: 20 },
+            { name: 'satellite_azimuth', type: 'uint8_t', arrayLength: 20 },
+            { name: 'satellite_snr', type: 'uint8_t', arrayLength: 20 }
+        ]);
+        this.addMessageDefinition(26, 'SCALED_IMU', [
+            { name: 'time_boot_ms', type: 'uint32_t' },
+            { name: 'xacc', type: 'int16_t' },
+            { name: 'yacc', type: 'int16_t' },
+            { name: 'zacc', type: 'int16_t' },
+            { name: 'xgyro', type: 'int16_t' },
+            { name: 'ygyro', type: 'int16_t' },
+            { name: 'zgyro', type: 'int16_t' },
+            { name: 'xmag', type: 'int16_t' },
+            { name: 'ymag', type: 'int16_t' },
+            { name: 'zmag', type: 'int16_t' }
+        ]);
+        this.addMessageDefinition(27, 'RAW_IMU', [
+            { name: 'time_usec', type: 'uint64_t' },
+            { name: 'xacc', type: 'int16_t' },
+            { name: 'yacc', type: 'int16_t' },
+            { name: 'zacc', type: 'int16_t' },
+            { name: 'xgyro', type: 'int16_t' },
+            { name: 'ygyro', type: 'int16_t' },
+            { name: 'zgyro', type: 'int16_t' },
+            { name: 'xmag', type: 'int16_t' },
+            { name: 'ymag', type: 'int16_t' },
+            { name: 'zmag', type: 'int16_t' }
+        ]);
+        this.addMessageDefinition(28, 'RAW_PRESSURE', [
+            { name: 'time_usec', type: 'uint64_t' },
+            { name: 'press_abs', type: 'int16_t' },
+            { name: 'press_diff1', type: 'int16_t' },
+            { name: 'press_diff2', type: 'int16_t' },
+            { name: 'temperature', type: 'int16_t' }
+        ]);
+        this.addMessageDefinition(29, 'SCALED_PRESSURE', [
+            { name: 'time_boot_ms', type: 'uint32_t' },
+            { name: 'press_abs', type: 'float' },
+            { name: 'press_diff', type: 'float' },
+            { name: 'temperature', type: 'int16_t' }
+        ]);
+        this.addMessageDefinition(30, 'ATTITUDE', [
+            { name: 'time_boot_ms', type: 'uint32_t' },
+            { name: 'roll', type: 'float' },
+            { name: 'pitch', type: 'float' },
+            { name: 'yaw', type: 'float' },
+            { name: 'rollspeed', type: 'float' },
+            { name: 'pitchspeed', type: 'float' },
+            { name: 'yawspeed', type: 'float' }
+        ]);
+        this.addMessageDefinition(31, 'ATTITUDE_QUATERNION', [
+            { name: 'time_boot_ms', type: 'uint32_t' },
+            { name: 'q1', type: 'float' },
+            { name: 'q2', type: 'float' },
+            { name: 'q3', type: 'float' },
+            { name: 'q4', type: 'float' },
+            { name: 'rollspeed', type: 'float' },
+            { name: 'pitchspeed', type: 'float' },
+            { name: 'yawspeed', type: 'float' }
+        ]);
+        this.addMessageDefinition(32, 'LOCAL_POSITION_NED', [
+            { name: 'time_boot_ms', type: 'uint32_t' },
+            { name: 'x', type: 'float' },
+            { name: 'y', type: 'float' },
+            { name: 'z', type: 'float' },
+            { name: 'vx', type: 'float' },
+            { name: 'vy', type: 'float' },
+            { name: 'vz', type: 'float' }
+        ]);
+        this.addMessageDefinition(33, 'GLOBAL_POSITION_INT', [
+            { name: 'time_boot_ms', type: 'uint32_t' },
+            { name: 'lat', type: 'int32_t' },
+            { name: 'lon', type: 'int32_t' },
+            { name: 'alt', type: 'int32_t' },
+            { name: 'relative_alt', type: 'int32_t' },
+            { name: 'vx', type: 'int16_t' },
+            { name: 'vy', type: 'int16_t' },
+            { name: 'vz', type: 'int16_t' },
+            { name: 'hdg', type: 'uint16_t' }
+        ]);
+        this.addMessageDefinition(62, 'NAV_CONTROLLER_OUTPUT', [
+            { name: 'nav_roll', type: 'float' },
+            { name: 'nav_pitch', type: 'float' },
+            { name: 'nav_bearing', type: 'int16_t' },
+            { name: 'target_bearing', type: 'int16_t' },
+            { name: 'wp_dist', type: 'uint16_t' },
+            { name: 'alt_error', type: 'float' },
+            { name: 'aspd_error', type: 'float' },
+            { name: 'xtrack_error', type: 'float' }
+        ]);
+        this.addMessageDefinition(74, 'VFR_HUD', [
+            { name: 'airspeed', type: 'float' },
+            { name: 'groundspeed', type: 'float' },
+            { name: 'heading', type: 'int16_t' },
+            { name: 'throttle', type: 'uint16_t' },
+            { name: 'alt', type: 'float' },
+            { name: 'climb', type: 'float' }
+        ]);
+        this.addMessageDefinition(76, 'COMMAND_INT', [
+            { name: 'target_system', type: 'uint8_t' },
+            { name: 'target_component', type: 'uint8_t' },
+            { name: 'frame', type: 'uint8_t' },
+            { name: 'command', type: 'uint16_t' },
+            { name: 'current', type: 'uint8_t' },
+            { name: 'autocontinue', type: 'uint8_t' },
+            { name: 'param1', type: 'float' },
+            { name: 'param2', type: 'float' },
+            { name: 'param3', type: 'float' },
+            { name: 'param4', type: 'float' },
+            { name: 'x', type: 'int32_t' },
+            { name: 'y', type: 'int32_t' },
+            { name: 'z', type: 'float' }
+        ]);
+        this.addMessageDefinition(77, 'COMMAND_LONG', [
+            { name: 'target_system', type: 'uint8_t' },
+            { name: 'target_component', type: 'uint8_t' },
+            { name: 'command', type: 'uint16_t' },
+            { name: 'confirmation', type: 'uint8_t' },
+            { name: 'param1', type: 'float' },
+            { name: 'param2', type: 'float' },
+            { name: 'param3', type: 'float' },
+            { name: 'param4', type: 'float' },
+            { name: 'param5', type: 'float' },
+            { name: 'param6', type: 'float' },
+            { name: 'param7', type: 'float' }
+        ]);
+        this.addMessageDefinition(253, 'STATUSTEXT', [
+            { name: 'severity', type: 'uint8_t' },
+            { name: 'text', type: 'char[50]' }
+        ]);
+    }
+    addMessageDefinition(id, name, fields) {
+        this.messageDefinitions.set(id, { id, name, fields });
+    }
+    addCustomMessageDefinition(id, name, fields) {
+        this.addMessageDefinition(id, name, fields);
+    }
+    getMessageDefinition(id) {
+        return this.messageDefinitions.get(id);
+    }
+    getSupportedMessageIds() {
+        return Array.from(this.messageDefinitions.keys()).sort((a, b) => a - b);
+    }
+    async initializeFromGeneratedDefinitions() {
+        try {
+            // Load decoder definitions from dist folder
+            const dialects = ['common', 'ardupilotmega', 'minimal'];
+            const allDefinitions = new Map();
+            for (const dialectName of dialects) {
+                try {
+                    const { MESSAGE_DEFINITIONS } = await Promise.resolve(`${`../../dist/decoders/${dialectName}`}`).then(s => __importStar(require(s)));
+                    for (const def of MESSAGE_DEFINITIONS) {
+                        if (!allDefinitions.has(def.id)) {
+                            allDefinitions.set(def.id, def);
+                        }
+                    }
+                }
+                catch (error) {
+                    console.warn(`Failed to load ${dialectName} decoder definitions:`, error);
+                }
+            }
+            this.messageDefinitions = allDefinitions;
+            console.log(`Loaded ${this.messageDefinitions.size} message definitions from generated decoders`);
+        }
+        catch (error) {
+            console.warn('Failed to load generated decoder definitions, falling back to hardcoded definitions:', error);
+            this.initializeMessageDefinitions();
         }
-        return decoded;
     }
-    getMessageName(messageId) {
-        const messageNames = {
-            0: 'HEARTBEAT',
-            1: 'SYS_STATUS',
-            2: 'SYSTEM_TIME',
-            4: 'PING',
-            5: 'CHANGE_OPERATOR_CONTROL',
-            6: 'CHANGE_OPERATOR_CONTROL_ACK',
-            7: 'AUTH_KEY',
-            11: 'SET_MODE',
-            20: 'PARAM_REQUEST_READ',
-            21: 'PARAM_REQUEST_LIST',
-            22: 'PARAM_VALUE',
-            23: 'PARAM_SET',
-            24: 'GPS_RAW_INT',
-            25: 'GPS_STATUS',
-            26: 'SCALED_IMU',
-            27: 'RAW_IMU',
-            28: 'RAW_PRESSURE',
-            29: 'SCALED_PRESSURE',
-            30: 'ATTITUDE',
-            31: 'ATTITUDE_QUATERNION',
-            32: 'LOCAL_POSITION_NED',
-            33: 'GLOBAL_POSITION_INT',
-            34: 'RC_CHANNELS_SCALED',
-            35: 'RC_CHANNELS_RAW',
-            36: 'SERVO_OUTPUT_RAW',
-            37: 'MISSION_REQUEST_PARTIAL_LIST',
-            38: 'MISSION_WRITE_PARTIAL_LIST',
-            39: 'MISSION_ITEM',
-            40: 'MISSION_REQUEST',
-            41: 'MISSION_SET_CURRENT',
-            42: 'MISSION_CURRENT',
-            43: 'MISSION_REQUEST_LIST',
-            44: 'MISSION_COUNT',
-            45: 'MISSION_CLEAR_ALL',
-            46: 'MISSION_ITEM_REACHED',
-            47: 'MISSION_ACK',
-            48: 'SET_GPS_GLOBAL_ORIGIN',
-            49: 'GPS_GLOBAL_ORIGIN',
-            50: 'PARAM_MAP_RC',
-            51: 'MISSION_REQUEST_INT',
-            54: 'SAFETY_SET_ALLOWED_AREA',
-            55: 'SAFETY_ALLOWED_AREA',
-            61: 'ATTITUDE_QUATERNION_COV',
-            62: 'NAV_CONTROLLER_OUTPUT',
-            63: 'GLOBAL_POSITION_INT_COV',
-            64: 'LOCAL_POSITION_NED_COV',
-            65: 'RC_CHANNELS',
-            66: 'REQUEST_DATA_STREAM',
-            67: 'DATA_STREAM',
-            69: 'MANUAL_CONTROL',
-            70: 'RC_CHANNELS_OVERRIDE',
-            73: 'MISSION_ITEM_INT',
-            74: 'VFR_HUD',
-            75: 'COMMAND_INT',
-            76: 'COMMAND_LONG',
-            77: 'COMMAND_ACK',
-            81: 'MANUAL_SETPOINT',
-            82: 'SET_ATTITUDE_TARGET',
-            83: 'ATTITUDE_TARGET',
-            84: 'SET_POSITION_TARGET_LOCAL_NED',
-            85: 'POSITION_TARGET_LOCAL_NED',
-            86: 'SET_POSITION_TARGET_GLOBAL_INT',
-            87: 'POSITION_TARGET_GLOBAL_INT',
-            89: 'LOCAL_POSITION_NED_SYSTEM_GLOBAL_OFFSET',
-            90: 'HIL_STATE',
-            91: 'HIL_CONTROLS',
-            92: 'HIL_RC_INPUTS_RAW',
-            100: 'OPTICAL_FLOW',
-            101: 'GLOBAL_VISION_POSITION_ESTIMATE',
-            102: 'VISION_POSITION_ESTIMATE',
-            103: 'VISION_SPEED_ESTIMATE',
-            104: 'VICON_POSITION_ESTIMATE',
-            105: 'HIGHRES_IMU',
-            106: 'OPTICAL_FLOW_RAD',
-            107: 'HIL_SENSOR',
-            108: 'SIM_STATE',
-            109: 'RADIO_STATUS',
-            110: 'FILE_TRANSFER_PROTOCOL',
-            111: 'TIMESYNC',
-            112: 'CAMERA_TRIGGER',
-            113: 'HIL_GPS',
-            114: 'HIL_OPTICAL_FLOW',
-            115: 'HIL_STATE_QUATERNION',
-            116: 'SCALED_IMU2',
-            117: 'LOG_REQUEST_LIST',
-            118: 'LOG_ENTRY',
-            119: 'LOG_REQUEST_DATA',
-            120: 'LOG_DATA',
-            121: 'LOG_ERASE',
-            122: 'LOG_REQUEST_END',
-            123: 'GPS_INJECT_DATA',
-            124: 'GPS2_RAW',
-            125: 'POWER_STATUS',
-            126: 'SERIAL_CONTROL',
-            127: 'GPS_RTK',
-            128: 'GPS2_RTK',
-            129: 'SCALED_IMU3',
-            130: 'DATA_TRANSMISSION_HANDSHAKE',
-            131: 'ENCAPSULATED_DATA',
-            132: 'DISTANCE_SENSOR',
-            133: 'TERRAIN_REQUEST',
-            134: 'TERRAIN_DATA',
-            135: 'TERRAIN_CHECK',
-            136: 'TERRAIN_REPORT',
-            137: 'SCALED_PRESSURE2',
-            138: 'ATT_POS_MOCAP',
-            139: 'SET_ACTUATOR_CONTROL_TARGET',
-            140: 'ACTUATOR_CONTROL_TARGET',
-            141: 'ALTITUDE',
-            142: 'RESOURCE_REQUEST',
-            143: 'SCALED_PRESSURE3',
-            144: 'FOLLOW_TARGET',
-            146: 'CONTROL_SYSTEM_STATE',
-            147: 'BATTERY_STATUS',
-            148: 'AUTOPILOT_VERSION',
-            149: 'LANDING_TARGET',
-            230: 'ESTIMATOR_STATUS',
-            231: 'WIND_COV',
-            232: 'GPS_INPUT',
-            233: 'GPS_RTCM_DATA',
-            234: 'HIGH_LATENCY',
-            235: 'HIGH_LATENCY2',
-            241: 'VIBRATION',
-            242: 'HOME_POSITION',
-            243: 'SET_HOME_POSITION',
-            244: 'MESSAGE_INTERVAL',
-            245: 'EXTENDED_SYS_STATE',
-            246: 'ADSB_VEHICLE',
-            247: 'COLLISION',
-            248: 'V2_EXTENSION',
-            249: 'MEMORY_VECT',
-            250: 'DEBUG_VECT',
-            251: 'NAMED_VALUE_FLOAT',
-            252: 'NAMED_VALUE_INT',
-            253: 'STATUSTEXT',
-            254: 'DEBUG',
-            256: 'SETUP_SIGNING',
-            257: 'BUTTON_CHANGE',
-            258: 'PLAY_TUNE',
-            259: 'CAMERA_INFORMATION',
-            260: 'CAMERA_SETTINGS',
-            261: 'STORAGE_INFORMATION',
-            262: 'CAMERA_CAPTURE_STATUS',
-            263: 'CAMERA_IMAGE_CAPTURED',
-            264: 'FLIGHT_INFORMATION',
-            265: 'MOUNT_ORIENTATION',
-            266: 'LOGGING_DATA',
-            267: 'LOGGING_DATA_ACKED',
-            268: 'LOGGING_ACK',
-            269: 'VIDEO_STREAM_INFORMATION',
-            270: 'VIDEO_STREAM_STATUS',
-            299: 'WIFI_CONFIG_AP'
-        };
-        return messageNames[messageId] || `UNKNOWN_${messageId}`;
+    static async createWithGeneratedDefinitions() {
+        const decoder = new MAVLinkMessageDecoder();
+        await decoder.initializeFromGeneratedDefinitions();
+        return decoder;
     }
 }
 exports.MAVLinkMessageDecoder = MAVLinkMessageDecoder;