esp32tool 1.3.7 → 1.3.8

package/dist/esp_loader.js

@@ -1,5 +1,5 @@
 /// <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, 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, 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, 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, } 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, 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, 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 { FLASH_MANUFACTURERS, FLASH_DEVICES } from "./flash_jedec";
@@ -358,7 +358,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());
@@ -672,9 +678,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
     // ============================================================================
@@ -698,77 +701,82 @@ export class ESPLoader extends EventTarget {
             requestToSend: rts,
         });
     }
+    async runSignalSequence(steps) {
+        const webusb = this.port.isWebUSB === true;
+        for (const step of steps) {
+            if (step.dtr !== undefined && step.rts !== undefined) {
+                if (webusb) {
+                    await this.setDTRandRTSWebUSB(step.dtr, step.rts);
+                }
+                else {
+                    await this.setDTRandRTS(step.dtr, step.rts);
+                }
+            }
+            else {
+                if (step.dtr !== undefined) {
+                    webusb
+                        ? await this.setDTRWebUSB(step.dtr)
+                        : await this.setDTR(step.dtr);
+                }
+                if (step.rts !== undefined) {
+                    webusb
+                        ? await this.setRTSWebUSB(step.rts)
+                        : await this.setRTS(step.rts);
+                }
+            }
+            if (step.delayMs)
+                await sleep(step.delayMs);
+        }
+    }
     /**
      * @name hardResetUSBJTAGSerial
      * USB-JTAG/Serial reset for Web Serial (Desktop)
      */
     async hardResetUSBJTAGSerial() {
-        await this.setRTS(false);
-        await this.setDTR(false); // Idle
-        await this.sleep(100);
-        await this.setDTR(true); // Set IO0
-        await this.setRTS(false);
-        await this.sleep(100);
-        await this.setRTS(true); // Reset
-        await this.setDTR(false);
-        await this.setRTS(true);
-        await this.sleep(100);
-        await this.setDTR(false);
-        await this.setRTS(false); // Chip out of reset
-        await this.sleep(200);
+        await this.runSignalSequence([
+            { rts: false },
+            { dtr: false, delayMs: 100 },
+            { dtr: true, rts: false, delayMs: 100 },
+            { rts: true },
+            { dtr: false, rts: true, delayMs: 100 },
+            { dtr: false, rts: false, delayMs: 200 },
+        ]);
     }
     /**
      * @name hardResetClassic
      * Classic reset for Web Serial (Desktop) DTR = IO0, RTS = EN
      */
     async hardResetClassic() {
-        await this.setDTR(false); // IO0=HIGH
-        await this.setRTS(true); // EN=LOW, chip in reset
-        await this.sleep(100);
-        await this.setDTR(true); // IO0=LOW
-        await this.setRTS(false); // EN=HIGH, chip out of reset
-        await this.sleep(50);
-        await this.setDTR(false); // IO0=HIGH, done
-        await this.sleep(200);
+        await this.runSignalSequence([
+            { dtr: false, rts: true, delayMs: 100 },
+            { dtr: true, rts: false, delayMs: 50 },
+            { dtr: false, delayMs: 200 },
+        ]);
     }
     /**
      * Reset to firmware mode (not bootloader) for Web Serial
      * Keeps IO0=HIGH during reset so chip boots into firmware
      */
     async hardResetToFirmware() {
-        await this.setDTR(false); // IO0=HIGH
-        await this.setRTS(true); // EN=LOW, chip in reset
-        await this.sleep(100);
-        await this.setRTS(false); // EN=HIGH, chip out of reset (IO0 stays HIGH)
-        await this.sleep(50);
-        await this.sleep(200);
-    }
-    /**
-     * Reset to firmware mode (not bootloader) for WebUSB
-     * Keeps IO0=HIGH during reset so chip boots into firmware
-     */
-    async hardResetToFirmwareWebUSB() {
-        await this.setDTRWebUSB(false); // IO0=HIGH
-        await this.setRTSWebUSB(true); // EN=LOW, chip in reset
-        await this.sleep(100);
-        await this.setRTSWebUSB(false); // EN=HIGH, chip out of reset (IO0 stays HIGH)
-        await this.sleep(50);
-        await this.sleep(200);
+        await this.runSignalSequence([
+            { dtr: false, rts: true, delayMs: 100 },
+            { rts: false, delayMs: 50 },
+            { delayMs: 200 },
+        ]);
     }
     /**
      * @name hardResetUnixTight
      * Unix Tight reset for Web Serial (Desktop) - sets DTR and RTS simultaneously
      */
     async hardResetUnixTight() {
-        await this.setDTRandRTS(true, true);
-        await this.setDTRandRTS(false, false);
-        await this.setDTRandRTS(false, true); // IO0=HIGH & EN=LOW, chip in reset
-        await this.sleep(100);
-        await this.setDTRandRTS(true, false); // IO0=LOW & EN=HIGH, chip out of reset
-        await this.sleep(50);
-        await this.setDTRandRTS(false, false); // IO0=HIGH, done
-        await this.setDTR(false); // Needed in some environments to ensure IO0=HIGH
-        await this.sleep(200);
+        await this.runSignalSequence([
+            { dtr: true, rts: true },
+            { dtr: false, rts: false },
+            { dtr: false, rts: true, delayMs: 100 },
+            { dtr: true, rts: false, delayMs: 50 },
+            { dtr: false, rts: false },
+            { dtr: false, delayMs: 200 },
+        ]);
     }
     // ============================================================================
     // WebUSB (Android) - DTR/RTS Signal Handling & Reset Strategies
