Cancel
diff --git a/js/libraries/bluetooth-device-chooser/bt-device-chooser-renderer.js b/js/libraries/bluetooth-device-chooser/bt-device-chooser-renderer.js
index 8bda39a6c..60ac0d664 100644
--- a/js/libraries/bluetooth-device-chooser/bt-device-chooser-renderer.js
+++ b/js/libraries/bluetooth-device-chooser/bt-device-chooser-renderer.js
@@ -1,25 +1,71 @@
import './bt-device-chooser-style.css'
document.addEventListener("DOMContentLoaded", () => {
- window.electronAPI.bleScan(data => {
- data.forEach(device => {
- var dev = document.getElementById(device.deviceId)
- if (dev) {
- dev.parentElement.removeChild(dev);
- }
- var item = document.createElement('div');
- item.className = 'item'
+ // Store all discovered devices
+ const devices = new Map();
+
+ // Get DOM elements
+ const searchInput = document.getElementById('search');
+ const listElement = document.getElementById('list');
+ const cancelElement = document.getElementById('cancel');
+
+ // Render devices in sorted and filtered order
+ function renderDevices() {
+ const searchText = searchInput.value.toLowerCase().trim();
+
+ // Get all devices except cancel button
+ const existingDevices = Array.from(listElement.querySelectorAll('.item:not(#cancel)'));
+ existingDevices.forEach(el => el.remove());
+
+ // Sort devices alphabetically by name
+ const sortedDevices = Array.from(devices.values()).sort((a, b) => {
+ return a.deviceName.localeCompare(b.deviceName);
+ });
+
+ // Filter devices based on search text
+ const filteredDevices = sortedDevices.filter(device => {
+ if (!searchText) return true;
+ const deviceText = `${device.deviceName} ${device.deviceId}`.toLowerCase();
+ return deviceText.includes(searchText);
+ });
+
+ // Render filtered and sorted devices
+ filteredDevices.forEach(device => {
+ const item = document.createElement('div');
+ item.className = 'item';
item.id = device.deviceId;
item.addEventListener('click', () => {
window.electronAPI.deviceSelected(item.id);
window.close();
});
- var text = device.deviceName + ' (' + device.deviceId + ')';
- item.appendChild(document.createTextNode(text.length > 45 ? device.deviceName.substring(0, 45) : text.substring(0, 45)));
- document.getElementById('list').prepend(item);
+ const MAX_DEVICE_NAME_LENGTH = 45;
+ const text = `${device.deviceName} (${device.deviceId})`;
+ const displayText = text.length > MAX_DEVICE_NAME_LENGTH ? text.substring(0, MAX_DEVICE_NAME_LENGTH) : text;
+ item.appendChild(document.createTextNode(displayText));
+
+ // Insert before cancel button to keep it at the bottom
+ listElement.insertBefore(item, cancelElement);
});
+ }
+
+ // Handle search input changes
+ searchInput.addEventListener('input', () => {
+ renderDevices();
});
- document.getElementById('cancel').addEventListener('click', () => {
+
+ // Handle device scan updates
+ window.electronAPI.bleScan(data => {
+ data.forEach(device => {
+ devices.set(device.deviceId, device);
+ });
+ renderDevices();
+ });
+
+ // Handle cancel button
+ cancelElement.addEventListener('click', () => {
window.close();
});
+
+ // Initial render (in case devices were already discovered)
+ renderDevices();
});
diff --git a/js/libraries/bluetooth-device-chooser/bt-device-chooser-style.css b/js/libraries/bluetooth-device-chooser/bt-device-chooser-style.css
index c2e7af3e8..440dcbc31 100644
--- a/js/libraries/bluetooth-device-chooser/bt-device-chooser-style.css
+++ b/js/libraries/bluetooth-device-chooser/bt-device-chooser-style.css
@@ -10,10 +10,28 @@ h1 {
color: white;
}
-#id {
+#search {
+ width: 345px;
+ padding: 10px;
margin: 5px;
+ font-size: 14px;
+ border: 1px solid whitesmoke;
+ background-color: #1a1a1a;
+ color: white;
+ box-sizing: border-box;
+}
+
+#search::placeholder {
+ color: #888;
}
+#search:focus {
+ outline: none;
+ border-color: rgb(88, 88, 192);
+ background-color: #2a2a2a;
+}
+
+
#list {
color: white;
}
@@ -21,9 +39,6 @@ h1 {
.item {
margin: 5px;
padding: 5px;
- height: 40px;
- line-height: 40px;
- width: 345px;
display: inline-block;
vertical-align: middle;
border: 1px solid whitesmoke;
@@ -35,4 +50,5 @@ h1 {
#cancel {
text-align: center;
+ display: block;
}
diff --git a/js/main/main.js b/js/main/main.js
index 34faa50a8..ae6ead9c2 100644
--- a/js/main/main.js
+++ b/js/main/main.js
@@ -64,7 +64,7 @@ function createDeviceChooser() {
bluetoothDeviceChooser = new BrowserWindow({
parent: mainWindow,
width: 410,
- height: 400,
+ height: 600,
webPreferences: {
preload: path.join(__dirname, 'bt-device-chooser-preload.mjs'),
}
@@ -280,8 +280,35 @@ app.whenReady().then(() => {
return dialog.showOpenDialog(options);
}),
- ipcMain.handle('dialog.showSaveDialog', (_event, options) => {
- return dialog.showSaveDialog(options);
+ ipcMain.handle('dialog.showSaveDialog', async (_event, options) => {
+ const opts = options || {};
+ const LAST_SAVE_DIRECTORY_KEY = 'lastSaveDirectory';
+
+ // Get the last save directory from store
+ const lastDirectory = store.get(LAST_SAVE_DIRECTORY_KEY, null);
+
+ // If we have a last directory, combine it with the filename if one was provided
+ if (lastDirectory && opts.defaultPath) {
+ // If defaultPath is just a filename (no directory), prepend the last directory
+ if (!path.dirname(opts.defaultPath) || path.dirname(opts.defaultPath) === '.') {
+ opts.defaultPath = path.join(lastDirectory, opts.defaultPath);
+ }
+ } else if (lastDirectory && !opts.defaultPath) {
+ // No filename provided, just use the directory
+ opts.defaultPath = lastDirectory;
+ }
+
+ // Show the save dialog
+ const result = await dialog.showSaveDialog(opts);
+
+ // If user selected a file (didn't cancel), save the directory for next time
+ if (result && result.filePath && !result.canceled) {
+ // Extract directory from the full file path (path already imported at top)
+ const directory = path.dirname(result.filePath);
+ store.set(LAST_SAVE_DIRECTORY_KEY, directory);
+ }
+
+ return result;
}),
ipcMain.on('dialog.alert', (event, message) => {
diff --git a/js/msp/MSPHelper.js b/js/msp/MSPHelper.js
index 2cc00953d..cb03e98db 100644
--- a/js/msp/MSPHelper.js
+++ b/js/msp/MSPHelper.js
@@ -198,6 +198,12 @@ var mspHelper = (function () {
FC.GPS_DATA.hdop = data.getUint16(14, true);
FC.GPS_DATA.eph = data.getUint16(16, true);
FC.GPS_DATA.epv = data.getUint16(18, true);
+ // Check if hwVersion field exists (firmware with extended MSP_GPSSTATISTICS)
+ if (data.byteLength >= 24) {
+ FC.GPS_DATA.hwVersion = data.getUint32(20, true);
+ } else {
+ FC.GPS_DATA.hwVersion = 0; // Unknown for older firmware
+ }
break;
case MSPCodes.MSP2_ADSB_VEHICLE_LIST:
var byteOffsetCounter = 0;
diff --git a/js/serial_backend.js b/js/serial_backend.js
index 3c7f4486a..d2e8a4741 100755
--- a/js/serial_backend.js
+++ b/js/serial_backend.js
@@ -345,7 +345,7 @@ var SerialBackend = (function () {
privateScope.onOpen = function (openInfo) {
if (FC.restartRequired) {
- GUI_control.prototype.log("" + i18n.getMessage("illegalStateRestartRequired") + " " + i18n.getMessage("illegalStateRestartRequired") + " " + i18n.getMessage("illegalStateRestartRequired") + " " + i18n.getMessage("illegalStateRestartRequired") + " } lcStatus - Array of LC status values (0=FALSE, non-zero=TRUE)
+ * @param {Array} lcConditions - Array of LC condition objects
+ * @param {Object} lcToLineMapping - Map of LC index to editor line number
+ * @returns {Object} { trueLCs: number[], falseLCs: number[] }
+ */
+export function categorizeLCsByStatus(lcStatus, lcConditions, lcToLineMapping) {
+ const trueLCs = [];
+ const falseLCs = [];
+
+ for (let lcIndex = 0; lcIndex < lcStatus.length; lcIndex++) {
+ const status = lcStatus[lcIndex];
+ const condition = lcConditions[lcIndex];
+
+ // Only process enabled LCs that are in our mapping (i.e., visible in the editor)
+ if (condition && condition.getEnabled && condition.getEnabled() !== 0 && lcToLineMapping[lcIndex] !== undefined) {
+ if (status !== 0) {
+ trueLCs.push(lcIndex);
+ } else {
+ falseLCs.push(lcIndex);
+ }
+ }
+ }
+
+ return { trueLCs, falseLCs };
+}
+
+/**
+ * Map LC indices to editor line numbers with their combined status
+ *
+ * Handles cases where multiple LCs map to the same line (shows "mixed" if both TRUE and FALSE exist)
+ *
+ * @param {number[]} trueLCs - Array of TRUE LC indices
+ * @param {number[]} falseLCs - Array of FALSE LC indices
+ * @param {Object} lcToLineMapping - Map of LC index to editor line number
+ * @returns {Object} Map of line number to status ('true'|'false'|'mixed')
+ */
+export function mapLCsToLines(trueLCs, falseLCs, lcToLineMapping) {
+ const lineStatus = {}; // { lineNum: 'true'|'false'|'mixed' }
+
+ // Process TRUE LCs
+ for (const lcIndex of trueLCs) {
+ const line = lcToLineMapping[lcIndex];
+ if (line !== undefined) {
+ if (lineStatus[line] === 'false') {
+ lineStatus[line] = 'mixed'; // Both true and false LCs on same line
+ } else if (lineStatus[line] !== 'mixed') {
+ lineStatus[line] = 'true';
+ }
+ }
+ }
+
+ // Process FALSE LCs
+ for (const lcIndex of falseLCs) {
+ const line = lcToLineMapping[lcIndex];
+ if (line !== undefined) {
+ if (lineStatus[line] === 'true') {
+ lineStatus[line] = 'mixed'; // Both true and false LCs on same line
+ } else if (lineStatus[line] !== 'mixed') {
+ lineStatus[line] = 'false';
+ }
+ }
+ }
+
+ return lineStatus;
+}
+
+/**
+ * Create Monaco editor decorations from line status
+ *
+ * @param {Object} lineStatus - Map of line number to status ('true'|'false'|'mixed')
+ * @param {Object} monaco - Monaco editor instance (passed from caller)
+ * @returns {Array} Array of Monaco decoration objects
+ */
+export function createMonacoDecorations(lineStatus, monaco) {
+ return Object.entries(lineStatus).map(([lineNum, status]) => {
+ // For mixed status, show green checkmark (at least one condition is true)
+ const className = (status === 'true' || status === 'mixed') ? 'lc-active-true' : 'lc-active-false';
+ const message = status === 'mixed'
+ ? 'Multiple logic conditions: at least one is TRUE'
+ : (status === 'true' ? 'Logic condition is TRUE' : 'Logic condition is FALSE');
+
+ return {
+ range: new monaco.Range(parseInt(lineNum), 1, parseInt(lineNum), 1),
+ options: {
+ glyphMarginClassName: className,
+ glyphMarginHoverMessage: {
+ value: message
+ }
+ }
+ };
+ });
+}
+
+/**
+ * Apply decorations to Monaco editor
+ *
+ * @param {Object} editor - Monaco editor instance
+ * @param {Array} currentDecorations - Current decoration IDs
+ * @param {Array} newDecorations - New decorations to apply
+ * @returns {Array} Updated decoration IDs
+ */
+export function applyDecorations(editor, currentDecorations, newDecorations) {
+ if (!editor || !editor.deltaDecorations) {
+ return currentDecorations || [];
+ }
+
+ return editor.deltaDecorations(
+ currentDecorations || [],
+ newDecorations
+ );
+}
+
+/**
+ * Clear all decorations from Monaco editor
+ *
+ * @param {Object} editor - Monaco editor instance
+ * @param {Array} currentDecorations - Current decoration IDs to clear
+ * @returns {Array} Empty array (no decorations)
+ */
+export function clearDecorations(editor, currentDecorations) {
+ if (!editor || !editor.deltaDecorations || !currentDecorations) {
+ return [];
+ }
+
+ return editor.deltaDecorations(currentDecorations, []);
+}
diff --git a/js/transpiler/transpiler/action_decompiler.js b/js/transpiler/transpiler/action_decompiler.js
index aa2ebc788..3a51ce3da 100644
--- a/js/transpiler/transpiler/action_decompiler.js
+++ b/js/transpiler/transpiler/action_decompiler.js
@@ -51,14 +51,60 @@ class ActionDecompiler {
return this.handleOverrideThrottle(lc, allConditions);
}
+ // Operations that only use operandA (operandB is unused/ignored)
+ // These should not decompile operandB to avoid incorrect validation warnings
+ const operandAOnlyOperations = [
+ OPERATION.SET_VTX_POWER_LEVEL,
+ OPERATION.SET_VTX_BAND,
+ OPERATION.SET_VTX_CHANNEL,
+ OPERATION.SET_OSD_LAYOUT,
+ OPERATION.LOITER_OVERRIDE,
+ OPERATION.OVERRIDE_MIN_GROUND_SPEED,
+ OPERATION.SET_HEADING_TARGET,
+ OPERATION.SET_PROFILE,
+ OPERATION.SET_GIMBAL_SENSITIVITY
+ ];
+
+ // Operations that use no operands (boolean flags only)
+ const noOperandOperations = [
+ OPERATION.OVERRIDE_ARMING_SAFETY,
+ OPERATION.SWAP_ROLL_YAW,
+ OPERATION.INVERT_ROLL,
+ OPERATION.INVERT_PITCH,
+ OPERATION.INVERT_YAW,
+ OPERATION.DISABLE_GPS_FIX,
+ OPERATION.RESET_MAG_CALIBRATION
+ ];
+
// INAV operand pattern (confirmed by logic_condition.c):
- // - Most overrides: operandA = value, operandB = 0
+ // - Most overrides: operandA = value, operandB = 0 (unused)
// - GVAR_INC/DEC: operandA = gvar index, operandB = increment/decrement
// - FLIGHT_AXIS: operandA = axis index, operandB = angle/rate
// - RC_CHANNEL: operandA = channel, operandB = value
// - PORT_SET: operandA = pin, operandB = value
- const valueA = this.decompileOperand(lc.operandAType, lc.operandAValue, allConditions);
- const valueB = this.decompileOperand(lc.operandBType, lc.operandBValue, allConditions);
+
+ // Warn about unexpected operands (version detection for new firmware features)
+ if (noOperandOperations.includes(lc.operation)) {
+ if (lc.operandAType !== 0 || lc.operandAValue !== 0) {
+ this.addWarning(`Unexpected operand A to ${getOperationName(lc.operation)} operation (type=${lc.operandAType}, value=${lc.operandAValue}). This may indicate a firmware version mismatch.`);
+ }
+ if (lc.operandBType !== 0 || lc.operandBValue !== 0) {
+ this.addWarning(`Unexpected operand B to ${getOperationName(lc.operation)} operation (type=${lc.operandBType}, value=${lc.operandBValue}). This may indicate a firmware version mismatch.`);
+ }
+ } else if (operandAOnlyOperations.includes(lc.operation)) {
+ if (lc.operandBType !== 0 || lc.operandBValue !== 0) {
+ this.addWarning(`Unexpected operand B to ${getOperationName(lc.operation)} operation (type=${lc.operandBType}, value=${lc.operandBValue}). This may indicate a firmware version mismatch.`);
+ }
+ }
+
+ // Only decompile operands that are actually used by the operation
+ // This prevents incorrect validation warnings (e.g., PID range check on unused operands)
+ const valueA = noOperandOperations.includes(lc.operation)
+ ? null
+ : this.decompileOperand(lc.operandAType, lc.operandAValue, allConditions);
+ const valueB = (operandAOnlyOperations.includes(lc.operation) || noOperandOperations.includes(lc.operation))
+ ? null
+ : this.decompileOperand(lc.operandBType, lc.operandBValue, allConditions);
switch (lc.operation) {
// GVAR operations: operandA = index, operandB = value
diff --git a/js/transpiler/transpiler/activator_hoisting.js b/js/transpiler/transpiler/activator_hoisting.js
index f57ce8eba..3635989c5 100644
--- a/js/transpiler/transpiler/activator_hoisting.js
+++ b/js/transpiler/transpiler/activator_hoisting.js
@@ -1,11 +1,30 @@
/**
- * INAV Activator Hoisting Module
+ * INAV Logic Condition Hoisting Manager
*
- * Location: js/transpiler/transpiler/activator_hoisting.js
+ * Extracts complex or multiply-referenced expressions into named const variables
+ * to improve readability and avoid redundancy in decompiled JavaScript.
*
- * Identifies LCs with activators that should be hoisted to variables.
- * LCs with activators that are referenced as operands are extracted to const declarations
- * so the activator relationship is preserved and the code is more readable.
+ * Hoisting Criteria (all must be true):
+ * - Referenced as operand by other LCs
+ * - Complex (arithmetic, math, logic) OR multiply-referenced (used >1 times)
+ * - Not a stateful operation (STICKY, TIMER, DELAY, EDGE)
+ * - Not an action (GVAR_SET, overrides, etc.)
+ * - Not reading from GVARs that are written elsewhere
+ *
+ * GVAR Dependency Tracking:
+ * Prevents hoisting expressions that read from GVARs before those GVARs are written,
+ * which would cause the hoisted expression to use OLD values instead of NEW values.
+ * If a GVAR is only read (never written), hoisting is safe.
+ *
+ * Execution Order Preservation:
+ * - Hoisted variables emitted in LC index order (matches firmware evaluation order)
+ * - Activator scoping: variables hoisted to global or inside stateful operation blocks
+ * - LC operands always resolve correctly due to index-ordered declaration
+ *
+ * Example:
+ * const cond1 = Math.min(1000, gvar[5] * 100); // Complex, referenced 2x
+ * if (trigger) { doA(cond1); }
+ * if (other) { doB(cond1); }
*/
'use strict';
@@ -28,7 +47,78 @@ export class ActivatorHoistingManager {
}
/**
- * Check if an LC's activator chain contains STICKY/TIMER operations
+ * Find which GVARs are being written by ANY enabled LC
+ * These are GVARs that could cause read-after-write dependencies if hoisted
+ * @param {Array} conditions - All logic conditions
+ * @returns {Set} Set of GVAR indices that are written
+ */
+ findWrittenGvars(conditions) {
+ const writtenGvars = new Set();
+ const OPERATION_GVAR_SET = 18; // From inav_constants.js
+
+ for (const lc of conditions) {
+ if (lc._gap) continue;
+ if (!lc.enabled) continue; // Skip disabled LCs
+
+ // Check if this is a GVAR_SET operation (regardless of activatorId)
+ // Even if the write is conditional (has activator), we still need to track it
+ // because hoisting a read BEFORE a conditional write breaks execution order
+ if (lc.operation === OPERATION_GVAR_SET) {
+ // operandAValue is the GVAR index being written
+ writtenGvars.add(lc.operandAValue);
+ }
+ }
+
+ return writtenGvars;
+ }
+
+ /**
+ * Check if an LC reads from any GVAR that is written at root level
+ * Only prevent hoisting if reading from a GVAR that is actually being set
+ * @param {Object} lc - Logic condition to check
+ * @param {Array} conditions - All conditions (for recursive LC operand checks)
+ * @param {Set} writtenGvars - Set of GVAR indices that are written at root level
+ * @param {Set} visited - Set of visited LC indices to prevent infinite recursion
+ * @returns {boolean} True if this LC reads from a GVAR that is written
+ */
+ readsFromWrittenGvar(lc, conditions, writtenGvars, visited = new Set()) {
+ if (!lc) return false;
+
+ // Prevent infinite recursion on circular LC references
+ if (visited.has(lc.index)) return false;
+ visited.add(lc.index);
+
+ const OPERAND_TYPE_GVAR = 5; // From inav_constants.js
+ const OPERAND_TYPE_LC = 4;
+
+ // Direct GVAR read - check if it's a GVAR that's being written
+ if (lc.operandAType === OPERAND_TYPE_GVAR && writtenGvars.has(lc.operandAValue)) {
+ return true;
+ }
+ if (lc.operandBType === OPERAND_TYPE_GVAR && writtenGvars.has(lc.operandBValue)) {
+ return true;
+ }
+
+ // Recursive check: if operand is another LC, check if that LC reads from written GVAR
+ // This handles cases like: LC_A uses LC_B as operand, and LC_B reads from a written GVAR
+ if (lc.operandAType === OPERAND_TYPE_LC) {
+ const refLc = conditions.find(c => c.index === lc.operandAValue);
+ if (refLc && this.readsFromWrittenGvar(refLc, conditions, writtenGvars, visited)) {
+ return true;
+ }
+ }
+ if (lc.operandBType === OPERAND_TYPE_LC) {
+ const refLc = conditions.find(c => c.index === lc.operandBValue);
+ if (refLc && this.readsFromWrittenGvar(refLc, conditions, writtenGvars, visited)) {
+ return true;
+ }
+ }
+
+ return false;
+ }
+
+ /**
+ * Check if an LC's activator chain contains stateful operations (STICKY/TIMER/DELAY/EDGE)
* These need late binding and shouldn't be hoisted
*/
activatorChainHasSticky(lcIndex, conditions, visited = new Set()) {
@@ -41,7 +131,10 @@ export class ActivatorHoistingManager {
const activator = conditions.find(c => c.index === lc.activatorId);
if (!activator) return false;
- if (activator.operation === OPERATION.STICKY || activator.operation === OPERATION.TIMER) {
+ if (activator.operation === OPERATION.STICKY ||
+ activator.operation === OPERATION.TIMER ||
+ activator.operation === OPERATION.DELAY ||
+ activator.operation === OPERATION.EDGE) {
return true;
}
@@ -61,13 +154,26 @@ export class ActivatorHoistingManager {
this.hoistedActivatorVars.clear();
let condVarCount = 1;
+ // First pass: identify which GVARs are being written by root-level LCs
+ const writtenGvars = this.findWrittenGvars(conditions);
+
for (const lc of conditions) {
if (lc._gap) continue;
- // Skip actions, sticky, and timer operations
+ // Skip actions and stateful operations (STICKY, TIMER, DELAY, EDGE)
+ // These operations maintain state across loop iterations and should not be hoisted
if (this.isActionOperation(lc.operation) ||
lc.operation === OPERATION.STICKY ||
- lc.operation === OPERATION.TIMER) {
+ lc.operation === OPERATION.TIMER ||
+ lc.operation === OPERATION.DELAY ||
+ lc.operation === OPERATION.EDGE) {
+ continue;
+ }
+
+ // Skip LCs that read from GVARs that are written by root-level LCs
+ // Hoisting these would cause them to use OLD GVAR values instead of NEW values.
+ // But if a GVAR is only READ (never written), hoisting is safe.
+ if (this.readsFromWrittenGvar(lc, conditions, writtenGvars)) {
continue;
}
@@ -108,7 +214,7 @@ export class ActivatorHoistingManager {
// - Arithmetic: ADD, SUB, MUL, DIV, MOD
// - Math functions: MIN, MAX, ABS
// - Logic: AND, OR, XOR, NAND, NOR, NOT
- // - Stateful: EDGE (transitions), STICKY/TIMER (if referenced as operands)
+ // Note: EDGE, STICKY, TIMER, DELAY are stateful and excluded separately in identifyHoistedVars()
const complexOps = [
OPERATION.ADD, // 14
OPERATION.SUB, // 15
@@ -124,18 +230,17 @@ export class ActivatorHoistingManager {
OPERATION.NOR, // 11
OPERATION.NOT, // 12
OPERATION.MOD, // 19
- OPERATION.EDGE, // 47 - stateful, activator relationship important
];
return complexOps.includes(operation);
}
/**
- * Find the first STICKY/TIMER in an LC's activator chain
+ * Find the first stateful operation (STICKY/TIMER/DELAY/EDGE) in an LC's activator chain
* This determines the scope where the variable should be hoisted
* @param {number} lcIndex - LC index to check
* @param {Array} conditions - All conditions
- * @returns {number} LC index of the STICKY/TIMER scope, or -1 for global scope
+ * @returns {number} LC index of the stateful operation scope, or -1 for global scope
*/
findStickyInActivatorChain(lcIndex, conditions, visited = new Set()) {
if (visited.has(lcIndex)) return -1;
@@ -147,8 +252,11 @@ export class ActivatorHoistingManager {
const activator = conditions.find(c => c.index === lc.activatorId);
if (!activator) return -1;
- // If activator is STICKY/TIMER, that's our scope
- if (activator.operation === OPERATION.STICKY || activator.operation === OPERATION.TIMER) {
+ // If activator is stateful (STICKY/TIMER/DELAY/EDGE), that's our scope
+ if (activator.operation === OPERATION.STICKY ||
+ activator.operation === OPERATION.TIMER ||
+ activator.operation === OPERATION.DELAY ||
+ activator.operation === OPERATION.EDGE) {
return activator.index;
}
diff --git a/js/transpiler/transpiler/codegen.js b/js/transpiler/transpiler/codegen.js
index f9df21f06..27859f974 100644
--- a/js/transpiler/transpiler/codegen.js
+++ b/js/transpiler/transpiler/codegen.js
@@ -68,6 +68,9 @@ class INAVCodeGenerator {
constructor(variableHandler = null) {
this.lcIndex = 0; // Current logic condition index
this.commands = [];
+ this.lcToLineMapping = {}; // Map LC index -> source line number for highlighting
+ this.currentSourceLine = null; // Current source line being processed (for line tracking)
+ this.lineOffset = 0; // Line offset from auto-added imports (set by transpiler)
this.errorHandler = new ErrorHandler(); // Error and warning collection
this.operandMapping = buildForwardMapping(apiDefinitions);
this.arrowHelper = new ArrowFunctionHelper(this);
@@ -150,28 +153,42 @@ class INAVCodeGenerator {
*/
generateStatement(stmt) {
if (!stmt) return;
- switch (stmt.type) {
- case 'EventHandler':
- this.generateEventHandler(stmt);
- break;
- case 'Assignment':
- // Top-level assignment (e.g., gvar[0] = value) - runs unconditionally
- this.generateTopLevelAssignment(stmt);
- break;
- case 'StickyAssignment':
- // latch1 = sticky({on: ..., off: ...})
- this.generateStickyAssignment(stmt);
- break;
- case 'LetDeclaration':
- case 'VarDeclaration':
- // Skip - declarations handled separately
- break;
- default:
- this.errorHandler.addError(
- `Unsupported statement type: ${stmt.type}. Only assignments and event handlers are supported`,
- stmt,
- 'unsupported_statement'
- );
+
+ // Set current source line for LC-to-line tracking
+ const previousSourceLine = this.currentSourceLine;
+ if (stmt.loc && stmt.loc.start) {
+ // Acorn line numbers include auto-added import lines at the top
+ // Subtract lineOffset to match Monaco editor line numbers
+ this.currentSourceLine = stmt.loc.start.line - this.lineOffset;
+ }
+
+ try {
+ switch (stmt.type) {
+ case 'EventHandler':
+ this.generateEventHandler(stmt);
+ break;
+ case 'Assignment':
+ // Top-level assignment (e.g., gvar[0] = value) - runs unconditionally
+ this.generateTopLevelAssignment(stmt);
+ break;
+ case 'StickyAssignment':
+ // latch1 = sticky({on: ..., off: ...})
+ this.generateStickyAssignment(stmt);
+ break;
+ case 'LetDeclaration':
+ case 'VarDeclaration':
+ // Skip - declarations handled separately
+ break;
+ default:
+ this.errorHandler.addError(
+ `Unsupported statement type: ${stmt.type}. Only assignments and event handlers are supported`,
+ stmt,
+ 'unsupported_statement'
+ );
+ }
+ } finally {
+ // Restore previous source line context
+ this.currentSourceLine = previousSourceLine;
}
}
@@ -248,6 +265,12 @@ class INAVCodeGenerator {
this.commands.push(
`logic ${lcIndex} 1 ${activatorId} ${operation} ${operandA.type} ${operandA.value} ${operandB.type} ${operandB.value} ${flags}`
);
+
+ // Track source line mapping for transpiler-side highlighting
+ if (this.currentSourceLine !== null) {
+ this.lcToLineMapping[lcIndex] = this.currentSourceLine;
+ }
+
this.lcIndex++;
return lcIndex;
}
diff --git a/js/transpiler/transpiler/decompiler.js b/js/transpiler/transpiler/decompiler.js
index 6bf6f6fff..a674515fa 100644
--- a/js/transpiler/transpiler/decompiler.js
+++ b/js/transpiler/transpiler/decompiler.js
@@ -195,6 +195,8 @@ class Decompiler {
// Note: All INAV objects are always imported for user convenience
this.inlineDeclaredVars = new Set(); // Track let variables declared inline in body
this.hoistedVarCounters = new Map(); // Track counters for hoisted variable names (e.g., min, min2, min3)
+ this.lcToLineMapping = {}; // Track which LC maps to which line in final JavaScript (for active LC highlighting)
+ this._tempLcLines = []; // Temporary storage: [{lcIndex, relativeLineOffset}] during generation
// Create hoisting manager for activator-wrapped LCs
this.hoistingManager = new ActivatorHoistingManager({
@@ -235,6 +237,7 @@ class Decompiler {
return {
success: true,
code: this.generateBoilerplate('// No logic conditions found'),
+ lcToLineMapping: {},
warnings: this.warnings,
stats: { total: logicConditions.length, enabled: 0, groups: 0 }
};
@@ -248,9 +251,14 @@ class Decompiler {
// Apply custom variable names from variable map as a final rename pass
code = this.applyCustomVariableNames(code, enabled);
+ // Build LC-to-line mapping for active highlighting feature
+ // Convert tracked lines to actual line numbers in the final code
+ this.finalizeLcLineMapping(code, enabled);
+
return {
success: true,
code,
+ lcToLineMapping: this.lcToLineMapping,
warnings: this.warnings,
stats: {
total: logicConditions.length,
@@ -549,6 +557,11 @@ class Decompiler {
* @returns {string} JavaScript code
*/
decompileTree(node, allConditions, indent = 0) {
+ // Defensive check: ensure node has required properties
+ if (!node?.lc || !Array.isArray(node.children)) {
+ return '';
+ }
+
const indentStr = ' '.repeat(indent);
const lines = [];
@@ -608,8 +621,16 @@ class Decompiler {
const condition = hoistedVarName || this.decompileCondition(node.lc, allConditions);
if (node.children.length === 0) {
- // Condition with no children - skip it (it's a helper used elsewhere)
- return '';
+ // Only skip if this is a helper condition that can't be externally referenced
+ // Conditions that could be externally referenced (e.g., via Global Functions, OSD)
+ // should still be rendered even if they have no children
+ if (!this.couldBeExternallyReferenced(node.lc.operation)) {
+ return '';
+ }
+ // Render empty if block with comment for external reference
+ lines.push(indentStr + `if (${condition}) {`);
+ lines.push(indentStr + ` /* LC ${node.lc.index}: for external reference */`);
+ lines.push(indentStr + '}');
} else {
// Separate children into: actions, boolean conditions (same level), nested conditions
const actions = [];
@@ -642,7 +663,11 @@ class Decompiler {
}
// Build if statement
- lines.push(indentStr + `if (${condition}) {`);
+ const ifLine = indentStr + `if (${condition}) {`;
+ lines.push(ifLine);
+
+ // Track this LC for line mapping (we'll calculate actual line numbers after boilerplate is added)
+ this._tempLcLines.push({ lcIndex: node.lc.index, lineContent: ifLine });
// First, output any actions at this level
for (const actionNode of actions) {
@@ -1168,6 +1193,126 @@ class Decompiler {
return declarations;
}
+ /**
+ * Build mapping from LC indices to line numbers in the generated code
+ * This enables real-time highlighting of active logic conditions in JavaScript Programming tab
+ *
+ * For compound conditions like "if (a && b)", multiple LCs map to the same line:
+ * - LC#0 (a) → line N
+ * - LC#1 (b) → line N
+ * - LC#2 (AND(0,1)) → line N
+ * This is correct: when any of them is true, we highlight line N.
+ *
+ * @param {string} code - Final generated JavaScript code
+ * @param {Array} conditions - Enabled logic conditions
+ */
+ /**
+ * Finalize LC-to-line mapping after code generation
+ * Converts tracked LC lines to actual line numbers in final code
+ * @param {string} code - Final generated code with boilerplate
+ * @param {Array} conditions - All logic conditions
+ */
+ finalizeLcLineMapping(code, conditions) {
+ const lines = code.split('\n');
+
+ console.log('[Decompiler] finalizeLcLineMapping - tracked lines:', this._tempLcLines);
+ console.log('[Decompiler] finalizeLcLineMapping - total code lines:', lines.length);
+
+ // First pass: Find tracked if-statements in the final code
+ const usedLines = new Set();
+ for (const tracked of this._tempLcLines) {
+ const { lcIndex, lineContent } = tracked;
+
+ console.log(`[Decompiler] Looking for LC${lcIndex}:`, lineContent.trim());
+
+ // Find this line content in the final code, skipping lines already claimed by a previous LC
+ for (let lineIdx = 0; lineIdx < lines.length; lineIdx++) {
+ if (usedLines.has(lineIdx)) continue;
+ if (lines[lineIdx].trim() === lineContent.trim()) {
+ this.lcToLineMapping[lcIndex] = lineIdx + 1; // Monaco uses 1-based line numbers
+ usedLines.add(lineIdx);
+ console.log(`[Decompiler] Found LC${lcIndex} at line ${lineIdx + 1}`);
+ break;
+ }
+ }
+
+ if (!this.lcToLineMapping[lcIndex]) {
+ console.warn(`[Decompiler] Could not find LC${lcIndex} in final code`);
+ }
+ }
+
+ console.log('[Decompiler] Final mapping:', this.lcToLineMapping);
+
+ // Second pass: Handle hoisted variables (const declarations)
+ for (const lc of conditions) {
+ if (lc._gap) continue;
+
+ const hoistedVarName = this.hoistingManager?.getHoistedVarName(lc.index);
+ if (hoistedVarName && !this.lcToLineMapping[lc.index]) {
+ for (let lineIdx = 0; lineIdx < lines.length; lineIdx++) {
+ const line = lines[lineIdx];
+ if (line.match(new RegExp(`const\\s+${hoistedVarName}\\s*=`))) {
+ this.lcToLineMapping[lc.index] = lineIdx + 1;
+ break;
+ }
+ }
+ }
+ }
+
+ // Third pass: Handle sticky/timer variables
+ for (const lc of conditions) {
+ if (lc._gap) continue;
+
+ if ((lc.operation === OPERATION.STICKY || lc.operation === OPERATION.TIMER) && !this.lcToLineMapping[lc.index]) {
+ const varName = this.stickyVarNames.get(lc.index);
+ if (varName) {
+ for (let lineIdx = 0; lineIdx < lines.length; lineIdx++) {
+ const line = lines[lineIdx];
+ if (line.match(new RegExp(`${varName}\\s*=\\s*(?:sticky|timer)`))) {
+ this.lcToLineMapping[lc.index] = lineIdx + 1;
+ break;
+ }
+ }
+ }
+ }
+ }
+
+ // Fourth pass: Map LCs based on activator relationships
+ // For LCs with activators (child conditions/actions), inherit the activator's line
+ for (const lc of conditions) {
+ if (lc._gap) continue;
+
+ if (lc.activatorId !== -1 && !this.lcToLineMapping[lc.index]) {
+ const activatorLine = this.lcToLineMapping[lc.activatorId];
+ if (activatorLine) {
+ this.lcToLineMapping[lc.index] = activatorLine;
+ }
+ }
+ }
+
+ // Fifth pass: Handle LCs that are operands of other LCs (compound conditions)
+ // For example, in "if (a && b)", LC#0 (a) and LC#1 (b) are operands of parent LC
+ for (const lc of conditions) {
+ if (lc._gap) continue;
+
+ const operandLCs = [];
+ if (lc.operandAType === OPERAND_TYPE.LC) {
+ operandLCs.push(lc.operandAValue);
+ }
+ if (lc.operandBType === OPERAND_TYPE.LC) {
+ operandLCs.push(lc.operandBValue);
+ }
+
+ if (this.lcToLineMapping[lc.index]) {
+ for (const operandLcIndex of operandLCs) {
+ if (!this.lcToLineMapping[operandLcIndex]) {
+ this.lcToLineMapping[operandLcIndex] = this.lcToLineMapping[lc.index];
+ }
+ }
+ }
+ }
+ }
+
/**
* Generate boilerplate code with proper formatting
* @param {string} body - Main code body
diff --git a/js/transpiler/transpiler/index.js b/js/transpiler/transpiler/index.js
index cacdf4631..84ad741fc 100644
--- a/js/transpiler/transpiler/index.js
+++ b/js/transpiler/transpiler/index.js
@@ -115,8 +115,9 @@ class Transpiler {
const optimized = this.optimize(analyzed.ast);
// Step 4: Generate INAV CLI commands
- // Pass the analyzer's variableHandler to codegen
+ // Pass the analyzer's variableHandler and lineOffset to codegen
this.codegen.variableHandler = this.analyzer.variableHandler;
+ this.codegen.lineOffset = lineOffset;
const commands = this.codegen.generate(optimized);
// Combine all warnings
@@ -153,6 +154,7 @@ class Transpiler {
success: true,
commands,
logicConditionCount: this.codegen.lcIndex,
+ lcToLineMapping: this.codegen.lcToLineMapping,
warnings: categorized,
optimizations: this.optimizer.getStats(),
gvarUsage: gvarSummary,
diff --git a/js/transpiler/transpiler/tests/debug_const.mjs b/js/transpiler/transpiler/tests/debug_const.mjs
new file mode 100644
index 000000000..a89f9df2b
--- /dev/null
+++ b/js/transpiler/transpiler/tests/debug_const.mjs
@@ -0,0 +1,24 @@
+import { Transpiler } from '../index.js';
+
+const transpiler = new Transpiler();
+const code = `
+const cond3 = flight.activeMixerProfile === 2 ? ((flight.mode.rth === 1 || flight.mode.poshold === 1)) : 0;
+
+if (!cond3) {
+ rc[5] = 1500;
+}
+`;
+
+// Add debug logging to trace the flow
+const originalTranspile = transpiler.transpile.bind(transpiler);
+transpiler.transpile = function(code) {
+ const result = originalTranspile(code);
+ console.log("After transpile, analyzer variableHandler:", [...this.analyzer.variableHandler.symbols.keys()]);
+ console.log("After transpile, codegen variableHandler:", this.codegen.variableHandler ? [...this.codegen.variableHandler.symbols.keys()] : 'undefined');
+ return result;
+};
+
+const result = transpiler.transpile(code);
+console.log("Success:", result.success);
+console.log("Error:", result.error);
+console.log("Commands:", result.commands);
diff --git a/js/transpiler/transpiler/tests/debug_recursion.mjs b/js/transpiler/transpiler/tests/debug_recursion.mjs
new file mode 100644
index 000000000..a57cbf27a
--- /dev/null
+++ b/js/transpiler/transpiler/tests/debug_recursion.mjs
@@ -0,0 +1,19 @@
+import { Transpiler } from '../index.js';
+
+const transpiler = new Transpiler();
+
+// Add recursion tracking for condition_generator.generate
+let depth = 0;
+
+const code = `
+if (approxEqual(rc[11], 2000)) {
+ rc[5] = 1500;
+}
+`;
+
+try {
+ const result = transpiler.transpile(code);
+ console.log("Success:", result.success);
+} catch (e) {
+ console.log("Error:", e.message);
+}
diff --git a/js/transpiler/transpiler/tests/decompiler.test.cjs b/js/transpiler/transpiler/tests/decompiler.test.cjs
index b14ec5897..483e1fc01 100644
--- a/js/transpiler/transpiler/tests/decompiler.test.cjs
+++ b/js/transpiler/transpiler/tests/decompiler.test.cjs
@@ -807,5 +807,102 @@ describe('whenChanged (DELTA operation)', () => {
});
});
+describe('LC Line Mapping - duplicate if-statements', () => {
+ let decompiler;
+ beforeEach(() => {
+ decompiler = new Decompiler();
+ });
+
+ test('should map duplicate if-conditions to separate lines', () => {
+ // Two identical HIGH conditions on rc[1], each with a different gvar action.
+ // Must produce two separate if-blocks mapped to different line numbers.
+ const conditions = [
+ { index: 0, enabled: 1, activatorId: -1, operation: 4, // HIGH
+ operandAType: 3, operandAValue: 1, // RC_CHANNEL 1
+ operandBType: 0, operandBValue: 0, flags: 0 },
+ { index: 1, enabled: 1, activatorId: 0, operation: 18, // GVAR_SET
+ operandAType: 6, operandAValue: 0, // GVAR 0
+ operandBType: 0, operandBValue: 1, flags: 0 },
+ { index: 2, enabled: 1, activatorId: -1, operation: 4, // HIGH (same as LC 0)
+ operandAType: 3, operandAValue: 1, // RC_CHANNEL 1
+ operandBType: 0, operandBValue: 0, flags: 0 },
+ { index: 3, enabled: 1, activatorId: 2, operation: 18, // GVAR_SET
+ operandAType: 6, operandAValue: 1, // GVAR 1
+ operandBType: 0, operandBValue: 2, flags: 0 },
+ ];
+
+ const result = decompiler.decompile(conditions);
+ expect(result.success).toBe(true);
+
+ // Both LCs must have mappings
+ expect(result.lcToLineMapping[0]).toBeDefined();
+ expect(result.lcToLineMapping[2]).toBeDefined();
+
+ // They must map to DIFFERENT lines (regression: used to both map to first occurrence)
+ expect(result.lcToLineMapping[0]).not.toBe(result.lcToLineMapping[2]);
+ });
+
+ test('should map triple duplicate if-conditions to three separate lines', () => {
+ const conditions = [
+ // First: if rc[1].high -> gvar[0] = 10
+ { index: 0, enabled: 1, activatorId: -1, operation: 4,
+ operandAType: 3, operandAValue: 1,
+ operandBType: 0, operandBValue: 0, flags: 0 },
+ { index: 1, enabled: 1, activatorId: 0, operation: 18,
+ operandAType: 6, operandAValue: 0,
+ operandBType: 0, operandBValue: 10, flags: 0 },
+ // Second: if rc[1].high -> gvar[1] = 20 (duplicate #1)
+ { index: 2, enabled: 1, activatorId: -1, operation: 4,
+ operandAType: 3, operandAValue: 1,
+ operandBType: 0, operandBValue: 0, flags: 0 },
+ { index: 3, enabled: 1, activatorId: 2, operation: 18,
+ operandAType: 6, operandAValue: 1,
+ operandBType: 0, operandBValue: 20, flags: 0 },
+ // Third: if rc[1].high -> gvar[2] = 30 (duplicate #2)
+ { index: 4, enabled: 1, activatorId: -1, operation: 4,
+ operandAType: 3, operandAValue: 1,
+ operandBType: 0, operandBValue: 0, flags: 0 },
+ { index: 5, enabled: 1, activatorId: 4, operation: 18,
+ operandAType: 6, operandAValue: 2,
+ operandBType: 0, operandBValue: 30, flags: 0 },
+ ];
+
+ const result = decompiler.decompile(conditions);
+ expect(result.success).toBe(true);
+
+ // All three must map to unique lines
+ const uniqueLines = new Set([
+ result.lcToLineMapping[0],
+ result.lcToLineMapping[2],
+ result.lcToLineMapping[4]
+ ]);
+ expect(uniqueLines.size).toBe(3);
+ });
+
+ test('should still map non-duplicate conditions correctly', () => {
+ // Control: two DIFFERENT conditions must map correctly (sanity check)
+ const conditions = [
+ { index: 0, enabled: 1, activatorId: -1, operation: 4, // HIGH
+ operandAType: 3, operandAValue: 1, // RC_CHANNEL 1
+ operandBType: 0, operandBValue: 0, flags: 0 },
+ { index: 1, enabled: 1, activatorId: 0, operation: 18,
+ operandAType: 6, operandAValue: 0,
+ operandBType: 0, operandBValue: 1, flags: 0 },
+ { index: 2, enabled: 1, activatorId: -1, operation: 4, // HIGH
+ operandAType: 3, operandAValue: 2, // RC_CHANNEL 2 (different!)
+ operandBType: 0, operandBValue: 0, flags: 0 },
+ { index: 3, enabled: 1, activatorId: 2, operation: 18,
+ operandAType: 6, operandAValue: 1,
+ operandBType: 0, operandBValue: 2, flags: 0 },
+ ];
+
+ const result = decompiler.decompile(conditions);
+ expect(result.success).toBe(true);
+ expect(result.lcToLineMapping[0]).toBeDefined();
+ expect(result.lcToLineMapping[2]).toBeDefined();
+ expect(result.lcToLineMapping[0]).not.toBe(result.lcToLineMapping[2]);
+ });
+});
+
// Export the load function for the runner
module.exports = { loadDecompiler };
diff --git a/js/transpiler/transpiler/tests/edge_activator_in_sticky.test.cjs b/js/transpiler/transpiler/tests/edge_activator_in_sticky.test.cjs
index e76d0571a..d6b3f8c5c 100644
--- a/js/transpiler/transpiler/tests/edge_activator_in_sticky.test.cjs
+++ b/js/transpiler/transpiler/tests/edge_activator_in_sticky.test.cjs
@@ -160,16 +160,20 @@ describe('Edge with activator used as sticky operand', () => {
// It should NOT appear as raw edge(rc[12].high, 100) inside the rc[11] ~ 1500 block
// without the profile check
- // Look for hoisted variable with activator
+ // Look for hoisted variable with activator (pattern 1)
const hasHoistedWithActivator = /const cond\d+ = .* \? .*edge\(.*\) : 0/.test(code);
- if (!hasHoistedWithActivator) {
- // If not hoisted, the edge inside sticky should still have profile check
- // This would be a more complex pattern, but let's check
- console.log('Edge was not hoisted with activator - checking alternative patterns');
+ // Look for inline edge with activator in sticky callback (pattern 2)
+ // The edge should be wrapped in a ternary inside the sticky on: callback
+ const hasInlineEdgeWithActivator = /on:\s*\(\)\s*=>\s*\(.*\?\s*edge\(.*\)\s*:\s*0\)/.test(code);
+
+ if (!hasHoistedWithActivator && !hasInlineEdgeWithActivator) {
+ console.log('Edge was not hoisted with activator and not inline with activator');
+ console.log('Code:', code);
}
- expect(hasHoistedWithActivator).toBe(true);
+ // Either pattern is acceptable - both preserve the activator relationship
+ expect(hasHoistedWithActivator || hasInlineEdgeWithActivator).toBe(true);
});
});
diff --git a/js/transpiler/transpiler/tests/gvar_hoisting_order.test.cjs b/js/transpiler/transpiler/tests/gvar_hoisting_order.test.cjs
new file mode 100644
index 000000000..d4eb99edf
--- /dev/null
+++ b/js/transpiler/transpiler/tests/gvar_hoisting_order.test.cjs
@@ -0,0 +1,222 @@
+/**
+ * GVAR Dependency Hoisting Test
+ *
+ * Tests that the decompiler respects execution order when hoisting variables.
+ * Hoisted variables that use GVARs should not be declared before the GVAR assignments.
+ */
+
+'use strict';
+
+// Import test utilities
+require('./simple_test_runner.cjs');
+
+// We need to dynamically import the ESM module
+let Decompiler;
+
+async function loadDecompiler() {
+ const module = await import('../decompiler.js');
+ Decompiler = module.Decompiler;
+}
+
+describe('GVAR Hoisting Order', () => {
+ let decompiler;
+
+ beforeEach(() => {
+ decompiler = new Decompiler();
+ });
+
+ test('should not hoist gvar usage before gvar assignment', () => {
+ /**
+ * This tests the bug where:
+ * - LC 0-2: Check RC channels
+ * - LC 3-5: Set gvar[7] based on RC channel (with activators)
+ * - LC 6-7: Calculate using gvar[7]
+ * - LC 8: Store result in gvar[6]
+ *
+ * The bug: LC 6-7's complex expression gets hoisted to the top,
+ * before LC 3-5 set gvar[7].
+ */
+ const conditions = [
+ // RC channel checks
+ { index: 0, enabled: 1, activatorId: -1, operation: 4, operandAType: 1, operandAValue: 8, operandBType: 0, operandBValue: 0, flags: 0 }, // RC 4 HIGH
+ { index: 1, enabled: 1, activatorId: -1, operation: 5, operandAType: 1, operandAValue: 8, operandBType: 0, operandBValue: 0, flags: 0 }, // RC 5 HIGH
+ { index: 2, enabled: 1, activatorId: -1, operation: 6, operandAType: 1, operandAValue: 8, operandBType: 0, operandBValue: 0, flags: 0 }, // RC 6 HIGH
+
+ // Set gvar[7] based on RC channel
+ { index: 3, enabled: 1, activatorId: 0, operation: 18, operandAType: 0, operandAValue: 7, operandBType: 0, operandBValue: 8, flags: 0 }, // gvar[7] = 8
+ { index: 4, enabled: 1, activatorId: 1, operation: 18, operandAType: 0, operandAValue: 7, operandBType: 0, operandBValue: 10, flags: 0 }, // gvar[7] = 10
+ { index: 5, enabled: 1, activatorId: 2, operation: 18, operandAType: 0, operandAValue: 7, operandBType: 0, operandBValue: 17, flags: 0 }, // gvar[7] = 17
+
+ // Complex calculation using gvar[7]: min(1000, gvar[7] * 1000 / 45)
+ { index: 6, enabled: 1, activatorId: -1, operation: 36, operandAType: 5, operandAValue: 7, operandBType: 0, operandBValue: 45, flags: 0 }, // gvar[7] * 1000 / 45
+
+ // max(0, LC6) - 500
+ { index: 7, enabled: 1, activatorId: -1, operation: 15, operandAType: 4, operandAValue: 6, operandBType: 0, operandBValue: 500, flags: 0 },
+
+ // Store result in gvar[6]
+ { index: 8, enabled: 1, activatorId: -1, operation: 18, operandAType: 0, operandAValue: 6, operandBType: 4, operandBValue: 7, flags: 0 }
+ ];
+
+ const result = decompiler.decompile(conditions);
+
+ expect(result.success).toBe(true);
+
+ const code = result.code;
+ const lines = code.split('\n').filter(line => line.trim());
+
+ // Find critical line indices
+ let hoistedVarLineIndex = -1;
+ let firstGvar7AssignmentIndex = -1;
+ let gvar6AssignmentIndex = -1;
+
+ for (let i = 0; i < lines.length; i++) {
+ const line = lines[i];
+
+ // Hoisted variable that uses gvar[7]
+ if (line.includes('const cond') && line.includes('gvar[7]')) {
+ hoistedVarLineIndex = i;
+ }
+
+ // First assignment to gvar[7]
+ if (firstGvar7AssignmentIndex === -1 && line.includes('gvar[7] =')) {
+ firstGvar7AssignmentIndex = i;
+ }
+
+ // Assignment to gvar[6]
+ if (line.includes('gvar[6] =')) {
+ gvar6AssignmentIndex = i;
+ }
+ }
+
+ // CRITICAL TEST: If a hoisted variable uses gvar[7], it MUST come after gvar[7] assignments
+ // This is the main bug we're testing for
+ if (hoistedVarLineIndex !== -1 && firstGvar7AssignmentIndex !== -1) {
+ // This assertion will FAIL with the current bug
+ // The hoisted variable is declared BEFORE gvar[7] is assigned
+ if (hoistedVarLineIndex < firstGvar7AssignmentIndex) {
+ throw new Error(
+ `Hoisting bug detected: hoisted variable using gvar[7] at line ${hoistedVarLineIndex} ` +
+ `appears BEFORE first gvar[7] assignment at line ${firstGvar7AssignmentIndex}. ` +
+ `This causes the hoisted var to use OLD gvar[7] value instead of NEW one.`
+ );
+ }
+ }
+
+ // Verify gvar[6] assignment happens (and uses the calculated value)
+ if (gvar6AssignmentIndex === -1) {
+ throw new Error('gvar[6] assignment not found in decompiled code');
+ }
+
+ // Verify the code contains the expected operations
+ if (!code.includes('gvar[7]')) {
+ throw new Error('gvar[7] not found in decompiled code');
+ }
+ if (!code.includes('gvar[6]')) {
+ throw new Error('gvar[6] not found in decompiled code');
+ }
+ });
+
+ test('should preserve execution order in simple gvar usage', () => {
+ /**
+ * Simpler test: Set gvar, then use it
+ * Expected: gvar[0] = 100; gvar[1] = gvar[0] + 50;
+ */
+ const conditions = [
+ // Set gvar[0] = 100
+ { index: 0, enabled: 1, activatorId: -1, operation: 18, operandAType: 0, operandAValue: 0, operandBType: 0, operandBValue: 100, flags: 0 },
+
+ // Calculate gvar[0] + 50
+ { index: 1, enabled: 1, activatorId: -1, operation: 14, operandAType: 5, operandAValue: 0, operandBType: 0, operandBValue: 50, flags: 0 },
+
+ // Set gvar[1] = LC1
+ { index: 2, enabled: 1, activatorId: -1, operation: 18, operandAType: 0, operandAValue: 1, operandBType: 4, operandBValue: 1, flags: 0 }
+ ];
+
+ const result = decompiler.decompile(conditions);
+
+ expect(result.success).toBe(true);
+
+ const code = result.code;
+ const lines = code.split('\n').filter(line => line.trim());
+
+ let gvar0Index = -1;
+ let gvar1Index = -1;
+
+ for (let i = 0; i < lines.length; i++) {
+ const line = lines[i];
+ if (line.includes('gvar[0] =')) gvar0Index = i;
+ if (line.includes('gvar[1] =')) gvar1Index = i;
+ }
+
+ // gvar[0] must be set before gvar[1] (which depends on it)
+ if (gvar0Index === -1) {
+ throw new Error('gvar[0] assignment not found');
+ }
+ if (gvar1Index === -1) {
+ throw new Error('gvar[1] assignment not found');
+ }
+ if (gvar1Index <= gvar0Index) {
+ throw new Error(
+ `Execution order bug: gvar[1] assignment at line ${gvar1Index} ` +
+ `should come AFTER gvar[0] assignment at line ${gvar0Index}`
+ );
+ }
+ });
+
+ test('should handle multiple gvar dependencies without hoisting', () => {
+ /**
+ * Test chain: gvar[0] = 10; gvar[1] = gvar[0] * 2; gvar[2] = gvar[1] + 5;
+ */
+ const conditions = [
+ // gvar[0] = 10
+ { index: 0, enabled: 1, activatorId: -1, operation: 18, operandAType: 0, operandAValue: 0, operandBType: 0, operandBValue: 10, flags: 0 },
+
+ // gvar[0] * 2
+ { index: 1, enabled: 1, activatorId: -1, operation: 16, operandAType: 5, operandAValue: 0, operandBType: 0, operandBValue: 2, flags: 0 },
+
+ // gvar[1] = LC1
+ { index: 2, enabled: 1, activatorId: -1, operation: 18, operandAType: 0, operandAValue: 1, operandBType: 4, operandBValue: 1, flags: 0 },
+
+ // gvar[1] + 5
+ { index: 3, enabled: 1, activatorId: -1, operation: 14, operandAType: 5, operandAValue: 1, operandBType: 0, operandBValue: 5, flags: 0 },
+
+ // gvar[2] = LC3
+ { index: 4, enabled: 1, activatorId: -1, operation: 18, operandAType: 0, operandAValue: 2, operandBType: 4, operandBValue: 3, flags: 0 }
+ ];
+
+ const result = decompiler.decompile(conditions);
+
+ expect(result.success).toBe(true);
+
+ const code = result.code;
+ const lines = code.split('\n').filter(line => line.trim());
+
+ let gvar0Index = -1;
+ let gvar1Index = -1;
+ let gvar2Index = -1;
+
+ for (let i = 0; i < lines.length; i++) {
+ const line = lines[i];
+ if (line.includes('gvar[0] =')) gvar0Index = i;
+ if (line.includes('gvar[1] =')) gvar1Index = i;
+ if (line.includes('gvar[2] =')) gvar2Index = i;
+ }
+
+ // Verify execution order: gvar[0] < gvar[1] < gvar[2]
+ if (gvar0Index === -1 || gvar1Index === -1 || gvar2Index === -1) {
+ throw new Error('Not all gvar assignments found in decompiled code');
+ }
+ if (gvar1Index <= gvar0Index) {
+ throw new Error(
+ `Execution order bug: gvar[1] at line ${gvar1Index} should come after gvar[0] at line ${gvar0Index}`
+ );
+ }
+ if (gvar2Index <= gvar1Index) {
+ throw new Error(
+ `Execution order bug: gvar[2] at line ${gvar2Index} should come after gvar[1] at line ${gvar1Index}`
+ );
+ }
+ });
+});
+
+module.exports = { loadDecompiler };
diff --git a/js/transpiler/transpiler/tests/roundtrip_no_destructuring.mjs b/js/transpiler/transpiler/tests/roundtrip_no_destructuring.mjs
new file mode 100644
index 000000000..f1cf264ba
--- /dev/null
+++ b/js/transpiler/transpiler/tests/roundtrip_no_destructuring.mjs
@@ -0,0 +1,65 @@
+import { Decompiler } from '../decompiler.js';
+import { Transpiler } from '../index.js';
+
+// Test round-trip with explicit inav.flight syntax (no destructuring)
+const testCode = `// Auto VTX power based on distance
+
+if (inav.flight.homeDistance > 100) {
+ inav.override.vtx.power = 3; // High power
+}
+
+if (inav.flight.homeDistance > 500) {
+ inav.override.vtx.power = 4; // Max power
+}`;
+
+console.log('=== Step 1: Compile explicit syntax ===');
+console.log('Code:\n' + testCode);
+
+const transpiler = new Transpiler();
+const compiled = transpiler.transpile(testCode);
+console.log('\nSuccess:', compiled.success);
+if (!compiled.success) {
+ console.log('Error:', compiled.error);
+ process.exit(1);
+}
+console.log('Commands:', compiled.commands);
+
+console.log('\n=== Step 2: Decompile back ===');
+// Parse commands into LC array
+const lcs = [];
+for (const cmd of compiled.commands) {
+ const parts = cmd.split(' ');
+ if (parts[0] === 'logic' && parts.length >= 9) {
+ lcs.push({
+ index: parseInt(parts[1]),
+ enabled: parseInt(parts[2]),
+ activatorId: parseInt(parts[3]),
+ operation: parseInt(parts[4]),
+ operandAType: parseInt(parts[5]),
+ operandAValue: parseInt(parts[6]),
+ operandBType: parseInt(parts[7]),
+ operandBValue: parseInt(parts[8]),
+ flags: parseInt(parts[9] || 0)
+ });
+ }
+}
+
+const decompiler = new Decompiler();
+const decompiled = decompiler.decompile(lcs);
+console.log('Success:', decompiled.success);
+console.log('Decompiled Code:\n' + decompiled.code);
+
+console.log('\n=== Step 3: Verify no destructuring ===');
+const hasDestructuring = decompiled.code.includes('const {') || decompiled.code.includes('const{');
+const hasExplicitSyntax = decompiled.code.includes('inav.flight.homeDistance') &&
+ decompiled.code.includes('inav.override.vtx.power');
+
+console.log('Has destructuring:', hasDestructuring ? 'YES ❌' : 'NO ✅');
+console.log('Has explicit syntax:', hasExplicitSyntax ? 'YES ✅' : 'NO ❌');
+
+if (!hasDestructuring && hasExplicitSyntax) {
+ console.log('\n✅ Round-trip successful! No destructuring in output.');
+} else {
+ console.log('\n❌ Round-trip failed');
+ process.exit(1);
+}
diff --git a/js/transpiler/transpiler/tests/roundtrip_vtol.cjs b/js/transpiler/transpiler/tests/roundtrip_vtol.cjs
new file mode 100644
index 000000000..faebc6512
--- /dev/null
+++ b/js/transpiler/transpiler/tests/roundtrip_vtol.cjs
@@ -0,0 +1,102 @@
+#!/usr/bin/env node
+/**
+ * Round-trip test for VTOL logic conditions
+ * Decompile original LCs, recompile, compare
+ */
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+
+async function main() {
+ // Parse original LCs
+ const lcPath = path.join(__dirname, '../../../../../claude/developer/work-in-progress/vtol-transistion-lcs.txt');
+ const lcText = fs.readFileSync(lcPath, 'utf8');
+ const originalLCs = lcText.trim().split('\n').map(line => {
+ const parts = line.split(' ');
+ return {
+ index: parseInt(parts[1]),
+ enabled: parseInt(parts[2]),
+ activatorId: parseInt(parts[3]),
+ operation: parseInt(parts[4]),
+ operandAType: parseInt(parts[5]),
+ operandAValue: parseInt(parts[6]),
+ operandBType: parseInt(parts[7]),
+ operandBValue: parseInt(parts[8]),
+ flags: parseInt(parts[9]) || 0
+ };
+ });
+
+ const { Decompiler } = await import('../decompiler.js');
+ const { Transpiler } = await import('../index.js');
+
+ // Step 1: Decompile
+ const decompiler = new Decompiler();
+ const decompiled = decompiler.decompile(originalLCs);
+
+ console.log('=== Step 1: Decompile ===');
+ console.log('Success:', decompiled.success);
+ console.log('Warnings:', decompiled.warnings.length);
+ decompiled.warnings.forEach(w => console.log(' -', w));
+
+ // Step 2: Recompile
+ const transpiler = new Transpiler();
+ const recompiled = transpiler.transpile(decompiled.code);
+
+ console.log('\n=== Step 2: Recompile ===');
+ console.log('Success:', recompiled.success);
+ if (!recompiled.success) {
+ console.log('Error:', recompiled.error);
+ console.log('Errors:', recompiled.errors);
+ process.exit(1);
+ }
+ console.log('Commands generated:', recompiled.commands.length);
+
+ // Step 3: Compare key behaviors
+ console.log('\n=== Step 3: Key Behavior Comparison ===');
+
+ // Parse recompiled commands
+ const recompiledLCs = recompiled.commands
+ .filter(cmd => cmd.startsWith('logic '))
+ .map(cmd => {
+ const parts = cmd.split(' ');
+ return {
+ index: parseInt(parts[1]),
+ operation: parseInt(parts[4]),
+ operandAType: parseInt(parts[5]),
+ operandAValue: parseInt(parts[6]),
+ operandBType: parseInt(parts[7]),
+ operandBValue: parseInt(parts[8])
+ };
+ });
+
+ // Check for override operations (38 = RC_CHANNEL_OVERRIDE)
+ const origOverrides = originalLCs.filter(lc => lc.operation === 38);
+ const recompOverrides = recompiledLCs.filter(lc => lc.operation === 38);
+
+ console.log('Original override count:', origOverrides.length);
+ console.log('Recompiled override count:', recompOverrides.length);
+
+ // Check specific overrides
+ let allFound = true;
+ for (const orig of origOverrides) {
+ const channel = orig.operandAValue;
+ const value = orig.operandBValue;
+ const found = recompOverrides.some(r => r.operandAValue === channel && r.operandBValue === value);
+ console.log(` rc[${channel}] = ${value}: ${found ? 'FOUND' : 'MISSING'}`);
+ if (!found) allFound = false;
+ }
+
+ console.log('\n=== Result ===');
+ if (allFound && recompiled.success) {
+ console.log('✅ Round-trip successful - all overrides preserved');
+ } else {
+ console.log('❌ Round-trip has issues');
+ process.exit(1);
+ }
+}
+
+main().catch(err => {
+ console.error('Error:', err);
+ process.exit(1);
+});
diff --git a/js/transpiler/transpiler/tests/roundtrip_vtol_transition.mjs b/js/transpiler/transpiler/tests/roundtrip_vtol_transition.mjs
new file mode 100644
index 000000000..afebfffc8
--- /dev/null
+++ b/js/transpiler/transpiler/tests/roundtrip_vtol_transition.mjs
@@ -0,0 +1,156 @@
+/**
+ * VTOL Transition Logic Conditions Round-Trip Test
+ *
+ * Tests decompile -> recompile cycle for the full VTOL transition config
+ */
+
+import { Decompiler } from '../decompiler.js';
+import { Transpiler } from '../index.js';
+import { readFileSync } from 'fs';
+import { dirname, join } from 'path';
+import { fileURLToPath } from 'url';
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+
+// Parse LC commands from file
+function parseLCCommands(text) {
+ const lines = text.trim().split('\n').filter(l => l.startsWith('logic '));
+ return lines.map(line => {
+ const parts = line.split(/\s+/);
+ // logic INDEX ENABLED ACTIVATOR OPERATION OPERAND_A_TYPE OPERAND_A_VALUE OPERAND_B_TYPE OPERAND_B_VALUE FLAGS
+ return {
+ index: parseInt(parts[1]),
+ enabled: parseInt(parts[2]),
+ activatorId: parseInt(parts[3]),
+ operation: parseInt(parts[4]),
+ operandAType: parseInt(parts[5]),
+ operandAValue: parseInt(parts[6]),
+ operandBType: parseInt(parts[7]),
+ operandBValue: parseInt(parts[8]),
+ flags: parseInt(parts[9]) || 0
+ };
+ });
+}
+
+// Parse a logic command string back to comparable format
+function parseLogicCommand(cmd) {
+ const parts = cmd.split(/\s+/);
+ return {
+ index: parseInt(parts[1]),
+ enabled: parseInt(parts[2]),
+ activatorId: parseInt(parts[3]),
+ operation: parseInt(parts[4]),
+ operandAType: parseInt(parts[5]),
+ operandAValue: parseInt(parts[6]),
+ operandBType: parseInt(parts[7]),
+ operandBValue: parseInt(parts[8]),
+ flags: parseInt(parts[9]) || 0
+ };
+}
+
+// Read the VTOL transition LCs
+const lcFile = join(__dirname, '../../../../../claude/developer/work-in-progress/vtol-transistion-lcs.txt');
+const lcText = readFileSync(lcFile, 'utf-8');
+const originalLCs = parseLCCommands(lcText);
+
+console.log(`=== Original: ${originalLCs.length} Logic Conditions ===\n`);
+
+// Step 1: Decompile
+console.log('=== Step 1: Decompile ===');
+const decompiler = new Decompiler();
+const decompiled = decompiler.decompile(originalLCs);
+console.log('Success:', decompiled.success);
+if (decompiled.warnings.length > 0) {
+ console.log('Warnings:', decompiled.warnings);
+}
+console.log('\nDecompiled JavaScript:');
+console.log('─'.repeat(60));
+console.log(decompiled.code);
+console.log('─'.repeat(60));
+
+// Step 2: Recompile
+console.log('\n=== Step 2: Recompile ===');
+const transpiler = new Transpiler();
+const recompiled = transpiler.transpile(decompiled.code);
+console.log('Success:', recompiled.success);
+if (!recompiled.success) {
+ console.log('Error:', recompiled.error);
+ console.log('Errors:', recompiled.errors);
+ process.exit(1);
+}
+
+console.log(`\nRecompiled: ${recompiled.commands.length} Logic Conditions`);
+
+// Step 3: Compare
+console.log('\n=== Step 3: Compare ===\n');
+
+// Parse recompiled commands
+const recompiledLCs = recompiled.commands.map(parseLogicCommand);
+
+// Build maps for comparison by semantic meaning
+function getLCKey(lc) {
+ // Key by operation and operands (ignoring index which may differ)
+ return `op${lc.operation}_${lc.operandAType}:${lc.operandAValue}_${lc.operandBType}:${lc.operandBValue}`;
+}
+
+const originalByKey = new Map();
+for (const lc of originalLCs) {
+ const key = getLCKey(lc);
+ if (!originalByKey.has(key)) originalByKey.set(key, []);
+ originalByKey.get(key).push(lc);
+}
+
+const recompiledByKey = new Map();
+for (const lc of recompiledLCs) {
+ const key = getLCKey(lc);
+ if (!recompiledByKey.has(key)) recompiledByKey.set(key, []);
+ recompiledByKey.get(key).push(lc);
+}
+
+// Check which operations are preserved
+const preserved = [];
+const missing = [];
+const added = [];
+
+for (const [key, originals] of originalByKey) {
+ if (recompiledByKey.has(key)) {
+ preserved.push({ key, original: originals[0], recompiled: recompiledByKey.get(key)[0] });
+ } else {
+ missing.push({ key, original: originals[0] });
+ }
+}
+
+for (const [key, recompileds] of recompiledByKey) {
+ if (!originalByKey.has(key)) {
+ added.push({ key, recompiled: recompileds[0] });
+ }
+}
+
+console.log(`Preserved: ${preserved.length}`);
+console.log(`Missing: ${missing.length}`);
+console.log(`Added: ${added.length}`);
+
+if (missing.length > 0) {
+ console.log('\n❌ Missing operations:');
+ for (const m of missing) {
+ console.log(` LC ${m.original.index}: op=${m.original.operation} A=${m.original.operandAType}:${m.original.operandAValue} B=${m.original.operandBType}:${m.original.operandBValue}`);
+ }
+}
+
+if (added.length > 0) {
+ console.log('\n➕ Added operations:');
+ for (const a of added) {
+ console.log(` LC ${a.recompiled.index}: op=${a.recompiled.operation} A=${a.recompiled.operandAType}:${a.recompiled.operandAValue} B=${a.recompiled.operandBType}:${a.recompiled.operandBValue}`);
+ }
+}
+
+// Summary
+console.log('\n=== Summary ===');
+if (missing.length === 0 && added.length === 0) {
+ console.log('✅ Perfect round-trip! All operations preserved.');
+} else if (missing.length === 0) {
+ console.log('⚠️ Round-trip added some helper LCs but preserved all original operations.');
+} else {
+ console.log('❌ Round-trip lost some operations.');
+ process.exit(1);
+}
diff --git a/js/transpiler/transpiler/tests/run_all_tests.sh b/js/transpiler/transpiler/tests/run_all_tests.sh
new file mode 100755
index 000000000..3a698fcf1
--- /dev/null
+++ b/js/transpiler/transpiler/tests/run_all_tests.sh
@@ -0,0 +1,50 @@
+#!/bin/bash
+cd /home/raymorris/Documents/planes/inavflight/inav-configurator
+
+echo "=== Running Full Transpiler Test Suite ==="
+echo ""
+
+TOTAL=0
+PASSED=0
+FAILED=0
+
+for test in js/transpiler/transpiler/tests/run_*.cjs; do
+ test_name=$(basename "$test" .cjs | sed 's/run_//')
+ printf "%-40s " "$test_name..."
+
+ output=$(node "$test" 2>&1)
+ exit_code=$?
+
+ if echo "$output" | grep -q "ALL TESTS PASSED"; then
+ echo "✅ PASSED"
+ PASSED=$((PASSED + 1))
+ elif echo "$output" | grep -q "FAILED"; then
+ echo "❌ FAILED"
+ FAILED=$((FAILED + 1))
+ echo "$output" | grep -A 5 "FAILED"
+ elif [ $exit_code -eq 0 ]; then
+ # Exit code 0 but no output - assume passed
+ echo "✅ PASSED (silent)"
+ PASSED=$((PASSED + 1))
+ else
+ echo "⚠️ UNKNOWN"
+ fi
+
+ TOTAL=$((TOTAL + 1))
+done
+
+echo ""
+echo "=== Test Suite Results ==="
+echo "Total: $TOTAL"
+echo "Passed: $PASSED"
+echo "Failed: $FAILED"
+
+if [ $FAILED -eq 0 ]; then
+ echo ""
+ echo "✅ ALL TEST SUITES PASSED"
+ exit 0
+else
+ echo ""
+ echo "❌ SOME TESTS FAILED"
+ exit 1
+fi
diff --git a/js/transpiler/transpiler/tests/run_gvar_hoisting_tests.cjs b/js/transpiler/transpiler/tests/run_gvar_hoisting_tests.cjs
new file mode 100755
index 000000000..0c9a0d1d8
--- /dev/null
+++ b/js/transpiler/transpiler/tests/run_gvar_hoisting_tests.cjs
@@ -0,0 +1,19 @@
+#!/usr/bin/env node
+/**
+ * Runner for GVAR hoisting order tests
+ */
+
+'use strict';
+
+const { runner } = require('./simple_test_runner.cjs');
+
+async function main() {
+ const { loadDecompiler } = require('./gvar_hoisting_order.test.cjs');
+ await loadDecompiler();
+ await runner.run();
+}
+
+main().catch(err => {
+ console.error('Test runner error:', err);
+ process.exit(1);
+});
diff --git a/js/transpiler/transpiler/tests/run_ternary_expression_tests.cjs b/js/transpiler/transpiler/tests/run_ternary_expression_tests.cjs
new file mode 100644
index 000000000..3ccfa6dd4
--- /dev/null
+++ b/js/transpiler/transpiler/tests/run_ternary_expression_tests.cjs
@@ -0,0 +1,21 @@
+#!/usr/bin/env node
+/**
+ * Ternary Expression Test Runner
+ *
+ * Run with: node run_ternary_expression_tests.cjs
+ */
+
+'use strict';
+
+const { runner } = require('./simple_test_runner.cjs');
+
+async function main() {
+ const { loadTranspiler } = require('./ternary_expression.test.cjs');
+ await loadTranspiler();
+ await runner.run();
+}
+
+main().catch(err => {
+ console.error('Test runner error:', err);
+ process.exit(1);
+});
diff --git a/js/transpiler/transpiler/tests/test-data/vtol-transistion-lcs.txt b/js/transpiler/transpiler/tests/test-data/vtol-transistion-lcs.txt
new file mode 100644
index 000000000..63b447746
--- /dev/null
+++ b/js/transpiler/transpiler/tests/test-data/vtol-transistion-lcs.txt
@@ -0,0 +1,39 @@
+logic 0 1 -1 1 2 31 0 1 0
+logic 1 1 0 14 2 11 0 0 0
+logic 2 1 0 17 4 1 0 28 0
+logic 3 1 -1 4 1 12 0 0 0
+logic 4 1 -1 5 1 12 0 0 0
+logic 5 1 -1 6 1 12 0 0 0
+logic 6 1 -1 48 4 4 0 1000 0
+logic 7 1 -1 3 2 14 0 2 0
+logic 8 1 -1 3 2 6 0 300 0
+logic 9 1 -1 8 4 7 4 8 0
+logic 10 1 -1 7 4 3 4 9 0
+logic 11 1 -1 13 4 5 4 10 0
+logic 12 1 11 3 4 2 0 71 0
+logic 13 1 12 47 4 3 0 5000 0
+logic 14 1 -1 9 4 6 4 13 0
+logic 15 1 -1 12 4 14 0 0 0
+logic 16 1 -1 7 4 3 4 15 0
+logic 17 1 -1 1 2 38 0 1 0
+logic 18 1 17 51 1 11 0 2000 0
+logic 19 1 18 38 0 15 0 1900 0
+logic 20 1 -1 1 2 38 0 2 0
+logic 21 1 -1 1 3 2 0 1 0
+logic 22 1 -1 1 3 3 0 1 0
+logic 23 1 20 8 4 21 4 22 0
+logic 24 1 -1 12 4 23 0 0 0
+logic 25 1 24 38 0 5 0 1500 0
+logic 26 1 17 47 4 5 0 100 0
+logic 27 1 -1 51 1 11 0 1500 0
+logic 28 1 -1 9 4 10 4 14 0
+logic 29 1 27 13 4 26 4 28 0
+logic 30 1 -1 48 4 29 0 500 0
+logic 31 1 30 3 2 10 0 2222 0
+logic 32 1 31 38 0 14 0 1800 0
+logic 33 1 16 38 0 16 0 1100 0
+logic 34 1 14 38 0 16 0 1400 0
+logic 35 1 5 38 0 16 0 1750 0
+logic 36 1 -1 12 4 9 0 0 0
+logic 37 1 36 47 4 33 0 3000 0
+logic 38 1 36 47 4 35 0 3000 0
diff --git a/js/transpiler/transpiler/tests/test_childless_boolean_condition.js b/js/transpiler/transpiler/tests/test_childless_boolean_condition.js
new file mode 100755
index 000000000..4c3a56114
--- /dev/null
+++ b/js/transpiler/transpiler/tests/test_childless_boolean_condition.js
@@ -0,0 +1,349 @@
+#!/usr/bin/env node
+
+/**
+ * Regression test for childless boolean condition with activator
+ *
+ * Bug: Boolean conditions with no children were being skipped entirely during
+ * decompilation, even if they could be externally referenced.
+ *
+ * Example: Logic condition 23 with activatorId=22, operation=LOWER_THAN,
+ * operandA=flight.airSpeed, operandB=1111 - this is a childless boolean condition
+ * that should be rendered as an if block with a comment for external reference.
+ *
+ * Before the fix: condition was completely missing from decompiled output
+ * After the fix: correctly renders as an if block with external reference comment
+ */
+
+import { Decompiler } from '../decompiler.js';
+import { OPERATION, OPERAND_TYPE } from '../inav_constants.js';
+
+function assertEquals(actual, expected, message) {
+ if (actual !== expected) {
+ throw new Error(`${message}\n Expected: ${expected}\n Actual: ${actual}`);
+ }
+}
+
+function assertContains(str, substring, message) {
+ if (!str.includes(substring)) {
+ throw new Error(`${message}\n String does not contain: ${substring}\n Actual: ${str}`);
+ }
+}
+
+function assertNotContains(str, substring, message) {
+ if (str.includes(substring)) {
+ throw new Error(`${message}\n String should not contain: ${substring}\n Actual: ${str}`);
+ }
+}
+
+function runTest(name, testFn) {
+ try {
+ testFn();
+ console.log(` ✅ ${name}`);
+ return true;
+ } catch (error) {
+ console.log(` ❌ ${name}`);
+ console.log(` ${error.message}`);
+ return false;
+ }
+}
+
+console.log('📦 Childless Boolean Condition Regression Tests\n');
+
+let passed = 0;
+let failed = 0;
+
+// Test 1: Childless boolean condition with no activator (root level)
+if (runTest('childless boolean condition at root level', () => {
+ const decompiler = new Decompiler();
+ const lcs = [
+ {
+ index: 0,
+ enabled: 1,
+ activatorId: -1,
+ operation: OPERATION.LOWER_THAN,
+ operandAType: OPERAND_TYPE.FLIGHT,
+ operandAValue: 11, // AIR_SPEED
+ operandBType: OPERAND_TYPE.VALUE,
+ operandBValue: 1111,
+ flags: 0
+ }
+ ];
+ const result = decompiler.decompile(lcs);
+ if (!result.success) {
+ throw new Error(`Decompilation failed: ${result.error || JSON.stringify(result)}`);
+ }
+ assertContains(result.code, 'inav.flight.airSpeed < 1111', 'Should contain the condition expression');
+ assertContains(result.code, 'LC 0: for external reference', 'Should contain external reference comment');
+ assertContains(result.code, 'if (', 'Should be wrapped in an if statement');
+})) {
+ passed++;
+} else {
+ failed++;
+}
+
+// Test 2: Childless boolean condition with activator (nested level) - the original bug case
+if (runTest('childless boolean condition with activator (nested)', () => {
+ const decompiler = new Decompiler();
+ const lcs = [
+ {
+ index: 22,
+ enabled: 1,
+ activatorId: -1,
+ operation: 2, // GREATER_THAN
+ operandAType: 2, // FLIGHT
+ operandAValue: 12, // ALTITUDE
+ operandBType: 0, // VALUE
+ operandBValue: 100,
+ flags: 0
+ },
+ {
+ index: 23,
+ enabled: 1,
+ activatorId: 22, // Activated by LC 22
+ operation: 3, // LOWER_THAN
+ operandAType: 2, // FLIGHT
+ operandAValue: 11, // AIR_SPEED
+ operandBType: 0, // VALUE
+ operandBValue: 1111,
+ flags: 0
+ }
+ ];
+ const result = decompiler.decompile(lcs);
+ if (!result.success) {
+ throw new Error(`Decompilation failed: ${result.error || JSON.stringify(result)}`);
+ }
+ // The outer condition should be rendered
+ assertContains(result.code, 'inav.flight.altitude > 100', 'Should contain the outer condition');
+ // The inner childless condition should also be rendered with external reference comment
+ assertContains(result.code, 'inav.flight.airSpeed < 1111', 'Should contain the inner condition expression');
+ assertContains(result.code, 'LC 23: for external reference', 'Should contain external reference comment for LC 23');
+})) {
+ passed++;
+} else {
+ failed++;
+}
+
+// Test 3: Multiple childless boolean conditions in sequence
+if (runTest('multiple childless boolean conditions', () => {
+ const decompiler = new Decompiler();
+ const lcs = [
+ {
+ index: 0,
+ enabled: 1,
+ activatorId: -1,
+ operation: 3, // LOWER_THAN
+ operandAType: 2, // FLIGHT
+ operandAValue: 11, // AIR_SPEED
+ operandBType: 0, // VALUE
+ operandBValue: 500,
+ flags: 0
+ },
+ {
+ index: 1,
+ enabled: 1,
+ activatorId: -1,
+ operation: 2, // GREATER_THAN
+ operandAType: 2, // FLIGHT
+ operandAValue: 4, // VBAT
+ operandBType: 0, // VALUE
+ operandBValue: 3700,
+ flags: 0
+ }
+ ];
+ const result = decompiler.decompile(lcs);
+ if (!result.success) {
+ throw new Error(`Decompilation failed: ${result.error || JSON.stringify(result)}`);
+ }
+ assertContains(result.code, 'inav.flight.airSpeed < 500', 'Should contain first condition');
+ assertContains(result.code, 'LC 0: for external reference', 'Should have external reference for LC 0');
+ assertContains(result.code, 'inav.flight.vbat > 3700', 'Should contain second condition');
+ assertContains(result.code, 'LC 1: for external reference', 'Should have external reference for LC 1');
+})) {
+ passed++;
+} else {
+ failed++;
+}
+
+// Test 4: Childless boolean condition should NOT be output if it has children
+if (runTest('boolean condition with children uses normal if-block', () => {
+ const decompiler = new Decompiler();
+ const lcs = [
+ {
+ index: 0,
+ enabled: 1,
+ activatorId: -1,
+ operation: 3, // LOWER_THAN
+ operandAType: 2, // FLIGHT
+ operandAValue: 11, // AIR_SPEED
+ operandBType: 0, // VALUE
+ operandBValue: 1111,
+ flags: 0
+ },
+ {
+ index: 1,
+ enabled: 1,
+ activatorId: 0, // Child of LC 0
+ operation: 23, // OVERRIDE_THROTTLE_SCALE
+ operandAType: 0, // VALUE
+ operandAValue: 50,
+ operandBType: 0,
+ operandBValue: 0,
+ flags: 0
+ }
+ ];
+ const result = decompiler.decompile(lcs);
+ if (!result.success) {
+ throw new Error(`Decompilation failed: ${result.error || JSON.stringify(result)}`);
+ }
+ assertContains(result.code, 'inav.flight.airSpeed < 1111', 'Should contain the condition');
+ assertContains(result.code, 'override.throttleScale', 'Should contain the child action');
+ // Should NOT have the external reference comment since it has children
+ assertNotContains(result.code, 'LC 0: for external reference', 'Should NOT have external reference comment when it has children');
+})) {
+ passed++;
+} else {
+ failed++;
+}
+
+// Test 5: Childless action operations should NOT get external reference comment
+if (runTest('childless action operations do not get external reference', () => {
+ const decompiler = new Decompiler();
+ const lcs = [
+ {
+ index: 0,
+ enabled: 1,
+ activatorId: -1,
+ operation: 23, // OVERRIDE_THROTTLE_SCALE (action, not boolean)
+ operandAType: 0, // VALUE
+ operandAValue: 75,
+ operandBType: 0,
+ operandBValue: 0,
+ flags: 0
+ }
+ ];
+ const result = decompiler.decompile(lcs);
+ if (!result.success) {
+ throw new Error(`Decompilation failed: ${result.error || JSON.stringify(result)}`);
+ }
+ assertContains(result.code, 'override.throttleScale', 'Should contain the action');
+ // Actions are not externally referenceable, so no comment needed
+ assertNotContains(result.code, 'for external reference', 'Should NOT have external reference comment for actions');
+})) {
+ passed++;
+} else {
+ failed++;
+}
+
+// Test 6: Comparison operations (all should support external reference)
+if (runTest('all comparison operations support external reference', () => {
+ const decompiler = new Decompiler();
+ const lcs = [
+ {
+ index: 0,
+ enabled: 1,
+ activatorId: -1,
+ operation: 1, // EQUAL
+ operandAType: 2, // FLIGHT
+ operandAValue: 17, // IS_ARMED
+ operandBType: 0, // VALUE
+ operandBValue: 1,
+ flags: 0
+ },
+ {
+ index: 1,
+ enabled: 1,
+ activatorId: -1,
+ operation: 2, // GREATER_THAN
+ operandAType: 2, // FLIGHT
+ operandAValue: 12, // ALTITUDE
+ operandBType: 0, // VALUE
+ operandBValue: 50,
+ flags: 0
+ },
+ {
+ index: 2,
+ enabled: 1,
+ activatorId: -1,
+ operation: 3, // LOWER_THAN
+ operandAType: 2, // FLIGHT
+ operandAValue: 5, // CELL_VOLTAGE
+ operandBType: 0, // VALUE
+ operandBValue: 350,
+ flags: 0
+ }
+ ];
+ const result = decompiler.decompile(lcs);
+ if (!result.success) {
+ throw new Error(`Decompilation failed: ${result.error || JSON.stringify(result)}`);
+ }
+ assertContains(result.code, 'LC 0: for external reference', 'EQUAL should have external reference');
+ assertContains(result.code, 'LC 1: for external reference', 'GREATER_THAN should have external reference');
+ assertContains(result.code, 'LC 2: for external reference', 'LOWER_THAN should have external reference');
+})) {
+ passed++;
+} else {
+ failed++;
+}
+
+// Test 7: Logical operations (AND, OR) can also be externally referenced
+if (runTest('logical operations support external reference', () => {
+ const decompiler = new Decompiler();
+ const lcs = [
+ {
+ index: 0,
+ enabled: 1,
+ activatorId: -1,
+ operation: 2, // GREATER_THAN
+ operandAType: 2, // FLIGHT
+ operandAValue: 12, // ALTITUDE
+ operandBType: 0, // VALUE
+ operandBValue: 100,
+ flags: 0
+ },
+ {
+ index: 1,
+ enabled: 1,
+ activatorId: -1,
+ operation: 3, // LOWER_THAN
+ operandAType: 2, // FLIGHT
+ operandAValue: 11, // AIR_SPEED
+ operandBType: 0, // VALUE
+ operandBValue: 500,
+ flags: 0
+ },
+ {
+ index: 2,
+ enabled: 1,
+ activatorId: -1,
+ operation: 7, // AND (childless, should get external reference)
+ operandAType: 4, // LC
+ operandAValue: 0,
+ operandBType: 4, // LC
+ operandBValue: 1,
+ flags: 0
+ }
+ ];
+ const result = decompiler.decompile(lcs);
+ if (!result.success) {
+ throw new Error(`Decompilation failed: ${result.error || JSON.stringify(result)}`);
+ }
+ assertContains(result.code, 'LC 2: for external reference', 'AND operation should have external reference when childless');
+})) {
+ passed++;
+} else {
+ failed++;
+}
+
+console.log('\n==================================================');
+console.log(`📊 Test Results:`);
+console.log(` Passed: ${passed}`);
+console.log(` Failed: ${failed}`);
+console.log(` Total: ${passed + failed}`);
+
+if (failed === 0) {
+ console.log('\n✅ ALL TESTS PASSED');
+ process.exit(0);
+} else {
+ console.log(`\n❌ ${failed} TEST(S) FAILED`);
+ process.exit(1);
+}
diff --git a/js/transpiler/transpiler/tests/test_gvar_check.js b/js/transpiler/transpiler/tests/test_gvar_check.js
new file mode 100755
index 000000000..a948f4b1b
--- /dev/null
+++ b/js/transpiler/transpiler/tests/test_gvar_check.js
@@ -0,0 +1,81 @@
+#!/usr/bin/env node
+/**
+ * Quick test to check if gvar operations work correctly
+ * Tests both reading and writing gvar values
+ */
+
+'use strict';
+
+import { transpile } from '../transpiler.js';
+
+console.log('Testing GVAR operations...\n');
+
+// Test 1: Simple gvar assignment
+const test1 = `
+const { gvar } = inav;
+gvar[0] = 100;
+`;
+
+console.log('Test 1: gvar[0] = 100');
+try {
+ const result1 = transpile(test1, 'test1');
+ console.log('Generated logic conditions:');
+ result1.conditions.forEach((cond, i) => {
+ console.log(` LC${i}: operandA={type:${cond.operandA.type}, value:${cond.operandA.value}}, ` +
+ `operandB={type:${cond.operandB.type}, value:${cond.operandB.value}}, ` +
+ `operation=${cond.operation}`);
+ });
+
+ // Check if it's using correct types
+ if (result1.conditions.length > 0) {
+ const cond = result1.conditions[0];
+ console.log('\nAnalysis:');
+ console.log(` operandA.type = ${cond.operandA.type} (expected 5 for GVAR, currently using ${cond.operandA.type})`);
+ console.log(` operation = ${cond.operation} (expected 18 for GVAR_SET, currently using ${cond.operation})`);
+
+ if (cond.operandA.type === 3) {
+ console.log(' ⚠️ WARNING: Using type 3 (FLIGHT_MODE) instead of 5 (GVAR)');
+ }
+ if (cond.operation === 19) {
+ console.log(' ⚠️ WARNING: Using operation 19 (GVAR_INC) instead of 18 (GVAR_SET)');
+ }
+ }
+} catch (err) {
+ console.log('ERROR:', err.message);
+}
+
+// Test 2: Reading gvar value
+console.log('\n---\n');
+const test2 = `
+const { gvar, override } = inav;
+override.throttle(gvar[0]);
+`;
+
+console.log('Test 2: override.throttle(gvar[0])');
+try {
+ const result2 = transpile(test2, 'test2');
+ console.log('Generated logic conditions:');
+ result2.conditions.forEach((cond, i) => {
+ console.log(` LC${i}: operandA={type:${cond.operandA.type}, value:${cond.operandA.value}}, ` +
+ `operandB={type:${cond.operandB.type}, value:${cond.operandB.value}}, ` +
+ `operation=${cond.operation}`);
+ });
+
+ if (result2.conditions.length > 0) {
+ const cond = result2.conditions[0];
+ console.log('\nAnalysis:');
+ console.log(` operandA.type = ${cond.operandA.type} (expected 5 for GVAR when reading gvar[0])`);
+
+ if (cond.operandA.type === 3) {
+ console.log(' ⚠️ WARNING: Using type 3 (FLIGHT_MODE) instead of 5 (GVAR)');
+ console.log(' This means it will try to read FLIGHT_MODE value 0 instead of GVAR 0!');
+ }
+ }
+} catch (err) {
+ console.log('ERROR:', err.message);
+}
+
+console.log('\n===\nConclusion:');
+console.log('If warnings appear above, gvar.js has incorrect operand type/operation values.');
+console.log('Firmware expects: type=5 (GVAR), operation=18 (GVAR_SET)');
+console.log('Current gvar.js uses: type=3, operation=19');
diff --git a/js/transpiler/transpiler/tests/test_simple_override.js b/js/transpiler/transpiler/tests/test_simple_override.js
new file mode 100644
index 000000000..2790003c7
--- /dev/null
+++ b/js/transpiler/transpiler/tests/test_simple_override.js
@@ -0,0 +1,14 @@
+#!/usr/bin/env node
+
+import { Transpiler } from '../index.js';
+
+const code = `
+const { flight, override } = inav;
+if (flight.armed) {
+ override.throttle = 1500;
+}`;
+
+const transpiler = new Transpiler();
+const result = transpiler.transpile(code);
+
+console.log('Result:', JSON.stringify(result, null, 2));
diff --git a/js/transpiler/transpiler/tests/utils/README.md b/js/transpiler/transpiler/tests/utils/README.md
new file mode 100644
index 000000000..cc4d79db2
--- /dev/null
+++ b/js/transpiler/transpiler/tests/utils/README.md
@@ -0,0 +1,91 @@
+# Test Utilities
+
+This directory contains utilities for analyzing and testing the transpiler.
+
+## Utilities
+
+### compare_original_vs_roundtrip.mjs
+Performs detailed comparison between original LCs and recompiled LCs after round-trip compilation (decompile → recompile).
+
+**Usage:**
+```bash
+node js/transpiler/transpiler/tests/utils/compare_original_vs_roundtrip.mjs
+```
+
+**What it does:**
+- Compares LC count
+- Finds missing/extra operations
+- Shows side-by-side comparison of all LCs
+- Useful for identifying where optimizations occur
+
+**Note:** This script uses the test file `../test-data/vtol-transistion-lcs.txt`. To analyze different LC sets, either replace this file or update the path in the script.
+
+### functional_comparison.mjs
+Checks functional equivalence between original and recompiled LCs by comparing actual outputs (RC overrides).
+
+**Usage:**
+```bash
+node js/transpiler/transpiler/tests/utils/functional_comparison.mjs
+```
+
+**What it does:**
+- Compares RC_OVERRIDE operations (actual outputs)
+- Verifies all override values match
+- Identifies eliminated optimizations
+- Returns exit code 0 if functionally equivalent
+
+**Use case:** Regression testing to ensure optimizations don't change behavior.
+
+### find_unhoist_duplicates.mjs
+Analyzes duplicate patterns in original LCs to identify optimization opportunities.
+
+**Usage:**
+```bash
+node js/transpiler/transpiler/tests/utils/find_unhoist_duplicates.mjs
+```
+
+**What it does:**
+- Finds duplicate operation patterns (ignoring activators)
+- Shows which LCs share the same operation+operands
+- Lists const variables in decompiled code
+- Helps identify what should be hoisted
+
+### analyze_remaining_gap.mjs
+Analyzes the remaining LC gap between original and recompiled to identify optimization opportunities.
+
+**Usage:**
+```bash
+node js/transpiler/transpiler/tests/utils/analyze_remaining_gap.mjs
+```
+
+**What it does:**
+- Counts and compares operation types
+- Identifies which operations are duplicated
+- Shows which LCs contribute to the gap
+- Useful for finding next optimization target
+
+## Adding Your Own Test LCs
+
+To test with different LC sets, you can:
+1. Replace `../test-data/vtol-transistion-lcs.txt` with your own test data
+2. Or update the file path in the scripts:
+
+```javascript
+const originalText = readFileSync(new URL('../test-data/your-lcs.txt', import.meta.url), 'utf-8');
+```
+
+The LC file format is standard INAV logic condition output:
+```
+logic 0 1 -1 1 2 31 0 1 0
+logic 1 1 0 14 2 11 0 0 0
+...
+```
+
+## Integration with CI/CD
+
+These utilities can be integrated into automated testing:
+
+```bash
+# Run functional comparison and fail if not equivalent
+node js/transpiler/transpiler/tests/utils/functional_comparison.mjs || exit 1
+```
diff --git a/js/transpiler/transpiler/tests/utils/analyze_remaining_gap.mjs b/js/transpiler/transpiler/tests/utils/analyze_remaining_gap.mjs
new file mode 100644
index 000000000..d4e207864
--- /dev/null
+++ b/js/transpiler/transpiler/tests/utils/analyze_remaining_gap.mjs
@@ -0,0 +1,125 @@
+import { Transpiler } from '/home/raymorris/Documents/planes/inavflight/inav-configurator/js/transpiler/transpiler/index.js';
+import { Decompiler } from '/home/raymorris/Documents/planes/inavflight/inav-configurator/js/transpiler/transpiler/decompiler.js';
+import { readFileSync } from 'fs';
+
+// Load original
+const originalText = readFileSync(new URL('../test-data/vtol-transistion-lcs.txt', import.meta.url), 'utf-8');
+const originalLCs = originalText.trim().split('\n')
+ .filter(line => line.match(/^logic \d+/))
+ .map(line => {
+ const parts = line.split(/\s+/);
+ return {
+ index: parseInt(parts[1]),
+ enabled: parseInt(parts[2]),
+ activatorId: parseInt(parts[3]),
+ operation: parseInt(parts[4]),
+ operandAType: parseInt(parts[5]),
+ operandAValue: parseInt(parts[6]),
+ operandBType: parseInt(parts[7]),
+ operandBValue: parseInt(parts[8])
+ };
+ });
+
+// Decompile and recompile
+const decompiler = new Decompiler();
+const decompileResult = decompiler.decompile(originalLCs);
+const decompiled = decompileResult.code;
+
+const transpiler = new Transpiler();
+const transpileResult = transpiler.transpile(decompiled);
+
+const recompiled = transpileResult.commands
+ .filter(cmd => cmd.startsWith('logic '))
+ .map(cmd => {
+ const parts = cmd.split(/\s+/);
+ return {
+ index: parseInt(parts[1]),
+ operation: parseInt(parts[4]),
+ operandAType: parseInt(parts[5]),
+ operandAValue: parseInt(parts[6]),
+ operandBType: parseInt(parts[7]),
+ operandBValue: parseInt(parts[8]),
+ cmd
+ };
+ });
+
+console.log('=== Analyzing Remaining +3 LC Gap ===\n');
+console.log(`Original: ${originalLCs.length} LCs`);
+console.log(`Recompiled: ${recompiled.length} LCs`);
+console.log(`Gap: +${recompiled.length - originalLCs.length} LCs\n`);
+
+// Find duplicate patterns in recompiled
+console.log('=== Looking for Duplicates in Recompiled ===\n');
+
+const patterns = new Map();
+for (const lc of recompiled) {
+ const key = `op=${lc.operation} A=${lc.operandAType}:${lc.operandAValue} B=${lc.operandBType}:${lc.operandBValue}`;
+ if (!patterns.has(key)) {
+ patterns.set(key, []);
+ }
+ patterns.get(key).push(lc.index);
+}
+
+console.log('Duplicate patterns (appearing 2+ times):');
+let foundDupes = false;
+for (const [pattern, indices] of patterns.entries()) {
+ if (indices.length > 1) {
+ foundDupes = true;
+ const opName = getOpName(parseInt(pattern.match(/op=(\d+)/)[1]));
+ console.log(` ${opName}: ${pattern}`);
+ console.log(` Used in LCs: ${indices.join(', ')}`);
+ }
+}
+
+if (!foundDupes) {
+ console.log(' (none found - all operations are unique)');
+}
+
+// Compare specific operations
+console.log('\n=== Extra Operations in Recompiled ===\n');
+
+const originalOps = countOperations(originalLCs);
+const recompiledOps = countOperations(recompiled);
+
+const extras = [];
+for (const [op, count] of recompiledOps.entries()) {
+ const origCount = originalOps.get(op) || 0;
+ if (count > origCount) {
+ extras.push({ op, extra: count - origCount, origCount, newCount: count });
+ }
+}
+
+extras.sort((a, b) => b.extra - a.extra);
+
+for (const { op, extra, origCount, newCount } of extras) {
+ console.log(`${op}: +${extra} (${origCount} → ${newCount})`);
+
+ // Find these operations in recompiled
+ const instances = recompiled.filter(lc => getOpName(lc.operation) === op);
+ console.log(` LCs: ${instances.map(lc => lc.index).join(', ')}`);
+
+ if (instances.length <= 3) {
+ instances.forEach(lc => console.log(` ${lc.cmd}`));
+ }
+ console.log('');
+}
+
+function countOperations(lcs) {
+ const counts = new Map();
+ for (const lc of lcs) {
+ if (lc.operation === undefined) continue;
+ const opName = getOpName(lc.operation);
+ counts.set(opName, (counts.get(opName) || 0) + 1);
+ }
+ return counts;
+}
+
+function getOpName(opCode) {
+ const ops = {
+ 0: 'TRUE', 1: 'EQUAL', 2: 'GREATER', 3: 'LOWER', 4: 'LOW', 5: 'MID', 6: 'HIGH',
+ 7: 'AND', 8: 'OR', 9: 'XOR', 10: 'NAND', 11: 'NOR', 12: 'NOT', 13: 'STICKY',
+ 14: 'ADD', 15: 'SUB', 16: 'MUL', 17: 'DIV', 18: 'GVAR_SET', 38: 'RC_OVERRIDE',
+ 47: 'EDGE', 48: 'DELAY'
+ };
+ return ops[opCode] || `OP${opCode}`;
+}
diff --git a/js/transpiler/transpiler/tests/utils/compare_original_vs_roundtrip.mjs b/js/transpiler/transpiler/tests/utils/compare_original_vs_roundtrip.mjs
new file mode 100644
index 000000000..08e4367ce
--- /dev/null
+++ b/js/transpiler/transpiler/tests/utils/compare_original_vs_roundtrip.mjs
@@ -0,0 +1,139 @@
+import { Transpiler } from '/home/raymorris/Documents/planes/inavflight/inav-configurator/js/transpiler/transpiler/index.js';
+import { Decompiler } from '/home/raymorris/Documents/planes/inavflight/inav-configurator/js/transpiler/transpiler/decompiler.js';
+import { readFileSync } from 'fs';
+
+// Load original LCs
+const originalText = readFileSync(new URL('../test-data/vtol-transistion-lcs.txt', import.meta.url), 'utf-8');
+const originalLCs = originalText.trim().split('\n')
+ .filter(line => line.match(/^logic \d+/))
+ .map(line => {
+ const parts = line.split(/\s+/);
+ return {
+ index: parseInt(parts[1]),
+ enabled: parseInt(parts[2]),
+ activatorId: parseInt(parts[3]),
+ operation: parseInt(parts[4]),
+ operandAType: parseInt(parts[5]),
+ operandAValue: parseInt(parts[6]),
+ operandBType: parseInt(parts[7]),
+ operandBValue: parseInt(parts[8]),
+ raw: line
+ };
+ });
+
+// Decompile and recompile
+const decompiler = new Decompiler();
+const decompileResult = decompiler.decompile(originalLCs);
+const decompiled = decompileResult.code;
+
+const transpiler = new Transpiler();
+const transpileResult = transpiler.transpile(decompiled);
+
+const recompiled = transpileResult.commands
+ .filter(cmd => cmd.startsWith('logic '))
+ .map(cmd => {
+ const parts = cmd.split(/\s+/);
+ return {
+ index: parseInt(parts[1]),
+ enabled: parseInt(parts[2]),
+ activatorId: parseInt(parts[3]),
+ operation: parseInt(parts[4]),
+ operandAType: parseInt(parts[5]),
+ operandAValue: parseInt(parts[6]),
+ operandBType: parseInt(parts[7]),
+ operandBValue: parseInt(parts[8]),
+ raw: cmd
+ };
+ });
+
+console.log('=== LC Count Comparison ===');
+console.log('Original: ' + originalLCs.length + ' LCs');
+console.log('Recompiled: ' + recompiled.length + ' LCs');
+console.log('Difference: ' + (recompiled.length - originalLCs.length) + ' LC\n');
+
+// Find which LC is missing/different
+console.log('=== Detailed Comparison ===\n');
+
+// Create a canonical form for comparison (operation + operands, ignoring index)
+function getCanonicalForm(lc) {
+ return lc.enabled + '|' + lc.activatorId + '|' + lc.operation + '|' + lc.operandAType + ':' + lc.operandAValue + '|' + lc.operandBType + ':' + lc.operandBValue;
+}
+
+const originalCanonical = originalLCs.map((lc, i) => ({ canonical: getCanonicalForm(lc), index: i, lc }));
+const recompiledCanonical = recompiled.map((lc, i) => ({ canonical: getCanonicalForm(lc), index: i, lc }));
+
+// Find LCs in original that aren't in recompiled
+const missingFromRecompiled = [];
+for (const orig of originalCanonical) {
+ const found = recompiledCanonical.find(r => r.canonical === orig.canonical);
+ if (!found) {
+ missingFromRecompiled.push(orig);
+ }
+}
+
+// Find LCs in recompiled that aren't in original
+const extraInRecompiled = [];
+for (const recomp of recompiledCanonical) {
+ const found = originalCanonical.find(o => o.canonical === recomp.canonical);
+ if (!found) {
+ extraInRecompiled.push(recomp);
+ }
+}
+
+if (missingFromRecompiled.length > 0) {
+ console.log('Missing from recompiled (in original but not in recompiled):');
+ for (const item of missingFromRecompiled) {
+ console.log(' LC ' + item.lc.index + ': ' + item.lc.raw);
+ console.log(' Operation: ' + getOpName(item.lc.operation));
+ console.log(' Activator: ' + item.lc.activatorId);
+ console.log('');
+ }
+}
+
+if (extraInRecompiled.length > 0) {
+ console.log('Extra in recompiled (not in original):');
+ for (const item of extraInRecompiled) {
+ console.log(' LC ' + item.lc.index + ': ' + item.lc.raw);
+ console.log(' Operation: ' + getOpName(item.lc.operation));
+ console.log(' Activator: ' + item.lc.activatorId);
+ console.log('');
+ }
+}
+
+if (missingFromRecompiled.length === 0 && extraInRecompiled.length === 0) {
+ console.log('✓ All LCs match! The difference is just in LC count/indexing.');
+}
+
+// Show side-by-side comparison
+console.log('\n=== Side-by-Side LC Comparison ===\n');
+const maxLen = Math.max(originalLCs.length, recompiled.length);
+for (let i = 0; i < maxLen; i++) {
+ const orig = originalLCs[i];
+ const recomp = recompiled[i];
+
+ if (orig && !recomp) {
+ console.log('LC ' + i + ': MISSING IN RECOMPILED');
+ console.log(' Original: ' + orig.raw);
+ } else if (!orig && recomp) {
+ console.log('LC ' + i + ': EXTRA IN RECOMPILED');
+ console.log(' Recompiled: ' + recomp.raw);
+ } else if (orig && recomp) {
+ const origCanon = getCanonicalForm(orig);
+ const recompCanon = getCanonicalForm(recomp);
+ if (origCanon !== recompCanon) {
+ console.log('LC ' + i + ': DIFFERENT');
+ console.log(' Original: ' + orig.raw);
+ console.log(' Recompiled: ' + recomp.raw);
+ }
+ }
+}
+
+function getOpName(opCode) {
+ const ops = {
+ 0: 'TRUE', 1: 'EQUAL', 2: 'GREATER', 3: 'LOWER', 4: 'LOW', 5: 'MID', 6: 'HIGH',
+ 7: 'AND', 8: 'OR', 9: 'XOR', 10: 'NAND', 11: 'NOR', 12: 'NOT', 13: 'STICKY',
+ 14: 'ADD', 15: 'SUB', 16: 'MUL', 17: 'DIV', 18: 'GVAR_SET', 38: 'RC_OVERRIDE',
+ 47: 'EDGE', 48: 'DELAY', 51: 'APPROX_EQUAL'
+ };
+ return ops[opCode] || 'OP' + opCode;
+}
diff --git a/js/transpiler/transpiler/tests/utils/find_unhoist_duplicates.mjs b/js/transpiler/transpiler/tests/utils/find_unhoist_duplicates.mjs
new file mode 100644
index 000000000..bcf2bbdf4
--- /dev/null
+++ b/js/transpiler/transpiler/tests/utils/find_unhoist_duplicates.mjs
@@ -0,0 +1,60 @@
+import { Decompiler } from '/home/raymorris/Documents/planes/inavflight/inav-configurator/js/transpiler/transpiler/decompiler.js';
+import { readFileSync } from 'fs';
+
+const originalText = readFileSync(new URL('../test-data/vtol-transistion-lcs.txt', import.meta.url), 'utf-8');
+const originalLCs = originalText.trim().split('\n')
+ .filter(line => line.match(/^logic \d+/))
+ .map(line => {
+ const parts = line.split(/\s+/);
+ return {
+ index: parseInt(parts[1]),
+ enabled: parseInt(parts[2]),
+ activatorId: parseInt(parts[3]),
+ operation: parseInt(parts[4]),
+ operandAType: parseInt(parts[5]),
+ operandAValue: parseInt(parts[6]),
+ operandBType: parseInt(parts[7]),
+ operandBValue: parseInt(parts[8])
+ };
+ });
+
+console.log('=== Finding Duplicate Patterns in Original LCs ===\n');
+
+// Group by operation + operands (ignoring activator)
+const patterns = new Map();
+for (const lc of originalLCs) {
+ const key = `op=${lc.operation} A=${lc.operandAType}:${lc.operandAValue} B=${lc.operandBType}:${lc.operandBValue}`;
+ if (!patterns.has(key)) {
+ patterns.set(key, []);
+ }
+ patterns.get(key).push({ index: lc.index, activatorId: lc.activatorId });
+}
+
+console.log('Patterns appearing 2+ times in original:\n');
+for (const [pattern, instances] of patterns.entries()) {
+ if (instances.length >= 2) {
+ const opCode = parseInt(pattern.match(/op=(\d+)/)[1]);
+ const opName = getOpName(opCode);
+ console.log(`${opName}: ${pattern}`);
+ console.log(` Instances: ${instances.map(i => `LC${i.index}(act=${i.activatorId})`).join(', ')}`);
+ console.log('');
+ }
+}
+
+// Decompile and check what got hoisted
+const decompiler = new Decompiler();
+const result = decompiler.decompile(originalLCs);
+const lines = result.code.split('\n');
+
+console.log('=== Const Variables in Decompiled Code ===\n');
+const constVars = lines.filter(line => line.trim().startsWith('const cond'));
+constVars.forEach(line => console.log(line.trim()));
+
+function getOpName(opCode) {
+ const ops = {
+ 0: 'TRUE', 1: 'EQUAL', 2: 'GREATER', 3: 'LOWER', 4: 'LOW', 5: 'MID', 6: 'HIGH',
+ 7: 'AND', 8: 'OR', 9: 'XOR', 10: 'NAND', 11: 'NOR', 12: 'NOT', 13: 'STICKY',
+ 17: 'DIV', 18: 'GVAR_SET', 38: 'RC_OVERRIDE', 47: 'EDGE', 48: 'DELAY'
+ };
+ return ops[opCode] || `OP${opCode}`;
+}
diff --git a/js/transpiler/transpiler/tests/utils/functional_comparison.mjs b/js/transpiler/transpiler/tests/utils/functional_comparison.mjs
new file mode 100644
index 000000000..2b571a4ba
--- /dev/null
+++ b/js/transpiler/transpiler/tests/utils/functional_comparison.mjs
@@ -0,0 +1,103 @@
+import { Transpiler } from '/home/raymorris/Documents/planes/inavflight/inav-configurator/js/transpiler/transpiler/index.js';
+import { Decompiler } from '/home/raymorris/Documents/planes/inavflight/inav-configurator/js/transpiler/transpiler/decompiler.js';
+import { readFileSync } from 'fs';
+
+// Load original LCs
+const originalText = readFileSync(new URL('../test-data/vtol-transistion-lcs.txt', import.meta.url), 'utf-8');
+const originalLCs = originalText.trim().split('\n')
+ .filter(line => line.match(/^logic \d+/))
+ .map(line => {
+ const parts = line.split(/\s+/);
+ return {
+ index: parseInt(parts[1]),
+ enabled: parseInt(parts[2]),
+ activatorId: parseInt(parts[3]),
+ operation: parseInt(parts[4]),
+ operandAType: parseInt(parts[5]),
+ operandAValue: parseInt(parts[6]),
+ operandBType: parseInt(parts[7]),
+ operandBValue: parseInt(parts[8]),
+ raw: line
+ };
+ });
+
+// Decompile and recompile
+const decompiler = new Decompiler();
+const decompileResult = decompiler.decompile(originalLCs);
+const decompiled = decompileResult.code;
+
+const transpiler = new Transpiler();
+const transpileResult = transpiler.transpile(decompiled);
+
+const recompiled = transpileResult.commands
+ .filter(cmd => cmd.startsWith('logic '))
+ .map(cmd => {
+ const parts = cmd.split(/\s+/);
+ return {
+ index: parseInt(parts[1]),
+ enabled: parseInt(parts[2]),
+ activatorId: parseInt(parts[3]),
+ operation: parseInt(parts[4]),
+ operandAType: parseInt(parts[5]),
+ operandAValue: parseInt(parts[6]),
+ operandBType: parseInt(parts[7]),
+ operandBValue: parseInt(parts[8]),
+ raw: cmd
+ };
+ });
+
+console.log('=== Functional Comparison ===\n');
+
+// Count RC_OVERRIDE operations (these are the actual outputs)
+const origOverrides = originalLCs.filter(lc => lc.operation === 38);
+const recompOverrides = recompiled.filter(lc => lc.operation === 38);
+
+console.log('RC_OVERRIDE operations (actual outputs):');
+console.log(' Original: ' + origOverrides.length);
+console.log(' Recompiled: ' + recompOverrides.length);
+
+console.log('\nOriginal RC_OVERRIDE details:');
+for (const lc of origOverrides) {
+ console.log(' LC ' + lc.index + ': rc[' + lc.operandAValue + '] = ' + lc.operandBValue + ' (activator: ' + lc.activatorId + ')');
+}
+
+console.log('\nRecompiled RC_OVERRIDE details:');
+for (const lc of recompOverrides) {
+ console.log(' LC ' + lc.index + ': rc[' + lc.operandAValue + '] = ' + lc.operandBValue + ' (activator: ' + lc.activatorId + ')');
+}
+
+// The key question: are all the same RC channels being overridden with the same values?
+const origOverrideSet = new Set(origOverrides.map(lc => 'rc[' + lc.operandAValue + ']=' + lc.operandBValue));
+const recompOverrideSet = new Set(recompOverrides.map(lc => 'rc[' + lc.operandAValue + ']=' + lc.operandBValue));
+
+console.log('\n=== RC Override Value Comparison ===');
+console.log('Original overrides: ' + Array.from(origOverrideSet).sort().join(', '));
+console.log('Recompiled overrides: ' + Array.from(recompOverrideSet).sort().join(', '));
+
+const missing = Array.from(origOverrideSet).filter(x => !recompOverrideSet.has(x));
+const extra = Array.from(recompOverrideSet).filter(x => !origOverrideSet.has(x));
+
+if (missing.length > 0) {
+ console.log('\n⚠️ Missing from recompiled: ' + missing.join(', '));
+}
+if (extra.length > 0) {
+ console.log('⚠️ Extra in recompiled: ' + extra.join(', '));
+}
+if (missing.length === 0 && extra.length === 0) {
+ console.log('\n✅ All RC override values match!');
+}
+
+// Check eliminated operation
+console.log('\n=== Optimization Analysis ===');
+const origAdd = originalLCs.filter(lc => lc.operation === 14);
+const recompAdd = recompiled.filter(lc => lc.operation === 14);
+console.log('ADD operations: ' + origAdd.length + ' → ' + recompAdd.length + ' (eliminated ' + (origAdd.length - recompAdd.length) + ')');
+
+// Show what was eliminated
+if (origAdd.length > recompAdd.length) {
+ console.log('\nEliminated ADD operation:');
+ console.log(' Original LC 1: ADD flight.airSpeed + 0 (with activator 0)');
+ console.log(' This was an identity operation (x + 0 = x) used as intermediate value');
+ console.log(' Recompiled code directly uses flight.airSpeed in the DIV operation');
+ console.log('\n✅ This is a valid optimization - no functional change');
+}
diff --git a/locale/en/messages.json b/locale/en/messages.json
index c16540af6..72cbbcd22 100644
--- a/locale/en/messages.json
+++ b/locale/en/messages.json
@@ -47,6 +47,12 @@
"options_cliAutocomplete": {
"message": "Advanced CLI AutoComplete"
},
+ "navExpandAll": {
+ "message": "Expand All"
+ },
+ "navCollapseAll": {
+ "message": "Collapse All"
+ },
"options_unit_type": {
"message": "Set how the units render on the configurator only"
},
@@ -119,6 +125,30 @@
"tabHelp": {
"message": "Documentation & Support"
},
+ "navGroupSetup": {
+ "message": "Setup & Configuration"
+ },
+ "navGroupFlight": {
+ "message": "Flight Control"
+ },
+ "navGroupTuning": {
+ "message": "Tuning"
+ },
+ "navGroupNavigation": {
+ "message": "Navigation & Mission"
+ },
+ "navGroupSensors": {
+ "message": "Sensors & Peripherals"
+ },
+ "navGroupLogging": {
+ "message": "Data Logging"
+ },
+ "navGroupProgramming": {
+ "message": "Programming"
+ },
+ "navGroupTools": {
+ "message": "Tools"
+ },
"tabSetup": {
"message": "Status"
},
@@ -1209,6 +1239,24 @@
"configurationGPSUseGlonass": {
"message": "Gps use Glonass Satellites (RU)"
},
+ "gpsPresetMode": {
+ "message": "GPS Configuration Preset"
+ },
+ "gpsPresetModeHelp": {
+ "message": "Choose a preset optimized for your GPS module, or use Manual for custom configuration. Auto-detect will identify your GPS module if connected."
+ },
+ "gpsUpdateRate": {
+ "message": "GPS Update Rate (Hz)"
+ },
+ "gpsUpdateRateHelp": {
+ "message": "How often the GPS module sends position updates. Higher rates provide lower latency but may reduce accuracy with multiple constellations on M10 modules."
+ },
+ "gpsAutoDetectFailed": {
+ "message": "Could not auto-detect GPS module. Please connect flight controller or select manual preset."
+ },
+ "gpsAutoDetectSuccess": {
+ "message": "GPS module detected:"
+ },
"tzOffset": {
"message": "Timezone Offset"
},
@@ -3686,6 +3734,12 @@
"osd_home_position_arm_screen": {
"message": "Home Position on Arming Screen"
},
+ "osd_framerate_hz": {
+ "message": "OSD Framerate (Hz)"
+ },
+ "osd_framerate_hz_help": {
+ "message": "Target refresh rate for OSD elements in Hz. Each element is redrawn at approximately this rate. Values above 10 Hz provide no visible improvement for typical flight data but increase CPU load. Artificial horizon and telemetry are always updated every cycle regardless of this setting. Set to -1 for legacy behavior (one element per frame)."
+ },
"osd_hud_settings": {
"message": "Heads-up Display settings"
},
diff --git a/package.json b/package.json
index 03de2b34b..c2485598c 100755
--- a/package.json
+++ b/package.json
@@ -2,7 +2,7 @@
"name": "inav-configurator",
"productName": "INAV Configurator",
"description": "Configurator for the open source flight controller software INAV.",
- "version": "9.0.0",
+ "version": "9.0.2",
"main": ".vite/build/main.js",
"type": "module",
"scripts": {
diff --git a/resources/public/sitl/linux/arm64/inav_SITL b/resources/public/sitl/linux/arm64/inav_SITL
index 7f9dee472..8f693c5f6 100755
Binary files a/resources/public/sitl/linux/arm64/inav_SITL and b/resources/public/sitl/linux/arm64/inav_SITL differ
diff --git a/resources/public/sitl/linux/inav_SITL b/resources/public/sitl/linux/inav_SITL
index 6c759f917..2708dce2d 100755
Binary files a/resources/public/sitl/linux/inav_SITL and b/resources/public/sitl/linux/inav_SITL differ
diff --git a/resources/public/sitl/macos/inav_SITL b/resources/public/sitl/macos/inav_SITL
index a40ea42ba..c9851c45a 100755
Binary files a/resources/public/sitl/macos/inav_SITL and b/resources/public/sitl/macos/inav_SITL differ
diff --git a/resources/public/sitl/windows/cygwin1.dll b/resources/public/sitl/windows/cygwin1.dll
index 17e06d74e..43e047f78 100644
Binary files a/resources/public/sitl/windows/cygwin1.dll and b/resources/public/sitl/windows/cygwin1.dll differ
diff --git a/resources/public/sitl/windows/inav_SITL.exe b/resources/public/sitl/windows/inav_SITL.exe
index 15d3b234c..fa3380bb0 100644
Binary files a/resources/public/sitl/windows/inav_SITL.exe and b/resources/public/sitl/windows/inav_SITL.exe differ
diff --git a/src/css/main.css b/src/css/main.css
index 43dab6ed9..18e51f5f5 100644
--- a/src/css/main.css
+++ b/src/css/main.css
@@ -680,11 +680,129 @@ input[type="number"]::-webkit-inner-spin-button {
background-color: #37a8db;
}
+/* Accordion Navigation Groups */
+#tabs .nav-group {
+ border-bottom: 1px solid rgba(0, 0, 0, 0.30);
+}
+
+#tabs .group-header {
+ display: flex;
+ align-items: center;
+ justify-content: space-between;
+ padding: 8px 12px;
+ cursor: pointer;
+ background-color: #2d2d2d;
+ transition: background-color 0.2s;
+ user-select: none;
+ border-top: solid 1px rgba(255, 255, 255, 0.05);
+}
+
+#tabs .group-header:hover {
+ background-color: #353535;
+}
+
+#tabs .group-header.active {
+ background-color: transparent;
+ padding: 0;
+ min-height: 1px;
+ border-top: 1px solid rgba(55, 168, 219, 0.3);
+}
+
+#tabs .group-title {
+ font-family: 'open_sanssemibold', Arial, serif;
+ font-size: 12px;
+ font-weight: 600;
+ color: #b0b0b0;
+ transition: opacity 0.2s;
+}
+
+#tabs .group-header.active .group-title {
+ display: none;
+}
+
+#tabs .chevron {
+ font-size: 10px;
+ transition: transform 0.2s, opacity 0.2s;
+ color: #808080;
+}
+
+#tabs .group-header.active .chevron {
+ display: none;
+}
+
+#tabs .group-items {
+ max-height: 0;
+ overflow: hidden;
+ transition: max-height 0.3s ease;
+ background-color: #252525;
+ list-style: none;
+ padding: 0;
+ margin: 0;
+}
+
+#tabs .group-items.expanded {
+ max-height: 500px;
+}
+
+#tabs .group-items li {
+ border-bottom: 1px solid rgba(0, 0, 0, 0.20);
+}
+
+#tabs .group-items li:last-child {
+ border-bottom: 0;
+}
+
+#tabs .group-items li a {
+ padding-left: 40px;
+}
+
+/* Expand/Collapse All Toggle */
+#tabs .nav-toggle-all {
+ margin-top: 4px;
+ padding: 0;
+ border-top: 1px solid rgba(255, 255, 255, 0.1);
+}
+
+#tabs .nav-toggle-all a {
+ display: flex;
+ align-items: center;
+ justify-content: center;
+ gap: 8px;
+ padding: 6px 12px;
+ color: #37a8db;
+ font-family: 'open_sanssemibold', Arial, serif;
+ font-size: 11px;
+ text-transform: uppercase;
+ letter-spacing: 0.5px;
+ background-color: rgba(55, 168, 219, 0.05);
+ transition: background-color 0.2s, color 0.2s;
+}
+
+#tabs .nav-toggle-all a:hover {
+ background-color: rgba(55, 168, 219, 0.15);
+ color: #4db8eb;
+}
+
+#tabs .nav-toggle-all svg {
+ width: 20px;
+ height: 20px;
+ flex-shrink: 0;
+}
+
+#tabs .nav-toggle-all .toggle-text {
+ display: none;
+}
+
.tabicon {
background: no-repeat 13px 7px;
background-size: 15px;
}
+/* Adjust icon position for accordion tabs */
+#tabs .group-items .tabicon {
+ background-position: 20px 7px;
+}
+
/* Tab-Icons */
.ic_setup {
background-image: url("./../../images/icons/cf_icon_setup_grey.svg");
@@ -1024,7 +1142,7 @@ li.active .ic_mag {
}
.ic_search {
- background-image: url("./../../images/icons/search-gray.svg");
+ background-image: url("./../../images/icons/search-white.svg");
}
.ic_search:hover {
diff --git a/src/css/tabs/led_strip.css b/src/css/tabs/led_strip.css
index 639251b23..4a01e72be 100644
--- a/src/css/tabs/led_strip.css
+++ b/src/css/tabs/led_strip.css
@@ -7,15 +7,19 @@
.tab-led-strip .section {
color: #565656;
- margin: 20px 0 5px 0;
+ margin: 0 0 12px 0;
border-bottom: 1px solid silver;
}
+.tab-led-strip .gridColumn {
+ display: inline-block;
+ vertical-align: top;
+ margin-right: 2em;
+}
+
.tab-led-strip .mainGrid {
width: calc((24px + 7px) * 16);
height: calc((24px + 7px) * 16);
- float: left;
- margin-right: 10px;
border-radius: 3px;
background-color: #dcdcdc;
border: silver;
@@ -152,23 +156,19 @@
}
.tab-led-strip .wire {
- color: rgba(255,255,255,.5);
+ color: rgba(255,255,255,1);
text-align: center;
- font-size: 12px;
- text-shadow: 1px 1px rgba(0,0,0,.4);
+ font-size: 11px;
+ font-weight: bold;
+ text-shadow: 1px 1px rgba(0,0,0,.6);
padding-top: 0;
display: block;
- /* font-family: monospace; */
margin-left: -1px;
margin-top: -21px;
width: 24px;
height: 24px;
}
-.gridWire .wire {
- color: rgba(255,255,255,1);
-}
-
.gridWire {
background: rgba(15, 171, 22, .5) !important;
}
@@ -194,13 +194,6 @@
}
-.tab-led-strip .w100 {
- width: 100%;
-}
-
-.tab-led-strip .w50 {
- width: 49%;
-}
/* Drop-down boxes */
@@ -339,8 +332,8 @@
.tab-led-strip .controls {
position: relative;
- float: left;
- width: 285px;
+ display: inline-block;
+ vertical-align: top;
margin-right: 10px;
}
@@ -376,21 +369,17 @@
width: 23%;
}
-.tab-led-strip .wires-remaining {
- float: right;
+.tab-led-strip .wires-placed {
text-align: center;
font-size: 14px;
+ margin: 6px 0;
+ color: #565656;
}
-.tab-led-strip .wires-remaining div {
- font-size: 40px;
+.tab-led-strip .wires-placed .placed-count {
+ font-size: 20px;
+ font-weight: bold;
color: #ffbb00;
- margin-bottom: -5px;
- margin-top: -10px;
-}
-
-.tab-led-strip .wires-remaining.error div {
- color: #FF5700;
}
.tab-led-strip > .buttons {
@@ -411,12 +400,115 @@
width: 122px;
height: 122px;
float: left;
- border: solid 1px rgb(236, 236, 236);
}
/*******JQUERYUI**********/
+
+/* Step Section Headers */
+.tab-led-strip .step-header {
+ color: #4a90d9 !important;
+ font-weight: bold !important;
+ border-bottom-color: #4a90d9 !important;
+ font-size: 1.3em;
+ margin-top: 1em;
+}
+
+.tab-led-strip .step-header .circle-number {
+ font-size: 1.6em;
+ font-weight: normal !important;
+}
+
+.tab-led-strip .step-instruction {
+ font-size: 0.95em;
+ color: #666;
+ margin: 8px 0;
+ padding: 6px 10px;
+ font-size: 0.8em;
+ border-radius: 3px;
+}
+
+/* Quick Layouts */
+.tab-led-strip .quick-layouts {
+ margin: 8px 0;
+}
+
+.tab-led-strip .quick-layouts .color_section {
+ display: block;
+ margin-bottom: 4px;
+ color: #565656;
+ font-size: 12px;
+}
+
+.tab-led-strip .quickLayout {
+ width: 31%;
+ font-size: 11px;
+ padding: 5px 3px;
+ margin-right: 2px;
+}
+
+.tab-led-strip .quickLayout:last-child {
+ margin-right: 0;
+}
+
+/* Placed counter */
+.tab-led-strip .wires-placed {
+ text-align: center;
+ font-size: 14px;
+ margin: 6px 0;
+ color: #565656;
+}
+
+.tab-led-strip .wires-placed .placed-count {
+ font-size: 20px;
+ font-weight: bold;
+ color: #ffbb00;
+}
+
+/* Wiring Controls under grid */
+.tab-led-strip .wiringControls {
+ display: flex;
+ gap: 8px;
+ margin: 8px 0;
+}
+
+/* Overlays Grid Layout */
+.tab-led-strip .overlays-grid {
+ display: grid;
+ grid-template-columns: 1fr 1fr;
+ gap: 4px 8px;
+ margin-top: 4px;
+}
+
+/* Edit Palette Button */
+.tab-led-strip .editPalette {
+ margin-top: 6px;
+ background: #f5f5f5;
+ border: 1px dashed #aaa;
+ color: #565656;
+ font-size: 12px;
+ cursor: pointer;
+}
+
+.tab-led-strip .editPalette:hover {
+ background: #e8e8e8;
+ border-color: #888;
+}
+
+/* Clear Actions (at bottom) */
+.tab-led-strip .clear-actions {
+ margin-top: 10px;
+ border-top: 1px solid #ddd;
+ padding-top: 8px;
+}
+
+/* Grid: unwired cells get dashed border */
+.tab-led-strip .mainGrid .gPoint:not([class*="function"]) {
+ border-style: dashed;
+ border-color: #ccc;
+}
+
.tab-led-strip .ui-selected {
box-shadow: inset 0 0 8px rgba(255, 0, 255, 1) !important;
border: solid 1px #000 !important;
@@ -432,4 +524,4 @@
position: absolute;
z-index: 100;
border: 1px dotted white;
-}
\ No newline at end of file
+}
diff --git a/src/css/tabs/mission_planer.css b/src/css/tabs/mission_planer.css
index 28527c46b..d123f8bb3 100644
--- a/src/css/tabs/mission_planer.css
+++ b/src/css/tabs/mission_planer.css
@@ -97,6 +97,10 @@
background-image: url(./../../../images/icons/cf_icon_MP_center_grey.svg);
}
+.tab-mission-control .ic_search {
+ background-image: url(./../../../images/icons/search-white.svg);
+}
+
.tab-mission-control .ic_setup {
background-image: url(./../../../images/icons/cf_icon_setup_white.svg);
}
diff --git a/tabs/firmware_flasher.js b/tabs/firmware_flasher.js
index 580bc81c2..69e7cbdb2 100755
--- a/tabs/firmware_flasher.js
+++ b/tabs/firmware_flasher.js
@@ -22,6 +22,14 @@ import store from './../js/store';
import dialog from '../js/dialog.js';
TABS.firmware_flasher = {};
+
+// Normalize target names to underscores for consistent dictionary lookups.
+// Hyphens supported as workaround for 9.0.0 filename inconsistency.
+function normalizeTargetName(name) {
+ if (name == null) return '';
+ return String(name).replace(/-/g, '_');
+}
+
TABS.firmware_flasher.initialize = function (callback) {
if (GUI.active_tab != 'firmware_flasher') {
@@ -72,7 +80,7 @@ TABS.firmware_flasher.initialize = function (callback) {
//var targetFromFilenameExpression = /inav_([\d.]+)?_?([^.]+)\.(.*)/;
// inav_8.0.0_TUNERCF405_dev-20240617-88fb1d0.hex
// inav_8.0.0_TUNERCF405_ci-20240617-88fb1d0.hex
- var targetFromFilenameExpression = /^inav_(\d+)([\d.]+)_([A-Za-z0-9_]+)_(ci|dev)-(\d{4})(\d{2})(\d{2})-(\w+)\.(hex)$/;
+ var targetFromFilenameExpression = /^inav_(\d+)([\d.]+)_([A-Za-z0-9_-]+)_(ci|dev)-(\d{4})(\d{2})(\d{2})-(\w+)\.(hex)$/;
var match = targetFromFilenameExpression.exec(filename);
if (!match) {
@@ -80,9 +88,10 @@ TABS.firmware_flasher.initialize = function (callback) {
return null;
}
+ var rawMatch = match[3]; // e.g., "TBS-LUCID-H7-WING" or "TBS_LUCID_H7_WING"
return {
- raw_target: match[3],
- target: match[3].replace("_", " "),
+ target_id: normalizeTargetName(rawMatch),
+ target: rawMatch.replace(/_/g, " ").replace(/-/g, " "), // Display: "TBS LUCID H7 WING"
format: match[9],
version: match[1]+match[2],
major: match[1]
@@ -100,9 +109,10 @@ TABS.firmware_flasher.initialize = function (callback) {
//GUI.log("non dev: match[2]: " + match[2] + " match[3]: " + match[3]);
+ var rawMatch = match[2]; // e.g., "MATEKF405" or "MATEK-F405"
return {
- raw_target: match[2],
- target: match[2].replace("_", " "),
+ target_id: normalizeTargetName(rawMatch),
+ target: rawMatch.replace(/_/g, " ").replace(/-/g, " "), // Display: "MATEKF405"
format: match[3],
};
}
@@ -115,7 +125,7 @@ TABS.firmware_flasher.initialize = function (callback) {
if (selectedTarget === "0") {
TABS.firmware_flasher.getTarget();
} else {
- $('select[name="board"] option[value=' + selectedTarget + ']').attr("selected", "selected");
+ $('select[name="board"] option[value="' + selectedTarget + '"]').attr("selected", "selected");
$('select[name="board"]').trigger('change');
}
});
@@ -158,8 +168,8 @@ TABS.firmware_flasher.initialize = function (callback) {
if ((!showDevReleases && release.prerelease) || !result) {
return;
}
- if($.inArray(result.target, unsortedTargets) == -1) {
- unsortedTargets.push(result.target);
+ if($.inArray(result.target_id, unsortedTargets) == -1) {
+ unsortedTargets.push(result.target_id);
}
});
});
@@ -170,8 +180,10 @@ TABS.firmware_flasher.initialize = function (callback) {
release.assets.forEach(function (asset) {
var result = parseDevFilename(asset.name);
- if (result && $.inArray(result.target, unsortedTargets) == -1) {
- unsortedTargets.push(result.target);
+ if (result) {
+ if ($.inArray(result.target_id, unsortedTargets) == -1) {
+ unsortedTargets.push(result.target_id);
+ }
}
});
});
@@ -214,13 +226,16 @@ TABS.firmware_flasher.initialize = function (callback) {
"version" : release.tag_name,
"url" : asset.browser_download_url,
"file" : asset.name,
- "raw_target": result.raw_target,
+ "target_id" : result.target_id,
"target" : result.target,
"date" : formattedDate,
"notes" : release.body,
"status" : release.prerelease ? "release-candidate" : "stable"
};
- releases[result.target].push(descriptor);
+ // Skip duplicate entries (e.g. both hyphen and underscore variants of same target+version)
+ if (!releases[result.target_id].some(d => d.version === descriptor.version && d.status === descriptor.status)) {
+ releases[result.target_id].push(descriptor);
+ }
});
});
@@ -268,13 +283,16 @@ TABS.firmware_flasher.initialize = function (callback) {
"version" : release.tag_name,
"url" : asset.browser_download_url,
"file" : asset.name,
- "raw_target": result.raw_target,
+ "target_id" : result.target_id,
"target" : result.target,
"date" : formattedDate,
"notes" : release.body,
"status" : release.prerelease ? "nightly" : "stable"
};
- releases[result.target].push(descriptor);
+ // Skip duplicate entries (e.g. both hyphen and underscore variants of same target+version)
+ if (!releases[result.target_id].some(d => d.version === descriptor.version && d.status === descriptor.status)) {
+ releases[result.target_id].push(descriptor);
+ }
});
});
}
@@ -289,7 +307,7 @@ TABS.firmware_flasher.initialize = function (callback) {
selectTargets.push(target);
var select_e =
$("{1} ".format(
- descriptor.raw_target,
+ descriptor.target_id,
descriptor.target
)).data('summary', descriptor);
boards_e.append(select_e);
@@ -324,6 +342,7 @@ TABS.firmware_flasher.initialize = function (callback) {
$("a.load_remote_file").addClass('disabled');
var target = $(this).children("option:selected").val();
+ var targetDisplay = $(this).children("option:selected").text();
if (!GUI.connect_lock) {
$('.progress').val(0).removeClass('valid invalid');
@@ -336,7 +355,7 @@ TABS.firmware_flasher.initialize = function (callback) {
if(target == 0) {
versions_e.append($("{0} ".format(i18n.getMessage('firmwareFlasherOptionLabelSelectFirmwareVersion'))));
} else {
- versions_e.append($("{0} {1} ".format(i18n.getMessage('firmwareFlasherOptionLabelSelectFirmwareVersionFor'), target)));
+ versions_e.append($("{0} {1} ".format(i18n.getMessage('firmwareFlasherOptionLabelSelectFirmwareVersionFor'), targetDisplay)));
}
if (typeof TABS.firmware_flasher.releases[target]?.forEach === 'function') {
@@ -826,7 +845,7 @@ TABS.firmware_flasher.onOpen = async function(openInfo) {
MSP.send_message(MSPCodes.MSP_API_VERSION, false, false, function () {
if (FC.CONFIG.apiVersion === "0.0.0") {
- GUI_control.prototype.log("Cannot prefetch target: " + i18n.getMessage("illegalStateRestartRequired") + " " + i18n.getMessage("illegalStateRestartRequired") + "
+
+
+
+ Auto-detect GPS Type
+ Manual Settings
+ u-blox M8
+ u-blox M9 (Precision Mode)
+ u-blox M9 (Sport Mode)
+ u-blox M10
+ u-blox M10 (High-Performance)
+
+
+ GPS Configuration Preset
+
+
+
+
+
+
+
+
+
+
+
+ GPS Update Rate (Hz)
+
+
+
-
-
-
diff --git a/tabs/gps.js b/tabs/gps.js
index c882e3737..433ec2be0 100644
--- a/tabs/gps.js
+++ b/tabs/gps.js
@@ -130,7 +130,13 @@ TABS.gps.initialize = function (callback) {
let vehiclesCursorInitialized = false;
let arrowIcon;
- function process_html() {
+ async function process_html(settingsPromise) {
+ // Wait for settings to finish loading to avoid race conditions
+ // where user changes are overwritten by background setting loads
+ if (settingsPromise) {
+ await settingsPromise;
+ }
+
i18n.localize();
var fcFeatures = FC.getFeatures();
@@ -200,6 +206,163 @@ TABS.gps.initialize = function (callback) {
gps_ubx_sbas_e.val(FC.MISC.gps_ubx_sbas);
+ // GPS Preset Configuration
+ const GPS_PRESETS = {
+ m8: {
+ name: "u-blox M8",
+ galileo: true,
+ glonass: true,
+ beidou: true,
+ rate: 8,
+ description: [
+ "4 GNSS constellations for maximum accuracy",
+ "8Hz update rate (conservative for M8)",
+ "Best for: Navigation, position hold, slower aircraft"
+ ]
+ },
+ 'm9-precision': {
+ name: "u-blox M9 (Precision Mode)",
+ galileo: true,
+ glonass: false,
+ beidou: true,
+ rate: 5,
+ description: [
+ "3 GNSS constellations (GPS+Galileo+Beidou) → 32 satellites",
+ "5Hz update rate, HDOP ~1.0-1.3",
+ "Best for: Long-range cruise, position hold, navigation missions"
+ ]
+ },
+ 'm9-sport': {
+ name: "u-blox M9 (Sport Mode)",
+ galileo: true,
+ glonass: false,
+ beidou: true,
+ rate: 10,
+ description: [
+ "3 GNSS constellations (GPS+Galileo+Beidou) → 16 satellites",
+ "10Hz update rate (hardware limit), HDOP ~2.0-2.5",
+ "Best for: Fast flying, racing, acrobatics, quick response"
+ ]
+ },
+ m10: {
+ name: "u-blox M10",
+ galileo: true,
+ glonass: false,
+ beidou: true,
+ rate: 8,
+ description: [
+ "3 GNSS constellations (GPS+Galileo+Beidou)",
+ "8Hz update rate (safe for M10 default CPU clock)",
+ "Best for: General use, balanced performance"
+ ]
+ },
+ 'm10-highperf': {
+ name: "u-blox M10 (High-Performance)",
+ galileo: true,
+ glonass: true,
+ beidou: true,
+ rate: 10,
+ description: [
+ "4 GNSS constellations for maximum satellites",
+ "10Hz update rate (requires high-performance CPU clock)",
+ "Only use if you KNOW your M10 has high-performance clock enabled"
+ ]
+ },
+ manual: {
+ name: "Manual Settings",
+ description: [
+ "Full control over constellation selection and update rate",
+ "For advanced users and special requirements"
+ ]
+ }
+ };
+
+ function detectGPSPreset(hwVersion) {
+ switch(hwVersion) {
+ case 800: return 'm8';
+ case 900: return 'm9-precision'; // Default to precision mode for better accuracy
+ case 1000: return 'm10';
+ default: return 'manual';
+ }
+ }
+
+ function applyGPSPreset(presetId) {
+ // Handle special cases first (before checking GPS_PRESETS)
+ if (presetId === 'manual') {
+ // Enable all controls
+ $('.preset-controlled').prop('disabled', false);
+ $('#gps_ublox_nav_hz').prop('disabled', false);
+ $('#preset_info').hide();
+ return;
+ }
+
+ if (presetId === 'auto') {
+ // Try to auto-detect from FC
+ if (FC.GPS_DATA && FC.GPS_DATA.hwVersion) {
+ const detectedPreset = detectGPSPreset(FC.GPS_DATA.hwVersion);
+ applyGPSPreset(detectedPreset);
+ $('#gps_preset_mode').val(detectedPreset);
+ GUI.log(i18n.getMessage('gpsAutoDetectSuccess') + ' ' + GPS_PRESETS[detectedPreset].name);
+ } else {
+ // Fall back to manual if can't detect
+ applyGPSPreset('manual');
+ $('#gps_preset_mode').val('manual');
+ GUI.log(i18n.getMessage('gpsAutoDetectFailed'));
+ }
+ return;
+ }
+
+ // Normal preset application
+ const preset = GPS_PRESETS[presetId];
+ if (!preset) return;
+
+ // Apply preset values (user can still adjust after applying)
+ $('#gps_use_galileo').prop('checked', preset.galileo);
+ $('#gps_use_glonass').prop('checked', preset.glonass);
+ $('#gps_use_beidou').prop('checked', preset.beidou);
+ $('#gps_ublox_nav_hz').val(preset.rate);
+
+ // Show preset info
+ $('#preset_name').text(preset.name);
+ $('#preset_details').html(preset.description.map(d => `
${d} `).join(''));
+ $('#preset_info').show();
+ }
+
+ // Set up preset mode handler (namespaced to prevent memory leaks)
+ $('#gps_preset_mode').on('change.gpsTab', function() {
+ applyGPSPreset($(this).val());
+ });
+
+ // Hardware detection status indicator
+ function updateHardwareStatus() {
+ if (FC.GPS_DATA && FC.GPS_DATA.hwVersion && FC.GPS_DATA.hwVersion > 0) {
+ const detectedPreset = detectGPSPreset(FC.GPS_DATA.hwVersion);
+ if (detectedPreset && detectedPreset !== 'manual' && GPS_PRESETS[detectedPreset]) {
+ $('#gps_hardware_name').text(GPS_PRESETS[detectedPreset].name + ' detected');
+ $('#gps_hardware_status').show();
+ }
+ }
+ }
+
+ // Handler for "Use optimal settings" link (namespaced)
+ $('#gps_apply_optimal').on('click.gpsTab', function(e) {
+ e.preventDefault();
+ if (FC.GPS_DATA && FC.GPS_DATA.hwVersion) {
+ const detectedPreset = detectGPSPreset(FC.GPS_DATA.hwVersion);
+ if (detectedPreset && detectedPreset !== 'manual') {
+ $('#gps_preset_mode').val(detectedPreset).trigger('change');
+ GUI.log('Applied recommended settings for ' + GPS_PRESETS[detectedPreset].name);
+ }
+ }
+ });
+
+ // Initialize - default to manual mode to preserve user's existing settings
+ // User can explicitly select a preset or use "Auto-detect" if desired
+ applyGPSPreset('manual');
+
+ // Check for hardware detection after a short delay to allow GPS data to arrive
+ setTimeout(updateHardwareStatus, 500);
+
let mapView = new View({
center: [0, 0],
zoom: 15
@@ -240,7 +403,7 @@ TABS.gps.initialize = function (callback) {
}));
}
- $("#center_button").on('click', function () {
+ $("#center_button").on('click.gpsTab', function () {
let lat = FC.GPS_DATA.lat / 10000000;
let lon = FC.GPS_DATA.lon / 10000000;
let center = fromLonLat([lon, lat]);
@@ -417,7 +580,7 @@ TABS.gps.initialize = function (callback) {
textBaseline: "bottom",
offsetY: +40,
padding: [2, 2, 2, 2],
- backgroundFill: '#444444',
+ backgroundFill: new Fill({ color: '#444444' }),
fill: new Fill({color: '#ffffff'}),
})),
});
@@ -466,7 +629,7 @@ TABS.gps.initialize = function (callback) {
});
}
- $('a.save').on('click', function () {
+ $('a.save').on('click.gpsTab', function () {
serialPortHelper.set($port.val(), 'GPS', $baud.val());
features.reset();
features.fromUI($('.tab-gps'));
@@ -517,7 +680,7 @@ TABS.gps.initialize = function (callback) {
}
}
- $('a.loadAssistnowOnline').on('click', function () {
+ $('a.loadAssistnowOnline').on('click.gpsTab', function () {
if(globalSettings.assistnowApiKey != null && globalSettings.assistnowApiKey != '') {
ublox.loadAssistnowOnline(processUbloxData);
} else {
@@ -525,7 +688,7 @@ TABS.gps.initialize = function (callback) {
}
});
- $('a.loadAssistnowOffline').on('click', function () {
+ $('a.loadAssistnowOffline').on('click.gpsTab', function () {
if(globalSettings.assistnowApiKey != null && globalSettings.assistnowApiKey != '') {
ublox.loadAssistnowOffline(processUbloxData);
} else {
@@ -539,6 +702,14 @@ TABS.gps.initialize = function (callback) {
};
TABS.gps.cleanup = function (callback) {
+ // Remove all namespaced event handlers to prevent memory leaks
+ $('#gps_preset_mode').off('.gpsTab');
+ $('#gps_apply_optimal').off('.gpsTab');
+ $('#center_button').off('.gpsTab');
+ $('a.save').off('.gpsTab');
+ $('a.loadAssistnowOnline').off('.gpsTab');
+ $('a.loadAssistnowOffline').off('.gpsTab');
+
if (callback) callback();
if (TABS.gps.toolboxAdsbVehicle){
TABS.gps.toolboxAdsbVehicle.close();
diff --git a/tabs/javascript_programming.html b/tabs/javascript_programming.html
index 60f9c5fbe..dd5889f0e 100644
--- a/tabs/javascript_programming.html
+++ b/tabs/javascript_programming.html
@@ -217,5 +217,43 @@
.note_spacer p {
margin-bottom: 10px;
}
+
+/* Active LC gutter marker - green checkmark for true conditions */
+.lc-active-true {
+ background: url('data:image/svg+xml;utf8,
') no-repeat center;
+ background-size: 16px 16px;
+ width: 16px;
+ margin-left: 3px;
+ cursor: pointer;
+}
+
+/* Inactive LC gutter marker - gray hollow circle for false conditions */
+.lc-active-false {
+ background: url('data:image/svg+xml;utf8,
') no-repeat center;
+ background-size: 16px 16px;
+ width: 16px;
+ margin-left: 3px;
+ cursor: pointer;
+}
+
+/* Monaco gutter margin styling */
+.monaco-editor .margin {
+ background-color: #f5f5f5;
+}
+
+.monaco-editor .margin-view-overlays .lc-active-true,
+.monaco-editor .margin-view-overlays .lc-active-false {
+ cursor: pointer;
+}
+
+/* Gvar display inline hints */
+.gvar-hint {
+ opacity: 0.65;
+ font-style: italic;
+ color: #888;
+ white-space: nowrap;
+ display: inline;
+ vertical-align: baseline;
+}
diff --git a/tabs/javascript_programming.js b/tabs/javascript_programming.js
index 3cfcacf0a..3df52f877 100644
--- a/tabs/javascript_programming.js
+++ b/tabs/javascript_programming.js
@@ -11,9 +11,12 @@ import mspHelper from './../js/msp/MSPHelper.js';
import { GUI, TABS } from './../js/gui.js';
import FC from './../js/fc.js';
import i18n from './../js/localization.js';
+import interval from './../js/intervals.js';
import { Transpiler } from './../js/transpiler/index.js';
import { Decompiler } from './../js/transpiler/transpiler/decompiler.js';
import * as MonacoLoader from './../js/transpiler/editor/monaco_loader.js';
+import * as LCHighlighting from './../js/transpiler/lc_highlighting.js';
+import * as GvarDisplay from './../js/transpiler/gvar_display.js';
import examples from './../js/transpiler/examples/index.js';
import settingsCache from './../js/settingsCache.js';
import * as monaco from 'monaco-editor';
@@ -38,6 +41,14 @@ TABS.javascript_programming = {
decompiler: null,
currentCode: '',
+ // Active LC highlighting state
+ lcToLineMapping: {},
+ activeDecorations: [],
+ statusChainer: null,
+
+ // Gvar display state
+ gvarWidgets: [],
+
analyticsChanges: {},
initialize: function (callback) {
@@ -52,6 +63,9 @@ TABS.javascript_programming = {
try {
self.initTranspiler();
+ // Store monaco reference for use in highlighting
+ self.monaco = monaco;
+
// Initialize editor with INAV configuration
self.editor = MonacoLoader.initializeMonacoEditor(monaco, 'monaco-editor');
@@ -71,15 +85,17 @@ TABS.javascript_programming = {
self.loadFromFC(function() {
self.isDirty = false;
+ self.updateSaveButtonState();
// Set up dirty tracking AFTER initial load to avoid marking as dirty during decompilation
self.editor.onDidChangeModelContent(function() {
- if (!self.isDirty) {
- console.log('[JavaScript Programming] Editor marked as dirty (unsaved changes)');
- }
self.isDirty = true;
+ self.updateSaveButtonState();
});
+ // Set up LC status polling for active highlighting
+ self.setupActiveHighlighting();
+
// Localize i18n strings
i18n.localize();
@@ -157,6 +173,7 @@ if (inav.flight.homeDistance > 100) {
if (confirm('Clear editor? This cannot be undone.')) {
self.editor.setValue(self.getDefaultCode());
self.isDirty = false;
+ self.updateSaveButtonState();
}
});
@@ -185,8 +202,7 @@ if (inav.flight.homeDistance > 100) {
});
},
- /*
- **
+ /**
* Load a specific example into the editor
* @param {string} exampleId - The ID of the example to load
*/
@@ -214,13 +230,13 @@ if (inav.flight.homeDistance > 100) {
// Set the code in the editor
if (self.editor && self.editor.setValue) {
self.editor.setValue(example.code);
- console.log('Loaded example:', example.name);
} else {
console.error('Editor not initialized');
}
// Mark as dirty since we changed the code
self.isDirty = true;
+ self.updateSaveButtonState();
} catch (error) {
console.error('Failed to load example:', error);
@@ -282,13 +298,30 @@ if (inav.flight.homeDistance > 100) {
}
});
- console.log('Examples dropdown populated with', Object.keys(examples).length, 'examples');
-
} catch (error) {
console.error('Failed to load examples:', error);
}
},
+ /**
+ * Update Save button state based on isDirty flag
+ * Disables Save button when code matches FC (isDirty = false)
+ */
+ updateSaveButtonState: function() {
+ const $saveButton = $('.tab-programming .save');
+
+ if (!$saveButton.length) {
+ return;
+ }
+
+ if (this.isDirty) {
+ // Code has been modified - enable Save button
+ $saveButton.removeClass('disabled');
+ } else {
+ // Code matches FC - disable Save button
+ $saveButton.addClass('disabled');
+ }
+ },
/**
* Transpile JavaScript to INAV logic conditions
@@ -337,6 +370,11 @@ if (inav.flight.homeDistance > 100) {
GUI.log(`Transpiled successfully: ${result.logicConditionCount}/64 logic conditions`);
+ // Store LC-to-line mapping for transpiler-side highlighting
+ if (result.lcToLineMapping) {
+ self.lcToLineMapping = result.lcToLineMapping;
+ }
+
} else {
// Show error
this.showError(result.error);
@@ -482,7 +520,14 @@ if (inav.flight.homeDistance > 100) {
if (!logicConditions || logicConditions.length === 0) {
GUI.log(i18n.getMessage('noLogicConditions') || 'No logic conditions found on FC');
self.editor.setValue(self.getDefaultCode());
- self.isDirty = false;
+ // Clear isDirty flag AFTER setValue completes
+ setTimeout(() => {
+ self.isDirty = false;
+ self.updateSaveButtonState();
+ }, 0);
+ // Clear stale mapping and decorations
+ self.lcToLineMapping = {};
+ self.clearActiveHighlighting();
if (callback) callback();
return;
}
@@ -504,7 +549,6 @@ if (inav.flight.homeDistance > 100) {
let_variables: {},
var_variables: {}
};
- console.log('Variable map retrieved:', variableMap);
// Decompile to JavaScript
try {
@@ -514,6 +558,12 @@ if (inav.flight.homeDistance > 100) {
// Set the decompiled code
self.editor.setValue(result.code);
+ // Clear old decorations before setting new mapping
+ self.clearActiveHighlighting();
+
+ // Store LC-to-line mapping for active highlighting
+ self.lcToLineMapping = result.lcToLineMapping || {};
+
// Show stats
if (result.stats) {
GUI.log(
@@ -529,13 +579,18 @@ if (inav.flight.homeDistance > 100) {
$('#transpiler-warnings').hide();
}
- self.isDirty = false;
+ // Clear isDirty flag AFTER setValue completes (setValue triggers onChange asynchronously)
+ setTimeout(() => {
+ self.isDirty = false;
+ self.updateSaveButtonState();
+ }, 0);
} else {
// Decompilation failed
GUI.log('Decompilation failed: ' + result.error);
self.showError('Decompilation failed: ' + result.error);
self.editor.setValue(result.code || self.getDefaultCode());
self.isDirty = false;
+ self.updateSaveButtonState();
}
} catch (error) {
@@ -544,6 +599,7 @@ if (inav.flight.homeDistance > 100) {
self.showError('Decompilation error: ' + error.message);
self.editor.setValue(self.getDefaultCode());
self.isDirty = false;
+ self.updateSaveButtonState();
}
if (callback) callback();
@@ -612,6 +668,11 @@ if (inav.flight.homeDistance > 100) {
return;
}
+ // Store LC-to-line mapping for transpiler-side highlighting
+ if (result.lcToLineMapping) {
+ self.lcToLineMapping = result.lcToLineMapping;
+ }
+
// Confirm save
const confirmMsg = i18n.getMessage('confirmSaveLogicConditions') ||
`Save ${result.logicConditionCount} logic conditions to flight controller?`;
@@ -624,7 +685,6 @@ if (inav.flight.homeDistance > 100) {
// Store variable map for preservation between sessions
if (result.variableMap) {
settingsCache.set('javascript_variables', result.variableMap);
- console.log('Variable map stored:', result.variableMap);
}
// Clear existing logic conditions
@@ -711,6 +771,7 @@ if (inav.flight.homeDistance > 100) {
saveChainer.setExitPoint(function() {
GUI.log(i18n.getMessage('logicConditionsSaved') || 'Logic conditions saved successfully');
self.isDirty = false;
+ self.updateSaveButtonState();
// Optionally reboot (commented out for safety - user can reboot manually)
// const shouldReboot = confirm('Reboot flight controller to apply changes?');
@@ -735,8 +796,158 @@ if (inav.flight.homeDistance > 100) {
});
},
+ /**
+ * Set up active LC highlighting with status polling
+ */
+ setupActiveHighlighting: function() {
+ const self = this;
+
+ // Prevent duplicate polling loops if initialize/setup runs multiple times
+ interval.remove('js_programming_lc_highlight');
+
+ // Prevent overlapping MSP requests
+ self._lcPollInFlight = false;
+
+ self.statusChainer = new MSPChainerClass();
+ self.statusChainer.setChain([
+ mspHelper.loadLogicConditionsStatus,
+ mspHelper.loadGlobalVariablesStatus
+ ]);
+ self.statusChainer.setExitPoint(function() {
+ try {
+ self.updateActiveHighlighting();
+ } catch (error) {
+ console.error('[JavaScript Programming] Active highlighting update failed:', error);
+ }
+
+ try {
+ self.updateGvarDisplay();
+ } catch (error) {
+ console.error('[JavaScript Programming] Gvar display update failed:', error);
+ }
+
+ self._lcPollInFlight = false;
+ });
+
+ // Start 500ms polling interval (2Hz - sufficient for debugging without saturating MSP)
+ interval.add('js_programming_lc_highlight', function() {
+ if (!self.statusChainer || self._lcPollInFlight) return;
+ self._lcPollInFlight = true;
+ self.statusChainer.execute();
+ }, 500);
+ },
+
+ /**
+ * Update active LC highlighting based on current status
+ */
+ updateActiveHighlighting: function() {
+ const self = this;
+
+ // Check if FC data is available first (short-circuit if disconnected)
+ if (!FC.LOGIC_CONDITIONS_STATUS || !FC.LOGIC_CONDITIONS) {
+ return;
+ }
+
+ const lcStatus = FC.LOGIC_CONDITIONS_STATUS.getAll();
+ const lcConditions = FC.LOGIC_CONDITIONS.get();
+
+ // Verify data is loaded and has expected types
+ if (!Array.isArray(lcStatus) || !Array.isArray(lcConditions)) {
+ return;
+ }
+
+ // Don't highlight if code has been modified
+ if (self.isDirty) {
+ self.clearActiveHighlighting();
+ return;
+ }
+
+ // Don't highlight if no mapping available
+ if (!self.lcToLineMapping || Object.keys(self.lcToLineMapping).length === 0) {
+ return;
+ }
+
+ // Categorize LCs by status (TRUE/FALSE)
+ const { trueLCs, falseLCs } = LCHighlighting.categorizeLCsByStatus(
+ lcStatus,
+ lcConditions,
+ self.lcToLineMapping
+ );
+
+ // Map LCs to editor line numbers with combined status
+ const lineStatus = LCHighlighting.mapLCsToLines(
+ trueLCs,
+ falseLCs,
+ self.lcToLineMapping
+ );
+
+ // Create Monaco decorations from line status
+ const decorations = LCHighlighting.createMonacoDecorations(lineStatus, self.monaco);
+
+ // Apply decorations to editor
+ self.activeDecorations = LCHighlighting.applyDecorations(
+ self.editor,
+ self.activeDecorations,
+ decorations
+ );
+ },
+
+ /**
+ * Clear all active LC highlighting
+ */
+ clearActiveHighlighting: function() {
+ const self = this;
+ self.activeDecorations = LCHighlighting.clearDecorations(
+ self.editor,
+ self.activeDecorations
+ );
+ },
+
+ /**
+ * Update inline gvar value display
+ * Shows non-zero gvar values as inline hints next to references
+ */
+ updateGvarDisplay: function() {
+ const self = this;
+
+ if (!self.editor || !FC.GLOBAL_VARIABLES_STATUS) {
+ return;
+ }
+
+ const code = self.editor.getValue();
+ const gvarRefs = GvarDisplay.findGvarReferences(code);
+
+ if (gvarRefs.length === 0) {
+ self.gvarWidgets = GvarDisplay.clearWidgets(
+ self.editor,
+ self.gvarWidgets
+ );
+ return;
+ }
+
+ const gvarValues = FC.GLOBAL_VARIABLES_STATUS.getAll();
+
+ const widgets = GvarDisplay.createGvarWidgets(
+ self.editor,
+ gvarRefs,
+ gvarValues
+ );
+
+ self.gvarWidgets = GvarDisplay.applyWidgets(
+ self.editor,
+ self.gvarWidgets,
+ widgets
+ );
+ },
+
cleanup: function (callback) {
- console.log('[JavaScript Programming] cleanup() - disposing editor');
+ interval.remove('js_programming_lc_highlight');
+ this.clearActiveHighlighting();
+ this.gvarWidgets = GvarDisplay.clearWidgets(
+ this.editor,
+ this.gvarWidgets
+ );
+ this.statusChainer = null;
// Dispose Monaco editor
// Note: Unsaved changes are checked BEFORE cleanup() is called:
diff --git a/tabs/led_strip.html b/tabs/led_strip.html
index cb26e66d1..123873fba 100644
--- a/tabs/led_strip.html
+++ b/tabs/led_strip.html
@@ -6,24 +6,30 @@
-