esp32tool 1.6.6 → 1.6.7

package/js/script.js

@@ -1,8 +1,8 @@
 // Import WebUSB serial support for Android compatibility
-import { WebUSBSerial, requestSerialPort } from './webusb-serial.js';
-import { ESP32ToolConsole } from './console.js';
-import { HexEditor } from './hex-editor.js';
-import { NVSEditor } from './nvs-editor.js';
+import { WebUSBSerial, requestSerialPort } from "./webusb-serial.js";
+import { ESP32ToolConsole } from "./console.js";
+import { HexEditor } from "./hex-editor.js";
+import { NVSEditor } from "./nvs-editor.js";
 
 // Make requestSerialPort available globally for esptool.js
 // Use defensive assignment to avoid accidental overwrites
@@ -25,7 +25,7 @@ let espStub;
 let esp32s2ReconnectInProgress = false;
 let currentLittleFS = null;
 let currentLittleFSPartition = null;
-let currentLittleFSPath = '/';
+let currentLittleFSPath = "/";
 let currentLittleFSBlockSize = 4096;
 let currentFilesystemType = null; // 'littlefs', 'fatfs', or 'spiffs'
 let littlefsModulePromise = null; // Cache for LittleFS WASM module
@@ -47,12 +47,16 @@ let consoleBootloaderHandlerModule = null;
  * Get display name for current filesystem type
  */
 function getFilesystemDisplayName() {
-  if (!currentFilesystemType) return 'Filesystem';
+  if (!currentFilesystemType) return "Filesystem";
   switch (currentFilesystemType) {
-    case 'littlefs': return 'LittleFS';
-    case 'fatfs': return 'FatFS';
-    case 'spiffs': return 'SPIFFS';
-    default: return 'Filesystem';
+    case "littlefs":
+      return "LittleFS";
+    case "fatfs":
+      return "FatFS";
+    case "spiffs":
+      return "SPIFFS";
+    default:
+      return "Filesystem";
   }
 }
 