@@ -798,72 +806,17 @@ export class ESPLoader extends EventTarget {
             requestToSend: rts,
         });
     }
-    /**
-     * @name hardResetUSBJTAGSerialWebUSB
-     * USB-JTAG/Serial reset for WebUSB (Android)
-     */
-    async hardResetUSBJTAGSerialWebUSB() {
-        await this.setRTSWebUSB(false);
-        await this.setDTRWebUSB(false); // Idle
-        await this.sleep(100);
-        await this.setDTRWebUSB(true); // Set IO0
-        await this.setRTSWebUSB(false);
-        await this.sleep(100);
-        await this.setRTSWebUSB(true); // Reset
-        await this.setDTRWebUSB(false);
-        await this.setRTSWebUSB(true);
-        await this.sleep(100);
-        await this.setDTRWebUSB(false);
-        await this.setRTSWebUSB(false); // Chip out of reset
-        await this.sleep(200);
-    }
     /**
      * @name hardResetUSBJTAGSerialInvertedDTRWebUSB
      * USB-JTAG/Serial reset with inverted DTR for WebUSB (Android)
      */
     async hardResetUSBJTAGSerialInvertedDTRWebUSB() {
-        await this.setRTSWebUSB(false);
-        await this.setDTRWebUSB(true); // Idle (DTR inverted)
-        await this.sleep(100);
-        await this.setDTRWebUSB(false); // Set IO0 (DTR inverted)
-        await this.setRTSWebUSB(false);
-        await this.sleep(100);
-        await this.setRTSWebUSB(true); // Reset
-        await this.setDTRWebUSB(true); // (DTR inverted)
-        await this.setRTSWebUSB(true);
-        await this.sleep(100);
-        await this.setDTRWebUSB(true); // (DTR inverted)
-        await this.setRTSWebUSB(false); // Chip out of reset
-        await this.sleep(200);
-    }
-    /**
-     * @name hardResetClassicWebUSB
-     * Classic reset for WebUSB (Android)
-     */
-    async hardResetClassicWebUSB() {
-        await this.setDTRWebUSB(false); // IO0=HIGH
-        await this.setRTSWebUSB(true); // EN=LOW, chip in reset
-        await this.sleep(100);
-        await this.setDTRWebUSB(true); // IO0=LOW
-        await this.setRTSWebUSB(false); // EN=HIGH, chip out of reset
-        await this.sleep(50);
-        await this.setDTRWebUSB(false); // IO0=HIGH, done
-        await this.sleep(200);
-    }
-    /**
-     * @name hardResetUnixTightWebUSB
-     * Unix Tight reset for WebUSB (Android) - sets DTR and RTS simultaneously
-     */
-    async hardResetUnixTightWebUSB() {
-        await this.setDTRandRTSWebUSB(false, false);
-        await this.setDTRandRTSWebUSB(true, true);
-        await this.setDTRandRTSWebUSB(false, true); // IO0=HIGH & EN=LOW, chip in reset
-        await this.sleep(100);
-        await this.setDTRandRTSWebUSB(true, false); // IO0=LOW & EN=HIGH, chip out of reset
-        await this.sleep(50);
-        await this.setDTRandRTSWebUSB(false, false); // IO0=HIGH, done
-        await this.setDTRWebUSB(false); // Ensure IO0=HIGH
-        await this.sleep(200);
+        await this.runSignalSequence([
+            { rts: false, dtr: true, delayMs: 100 },
+            { dtr: false, rts: false, delayMs: 100 },
+            { rts: true, dtr: true, delayMs: 100 },
+            { dtr: true, rts: false, delayMs: 200 },
+        ]);
     }
     /**
      * @name hardResetClassicLongDelayWebUSB
@@ -871,14 +824,11 @@ export class ESPLoader extends EventTarget {
      * Specifically for CP2102/CH340 which may need more time
      */
     async hardResetClassicLongDelayWebUSB() {
-        await this.setDTRWebUSB(false); // IO0=HIGH
-        await this.setRTSWebUSB(true); // EN=LOW, chip in reset
-        await this.sleep(500); // Extra long delay
-        await this.setDTRWebUSB(true); // IO0=LOW
-        await this.setRTSWebUSB(false); // EN=HIGH, chip out of reset
-        await this.sleep(200);
-        await this.setDTRWebUSB(false); // IO0=HIGH, done
-        await this.sleep(500); // Extra long delay
+        await this.runSignalSequence([
+            { dtr: false, rts: true, delayMs: 500 },
+            { dtr: true, rts: false, delayMs: 200 },
+            { dtr: false, delayMs: 500 },
+        ]);
     }
     /**
      * @name hardResetClassicShortDelayWebUSB
@@ -887,12 +837,12 @@ export class ESPLoader extends EventTarget {
     async hardResetClassicShortDelayWebUSB() {
         await this.setDTRWebUSB(false); // IO0=HIGH
         await this.setRTSWebUSB(true); // EN=LOW, chip in reset
-        await this.sleep(50);
+        await sleep(50);
         await this.setDTRWebUSB(true); // IO0=LOW
         await this.setRTSWebUSB(false); // EN=HIGH, chip out of reset
-        await this.sleep(25);
+        await sleep(25);
         await this.setDTRWebUSB(false); // IO0=HIGH, done
-        await this.sleep(100);
+        await sleep(100);
     }
     /**
      * @name hardResetInvertedWebUSB
@@ -901,12 +851,12 @@ export class ESPLoader extends EventTarget {
     async hardResetInvertedWebUSB() {
         await this.setDTRWebUSB(true); // IO0=HIGH (inverted)
         await this.setRTSWebUSB(false); // EN=LOW, chip in reset (inverted)
-        await this.sleep(100);
+        await sleep(100);
         await this.setDTRWebUSB(false); // IO0=LOW (inverted)
         await this.setRTSWebUSB(true); // EN=HIGH, chip out of reset (inverted)
-        await this.sleep(50);
+        await sleep(50);
         await this.setDTRWebUSB(true); // IO0=HIGH, done (inverted)
-        await this.sleep(200);
+        await sleep(200);
     }
     /**
      * @name hardResetInvertedDTRWebUSB
@@ -915,12 +865,12 @@ export class ESPLoader extends EventTarget {
     async hardResetInvertedDTRWebUSB() {
         await this.setDTRWebUSB(true); // IO0=HIGH (DTR inverted)
         await this.setRTSWebUSB(true); // EN=LOW, chip in reset (RTS normal)
-        await this.sleep(100);
+        await sleep(100);
         await this.setDTRWebUSB(false); // IO0=LOW (DTR inverted)
         await this.setRTSWebUSB(false); // EN=HIGH, chip out of reset (RTS normal)
-        await this.sleep(50);
+        await sleep(50);
         await this.setDTRWebUSB(true); // IO0=HIGH, done (DTR inverted)
-        await this.sleep(200);
+        await sleep(200);
     }
     /**
      * @name hardResetInvertedRTSWebUSB
@@ -929,12 +879,12 @@ export class ESPLoader extends EventTarget {
     async hardResetInvertedRTSWebUSB() {
         await this.setDTRWebUSB(false); // IO0=HIGH (DTR normal)
         await this.setRTSWebUSB(false); // EN=LOW, chip in reset (RTS inverted)
-        await this.sleep(100);
+        await sleep(100);
         await this.setDTRWebUSB(true); // IO0=LOW (DTR normal)
         await this.setRTSWebUSB(true); // EN=HIGH, chip out of reset (RTS inverted)
-        await this.sleep(50);
+        await sleep(50);
         await this.setDTRWebUSB(false); // IO0=HIGH, done (DTR normal)
-        await this.sleep(200);
+        await sleep(200);
     }
     /**
      * Check if we're using WebUSB (Android) or Web Serial (Desktop)
@@ -978,7 +928,7 @@ export class ESPLoader extends EventTarget {
                     resetStrategies.push({
                         name: "USB-JTAG/Serial (WebUSB) - ESP32-S2",
                         fn: async () => {
-                            return await self.hardResetUSBJTAGSerialWebUSB();
+                            return await self.hardResetUSBJTAGSerial();
                         },
                     });
                     // Strategy 2: USB-JTAG/Serial Inverted DTR (works in JTAG mode)
@@ -992,14 +942,14 @@ export class ESPLoader extends EventTarget {
                     resetStrategies.push({
                         name: "UnixTight (WebUSB) - ESP32-S2 CDC",
                         fn: async () => {
-                            return await self.hardResetUnixTightWebUSB();
+                            return await self.hardResetUnixTight();
                         },
                     });
                     // Strategy 4: Classic reset (CDC fallback)
                     resetStrategies.push({
                         name: "Classic (WebUSB) - ESP32-S2 CDC",
                         fn: async () => {
-                            return await self.hardResetClassicWebUSB();
+                            return await self.hardResetClassic();
                         },
                     });
                 }
@@ -1014,7 +964,7 @@ export class ESPLoader extends EventTarget {
                     resetStrategies.push({
                         name: "USB-JTAG/Serial (WebUSB)",
                         fn: async () => {
-                            return await self.hardResetUSBJTAGSerialWebUSB();
+                            return await self.hardResetUSBJTAGSerial();
                         },
                     });
                     resetStrategies.push({
@@ -1032,13 +982,13 @@ export class ESPLoader extends EventTarget {
                     resetStrategies.push({
                         name: "UnixTight (WebUSB) - CH34x",
                         fn: async () => {
-                            return await self.hardResetUnixTightWebUSB();
+                            return await self.hardResetUnixTight();
                         },
                     });
                     resetStrategies.push({
                         name: "Classic (WebUSB) - CH34x",
                         fn: async () => {
-                            return await self.hardResetClassicWebUSB();
+                            return await self.hardResetClassic();
                         },
                     });
                     resetStrategies.push({
@@ -1066,13 +1016,13 @@ export class ESPLoader extends EventTarget {
                     resetStrategies.push({
                         name: "UnixTight (WebUSB) - CP2102",
                         fn: async () => {
-                            return await self.hardResetUnixTightWebUSB();
+                            return await self.hardResetUnixTight();
                         },
                     });
                     resetStrategies.push({
                         name: "Classic (WebUSB) - CP2102",
                         fn: async () => {
-                            return await self.hardResetClassicWebUSB();
+                            return await self.hardResetClassic();
                         },
                     });
                     resetStrategies.push({
@@ -1099,13 +1049,13 @@ export class ESPLoader extends EventTarget {
                     resetStrategies.push({
                         name: "UnixTight (WebUSB)",
                         fn: async () => {
-                            return await self.hardResetUnixTightWebUSB();
+                            return await self.hardResetUnixTight();
                         },
                     });
                     resetStrategies.push({
                         name: "Classic (WebUSB)",
                         fn: async function () {
-                            return await self.hardResetClassicWebUSB();
+                            return await self.hardResetClassic();
                         },
                     });
                     resetStrategies.push({
@@ -1135,7 +1085,7 @@ export class ESPLoader extends EventTarget {
                     resetStrategies.push({
                         name: "Classic (WebUSB)",
                         fn: async function () {
-                            return await self.hardResetClassicWebUSB();
+                            return await self.hardResetClassic();
                         },
                     });
                 }
@@ -1143,7 +1093,7 @@ export class ESPLoader extends EventTarget {
                 resetStrategies.push({
                     name: "UnixTight (WebUSB)",
                     fn: async function () {
-                        return await self.hardResetUnixTightWebUSB();
+                        return await self.hardResetUnixTight();
                     },
                 });
                 // WebUSB Strategy: Classic with long delays
@@ -1165,7 +1115,7 @@ export class ESPLoader extends EventTarget {
                     resetStrategies.push({
                         name: "USB-JTAG/Serial fallback (WebUSB)",
                         fn: async function () {
-                            return await self.hardResetUSBJTAGSerialWebUSB();
+                            return await self.hardResetUSBJTAGSerial();
                         },
                     });
                 }
@@ -1334,32 +1284,114 @@ 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;
-        }
-        else {
-            // Use classic reset for non-USB devices
-            if (this.isWebUSB()) {
-                await this.hardResetClassicWebUSB();
-                this.logger.debug("Classic reset (WebUSB/Android).");
+    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 };
+                }
+                // Check if chip supports WDT reset
+                // 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 {
-                await this.hardResetClassic();
-                this.logger.debug("Classic reset.");
+                // 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;
             }
         }
-        return false;
+        catch (err) {
+            this.logger.error(`Failed to reset to firmware mode: ${err}`);
+            throw err;
+        }
     }
     async hardReset(bootloader = false) {
         // In console mode, only allow simple hardware reset (no bootloader entry)
@@ -1370,78 +1402,75 @@ export class ESPLoader extends EventTarget {
             }
             // Simple hardware reset to restart firmware (IO0=HIGH)
             this.logger.debug("Performing hardware reset (console mode)...");
-            if (this.isWebUSB()) {
-                await this.hardResetToFirmwareWebUSB();
-            }
-            else {
-                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 {
-                // Use different reset strategy for WebUSB (Android) vs Web Serial (Desktop)
-                if (this.isWebUSB()) {
-                    await this.hardResetClassicWebUSB();
-                    this.logger.debug("Classic reset (WebUSB/Android).");
-                }
-                else {
-                    await this.hardResetClassic();
-                    this.logger.debug("Classic reset.");
-                }
+                await this.hardResetClassic();
+                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)
-                    return;
-            }
-            else if (this.chipFamily === CHIP_FAMILY_ESP32C6) {
-                const wdtResetUsed = await this.tryUsbWdtReset("ESP32-C6");
-                if (wdtResetUsed)
-                    return;
-            }
-            // Standard reset for all other cases
-            if (this.isWebUSB()) {
-                // WebUSB: Use longer delays for better compatibility
-                await this.setRTSWebUSB(true); // EN->LOW
-                await this.sleep(200);
-                await this.setRTSWebUSB(false);
-                await this.sleep(200);
-                this.logger.debug("Hard reset (WebUSB).");
+            // 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: Use WDT reset
+                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 {
-                // Web Serial: Standard reset
-                await this.setRTS(true); // EN->LOW
-                await this.sleep(100);
-                await this.setRTS(false);
-                this.logger.debug("Hard reset.");
+                // External serial chip: Use classic reset
+                this.logger.debug("External serial chip detected - using classic reset");
+                if (this.isWebUSB()) {
+                    // WebUSB: Use longer delays for better compatibility
+                    await this.setRTSWebUSB(true); // EN->LOW
+                    await sleep(200);
+                    await this.setRTSWebUSB(false);
+                    await sleep(200);
+                    this.logger.debug("Hard reset to firmware (WebUSB).");
+                }
+                else {
+                    // Web Serial: Standard reset
+                    await this.setRTS(true); // EN->LOW
+                    await sleep(100);
+                    await this.setRTS(false);
+                    this.logger.debug("Hard reset to firmware.");
+                }
             }
         }
         await new Promise((resolve) => setTimeout(resolve, 1000));
@@ -2655,29 +2684,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
         }
     }
     /**
@@ -2716,6 +2741,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
@@ -2743,60 +2903,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
@@ -2851,98 +2992,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.debug(`${this.chipName} USB-OTG: Port will change after WDT reset`);
-                    // 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
@@ -3197,12 +3306,7 @@ export class ESPLoader extends EventTarget {
             // Perform hardware reset to bootloader (GPIO0=LOW)
             // This will cause the port to change from CDC (firmware) to JTAG (bootloader)
             try {
-                if (this.isWebUSB()) {
-                    await this.hardResetClassicWebUSB();
-                }
-                else {
-                    await this.hardResetClassic();
-                }
+                await this.hardResetClassic();
                 this.logger.debug("Reset to bootloader initiated");
             }
             catch (err) {
@@ -3255,19 +3359,15 @@ 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
-        const isWebUSB = this.port.isWebUSB === true;
         try {
             this.logger.debug("Resetting device in console mode");
-            if (isWebUSB) {
-                await this.hardResetToFirmwareWebUSB();
-            }
-            else {
-                await this.hardResetToFirmware();
-            }
+            await this.hardResetToFirmware();
             this.logger.debug("Device reset complete");
         }
         catch (err) {
@@ -3275,6 +3375,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.