tasmota-webserial-esptool 9.2.19 → 9.2.21

package/dist/esp_loader.js

@@ -1,7 +1,7 @@
 /// <reference types="@types/w3c-web-serial" />
-import { CHIP_FAMILY_ESP32, CHIP_FAMILY_ESP32S2, CHIP_FAMILY_ESP32S3, CHIP_FAMILY_ESP32C2, CHIP_FAMILY_ESP32C3, CHIP_FAMILY_ESP32C5, CHIP_FAMILY_ESP32C6, CHIP_FAMILY_ESP32C61, CHIP_FAMILY_ESP32H2, CHIP_FAMILY_ESP32H4, CHIP_FAMILY_ESP32H21, CHIP_FAMILY_ESP32P4, CHIP_FAMILY_ESP32S31, CHIP_FAMILY_ESP8266, MAX_TIMEOUT, DEFAULT_TIMEOUT, ERASE_REGION_TIMEOUT_PER_MB, ESP_CHANGE_BAUDRATE, ESP_CHECKSUM_MAGIC, ESP_FLASH_BEGIN, ESP_FLASH_DATA, ESP_FLASH_END, ESP_MEM_BEGIN, ESP_MEM_DATA, ESP_MEM_END, ESP_READ_REG, ESP_WRITE_REG, ESP_SPI_ATTACH, ESP_SYNC, ESP_GET_SECURITY_INFO, FLASH_SECTOR_SIZE, FLASH_WRITE_SIZE, STUB_FLASH_WRITE_SIZE, MEM_END_ROM_TIMEOUT, ROM_INVALID_RECV_MSG, SYNC_PACKET, SYNC_TIMEOUT, USB_RAM_BLOCK, ESP_ERASE_FLASH, ESP_ERASE_REGION, ESP_READ_FLASH, CHIP_ERASE_TIMEOUT, FLASH_READ_TIMEOUT, timeoutPerMb, ESP_ROM_BAUD, USB_JTAG_SERIAL_PID, ESP_FLASH_DEFL_BEGIN, ESP_FLASH_DEFL_DATA, ESP_FLASH_DEFL_END, getSpiFlashAddresses, DETECTED_FLASH_SIZES, CHIP_DETECT_MAGIC_REG_ADDR, CHIP_DETECT_MAGIC_VALUES, CHIP_ID_TO_INFO, ESP32P4_EFUSE_BLOCK1_ADDR, SlipReadError, ESP32S2_RTC_CNTL_WDTWPROTECT_REG, ESP32S2_RTC_CNTL_WDTCONFIG0_REG, ESP32S2_RTC_CNTL_WDTCONFIG1_REG, ESP32S2_RTC_CNTL_WDT_WKEY, ESP32S2_RTC_CNTL_OPTION1_REG, ESP32S2_RTC_CNTL_FORCE_DOWNLOAD_BOOT_MASK, ESP32S3_RTC_CNTL_WDTWPROTECT_REG, ESP32S3_RTC_CNTL_WDTCONFIG0_REG, ESP32S3_RTC_CNTL_WDTCONFIG1_REG, ESP32S3_RTC_CNTL_WDT_WKEY, ESP32S3_RTC_CNTL_OPTION1_REG, ESP32S3_RTC_CNTL_FORCE_DOWNLOAD_BOOT_MASK, ESP32C3_EFUSE_RD_MAC_SPI_SYS_3_REG, ESP32C3_EFUSE_RD_MAC_SPI_SYS_5_REG, ESP32C3_RTC_CNTL_WDTWPROTECT_REG, ESP32C3_RTC_CNTL_WDTCONFIG0_REG, ESP32C3_RTC_CNTL_WDTCONFIG1_REG, ESP32C3_RTC_CNTL_WDT_WKEY, ESP32C5_C6_RTC_CNTL_WDTWPROTECT_REG, ESP32C5_C6_RTC_CNTL_WDTCONFIG0_REG, ESP32C5_C6_RTC_CNTL_WDTCONFIG1_REG, ESP32C5_C6_RTC_CNTL_WDT_WKEY, ESP32P4_RTC_CNTL_WDTWPROTECT_REG, ESP32P4_RTC_CNTL_WDTCONFIG0_REG, ESP32P4_RTC_CNTL_WDTCONFIG1_REG, ESP32P4_RTC_CNTL_WDT_WKEY, ESP32P4_RTC_CNTL_OPTION1_REG, ESP32P4_RTC_CNTL_FORCE_DOWNLOAD_BOOT_MASK, ESP32P4_LP_SYSTEM_REG_ANA_XPD_PAD_GROUP_REG, ESP32P4_PMU_EXT_LDO_P0_0P1A_ANA_REG, ESP32P4_PMU_ANA_0P1A_EN_CUR_LIM_0, ESP32P4_PMU_EXT_LDO_P0_0P1A_REG, ESP32P4_PMU_0P1A_TARGET0_0, ESP32P4_PMU_0P1A_FORCE_TIEH_SEL_0, ESP32P4_PMU_DATE_REG, ESP32C5_PCR_SYSCLK_CONF_REG, ESP32C5_PCR_SYSCLK_XTAL_FREQ_V, ESP32C5_PCR_SYSCLK_XTAL_FREQ_S, ESP32C5_UART_CLKDIV_REG, ESP32S2_UARTDEV_BUF_NO, ESP32S2_UARTDEV_BUF_NO_USB_OTG, ESP32S3_UARTDEV_BUF_NO, ESP32S3_UARTDEV_BUF_NO_USB_JTAG_SERIAL, ESP32S3_UARTDEV_BUF_NO_USB_OTG, ESP32C3_BUF_UART_NO_OFFSET, ESP32C3_UARTDEV_BUF_NO_USB_JTAG_SERIAL, ESP32C5_UARTDEV_BUF_NO, ESP32C5_UARTDEV_BUF_NO_USB_JTAG_SERIAL, ESP32C6_UARTDEV_BUF_NO, ESP32C6_UARTDEV_BUF_NO_USB_JTAG_SERIAL, ESP32C61_UARTDEV_BUF_NO_REV_LE2, ESP32C61_UARTDEV_BUF_NO_REV_GT2, ESP32C61_UARTDEV_BUF_NO_USB_JTAG_SERIAL_REV_LE2, ESP32C61_UARTDEV_BUF_NO_USB_JTAG_SERIAL_REV_GT2, ESP32H2_UARTDEV_BUF_NO, ESP32H2_UARTDEV_BUF_NO_USB_JTAG_SERIAL, ESP32H4_UARTDEV_BUF_NO, ESP32H4_UARTDEV_BUF_NO_USB_JTAG_SERIAL, ESP32P4_UARTDEV_BUF_NO_REV0, ESP32P4_UARTDEV_BUF_NO_REV300, ESP32P4_UARTDEV_BUF_NO_USB_JTAG_SERIAL, ESP32P4_UARTDEV_BUF_NO_USB_OTG, } from "./const";
+import { CHIP_FAMILY_ESP32, CHIP_FAMILY_ESP32S2, CHIP_FAMILY_ESP32S3, CHIP_FAMILY_ESP32C2, CHIP_FAMILY_ESP32C3, CHIP_FAMILY_ESP32C5, CHIP_FAMILY_ESP32C6, CHIP_FAMILY_ESP32C61, CHIP_FAMILY_ESP32H2, CHIP_FAMILY_ESP32H4, CHIP_FAMILY_ESP32H21, CHIP_FAMILY_ESP32P4, CHIP_FAMILY_ESP32S31, CHIP_FAMILY_ESP8266, MAX_TIMEOUT, DEFAULT_TIMEOUT, ERASE_REGION_TIMEOUT_PER_MB, ESP_CHANGE_BAUDRATE, ESP_CHECKSUM_MAGIC, ESP_FLASH_BEGIN, ESP_FLASH_DATA, ESP_FLASH_END, ESP_MEM_BEGIN, ESP_MEM_DATA, ESP_MEM_END, ESP_READ_REG, ESP_WRITE_REG, ESP_SPI_ATTACH, ESP_SYNC, ESP_GET_SECURITY_INFO, FLASH_SECTOR_SIZE, FLASH_WRITE_SIZE, STUB_FLASH_WRITE_SIZE, MEM_END_ROM_TIMEOUT, ROM_INVALID_RECV_MSG, SYNC_PACKET, SYNC_TIMEOUT, USB_RAM_BLOCK, ESP_ERASE_FLASH, ESP_ERASE_REGION, ESP_READ_FLASH, CHIP_ERASE_TIMEOUT, FLASH_READ_TIMEOUT, timeoutPerMb, ESP_ROM_BAUD, USB_JTAG_SERIAL_PID, ESP_FLASH_DEFL_BEGIN, ESP_FLASH_DEFL_DATA, ESP_FLASH_DEFL_END, getSpiFlashAddresses, DETECTED_FLASH_SIZES, CHIP_DETECT_MAGIC_REG_ADDR, CHIP_DETECT_MAGIC_VALUES, CHIP_ID_TO_INFO, ESP32_BASEFUSEADDR, ESP32_APB_CTL_DATE_ADDR, ESP32S2_EFUSE_BLOCK1_ADDR, ESP32S3_EFUSE_BLOCK1_ADDR, ESP32C2_EFUSE_BLOCK2_ADDR, ESP32C5_EFUSE_BLOCK1_ADDR, ESP32C6_EFUSE_BLOCK1_ADDR, ESP32C61_EFUSE_BLOCK1_ADDR, ESP32H2_EFUSE_BLOCK1_ADDR, ESP32P4_EFUSE_BLOCK1_ADDR, ESP32S31_EFUSE_BLOCK1_ADDR, SlipReadError, ESP32S2_RTC_CNTL_WDTWPROTECT_REG, ESP32S2_RTC_CNTL_WDTCONFIG0_REG, ESP32S2_RTC_CNTL_WDTCONFIG1_REG, ESP32S2_RTC_CNTL_WDT_WKEY, ESP32S2_RTC_CNTL_OPTION1_REG, ESP32S2_RTC_CNTL_FORCE_DOWNLOAD_BOOT_MASK, ESP32S3_RTC_CNTL_WDTWPROTECT_REG, ESP32S3_RTC_CNTL_WDTCONFIG0_REG, ESP32S3_RTC_CNTL_WDTCONFIG1_REG, ESP32S3_RTC_CNTL_WDT_WKEY, ESP32S3_RTC_CNTL_OPTION1_REG, ESP32S3_RTC_CNTL_FORCE_DOWNLOAD_BOOT_MASK, ESP32C3_EFUSE_RD_MAC_SPI_SYS_3_REG, ESP32C3_EFUSE_RD_MAC_SPI_SYS_5_REG, ESP32C5_UART_CLKDIV_REG, ESP32C5_PCR_SYSCLK_CONF_REG, ESP32C5_PCR_SYSCLK_XTAL_FREQ_V, ESP32C5_PCR_SYSCLK_XTAL_FREQ_S, ESP32P4_RTC_CNTL_WDTWPROTECT_REG, ESP32P4_RTC_CNTL_WDTCONFIG0_REG, ESP32P4_RTC_CNTL_WDTCONFIG1_REG, ESP32P4_RTC_CNTL_WDT_WKEY, ESP32P4_RTC_CNTL_OPTION1_REG, ESP32P4_RTC_CNTL_FORCE_DOWNLOAD_BOOT_MASK, ESP32P4_LP_SYSTEM_REG_ANA_XPD_PAD_GROUP_REG, ESP32P4_PMU_EXT_LDO_P0_0P1A_ANA_REG, ESP32P4_PMU_ANA_0P1A_EN_CUR_LIM_0, ESP32P4_PMU_EXT_LDO_P0_0P1A_REG, ESP32P4_PMU_0P1A_TARGET0_0, ESP32P4_PMU_0P1A_FORCE_TIEH_SEL_0, ESP32P4_PMU_DATE_REG, ESP32S2_UARTDEV_BUF_NO, ESP32S2_UARTDEV_BUF_NO_USB_OTG, ESP32S3_UARTDEV_BUF_NO, ESP32S3_UARTDEV_BUF_NO_USB_OTG, ESP32S3_UARTDEV_BUF_NO_USB_JTAG_SERIAL, ESP32C3_UARTDEV_BUF_NO_USB_JTAG_SERIAL, ESP32C3_BUF_UART_NO_OFFSET, ESP32C5_UARTDEV_BUF_NO, ESP32C5_UARTDEV_BUF_NO_USB_JTAG_SERIAL, ESP32C6_UARTDEV_BUF_NO, ESP32C6_UARTDEV_BUF_NO_USB_JTAG_SERIAL, ESP32C61_UARTDEV_BUF_NO_REV_LE2, ESP32C61_UARTDEV_BUF_NO_REV_GT2, ESP32C61_UARTDEV_BUF_NO_USB_JTAG_SERIAL_REV_LE2, ESP32C61_UARTDEV_BUF_NO_USB_JTAG_SERIAL_REV_GT2, ESP32H2_UARTDEV_BUF_NO, ESP32H2_UARTDEV_BUF_NO_USB_JTAG_SERIAL, ESP32H4_UARTDEV_BUF_NO, ESP32H4_UARTDEV_BUF_NO_USB_JTAG_SERIAL, ESP32P4_UARTDEV_BUF_NO_REV0, ESP32P4_UARTDEV_BUF_NO_REV300, ESP32P4_UARTDEV_BUF_NO_USB_OTG, ESP32P4_UARTDEV_BUF_NO_USB_JTAG_SERIAL, } from "./const";
 import { getStubCode } from "./stubs";