@@ -64,71 +68,75 @@ function clearAllCachedData() {
   if (currentLittleFS) {
     try {
       // Only call destroy if it exists (LittleFS has it, FatFS/SPIFFS don't)
-      if (typeof currentLittleFS.destroy === 'function') {
+      if (typeof currentLittleFS.destroy === "function") {
         currentLittleFS.destroy();
       }
     } catch (e) {
-      debugMsg('Error destroying filesystem: ' + e);
+      debugMsg("Error destroying filesystem: " + e);
     }
   }
-  
+
   // Reset filesystem state
   currentLittleFS = null;
   currentLittleFSPartition = null;
-  currentLittleFSPath = '/';
+  currentLittleFSPath = "/";
   currentLittleFSBlockSize = 4096;
   currentFilesystemType = null;
   lastReadFlashData = null;
   currentChipName = null;
   currentMacAddr = null;
-  
+
   // Hide filesystem manager
-  littlefsManager.classList.add('hidden');
-  
+  littlefsManager.classList.add("hidden");
+
   // Clear partition list
-  partitionList.innerHTML = '';
-  partitionList.classList.add('hidden');
-  
+  partitionList.innerHTML = "";
+  partitionList.classList.add("hidden");
+
   // Show the Read Partition Table button again
-  butReadPartitions.classList.remove('hidden');
-  
+  butReadPartitions.classList.remove("hidden");
+
   // Close NVS editor if open
   if (nvsEditorInstance) {
-    try { nvsEditorInstance.close(); } catch (_) {}
+    try {
+      nvsEditorInstance.close();
+    } catch (_) {}
     nvsEditorInstance = null;
   }
-  nvseditorContainer.classList.add('hidden');
-  document.body.classList.remove('nvseditor-active');
-  
+  nvseditorContainer.classList.add("hidden");
+  document.body.classList.remove("nvseditor-active");
+
   // Hide Detect FS button
-  butDetectFS.classList.add('hidden');
-  
+  butDetectFS.classList.add("hidden");
+
   // Hide Open FS Manager button (if it exists)
   if (butOpenFSManager) {
-    butOpenFSManager.classList.add('hidden');
+    butOpenFSManager.classList.add("hidden");
   }
-  
+
   // Hide ESP8266 info (if it exists)
-  const esp8266Info = document.getElementById('esp8266Info');
+  const esp8266Info = document.getElementById("esp8266Info");
   if (esp8266Info) {
-    esp8266Info.classList.add('hidden');
+    esp8266Info.classList.add("hidden");
   }
-  
+
   // Clear file input
   if (littlefsFileInput) {
-    littlefsFileInput.value = '';
+    littlefsFileInput.value = "";
   }
-  
+
   // Reset buttons
   butLittlefsUpload.disabled = true;
-  
+
   // Clear any cached module promises
   littlefsModulePromise = null;
-  
-  logMsg('All cached data cleared');
+
+  logMsg("All cached data cleared");
 }
 
-const baudRates = [2000000, 1500000, 921600, 500000, 460800, 230400, 153600, 128000, 115200];
+const baudRates = [
+  2000000, 1500000, 921600, 500000, 460800, 230400, 153600, 128000, 115200,
+];
 
 // Advanced read flash parameters
 // chunkSize: Amount of data to request from ESP in one command (in KB)
@@ -138,7 +146,7 @@ const chunkSizes = [
   { label: "16 KB (WebUSB)", value: 0x4000 },
   { label: "64 KB", value: 0x10000 },
   { label: "128 KB (Desktop)", value: 0x20000 },
-  { label: "256 KB", value: 0x40000 }
+  { label: "256 KB", value: 0x40000 },
 ];
 
 // blockSize: Size of each data block sent by ESP (in bytes)
@@ -154,7 +162,7 @@ const blockSizes = [
   { label: "1024 B", value: 1024 },
   { label: "1984 B", value: 1984 },
   { label: "2024 B", value: 2024 },
-  { label: "3968 B (Desktop)", value: 3968 }
+  { label: "3968 B (Desktop)", value: 3968 },
 ];
 
 // maxInFlight: Maximum unacknowledged bytes (in bytes)
@@ -176,7 +184,7 @@ const maxInFlights = [
   { label: "31744 B", value: 31744 },
   { label: "63488 B", value: 63488 },
   { label: "126976 B", value: 126976 },
-  { label: "253952 B", value: 253952 }
+  { label: "253952 B", value: 253952 },
 ];
 
 // Check if running in Electron
@@ -248,7 +256,7 @@ const nvseditorContainer = document.getElementById("nvseditor-container");
 
 // NVS and partition table layout constants
 const PARTITION_TABLE_OFFSET = 0x8000;
-const PARTITION_TABLE_SIZE   = 0x1000;
+const PARTITION_TABLE_SIZE = 0x1000;
 
 let currentViewedFile = null;
 let currentViewedFileData = null;
@@ -256,17 +264,18 @@ let currentViewedFileData = null;
 // Mobile detection
 function isMobileDevice() {
   const userAgent = navigator.userAgent || navigator.vendor || window.opera;
-  
+
   // Check for mobile user agents
-  const mobileRegex = /Android|webOS|iPhone|iPad|iPod|BlackBerry|IEMobile|Opera Mini/i;
+  const mobileRegex =
+    /Android|webOS|iPhone|iPad|iPod|BlackBerry|IEMobile|Opera Mini/i;
   const isMobileUA = mobileRegex.test(userAgent);
-  
+
   // Check for touch support
-  const hasTouch = 'ontouchstart' in window || navigator.maxTouchPoints > 0;
-  
+  const hasTouch = "ontouchstart" in window || navigator.maxTouchPoints > 0;
+
   // Check screen size
   const isSmallScreen = window.innerWidth <= 768;
-  
+
   return isMobileUA || (hasTouch && isSmallScreen);
 }
 
@@ -277,20 +286,20 @@ function isMobileDevice() {
  */
 function isUsingWebUSB() {
   // If we have an active connection, check the port's isWebUSB property
-  if (espStub && espStub.port && typeof espStub.port.isWebUSB !== 'undefined') {
+  if (espStub && espStub.port && typeof espStub.port.isWebUSB !== "undefined") {
     return espStub.port.isWebUSB === true;
   }
-  
+
   // Fallback: Check if we're on a mobile device (likely using WebUSB)
   if (isMobileDevice()) {
     return true;
   }
-  
+
   // Check if Web Serial is NOT available but USB is (WebUSB only)
   if (!("serial" in navigator) && "usb" in navigator) {
     return true;
   }
-  
+
   // Default to Web Serial (desktop)
   return false;
 }
@@ -302,26 +311,26 @@ function isUsingWebUSB() {
  */
 function getDefaultAdvancedParams() {
   const isWebUSB = isUsingWebUSB();
-  
+
   return {
-    chunkSize: isWebUSB ? 0x4000 : 0x20000,  // 16 KB for WebUSB, 128 KB for Desktop
-    blockSize: isWebUSB ? 248 : 3968,         // 248 B for WebUSB, 3968 B for Desktop
-    maxInFlight: isWebUSB ? 248 : 15872       // 248 B for WebUSB, 15872 B for Desktop
+    chunkSize: isWebUSB ? 0x4000 : 0x20000, // 16 KB for WebUSB, 128 KB for Desktop
+    blockSize: isWebUSB ? 248 : 3968, // 248 B for WebUSB, 3968 B for Desktop
+    maxInFlight: isWebUSB ? 248 : 15872, // 248 B for WebUSB, 15872 B for Desktop
   };
 }
 
 // Update mobile classes and padding
 function updateMobileClasses() {
   const isMobile = isMobileDevice();
-  
+
   if (isMobile) {
-    document.body.classList.add('mobile-device');
-    document.body.classList.add('no-hover');
+    document.body.classList.add("mobile-device");
+    document.body.classList.add("no-hover");
   } else {
-    document.body.classList.remove('mobile-device');
-    document.body.classList.remove('no-hover');
+    document.body.classList.remove("mobile-device");
+    document.body.classList.remove("no-hover");
   }
-  
+
   // Update main padding to match header height
   updateMainPadding();
 }
@@ -346,13 +355,13 @@ const debouncedUpdateMobileClasses = debounce(updateMobileClasses, 250);
 updateMobileClasses();
 
 // Update on resize and orientation change
-window.addEventListener('resize', debouncedUpdateMobileClasses);
-window.addEventListener('orientationchange', debouncedUpdateMobileClasses);
+window.addEventListener("resize", debouncedUpdateMobileClasses);
+window.addEventListener("orientationchange", debouncedUpdateMobileClasses);
 
 document.addEventListener("DOMContentLoaded", () => {
   butConnect.addEventListener("click", () => {
     clickConnect().catch(async (e) => {
-      debugMsg('Connection error: ' + e);
+      debugMsg("Connection error: " + e);
       errorMsg(e.message || e);
       if (espStub) {
         await espStub.disconnect();
@@ -378,8 +387,8 @@ document.addEventListener("DOMContentLoaded", () => {
   butLittlefsMkdir.addEventListener("click", clickLittlefsMkdir);
   butCloseFileViewer.addEventListener("click", closeFileViewer);
   butDownloadFromViewer.addEventListener("click", downloadFromViewer);
-  tabText.addEventListener("click", () => switchViewerTab('text'));
-  tabHex.addEventListener("click", () => switchViewerTab('hex'));
+  tabText.addEventListener("click", () => switchViewerTab("text"));
+  tabHex.addEventListener("click", () => switchViewerTab("hex"));
   littlefsFileInput.addEventListener("change", () => {
     butLittlefsUpload.disabled = !littlefsFileInput.files.length;
   });
@@ -389,10 +398,10 @@ document.addEventListener("DOMContentLoaded", () => {
   for (let i = 0; i < offsets.length; i++) {
     offsets[i].addEventListener("change", checkProgrammable);
   }
-  
+
   // Initialize upload rows visibility - only show first row
   updateUploadRowsVisibility();
-  
+
   bindCheckboxSetting(autoscroll, "autoscroll");
   consoleSwitch.addEventListener("click", clickConsole);
   baudRateSelect.addEventListener("change", changeBaudRate);
@@ -401,7 +410,9 @@ document.addEventListener("DOMContentLoaded", () => {
   blockSizeSelect.addEventListener("change", changeAdvancedParam);
   maxInFlightSelect.addEventListener("change", changeAdvancedParam);
   bindCheckboxSetting(darkMode, "darkmode", () => updateTheme());
-  bindCheckboxSetting(debugMode, "debugmode", (v) => logMsg("Debug mode " + (v ? "enabled" : "disabled")));
+  bindCheckboxSetting(debugMode, "debugmode", (v) =>
+    logMsg("Debug mode " + (v ? "enabled" : "disabled")),
+  );
   bindCheckboxSetting(showLog, "showlog", () => updateLogVisibility());
   window.addEventListener("error", function (event) {
     console.log("Got an uncaught error: ", event.error);
@@ -418,7 +429,7 @@ document.addEventListener("DOMContentLoaded", () => {
   loadAllSettings();
   updateTheme();
   logMsg("ESP32Tool loaded.");
-  
+
   // Set initial main padding based on header height
   updateMainPadding();
 });
@@ -435,7 +446,7 @@ function initBaudRate() {
 function initAdvancedParams() {
   // Get default values based on environment (Desktop vs WebUSB)
   const defaults = getDefaultAdvancedParams();
-  
+
   // Initialize chunkSize dropdown
   for (let item of chunkSizes) {
     const option = document.createElement("option");
@@ -474,37 +485,45 @@ function initAdvancedParams() {
 function updateAdvancedParamsForConnection() {
   // Get the correct defaults based on actual connection
   const defaults = getDefaultAdvancedParams();
-  
+
   // Get current values
   const currentChunkSize = parseInt(chunkSizeSelect.value);
   const currentBlockSize = parseInt(blockSizeSelect.value);
   const currentMaxInFlight = parseInt(maxInFlightSelect.value);
-  
+
   // Check if values are at old defaults (need updating)
-  const oldWebUSBDefaults = { chunkSize: 0x4000, blockSize: 248, maxInFlight: 248 };
-  const oldDesktopDefaults = { chunkSize: 0x40000, blockSize: 3968, maxInFlight: 15872 };
-  
-  const isAtWebUSBDefaults = 
+  const oldWebUSBDefaults = {
+    chunkSize: 0x4000,
+    blockSize: 248,
+    maxInFlight: 248,
+  };
+  const oldDesktopDefaults = {
+    chunkSize: 0x40000,
+    blockSize: 3968,
+    maxInFlight: 15872,
+  };
+
+  const isAtWebUSBDefaults =
     currentChunkSize === oldWebUSBDefaults.chunkSize &&
     currentBlockSize === oldWebUSBDefaults.blockSize &&
     currentMaxInFlight === oldWebUSBDefaults.maxInFlight;
-    
-  const isAtDesktopDefaults = 
+
+  const isAtDesktopDefaults =
     currentChunkSize === oldDesktopDefaults.chunkSize &&
     currentBlockSize === oldDesktopDefaults.blockSize &&
     currentMaxInFlight === oldDesktopDefaults.maxInFlight;
-  
+
   // Only update if at defaults (user hasn't customized)
   if (isAtWebUSBDefaults || isAtDesktopDefaults) {
     chunkSizeSelect.value = defaults.chunkSize;
     blockSizeSelect.value = defaults.blockSize;
     maxInFlightSelect.value = defaults.maxInFlight;
-    
+
     // Save the new values
     saveSetting("chunkSize", defaults.chunkSize);
     saveSetting("blockSize", defaults.blockSize);
     saveSetting("maxInFlight", defaults.maxInFlight);
-    
+
     const connectionType = isUsingWebUSB() ? "WebUSB" : "Web Serial";
     debugMsg(`Advanced parameters updated for ${connectionType} connection`);
   }
@@ -606,7 +625,10 @@ function buildAdvancedOptions() {
 
   const chunkSize = validate("chunkSize", parseInt(chunkSizeSelect.value));
   const blockSize = validate("blockSize", parseInt(blockSizeSelect.value));
-  const maxInFlight = validate("maxInFlight", parseInt(maxInFlightSelect.value));
+  const maxInFlight = validate(
+    "maxInFlight",
+    parseInt(maxInFlightSelect.value),
+  );
 
   // blockSize and maxInFlight must both be finite or both non-finite
   const hasBlockSize = Number.isFinite(blockSize);
@@ -624,10 +646,10 @@ function buildAdvancedOptions() {
  * @returns {number} Size in bytes
  */
 function parseFlashSize(sizeStr) {
-  if (!sizeStr || typeof sizeStr !== 'string') {
+  if (!sizeStr || typeof sizeStr !== "string") {
     return 0;
   }
-  
+
   // Extract number and unit
   const match = sizeStr.match(/^(\d+)(KB|MB)$/i);
   if (!match) {
@@ -635,16 +657,16 @@ function parseFlashSize(sizeStr) {
     const num = parseInt(sizeStr);
     return isNaN(num) ? 0 : num * 1024 * 1024;
   }
-  
+
   const value = parseInt(match[1]);
   const unit = match[2].toUpperCase();
-  
-  if (unit === 'KB') {
+
+  if (unit === "KB") {
     return value * 1024; // KB to bytes
-  } else if (unit === 'MB') {
+  } else if (unit === "MB") {
     return value * 1024 * 1024; // MB to bytes
   }
-  
+
   return 0;
 }
 
@@ -653,15 +675,15 @@ function parseFlashSize(sizeStr) {
  * Click handler for the connect/disconnect button.
  */
 async function clickConnect() {
-  console.log('[clickConnect] Function called');
-  
+  console.log("[clickConnect] Function called");
+
   if (espStub) {
-    console.log('[clickConnect] Already connected, disconnecting...');
+    console.log("[clickConnect] Already connected, disconnecting...");
     // Remove disconnect event listener to prevent it from firing during manual disconnect
     if (espStub.handleDisconnect) {
       espStub.removeEventListener("disconnect", espStub.handleDisconnect);
     }
-    
+
     await espStub.disconnect();
     try {
       await espStub.port?.close?.();
@@ -670,32 +692,32 @@ async function clickConnect() {
     }
     toggleUIConnected(false);
     espStub = undefined;
-    
+
     // Clear all cached data and state
     clearAllCachedData();
-    
+
     return;
   }
 
-  console.log('[clickConnect] Getting esploaderMod...');
+  console.log("[clickConnect] Getting esploaderMod...");
   const esploaderMod = await window.esptoolPackage;
 
   // Platform detection: Android always uses WebUSB, Desktop uses Web Serial
-  const userAgent = navigator.userAgent || '';
+  const userAgent = navigator.userAgent || "";
   const isAndroid = /Android/i.test(userAgent);
-  
+
   // Only log platform details to UI in debug mode (avoid fingerprinting surface)
   if (debugMode.checked) {
-    const platformMsg = `Platform: ${isAndroid ? 'Android' : 'Desktop'} (UA: ${userAgent.substring(0, 50)}...)`;
+    const platformMsg = `Platform: ${isAndroid ? "Android" : "Desktop"} (UA: ${userAgent.substring(0, 50)}...)`;
     logMsg(platformMsg);
   }
-  logMsg(`Using: ${isAndroid ? 'WebUSB' : 'Web Serial'}`);
-  
+  logMsg(`Using: ${isAndroid ? "WebUSB" : "Web Serial"}`);
+
   let esploader;
-  
+
   if (isAndroid) {
     // Android: Use WebUSB directly
-    console.log('[Connect] Using WebUSB for Android');
+    console.log("[Connect] Using WebUSB for Android");
     try {
       const port = await WebUSBSerial.requestPort((...args) => logMsg(...args));
       esploader = await esploaderMod.connectWithPort(port, {
@@ -709,14 +731,14 @@ async function clickConnect() {
     }
   } else {
     // Desktop: Use Web Serial (standard esptool connect)
-    console.log('[Connect] Using Web Serial for Desktop');
+    console.log("[Connect] Using Web Serial for Desktop");
     esploader = await esploaderMod.connect({
       log: (...args) => logMsg(...args),
       debug: (...args) => debugMsg(...args),
       error: (...args) => errorMsg(...args),
     });
   }
-  
+
   // Handle ESP32-S2 Native USB reconnection requirement for BROWSER
   // Only add listener if not already in reconnect mode
   if (!esp32s2ReconnectInProgress) {
@@ -725,13 +747,13 @@ async function clickConnect() {
       if (esp32s2ReconnectInProgress) {
         return;
       }
-      
+
       esp32s2ReconnectInProgress = true;
       logMsg("ESP32-S2 Native USB detected!");
       toggleUIConnected(false);
       const previousStubPort = espStub?.port;
       espStub = undefined;
-      
+
       try {
         // Close the port first
         await esploader.port.close();
@@ -744,20 +766,20 @@ async function clickConnect() {
         // Ignore port close errors
         debugMsg(`Port close error (ignored): ${closeErr.message}`);
       }
-      
+
       // Show modal dialog
       const modal = document.getElementById("esp32s2Modal");
       const reconnectBtn = document.getElementById("butReconnectS2");
-        
+
       modal.classList.remove("hidden");
-        
+
       // Handle reconnect button click
       const handleReconnect = async () => {
         modal.classList.add("hidden");
         reconnectBtn.removeEventListener("click", handleReconnect);
-          
+
         logMsg("Requesting new device selection...");
-          
+
         // Trigger port selection
         try {
           await clickConnect();
@@ -772,7 +794,7 @@ async function clickConnect() {
       reconnectBtn.addEventListener("click", handleReconnect);
     });
   }
-  
+
   try {
     await esploader.initialize();
   } catch (err) {
@@ -781,7 +803,7 @@ async function clickConnect() {
       logMsg("Initialization interrupted for ESP32-S2 reconnection.");
       return;
     }
-    
+
     // Not ESP32-S2 or other error
     try {
       await esploader.disconnect();
@@ -799,52 +821,53 @@ async function clickConnect() {
   currentMacAddr = formatMacAddr(esploader.macAddr());
 
   espStub = await esploader.runStub();
-  
+
   // Update advanced parameters based on actual connection type (WebUSB vs Web Serial)
   // Only update if user hasn't manually changed them (still at defaults)
   updateAdvancedParamsForConnection();
-  
+
   toggleUIConnected(true);
   toggleUIToolbar(true);
-  
+
   // Auto-initialize console if it was enabled before
   if (consoleSwitch.checked) {
     logMsg("Auto-initializing console from saved settings...");
     await clickConsole();
   }
-  
+
   // Check if ESP8266 and show filesystem button
-  const isESP8266 = currentChipName && currentChipName.toUpperCase().includes("ESP8266");
+  const isESP8266 =
+    currentChipName && currentChipName.toUpperCase().includes("ESP8266");
   if (isESP8266) {
     // Hide partition table button for ESP8266
-    butReadPartitions.classList.add('hidden');
-    butNVSEditor.classList.add('hidden');
-    
+    butReadPartitions.classList.add("hidden");
+    butNVSEditor.classList.add("hidden");
+
     // Show ESP8266 filesystem detection button
-    butDetectFS.classList.remove('hidden');
+    butDetectFS.classList.remove("hidden");
   } else {
     // Show partition table button for ESP32
-    butReadPartitions.classList.remove('hidden');
-    butNVSEditor.classList.remove('hidden');
-    
+    butReadPartitions.classList.remove("hidden");
+    butNVSEditor.classList.remove("hidden");
+
     // Hide ESP8266 filesystem detection button
     if (butDetectFS) {
-      butDetectFS.classList.add('hidden');
+      butDetectFS.classList.add("hidden");
     }
   }
-  
+
   // Set detected flash size in the read size field
   if (espStub.flashSize) {
     const flashSizeBytes = parseFlashSize(espStub.flashSize);
     readSize.value = "0x" + flashSizeBytes.toString(16);
   }
-  
+
   // Set the selected baud rate
   let baud = parseInt(baudRateSelect.value);
   if (baudRates.includes(baud) && esploader.chipName !== "ESP8266") {
     await espStub.setBaudrate(baud);
   }
-  
+
   // Store disconnect handler so we can remove it later
   const handleDisconnect = () => {
     toggleUIConnected(false);
@@ -899,10 +922,14 @@ function showS2Modal(title, text) {
     if (modalTitle) modalTitle.textContent = title;
     if (modalText) modalText.textContent = text;
     modal.classList.remove("hidden");
-    reconnectBtn.addEventListener("click", () => {
-      modal.classList.add("hidden");
-      resolve();
-    }, { once: true });
+    reconnectBtn.addEventListener(
+      "click",
+      () => {
+        modal.classList.add("hidden");
+        resolve();
+      },
+      { once: true },
+    );
   });
 }
 
@@ -932,9 +959,9 @@ function assignPort(newPort) {
 async function openConsolePortAndInit(newPort) {
   await newPort.open({ baudRate: 115200 });
   assignPort(newPort);
-  
+
   debugMsg("Port opened for console at 115200 baud");
-  
+
   // WebUSB needs extra time for USB interface and streams to stabilize
   if (isUsingWebUSB()) {
     let retries = 30;
@@ -947,10 +974,10 @@ async function openConsolePortAndInit(newPort) {
     }
     debugMsg("WebUSB port streams ready for console");
   }
-  
+
   consoleSwitch.checked = true;
   saveSetting("console", true);
-  
+
   await initConsoleUI();
 }
 
@@ -961,56 +988,71 @@ async function openConsolePortAndInit(newPort) {
 async function initConsoleUI() {
   // Wait for port to be ready
   await sleep(200);
-  
+
   // Show console container and hide commands
   consoleContainer.classList.remove("hidden");
-  
+
   // Add console-active class to body for mobile styling
   document.body.classList.add("console-active");
   const commands = document.getElementById("commands");
   if (commands) commands.classList.add("hidden");
-  
+
   // Initialize console
   consoleInstance = new ESP32ToolConsole(espStub.port, consoleContainer, true);
   await consoleInstance.init();
-  
+
   // Listen for console reset events
   if (consoleResetHandler) {
-    consoleContainer.removeEventListener('console-reset', consoleResetHandler);
+    consoleContainer.removeEventListener("console-reset", consoleResetHandler);
   }
   consoleResetHandler = async () => {
-    if (espLoaderBeforeConsole && typeof espLoaderBeforeConsole.resetInConsoleMode === 'function') {
+    if (
+      espLoaderBeforeConsole &&
+      typeof espLoaderBeforeConsole.resetInConsoleMode === "function"
+    ) {
       try {
         const isS2 = chipFamilyBeforeConsole === CHIP_FAMILY_ESP32S2;
-        
+
         if (isS2) {
-          debugMsg("ESP32-S2 console reset: entering bootloader, then WDT reset to firmware...");
-          
+          debugMsg(
+            "ESP32-S2 console reset: entering bootloader, then WDT reset to firmware...",
+          );
+
           if (consoleInstance) {
             await consoleInstance.disconnect();
           }
-          
+
           await espLoaderBeforeConsole.resetInConsoleMode();
-          
+
           const waitTime = isUsingWebUSB() ? 1000 : 500;
           await sleep(waitTime);
-          
+
           // Step 1: Select bootloader port for WDT reset
           const portLabel = isUsingWebUSB() ? "USB device" : "serial port";
-          await showS2Modal("Select bootloader port", `Select the ${portLabel} (bootloader) to reset the device.`);
+          await showS2Modal(
+            "Select bootloader port",
+            `Select the ${portLabel} (bootloader) to reset the device.`,
+          );
           const bootloaderPort = await requestPort();
-          
+
           debugMsg("Syncing with bootloader and performing WDT reset...");
           await espLoaderBeforeConsole.syncAndWdtReset(bootloaderPort);
-          try { await bootloaderPort.close(); } catch (e) { /* port may already be gone */ }
-          
+          try {
+            await bootloaderPort.close();
+          } catch (e) {
+            /* port may already be gone */
+          }
+
           debugMsg("Waiting for device to boot into firmware...");
           await sleep(waitTime);
-          
+
           // Step 2: Select firmware port for console
-          await showS2Modal("Select console port", `Select the ${portLabel} (firmware) for console.`);
+          await showS2Modal(
+            "Select console port",
+            `Select the ${portLabel} (firmware) for console.`,
+          );
           const consolePort = await requestPort();
-          
+
           await consolePort.open({ baudRate: 115200 });
           assignPort(consolePort);
           await consoleInstance.reconnect(consolePort);
@@ -1025,11 +1067,11 @@ async function initConsoleUI() {
       }
     }
   };
-  consoleContainer.addEventListener('console-reset', consoleResetHandler);
-  
+  consoleContainer.addEventListener("console-reset", consoleResetHandler);
+
   // Listen for console close events
   if (consoleCloseHandler) {
-    consoleContainer.removeEventListener('console-close', consoleCloseHandler);
+    consoleContainer.removeEventListener("console-close", consoleCloseHandler);
   }
   consoleCloseHandler = async () => {
     if (!consoleSwitch.checked) return;
@@ -1038,22 +1080,28 @@ async function initConsoleUI() {
     saveSetting("console", false);
     await closeConsole();
   };
-  consoleContainer.addEventListener('console-close', consoleCloseHandler);
-  
+  consoleContainer.addEventListener("console-close", consoleCloseHandler);
+
   // Listen for console bootloader detection events
   // The console detects bootloader patterns in real-time as data arrives
   // and dispatches this event when bootloader is detected
   if (consoleBootloaderHandlerModule) {
-    consoleContainer.removeEventListener('console-bootloader', consoleBootloaderHandlerModule);
+    consoleContainer.removeEventListener(
+      "console-bootloader",
+      consoleBootloaderHandlerModule,
+    );
   }
   consoleBootloaderHandlerModule = async () => {
     logMsg("Console detected bootloader mode - resetting to firmware...");
-    if (espLoaderBeforeConsole && typeof espLoaderBeforeConsole.resetInConsoleMode === 'function') {
+    if (
+      espLoaderBeforeConsole &&
+      typeof espLoaderBeforeConsole.resetInConsoleMode === "function"
+    ) {
       try {
         await espLoaderBeforeConsole.resetInConsoleMode();
         logMsg("✅ Device reset to firmware mode");
         // Clear console to see new output after reset
-        if (consoleInstance && typeof consoleInstance.clear === 'function') {
+        if (consoleInstance && typeof consoleInstance.clear === "function") {
           consoleInstance.clear();
         }
       } catch (err) {
@@ -1061,8 +1109,11 @@ async function initConsoleUI() {
       }
     }
   };
-  consoleContainer.addEventListener('console-bootloader', consoleBootloaderHandlerModule);
-  
+  consoleContainer.addEventListener(
+    "console-bootloader",
+    consoleBootloaderHandlerModule,
+  );
+
   logMsg("Console initialized");
 }
 
@@ -1072,7 +1123,7 @@ async function initConsoleUI() {
  */
 async function clickConsole() {
   const shouldEnable = consoleSwitch.checked;
-  
+
   if (shouldEnable) {
     // After WDT reset, everything is gone - start fresh with port selection
     // Initialize console if connected and not already created
@@ -1098,30 +1149,32 @@ async function clickConsole() {
         } catch (baudErr) {
           logMsg(`Failed to set baudrate to 115200: ${baudErr.message}`);
         }
-        
+
         // Enter console mode - handles both USB-JTAG and serial chip devices
         try {
           const portWasClosed = await espStub.enterConsoleMode();
-          
+
           if (portWasClosed) {
             // USB-JTAG/OTG device: Port was closed after WDT reset
             debugMsg("Device reset to firmware mode (port closed)");
-            
+
             // Wait for device to boot and USB port to become available
             // Android/WebUSB needs more time than Desktop for USB enumeration
             const isWebUSB = isUsingWebUSB();
             const waitTime = isWebUSB ? 1000 : 500; // 1s for Android, 500ms for Desktop
-            debugMsg(`Waiting ${waitTime}ms for device to boot and USB to enumerate...`);
+            debugMsg(
+              `Waiting ${waitTime}ms for device to boot and USB to enumerate...`,
+            );
             await sleep(waitTime);
-            
+
             // Check if this is ESP32-S2 or if we're on Android (WebUSB)
             // Both need modal for user gesture
             const isS2 = chipFamilyBeforeConsole === CHIP_FAMILY_ESP32S2;
             const needsModal = isS2 || isWebUSB;
-            
+
             if (needsModal) {
               // ESP32-S2 (all platforms) or Android (all chips): Use modal for user gesture
-              
+
               // After WDT reset, the USB device re-enumerates and creates a NEW port
               // The old port is dead and will be garbage collected by the browser
               // We just need to clear our references to it
@@ -1129,7 +1182,7 @@ async function clickConsole() {
               espStub.connected = false;
               espStub._writer = undefined;
               espStub._reader = undefined;
-              
+
               if (espStub._parent) {
                 espStub._parent.port = null;
                 espStub._parent.connected = false;
@@ -1138,16 +1191,18 @@ async function clickConsole() {
                 espLoaderBeforeConsole.port = null;
                 espLoaderBeforeConsole.connected = false;
               }
-              
-              debugMsg("Old port references cleared (USB device will re-enumerate)");
-              
+
+              debugMsg(
+                "Old port references cleared (USB device will re-enumerate)",
+              );
+
               // Wait for browser to process port closure and USB re-enumeration
               await sleep(300);
-              
+
               const portLabel = isWebUSB ? "USB device" : "serial port";
               await showS2Modal(
                 "Device has been reset to firmware mode",
-                `Please click the button below to select the ${portLabel} for console.`
+                `Please click the button below to select the ${portLabel} for console.`,
               );
             }
 
@@ -1159,7 +1214,7 @@ async function clickConsole() {
               consoleSwitch.checked = false;
               saveSetting("console", false);
             }
-            
+
             return;
           } else {
             // Serial chip device: Port stays open
@@ -1171,15 +1226,15 @@ async function clickConsole() {
           saveSetting("console", false);
           return;
         }
-        
+
         // Wait for:
         // - Firmware to start after reset
         // - Port to be ready for new reader
         await sleep(500);
-        
+
         // Initialize console UI and handlers
         await initConsoleUI();
-        
+
         saveSetting("console", true);
       } catch (err) {
         errorMsg("Failed to initialize console: " + err.message);
@@ -1206,7 +1261,7 @@ async function clickConsole() {
 async function closeConsole() {
   // Remove console-active class from body FIRST to restore visibility
   document.body.classList.remove("console-active");
-  
+
   // Hide console and show commands again
   consoleContainer.classList.add("hidden");
   const commands = document.getElementById("commands");
@@ -1215,7 +1270,7 @@ async function closeConsole() {
     // Force display to ensure it's visible
     commands.style.display = "";
   }
-  
+
   // Restore original state (bootloader + stub + baudrate)
   if (espLoaderBeforeConsole && Number.isFinite(baudRateBeforeConsole)) {
     // Disconnect console first to release locks
@@ -1227,34 +1282,44 @@ async function closeConsole() {
       }
       consoleInstance = null;
     }
-    
+
     // Remove console event handlers
     if (consoleResetHandler) {
-      consoleContainer.removeEventListener('console-reset', consoleResetHandler);
+      consoleContainer.removeEventListener(
+        "console-reset",
+        consoleResetHandler,
+      );
       consoleResetHandler = null;
     }
     if (consoleCloseHandler) {
-      consoleContainer.removeEventListener('console-close', consoleCloseHandler);
+      consoleContainer.removeEventListener(
+        "console-close",
+        consoleCloseHandler,
+      );
       consoleCloseHandler = null;
     }
     if (consoleBootloaderHandlerModule) {
-      consoleContainer.removeEventListener('console-bootloader', consoleBootloaderHandlerModule);
+      consoleContainer.removeEventListener(
+        "console-bootloader",
+        consoleBootloaderHandlerModule,
+      );
       consoleBootloaderHandlerModule = null;
     }
-    
+
     // Use esp_loader's exitConsoleMode function
     try {
-      const needsManualReconnect = await espLoaderBeforeConsole.exitConsoleMode();
-      
+      const needsManualReconnect =
+        await espLoaderBeforeConsole.exitConsoleMode();
+
       if (needsManualReconnect) {
         // Port has changed, need to select new port
         // logMsg("Port changed - please select the new port");
         toggleUIConnected(false);
         espStub = undefined;
-        
+
         // Wait a moment for port to stabilize
         await sleep(1000);
-        
+
         // Trigger port selection
         try {
           await clickConnect();
@@ -1296,7 +1361,7 @@ async function closeConsole() {
  */
 function updateLogVisibility() {
   const logControls = document.querySelector(".log-controls");
-  
+
   if (showLog.checked) {
     log.classList.remove("hidden");
     if (logControls) {
@@ -1352,17 +1417,17 @@ function updateAdvancedVisibility() {
 function updateMainPadding() {
   // Use requestAnimationFrame to ensure DOM has updated
   requestAnimationFrame(() => {
-    const header = document.querySelector('.header');
-    const main = document.querySelector('.main');
-    
+    const header = document.querySelector(".header");
+    const main = document.querySelector(".main");
+
     // Guard against missing elements
     if (!header || !main) {
       return;
     }
-    
+
     const headerHeight = header.offsetHeight;
     // Add small buffer (10px) for better spacing
-    main.style.paddingTop = (headerHeight + 10) + 'px';
+    main.style.paddingTop = headerHeight + 10 + "px";
   });
 }
 
@@ -1372,21 +1437,21 @@ function updateMainPadding() {
  */
 async function clickDetectFS() {
   if (!espStub || !espStub.flashSize) {
-    errorMsg('Not connected or flash size unknown');
+    errorMsg("Not connected or flash size unknown");
     return;
   }
-  
+
   try {
     butDetectFS.disabled = true;
-    logMsg('Detecting ESP8266 filesystem...');
-    
+    logMsg("Detecting ESP8266 filesystem...");
+
     const flashSizeBytes = parseFlashSize(espStub.flashSize);
     const flashSizeMB = flashSizeBytes / (1024 * 1024);
     const esptoolMod = await window.esptoolPackage;
-    
+
     // Scan flash for filesystem signatures - optimized based on flash size
     let scanOffsets = [];
-    
+
     if (flashSizeMB >= 4) {
       // 4MB/8MB/16MB Flash
       scanOffsets = [
@@ -1413,19 +1478,19 @@ async function clickDetectFS() {
         { offset: 0x05b000, size: 0x20000 }, // Covers 128KB, 64KB, 32KB (0x05b000, 0x06b000, 0x073000)
       ];
     }
-    
+
     // Collect all found filesystems
     const foundFilesystems = [];
-    
+
     for (const scan of scanOffsets) {
       if (scan.offset + scan.size > flashSizeBytes) {
         continue;
       }
-      
+
       try {
         logMsg(`Scanning at 0x${scan.offset.toString(16)}...`);
         const scanData = await espStub.readFlash(scan.offset, scan.size);
-        
+
         // Check multiple offsets within the read data
         const checkOffsets = [];
         if (scan.size > 0x10000) {
@@ -1437,90 +1502,114 @@ async function clickDetectFS() {
           // Small read - check only start position
           checkOffsets.push(scan.offset);
         }
-        
+
         for (const checkOffset of checkOffsets) {
           const dataOffset = checkOffset - scan.offset;
           if (dataOffset + 0x10000 > scanData.length) continue;
-          
+
           const checkData = scanData.slice(dataOffset, dataOffset + 0x10000);
-          const scannedLayout = esptoolMod.scanESP8266Filesystem(checkData, checkOffset, flashSizeBytes);
-          
+          const scannedLayout = esptoolMod.scanESP8266Filesystem(
+            checkData,
+            checkOffset,
+            flashSizeBytes,
+          );
+
           if (scannedLayout) {
-            const fsType = esptoolMod.detectFilesystemFromImage(checkData, currentChipName);
-            
+            const fsType = esptoolMod.detectFilesystemFromImage(
+              checkData,
+              currentChipName,
+            );
+
             // Validate: Check if it's a real filesystem with valid magic
-            if (fsType !== 'unknown') {
+            if (fsType !== "unknown") {
               foundFilesystems.push({
                 layout: scannedLayout,
                 fsType: fsType,
-                data: checkData
+                data: checkData,
               });
-              logMsg(`Found ${fsType.toUpperCase()} at 0x${scannedLayout.start.toString(16)} - 0x${scannedLayout.end.toString(16)} (${formatSize(scannedLayout.size)})`);
+              logMsg(
+                `Found ${fsType.toUpperCase()} at 0x${scannedLayout.start.toString(16)} - 0x${scannedLayout.end.toString(16)} (${formatSize(scannedLayout.size)})`,
+              );
             }
           }
         }
-        
       } catch (e) {
         // Continue scanning
-        logMsg(`Scan at 0x${scan.offset.toString(16)} failed: ${e.message || e}`);
+        logMsg(
+          `Scan at 0x${scan.offset.toString(16)} failed: ${e.message || e}`,
+        );
       }
     }
-    
+
     // Choose the best filesystem from found ones
     let detectedLayout = null;
-    
+
     if (foundFilesystems.length === 0) {
       // No filesystem found - use fallback
-      logMsg('No filesystem found by scanning, using default layout...');
+      logMsg("No filesystem found by scanning, using default layout...");
       const fsLayouts = esptoolMod.getESP8266FilesystemLayout(flashSizeMB);
       if (fsLayouts && fsLayouts.length > 0) {
         detectedLayout = fsLayouts[0];
-        logMsg(`Using default layout for ${flashSizeMB}MB flash: 0x${detectedLayout.start.toString(16)} - 0x${detectedLayout.end.toString(16)} (${formatSize(detectedLayout.size)})`);
+        logMsg(
+          `Using default layout for ${flashSizeMB}MB flash: 0x${detectedLayout.start.toString(16)} - 0x${detectedLayout.end.toString(16)} (${formatSize(detectedLayout.size)})`,
+        );
       }
     } else if (foundFilesystems.length === 1) {
       // Only one found - use it
       detectedLayout = foundFilesystems[0].layout;
-      logMsg(`Using detected filesystem at 0x${detectedLayout.start.toString(16)}`);
+      logMsg(
+        `Using detected filesystem at 0x${detectedLayout.start.toString(16)}`,
+      );
     } else {
       // Multiple found - choose the best one
       // Prefer filesystems with valid size from block_count over layout-based sizes
-      logMsg(`Found ${foundFilesystems.length} filesystems, selecting best match...`);
-      
+      logMsg(
+        `Found ${foundFilesystems.length} filesystems, selecting best match...`,
+      );
+
       // Sort by: 1) Has valid block_count (size not from layout), 2) Smallest offset
       foundFilesystems.sort((a, b) => {
         // Check if size matches a known layout (indicates fallback was used)
-        const aIsLayout = [0x1fa000, 0x2fa000, 0x0fa000, 0x5fa000, 0x6fa000, 0xdfa000, 0xefa000].includes(a.layout.size);
-        const bIsLayout = [0x1fa000, 0x2fa000, 0x0fa000, 0x5fa000, 0x6fa000, 0xdfa000, 0xefa000].includes(b.layout.size);
-        
+        const aIsLayout = [
+          0x1fa000, 0x2fa000, 0x0fa000, 0x5fa000, 0x6fa000, 0xdfa000, 0xefa000,
+        ].includes(a.layout.size);
+        const bIsLayout = [
+          0x1fa000, 0x2fa000, 0x0fa000, 0x5fa000, 0x6fa000, 0xdfa000, 0xefa000,
+        ].includes(b.layout.size);
+
         if (aIsLayout !== bIsLayout) {
           return aIsLayout ? 1 : -1; // Prefer non-layout (real block_count)
         }
-        
+
         return a.layout.start - b.layout.start; // Then prefer smaller offset
       });
-      
+
       detectedLayout = foundFilesystems[0].layout;
-      logMsg(`Selected filesystem at 0x${detectedLayout.start.toString(16)} (${formatSize(detectedLayout.size)})`);
+      logMsg(
+        `Selected filesystem at 0x${detectedLayout.start.toString(16)} (${formatSize(detectedLayout.size)})`,
+      );
     }
-    
+
     if (!detectedLayout) {
-      errorMsg('No filesystem layout found for this flash size');
+      errorMsg("No filesystem layout found for this flash size");
       butDetectFS.disabled = false;
       return;
     }
-    
+
     // Show progress bar
-    readProgress.classList.remove('hidden');
-    const progressBar = readProgress.querySelector('div');
+    readProgress.classList.remove("hidden");
+    const progressBar = readProgress.querySelector("div");
     if (progressBar) {
-      progressBar.style.width = '0%';
+      progressBar.style.width = "0%";
     }
-    
+
     // Read the filesystem with real progress tracking
-    logMsg(`Reading ${formatSize(detectedLayout.size)} from 0x${detectedLayout.start.toString(16)}...`);
-    
+    logMsg(
+      `Reading ${formatSize(detectedLayout.size)} from 0x${detectedLayout.start.toString(16)}...`,
+    );
+
     const fsData = await espStub.readFlash(
-      detectedLayout.start, 
+      detectedLayout.start,
       detectedLayout.size,
       (packet, progress, totalSize) => {
         // Update progress bar with real progress
@@ -1528,59 +1617,61 @@ async function clickDetectFS() {
           const percentage = (progress / totalSize) * 100;
           progressBar.style.width = `${percentage.toFixed(1)}%`;
         }
-      }
+      },
     );
-    
+
     // Keep progress bar at 100% for a moment
     if (progressBar) {
-      progressBar.style.width = '100%';
+      progressBar.style.width = "100%";
     }
-    await new Promise(resolve => setTimeout(resolve, 300));
-    readProgress.classList.add('hidden');
-    
+    await new Promise((resolve) => setTimeout(resolve, 300));
+    readProgress.classList.add("hidden");
+
     // Store the data for later use
     lastReadFlashData = fsData;
 
     // Hide Open FS Manager since we're opening directly
-    butOpenFSManager.classList.add('hidden');
+    butOpenFSManager.classList.add("hidden");
 
     // Detect filesystem type
-    const fsType = esptoolMod.detectFilesystemFromImage(fsData, currentChipName);
+    const fsType = esptoolMod.detectFilesystemFromImage(
+      fsData,
+      currentChipName,
+    );
     logMsg(`Detected filesystem type: ${fsType.toUpperCase()}`);
-    
-    if (fsType === 'unknown') {
-      errorMsg('Could not detect filesystem type');
+
+    if (fsType === "unknown") {
+      errorMsg("Could not detect filesystem type");
       butDetectFS.disabled = false;
       return;
     }
-    
+
     // Create a partition object for compatibility
     const partition = {
-      name: 'filesystem',
+      name: "filesystem",
       type: 0x01,
-      subtype: fsType === 'littlefs' ? 0x82 : (fsType === 'fatfs' ? 0x81 : 0x82),
+      subtype: fsType === "littlefs" ? 0x82 : fsType === "fatfs" ? 0x81 : 0x82,
       offset: detectedLayout.start,
       size: detectedLayout.size,
       _readData: fsData,
       _blockSize: detectedLayout.block,
-      _pageSize: detectedLayout.page
+      _pageSize: detectedLayout.page,
     };
-    
+
     // Open the filesystem directly
-    if (fsType === 'littlefs') {
+    if (fsType === "littlefs") {
       await openLittleFS(partition);
-    } else if (fsType === 'fatfs') {
+    } else if (fsType === "fatfs") {
       await openFatFS(partition);
-    } else if (fsType === 'spiffs') {
+    } else if (fsType === "spiffs") {
       await openSPIFFS(partition);
     }
-    
   } catch (e) {
     errorMsg(`Failed to detect/open filesystem: ${e.message || e}`);
-    debugMsg('Filesystem detection error details: ' + e);
+    debugMsg("Filesystem detection error details: " + e);
   } finally {
     // Hide progress bar
-    readProgress.classList.add('hidden');
+    readProgress.classList.add("hidden");
     butDetectFS.disabled = false;
   }
 }
@@ -1591,13 +1682,17 @@ async function clickDetectFS() {
  */
 async function clickErase() {
   let confirmed = false;
-  
+
   if (isElectron) {
-    confirmed = await window.electronAPI.showConfirm("This will erase the entire flash. Click OK to continue.");
+    confirmed = await window.electronAPI.showConfirm(
+      "This will erase the entire flash. Click OK to continue.",
+    );
   } else {
-    confirmed = window.confirm("This will erase the entire flash. Click OK to continue.");
+    confirmed = window.confirm(
+      "This will erase the entire flash. Click OK to continue.",
+    );
   }
-  
+
   if (confirmed) {
     baudRateSelect.disabled = true;
     butErase.disabled = true;
@@ -1730,14 +1825,14 @@ async function checkFirmware(event) {
 function updateUploadRowsVisibility() {
   const uploadRows = document.querySelectorAll(".upload");
   let lastFilledIndex = -1;
-  
+
   // Find the last filled row
   for (let i = 0; i < firmware.length; i++) {
     if (firmware[i].files.length > 0) {
       lastFilledIndex = i;
     }
   }
-  
+
   // Show rows up to lastFilledIndex + 1 (next empty row), minimum 1 row
   for (let i = 0; i < uploadRows.length; i++) {
     if (i <= lastFilledIndex + 1) {
@@ -1762,9 +1857,11 @@ async function clickReadFlash() {
   }
 
   // Create filename with chip type and MAC address
-  const chipInfo = currentChipName ? currentChipName.replace(/\s+/g, '_') : 'ESP';
-  const macInfo = currentMacAddr ? currentMacAddr.replace(/:/g, '') : '';
-  const defaultFilename = `${chipInfo}${macInfo ? '_' + macInfo : ''}_flash_0x${offset.toString(16)}_0x${size.toString(16)}.bin`;
+  const chipInfo = currentChipName
+    ? currentChipName.replace(/\s+/g, "_")
+    : "ESP";
+  const macInfo = currentMacAddr ? currentMacAddr.replace(/:/g, "") : "";
+  const defaultFilename = `${chipInfo}${macInfo ? "_" + macInfo : ""}_flash_0x${offset.toString(16)}_0x${size.toString(16)}.bin`;
 
   baudRateSelect.disabled = true;
   butErase.disabled = true;
@@ -1780,7 +1877,9 @@ async function clickReadFlash() {
     // Prepare options object if advanced mode is enabled
     const options = buildAdvancedOptions();
     if (options) {
-      logMsg(`Advanced mode: chunkSize=0x${options.chunkSize?.toString(16)}, blockSize=${options.blockSize}, maxInFlight=${options.maxInFlight}`);
+      logMsg(
+        `Advanced mode: chunkSize=0x${options.chunkSize?.toString(16)}, blockSize=${options.blockSize}, maxInFlight=${options.maxInFlight}`,
+      );
     }
 
     const data = await espStub.readFlash(
@@ -1790,39 +1889,38 @@ async function clickReadFlash() {
         progressBar.style.width =
           Math.floor((progress / totalSize) * 100) + "%";
       },
-      options
+      options,
     );
 
     logMsg(`Successfully read ${data.length} bytes from flash`);
 
     // Save file using Electron API or browser download
     await saveDataToFile(data, defaultFilename);
-    
+
     // Check if this looks like a filesystem
-    const chipName = currentChipName || '';
+    const chipName = currentChipName || "";
     const esptoolMod = await window.esptoolPackage;
     const fsType = esptoolMod.detectFilesystemFromImage(data, chipName);
-    
-    if (fsType !== 'unknown') {
+
+    if (fsType !== "unknown") {
       logMsg(`Detected ${fsType} filesystem in read data`);
-      
+
       // Store the read data and metadata for later use
       lastReadFlashData = {
         data: data,
         offset: offset,
         size: size,
-        fsType: fsType
+        fsType: fsType,
       };
-      
+
       // Show "Open FS Manager" button
-      butOpenFSManager.classList.remove('hidden');
+      butOpenFSManager.classList.remove("hidden");
       logMsg('Click "Open FS Manager" to access the filesystem');
     } else {
       // Hide button if no filesystem detected
-      butOpenFSManager.classList.add('hidden');
+      butOpenFSManager.classList.add("hidden");
       lastReadFlashData = null;
     }
-
   } catch (e) {
     errorMsg("Failed to read flash: " + e);
   } finally {
@@ -1861,12 +1959,12 @@ async function clickHexEditor() {
     }
 
     // Show the container and progress overlay immediately
-    hexeditorContainer.classList.remove('hidden');
-    document.body.classList.add('hexeditor-active');
+    hexeditorContainer.classList.remove("hidden");
+    document.body.classList.add("hexeditor-active");
 
     // Build a temporary UI for progress display
     hexEditorInstance.initProgressUI();
-    hexEditorInstance.showProgress('Reading flash...', 0);
+    hexEditorInstance.showProgress("Reading flash...", 0);
 
     // Prepare options
     const options = buildAdvancedOptions();
@@ -1878,10 +1976,10 @@ async function clickHexEditor() {
         const pct = Math.floor((progress / totalSize) * 100);
         hexEditorInstance.showProgress(
           `Reading flash... ${pct}% (${(progress / 1024).toFixed(0)} / ${(totalSize / 1024).toFixed(0)} KB)`,
-          pct
+          pct,
         );
       },
-      options
+      options,
     );
 
     logMsg(`Successfully read ${data.length} bytes from flash for hex editor`);
@@ -1913,7 +2011,7 @@ async function clickHexEditor() {
 
         editor.showProgress(
           `Writing sector at 0x${flashAddr.toString(16).toUpperCase()}... (${written + 1}/${total})`,
-          Math.floor((written / total) * 100)
+          Math.floor((written / total) * 100),
         );
 
         await espStub.flashData(
@@ -1922,15 +2020,15 @@ async function clickHexEditor() {
             const sectorPct = Math.floor((bytesWritten / totalBytes) * 100);
             editor.showProgress(
               `Writing sector at 0x${flashAddr.toString(16).toUpperCase()}... ${sectorPct}% (${written + 1}/${total})`,
-              Math.floor(((written + bytesWritten / totalBytes) / total) * 100)
+              Math.floor(((written + bytesWritten / totalBytes) / total) * 100),
             );
           },
-          flashAddr
+          flashAddr,
         );
         written++;
       }
 
-      editor.showProgress('Write complete!', 100);
+      editor.showProgress("Write complete!", 100);
       logMsg(`Successfully wrote ${total} sector(s) to flash`);
       await sleep(500);
       editor.hideProgress();
@@ -1938,20 +2036,21 @@ async function clickHexEditor() {
 
     // Set up close handler
     hexEditorInstance.onClose = () => {
-      hexeditorContainer.classList.add('hidden');
-      document.body.classList.remove('hexeditor-active');
+      hexeditorContainer.classList.add("hidden");
+      document.body.classList.remove("hexeditor-active");
       hexEditorInstance = null;
     };
-
   } catch (e) {
     errorMsg("Failed to read flash for hex editor: " + e);
-    hexeditorContainer.classList.add('hidden');
-    document.body.classList.remove('hexeditor-active');
+    hexeditorContainer.classList.add("hidden");
+    document.body.classList.remove("hexeditor-active");
     if (hexEditorInstance) {
-     // close() handles ResizeObserver/keydown cleanup; onClose is not yet wired here so null manually
-     try { hexEditorInstance.close(); } catch (_) {}
-     hexEditorInstance = null;
-   }
+      // close() handles ResizeObserver/keydown cleanup; onClose is not yet wired here so null manually
+      try {
+        hexEditorInstance.close();
+      } catch (_) {}
+      hexEditorInstance = null;
+    }
   } finally {
     butHexEditor.disabled = false;
   }
@@ -1967,14 +2066,20 @@ async function clickNVSEditor() {
 
   // Guard against losing unsaved changes
   if (nvsEditorInstance && nvsEditorInstance.modified === true) {
-    if (!confirm('You have unsaved changes in the NVS editor. Discard changes and reload?')) {
+    if (
+      !confirm(
+        "You have unsaved changes in the NVS editor. Discard changes and reload?",
+      )
+    ) {
       butNVSEditor.disabled = false;
       return;
     }
     // User confirmed - close existing editor
-    nvseditorContainer.classList.add('hidden');
-    document.body.classList.remove('nvseditor-active');
-    try { nvsEditorInstance.close(); } catch (_) {}
+    nvseditorContainer.classList.add("hidden");
+    document.body.classList.remove("nvseditor-active");
+    try {
+      nvsEditorInstance.close();
+    } catch (_) {}
     nvsEditorInstance = null;
   }
 
@@ -1984,10 +2089,10 @@ async function clickNVSEditor() {
     if (!nvsEditorInstance) {
       nvsEditorInstance = new NVSEditor(nvseditorContainer);
     }
-    nvseditorContainer.classList.remove('hidden');
-    document.body.classList.add('nvseditor-active');
+    nvseditorContainer.classList.remove("hidden");
+    document.body.classList.add("nvseditor-active");
     nvsEditorInstance.initProgressUI();
-    nvsEditorInstance.showProgress('Reading partition table...', 0);
+    nvsEditorInstance.showProgress("Reading partition table...", 0);
 
     const MAX_PT_ATTEMPTS = 10;
     let partitions = [];
@@ -1999,19 +2104,25 @@ async function clickNVSEditor() {
       if (partitions.length > 0) break;
     }
     if (partitions.length === 0) {
-      throw new Error('No valid partition table found after ' + MAX_PT_ATTEMPTS + ' attempts');
+      throw new Error(
+        "No valid partition table found after " + MAX_PT_ATTEMPTS + " attempts",
+      );
     }
 
     // Step 2: Find NVS partition (type=0x01 data, subtype=0x02 nvs)
-    const nvsPartition = partitions.find(p => p.type === 0x01 && p.subtype === 0x02);
+    const nvsPartition = partitions.find(
+      (p) => p.type === 0x01 && p.subtype === 0x02,
+    );
     if (!nvsPartition) {
-      throw new Error('No NVS partition found in partition table');
+      throw new Error("No NVS partition found in partition table");
     }
 
-    logMsg(`Found NVS partition "${nvsPartition.name}" at 0x${nvsPartition.offset.toString(16)}, size ${nvsPartition.size} bytes`);
+    logMsg(
+      `Found NVS partition "${nvsPartition.name}" at 0x${nvsPartition.offset.toString(16)}, size ${nvsPartition.size} bytes`,
+    );
 
     // Step 3: Read the NVS partition
-    nvsEditorInstance.showProgress('Reading NVS partition...', 10);
+    nvsEditorInstance.showProgress("Reading NVS partition...", 10);
     const options = buildAdvancedOptions();
     const nvsData = await espStub.readFlash(
       nvsPartition.offset,
@@ -2020,16 +2131,16 @@ async function clickNVSEditor() {
         const pct = 10 + Math.floor((progress / totalSize) * 85);
         nvsEditorInstance.showProgress(
           `Reading NVS... ${Math.floor((progress / totalSize) * 100)}% (${(progress / 1024).toFixed(0)} / ${(totalSize / 1024).toFixed(0)} KB)`,
-          pct
+          pct,
         );
       },
-      options
+      options,
     );
 
     logMsg(`Successfully read ${nvsData.length} bytes from NVS partition`);
 
     // Step 4: Open NVS editor
-    nvsEditorInstance.showProgress('Parsing NVS data...', 95);
+    nvsEditorInstance.showProgress("Parsing NVS data...", 95);
     nvsEditorInstance.open(nvsData, nvsPartition.offset, nvsPartition.name);
 
     // Step 5: Set up write handler
@@ -2037,25 +2148,25 @@ async function clickNVSEditor() {
       const editor = nvsEditorInstance;
       if (!editor) return;
 
-      editor.showProgress('Writing NVS partition...', 0);
+      editor.showProgress("Writing NVS partition...", 0);
 
       try {
         const nvsBuffer = editedData.buffer.slice(
           editedData.byteOffset,
-          editedData.byteOffset + editedData.byteLength
-      );
-      await espStub.flashData(
-        nvsBuffer,
-        (bytesWritten, totalBytes) => {
-          const pct = Math.floor((bytesWritten / totalBytes) * 100);
-          editor.showProgress(`Writing NVS... ${pct}%`, pct);
-        },
-        nvsPartition.offset
-      );
+          editedData.byteOffset + editedData.byteLength,
+        );
+        await espStub.flashData(
+          nvsBuffer,
+          (bytesWritten, totalBytes) => {
+            const pct = Math.floor((bytesWritten / totalBytes) * 100);
+            editor.showProgress(`Writing NVS... ${pct}%`, pct);
+          },
+          nvsPartition.offset,
+        );
 
-      editor.showProgress('Write complete!', 100);
-      logMsg('NVS partition written successfully');
-      await sleep(500);
+        editor.showProgress("Write complete!", 100);
+        logMsg("NVS partition written successfully");
+        await sleep(500);
       } finally {
         editor.hideProgress();
       }
@@ -2063,17 +2174,18 @@ async function clickNVSEditor() {
 
     // Step 6: Set up close handler
     nvsEditorInstance.onClose = () => {
-      nvseditorContainer.classList.add('hidden');
-      document.body.classList.remove('nvseditor-active');
+      nvseditorContainer.classList.add("hidden");
+      document.body.classList.remove("nvseditor-active");
       nvsEditorInstance = null;
     };
-
   } catch (e) {
-    errorMsg('Failed to open NVS editor: ' + e);
-    nvseditorContainer.classList.add('hidden');
-    document.body.classList.remove('nvseditor-active');
+    errorMsg("Failed to open NVS editor: " + e);
+    nvseditorContainer.classList.add("hidden");
+    document.body.classList.remove("nvseditor-active");
     if (nvsEditorInstance) {
-      try { nvsEditorInstance.close(); } catch (_) {}
+      try {
+        nvsEditorInstance.close();
+      } catch (_) {}
       nvsEditorInstance = null;
     }
   } finally {
@@ -2087,10 +2199,10 @@ async function clickNVSEditor() {
  */
 async function clickOpenFSManager() {
   if (!lastReadFlashData) {
-    errorMsg('No filesystem data available. Please read flash first.');
+    errorMsg("No filesystem data available. Please read flash first.");
     return;
   }
-  
+
   try {
     // Create a pseudo-partition object for the read data
     const pseudoPartition = {
@@ -2098,10 +2210,10 @@ async function clickOpenFSManager() {
       offset: lastReadFlashData.offset,
       size: lastReadFlashData.size,
       type: 0x01,
-      subtype: lastReadFlashData.fsType === 'fatfs' ? 0x81 : 0x82,
-      _readData: lastReadFlashData.data // Store the already-read data
+      subtype: lastReadFlashData.fsType === "fatfs" ? 0x81 : 0x82,
+      _readData: lastReadFlashData.data, // Store the already-read data
     };
-    
+
     await openFilesystem(pseudoPartition);
   } catch (e) {
     errorMsg(`Failed to open filesystem: ${e.message || e}`);
@@ -2113,7 +2225,6 @@ async function clickOpenFSManager() {
  * Click handler for the read partitions button.
  */
 async function clickReadPartitions() {
-
   butReadPartitions.disabled = true;
   butErase.disabled = true;
   butProgram.disabled = true;
@@ -2137,15 +2248,18 @@ async function clickReadPartitions() {
     }
 
     if (partitions.length === 0) {
-      errorMsg("No valid partition table found after " + MAX_ATTEMPTS + " attempts");
+      errorMsg(
+        "No valid partition table found after " + MAX_ATTEMPTS + " attempts",
+      );
       return;
     }
 
-    logMsg(`Found ${partitions.length} partition(s) at 0x${foundOffset.toString(16)}`);
-    
+    logMsg(
+      `Found ${partitions.length} partition(s) at 0x${foundOffset.toString(16)}`,
+    );
+
     // Display partitions
     displayPartitions(partitions);
-    
   } catch (e) {
     errorMsg("Failed to read partition table: " + e);
   } finally {
@@ -2166,16 +2280,24 @@ function parsePartitionTable(data) {
 
   for (let i = 0; i < data.length; i += PARTITION_ENTRY_SIZE) {
     const magic = data[i] | (data[i + 1] << 8);
-    
+
     if (magic !== PARTITION_MAGIC) {
       break; // End of partition table
     }
 
     const type = data[i + 2];
     const subtype = data[i + 3];
-    const offset = data[i + 4] | (data[i + 5] << 8) | (data[i + 6] << 16) | (data[i + 7] << 24);
-    const size = data[i + 8] | (data[i + 9] << 8) | (data[i + 10] << 16) | (data[i + 11] << 24);
-    
+    const offset =
+      data[i + 4] |
+      (data[i + 5] << 8) |
+      (data[i + 6] << 16) |
+      (data[i + 7] << 24);
+    const size =
+      data[i + 8] |
+      (data[i + 9] << 8) |
+      (data[i + 10] << 16) |
+      (data[i + 11] << 24);
+
     // Read name (16 bytes, null-terminated)
     let name = "";
     for (let j = 12; j < 28; j++) {
@@ -2183,17 +2305,33 @@ function parsePartitionTable(data) {
       name += String.fromCharCode(data[i + j]);
     }
 
-    const flags = data[i + 28] | (data[i + 29] << 8) | (data[i + 30] << 16) | (data[i + 31] << 24);
+    const flags =
+      data[i + 28] |
+      (data[i + 29] << 8) |
+      (data[i + 30] << 16) |
+      (data[i + 31] << 24);
 
     // Get type names
     const typeNames = { 0x00: "app", 0x01: "data" };
     const appSubtypes = {
-      0x00: "factory", 0x10: "ota_0", 0x11: "ota_1", 0x12: "ota_2",
-      0x13: "ota_3", 0x14: "ota_4", 0x15: "ota_5", 0x20: "test"
+      0x00: "factory",
+      0x10: "ota_0",
+      0x11: "ota_1",
+      0x12: "ota_2",
+      0x13: "ota_3",
+      0x14: "ota_4",
+      0x15: "ota_5",
+      0x20: "test",
     };
     const dataSubtypes = {
-      0x00: "ota", 0x01: "phy", 0x02: "nvs", 0x03: "coredump",
-      0x04: "nvs_keys", 0x05: "efuse", 0x81: "fat", 0x82: "spiffs"
+      0x00: "ota",
+      0x01: "phy",
+      0x02: "nvs",
+      0x03: "coredump",
+      0x04: "nvs_keys",
+      0x05: "efuse",
+      0x81: "fat",
+      0x82: "spiffs",
     };
 
     const typeName = typeNames[type] || `0x${type.toString(16)}`;
@@ -2214,7 +2352,7 @@ function parsePartitionTable(data) {
       size,
       flags,
       typeName,
-      subtypeName
+      subtypeName,
     });
   }
 
@@ -2227,17 +2365,17 @@ function parsePartitionTable(data) {
 function displayPartitions(partitions) {
   partitionList.innerHTML = "";
   partitionList.classList.remove("hidden");
-  
+
   // Hide the Read Partition Table button after successful read
   butReadPartitions.classList.add("hidden");
 
   const table = document.createElement("table");
   table.className = "partition-table-display";
-  
+
   // Header
   const thead = document.createElement("thead");
   const headerRow = document.createElement("tr");
-  ["Name", "Type", "SubType", "Offset", "Size", "Action"].forEach(text => {
+  ["Name", "Type", "SubType", "Offset", "Size", "Action"].forEach((text) => {
     const th = document.createElement("th");
     th.textContent = text;
     headerRow.appendChild(th);
@@ -2247,39 +2385,39 @@ function displayPartitions(partitions) {
 
   // Body
   const tbody = document.createElement("tbody");
-  partitions.forEach(partition => {
+  partitions.forEach((partition) => {
     const row = document.createElement("tr");
-    
+
     // Name
     const nameCell = document.createElement("td");
     nameCell.setAttribute("data-label", "Name");
     nameCell.textContent = partition.name;
     row.appendChild(nameCell);
-    
+
     // Type
     const typeCell = document.createElement("td");
     typeCell.setAttribute("data-label", "Type");
     typeCell.textContent = partition.typeName;
     row.appendChild(typeCell);
-    
+
     // SubType
     const subtypeCell = document.createElement("td");
     subtypeCell.setAttribute("data-label", "SubType");
     subtypeCell.textContent = partition.subtypeName;
     row.appendChild(subtypeCell);
-    
+
     // Offset
     const offsetCell = document.createElement("td");
     offsetCell.setAttribute("data-label", "Offset");
     offsetCell.textContent = `0x${partition.offset.toString(16)}`;
     row.appendChild(offsetCell);
-    
+
     // Size
     const sizeCell = document.createElement("td");
     sizeCell.setAttribute("data-label", "Size");
     sizeCell.textContent = formatSize(partition.size);
     row.appendChild(sizeCell);
-    
+
     // Action
     const actionCell = document.createElement("td");
     actionCell.setAttribute("data-label", "Action");
@@ -2288,23 +2426,26 @@ function displayPartitions(partitions) {
     downloadBtn.className = "partition-download-btn";
     downloadBtn.onclick = () => downloadPartition(partition);
     actionCell.appendChild(downloadBtn);
-    
+
     // Add "Open FS" button for data partitions with filesystem
     // 0x81 = FAT, 0x82 = SPIFFS (often contains LittleFS)
-    if (partition.type === 0x01 && (partition.subtype === 0x81 || partition.subtype === 0x82)) {
+    if (
+      partition.type === 0x01 &&
+      (partition.subtype === 0x81 || partition.subtype === 0x82)
+    ) {
       const fsBtn = document.createElement("button");
       fsBtn.textContent = "Open FS";
       fsBtn.className = "littlefs-fs-button";
       fsBtn.onclick = () => openFilesystem(partition);
       actionCell.appendChild(fsBtn);
     }
-    
+
     row.appendChild(actionCell);
-    
+
     tbody.appendChild(row);
   });
   table.appendChild(tbody);
-  
+
   partitionList.appendChild(table);
 }
 
@@ -2313,9 +2454,11 @@ function displayPartitions(partitions) {
  */
 async function downloadPartition(partition) {
   // Create filename with chip type and MAC address
-  const chipInfo = currentChipName ? currentChipName.replace(/\s+/g, '_') : 'ESP';
-  const macInfo = currentMacAddr ? currentMacAddr.replace(/:/g, '') : '';
-  const defaultFilename = `${chipInfo}${macInfo ? '_' + macInfo : ''}_${partition.name}_0x${partition.offset.toString(16)}.bin`;
+  const chipInfo = currentChipName
+    ? currentChipName.replace(/\s+/g, "_")
+    : "ESP";
+  const macInfo = currentMacAddr ? currentMacAddr.replace(/:/g, "") : "";
+  const defaultFilename = `${chipInfo}${macInfo ? "_" + macInfo : ""}_${partition.name}_0x${partition.offset.toString(16)}.bin`;
 
   const partitionProgress = document.getElementById("partitionProgress");
   const progressBar = partitionProgress.querySelector("div");
@@ -2325,7 +2468,7 @@ async function downloadPartition(partition) {
     progressBar.style.width = "0%";
 
     logMsg(
-      `Downloading partition "${partition.name}" (${formatSize(partition.size)})...`
+      `Downloading partition "${partition.name}" (${formatSize(partition.size)})...`,
     );
 
     const data = await espStub.readFlash(
@@ -2334,7 +2477,7 @@ async function downloadPartition(partition) {
       (packet, progress, totalSize) => {
         const percent = Math.floor((progress / totalSize) * 100);
         progressBar.style.width = percent + "%";
-      }
+      },
     );
 
     // Save file using Electron API or browser download
@@ -2367,7 +2510,7 @@ function formatSize(bytes) {
  * Click handler for the clear button.
  */
 async function clickClear() {
-// reset();     Reset function wasnt declared.
+  // reset();     Reset function wasnt declared.
   log.innerHTML = "";
 }
 
@@ -2402,30 +2545,29 @@ function toggleUIConnected(connected) {
   let lbl = "Connect";
   const header = document.querySelector(".header");
   const main = document.querySelector(".main");
-  
+
   if (connected) {
     lbl = "Disconnect";
     isConnected = true;
-
   } else {
     isConnected = false;
     toggleUIToolbar(false);
-    
+
     // Cleanup console if it was running
     if (consoleInstance) {
-      consoleInstance.disconnect().catch(err => {
+      consoleInstance.disconnect().catch((err) => {
         debugMsg("Error disconnecting console: " + err);
       });
       consoleInstance = null;
     }
-    
+
     // Hide console container, show commands, and uncheck switch
     consoleContainer.classList.add("hidden");
     const commands = document.getElementById("commands");
     if (commands) commands.classList.remove("hidden");
     consoleSwitch.checked = false;
     saveSetting("console", false);
-    
+
     // Close hex editor if open
     if (hexEditorInstance) {
       hexEditorInstance.close();
@@ -2433,11 +2575,13 @@ function toggleUIConnected(connected) {
     }
     // Close NVS editor if open (disconnect or unexpected port loss)
     if (nvsEditorInstance) {
-      try { nvsEditorInstance.close(); } catch (_) {}
+      try {
+        nvsEditorInstance.close();
+      } catch (_) {}
       nvsEditorInstance = null;
     }
-    nvseditorContainer.classList.add('hidden');
-    document.body.classList.remove('nvseditor-active');
+    nvseditorContainer.classList.add("hidden");
+    document.body.classList.remove("nvseditor-active");
   }
   butConnect.textContent = lbl;
 }
@@ -2445,7 +2589,7 @@ function toggleUIConnected(connected) {
 function loadAllSettings() {
   // Get default values based on environment (Desktop vs WebUSB)
   const defaults = getDefaultAdvancedParams();
-  
+
   // Load all saved settings or defaults
   autoscroll.checked = loadSetting("autoscroll", true);
   baudRateSelect.value = loadSetting("baudrate", 2000000);
@@ -2454,18 +2598,18 @@ function loadAllSettings() {
   showLog.checked = loadSetting("showlog", false);
   consoleSwitch.checked = loadSetting("console", false);
   advancedMode.checked = loadSetting("advanced", false);
-  
+
   // Load advanced parameters with environment-specific defaults
   chunkSizeSelect.value = loadSetting("chunkSize", defaults.chunkSize);
   blockSizeSelect.value = loadSetting("blockSize", defaults.blockSize);
   maxInFlightSelect.value = loadSetting("maxInFlight", defaults.maxInFlight);
-  
+
   // Apply show log setting
   updateLogVisibility();
-  
+
   // Don't show console container here - it will be initialized after connect
   // if consoleSwitch.checked is true
-  
+
   // Apply advanced mode visibility
   updateAdvancedVisibility();
 }
@@ -2498,9 +2642,9 @@ async function saveDataToFile(data, defaultFilename) {
     // Use Electron's native save dialog
     const result = await window.electronAPI.saveFile(
       Array.from(data), // Convert Uint8Array to regular array for IPC
-      defaultFilename
+      defaultFilename,
     );
-    
+
     if (result.success) {
       logMsg(`File saved: ${result.filePath}`);
     } else if (result.canceled) {
@@ -2529,12 +2673,12 @@ async function saveDataToFile(data, defaultFilename) {
 async function readFileFromDisk() {
   if (isElectron) {
     const result = await window.electronAPI.openFile();
-    
+
     if (result.success) {
       return {
         data: new Uint8Array(result.data),
         filename: result.filename,
-        filePath: result.filePath
+        filePath: result.filePath,
       };
     } else if (result.canceled) {
       return null;
@@ -2545,25 +2689,24 @@ async function readFileFromDisk() {
   return null;
 }
 
-
 /**
  * Open and mount a filesystem partition
  */
 async function openFilesystem(partition) {
   try {
     logMsg(`Detecting filesystem type for partition "${partition.name}"...`);
-    
+
     // Detect filesystem type
     const fsType = await detectFilesystemType(partition.offset, partition.size);
-    
-    if (fsType === 'littlefs') {
+
+    if (fsType === "littlefs") {
       await openLittleFS(partition);
-    } else if (fsType === 'fatfs') {
+    } else if (fsType === "fatfs") {
       await openFatFS(partition);
-    } else if (fsType === 'spiffs') {
+    } else if (fsType === "spiffs") {
       await openSPIFFS(partition);
     } else {
-      errorMsg('Unknown filesystem type. Cannot open partition.');
+      errorMsg("Unknown filesystem type. Cannot open partition.");
     }
   } catch (e) {
     errorMsg(`Failed to open filesystem: ${e.message || e}`);
@@ -2572,14 +2715,14 @@ async function openFilesystem(partition) {
 
 /**
  * Detect filesystem type by reading partition header
- * 
+ *
  * Uses the centralized detectFilesystemFromImage function from the esptool module.
  * This function properly validates filesystem structures:
- * 
+ *
  * - LittleFS: Validates superblock at block 0/1 with "littlefs" magic at offset 8 and version check
  * - FatFS: Checks for FAT boot signature (0xAA55) and FAT signature strings
  * - SPIFFS: Checks for SPIFFS magic number (0x20140529)
- * 
+ *
  * Falls back to SPIFFS if no filesystem is detected.
  */
 async function detectFilesystemType(offset, size) {
@@ -2587,34 +2730,33 @@ async function detectFilesystemType(offset, size) {
     // Read first 8KB or entire partition if smaller
     const readSize = Math.min(8192, size);
     const data = await espStub.readFlash(offset, readSize);
-    
+
     if (data.length < 32) {
-      logMsg('Partition too small, assuming SPIFFS');
-      return 'spiffs';
+      logMsg("Partition too small, assuming SPIFFS");
+      return "spiffs";
     }
-    
+
     // Get chip name for ESP8266-specific detection
-    const chipName = currentChipName || '';
-    
+    const chipName = currentChipName || "";
+
     // Use the detectFilesystemFromImage function from esptool package
     const esptoolMod = await window.esptoolPackage;
     const fsType = esptoolMod.detectFilesystemFromImage(data, chipName);
-    
+
     // Convert FilesystemType enum to lowercase string
     const fsTypeStr = fsType.toLowerCase();
-    
-    if (fsTypeStr !== 'unknown') {
+
+    if (fsTypeStr !== "unknown") {
       logMsg(`Detected filesystem: ${fsTypeStr}`);
       return fsTypeStr;
     }
-    
+
     // Default: If no clear signature found, assume SPIFFS
-    logMsg('No clear filesystem signature found, assuming SPIFFS');
-    return 'spiffs';
-    
+    logMsg("No clear filesystem signature found, assuming SPIFFS");
+    return "spiffs";
   } catch (err) {
     errorMsg(`Failed to detect filesystem type: ${err.message || err}`);
-    return 'spiffs'; // Safe fallback
+    return "spiffs"; // Safe fallback
   }
 }
 
@@ -2626,14 +2768,13 @@ async function loadLittlefsModule() {
     // Derive base path from current document URL (works for all hosting layouts)
     const basePath = new URL(".", window.location.href).pathname;
     const modulePath = `${basePath}src/wasm/littlefs/index.js`;
-    
-    littlefsModulePromise = import(modulePath)
-      .catch(error => {
-        errorMsg('Failed to load LittleFS module from: ' + modulePath);
-        debugMsg('LittleFS module load error: ' + error);
-        littlefsModulePromise = null; // Reset on error so it can be retried
-        throw error;
-      });
+
+    littlefsModulePromise = import(modulePath).catch((error) => {
+      errorMsg("Failed to load LittleFS module from: " + modulePath);
+      debugMsg("LittleFS module load error: " + error);
+      littlefsModulePromise = null; // Reset on error so it can be retried
+      throw error;
+    });
   }
   return littlefsModulePromise;
 }
@@ -2648,27 +2789,27 @@ function resetLittleFSState() {
       // Don't call destroy() - it can cause crashes
       // Just let garbage collection handle it
     } catch (e) {
-      debugMsg('Error cleaning up LittleFS: ' + e);
+      debugMsg("Error cleaning up LittleFS: " + e);
     }
   }
-  
+
   currentLittleFS = null;
   currentLittleFSPartition = null;
-  currentLittleFSPath = '/';
+  currentLittleFSPath = "/";
   currentLittleFSBlockSize = 4096;
-  
+
   // Hide UI - safely check if elements exist
   try {
     if (littlefsManager) {
-      littlefsManager.classList.add('hidden');
+      littlefsManager.classList.add("hidden");
     }
-    
+
     // Clear file list
     if (littlefsFileList) {
-      littlefsFileList.innerHTML = '';
+      littlefsFileList.innerHTML = "";
     }
   } catch (e) {
-    debugMsg('Error resetting LittleFS UI: ' + e);
+    debugMsg("Error resetting LittleFS UI: " + e);
   }
 }
 
@@ -2677,80 +2818,88 @@ function resetLittleFSState() {
  */
 async function openLittleFS(partition) {
   try {
-    logMsg(`Reading LittleFS partition "${partition.name}" (${formatSize(partition.size)})...`);
-    
+    logMsg(
+      `Reading LittleFS partition "${partition.name}" (${formatSize(partition.size)})...`,
+    );
+
     let data;
-    
+
     // Check if data was already read (from Read Flash button)
     if (partition._readData) {
       data = partition._readData;
-      logMsg('Using already-read flash data');
+      logMsg("Using already-read flash data");
     } else {
       // Read entire partition
       const partitionProgress = document.getElementById("partitionProgress");
       const progressBar = partitionProgress.querySelector("div");
       partitionProgress.classList.remove("hidden");
-      
+
       data = await espStub.readFlash(
         partition.offset,
         partition.size,
         (packet, progress, totalSize) => {
           const percent = Math.floor((progress / totalSize) * 100);
           progressBar.style.width = percent + "%";
-        }
+        },
       );
-      
+
       partitionProgress.classList.add("hidden");
       progressBar.style.width = "0%";
     }
-    
-    logMsg('Mounting LittleFS filesystem...');
-    
+
+    logMsg("Mounting LittleFS filesystem...");
+
     // Import constants from esptool module
     const basePath = new URL(".", window.location.href).pathname;
     const esptoolModulePath = `${basePath}js/modules/esptool.js`;
-    const { 
+    const {
       LITTLEFS_BLOCK_SIZE_CANDIDATES,
-      ESP8266_LITTLEFS_BLOCK_SIZE_CANDIDATES 
+      ESP8266_LITTLEFS_BLOCK_SIZE_CANDIDATES,
     } = await import(esptoolModulePath);
-    
+
     // Get chip-specific block sizes using defined constants
-    const chipName = currentChipName || '';
+    const chipName = currentChipName || "";
     const isESP8266 = chipName.toUpperCase().includes("ESP8266");
-    const blockSizes = isESP8266 ? ESP8266_LITTLEFS_BLOCK_SIZE_CANDIDATES : LITTLEFS_BLOCK_SIZE_CANDIDATES;
-    
+    const blockSizes = isESP8266
+      ? ESP8266_LITTLEFS_BLOCK_SIZE_CANDIDATES
+      : LITTLEFS_BLOCK_SIZE_CANDIDATES;
+
     let fs = null;
     let blockSize = 0;
-    
+
     // Use cached module loader
     const module = await loadLittlefsModule();
     const { createLittleFSFromImage, formatDiskVersion } = module;
-    
+
     for (const bs of blockSizes) {
       try {
         const blockCount = Math.floor(partition.size / bs);
-        
+
         // ESP8266-specific parameters (from main.py)
-        const mountOptions = isESP8266 ? {
-          blockSize: bs,
-          blockCount: blockCount,
-          readSize: 64,
-          progSize: 64,
-          cacheSize: 64,
-          lookaheadSize: 64,
-          nameMax: 32,
-          blockCycles: 16,
-        } : {
-          blockSize: bs,
-          blockCount: blockCount,
-        };
-        
+        const mountOptions = isESP8266
+          ? {
+              blockSize: bs,
+              blockCount: blockCount,
+              readSize: 64,
+              progSize: 64,
+              cacheSize: 64,
+              lookaheadSize: 64,
+              nameMax: 32,
+              blockCycles: 16,
+            }
+          : {
+              blockSize: bs,
+              blockCount: blockCount,
+            };
+
         fs = await createLittleFSFromImage(data, mountOptions);
-        
+
         // Try to list root to verify it works
-        fs.list('/');
+        fs.list("/");
         blockSize = bs;
-        logMsg(`Successfully mounted LittleFS with block size ${bs}${isESP8266 ? ' (ESP8266 parameters)' : ''}`);
+        logMsg(
+          `Successfully mounted LittleFS with block size ${bs}${isESP8266 ? " (ESP8266 parameters)" : ""}`,
+        );
         break;
       } catch (err) {
         // Try next block size
@@ -2758,44 +2907,44 @@ async function openLittleFS(partition) {
         fs = null;
       }
     }
-    
+
     if (!fs) {
-      throw new Error('Failed to mount LittleFS with any block size');
+      throw new Error("Failed to mount LittleFS with any block size");
     }
-    
+
     // Store filesystem instance
     currentLittleFS = fs;
     currentLittleFSPartition = partition;
-    currentLittleFSPath = '/';
+    currentLittleFSPath = "/";
     currentLittleFSBlockSize = blockSize;
-    currentFilesystemType = 'littlefs';
-    
+    currentFilesystemType = "littlefs";
+
     // Update UI
     littlefsPartitionName.textContent = partition.name;
     littlefsPartitionSize.textContent = formatSize(partition.size);
-    
+
     // Get disk version
     try {
       const diskVer = fs.getDiskVersion();
-      const major = (diskVer >> 16) & 0xFFFF;
-      const minor = diskVer & 0xFFFF;
+      const major = (diskVer >> 16) & 0xffff;
+      const minor = diskVer & 0xffff;
       littlefsDiskVersion.textContent = `LittleFS v${major}.${minor}`;
     } catch (e) {
-      littlefsDiskVersion.textContent = '';
+      littlefsDiskVersion.textContent = "";
     }
-    
+
     // Show manager
-    littlefsManager.classList.remove('hidden');
-    
+    littlefsManager.classList.remove("hidden");
+
     // Enable all operations for LittleFS (including directories)
     butLittlefsUpload.disabled = false;
     butLittlefsMkdir.disabled = false;
     butLittlefsWrite.disabled = false;
-    
+
     // Load files
     refreshLittleFS();
-    
-    logMsg('LittleFS filesystem opened successfully');
+
+    logMsg("LittleFS filesystem opened successfully");
   } catch (e) {
     errorMsg(`Failed to open LittleFS: ${e.message || e}`);
     // Don't call destroy() - just reset state
@@ -2808,42 +2957,46 @@ async function openLittleFS(partition) {
  */
 async function openFatFS(partition) {
   try {
-    logMsg(`Reading FatFS partition "${partition.name}" (${formatSize(partition.size)})...`);
-    
+    logMsg(
+      `Reading FatFS partition "${partition.name}" (${formatSize(partition.size)})...`,
+    );
+
     let data;
-    
+
     // Check if data was already read (from Read Flash button)
     if (partition._readData) {
       data = partition._readData;
-      logMsg('Using already-read flash data');
+      logMsg("Using already-read flash data");
     } else {
       // Read entire partition
       const partitionProgress = document.getElementById("partitionProgress");
       const progressBar = partitionProgress.querySelector("div");
       partitionProgress.classList.remove("hidden");
-      
+
       data = await espStub.readFlash(
         partition.offset,
         partition.size,
         (packet, progress, totalSize) => {
           const percent = Math.floor((progress / totalSize) * 100);
           progressBar.style.width = percent + "%";
-        }
+        },
       );
-      
+
       partitionProgress.classList.add("hidden");
       progressBar.style.width = "0%";
     }
-    
-    logMsg('Mounting FatFS filesystem...');
-    logMsg(`Partition size: ${formatSize(partition.size)} (${partition.size} bytes)`);
-    
+
+    logMsg("Mounting FatFS filesystem...");
+    logMsg(
+      `Partition size: ${formatSize(partition.size)} (${partition.size} bytes)`,
+    );
+
     // Check if FAT filesystem starts at offset 0x1000 (common for ESP8266/ESP32)
     let fatOffset = 0;
     if (data.length >= 0x1000 + 512) {
       const bootSigAt0 = data[510] | (data[511] << 8);
       const bootSigAt0x1000 = data[0x1000 + 510] | (data[0x1000 + 511] << 8);
-      
+
       // If boot signature is at 0x1000 but not at 0, use offset 0x1000
       if (bootSigAt0x1000 === 0xaa55 && bootSigAt0 !== 0xaa55) {
         fatOffset = 0x1000;
@@ -2852,38 +3005,40 @@ async function openFatFS(partition) {
         data = data.slice(fatOffset);
       }
     }
-    
+
     // Load FatFS module
     const basePath = new URL(".", window.location.href).pathname;
     const modulePath = `${basePath}src/wasm/fatfs/index.js`;
     const module = await import(modulePath);
     const { createFatFSFromImage, createFatFS } = module;
-    
+
     // Use 4096 block size (ESP32 standard)
     let blockSize = 4096;
     let blockCount = Math.max(1, Math.floor(data.length / blockSize));
     if (blockCount <= 0) {
       blockCount = 1;
     }
-    
+
     let fs = null;
-    
+
     // First try to mount existing FatFS from image
     try {
-      logMsg(`Trying to mount FatFS with block size ${blockSize} (${blockCount} blocks)...`);
-      
+      logMsg(
+        `Trying to mount FatFS with block size ${blockSize} (${blockCount} blocks)...`,
+      );
+
       fs = await createFatFSFromImage(data, {
         blockSize: blockSize,
         blockCount: blockCount,
       });
-      
+
       logMsg(`FatFS instance created, attempting to list files...`);
       const files = fs.list();
       logMsg(`Successfully listed ${files.length} files/directories`);
       logMsg(`Successfully mounted FatFS`);
     } catch (err) {
       logMsg(`Failed to mount existing FatFS: ${err.message || err}`);
-      
+
       // If mounting fails, create a new empty formatted filesystem
       // Note: This does NOT use the image data - it creates a blank filesystem
       if (createFatFS) {
@@ -2895,47 +3050,53 @@ async function openFatFS(partition) {
             formatOnInit: true,
           });
           logMsg(`Created new formatted FatFS`);
-          logMsg(`Partition appears blank/unformatted. You can format and save to initialize it.`);
+          logMsg(
+            `Partition appears blank/unformatted. You can format and save to initialize it.`,
+          );
         } catch (createErr) {
-          logMsg(`Failed to create new FatFS: ${createErr.message || createErr}`);
+          logMsg(
+            `Failed to create new FatFS: ${createErr.message || createErr}`,
+          );
           throw err; // Throw original error
         }
       } else {
         throw err;
       }
     }
-    
+
     if (!fs) {
-      throw new Error('Failed to mount FatFS with any block size. The partition may not contain a valid FAT filesystem or may be corrupted.');
+      throw new Error(
+        "Failed to mount FatFS with any block size. The partition may not contain a valid FAT filesystem or may be corrupted.",
+      );
     }
-    
+
     // Store filesystem instance and block size
     currentLittleFS = fs;
     currentLittleFSPartition = partition;
-    currentLittleFSPath = '/';
+    currentLittleFSPath = "/";
     currentLittleFSBlockSize = blockSize;
-    currentFilesystemType = 'fatfs';
-    
+    currentFilesystemType = "fatfs";
+
     // Update UI
     littlefsPartitionName.textContent = partition.name;
     littlefsPartitionSize.textContent = formatSize(partition.size);
-    littlefsDiskVersion.textContent = 'FAT';
-    
+    littlefsDiskVersion.textContent = "FAT";
+
     // Show manager
-    littlefsManager.classList.remove('hidden');
-    
+    littlefsManager.classList.remove("hidden");
+
     // Enable all operations for FatFS (including directories)
     butLittlefsUpload.disabled = false;
     butLittlefsMkdir.disabled = false;
     butLittlefsWrite.disabled = false;
-    
+
     // Load files
     refreshLittleFS();
-    
-    logMsg('FatFS filesystem opened successfully');
+
+    logMsg("FatFS filesystem opened successfully");
   } catch (e) {
     errorMsg(`Failed to open FatFS: ${e.message || e}`);
-    debugMsg('FatFS open error details: ' + e);
+    debugMsg("FatFS open error details: " + e);
     resetLittleFSState();
   }
 }
@@ -2945,57 +3106,65 @@ async function openFatFS(partition) {
  */
 async function openSPIFFS(partition) {
   try {
-    logMsg(`Reading SPIFFS partition "${partition.name}" (${formatSize(partition.size)})...`);
-    
+    logMsg(
+      `Reading SPIFFS partition "${partition.name}" (${formatSize(partition.size)})...`,
+    );
+
     let data;
-    
+
     // Check if data was already read (from Read Flash button)
     if (partition._readData) {
       data = partition._readData;
-      logMsg('Using already-read flash data');
+      logMsg("Using already-read flash data");
     } else {
       // Read entire partition
       const partitionProgress = document.getElementById("partitionProgress");
       const progressBar = partitionProgress.querySelector("div");
       partitionProgress.classList.remove("hidden");
-      
+
       data = await espStub.readFlash(
         partition.offset,
         partition.size,
         (packet, progress, totalSize) => {
           const percent = Math.floor((progress / totalSize) * 100);
           progressBar.style.width = percent + "%";
-        }
+        },
       );
-      
+
       partitionProgress.classList.add("hidden");
       progressBar.style.width = "0%";
     }
-    
-    logMsg('Parsing SPIFFS filesystem...');
-    logMsg(`Partition size: ${formatSize(partition.size)} (${partition.size} bytes)`);
-    
+
+    logMsg("Parsing SPIFFS filesystem...");
+    logMsg(
+      `Partition size: ${formatSize(partition.size)} (${partition.size} bytes)`,
+    );
+
     // Import SPIFFS module
     const basePath = new URL(".", window.location.href).pathname;
     const modulePath = `${basePath}js/modules/esptool.js`;
 
-    const { 
-      SpiffsFS, 
-      SpiffsReader, 
-      SpiffsBuildConfig, 
+    const {
+      SpiffsFS,
+      SpiffsReader,
+      SpiffsBuildConfig,
       DEFAULT_SPIFFS_CONFIG,
       ESP8266_SPIFFS_PAGE_SIZE,
-      ESP8266_SPIFFS_BLOCK_SIZE
+      ESP8266_SPIFFS_BLOCK_SIZE,
     } = await import(modulePath);
-    
+
     // Get chip-specific parameters
-    const chipName = currentChipName || '';
+    const chipName = currentChipName || "";
     const isESP8266 = chipName.toUpperCase().includes("ESP8266");
-    
+
     // ESP8266 uses different SPIFFS parameters (from main.py)
-    const pageSize = isESP8266 ? ESP8266_SPIFFS_PAGE_SIZE : DEFAULT_SPIFFS_CONFIG.pageSize || 256;
-    const blockSize = isESP8266 ? ESP8266_SPIFFS_BLOCK_SIZE : DEFAULT_SPIFFS_CONFIG.blockSize || 4096;
-    
+    const pageSize = isESP8266
+      ? ESP8266_SPIFFS_PAGE_SIZE
+      : DEFAULT_SPIFFS_CONFIG.pageSize || 256;
+    const blockSize = isESP8266
+      ? ESP8266_SPIFFS_BLOCK_SIZE
+      : DEFAULT_SPIFFS_CONFIG.blockSize || 4096;
+
     // Create build config with partition size and chip-specific parameters
     const config = new SpiffsBuildConfig({
       ...DEFAULT_SPIFFS_CONFIG,
@@ -3003,17 +3172,19 @@ async function openSPIFFS(partition) {
       pageSize: pageSize,
       blockSize: blockSize,
     });
-    
-    logMsg(`Using SPIFFS config: page_size=${pageSize}, block_size=${blockSize}${isESP8266 ? ' (ESP8266)' : ''}`);
-    
+
+    logMsg(
+      `Using SPIFFS config: page_size=${pageSize}, block_size=${blockSize}${isESP8266 ? " (ESP8266)" : ""}`,
+    );
+
     // Create reader and parse existing files
     const reader = new SpiffsReader(data, config);
     reader.parse();
-    
+
     // Get file list
     const files = reader.listFiles();
     logMsg(`Found ${files.length} files in SPIFFS`);
-    
+
     // Create a wrapper object that mimics LittleFS interface with full read/write support
     const spiffsWrapper = {
       _reader: reader,
@@ -3022,102 +3193,108 @@ async function openSPIFFS(partition) {
       _config: config,
       _originalData: data, // Store original image data
       _modified: false,
-      
-      list: function(path = '/') {
+
+      list: function (path = "/") {
         // Normalize path
-        const normalizedPath = path === '/' ? '' : path.replace(/^\//, '').replace(/\/$/, '');
-        
+        const normalizedPath =
+          path === "/" ? "" : path.replace(/^\//, "").replace(/\/$/, "");
+
         // Get all files with proper path property for UI compatibility
-        const allFiles = this._files.map(f => {
-          const fileName = f.name.startsWith('/') ? f.name.substring(1) : f.name;
+        const allFiles = this._files.map((f) => {
+          const fileName = f.name.startsWith("/")
+            ? f.name.substring(1)
+            : f.name;
           return {
             name: fileName,
-            path: '/' + fileName, // Add path property for UI
-            type: 'file',
+            path: "/" + fileName, // Add path property for UI
+            type: "file",
             size: f.size,
-            _data: f.data
+            _data: f.data,
           };
         });
-        
+
         // If root, return all files
         if (!normalizedPath) {
           return allFiles;
         }
-        
+
         // Filter by path prefix
-        const prefix = normalizedPath + '/';
-        return allFiles.filter(f => f.name.startsWith(prefix));
+        const prefix = normalizedPath + "/";
+        return allFiles.filter((f) => f.name.startsWith(prefix));
       },
-      
-      read: function(path) {
-        const normalizedPath = path.startsWith('/') ? path.substring(1) : path;
-        const file = this._files.find(f => {
-          const fname = f.name.startsWith('/') ? f.name.substring(1) : f.name;
+
+      read: function (path) {
+        const normalizedPath = path.startsWith("/") ? path.substring(1) : path;
+        const file = this._files.find((f) => {
+          const fname = f.name.startsWith("/") ? f.name.substring(1) : f.name;
           return fname === normalizedPath;
         });
         return file ? file.data : null;
       },
-      
-      readFile: function(path) {
+
+      readFile: function (path) {
         // Alias for read() to match LittleFS interface
         return this.read(path);
       },
-      
-      write: function(path, data) {
+
+      write: function (path, data) {
         // Determine the filename format used in original files
         // Check if original files have leading slash
-        const hasLeadingSlash = this._files.length > 0 && this._files[0].name.startsWith('/');
-        
+        const hasLeadingSlash =
+          this._files.length > 0 && this._files[0].name.startsWith("/");
+
         // Normalize path for comparison
-        const normalizedPath = path.startsWith('/') ? path.substring(1) : path;
-        
+        const normalizedPath = path.startsWith("/") ? path.substring(1) : path;
+
         // Store filename in the same format as original files
-        const storedName = hasLeadingSlash ? '/' + normalizedPath : normalizedPath;
-        
+        const storedName = hasLeadingSlash
+          ? "/" + normalizedPath
+          : normalizedPath;
+
         // Check if file already exists
-        const existingIndex = this._files.findIndex(f => {
-          const fname = f.name.startsWith('/') ? f.name.substring(1) : f.name;
+        const existingIndex = this._files.findIndex((f) => {
+          const fname = f.name.startsWith("/") ? f.name.substring(1) : f.name;
           return fname === normalizedPath;
         });
-        
+
         // Update or add file
         if (existingIndex >= 0) {
           this._files[existingIndex] = {
             name: storedName,
             size: data.length,
-            data: data
+            data: data,
           };
         } else {
           this._files.push({
             name: storedName,
             size: data.length,
-            data: data
+            data: data,
           });
         }
-        
+
         this._modified = true;
       },
-      
-      writeFile: function(path, data) {
+
+      writeFile: function (path, data) {
         // Alias for write() to match LittleFS interface
         return this.write(path, data);
       },
-      
-      addFile: function(path, data) {
+
+      addFile: function (path, data) {
         // Alias for write() to match alternative interface
         return this.write(path, data);
       },
-      
-      remove: function(path) {
+
+      remove: function (path) {
         // Normalize path
-        const normalizedPath = path.startsWith('/') ? path.substring(1) : path;
-        
+        const normalizedPath = path.startsWith("/") ? path.substring(1) : path;
+
         // Find and remove file
-        const index = this._files.findIndex(f => {
-          const fname = f.name.startsWith('/') ? f.name.substring(1) : f.name;
+        const index = this._files.findIndex((f) => {
+          const fname = f.name.startsWith("/") ? f.name.substring(1) : f.name;
           return fname === normalizedPath;
         });
-        
+
         if (index >= 0) {
           this._files.splice(index, 1);
           this._modified = true;
@@ -3125,77 +3302,81 @@ async function openSPIFFS(partition) {
           throw new Error(`File not found: ${path}`);
         }
       },
-      
-      deleteFile: function(path) {
+
+      deleteFile: function (path) {
         // Alias for remove() to match LittleFS interface
         return this.remove(path);
       },
-      
-      delete: function(path, options) {
+
+      delete: function (path, options) {
         // For compatibility with LittleFS delete method
         // SPIFFS doesn't have directories, so just delete the file
         return this.remove(path);
       },
-      
-      mkdir: function() {
-        throw new Error('SPIFFS does not support directories. Files are stored in a flat structure.');
+
+      mkdir: function () {
+        throw new Error(
+          "SPIFFS does not support directories. Files are stored in a flat structure.",
+        );
       },
-      
-      toImage: function() {
+
+      toImage: function () {
         // If not modified, return original data
         if (!this._modified) {
           return this._originalData || new Uint8Array(this._partition.size);
         }
-        
+
         // Create new SPIFFS filesystem with all files
         const fs = new SpiffsFS(this._partition.size, this._config);
-        
+
         // Add all files - preserve original filename format
         for (const file of this._files) {
           // Use the filename exactly as stored in _files
           // This preserves whether it has a leading slash or not
           const fileName = file.name;
-          
+
           // Log for debugging
-          console.log(`Adding file to SPIFFS: "${fileName}" (${file.data.length} bytes)`);
-          
+          console.log(
+            `Adding file to SPIFFS: "${fileName}" (${file.data.length} bytes)`,
+          );
+
           fs.createFile(fileName, file.data);
         }
-        
+
         // Generate binary image
         const image = fs.toBinary();
         console.log(`Generated SPIFFS image: ${image.length} bytes`);
         return image;
-      }
+      },
     };
-    
+
     // Store filesystem instance
     currentLittleFS = spiffsWrapper;
     currentLittleFSPartition = partition;
-    currentLittleFSPath = '/';
+    currentLittleFSPath = "/";
     currentLittleFSBlockSize = config.blockSize;
-    currentFilesystemType = 'spiffs';
-    
+    currentFilesystemType = "spiffs";
+
     // Update UI
     littlefsPartitionName.textContent = partition.name;
     littlefsPartitionSize.textContent = formatSize(partition.size);
-    littlefsDiskVersion.textContent = 'SPIFFS';
-    
+    littlefsDiskVersion.textContent = "SPIFFS";
+
     // Show manager
-    littlefsManager.classList.remove('hidden');
-    
+    littlefsManager.classList.remove("hidden");
+
     // Enable write operations for SPIFFS (but not mkdir since SPIFFS is flat)
     butLittlefsUpload.disabled = false;
     butLittlefsMkdir.disabled = true; // SPIFFS doesn't support directories
     butLittlefsWrite.disabled = false;
-    
+
     // Load files
     refreshLittleFS();
-    
-    logMsg('SPIFFS filesystem opened successfully');
+
+    logMsg("SPIFFS filesystem opened successfully");
   } catch (e) {
     errorMsg(`Failed to open SPIFFS: ${e.message || e}`);
-    debugMsg('SPIFFS open error details: ' + e);
+    debugMsg("SPIFFS open error details: " + e);
     resetLittleFSState();
   }
 }
@@ -3216,15 +3397,15 @@ function littlefsEstimateFileFootprint(size) {
 function littlefsEstimateUsage(entries) {
   const block = currentLittleFSBlockSize || 4096;
   let total = block * 2; // root metadata copies
-  
+
   for (const entry of entries || []) {
-    if (entry.type === 'dir') {
+    if (entry.type === "dir") {
       total += block;
     } else {
       total += littlefsEstimateFileFootprint(entry.size || 0);
     }
   }
-  
+
   return total;
 }
 
@@ -3233,149 +3414,154 @@ function littlefsEstimateUsage(entries) {
  */
 function refreshLittleFS() {
   if (!currentLittleFS) return;
-  
+
   try {
     // Calculate usage based on all files (like ESPConnect)
-    const allFiles = currentLittleFS.list('/');
+    const allFiles = currentLittleFS.list("/");
     const usedBytes = littlefsEstimateUsage(allFiles);
     const totalBytes = currentLittleFSPartition.size;
     const usedPercent = Math.round((usedBytes / totalBytes) * 100);
-    
-    littlefsUsageBar.style.width = usedPercent + '%';
+
+    littlefsUsageBar.style.width = usedPercent + "%";
     littlefsUsageText.textContent = `Used: ${formatSize(usedBytes)} / ${formatSize(totalBytes)} (${usedPercent}%)`;
-    
+
     // Update breadcrumb
-    littlefsBreadcrumb.textContent = currentLittleFSPath || '/';
-    butLittlefsUp.disabled = currentLittleFSPath === '/' || !currentLittleFSPath;
-    
+    littlefsBreadcrumb.textContent = currentLittleFSPath || "/";
+    butLittlefsUp.disabled =
+      currentLittleFSPath === "/" || !currentLittleFSPath;
+
     // List files - the list() function behavior differs between filesystems
     let entries;
-    
-    if (currentFilesystemType === 'fatfs') {
+
+    if (currentFilesystemType === "fatfs") {
       // FatFS returns ALL files recursively from root, so we always list from root and filter
-      const allEntries = currentLittleFS.list('/');
-      const isRoot = currentLittleFSPath === '/';
-      
+      const allEntries = currentLittleFS.list("/");
+      const isRoot = currentLittleFSPath === "/";
+
       // Filter to show only direct children
-      entries = allEntries.filter(entry => {
+      entries = allEntries.filter((entry) => {
         // Remove /fatfs prefix from entry path for comparison
         let entryPath = entry.path;
-        if (entryPath.startsWith('/fatfs/')) {
+        if (entryPath.startsWith("/fatfs/")) {
           entryPath = entryPath.slice(6);
-        } else if (entryPath === '/fatfs') {
-          entryPath = '/';
+        } else if (entryPath === "/fatfs") {
+          entryPath = "/";
         }
-        
+
         if (isRoot) {
           // In root: only show top-level entries
           const withoutLeadingSlash = entryPath.slice(1);
-          return withoutLeadingSlash && !withoutLeadingSlash.includes('/');
+          return withoutLeadingSlash && !withoutLeadingSlash.includes("/");
         } else {
           // In subdirectory: entry must be direct child of current path
-          const expectedPrefix = currentLittleFSPath + '/';
+          const expectedPrefix = currentLittleFSPath + "/";
           if (!entryPath.startsWith(expectedPrefix)) {
             return false;
           }
           const relativePath = entryPath.slice(expectedPrefix.length);
-          return relativePath && !relativePath.includes('/');
+          return relativePath && !relativePath.includes("/");
         }
       });
-      
+
       // Add name attribute for FatFS entries
-      entries = entries.map(entry => ({
+      entries = entries.map((entry) => ({
         ...entry,
-        name: entry.path.split('/').pop() || entry.path
+        name: entry.path.split("/").pop() || entry.path,
       }));
     } else {
       // LittleFS and SPIFFS return only direct children
       entries = currentLittleFS.list(currentLittleFSPath);
     }
-    
+
     // Clear table
-    littlefsFileList.innerHTML = '';
-    
+    littlefsFileList.innerHTML = "";
+
     if (entries.length === 0) {
-      const row = document.createElement('tr');
-      row.innerHTML = '<td colspan="4" class="empty-state">No files in this directory</td>';
+      const row = document.createElement("tr");
+      row.innerHTML =
+        '<td colspan="4" class="empty-state">No files in this directory</td>';
       littlefsFileList.appendChild(row);
       return;
     }
-    
+
     // Sort: directories first, then files
     entries.sort((a, b) => {
-      if (a.type === 'dir' && b.type !== 'dir') return -1;
-      if (a.type !== 'dir' && b.type === 'dir') return 1;
+      if (a.type === "dir" && b.type !== "dir") return -1;
+      if (a.type !== "dir" && b.type === "dir") return 1;
       return a.path.localeCompare(b.path);
     });
-    
+
     // Add rows
-    entries.forEach(entry => {
-      const row = document.createElement('tr');
-      
+    entries.forEach((entry) => {
+      const row = document.createElement("tr");
+
       // Name
-      const nameCell = document.createElement('td');
-      nameCell.setAttribute('data-label', 'Name');
-      const nameDiv = document.createElement('div');
-      nameDiv.className = 'file-name' + (entry.type === 'dir' ? ' clickable' : '');
-      
-      const icon = document.createElement('span');
-      icon.className = 'file-icon';
-      icon.textContent = entry.type === 'dir' ? '📁' : '📄';
-      
+      const nameCell = document.createElement("td");
+      nameCell.setAttribute("data-label", "Name");
+      const nameDiv = document.createElement("div");
+      nameDiv.className =
+        "file-name" + (entry.type === "dir" ? " clickable" : "");
+
+      const icon = document.createElement("span");
+      icon.className = "file-icon";
+      icon.textContent = entry.type === "dir" ? "📁" : "📄";
+
       // Use entry.name instead of parsing the path
-      const name = entry.name || entry.path.split('/').filter(Boolean).pop() || '/';
-      const nameText = document.createElement('span');
+      const name =
+        entry.name || entry.path.split("/").filter(Boolean).pop() || "/";
+      const nameText = document.createElement("span");
       nameText.textContent = name;
-      
+
       nameDiv.appendChild(icon);
       nameDiv.appendChild(nameText);
-      
-      if (entry.type === 'dir') {
+
+      if (entry.type === "dir") {
         nameDiv.onclick = () => navigateLittleFS(entry.path);
       }
-      
+
       nameCell.appendChild(nameDiv);
       row.appendChild(nameCell);
-      
+
       // Type
-      const typeCell = document.createElement('td');
-      typeCell.setAttribute('data-label', 'Type');
-      typeCell.textContent = entry.type === 'dir' ? 'Directory' : 'File';
+      const typeCell = document.createElement("td");
+      typeCell.setAttribute("data-label", "Type");
+      typeCell.textContent = entry.type === "dir" ? "Directory" : "File";
       row.appendChild(typeCell);
-      
+
       // Size
-      const sizeCell = document.createElement('td');
-      sizeCell.setAttribute('data-label', 'Size');
-      sizeCell.textContent = entry.type === 'file' ? formatSize(entry.size) : '-';
+      const sizeCell = document.createElement("td");
+      sizeCell.setAttribute("data-label", "Size");
+      sizeCell.textContent =
+        entry.type === "file" ? formatSize(entry.size) : "-";
       row.appendChild(sizeCell);
-      
+
       // Actions
-      const actionsCell = document.createElement('td');
-      actionsCell.setAttribute('data-label', 'Actions');
-      const actionsDiv = document.createElement('div');
-      actionsDiv.className = 'file-actions';
-      
-      if (entry.type === 'file') {
-        const downloadBtn = document.createElement('button');
-        downloadBtn.textContent = 'Download';
+      const actionsCell = document.createElement("td");
+      actionsCell.setAttribute("data-label", "Actions");
+      const actionsDiv = document.createElement("div");
+      actionsDiv.className = "file-actions";
+
+      if (entry.type === "file") {
+        const downloadBtn = document.createElement("button");
+        downloadBtn.textContent = "Download";
         downloadBtn.onclick = () => downloadLittleFSFile(entry.path);
         actionsDiv.appendChild(downloadBtn);
-        
-        const viewBtn = document.createElement('button');
-        viewBtn.textContent = 'View';
+
+        const viewBtn = document.createElement("button");
+        viewBtn.textContent = "View";
         viewBtn.onclick = () => viewLittleFSFile(entry.path);
         actionsDiv.appendChild(viewBtn);
       }
-      
-      const deleteBtn = document.createElement('button');
-      deleteBtn.textContent = 'Delete';
-      deleteBtn.className = 'delete-btn';
+
+      const deleteBtn = document.createElement("button");
+      deleteBtn.textContent = "Delete";
+      deleteBtn.className = "delete-btn";
       deleteBtn.onclick = () => deleteLittleFSFile(entry.path, entry.type);
       actionsDiv.appendChild(deleteBtn);
-      
+
       actionsCell.appendChild(actionsDiv);
       row.appendChild(actionsCell);
-      
+
       littlefsFileList.appendChild(row);
     });
   } catch (e) {
@@ -3389,17 +3575,17 @@ function refreshLittleFS() {
 function navigateLittleFS(path) {
   // Remove /fatfs prefix if present (for FatFS compatibility)
   let normalizedPath = path;
-  if (normalizedPath.startsWith('/fatfs/')) {
+  if (normalizedPath.startsWith("/fatfs/")) {
     normalizedPath = normalizedPath.slice(6); // Remove '/fatfs' keeping the /
-  } else if (normalizedPath === '/fatfs') {
-    normalizedPath = '/';
+  } else if (normalizedPath === "/fatfs") {
+    normalizedPath = "/";
   }
-  
+
   // Remove trailing slash except for root
-  if (normalizedPath !== '/' && normalizedPath.endsWith('/')) {
+  if (normalizedPath !== "/" && normalizedPath.endsWith("/")) {
     normalizedPath = normalizedPath.slice(0, -1);
   }
-  
+
   currentLittleFSPath = normalizedPath;
   refreshLittleFS();
 }
@@ -3408,14 +3594,14 @@ function navigateLittleFS(path) {
  * Navigate up one directory
  */
 function clickLittlefsUp() {
-  if (currentLittleFSPath === '/' || !currentLittleFSPath) return;
-  
+  if (currentLittleFSPath === "/" || !currentLittleFSPath) return;
+
   // Split path and remove last segment
-  const parts = currentLittleFSPath.split('/').filter(Boolean);
+  const parts = currentLittleFSPath.split("/").filter(Boolean);
   parts.pop();
-  
+
   // Reconstruct path
-  currentLittleFSPath = parts.length ? '/' + parts.join('/') : '/';
+  currentLittleFSPath = parts.length ? "/" + parts.join("/") : "/";
   refreshLittleFS();
 }
 
@@ -3432,21 +3618,25 @@ function clickLittlefsRefresh() {
  */
 async function clickLittlefsBackup() {
   if (!currentLittleFS || !currentLittleFSPartition) return;
-  
+
   try {
     logMsg(`Creating ${getFilesystemDisplayName()} backup image...`);
     const image = currentLittleFS.toImage();
-    
+
     // Create filename with chip type and MAC address
-    const chipInfo = currentChipName ? currentChipName.replace(/\s+/g, '_') : 'ESP';
-    const macInfo = currentMacAddr ? currentMacAddr.replace(/:/g, '') : '';
-    const fsType = currentFilesystemType || 'filesystem';
-    const filename = `${chipInfo}${macInfo ? '_' + macInfo : ''}_${currentLittleFSPartition.name}_${fsType}_backup.bin`;
+    const chipInfo = currentChipName
+      ? currentChipName.replace(/\s+/g, "_")
+      : "ESP";
+    const macInfo = currentMacAddr ? currentMacAddr.replace(/:/g, "") : "";
+    const fsType = currentFilesystemType || "filesystem";
+    const filename = `${chipInfo}${macInfo ? "_" + macInfo : ""}_${currentLittleFSPartition.name}_${fsType}_backup.bin`;
     await saveDataToFile(image, filename);
-    
+
     logMsg(`${getFilesystemDisplayName()} backup saved as "${filename}"`);
   } catch (e) {
-    errorMsg(`Failed to backup ${getFilesystemDisplayName()}: ${e.message || e}`);
+    errorMsg(
+      `Failed to backup ${getFilesystemDisplayName()}: ${e.message || e}`,
+    );
   }
 }
 
@@ -3455,27 +3645,29 @@ async function clickLittlefsBackup() {
  */
 async function clickLittlefsWrite() {
   if (!currentLittleFS || !currentLittleFSPartition) return;
-  
+
   const confirmed = confirm(
     `Write modified filesystem to flash?\n\n` +
-    `Partition: ${currentLittleFSPartition.name}\n` +
-    `Offset: 0x${currentLittleFSPartition.offset.toString(16)}\n` +
-    `Size: ${formatSize(currentLittleFSPartition.size)}\n\n` +
-    `This will overwrite the current filesystem on the device!`
+      `Partition: ${currentLittleFSPartition.name}\n` +
+      `Offset: 0x${currentLittleFSPartition.offset.toString(16)}\n` +
+      `Size: ${formatSize(currentLittleFSPartition.size)}\n\n` +
+      `This will overwrite the current filesystem on the device!`,
   );
-  
+
   if (!confirmed) return;
-  
+
   try {
     logMsg(`Creating ${getFilesystemDisplayName()} image...`);
     const image = currentLittleFS.toImage();
     logMsg(`Image created: ${formatSize(image.length)}`);
-    
+
     if (image.length > currentLittleFSPartition.size) {
-      errorMsg(`Image size (${formatSize(image.length)}) exceeds partition size (${formatSize(currentLittleFSPartition.size)})`);
+      errorMsg(
+        `Image size (${formatSize(image.length)}) exceeds partition size (${formatSize(currentLittleFSPartition.size)})`,
+      );
       return;
     }
-    
+
     // Disable buttons during write
     butLittlefsRefresh.disabled = true;
     butLittlefsBackup.disabled = true;
@@ -3483,19 +3675,24 @@ async function clickLittlefsWrite() {
     butLittlefsClose.disabled = true;
     butLittlefsUpload.disabled = true;
     butLittlefsMkdir.disabled = true;
-    
-    logMsg(`Writing ${formatSize(image.length)} to partition "${currentLittleFSPartition.name}" at 0x${currentLittleFSPartition.offset.toString(16)}...`);
-    
+
+    logMsg(
+      `Writing ${formatSize(image.length)} to partition "${currentLittleFSPartition.name}" at 0x${currentLittleFSPartition.offset.toString(16)}...`,
+    );
+
     // Use the LittleFS usage bar as progress indicator
     const usageBar = document.getElementById("littlefsUsageBar");
     const usageText = document.getElementById("littlefsUsageText");
     const originalUsageBarWidth = usageBar.style.width;
     const originalUsageText = usageText.textContent;
-    
+
     // Convert Uint8Array to ArrayBuffer (CRITICAL: flashData expects ArrayBuffer, not Uint8Array)
     // This matches the ESPConnect implementation
-    const imageBuffer = image.buffer.slice(image.byteOffset, image.byteOffset + image.byteLength);
-    
+    const imageBuffer = image.buffer.slice(
+      image.byteOffset,
+      image.byteOffset + image.byteLength,
+    );
+
     // Write the image to flash with progress indication
     await espStub.flashData(
       imageBuffer,
@@ -3504,18 +3701,19 @@ async function clickLittlefsWrite() {
         usageBar.style.width = percent + "%";
         usageText.textContent = `Writing: ${formatSize(bytesWritten)} / ${formatSize(totalBytes)} (${percent}%)`;
       },
-      currentLittleFSPartition.offset
+      currentLittleFSPartition.offset,
     );
-    
+
     // Restore original usage display
     usageBar.style.width = originalUsageBarWidth;
     usageText.textContent = originalUsageText;
-    
+
     logMsg(`${getFilesystemDisplayName()} successfully written to flash!`);
     logMsg(`To use the new filesystem, reset your device.`);
-    
   } catch (e) {
-    errorMsg(`Failed to write ${getFilesystemDisplayName()} to flash: ${e.message || e}`);
+    errorMsg(
+      `Failed to write ${getFilesystemDisplayName()} to flash: ${e.message || e}`,
+    );
   } finally {
     // Re-enable buttons
     butLittlefsRefresh.disabled = false;
@@ -3524,7 +3722,7 @@ async function clickLittlefsWrite() {
     butLittlefsClose.disabled = false;
     butLittlefsUpload.disabled = !littlefsFileInput.files.length;
     // Re-enable mkdir only if not SPIFFS
-    butLittlefsMkdir.disabled = (currentFilesystemType === 'spiffs');
+    butLittlefsMkdir.disabled = currentFilesystemType === "spiffs";
   }
 }
 
@@ -3532,12 +3730,12 @@ async function clickLittlefsWrite() {
  * Close LittleFS manager
  */
 function clickLittlefsClose() {
-  const fsName = getFilesystemDisplayName() || 'Filesystem';
-  
+  const fsName = getFilesystemDisplayName() || "Filesystem";
+
   if (currentLittleFS) {
     try {
       // Only call destroy if it exists (LittleFS has it, FatFS/SPIFFS don't)
-      if (typeof currentLittleFS.destroy === 'function') {
+      if (typeof currentLittleFS.destroy === "function") {
         currentLittleFS.destroy();
       }
     } catch (e) {
@@ -3545,11 +3743,11 @@ function clickLittlefsClose() {
     }
     currentLittleFS = null;
   }
-  
+
   currentLittleFSPartition = null;
-  currentLittleFSPath = '/';
+  currentLittleFSPath = "/";
   currentFilesystemType = null;
-  littlefsManager.classList.add('hidden');
+  littlefsManager.classList.add("hidden");
   logMsg(`${fsName} manager closed`);
 }
 
@@ -3558,24 +3756,24 @@ function clickLittlefsClose() {
  */
 async function clickLittlefsUpload() {
   if (!currentLittleFS || !littlefsFileInput.files.length) return;
-  
+
   const file = littlefsFileInput.files[0];
-  
+
   try {
     logMsg(`Uploading file "${file.name}"...`);
-    
+
     const data = await file.arrayBuffer();
     const uint8Data = new Uint8Array(data);
-    
+
     // Construct target path
     let targetPath = currentLittleFSPath;
-    if (!targetPath.endsWith('/')) targetPath += '/';
+    if (!targetPath.endsWith("/")) targetPath += "/";
     targetPath += file.name;
-    
+
     // Ensure parent directories exist
-    const segments = targetPath.split('/').filter(Boolean);
+    const segments = targetPath.split("/").filter(Boolean);
     if (segments.length > 1) {
-      let built = '';
+      let built = "";
       for (let i = 0; i < segments.length - 1; i++) {
         built += `/${segments[i]}`;
         try {
@@ -3585,25 +3783,25 @@ async function clickLittlefsUpload() {
         }
       }
     }
-    
+
     // Write file to LittleFS - EXACTLY like ESPConnect
-    if (typeof currentLittleFS.writeFile === 'function') {
+    if (typeof currentLittleFS.writeFile === "function") {
       currentLittleFS.writeFile(targetPath, uint8Data);
-    } else if (typeof currentLittleFS.addFile === 'function') {
+    } else if (typeof currentLittleFS.addFile === "function") {
       currentLittleFS.addFile(targetPath, uint8Data);
     }
-    
+
     // Verify by reading back
     const readBack = currentLittleFS.readFile(targetPath);
     logMsg(`File written: ${readBack.length} bytes at ${targetPath}`);
-    
+
     // Clear input
-    littlefsFileInput.value = '';
+    littlefsFileInput.value = "";
     butLittlefsUpload.disabled = true;
-    
+
     // Refresh list
     refreshLittleFS();
-    
+
     logMsg(`File "${file.name}" uploaded successfully`);
   } catch (e) {
     errorMsg(`Failed to upload file: ${e.message || e}`);
@@ -3615,30 +3813,32 @@ async function clickLittlefsUpload() {
  */
 async function clickLittlefsMkdir() {
   if (!currentLittleFS) return;
-  
+
   // Check if mkdir is supported (SPIFFS doesn't support directories)
-  if (currentFilesystemType === 'spiffs') {
-    errorMsg('SPIFFS does not support directories. Files are stored in a flat structure.');
+  if (currentFilesystemType === "spiffs") {
+    errorMsg(
+      "SPIFFS does not support directories. Files are stored in a flat structure.",
+    );
     return;
   }
-  
+
   let dirName;
   if (isElectron) {
-    dirName = await window.electronAPI.showPrompt('Enter directory name:');
+    dirName = await window.electronAPI.showPrompt("Enter directory name:");
   } else {
-    dirName = prompt('Enter directory name:');
+    dirName = prompt("Enter directory name:");
   }
-  
+
   if (!dirName || !dirName.trim()) return;
-  
+
   try {
     let targetPath = currentLittleFSPath;
-    if (!targetPath.endsWith('/')) targetPath += '/';
+    if (!targetPath.endsWith("/")) targetPath += "/";
     targetPath += dirName.trim();
-    
+
     currentLittleFS.mkdir(targetPath);
     refreshLittleFS();
-    
+
     logMsg(`Directory "${dirName}" created successfully`);
   } catch (e) {
     errorMsg(`Failed to create directory: ${e.message || e}`);
@@ -3650,15 +3850,15 @@ async function clickLittlefsMkdir() {
  */
 async function downloadLittleFSFile(path) {
   if (!currentLittleFS) return;
-  
+
   try {
     logMsg(`Downloading file "${path}"...`);
-    
+
     const data = currentLittleFS.readFile(path);
-    const filename = path.split('/').filter(Boolean).pop() || 'file.bin';
-    
+    const filename = path.split("/").filter(Boolean).pop() || "file.bin";
+
     await saveDataToFile(data, filename);
-    
+
     logMsg(`File "${filename}" downloaded successfully`);
   } catch (e) {
     errorMsg(`Failed to download file: ${e.message || e}`);
@@ -3670,21 +3870,23 @@ async function downloadLittleFSFile(path) {
  */
 function deleteLittleFSFile(path, type) {
   if (!currentLittleFS) return;
-  
-  const name = path.split('/').filter(Boolean).pop() || path;
+
+  const name = path.split("/").filter(Boolean).pop() || path;
   const confirmed = confirm(`Delete ${type} "${name}"?`);
-  
+
   if (!confirmed) return;
-  
+
   try {
-    if (type === 'dir') {
+    if (type === "dir") {
       currentLittleFS.delete(path, { recursive: true });
     } else {
       currentLittleFS.deleteFile(path);
     }
-    
+
     refreshLittleFS();
-    logMsg(`${type === 'dir' ? 'Directory' : 'File'} "${name}" deleted successfully`);
+    logMsg(
+      `${type === "dir" ? "Directory" : "File"} "${name}" deleted successfully`,
+    );
   } catch (e) {
     errorMsg(`Failed to delete ${type}: ${e.message || e}`);
   }
@@ -3695,28 +3897,28 @@ function deleteLittleFSFile(path, type) {
  */
 async function viewLittleFSFile(path) {
   if (!currentLittleFS) return;
-  
+
   try {
     logMsg(`Loading file "${path}"...`);
-    
+
     const data = currentLittleFS.readFile(path);
-    const filename = path.split('/').filter(Boolean).pop() || 'file';
-    
+    const filename = path.split("/").filter(Boolean).pop() || "file";
+
     // Store current file data
     currentViewedFile = path;
     currentViewedFileData = data;
-    
+
     // Update modal info
     fileViewerTitle.textContent = filename;
     fileViewerPath.textContent = path;
     fileViewerSize.textContent = formatSize(data.length);
-    
+
     // Show text view by default
-    switchViewerTab('text');
-    
+    switchViewerTab("text");
+
     // Show modal
-    fileViewerModal.classList.remove('hidden');
-    
+    fileViewerModal.classList.remove("hidden");
+
     logMsg(`File "${filename}" loaded successfully`);
   } catch (e) {
     errorMsg(`Failed to view file: ${e.message || e}`);
@@ -3727,7 +3929,7 @@ async function viewLittleFSFile(path) {
  * Close file viewer modal
  */
 function closeFileViewer() {
-  fileViewerModal.classList.add('hidden');
+  fileViewerModal.classList.add("hidden");
   currentViewedFile = null;
   currentViewedFileData = null;
 }
@@ -3737,8 +3939,9 @@ function closeFileViewer() {
  */
 async function downloadFromViewer() {
   if (!currentViewedFile || !currentViewedFileData) return;
-  
-  const filename = currentViewedFile.split('/').filter(Boolean).pop() || 'file.bin';
+
+  const filename =
+    currentViewedFile.split("/").filter(Boolean).pop() || "file.bin";
   await saveDataToFile(currentViewedFileData, filename);
   logMsg(`File "${filename}" downloaded from viewer`);
 }
@@ -3748,15 +3951,15 @@ async function downloadFromViewer() {
  */
 function switchViewerTab(mode) {
   if (!currentViewedFileData) return;
-  
+
   // Update tab buttons
-  if (mode === 'text') {
-    tabText.classList.add('active');
-    tabHex.classList.remove('active');
+  if (mode === "text") {
+    tabText.classList.add("active");
+    tabHex.classList.remove("active");
     displayTextView(currentViewedFileData);
   } else {
-    tabHex.classList.add('active');
-    tabText.classList.remove('active');
+    tabHex.classList.add("active");
+    tabText.classList.remove("active");
     displayHexView(currentViewedFileData);
   }
 }
@@ -3767,13 +3970,13 @@ function switchViewerTab(mode) {
 function displayTextView(data) {
   try {
     // Try to decode as UTF-8
-    const decoder = new TextDecoder('utf-8', { fatal: false });
+    const decoder = new TextDecoder("utf-8", { fatal: false });
     const text = decoder.decode(data);
-    
+
     fileViewerText.textContent = text;
-    fileViewerText.className = '';
+    fileViewerText.className = "";
   } catch (e) {
-    fileViewerText.textContent = 'Unable to display as text. Try Hex view.';
+    fileViewerText.textContent = "Unable to display as text. Try Hex view.";
   }
 }
 
@@ -3783,52 +3986,52 @@ function displayTextView(data) {
 function displayHexView(data) {
   const lines = [];
   const bytesPerLine = 16;
-  
+
   for (let i = 0; i < data.length; i += bytesPerLine) {
-    const offset = i.toString(16).padStart(8, '0').toUpperCase();
-    
+    const offset = i.toString(16).padStart(8, "0").toUpperCase();
+
     // Hex bytes
     const hexBytes = [];
     const asciiChars = [];
-    
+
     for (let j = 0; j < bytesPerLine; j++) {
       if (i + j < data.length) {
         const byte = data[i + j];
-        hexBytes.push(byte.toString(16).padStart(2, '0').toUpperCase());
-        
+        hexBytes.push(byte.toString(16).padStart(2, "0").toUpperCase());
+
         // ASCII representation (printable characters only)
         if (byte >= 32 && byte <= 126) {
           asciiChars.push(String.fromCharCode(byte));
         } else {
-          asciiChars.push('.');
+          asciiChars.push(".");
         }
       } else {
-        hexBytes.push('  ');
-        asciiChars.push(' ');
+        hexBytes.push("  ");
+        asciiChars.push(" ");
       }
     }
-    
+
     // Format: offset | hex bytes (grouped by 8) | ascii
-    const hexPart1 = hexBytes.slice(0, 8).join(' ');
-    const hexPart2 = hexBytes.slice(8, 16).join(' ');
-    const hexPart = hexPart1 + '  ' + hexPart2;
-    const asciiPart = asciiChars.join('');
-    
+    const hexPart1 = hexBytes.slice(0, 8).join(" ");
+    const hexPart2 = hexBytes.slice(8, 16).join(" ");
+    const hexPart = hexPart1 + "  " + hexPart2;
+    const asciiPart = asciiChars.join("");
+
     lines.push(
       `<div class="hex-line">` +
-      `<span class="hex-offset">${offset}</span>` +
-      `<span class="hex-bytes">${hexPart}</span>` +
-      `<span class="hex-ascii">${asciiPart}</span>` +
-      `</div>`
+        `<span class="hex-offset">${offset}</span>` +
+        `<span class="hex-bytes">${hexPart}</span>` +
+        `<span class="hex-ascii">${asciiPart}</span>` +
+        `</div>`,
     );
   }
-  
-  fileViewerText.innerHTML = `<div class="hex-view">${lines.join('')}</div>`;
-  fileViewerText.className = 'hex-view';
+
+  fileViewerText.innerHTML = `<div class="hex-view">${lines.join("")}</div>`;
+  fileViewerText.className = "hex-view";
 }
 
 // Close modal when clicking outside
-fileViewerModal.addEventListener('click', (e) => {
+fileViewerModal.addEventListener("click", (e) => {
   if (e.target === fileViewerModal) {
     closeFileViewer();
   }