-import { hexFormatter, sleep, slipEncode, toHex } from "./util";
+import { hexFormatter, padTo, sleep, slipEncode, toHex } from "./util";
 import { deflate } from "pako";
 import { pack, unpack } from "./struct";
 export class ESPLoader extends EventTarget {
@@ -357,7 +357,13 @@ export class ESPLoader extends EventTarget {
         }
         catch (err) {
             this.logger.debug(`Could not detect USB connection type: ${err}`);
-            // Leave as undefined if detection fails
+        }
+        try {
+            const usbMode = await this.getUsbMode();
+            this.logger.debug(`USB mode (register): ${usbMode.mode} (uartNo=${usbMode.uartNo})`);
+        }
+        catch (err) {
+            this.logger.debug(`Could not detect USB mode: ${err}`);
         }
         // Read the OTP data for this chip and store into this.efuses array
         const FlAddr = getSpiFlashAddresses(this.getChipFamily());
@@ -365,7 +371,10 @@ export class ESPLoader extends EventTarget {
         for (let i = 0; i < 4; i++) {
             this._efuses[i] = await this.readRegister(AddrMAC + 4 * i);
         }
-        this.logger.log(`Chip type ${this.chipName}`);
+        const revisionInfo = this.chipRevision !== null && this.chipRevision !== undefined
+            ? ` (revision ${this.chipRevision})`
+            : "";
+        this.logger.log(`Connected to ${this.chipName}${revisionInfo}`);
         this.logger.debug(`Bootloader flash offset: 0x${FlAddr.flashOffs.toString(16)}`);
         // Mark initialization as successful
         this._initializationSucceeded = true;
@@ -382,22 +391,14 @@ export class ESPLoader extends EventTarget {
             if (chipInfo) {
                 this.chipName = chipInfo.name;
                 this.chipFamily = chipInfo.family;
-                // Get chip revision for ESP32-P4 and ESP32-C3
-                if (this.chipFamily === CHIP_FAMILY_ESP32P4) {
-                    this.chipRevision = await this.getChipRevision();
-                    this.logger.debug(`ESP32-P4 revision: ${this.chipRevision}`);
-                    // Set chip variant based on revision
-                    if (this.chipRevision >= 300) {
-                        this.chipVariant = "rev300";
-                    }
-                    else {
-                        this.chipVariant = "rev0";
-                    }
-                    this.logger.debug(`ESP32-P4 variant: ${this.chipVariant}`);
+                this.chipRevision = await this.getChipRevision();
+                this.logger.debug(`${this.chipName} revision: ${this.chipRevision}`);
+                if (this.chipFamily === CHIP_FAMILY_ESP32P4 &&
+                    this.chipRevision >= 300) {
+                    this.chipVariant = "rev300";
                 }
-                else if (this.chipFamily === CHIP_FAMILY_ESP32C3) {
-                    this.chipRevision = await this.getChipRevision();
-                    this.logger.debug(`ESP32-C3 revision: ${this.chipRevision}`);
+                else if (this.chipFamily === CHIP_FAMILY_ESP32P4) {
+                    this.chipVariant = "rev0";
                 }
                 this.logger.debug(`Detected chip via IMAGE_CHIP_ID: ${chipId} (${this.chipName})`);
                 return;
@@ -429,40 +430,109 @@ export class ESPLoader extends EventTarget {
         }
         this.chipName = chip.name;
         this.chipFamily = chip.family;
+        this.chipRevision = await this.getChipRevision();
+        this.logger.debug(`${this.chipName} revision: ${this.chipRevision}`);
         if (this.chipFamily === CHIP_FAMILY_ESP32P4) {
-            this.chipRevision = await this.getChipRevision();
-            if (this.chipRevision >= 300) {
-                this.chipVariant = "rev300";
-            }
-            else {
-                this.chipVariant = "rev0";
-            }
+            this.chipVariant = this.chipRevision >= 300 ? "rev300" : "rev0";
             this.logger.debug(`ESP32-P4 variant: ${this.chipVariant}`);
         }
-        else if (this.chipFamily === CHIP_FAMILY_ESP32C3) {
-            this.chipRevision = await this.getChipRevision();
-        }
         this.logger.debug(`Detected chip via magic value: ${toHex(chipMagicValue >>> 0, 8)} (${this.chipName})`);
     }
-    /**
-     * Get chip revision for ESP32-P4
-     */
     async getChipRevision() {
-        if (this.chipFamily === CHIP_FAMILY_ESP32P4) {
-            // Read from EFUSE_BLOCK1 to get chip revision
-            // Word 2 contains revision info for ESP32-P4
-            const word2 = await this.readRegister(ESP32P4_EFUSE_BLOCK1_ADDR + 8);
-            // Minor revision: bits [3:0]
-            const minorRev = word2 & 0x0f;
-            // Major revision: bits [23] << 2 | bits [5:4]
-            const majorRev = (((word2 >> 23) & 1) << 2) | ((word2 >> 4) & 0x03);
-            // Revision is major * 100 + minor
-            return majorRev * 100 + minorRev;
-        }
-        else if (this.chipFamily === CHIP_FAMILY_ESP32C3) {
-            return await this.getChipRevisionC3();
+        var _a;
+        let minor = 0;
+        let major = 0;
+        switch (this.chipFamily) {
+            case CHIP_FAMILY_ESP32: {
+                const efuse3 = await this.readRegister(ESP32_BASEFUSEADDR + 4 * 3);
+                const efuse5 = await this.readRegister(ESP32_BASEFUSEADDR + 4 * 5);
+                minor = (efuse5 >> 24) & 0x3;
+                const revBit0 = (efuse3 >> 15) & 0x1;
+                const revBit1 = (efuse5 >> 20) & 0x1;
+                const apb = await this.readRegister(ESP32_APB_CTL_DATE_ADDR);
+                const revBit2 = (apb >> 31) & 0x1;
+                const combined = (revBit2 << 2) | (revBit1 << 1) | revBit0;
+                major =
+                    (_a = { 0: 0, 1: 1, 3: 2, 7: 3 }[combined]) !== null && _a !== void 0 ? _a : 0;
+                break;
+            }
+            case CHIP_FAMILY_ESP32S2: {
+                const w3 = await this.readRegister(ESP32S2_EFUSE_BLOCK1_ADDR + 4 * 3);
+                const w4 = await this.readRegister(ESP32S2_EFUSE_BLOCK1_ADDR + 4 * 4);
+                const hi = (w3 >> 20) & 0x01;
+                const lo = (w4 >> 4) & 0x07;
+                minor = (hi << 3) + lo;
+                major = (w3 >> 18) & 0x03;
+                break;
+            }
+            case CHIP_FAMILY_ESP32S3: {
+                const w3 = await this.readRegister(ESP32S3_EFUSE_BLOCK1_ADDR + 4 * 3);
+                const w5 = await this.readRegister(ESP32S3_EFUSE_BLOCK1_ADDR + 4 * 5);
+                const hi = (w5 >> 23) & 0x01;
+                const lo = (w3 >> 18) & 0x07;
+                minor = (hi << 3) + lo;
+                major = (w5 >> 24) & 0x03;
+                break;
+            }
+            case CHIP_FAMILY_ESP32C2: {
+                const w1 = await this.readRegister(ESP32C2_EFUSE_BLOCK2_ADDR + 4 * 1);
+                minor = (w1 >> 16) & 0x0f;
+                major = (w1 >> 20) & 0x03;
+                break;
+            }
+            case CHIP_FAMILY_ESP32C3: {
+                const w3 = await this.readRegister(ESP32C3_EFUSE_RD_MAC_SPI_SYS_3_REG);
+                const w5 = await this.readRegister(ESP32C3_EFUSE_RD_MAC_SPI_SYS_5_REG);
+                const hi = (w5 >> 23) & 0x01;
+                const lo = (w3 >> 18) & 0x07;
+                minor = (hi << 3) + lo;
+                major = (w5 >> 24) & 0x03;
+                break;
+            }
+            case CHIP_FAMILY_ESP32C5: {
+                const w2 = await this.readRegister(ESP32C5_EFUSE_BLOCK1_ADDR + 4 * 2);
+                minor = w2 & 0x0f;
+                major = (w2 >> 4) & 0x03;
+                break;
+            }
+            case CHIP_FAMILY_ESP32C6: {
+                const w3 = await this.readRegister(ESP32C6_EFUSE_BLOCK1_ADDR + 4 * 3);
+                minor = (w3 >> 18) & 0x0f;
+                major = (w3 >> 22) & 0x03;
+                break;
+            }
+            case CHIP_FAMILY_ESP32C61: {
+                const w2 = await this.readRegister(ESP32C61_EFUSE_BLOCK1_ADDR + 4 * 2);
+                minor = w2 & 0x0f;
+                major = (w2 >> 4) & 0x03;
+                break;
+            }
+            case CHIP_FAMILY_ESP32H2: {
+                const w3 = await this.readRegister(ESP32H2_EFUSE_BLOCK1_ADDR + 4 * 3);
+                minor = (w3 >> 18) & 0x07;
+                major = (w3 >> 21) & 0x03;
+                break;
+            }
+            case CHIP_FAMILY_ESP32H4: {
+                break;
+            }
+            case CHIP_FAMILY_ESP32H21: {
+                break;
+            }
+            case CHIP_FAMILY_ESP32P4: {
+                const w2 = await this.readRegister(ESP32P4_EFUSE_BLOCK1_ADDR + 4 * 2);
+                minor = w2 & 0x0f;
+                major = (((w2 >> 23) & 1) << 2) | ((w2 >> 4) & 0x03);
+                break;
+            }
+            case CHIP_FAMILY_ESP32S31: {
+                const w2 = await this.readRegister(ESP32S31_EFUSE_BLOCK1_ADDR + 4 * 2);
+                minor = w2 & 0x0f;
+                major = (w2 >> 4) & 0x03;
+                break;
+            }
         }
-        return 0;
+        return major * 100 + minor;
     }
     /**
      * Power on the flash chip for ESP32-P4 Rev 301 (ECO6)
@@ -607,9 +677,6 @@ export class ESPLoader extends EventTarget {
         this._suppressDisconnect = false;
         this.logger.debug("Finished read loop");
     }
-    sleep(ms = 100) {
-        return new Promise((resolve) => setTimeout(resolve, ms));
-    }
     // ============================================================================
     // Web Serial (Desktop) - DTR/RTS Signal Handling & Reset Strategies
     // ============================================================================
@@ -633,10 +700,6 @@ export class ESPLoader extends EventTarget {
             requestToSend: rts,
         });
     }
-    /**
-     * Helper function to run a sequence of signal changes
-     * Automatically detects WebUSB vs Web Serial and calls appropriate methods
-     */
     async runSignalSequence(steps) {
         const webusb = this.port.isWebUSB === true;
         for (const step of steps) {
@@ -650,14 +713,20 @@ export class ESPLoader extends EventTarget {
             }
             else {
                 if (step.dtr !== undefined) {
-                    webusb
-                        ? await this.setDTRWebUSB(step.dtr)
-                        : await this.setDTR(step.dtr);
+                    if (webusb) {
+                        await this.setDTRWebUSB(step.dtr);
+                    }
+                    else {
+                        await this.setDTR(step.dtr);
+                    }
                 }
                 if (step.rts !== undefined) {
-                    webusb
-                        ? await this.setRTSWebUSB(step.rts)
-                        : await this.setRTS(step.rts);
+                    if (webusb) {
+                        await this.setRTSWebUSB(step.rts);
+                    }
+                    else {
+                        await this.setRTS(step.rts);
+                    }
                 }
             }
             if (step.delayMs)
@@ -1002,8 +1071,12 @@ export class ESPLoader extends EventTarget {
                     });
                 }
             }
-            // Add general fallback strategies only for non-CP2102 and non-ESP32-S2 Native USB chips
-            if (!isCP2102 && !isESP32S2NativeUSB) {
+            // Add general fallback strategies only for Native USB chips (not USB-Serial)
+            // and only for chips not already handled by specific blocks above
+            if (!isUSBSerialChip &&
+                !isCP2102 &&
+                !isESP32S2NativeUSB &&
+                !isUSBJTAGSerial) {
                 // Classic reset (for chips not handled above)
                 if (portInfo.usbVendorId !== 0x1a86) {
                     resetStrategies.push({
@@ -1035,7 +1108,7 @@ export class ESPLoader extends EventTarget {
                     },
                 });
                 // WebUSB Strategy: USB-JTAG/Serial fallback
-                if (!isUSBJTAGSerial && !isEspressifUSB) {
+                if (!isEspressifUSB) {
                     resetStrategies.push({
                         name: "USB-JTAG/Serial fallback (WebUSB)",
                         fn: async function () {
@@ -1110,10 +1183,10 @@ export class ESPLoader extends EventTarget {
                     try {
                         await Promise.race([syncPromise, timeoutPromise]);
                         // Sync succeeded
-                        this.logger.log(`Connected CDC/JTAG successfully with ${strategy.name} reset.`);
+                        this.logger.debug(`Connected CDC/JTAG successfully with ${strategy.name} reset.`);
                         return;
                     }
-                    catch (error) {
+                    catch {
                         throw new Error("Sync timeout or abandoned");
                     }
                 }
@@ -1144,35 +1217,19 @@ export class ESPLoader extends EventTarget {
     }
     /**
      * @name watchdogReset
-     * Watchdog reset for ESP32-S2/S3/C3 with USB-OTG or USB-JTAG/Serial
+     * Watchdog reset for ESP32-S2/S3/P4 with USB-OTG or USB-JTAG/Serial
      * Uses RTC watchdog timer to reset the chip - works when DTR/RTS signals are not available
      * This is an alias for rtcWdtResetChipSpecific() for backwards compatibility
+     * Note: ESP32-C3, ESP32-C5, ESP32-C6 do NOT boot correctly after WDT reset
      */
     async watchdogReset() {
         await this.rtcWdtResetChipSpecific();
     }
     /**
-     * Get chip revision for ESP32-C3
-     * Reads from EFUSE registers and calculates revision
-     */
-    async getChipRevisionC3() {
-        if (this.chipFamily !== CHIP_FAMILY_ESP32C3) {
-            return 0;
-        }
-        // Read EFUSE_RD_MAC_SPI_SYS_3_REG (bits [20:18] = lower 3 bits of revision)
-        const word3 = await this.readRegister(ESP32C3_EFUSE_RD_MAC_SPI_SYS_3_REG);
-        const low = (word3 >> 18) & 0x07;
-        // Read EFUSE_RD_MAC_SPI_SYS_5_REG (bits [25:23] = upper 3 bits of revision)
-        const word5 = await this.readRegister(ESP32C3_EFUSE_RD_MAC_SPI_SYS_5_REG);
-        const hi = (word5 >> 23) & 0x07;
-        // Combine: upper 3 bits from word5, lower 3 bits from word3
-        const revision = (hi << 3) | low;
-        return revision;
-    }
-    /**
-     * RTC watchdog timer reset for ESP32-S2, ESP32-S3, ESP32-C3, ESP32-C5, ESP32-C6, and ESP32-P4
+     * RTC watchdog timer reset for ESP32-S2, ESP32-S3, and ESP32-P4
      * Uses specific registers for each chip family
-     * Note: ESP32-H2 does NOT support WDT reset
+     * Note: ESP32-C3 does NOT boot correctly after WDT reset
+     * Note: ESP32-C5, ESP32-C6, ESP32-C61, ESP32-H2 do NOT support WDT reset (no usable RTC WDT path)
      */
     async rtcWdtResetChipSpecific() {
         this.logger.debug("Hard resetting with watchdog timer...");
@@ -1192,20 +1249,6 @@ export class ESPLoader extends EventTarget {
             WDTCONFIG1_REG = ESP32S3_RTC_CNTL_WDTCONFIG1_REG;
             WDT_WKEY = ESP32S3_RTC_CNTL_WDT_WKEY;
         }
-        else if (this.chipFamily === CHIP_FAMILY_ESP32C3) {
-            WDTWPROTECT_REG = ESP32C3_RTC_CNTL_WDTWPROTECT_REG;
-            WDTCONFIG0_REG = ESP32C3_RTC_CNTL_WDTCONFIG0_REG;
-            WDTCONFIG1_REG = ESP32C3_RTC_CNTL_WDTCONFIG1_REG;
-            WDT_WKEY = ESP32C3_RTC_CNTL_WDT_WKEY;
-        }
-        else if (this.chipFamily === CHIP_FAMILY_ESP32C5 ||
-            this.chipFamily === CHIP_FAMILY_ESP32C6) {
-            // C5 and C6 use LP_WDT (Low Power Watchdog Timer)
-            WDTWPROTECT_REG = ESP32C5_C6_RTC_CNTL_WDTWPROTECT_REG;
-            WDTCONFIG0_REG = ESP32C5_C6_RTC_CNTL_WDTCONFIG0_REG;
-            WDTCONFIG1_REG = ESP32C5_C6_RTC_CNTL_WDTCONFIG1_REG;
-            WDT_WKEY = ESP32C5_C6_RTC_CNTL_WDT_WKEY;
-        }
         else if (this.chipFamily === CHIP_FAMILY_ESP32P4) {
             // P4 uses LP_WDT (Low Power Watchdog Timer)
             WDTWPROTECT_REG = ESP32P4_RTC_CNTL_WDTWPROTECT_REG;
@@ -1226,26 +1269,113 @@ export class ESPLoader extends EventTarget {
         // Lock watchdog registers
         await this.writeRegister(WDTWPROTECT_REG, 0, undefined, 0);
         // Wait for reset to take effect
-        await this.sleep(500);
+        await sleep(500);
     }
     /**
-     * Helper: USB-based WDT reset
-     * Returns true if WDT reset was performed, false otherwise
+     * Reset device from bootloader mode to firmware mode
+     * Automatically selects the correct reset strategy based on USB connection type
+     * @param clearForceDownloadFlag - If true, clears the force download boot flag (USB-OTG only)
+     * @returns true if port will change (USB-OTG), false otherwise
      */
-    async tryUsbWdtReset(chipName) {
-        const isUsingUsbOtg = await this.detectUsbConnectionType();
-        if (isUsingUsbOtg) {
-            // Use WDT reset for USB-OTG devices
-            await this.rtcWdtResetChipSpecific();
-            this.logger.debug(`${chipName}: RTC WDT reset (USB-JTAG/Serial or USB-OTG detected)`);
-            return true;
+    async resetToFirmwareMode(clearForceDownloadFlag = true) {
+        this.logger.debug("Resetting from bootloader to firmware mode...");
+        try {
+            // Detect USB connection type
+            const isUsbJtagOrOtg = await this.detectUsbConnectionType();
+            if (isUsbJtagOrOtg) {
+                // USB-JTAG/OTG devices need special handling
+                this.logger.debug("USB-JTAG/OTG detected - checking WDT reset support");
+                // Get detailed USB mode information
+                let usbMode;
+                try {
+                    usbMode = await this.getUsbMode();
+                    this.logger.debug(`USB mode: ${usbMode.mode} (uartNo=${usbMode.uartNo})`);
+                }
+                catch (err) {
+                    this.logger.debug(`Could not get USB mode: ${err}`);
+                    // Fall back to generic USB-JTAG/OTG handling
+                    usbMode = { mode: "usb-jtag-serial", uartNo: 0 };
+                }
+                // WDT reset is not needed for ESP32-C3
+                // WDT reset is supported by: ESP32-S2, ESP32-S3, ESP32-P4
+                // WDT reset is NOT supported by: ESP32-C5, ESP32-C6, ESP32-C61, ESP32-H2
+                const supportsWdtReset = this.chipFamily === CHIP_FAMILY_ESP32S2 ||
+                    this.chipFamily === CHIP_FAMILY_ESP32S3 ||
+                    this.chipFamily === CHIP_FAMILY_ESP32P4;
+                if (!supportsWdtReset) {
+                    this.logger.debug(`${this.chipName} does not support WDT reset - using classic reset instead`);
+                    // Use classic reset for chips without WDT support
+                    await this.hardResetToFirmware();
+                    this.logger.debug("Classic reset to firmware complete");
+                    return false; // Port stays open
+                }
+                // WDT reset is supported - proceed with WDT reset logic
+                this.logger.debug(`${this.chipName} supports WDT reset - using WDT reset strategy`);
+                // CRITICAL: WDT register writes require ROM (not stub) and baudrate 115200
+                // If on stub, need to return to ROM first
+                if (this.IS_STUB) {
+                    this.logger.debug("On stub - returning to ROM before WDT reset");
+                    // Change baudrate back to ROM baudrate if needed
+                    if (this.currentBaudRate !== ESP_ROM_BAUD) {
+                        this.logger.debug(`Changing baudrate from ${this.currentBaudRate} to ${ESP_ROM_BAUD}`);
+                        await this.reconfigurePort(ESP_ROM_BAUD);
+                        this.currentBaudRate = ESP_ROM_BAUD;
+                        this.logger.debug("Baudrate changed to 115200");
+                    }
+                    // CRITICAL: Temporarily clear console mode flag so hardReset(true) works
+                    const wasInConsoleMode = this._consoleMode;
+                    this._consoleMode = false;
+                    // Reset to bootloader (ROM)
+                    await this.hardReset(true);
+                    await sleep(200);
+                    // Restore console mode flag
+                    this._consoleMode = wasInConsoleMode;
+                    // Sync with ROM
+                    await this.sync();
+                    this.IS_STUB = false;
+                    this.logger.debug("Now on ROM");
+                }
+                else {
+                    // Even if not on stub, ensure baudrate is 115200 for WDT register writes
+                    if (this.currentBaudRate !== ESP_ROM_BAUD) {
+                        this.logger.debug(`Not on stub, but baudrate is ${this.currentBaudRate} - changing to ${ESP_ROM_BAUD} for WDT reset`);
+                        await this.reconfigurePort(ESP_ROM_BAUD);
+                        this.currentBaudRate = ESP_ROM_BAUD;
+                        this.logger.debug("Baudrate changed to 115200");
+                    }
+                }
+                // Clear force download boot flag if requested (USB-OTG only)
+                if (clearForceDownloadFlag && usbMode.mode === "usb-otg") {
+                    const flagCleared = await this._clearForceDownloadBootIfNeeded();
+                    if (flagCleared) {
+                        this.logger.debug("Force download boot flag cleared");
+                    }
+                }
+                // Perform WDT reset to boot into firmware
+                await this.rtcWdtResetChipSpecific();
+                this.logger.debug("WDT reset performed - device will boot to firmware");
+                // Check if port will change after WDT reset
+                // USB-OTG (ESP32-S2/P4): Port always changes
+                // USB-JTAG/Serial (ESP32-S3/C3/C5/C6/C61/H2/P4): Port may change depending on platform
+                const portWillChange = usbMode.mode === "usb-otg" || usbMode.mode === "usb-jtag-serial";
+                if (portWillChange) {
+                    this.logger.debug(`Port will change after WDT reset (${usbMode.mode}) - port reselection needed`);
+                    return true;
+                }
+                return false;
+            }
+            else {
+                // External serial chip - use classic reset to firmware
+                this.logger.debug("External serial chip detected - using classic reset");
+                await this.hardResetToFirmware();
+                this.logger.debug("Classic reset to firmware complete");
+                return false;
+            }
         }
-        else {
-            // Use classic reset for non-USB devices
-            await this.hardResetClassic();
-            this.logger.debug("Classic reset.");
+        catch (err) {
+            this.logger.error(`Failed to reset to firmware mode: ${err}`);
+            throw err;
         }
-        return false;
     }
     async hardReset(bootloader = false) {
         // In console mode, only allow simple hardware reset (no bootloader entry)
@@ -1256,66 +1386,87 @@ export class ESPLoader extends EventTarget {
             }
             // Simple hardware reset to restart firmware (IO0=HIGH)
             this.logger.debug("Performing hardware reset (console mode)...");
-            await this.hardResetToFirmware();
+            await this.resetInConsoleMode();
             this.logger.debug("Hardware reset complete");
             return;
         }
         if (bootloader) {
-            // enter flash mode
+            // Enter bootloader/flash mode
             if (this.port.getInfo().usbProductId === USB_JTAG_SERIAL_PID) {
                 await this.hardResetUSBJTAGSerial();
-                this.logger.debug("USB-JTAG/Serial reset.");
+                this.logger.debug("USB-JTAG/Serial reset to bootloader.");
             }
             else {
                 await this.hardResetClassic();
-                this.logger.debug("Classic reset.");
+                this.logger.debug("Classic reset to bootloader.");
             }
         }
         else {
-            // just reset (no bootloader mode)
-            // For ESP32-S2/S3/P4 with USB-OTG or USB-JTAG/Serial, check if watchdog reset is needed
-            this.logger.debug("*** Performing WDT reset strategy ***");
-            if (this.chipFamily === CHIP_FAMILY_ESP32S2) {
-                const wdtResetUsed = await this.tryUsbWdtReset("ESP32-S2");
-                if (wdtResetUsed)
-                    return;
-                //      } else if (this.chipFamily === CHIP_FAMILY_ESP32S3) {
-                //        const wdtResetUsed = await this.tryUsbWdtReset("ESP32-S3");
-                //        if (wdtResetUsed) return;
-            }
-            else if (this.chipFamily === CHIP_FAMILY_ESP32P4) {
-                const wdtResetUsed = await this.tryUsbWdtReset("ESP32-P4");
-                if (wdtResetUsed)
-                    return;
-                //      } else if (this.chipFamily === CHIP_FAMILY_ESP32C3) {
-                //        const wdtResetUsed = await this.tryUsbWdtReset("ESP32-C3");
-                //        if (wdtResetUsed) return;
-            }
-            else if (this.chipFamily === CHIP_FAMILY_ESP32C5) {
-                const wdtResetUsed = await this.tryUsbWdtReset("ESP32-C5");
-                if (wdtResetUsed)
+            // Reset to firmware mode (exit bootloader)
+            // Use intelligent reset strategy based on USB connection type
+            this.logger.debug("Resetting to firmware mode...");
+            // Detect USB connection type to choose correct reset method
+            const isUsbJtagOrOtg = await this.detectUsbConnectionType();
+            if (isUsbJtagOrOtg) {
+                // USB-JTAG/OTG devices: Check if chip supports WDT reset
+                // Only S2, S3, P4 support WDT reset correctly
+                // C3, C5, C6, C61, H2 do NOT boot correctly after WDT reset
+                const supportsWdtReset = this.chipFamily === CHIP_FAMILY_ESP32S2 ||
+                    this.chipFamily === CHIP_FAMILY_ESP32S3 ||
+                    this.chipFamily === CHIP_FAMILY_ESP32P4;
+                if (supportsWdtReset) {
+                    this.logger.debug("USB-JTAG/OTG detected - using WDT reset");
+                    // Get USB mode details
+                    let usbMode;
+                    try {
+                        usbMode = await this.getUsbMode();
+                        this.logger.debug(`USB mode: ${usbMode.mode} (uartNo=${usbMode.uartNo})`);
+                    }
+                    catch (err) {
+                        this.logger.debug(`Could not get USB mode: ${err}`);
+                        usbMode = { mode: "usb-jtag-serial", uartNo: 0 };
+                    }
+                    // Clear force download flag for USB-OTG devices
+                    if (usbMode.mode === "usb-otg") {
+                        try {
+                            const flagCleared = await this._clearForceDownloadBootIfNeeded();
+                            if (flagCleared) {
+                                this.logger.debug("Force download boot flag cleared");
+                            }
+                        }
+                        catch (err) {
+                            this.logger.debug(`Could not clear force download flag: ${err}`);
+                        }
+                    }
+                    // Perform WDT reset
+                    await this.rtcWdtResetChipSpecific();
+                    this.logger.debug(`${this.chipName}: WDT reset to firmware complete`);
                     return;
+                }
+                else {
+                    // C3, C5, C6, etc. - use classic reset (like external serial chips)
+                    this.logger.debug(`${this.chipName} does not support WDT reset - using classic reset instead`);
+                }
             }
-            else if (this.chipFamily === CHIP_FAMILY_ESP32C6) {
-                const wdtResetUsed = await this.tryUsbWdtReset("ESP32-C6");
-                if (wdtResetUsed)
-                    return;
+            else {
+                // External serial chip: Use classic reset
+                this.logger.debug("External serial chip detected - using classic reset");
             }
-            // Standard reset for all other cases
+            // Classic reset: used for external serial chips and USB-JTAG chips that do not support WDT reset
             if (this.isWebUSB()) {
                 // WebUSB: Use longer delays for better compatibility
                 await this.setRTSWebUSB(true); // EN->LOW
-                await this.sleep(200);
+                await sleep(200);
                 await this.setRTSWebUSB(false);
-                await this.sleep(200);
-                this.logger.debug("Hard reset (WebUSB).");
+                await sleep(200);
+                this.logger.debug("Hard reset to firmware (WebUSB).");
             }
             else {
                 // Web Serial: Standard reset
                 await this.setRTS(true); // EN->LOW
-                await this.sleep(100);
+                await sleep(100);
                 await this.setRTS(false);
-                this.logger.debug("Hard reset.");
+                this.logger.debug("Hard reset to firmware.");
             }
         }
         await new Promise((resolve) => setTimeout(resolve, 1000));
@@ -1715,28 +1866,6 @@ export class ESPLoader extends EventTarget {
             return 40;
         return 26;
     }
-    async setBaudrateC5Rom(baud) {
-        const crystalFreqRomExpect = await this.getC5CrystalFreqRomExpect();
-        const crystalFreqDetect = await this.getC5CrystalFreqDetected();
-        this.logger.log(`ROM expects crystal freq: ${crystalFreqRomExpect} MHz, detected ${crystalFreqDetect} MHz.`);
-        let baudRate = baud;
-        if (crystalFreqDetect === 48 && crystalFreqRomExpect === 40) {
-            baudRate = Math.trunc((baud * 40) / 48);
-        }
-        else if (crystalFreqDetect === 40 && crystalFreqRomExpect === 48) {
-            baudRate = Math.trunc((baud * 48) / 40);
-        }
-        this.logger.log(`Changing baud rate to ${baudRate}...`);
-        try {
-            const buffer = pack("<II", baudRate, 0);
-            await this.checkCommand(ESP_CHANGE_BAUDRATE, buffer);
-        }
-        catch (e) {
-            this.logger.error(`Baudrate change error: ${e}`);
-            throw new Error(`Unable to change the baud rate to ${baudRate}: No response from set baud rate command.`);
-        }
-        this.logger.log("Changed.");
-    }
     async setBaudrate(baud) {
         const chipFamily = this._parent ? this._parent.chipFamily : this.chipFamily;
         if (!this.IS_STUB && chipFamily === CHIP_FAMILY_ESP32C5) {
@@ -1744,7 +1873,6 @@ export class ESPLoader extends EventTarget {
         }
         else {
             try {
-                // Send ESP_ROM_BAUD(115200) as the old one if running STUB otherwise 0
                 const buffer = pack("<II", baud, this.IS_STUB ? ESP_ROM_BAUD : 0);
                 await this.checkCommand(ESP_CHANGE_BAUDRATE, buffer);
             }
@@ -1776,7 +1904,29 @@ export class ESPLoader extends EventTarget {
             this.logger.log(`⚠️  WARNING: Baudrate ${baud} exceeds USB-Serial chip limit (${maxBaud})!`);
             this.logger.log(`⚠️  This may cause data corruption or connection failures!`);
         }
-        this.logger.log(`Changed baud rate to ${baud}`);
+        this.logger.debug(`Changed baud rate to ${baud}`);
+    }
+    async setBaudrateC5Rom(baud) {
+        const crystalFreqRomExpect = await this.getC5CrystalFreqRomExpect();
+        const crystalFreqDetect = await this.getC5CrystalFreqDetected();
+        this.logger.log(`ROM expects crystal freq: ${crystalFreqRomExpect} MHz, detected ${crystalFreqDetect} MHz.`);
+        let baudRate = baud;
+        if (crystalFreqDetect === 48 && crystalFreqRomExpect === 40) {
+            baudRate = Math.trunc((baud * 40) / 48);
+        }
+        else if (crystalFreqDetect === 40 && crystalFreqRomExpect === 48) {
+            baudRate = Math.trunc((baud * 48) / 40);
+        }
+        this.logger.log(`Changing baud rate to ${baudRate}...`);
+        try {
+            const buffer = pack("<II", baudRate, 0);
+            await this.checkCommand(ESP_CHANGE_BAUDRATE, buffer);
+        }
+        catch (e) {
+            this.logger.error(`Baudrate change error: ${e}`);
+            throw new Error(`Unable to change the baud rate to ${baudRate}: No response from set baud rate command.`);
+        }
+        this.logger.log("Changed.");
     }
     async reconfigurePort(baud) {
         var _a;
@@ -1837,9 +1987,9 @@ export class ESPLoader extends EventTarget {
             // Restart Readloop
             this.readLoop();
         }
-        catch (e) {
-            //      this.logger.error(`Reconfigure port error: ${e}`);
-            //      throw new Error(`Unable to change the baud rate to ${baud}: ${e}`);
+        catch {
+            //      this.logger.error(`Reconfigure port error`);
+            //      throw new Error(`Unable to change the baud rate to ${baud}`);
         }
         finally {
             // Always reset flag, even on error or early return
@@ -1946,6 +2096,8 @@ export class ESPLoader extends EventTarget {
             const headerFlashSizeFreq = header[3];
             this.logger.log(`Image header, Magic=${toHex(headerMagic)}, FlashMode=${toHex(headerFlashMode)}, FlashSizeFreq=${toHex(headerFlashSizeFreq)}`);
         }
+        const paddedData = padTo(new Uint8Array(binaryData), 4);
+        binaryData = paddedData.buffer;
         const uncompressedFilesize = binaryData.byteLength;
         let compressedFilesize = 0;
         let dataToFlash;
@@ -2242,13 +2394,9 @@ export class ESPLoader extends EventTarget {
         return status;
     }
     async detectFlashSize() {
-        this.logger.log("Detecting Flash Size");
+        this.logger.debug("Detecting Flash Size");
         const flashId = await this.flashId();
-        const manufacturer = flashId & 0xff;
         const flashIdLowbyte = (flashId >> 16) & 0xff;
-        this.logger.log(`FlashId: ${toHex(flashId)}`);
-        this.logger.log(`Flash Manufacturer: ${manufacturer.toString(16)}`);
-        this.logger.log(`Flash Device: ${((flashId >> 8) & 0xff).toString(16)}${flashIdLowbyte.toString(16)}`);
         this.flashSize = DETECTED_FLASH_SIZES[flashIdLowbyte];
         this.logger.log(`Auto-detected Flash size: ${this.flashSize}`);
     }
@@ -2310,7 +2458,7 @@ export class ESPLoader extends EventTarget {
         // We're transferring over USB, right?
         const ramBlock = USB_RAM_BLOCK;
         // Upload
-        this.logger.log("Uploading stub...");
+        this.logger.debug("Uploading stub...");
         for (const field of ["text", "data"]) {
             const fieldData = stub[field];
             const offset = stub[`${field}_start`];
@@ -2332,7 +2480,7 @@ export class ESPLoader extends EventTarget {
         if (pChar != "OHAI") {
             throw new Error("Failed to start stub. Unexpected response: " + pChar);
         }
-        this.logger.log("Stub is now running...");
+        this.logger.debug("Stub is now running...");
         const espStubLoader = new EspStubLoader(this.port, this.logger, this);
         // Try to autodetect the flash size.
         if (!skipFlashDetection) {
@@ -2436,81 +2584,6 @@ export class ESPLoader extends EventTarget {
         // Always await the write chain to ensure errors are caught
         await this._writeChain;
     }
-    async getUsbMode() {
-        var _a, _b;
-        const family = this._parent ? this._parent.chipFamily : this.chipFamily;
-        const revision = this._parent
-            ? ((_a = this._parent.chipRevision) !== null && _a !== void 0 ? _a : 0)
-            : ((_b = this.chipRevision) !== null && _b !== void 0 ? _b : 0);
-        let bufNoAddr = null;
-        let jtagSerialVal = null;
-        let otgVal = null;
-        switch (family) {
-            case CHIP_FAMILY_ESP32S2:
-                bufNoAddr = ESP32S2_UARTDEV_BUF_NO;
-                otgVal = ESP32S2_UARTDEV_BUF_NO_USB_OTG;
-                break;
-            case CHIP_FAMILY_ESP32S3:
-                bufNoAddr = ESP32S3_UARTDEV_BUF_NO;
-                jtagSerialVal = ESP32S3_UARTDEV_BUF_NO_USB_JTAG_SERIAL;
-                otgVal = ESP32S3_UARTDEV_BUF_NO_USB_OTG;
-                break;
-            case CHIP_FAMILY_ESP32C3: {
-                const bssAddr = revision < 101 ? 0x3fcdf064 : 0x3fcdf060;
-                bufNoAddr = bssAddr + ESP32C3_BUF_UART_NO_OFFSET;
-                jtagSerialVal = ESP32C3_UARTDEV_BUF_NO_USB_JTAG_SERIAL;
-                break;
-            }
-            case CHIP_FAMILY_ESP32C5:
-                bufNoAddr = ESP32C5_UARTDEV_BUF_NO;
-                jtagSerialVal = ESP32C5_UARTDEV_BUF_NO_USB_JTAG_SERIAL;
-                break;
-            case CHIP_FAMILY_ESP32C6:
-                bufNoAddr = ESP32C6_UARTDEV_BUF_NO;
-                jtagSerialVal = ESP32C6_UARTDEV_BUF_NO_USB_JTAG_SERIAL;
-                break;
-            case CHIP_FAMILY_ESP32C61:
-                bufNoAddr =
-                    revision <= 200
-                        ? ESP32C61_UARTDEV_BUF_NO_REV_LE2
-                        : ESP32C61_UARTDEV_BUF_NO_REV_GT2;
-                jtagSerialVal =
-                    revision <= 200
-                        ? ESP32C61_UARTDEV_BUF_NO_USB_JTAG_SERIAL_REV_LE2
-                        : ESP32C61_UARTDEV_BUF_NO_USB_JTAG_SERIAL_REV_GT2;
-                break;
-            case CHIP_FAMILY_ESP32H2:
-                bufNoAddr = ESP32H2_UARTDEV_BUF_NO;
-                jtagSerialVal = ESP32H2_UARTDEV_BUF_NO_USB_JTAG_SERIAL;
-                break;
-            case CHIP_FAMILY_ESP32H4:
-                bufNoAddr = ESP32H4_UARTDEV_BUF_NO;
-                jtagSerialVal = ESP32H4_UARTDEV_BUF_NO_USB_JTAG_SERIAL;
-                break;
-            case CHIP_FAMILY_ESP32P4:
-                bufNoAddr =
-                    revision < 300
-                        ? ESP32P4_UARTDEV_BUF_NO_REV0
-                        : ESP32P4_UARTDEV_BUF_NO_REV300;
-                jtagSerialVal = ESP32P4_UARTDEV_BUF_NO_USB_JTAG_SERIAL;
-                otgVal = ESP32P4_UARTDEV_BUF_NO_USB_OTG;
-                break;
-        }
-        if (bufNoAddr === null) {
-            return { mode: "uart", uartNo: 0 };
-        }
-        const uartNo = (await this.readRegister(bufNoAddr)) & 0xff;
-        if (otgVal !== null && uartNo === otgVal) {
-            this.logger.debug(`USB mode: USB-OTG (uartNo=${uartNo})`);
-            return { mode: "usb-otg", uartNo };
-        }
-        if (jtagSerialVal !== null && uartNo === jtagSerialVal) {
-            this.logger.debug(`USB mode: USB-JTAG/Serial (uartNo=${uartNo})`);
-            return { mode: "usb-jtag-serial", uartNo };
-        }
-        this.logger.debug(`USB mode: UART (uartNo=${uartNo})`);
-        return { mode: "uart", uartNo };
-    }
     async disconnect() {
         if (this._parent) {
             await this._parent.disconnect();
@@ -2524,8 +2597,8 @@ export class ESPLoader extends EventTarget {
         try {
             await this._writeChain;
         }
-        catch (err) {
-            //      this.logger.debug(`Pending write error during disconnect: ${err}`);
+        catch {
+            //      this.logger.debug("Pending write error during disconnect");
         }
         // Release persistent writer before closing
         if (this._writer) {
@@ -2533,8 +2606,8 @@ export class ESPLoader extends EventTarget {
                 await this._writer.close();
                 this._writer.releaseLock();
             }
-            catch (err) {
-                //        this.logger.debug(`Writer close/release error: ${err}`);
+            catch {
+                //        this.logger.debug("Writer close/release error");
             }
             this._writer = undefined;
         }
@@ -2546,8 +2619,8 @@ export class ESPLoader extends EventTarget {
                 await writer.close();
                 writer.releaseLock();
             }
-            catch (err) {
-                //        this.logger.debug(`Direct writer close error: ${err}`);
+            catch {
+                //        this.logger.debug("Direct writer close error");
             }
         }
         await new Promise((resolve) => {
@@ -2568,7 +2641,7 @@ export class ESPLoader extends EventTarget {
             try {
                 this._reader.cancel();
             }
-            catch (err) {
+            catch {
                 // Reader already released, resolve immediately
                 clearTimeout(timeout);
                 resolve(undefined);
@@ -2598,8 +2671,8 @@ export class ESPLoader extends EventTarget {
         try {
             await this._writeChain;
         }
-        catch (err) {
-            //      this.logger.debug(`Pending write error during release: ${err}`);
+        catch {
+            //      this.logger.debug("Pending write error during release");
         }
         // Release writer
         if (this._writer) {
@@ -2612,29 +2685,25 @@ export class ESPLoader extends EventTarget {
             }
             this._writer = undefined;
         }
-        // Cancel and release reader
+        // Cancel reader - let readLoop's finally block handle releaseLock()
         if (this._reader) {
-            const reader = this._reader;
             try {
                 // Suppress disconnect event during console mode switching
                 this._suppressDisconnect = true;
-                await reader.cancel();
-                this.logger.debug("Reader cancelled");
+                // Cancel will cause readLoop to exit and call releaseLock() in its finally block
+                await this._reader.cancel();
+                this.logger.debug("Reader cancelled - waiting for readLoop to finish");
+                // CRITICAL: Wait a bit for readLoop's finally block to complete
+                // The finally block needs time to call releaseLock() and set _reader = undefined
+                // This is much faster than waiting for browser to unlock (just waiting for JS execution)
+                await sleep(50);
+                this.logger.debug("ReadLoop cleanup should be complete");
             }
             catch (err) {
                 this.logger.debug(`Reader cancel error: ${err}`);
             }
-            finally {
-                try {
-                    reader.releaseLock();
-                }
-                catch (err) {
-                    this.logger.debug(`Reader release error: ${err}`);
-                }
-            }
-            if (this._reader === reader) {
-                this._reader = undefined;
-            }
+            // Don't call releaseLock() or set _reader to undefined here
+            // Let readLoop's finally block handle it to avoid race conditions
         }
     }
     /**
@@ -2673,6 +2742,141 @@ export class ESPLoader extends EventTarget {
         this.logger.debug(`USB-JTAG/OTG detection: ${isUsbJtag ? "YES" : "NO"} (PID=0x${pid === null || pid === void 0 ? void 0 : pid.toString(16)})`);
         return isUsbJtag;
     }
+    async getUsbMode() {
+        var _a, _b;
+        const family = this._parent ? this._parent.chipFamily : this.chipFamily;
+        const revision = this._parent
+            ? ((_a = this._parent.chipRevision) !== null && _a !== void 0 ? _a : 0)
+            : ((_b = this.chipRevision) !== null && _b !== void 0 ? _b : 0);
+        let bufNoAddr = null;
+        let jtagSerialVal = null;
+        let otgVal = null;
+        switch (family) {
+            case CHIP_FAMILY_ESP32S2:
+                bufNoAddr = ESP32S2_UARTDEV_BUF_NO;
+                otgVal = ESP32S2_UARTDEV_BUF_NO_USB_OTG;
+                break;
+            case CHIP_FAMILY_ESP32S3:
+                bufNoAddr = ESP32S3_UARTDEV_BUF_NO;
+                jtagSerialVal = ESP32S3_UARTDEV_BUF_NO_USB_JTAG_SERIAL;
+                otgVal = ESP32S3_UARTDEV_BUF_NO_USB_OTG;
+                break;
+            case CHIP_FAMILY_ESP32C3: {
+                const bssAddr = revision < 101 ? 0x3fcdf064 : 0x3fcdf060;
+                bufNoAddr = bssAddr + ESP32C3_BUF_UART_NO_OFFSET;
+                jtagSerialVal = ESP32C3_UARTDEV_BUF_NO_USB_JTAG_SERIAL;
+                break;
+            }
+            case CHIP_FAMILY_ESP32C5:
+                bufNoAddr = ESP32C5_UARTDEV_BUF_NO;
+                jtagSerialVal = ESP32C5_UARTDEV_BUF_NO_USB_JTAG_SERIAL;
+                break;
+            case CHIP_FAMILY_ESP32C6:
+                bufNoAddr = ESP32C6_UARTDEV_BUF_NO;
+                jtagSerialVal = ESP32C6_UARTDEV_BUF_NO_USB_JTAG_SERIAL;
+                break;
+            case CHIP_FAMILY_ESP32C61:
+                bufNoAddr =
+                    revision <= 200
+                        ? ESP32C61_UARTDEV_BUF_NO_REV_LE2
+                        : ESP32C61_UARTDEV_BUF_NO_REV_GT2;
+                jtagSerialVal =
+                    revision <= 200
+                        ? ESP32C61_UARTDEV_BUF_NO_USB_JTAG_SERIAL_REV_LE2
+                        : ESP32C61_UARTDEV_BUF_NO_USB_JTAG_SERIAL_REV_GT2;
+                break;
+            case CHIP_FAMILY_ESP32H2:
+                bufNoAddr = ESP32H2_UARTDEV_BUF_NO;
+                jtagSerialVal = ESP32H2_UARTDEV_BUF_NO_USB_JTAG_SERIAL;
+                break;
+            case CHIP_FAMILY_ESP32H4:
+                bufNoAddr = ESP32H4_UARTDEV_BUF_NO;
+                jtagSerialVal = ESP32H4_UARTDEV_BUF_NO_USB_JTAG_SERIAL;
+                break;
+            case CHIP_FAMILY_ESP32P4:
+                bufNoAddr =
+                    revision < 300
+                        ? ESP32P4_UARTDEV_BUF_NO_REV0
+                        : ESP32P4_UARTDEV_BUF_NO_REV300;
+                jtagSerialVal = ESP32P4_UARTDEV_BUF_NO_USB_JTAG_SERIAL;
+                otgVal = ESP32P4_UARTDEV_BUF_NO_USB_OTG;
+                break;
+        }
+        if (bufNoAddr === null) {
+            return { mode: "uart", uartNo: 0 };
+        }
+        const uartNo = (await this.readRegister(bufNoAddr)) & 0xff;
+        if (otgVal !== null && uartNo === otgVal) {
+            this.logger.debug(`USB mode: USB-OTG (uartNo=${uartNo})`);
+            return { mode: "usb-otg", uartNo };
+        }
+        if (jtagSerialVal !== null && uartNo === jtagSerialVal) {
+            this.logger.debug(`USB mode: USB-JTAG/Serial (uartNo=${uartNo})`);
+            return { mode: "usb-jtag-serial", uartNo };
+        }
+        this.logger.debug(`USB mode: UART (uartNo=${uartNo})`);
+        return { mode: "uart", uartNo };
+    }
+    /**
+     * Check if the current chip supports USB-JTAG or USB-OTG
+     * @returns true if chip has native USB support (JTAG or OTG)
+     */
+    supportsNativeUsb() {
+        const family = this._parent ? this._parent.chipFamily : this.chipFamily;
+        // Chips with USB-JTAG/Serial or USB-OTG support
+        const usbChips = [
+            CHIP_FAMILY_ESP32S2, // USB-OTG
+            CHIP_FAMILY_ESP32S3, // USB-OTG + USB-JTAG/Serial
+            CHIP_FAMILY_ESP32C3, // USB-JTAG/Serial
+            CHIP_FAMILY_ESP32C5, // USB-JTAG/Serial
+            CHIP_FAMILY_ESP32C6, // USB-JTAG/Serial
+            CHIP_FAMILY_ESP32C61, // USB-JTAG/Serial
+            CHIP_FAMILY_ESP32H2, // USB-JTAG/Serial
+            CHIP_FAMILY_ESP32H4, // USB-JTAG/Serial
+            CHIP_FAMILY_ESP32P4, // USB-OTG + USB-JTAG/Serial
+        ];
+        return usbChips.includes(family);
+    }
+    /**
+     * @name _ensureStreamsReady
+     * After a hardware reset, ensure port streams are available.
+     * On WebUSB, recreates streams since they break after reset.
+     * On Web Serial, waits for streams to become available.
+     */
+    async _ensureStreamsReady() {
+        if (this.isWebUSB()) {
+            try {
+                await this.port.recreateStreams();
+                this.logger.debug("WebUSB streams recreated");
+                let retries = 30;
+                while (retries > 0 && !this.port.readable) {
+                    await sleep(100);
+                    retries--;
+                }
+                if (!this.port.readable) {
+                    throw new Error("Readable stream not available after recreating streams");
+                }
+                this.logger.debug("WebUSB streams are ready");
+            }
+            catch (err) {
+                this.logger.error(`Failed to recreate WebUSB streams: ${err}`);
+                this._consoleMode = false;
+                throw err;
+            }
+        }
+        else {
+            let retries = 20;
+            while (retries > 0 && !this.port.readable) {
+                await sleep(100);
+                retries--;
+            }
+            if (!this.port.readable) {
+                this._consoleMode = false;
+                throw new Error("Readable stream not available after reset");
+            }
+            this.logger.debug("Port streams are ready");
+        }
+    }
     /**
      * @name enterConsoleMode
      * Prepare device for console mode by resetting to firmware
@@ -2700,60 +2904,41 @@ export class ESPLoader extends EventTarget {
             if (this.isUsbJtagOrOtg === undefined) {
                 throw new Error(`Cannot enter console mode: USB connection type unknown and detection failed: ${err}`);
             }
-            // Set console mode flag
-            this._consoleMode = false;
             this.logger.debug(`USB detection failed, using cached value: ${this.isUsbJtagOrOtg}`);
             isUsbJtag = this.isUsbJtagOrOtg;
         }
-        // Release reader/writer so console can create new ones
-        // This is needed for Desktop (Web Serial) to unlock streams
+        // Set console mode flag BEFORE any operations
+        this._consoleMode = true;
         if (isUsbJtag) {
-            // USB-JTAG/OTG devices: Use watchdog reset which closes port
+            // USB-JTAG/OTG devices: Use reset which may close port
             const wasReset = await this._resetToFirmwareIfNeeded();
-            return wasReset; // true = port closed, caller must reopen
+            if (wasReset) {
+                return true; // port closed, caller must reopen
+            }
+            // Port stayed open (e.g. C3/C5/C6/H2 classic reset)
+            await this._ensureStreamsReady();
+            return false;
         }
         else {
             // External serial chip devices: Release locks and do simple reset
             try {
                 await this.releaseReaderWriter();
-                await this.sleep(100);
+                await sleep(100);
             }
             catch (err) {
                 this.logger.debug(`Failed to release locks: ${err}`);
             }
-            // Hardware reset to firmware mode (IO0=HIGH)
             try {
-                await this.hardReset(false);
-                this.logger.log("Device reset to firmware mode");
+                await this.hardResetToFirmware();
+                this.logger.debug("Device reset to firmware mode");
             }
             catch (err) {
                 this.logger.debug(`Could not reset device: ${err}`);
             }
-            // For WebUSB (Android), recreate streams after hardware reset
-            if (this.isWebUSB()) {
-                try {
-                    // Use the public recreateStreams() method to safely recreate streams
-                    // without closing the port (important after hardware reset)
-                    await this.port.recreateStreams();
-                    this.logger.debug("WebUSB streams recreated for console mode");
-                }
-                catch (err) {
-                    // Set console mode flag
-                    this._consoleMode = false;
-                    this.logger.debug(`Failed to recreate WebUSB streams: ${err}`);
-                }
-            }
-            // Set console mode flag
-            this._consoleMode = true;
-            return false; // Port stays open
+            await this._ensureStreamsReady();
+            return false;
         }
     }
-    /**
-     * @name _resetToFirmwareIfNeeded
-     * Reset device from bootloader to firmware when switching to console mode
-     * Detects USB-JTAG/Serial and USB-OTG devices and performs appropriate reset
-     * @returns true if reconnect was performed, false otherwise
-     */
     /**
      * @name _clearForceDownloadBootIfNeeded
      * Read and clear the force download boot flag if it is set
@@ -2808,99 +2993,66 @@ export class ESPLoader extends EventTarget {
             return false;
         }
     }
+    /**
+     * @name _resetToFirmwareIfNeeded
+     * Reset device from bootloader to firmware when switching to console mode
+     * Detects USB-JTAG/Serial and USB-OTG devices and performs appropriate reset
+     * @returns true if reconnect was performed, false otherwise
+     */
     async _resetToFirmwareIfNeeded() {
+        // Detect if we need WDT reset (USB-JTAG/OTG) or classic reset
+        const isUsbJtagOrOtg = await this.detectUsbConnectionType();
         try {
             // Check if port is open - if not, assume device is already in firmware mode
             if (!this.port.writable || !this.port.readable) {
                 this.logger.debug("Port is not open - assuming device is already in firmware mode");
                 return false;
             }
-            const isUsingUsbOtg = await this.detectUsbConnectionType();
-            if (isUsingUsbOtg) {
-                // For USB-OTG devices, we need to check if force download flag is set
-                // Only if it's set, we need WDT reset (which causes port change)
-                // If it's clear, we can use normal reset (no port change)
-                if (this.IS_STUB) {
-                    this.logger.debug("On stub - need to get back to ROM to check flag");
-                    // If we're running at higher baudrate, we need to change back to ROM baudrate
-                    if (this.currentBaudRate !== ESP_ROM_BAUD) {
-                        this.logger.debug(`Changing baudrate from ${this.currentBaudRate} to ${ESP_ROM_BAUD} for ROM`);
-                        try {
-                            await this.reconfigurePort(ESP_ROM_BAUD);
-                            this.currentBaudRate = ESP_ROM_BAUD;
-                        }
-                        catch (err) {
-                            this.logger.debug(`Baudrate change failed: ${err}`);
-                            // Continue anyway
-                        }
-                    }
-                    this.logger.debug("Resetting to bootloader (ROM)...");
-                    // Reset to bootloader - this will clear the stub from RAM
-                    try {
-                        await this.hardReset(true);
-                        // Wait for reset to complete
-                        await sleep(200);
-                        // Sync with ROM
-                        await this.sync();
-                        this.logger.debug("Now on ROM after reset");
-                        // Mark that we're no longer on stub
-                        this.IS_STUB = false;
-                    }
-                    catch (resetErr) {
-                        this.logger.debug(`Reset to ROM failed: ${resetErr}`);
-                        // If reset fails, we might already be in firmware mode
-                        // In this case, we don't need to do anything - just use normal reset
-                        this.logger.debug("Assuming device is already in firmware mode");
-                        // Release reader/writer before returning
-                        await this.releaseReaderWriter();
-                        return false; // No port change needed
-                    }
-                }
-                else {
-                    this.logger.debug("Already on ROM - checking force download flag");
-                }
-                // Now check if force download flag is set and clear it if needed
-                const flagWasCleared = await this._clearForceDownloadBootIfNeeded();
-                if (flagWasCleared) {
-                    this.logger.debug("Force download flag was cleared - device will boot to firmware after reset");
-                }
-                else {
-                    this.logger.debug("Force download flag already clear - device will boot to firmware after reset");
-                }
-                // Perform WDT reset BEFORE releasing reader/writer (needs communication)
-                // After WDT reset, the device will reboot into firmware mode
-                await this.hardReset(false);
-                // For USB-OTG devices (ESP32-S2, ESP32-P4), the port will change after WDT reset
-                const portWillChange = (this.chipFamily === CHIP_FAMILY_ESP32S2 && isUsingUsbOtg) ||
-                    (this.chipFamily === CHIP_FAMILY_ESP32P4 && isUsingUsbOtg);
-                if (portWillChange) {
-                    // Port will change - release reader/writer and let the port become invalid
-                    await this.releaseReaderWriter();
-                    this.logger.log(`${this.chipName} USB-OTG: Port will change after WDT reset`);
-                    this.logger.log("Please select the new port for console mode");
-                    // Dispatch event to signal port change
-                    this.dispatchEvent(new CustomEvent("usb-otg-port-change", {
-                        detail: {
-                            chipName: this.chipName,
-                            message: `${this.chipName} USB port changed after reset. Please select the new port.`,
-                            reason: "wdt-reset-to-firmware",
-                        },
-                    }));
-                    // Return true to indicate port selection is needed
-                    return true;
-                }
-                else {
-                    // Port stays the same - release reader/writer so console can use the stream
+            if (isUsbJtagOrOtg) {
+                // USB-JTAG/OTG: DON'T release reader/writer before WDT reset
+                // The WDT reset needs active communication to send register write commands
+                // The port will close automatically after the WDT reset anyway
+                this.logger.debug("USB-JTAG/OTG: Keeping reader/writer active for WDT reset");
+            }
+            else {
+                // External serial chip: Release reader/writer before classic reset
+                await this.releaseReaderWriter();
+                this.logger.debug("External serial: Reader/writer released before reset");
+            }
+            // Use the new resetToFirmwareMode method which handles all the logic
+            const portWillChange = await this.resetToFirmwareMode(true);
+            if (portWillChange) {
+                this.logger.debug(`${this.chipName}: Port will change after WDT reset - user must reselect port`);
+                // Dispatch event to signal port change
+                this.dispatchEvent(new CustomEvent("usb-otg-port-change", {
+                    detail: {
+                        chipName: this.chipName,
+                        message: `${this.chipName} USB port changed after reset. Please select the new port.`,
+                        reason: "wdt-reset-to-firmware",
+                    },
+                }));
+                return true;
+            }
+            else {
+                // Port stays the same - release reader/writer now if not already done
+                if (isUsbJtagOrOtg) {
                     await this.releaseReaderWriter();
-                    return false;
+                    this.logger.debug("Reader/writer released after reset");
                 }
+                return false;
             }
         }
         catch (err) {
-            this.logger.debug(`Could not reset device to firmware mode: ${err}`);
-            // Continue anyway - console mode might still work
+            this.logger.error(`Reset to firmware mode failed: ${err}`);
+            // For USB-JTAG/OTG, the port is likely dead after a failed reset
+            // For external serial, the port is usually still fine
+            if (isUsbJtagOrOtg) {
+                this.logger.debug("Forcing port reselection due to USB-JTAG/OTG reset failure");
+                return true;
+            }
+            this.logger.debug("External serial reset failed, but port should still be usable");
+            return false;
         }
-        return false;
     }
     /**
      * @name reconnectAndResume
@@ -3114,7 +3266,7 @@ export class ESPLoader extends EventTarget {
             await this.connectWithResetStrategies();
             // Detect chip type
             await this.detectChip();
-            this.logger.log(`Reconnected to bootloader: ${this.chipName}`);
+            this.logger.debug(`Reconnected to bootloader: ${this.chipName}`);
         }
         catch (err) {
             // Ensure flag is reset on error
@@ -3151,7 +3303,7 @@ export class ESPLoader extends EventTarget {
         }
         if (isUsbOtgChip && isUsbJtagOrOtg) {
             // USB-OTG devices: Need to reset to bootloader, which will cause port change
-            this.logger.log(`${this.chipName} USB: Resetting to bootloader mode`);
+            this.logger.debug(`${this.chipName} USB: Resetting to bootloader mode`);
             // Perform hardware reset to bootloader (GPIO0=LOW)
             // This will cause the port to change from CDC (firmware) to JTAG (bootloader)
             try {
@@ -3163,7 +3315,7 @@ export class ESPLoader extends EventTarget {
             }
             // Wait for reset to complete and port to change
             await sleep(500);
-            this.logger.log(`${this.chipName}: Port changed. Please select the bootloader port.`);
+            this.logger.debug(`${this.chipName}: Port changed. Please select the bootloader port.`);
             // Dispatch event to signal port change
             this.dispatchEvent(new CustomEvent("usb-otg-port-change", {
                 detail: {
@@ -3208,8 +3360,10 @@ export class ESPLoader extends EventTarget {
             return await this._parent.resetInConsoleMode();
         }
         if (!this.isConsoleResetSupported()) {
-            this.logger.debug("Console reset not supported for ESP32-S2 USB-JTAG/CDC");
-            return; // Do nothing
+            this.logger.debug("Simple Console reset not supported for ESP32-S2 USB-JTAG/CDC - using exitConsoleMode to enter bootloader");
+            await this.exitConsoleMode();
+            this.logger.debug("S2 now in bootloader mode - caller must do syncAndWdtReset on new port, then reconnect console");
+            return;
         }
         // For other devices: Use standard firmware reset
         try {
@@ -3222,6 +3376,41 @@ export class ESPLoader extends EventTarget {
             throw err;
         }
     }
+    /**
+     * @name syncAndWdtReset
+     * Open a new bootloader port, sync with ROM (no stub, no reset strategies), and fire WDT reset.
+     * This is used for ESP32-S2 USB-OTG devices which require WDT reset to switch modes.
+     * After WDT reset the port will re-enumerate again.
+     * The user must select the new port after this method is called.
+     * @param newPort - The bootloader port selected by the user
+     */
+    async syncAndWdtReset(newPort) {
+        if (this._parent) {
+            await this._parent.syncAndWdtReset(newPort);
+            return;
+        }
+        this.port = newPort;
+        this.connected = false;
+        this.IS_STUB = false;
+        this.__inputBuffer = [];
+        this.__inputBufferReadIndex = 0;
+        this.__totalBytesRead = 0;
+        this.logger.debug("Opening bootloader port at 115200...");
+        await this.port.open({ baudRate: ESP_ROM_BAUD });
+        this.connected = true;
+        this.currentBaudRate = ESP_ROM_BAUD;
+        // Start read loop
+        this.readLoop();
+        await sleep(100);
+        // Sync with ROM only - no reset strategies, device is already in bootloader
+        this.logger.debug("Syncing with bootloader ROM...");
+        await this.sync();
+        this.logger.debug("Bootloader sync OK, no stub");
+        // Fire WDT reset → device boots into firmware
+        this.logger.debug("Firing WDT reset...");
+        await this.rtcWdtResetChipSpecific();
+        this.logger.debug("WDT reset fired - device will boot to firmware");
+    }
     /**
      * @name drainInputBuffer
      * Actively drain the input buffer by reading data for a specified time.
@@ -3395,7 +3584,7 @@ export class ESPLoader extends EventTarget {
                         }
                         catch (err) {
                             if (err instanceof SlipReadError) {
-                                this.logger.debug(`SLIP read error at ${resp.length} bytes: ${err.message}`);
+                                this.logger.debug(`${err.message} at byte 0x${resp.length.toString(16)}`);
                                 // Send empty SLIP frame to abort the stub's read operation
                                 // The stub expects 4 bytes (ACK), if we send less it will break out
                                 try {
@@ -3505,18 +3694,8 @@ export class ESPLoader extends EventTarget {
                     // Check if it's a timeout error or SLIP error
                     if (err instanceof SlipReadError) {
                         if (retryCount <= MAX_RETRIES) {
-                            this.logger.debug(`${err.message} at 0x${currentAddr.toString(16)}. Draining buffer and retrying (attempt ${retryCount}/${MAX_RETRIES})...`);
-                            try {
-                                await this.drainInputBuffer(200);
-                                // Clear application buffer
-                                await this.flushSerialBuffers();
-                                // Wait before retry to let hardware settle
-                                await sleep(SYNC_TIMEOUT);
-                                // Continue to retry the same chunk (will send NEW read command)
-                            }
-                            catch (drainErr) {
-                                this.logger.debug(`Buffer drain error: ${drainErr}`);
-                            }
+                            this.logger.debug(`Cleared buffer and retrying (attempt ${retryCount}/${MAX_RETRIES})...`);
+                            // Continue to retry the same chunk (will send NEW read command)
                         }
                         else {
                             // All retries exhausted - attempt recovery by reloading stub